7 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Распознавание жестов движений на Android используя Tensorflow

Содержание

Android quickstart

To get started with TensorFlow Lite on Android, we recommend exploring the following example.

Read TensorFlow Lite Android image classification for an explanation of the source code.

This example app uses image classification to continuously classify whatever it sees from the device’s rear-facing camera. The application can run either on device or emulator.

Inference is performed using the TensorFlow Lite Java API and the TensorFlow Lite Android Support Library. The demo app classifies frames in real-time, displaying the top most probable classifications. It allows the user to choose between a floating point or quantized model, select the thread count, and decide whether to run on CPU, GPU, or via NNAPI.

Build in Android Studio

To build the example in Android Studio, follow the instructions in README.md.

Create your own Android app

To get started quickly writing your own Android code, we recommend using our Android image classification example as a starting point.

The following sections contain some useful information for working with TensorFlow Lite on Android.

Use the TensorFlow Lite Android Support Library

The TensorFlow Lite Android Support Library makes it easier to integrate models into your application. It provides high-level APIs that help transform raw input data into the form required by the model, and interpret the model’s output, reducing the amount of boilerplate code required.

It supports common data formats for inputs and outputs, including images and arrays. It also provides pre- and post-processing units that perform tasks such as image resizing and cropping.

Use the TensorFlow Lite AAR from JCenter

To use TensorFlow Lite in your Android app, we recommend using the TensorFlow Lite AAR hosted at JCenter.

You can specify this in your build.gradle dependencies as follows:

This AAR includes binaries for all of the Android ABIs. You can reduce the size of your application’s binary by only including the ABIs you need to support.

We recommend most developers omit the x86 , x86_64 , and arm32 ABIs. This can be achieved with the following Gradle configuration, which specifically includes only armeabi-v7a and arm64-v8a , which should cover most modern Android devices.

To learn more about abiFilters , see NdkOptions in the Android Gradle documentation.

Build TensorFlow Lite locally

In some cases, you might wish to use a local build of TensorFlow Lite. For example, you may be building a custom binary that includes operations selected from TensorFlow, or you may wish to make local changes to TensorFlow Lite.

Install Bazel and Android Prerequisites

Bazel is the primary build system for TensorFlow. To build with it, you must have it and the Android NDK and SDK installed on your system.

  1. Install the latest version of the Bazel build system.
  2. The Android NDK is required to build the native (C/C++) TensorFlow Lite code. The current recommended version is 17c, which may be found here.
  3. The Android SDK and build tools may be obtained here, or alternatively as part of Android Studio. Build tools API >= 23 is the recommended version for building TensorFlow Lite.

Configure WORKSPACE and .bazelrc

Run the ./configure script in the root TensorFlow checkout directory, and answer «Yes» when the script asks to interactively configure the ./WORKSPACE for Android builds. The script will attempt to configure settings using the following environment variables:

  • ANDROID_SDK_HOME
  • ANDROID_SDK_API_LEVEL
  • ANDROID_NDK_HOME
  • ANDROID_NDK_API_LEVEL

If these variables aren’t set, they must be provided interactively in the script prompt. Successful configuration should yield entries similar to the following in the .tf_configure.bazelrc file in the root folder:

Build and Install

Once Bazel is properly configured, you can build the TensorFlow Lite AAR from the root checkout directory as follows:

This will generate an AAR file in bazel-bin/tensorflow/lite/java/ . Note that this builds a «fat» AAR with several different architectures; if you don’t need all of them, use the subset appropriate for your deployment environment. From there, there are several approaches you can take to use the .aar in your Android Studio project.

Add AAR directly to project

Move the tensorflow-lite.aar file into a directory called libs in your project. Modify your app’s build.gradle file to reference the new directory and replace the existing TensorFlow Lite dependency with the new local library, e.g.:

Install AAR to local Maven repository

Execute the following command from your root checkout directory:

In your app’s build.gradle , ensure you have the mavenLocal() dependency and replace the standard TensorFlow Lite dependency with the one that has support for select TensorFlow ops:

Note that the 0.1.100 version here is purely for the sake of testing/development. With the local AAR installed, you can use the standard TensorFlow Lite Java inference APIs in your app code.

Build C++ libraries

If you want to use TFLite through C++ libraries, you can build the shared libraries:

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.

Использование TensorFlow на Android: шаг за шагом

Сегодня почти все слышали о машинном или глубоком обучении. Но знаете ли вы, что это такое конкретно и как это использовать? Я, например, не знал. На самом деле я начал интересоваться этой темой только пару месяцев назад, и это оказалось очень интересным.

Я хотел создать приложение, которое использует машинное обучение. Для этой цели подходит TensorFlow, библиотека Google с открытым исходным кодом. С её помощью мы можем создать нейронную сеть, обучить её, сохранить и использовать в своем приложении.

Если вам интересно, как работает нейронная сеть, я предлагаю вам прочитать эту статью. Это хорошее начало, но для работы с TensorFlow нам не нужно знать все. Android-разработчику пригодится минимальное знание, которое даст понимание использования библиотеки в приложении.

В этой статье мы будем использовать в качестве примера приложение Hot or Not, в котором разберем все аспекты кода и пошагово объясним, что происходит.

Hot or Not?

Само приложение довольно простое. Мы делаем фото, оно классифицируется как “горячее” или “нет”, а результаты появляются на экране.

Делаем фото

Начнем с фото. Код выглядит таким образом:

Мы просто делаем фотографию, а классифицировать фото будет onActivityresult().

Классификация фото

Следующий шаг — создать интерфейс классификатора, который будет использовать TensorFlow.

Как вы можете видеть, нам нужен только один метод с параметром Bitmap, который является нашим фото. Этот метод возвращает Result.

Класс Result имеет два свойства — строка с результатом (hot или not) и уверенность в результате. Мы будем использовать уверенность после классификации.

Время создать классификатор внутри MainActivity.

Мы немного изменили код MainActivity. Давайте посмотрим на метод createClassifier(). Для его создания мы будем использовать ImageClassifierFactory. Но сначала взглянем на параметры.

Параметр assets находится в AssetManager, остальные параметры — в классе Constants.

Что это за параметры?

  • GRAPH_FILE_PATH — путь к классификатору в папке ассетов. Мы будем использовать слова “классификатор” и “граф”, так как наш классификатор является сохраненным графом нейронной сети. Его можно также назвать моделью.

  • LABELS_FILE_PATH — путь к нашим ярлыкам в папке. Проще говоря, лейблы — это наши возможные результаты. Наш классификатор обучен оценивать фото, поэтому у нас есть всего два ярлыка — hot и not.

  • GRAPH_INPUT_NAME — название входных данных от классификатора. Мы отправляем сюда изображение.
  • GRAPH_OUTPUT_NAME — название выходных данных классификатора.
  • IMAGE_SIZE — размер изображения в пикселях. Наш классификатор может понимать изображения размером 224×224 пикселя.
Читать еще:  Google Cast окончательно встроили в Chrome

Для лучшего понимания работы классификатора посмотрим на изображение ниже.

Нам нужно считать классификатор чем-то вроде черного ящика. Мы берем фото размером 224×224 и загружаем его. Затем происходит классификация, после которой мы получаем ярлыки со степенью уверенности. Например, для hot эта степень составляет 0,7, а для not — 0,3, поэтому мы можем считать это вероятностью.

Теперь надо использовать классификатор в Activity, а потом перейдем к его реализации. Отправляем фото в метод classifyPhoto().

Здесь мы обрезаем изображение до нужного размера. После этой операции мы вызываем метод recognizeImage() и получаем результаты.

Чтобы обрезать изображение, мы используем ImageUtils.getCroppedBitmap(). Я взял алгоритм из класса ImageUtils из урока по TensorFlow и конвертировал этот класс в Kotlin. Перейдем к методу Factory.

На основе параметров из Activity он создает экземпляр классификатора, но самому классификатору нужна более конкретная информация. Вот некоторые параметры:

  • labels — список строк. Мы используем класс FileUtils, чтобы получить ярлыки и текстового файла.
  • imageBitmapPixels — массив, который заполняется на основе размера изображения. Мы заполним его во время классификации.
  • imageNormalizedPixels — массив на основе размера изображения и количества цветовых каналов. Наш классификатор использует нормированные значения, поэтому нам нужно конвертировать целые числа в float.
  • results — массив на основе количества ярлыков. Классификатор возвращает вероятность каждого ярлыка.
  • tensorFlowInference — API из библиотеки TensorFlow. Для загрузки графа требуется менеджер ассетов и путь к файлу графа.

Наши параметры созданы, и теперь мы можем заглянуть внутрь ImageClassifier.

Все происходящее мы можем видеть внутри метода recognizeImage(). В preprocessImageToNormalizedFloats() находится алгоритм нормализации пикселей, и его я тоже взял с Github из TensorFlowImageClassifier.

Теперь мы можем классифицировать изображение. Этот процесс состоит из трех фаз.

  • Загрузите классификатор с помощью метода feed(). К этому методу мы должны передать три параметра — название входных данных, массив с нормализованными значениями и размеры входных данных. В нашем случае размеры составляют: 1 (потому что мы помещаем одно изображение) * размер изображения * размер изображения * количество цветных каналов.
  • Запустите классификатор при помощи метода run(). Этому методу нужны два параметра: массив с возможными результатами (в нашем случае один — final_result) и flag для включения статистики.
  • Получите результаты из классификатора при помощи метода fetch(). Параметры здесь — это название выходных данных и массив, в котором будут содержаться результаты. Это FloatArray, так как классификатор возвращает вероятности для каждого из двух ярлыков.

Последний шаг — указать путь к объекту Result. Для этого используем PriorityQueue, который мы заполним результатами и покажем только один с наибольшим показателем вероятности.

Результат

Ничего особенного — просто текст и цветной фон, которые зависят от результата. Весь код вы можете найти на Github.

TensorFlow для мобильных устройств на Android и iOS

TensorFlow обычно используется для тренировки масштабных моделей на большом наборе данных, но нельзя игнорировать развивающийся рынок смартфонов и необходимость создавать будущее, основанное на глубоком обучении.

Перед вами перевод статьи TensorFlow on Mobile: Tutorial, автор — Sagar Sharma. Ссылка на оригинал — в подвале статьи.

Те, кто не может долго ждать, раздвигают границы, создавая инструменты, нацеленные на рынок с многотриллионным оборотом. Вы являетесь частью этого рынка, потому что, возможно, прямо сейчас читаете эту статью на своем Android или iOS устройстве либо оно лежит у вас в кармане, в любом случае, вы знаете, насколько машинное обучение на мобильных устройствах ориентировано на будущее.

Больше туториалов по Tensorflow:

Я опубликую два туториала о том, как запустить модели машинного обучения на вашем Android или iOS устройстве. В этом туториале используется более стабильная версия TensorFlow — TensorFlow Mobile, так что следуйте инструкциям по реализации своей модели и оптимизации ее для мобильных устройств.

Мы собираемся создать классификатор изображений путем тренировки финального слоя (Bottleneck) модели Inception-v3 и затем оптимизировать модель для смартфонов.

Туториал содержит всего 6 шагов.

Шаг 1: Создаем модель с помощью TensorFlow

Я уверен, что вы уже знакомы с этим шагом, поскольку вы учитесь запускать ту же модель на смартфонах.

Кроме того, чтобы этот туториал был строго ориентирован на внедрение модели на смартфоны, изучите этот быстрый урок Распознавание изображений с TensorFlow и Python API на CPU. Таким образом, мы будем на одной странице, и вы можете начать работу в новой директории с помощью обученной модели.

FYI: данные, на которых обучается модель, содержат виды цветов — тюльпаны, ромашка, подсолнух, одуванчик и розы.

После вы должны иметь эти два файла:

  1. tf_files/retrained_graph.pb, который содержит версию выбранной сети с натренированным на ваших категориях последним слоем и
  2. tf_files/retrained_labels.txt, который является текстовым файлом, содержащим ярлыки.

Шаг 2: Создание оптимизированной модели

Выполните следующую команду (соблюдайте путь):

Это создаст новый оптимизированный файл модели tf_files/optimized_graph.pb

Примечание. Если вы получаете сообщение об ошибке KeyError: «Следующие входные узлы не были найдены: <‘input’>n, то замените «input» на «Mul».

Компромиссы

Чтобы одновременно уменьшить предварительную обработку приложения и уменьшить размер библиотеки, tensorflow поддерживает только подмножество операций, которые обычно используются во время вывода. Операции, которые не поддерживаются, tensorflow/contrib/makefile/tf_op_files.txt

Проверка

Убедитесь, что ваш новый оптимизированный граф запущен, и файл optimize_for_inference, который удаляет все узлы, которые не нужны для заданного набора входных и выходных сигналов, не изменил выход сети.

Сравните вывод одного и того же изображения с помощью файла label_file на графах retrained_graph.pb и optimized_graph.pb:

Выполняйте эти команды одну за другой, и если оба выхода идентичны, то optimized_graph.pb создан верно.

Шаг 3: Квантуем модель, затем сжимаем

Проблема заключается в том, что размер модели по-прежнему большой и определенно не подходит для мобильных телефонов. Большая часть пространства, занимаемого графом, это веса — большие блоки чисел с плавающей запятой. Каждый вес имеет разное значение с плавающей запятой, с очень небольшой регулярностью.

Но сжатие работает за счет использования регулярности данных.

Квантование помогает уменьшить размер нейронной сети, выполняя квантование по весам. Это дает гораздо больше повторений в графе и сильно помогает в дальнейшем сжатии модели.

Используйте скрипт quantize_graph, чтобы применить изменения к графу:

Теперь сжимайте модель:

Это создаст файл rounded_graph.pb

Вы должны увидеть значительное улучшение сжатия.

Примечание. Если вы видите ошибку при запуске файла quantize_graph, загрузите этот файл и вставьте его в tools/quantization/quantize_graph.py в библиотеку Tensorflow (туда где установлен Tensorflow).

Далее туториал делится на два раздела — Android и iOS.

iOS — Шаг 4: Добавляем блок TensorFlow-experimental

Добавьте TensorFlow-experimental в ваш pod файл, который устанавливает универсальную бинарную структуру. Это самый простой способ запустить shadoworflow на iOS.

iOS — Шаг 5: Создайте приложение

  • Создайте собственное приложение или загрузите уже созданное приложение в XCode.
  • Добавьте файл под названием Podfile в корневую директорию проекта со следующим содержимым:
  • Запустите pod install для загрузки и установки TensorFlow-экспериментального модуля.
  • Откройте файл YourProjectName.xcworks и добавьте свой код.
  • В настройках сборки приложения обязательно добавьте $(inherited) к «Other linker flags» и «Header Search Paths».

iOS — Шаг 6: Запускаем сэмплы

Для запуска iOS сэмплов вам понадобится Xcode 7.3 или новее.

Имеется по три примера в simple, бенчмарке (benchmark) и камере (camera). Можете скопировать код.

Загрузите Inception v1 из корня Tensorflow и извлеките ярлык и файлы графов в папки данных внутрь примеров camera и simple, используя следующие шаги:

Перейдите в одну из директорий сэмпла, загрузите экспериментальный модуль Tensorflow-experimental и откройте рабочее пространство Xcode. Обратите внимание, что установка модуля может занять много времени, так как он большой (

450 МБ). Если вы хотите запустить простой пример, то:

Запустите простое приложение в симуляторе XCode. Вы должны увидеть одноэкранное приложение с кнопкой Run Model. Нажмите на него, и вы должны увидеть изображение Grace Hopper. После того, как вы построите и запустите его, вы должны получить изображение с камеры в реальном времени, которую вы можете наводить на объекты, чтобы получить результаты распознавания в реальном времени.

Примечание: я уверен, что мог допустить какую-то ошибку или что-то недосказать в разделе iOS. Пожалуйста, перейдите по следующим официальным ссылкам и оставьте комментарий, если вы обнаружите какую-либо ошибку, сообщество поможет вам.

Android — Шаг 4. Настройка Android Studio и тестовый запуск

Есть два способа осуществить задачу — это Android Studio и Bazel. Я буду использовать AS, так как с ней знакомы больше людей.

Тестовый прогон

Чтобы проверить, все ли работает правильно в Android Studio, давайте проведем тестовый запуск.

Откройте Android Studio и выберите «Открыть существующий проект Android Studio».

  • Перейдите в директорию tensorflow-for-poets-2/android/tfmobile.
  • Откройте файл Build.gradle и синхронизируйте Gradle. Если все работает отлично, нажмите кнопку BUILD>BUILD APK.

Теперь папка должна идти с файлом app.apk, скопируйте его в телефон и установите. Кроме того, не забудьте включить режим разработчика в вашем телефоне.

Android — Шаг 5: Запустите настроенное приложение

Если до этого момента все работает нормально, то дальше все уже пойдет как по маслу. По умолчанию стоит приложение для классификации изображений с 1000 категориями из Imagenet. Теперь, чтобы запустить наше настроенное приложение, выполните следующие два шага:

  • Добавьте файлы вашей модели в проект.

Прямо сейчас демонстрационное приложение просматривает файл graph.pb и файл label.txt, присутствующий в android/tfmobile/assets, а не ваши файлы roundnded_graph.pb и retrained_labels.txt.

  • Теперь замените файлы следующей командой или вы можете сделать это вручную.
Читать еще:  Старинное приспособление для пряжи

Измените «output_name» в файле ClassifierActivity.java

Выходной узел для нашей модели имеет другое имя: «final_result». Откройте ClassifierActivity.java и обновите переменную OUTPUT_NAME следующим образом:

Запустите снова, теперь все должно работать.

Я постарался сделать статью максимально точной и легкой для понимания. Любые комментарии, предложения или вопросы пишите в комментариях

Android обработка жестов: как добавить жесты в свое приложение и распознать их

Современные телефоны предоставляют программистам поистине удивительные возможность. Судите сами, сегодня дисплей для смартфона — не только средство отображения информации, но и мощный интерфейс для взаимодействия с пользователем. Современные дисплеи могут фиксировать множество прикосновений, распознавать жесты и даже определять силу нажатия (3D Touch). Тем удивительнее, что все это богатство довольно редко используется программистами при разработке новых игр и мобильных приложений. Эта статья поможет исправить это досадное недоразумение. Сегодня речь пойдет о распознавании жестов.

В Android для поддержки жестов используется специальный вид: «GestureOverlayView». Жесты как таковые представляют собой двоичные ресурсы. Их можно создать с помощью Android SDK. В свою activity жесты можно загрузить с помощью метода GestureLib.fromRawResource(). Если система распознает жест, вызывается метод onGesturePerformedListener(). Соответственно у activity должен быть объявлена поддержка интерфейса GestureOverlayView, кроме того, Activity должна зарегистрировать себя в GestureOverlayView с помощью метода addOnGesturePerformedListener().

Распознанные жестов в Android отображаются желтым цветом — а нераспознанные — бледно-желтым. Эту подсветку можно отключить через методы setGestureColor(Color.TRANSPARENT) и setUncertainGestureColor(Color.TRANSPARENT) для GestureOverlayView.

Создать новые жесты можно через Android эмулятор, запустив на нем программу GestureBuilder. Вы можете создать несколько жестов с одинаковыми именами. Это поможет более точно распознавать их. При создании эмулятора добавьте поддержку sdcard, в противном случае вы просто не сможете сохранить жесты. Все жесты сохраняются в файл gestures на эмуляторе. Скачать этот файл с эмулятора можно с помощью adb, выполнив команду:

После ее выполнения файл с жестами будет сохранен в папку «res/raw» и их можно будет использовать в GestureOverlayView.

Если Вам не хочется возиться с эмулятором, можете установить на свой телефон программу «Gesture Builder» из Google Play. У нее очень простой интерфейс. В режиме Add вы водите пальцем по дисплею смартфона, рисуя нужный жест. После этого вы вводите его название, и жест сохраняется на карточку. При сохранении жеста отображается путь до файла gesture.txt. После добавления всех необходимых жестов этот файл нужно скопировать в свой проект.

Давайте разработаем небольшое тестовое приложение, реализующее распознавание жестов. Создайте новый проект. Главную Activity назовите «GestureTest». Создадим layout main.xml.

Код главной activity приведен ниже. Обратите внимание, мы добавляем GestureOverlayView программно в методе onCreate. Там же мы привязали GesturePerformedListener для обработки жестов. Как видите, в onGesturePerformed мы создаем список predictions, содержащий наши жесты и параметр scope, который отражает степень соответствия введенного жеста жнсту библиотеки. В цикле for мы проходимся по этому списку, и если оказывается, что scope больше единицы, считаем жест распознанным, и через Toast печатаем сообщение на экране.

Можете запустить приложение и поводить пальцем по дисплею своего смартфона, поиграться с различными жестами.

Распознавание жестов движений на Android используя Tensorflow

Мы уже поработали в предыдущем уроке с акселерометром смартфона и сделали программу, способную распознавать движение аппарата в пространстве. В этом уроке мы поработаем над возможностями сенсорного экрана, научимся работать с жестами по дисплею, то есть, как научить наше приложения работать с прикосновениями пальцев пользователя, при чем эти прикосновения не будут направлены на какой нибудь элемент управления (кнопка, переключатель и т.д.).

Начинаем с создания проекта. Названия оставим по умолчанию, но, конечно, можете написать что то свое.

Сразу начнем с работы в основном layout файле activity_main.xml. Добавим туда следующие элементы:

Важным моментом здесь является определение элемента FrameLayout. Именно в нем будет происходить основная работа приложения.

Теперь перейдем к файлу MainActivity.java и немного изменим метод onCreate:

Мы объявили здесь класс под названием PlayAreaView и Android Studio на него ругается, но не пугайтесь, мы это исправим.

А сейчас мы выполним довольно интересную часть нашей работы — создадим холст для рисования жестов. Легкий способ это сделать заключается в том, чтобы создать объект для рисования Canvas (холст) с помощью метода onDraw. Это довольно просто и удобно, так как этот метод имеет всего один параметр: объект Canvas. Рисование в Canvas происходит с помощью вызова метода drawBitmap. Создаем в приложении новый класс по имени PlayAreaView.java и добавляем туда следующий код:

В нашем случае выполнение метода onDraw довольно простое. Как это обычно делается, определите еще и переменную DEBUG_TAG. Основная работа в этой части кода происходит при вызове команды drawBitmap, где первым параметром является изображение для рисования, второй параметр задает матричный объект под названием translate, который, как подсказывает его имя, будет показывать, где именно на экране будет происходить рисование. Этот матричный объект будет связывать все действия пользователя, все его прикосновения к экрану, с холстом.

Классу PlayAreaView нужно создать конструктор, выполняющий его самые базовые, начальные настройки. Так, как приложения будет реагировать на жесты, нам необходимо задать GestureDetector (определитель жестов). GestureDetector это класс, способный опознавать события типа жестов (прикасания пользователя к дисплею), проделывать над полученной от датчиков информацией о жестах математические операции, а потом, с помощью объекта GestureListener, создавать определенную обратную реакцию. О бъект GestureListener обрабатывает входящую в него информацию и выдает ответ, который мы можем видеть и реагировать не него (в нашем случае это будет перемещение изображения по экрану). В GestureDetector существует множество возможностей, но мы ограничимся только самыми необходимыми. Добавим этот метод в код файла PlayAreaView.java:

Взглянем на код немного пристальнее. Сначала мы инициализируем необходимый объект матрицы, который будет помогать нам в рисовании, и оно будет происходить в местах, определенных по умолчанию. Далее мы создаем объект GestureDetector и задаем GestureListener. Ну и напоследок, загружаем стандартную картинку, с которой будем работать в приложении. Вы можете использовать там любое изображение по собственному желанию. Это будет изображение, которое мы с помощью жестов будем заставлять перемещаться по рабочему холсту.

Теперь давайте создадим объект GestureDector, который будет принимать данные о жестах и обрабатывать их. Для этого в том же классе PlayAreaView.java добавим следующее:

В процессе работы с определением жестов с помощью GestureDector также нужно реализовать класс GestureListener. Основные жесты, в которых мы заинтересованы, это двойное нажатие по экрану и направленные движения (влево, вправо и т.д.). Для реализации определения этих движений, класс GestureListener должен выполнять интерфейсы OnGestureListener и OnDoubleTapListener:

После добавления этого класса, как подкласса Activity, добавьте все необходимые для них методы, которых жаждет Android Studio. Например, вот один из них:

Выполнение всех этих методов позволит вам изучить самые различные события, которые улавливает объект GestureDetector. Объект MotionEvent связан с самыми разными событиями, которые могут происходить при нажатии пользователем на экран.

Стоит отметить, что существует еще такой удобный метод, как SimpleOnGestureListener, который объединяет в себе функционал сразу двух интерфейсов: OnGestureListener и OnDoubleTapListener. В нем по умолчанию возвращается значение false.

Первое движение, с которым мы хотим работать в нашем приложении, это прокрутка. Оно происходит тогда, когда пользователь прикасается к экрану и, не отрывая пальца, ведет им в какую либо сторону. Это движение мы можем определить в интерфейсе OnGestureListener с помощью метода onScroll:

Выполнение этого метода является важным в связи с событием, когда пользователь ведет по экрану пальцем и вместе с этим начинает двигаться изображение на дисплее.

Изображение будет двигаться вдоль всего экрана, а иногда даже выходить за его границы. По определению, изображение будет видимым только тогда, когда его координаты находятся в рамках объекта для рисования (а его рамки у нас совпадают с размерами рабочего окна приложения), если же затащить изображение за эти границы, то оно будет не видимым. Также мы реализуем метод, который по двойному клику будет возвращать на экран заблудшее за рамками экрана изображение:

В принципе, в этом методе мы просто сбрасываем положение картинки на ее положение по умолчанию.

Следующее движение, которое мы будем определять и использовать, можно назвать инерцией. То есть, мы резким движением как бы толкаем картинку в определенную сторону, убираем палец, а она летит по инерции в указанном направлении, постепенно замедляя скорость до полной остановки. Скорость затухания этого движения задается программистом. Например, почти в каждой игре, где есть движение, есть своя физика процесса в которую входит и эта настройка в том числе. Самая лучшая настройка этого параметра может появиться только благодаря экспериментам и качественному подбору, либо же наугад что мы и сделаем.

В нашем случае, мы будем изменять время разности между событием, спровоцировавшим движение, и остановкой инерциального движения, а потом просто запускать анимацию движения картинки к нужному месту с нужной скоростью. Для этого будет использоваться метод onFling. Задание кажется довольно сложным, но я не дам вам шанса над ним подумать и покажу готовый код:) :

Нам даже не нужно выполнять никаких дополнительных проверок параметров, данные о скорости полностью решают нашу задачу. Скорость будет определяться в пискелях за секунду. Мы также можем использовать данные скорости для решения вопроса о том, где остановить движущийся объект, которым у нас является картинка. В нашем случае, мы используем в своих подсчетах 40% от секунды (то есть 400 мс). Данные о скорости будут передаваться в метод onAnimateMove, где и будет задаваться скорость движения изображения. Почему используется именно 400 мс? Потому, что это значение параметра наиболее качественно подходит к большинству устройств. Используя такое значение, мы будем видеть нормальное, относительно плавное движение, а не скачки или некрасивые замедления. Стоит отметить, что эти настройки скорости и анимации не имеют ничего общего с реальной физикой, просто в данном примере так удобно.

Читать еще:  Режимы чтения для браузера Google Chrome

Теперь все жесты, которые нам были интересны, учтены. В методе PlayAreaView.java добавим такой метод:

Он делает две вещи. Во первых, метод переводит (здесь «переводит» означает движение от точки A в B) изображение на расстояние в соответствии с движением пальца, во вторых, аннулирует предыдущее положение изображения. Каждый раз, когда происходит движение, мы будем просто обновлять нашу матрицу, заданную ранее.

Теперь добавим onResetLocation метод:

Этот метод будет просто сбрасывать все настройки на настройки по умолчанию.

При движении картинки в заданном пальцем пользователя направлении нужно настроить анимацию так, чтобы она была плавной, проходила гладко, так сказать. В Android есть встроенные классы для анимации (вспоминаем предыдущие уроки по анимации, вот, вот и вот) но в нашем случае их сложно применить. Создадим для приложения свою собственную анимацию. В Android существуют множество интерполяторов, с помощью которых можно задать различную анимацию. Вот их мы и применим для создания анимации. Давайте создадим метод под названием onAnimateMove :

Здесь мы задали начальное положение, начальное и конечное время. Мы инициализируем анимацию, используя класс OvershootInterpolator, и настраиваем ее основные характеристики. Напоследок для завершения работы над анимацией нужно вызвать еще один метод под названием onAnimateStep:

Вот, в принципе, и все основные шаги, которые нужно выполнить для создания программы, способной распознавать жесты пользователя и реагировать на них. Конечно, руководство далеко от идеала, но здесь можно почерпнуть много интересного и познавательного материала, что поможет немного разобраться в использовании подобных инструментов. Удачи в обучении!

Распознаем эмоции с Tensorflow

Tensorflow позволяет сделать распознавание эмоций.

Nimish Ronge сделал неплохой пример распознавания с использованием OpenCV и Tensorflow — https://github.com/nimish1512/Emotion-recognition-and-prediction

Несмотря на то, что в требованиях есть использование Python 3.x, программа нормально работает с Python 2.7

Кроме того, nimish1512 также отдает обученную нейросеть, которую можно скачать по следующим ссылкам:

Итак, работает под Ubuntu 14.04, Tensorflow 1.1., OpenCV 3.0.0:

Cначала ставим OpenCV по следующей инструкции:

Step 1:

Open up a terminal and update the apt-get package manager followed by upgrading any pre-installed packages:

Step 2:

Now we need to install our developer tools:

The pkg-config is likely already installed, but be sure to include it just in case. We’ll be using git to pull down the OpenCV repositories from GitHub. The cmake package is used to configure our build.

Step 3:

OpenCV needs to be able to load various image file formats from disk, including JPEG, PNG, TIFF, etc. In order to load these image formats from disk, we’ll need our image I/O packages:

Step 4:

At this point, we have the ability to load a given image off of disk. But how do we display the actual image to our screen? The answer is the GTK development library, which the highgui module of OpenCV depends on to guild Graphical User Interfaces (GUIs):

Step 5:

We can load images using OpenCV, but what about processing video streams and accessing individual frames? We’ve got that covered here:

Step 6:

Install libraries that are used to optimize various routines inside of OpenCV:

Step 7:

Install pip , a Python package manager:

Step 8:

Install virtualenv and virtualenvwrapper. These two packages allow us to create separate Python environments for each project we are working on. While installing virtualenv and virtualenvwrapper is not a requirement to get OpenCV 3.0 and Python 2.7+ up and running on your Ubuntu system, I highly recommend it and the rest of this tutorial will assume you have them installed!

Now that we have virtualenv and virtualenvwrapper installed, we need to update our

This quick update will ensure that both virtualenv and virtualenvwrapper are loaded each time you login.

To make the changes to our

/.bashrc file take effect, you can either (1) logout and log back in, (2) close your current terminal window and open a new one, or preferably, (3) reload the contents of your

Lastly, we can create our cv virtual environment where we’ll be doing our computer vision development and OpenCV 3.0 + Python 2.7+ installation:

Step 9:

As I mentioned above, this tutorial covers how to install OpenCV 3.0 and Python 2.7+ (I’ll have a OpenCV 3.0 + Python 3 tutorial available later this month), so we’ll need to install our Python 2.7 development tools:

Since OpenCV represents images as multi-dimensional NumPy arrays, we better install NumPy into our cv virtual environment:

Step 10:

Our environment is now all setup — we can proceed to change to our home directory, pull down OpenCV from GitHub, and checkout the 3.0.0 version:

Update (3 January 2016): You can replace the 3.0.0 version with whatever the current release is (as of right now, it’s 3.1.0 ). Be sure to check OpenCV.org for information on the latest release.

As I mentioned last week, we also need the opencv_contrib repo as well. Without this repository, we won’t have access to standard keypoint detectors and local invariant descriptors (such as SIFT, SURF, etc.) that were available in the OpenCV 2.4.X version. We’ll also be missing out on some of the newer OpenCV 3.0 features like text detection in natural images:

Again, make sure that you checkout the same version for opencv_contrib that you did for opencv above, otherwise you could run into compilation errors.

Time to setup the build:

Update (3 January 2016): In order to build OpenCV 3.1.0 , you need to set -D INSTALL_C_EXAMPLES=OFF (rather than ON ) in the cmake command. There is a bug in the OpenCV v3.1.0 CMake build script that can cause errors if you leave this switch on. Once you set this switch to off, CMake should run without a problem.

Notice how compared to last week our CMake command is substantially less verbose and requires less manual tweaking — this is because CMake is able to better automatically tune our install parameters (at least compared to OSX).

Now we can finally compile OpenCV:

Where you can replace the 4 with the number of available cores on your processor to speedup the compilation.

Here’s an example of OpenCV 3.0 compiling on my system:

Assuming that OpenCV compiled without error, you can now install it on your Ubuntu system:

Step 11:

If you’ve reached this step without an error, OpenCV should now be installed in /usr/local/lib/python2.7/site-packages

However, our cv virtual environment is located in our home directory — thus to use OpenCV within our cv environment, we first need to sym-link OpenCV into the site-packages directory of the cv virtual environment:

Step 12:

Congratulations! You have successfully installed OpenCV 3.0 with Python 2.7+ bindings on your Ubuntu system!

To confirm your installation, simply ensure that you are in the cv virtual environment, followed by importing cv2 :

Here’s an example of demonstrating the OpenCV 3.0 and Python 2.7+ install on my own Ubuntu machine:

Step 13:

Now that OpenCV has been configured and installed, let’s build a quick Python script to detect the red game cartridge in the image named games.jpg below:

Open up your favorite editor, create a new file, name it find_game.py , and insert the following code:

You’ll also need to download the games.jpg image and place it in the same directory as your find_game.py file. Once the games.jpg file has been downloaded, you can execute the script via:

Assuming that you have downloaded the games.jpg image and placed it in the same directory as our find_game.py script, you should see the following output:

Notice how our script was able to successfully detect the red game cartridge in the right portion of the image, followed by drawing a green bounding box surrounding it.

Obviously this isn’t the most exciting example in the world — but it has demonstrated that we have OpenCV 3.0 with Python 2.7+ bindings up and running on our Ubuntu system!

Затем устанавливаем Tensorflow также в виртуальное окружение cv.

Устанавливаем tflean – $pip install tflearn

Клонируем творение nimish1512

git clone https://github.com/nimish1512/Emotion-recognition-and-prediction.git

Для простоты переименовываем директорию, куда клонировали программу в emotion.

В эту же директорию сохраняем обученную нейросеть, которую скачали в самом начале. Получится так:

Запускаем виртуальное окружение. В моем случае $ source

Запускаем $python em_model.py

Результат налицо

Программа на Python (автор NoBugs)

Тренинг собственнойц нейросети может занять очень много времени ( недели) -= зависит от вашего компа.

Добавить комментарий Отменить ответ

Для отправки комментария вы должны авторизоваться.

Ссылка на основную публикацию
Статьи c упоминанием слов:
Adblock
detector