├── .idea
    └── vcs.xml
├── AndroidManifest.xml
├── BUILD
├── README.md
├── build.gradle
├── download-models.gradle
├── gradle.properties
├── gradlew
├── gradlew.bat
├── libs
    └── libandroid_tensorflow_inference_java.jar
├── local.properties
├── res
    ├── drawable-hdpi
    │   ├── ic_action_info.png
    │   ├── ic_launcher.png
    │   └── tile.9.png
    ├── drawable-mdpi
    │   ├── ic_action_info.png
    │   └── ic_launcher.png
    ├── drawable-xhdpi
    │   ├── ic_action_info.png
    │   └── ic_launcher.png
    ├── drawable-xxhdpi
    │   ├── ic_action_info.png
    │   └── ic_launcher.png
    ├── layout
    │   ├── activity_camera.xml
    │   ├── activity_photo_stylize.xml
    │   ├── camera_connection_fragment.xml
    │   ├── camera_connection_fragment_stylize.xml
    │   └── camera_connection_fragment_tracking.xml
    ├── values-sw600dp
    │   ├── template-dimens.xml
    │   └── template-styles.xml
    ├── values-v11
    │   ├── styles.xml
    │   └── template-styles.xml
    ├── values-v14
    │   └── styles.xml
    ├── values-v21
    │   ├── base-colors.xml
    │   └── base-template-styles.xml
    ├── values-w820dp
    │   └── dimens.xml
    └── values
    │   ├── attrs.xml
    │   ├── base-strings.xml
    │   ├── colors.xml
    │   ├── dimens.xml
    │   ├── strings.xml
    │   ├── styles.xml
    │   ├── template-dimens.xml
    │   └── template-styles.xml
├── sample_images
    ├── classify1.jpg
    ├── detect1.jpg
    ├── photo1.png
    └── stylize1.jpg
└── src
    └── org
        └── tensorflow
            └── demo
                ├── AutoFitTextureView.java
                ├── CameraActivity.java
                ├── CameraConnectionFragment.java
                ├── Classifier.java
                ├── ClassifierActivity.java
                ├── DetectorActivity.java
                ├── OverlayView.java
                ├── PhotoStylizeActivity.java
                ├── RecognitionScoreView.java
                ├── ResultsView.java
                ├── StylizeActivity.java
                ├── TensorFlowImageClassifier.java
                ├── TensorFlowMultiBoxDetector.java
                ├── TensorFlowYoloDetector.java
                ├── env
                    ├── BorderedText.java
                    ├── ImageUtils.java
                    ├── Logger.java
                    ├── Size.java
                    └── SplitTimer.java
                ├── tracking
                    ├── MultiBoxTracker.java
                    └── ObjectTracker.java
                └── util
                    ├── BitmapUtil.java
                    ├── FileUtil.java
                    └── MediaScanner.java


/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="VcsDirectoryMappings">
4 |     <mapping directory="" vcs="Git" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/AndroidManifest.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?><!--
 2 |  Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 3 | 
 4 |  Licensed under the Apache License, Version 2.0 (the "License");
 5 |  you may not use this file except in compliance with the License.
 6 |  You may obtain a copy of the License at
 7 | 
 8 |      http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 |  Unless required by applicable law or agreed to in writing, software
11 |  distributed under the License is distributed on an "AS IS" BASIS,
12 |  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  See the License for the specific language governing permissions and
14 |  limitations under the License.
15 | -->
16 | <manifest xmlns:android="http://schemas.android.com/apk/res/android"
17 |     package="org.tensorflow.demo">
18 | 
19 |     <uses-sdk
20 |         android:minSdkVersion="21"
21 |         android:targetSdkVersion="23" />
22 | 
23 |     <uses-permission android:name="android.permission.CAMERA" />
24 | 
25 |     <uses-feature android:name="android.hardware.camera" />
26 |     <uses-feature android:name="android.hardware.camera.autofocus" />
27 | 
28 |     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
29 | 
30 |     <uses-permission android:name="android.permission.READ_PHONE_STATE" />
31 |     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
32 | 
33 |     <application
34 |         android:allowBackup="true"
35 |         android:debuggable="true"
36 |         android:icon="@drawable/ic_launcher"
37 |         android:label="@string/app_name"
38 |         android:theme="@style/MaterialTheme">
39 |         <activity
40 |             android:name=".PhotoStylizeActivity"
41 |             android:label="@string/activity_name_photo_stylize"
42 |             android:screenOrientation="portrait">
43 |             <intent-filter>
44 |                 <action android:name="android.intent.action.MAIN" />
45 | 
46 |                 <category android:name="android.intent.category.LAUNCHER" />
47 |             </intent-filter>
48 |         </activity>
49 |         <activity
50 |             android:name=".ClassifierActivity"
51 |             android:label="@string/activity_name_classification"
52 |             android:screenOrientation="portrait">
53 |             <intent-filter>
54 |                 <action android:name="android.intent.action.MAIN" />
55 | 
56 |                 <category android:name="android.intent.category.LAUNCHER" />
57 |             </intent-filter>
58 |         </activity>
59 |         <activity
60 |             android:name=".DetectorActivity"
61 |             android:label="@string/activity_name_detection"
62 |             android:screenOrientation="portrait">
63 |             <intent-filter>
64 |                 <action android:name="android.intent.action.MAIN" />
65 | 
66 |                 <category android:name="android.intent.category.LAUNCHER" />
67 |             </intent-filter>
68 |         </activity>
69 |         <activity
70 |             android:name=".StylizeActivity"
71 |             android:label="@string/activity_name_stylize"
72 |             android:screenOrientation="portrait">
73 |             <intent-filter>
74 |                 <action android:name="android.intent.action.MAIN" />
75 | 
76 |                 <category android:name="android.intent.category.LAUNCHER" />
77 |             </intent-filter>
78 |         </activity>
79 |     </application>
80 | 
81 | </manifest>


--------------------------------------------------------------------------------
/BUILD:
--------------------------------------------------------------------------------
  1 | # Description:
  2 | #   TensorFlow camera demo app for Android.
  3 | 
  4 | package(default_visibility = ["//visibility:public"])
  5 | 
  6 | licenses(["notice"])  # Apache 2.0
  7 | 
  8 | load(
  9 |     "//tensorflow:tensorflow.bzl",
 10 |     "tf_copts",
 11 |     "tf_opts_nortti_if_android",
 12 | )
 13 | 
 14 | exports_files(["LICENSE"])
 15 | 
 16 | LINKER_SCRIPT = "//tensorflow/contrib/android:jni/version_script.lds"
 17 | 
 18 | # libtensorflow_demo.so contains the native code for image colorspace conversion
 19 | # and object tracking used by the demo. It does not require TF as a dependency
 20 | # to build if STANDALONE_DEMO_LIB is defined.
 21 | # TF support for the demo is provided separately by libtensorflow_inference.so.
 22 | cc_binary(
 23 |     name = "libtensorflow_demo.so",
 24 |     srcs = glob([
 25 |         "jni/**/*.cc",
 26 |         "jni/**/*.h",
 27 |     ]),
 28 |     copts = tf_copts(),
 29 |     defines = ["STANDALONE_DEMO_LIB"],
 30 |     linkopts = [
 31 |         "-landroid",
 32 |         "-ljnigraphics",
 33 |         "-llog",
 34 |         "-lm",
 35 |         "-z defs",
 36 |         "-s",
 37 |         "-Wl,--version-script",  # This line must be directly followed by LINKER_SCRIPT.
 38 |         LINKER_SCRIPT,
 39 |     ],
 40 |     linkshared = 1,
 41 |     linkstatic = 1,
 42 |     tags = [
 43 |         "manual",
 44 |         "notap",
 45 |     ],
 46 |     deps = [
 47 |         LINKER_SCRIPT,
 48 |     ],
 49 | )
 50 | 
 51 | cc_library(
 52 |     name = "tensorflow_native_libs",
 53 |     srcs = [
 54 |         ":libtensorflow_demo.so",
 55 |         "//tensorflow/contrib/android:libtensorflow_inference.so",
 56 |     ],
 57 |     tags = [
 58 |         "manual",
 59 |         "notap",
 60 |     ],
 61 | )
 62 | 
 63 | android_binary(
 64 |     name = "tensorflow_demo",
 65 |     srcs = glob([
 66 |         "src/**/*.java",
 67 |     ]),
 68 |     # Package assets from assets dir as well as all model targets. Remove undesired models
 69 |     # (and corresponding Activities in source) to reduce APK size.
 70 |     assets = [
 71 |         "//tensorflow/examples/android/assets:asset_files",
 72 |         ":external_assets",
 73 |     ],
 74 |     assets_dir = "",
 75 |     custom_package = "org.tensorflow.demo",
 76 |     inline_constants = 1,
 77 |     manifest = "AndroidManifest.xml",
 78 |     manifest_merger = "legacy",
 79 |     resource_files = glob(["res/**"]),
 80 |     tags = [
 81 |         "manual",
 82 |         "notap",
 83 |     ],
 84 |     deps = [
 85 |         ":tensorflow_native_libs",
 86 |         "//tensorflow/contrib/android:android_tensorflow_inference_java",
 87 |     ],
 88 | )
 89 | 
 90 | # LINT.IfChange
 91 | filegroup(
 92 |     name = "external_assets",
 93 |     srcs = [
 94 |         "@inception5h//:model_files",
 95 |         "@mobile_multibox//:model_files",
 96 |         "@stylize//:model_files",
 97 |     ],
 98 | )
 99 | # LINT.ThenChange(//tensorflow/examples/android/download-models.gradle)
100 | 
101 | filegroup(
102 |     name = "all_files",
103 |     srcs = glob(
104 |         ["**/*"],
105 |         exclude = [
106 |             "**/METADATA",
107 |             "**/OWNERS",
108 |             "bin/**",
109 |             "gen/**",
110 |             "gradleBuild/**",
111 |             "libs/**",
112 |         ],
113 |     ),
114 |     visibility = ["//tensorflow:__subpackages__"],
115 | )
116 | 
117 | filegroup(
118 |     name = "java_files",
119 |     srcs = glob(["src/**/*.java"]),
120 | )
121 | 
122 | filegroup(
123 |     name = "jni_files",
124 |     srcs = glob([
125 |         "jni/**/*.cc",
126 |         "jni/**/*.h",
127 |     ]),
128 | )
129 | 
130 | filegroup(
131 |     name = "resource_files",
132 |     srcs = glob(["res/**"]),
133 | )
134 | 
135 | exports_files(["AndroidManifest.xml"])
136 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | TensorFlow官方Android端示例中，风格迁移TF Stylize是对摄像头获取的画面动态渲染，
 3 | ###
 4 | 本人渣机运行起来非常卡，基本看不出效果，因此改为对图片进行风格迁移。
 5 | 
 6 | 截图 
 7 | -----------------------------------
 8 | ![image](https://github.com/SimonCherryGZ/TensorFlow_Android/raw/master/sample_images/photo1.png)
 9 | 
10 | 
11 | > Written with [StackEdit](https://stackedit.io/).
12 | 


--------------------------------------------------------------------------------
/build.gradle:
--------------------------------------------------------------------------------
  1 | // This file provides basic support for building the TensorFlow demo
  2 | // in Android Studio with Gradle.
  3 | //
  4 | // Note that Bazel is still used by default to compile the native libs,
  5 | // and should be installed at the location noted below. This build file
  6 | // automates the process of calling out to it and copying the compiled
  7 | // libraries back into the appropriate directory.
  8 | //
  9 | // Alternatively, experimental support for Makefile builds is provided by
 10 | // setting buildWithMake below to true. This will allow building the demo
 11 | // on Windows machines, but note that full equivalence with the Bazel
 12 | // build is not yet guaranteed. See comments below for caveats and tips
 13 | // for speeding up the build, such as as enabling ccache.
 14 | 
 15 | // Set to true to build with make.
 16 | // NOTE: Running a make build will cause subsequent Bazel builds to *fail*
 17 | // unless the contrib/makefile/downloads/ and gen/ dirs are deleted afterwards.
 18 | def buildWithMake = false
 19 | 
 20 | // Controls output directory in APK and CPU type for Bazel builds.
 21 | // NOTE: Does not affect the Makefile build target API (yet), which currently
 22 | // assumes armeabi-v7a. If building with make, changing this will require
 23 | // editing the Makefile as well.
 24 | def cpuType = 'armeabi-v7a'
 25 | 
 26 | // Output directory in the local directory for packaging into the APK.
 27 | def nativeOutDir = 'libs/' + cpuType
 28 | 
 29 | // Default to building with Bazel and override with make if requested.
 30 | def nativeBuildRule = 'buildNativeBazel'
 31 | def demoLibPath = '../../../bazel-bin/tensorflow/examples/android/libtensorflow_demo.so'
 32 | def inferenceLibPath = '../../../bazel-bin/tensorflow/contrib/android/libtensorflow_inference.so'
 33 | if (buildWithMake) {
 34 |     nativeBuildRule = 'buildNativeMake'
 35 |     demoLibPath = '../../../tensorflow/contrib/makefile/gen/lib/libtensorflow_demo.so'
 36 |     inferenceLibPath = '../../../tensorflow/contrib/makefile/gen/lib/libtensorflow_inference.so'
 37 | }
 38 | 
 39 | // Defines the NDK location for Makefile builds. Does *not* affect Bazel builds.
 40 | // Override with your absolute NDK location if this fails to get the location
 41 | // automatically.
 42 | def makeNdkRoot = System.getenv('NDK_ROOT')
 43 | 
 44 | // If building with Bazel, this is the location of the bazel binary.
 45 | // NOTE: Bazel does not yet support building for Android on Windows,
 46 | // so in this case the Makefile build must be used as described above.
 47 | def bazelLocation = '/usr/local/bin/bazel'
 48 | 
 49 | project.buildDir = 'gradleBuild'
 50 | getProject().setBuildDir('gradleBuild')
 51 | 
 52 | // import DownloadModels task
 53 | project.ext.ASSET_DIR = projectDir.toString() + '/assets'
 54 | project.ext.TMP_DIR = project.buildDir.toString() + '/downloads'
 55 | 
 56 | buildscript {
 57 |     repositories {
 58 |         jcenter()
 59 |     }
 60 | 
 61 |     dependencies {
 62 |         classpath 'com.android.tools.build:gradle:2.3.0'
 63 |     }
 64 | }
 65 | 
 66 | apply plugin: 'com.android.application'
 67 | 
 68 | android {
 69 |     compileSdkVersion 23
 70 |     buildToolsVersion "25.0.1"
 71 | 
 72 |     lintOptions {
 73 |         abortOnError false
 74 |     }
 75 | 
 76 |     sourceSets {
 77 |         main {
 78 |             // TensorFlow Java API sources.
 79 |             java {
 80 |                 srcDir '../../java/src/main/java'
 81 |                 exclude '**/examples/**'
 82 |             }
 83 | 
 84 |             // Android TensorFlow wrappers, etc.
 85 |             java {
 86 |                 srcDir '../../contrib/android/java'
 87 |             }
 88 | 
 89 |             // Android demo app sources.
 90 |             java {
 91 |                 srcDir 'src'
 92 |             }
 93 | 
 94 |             manifest.srcFile 'AndroidManifest.xml'
 95 |             resources.srcDirs = ['src']
 96 |             aidl.srcDirs = ['src']
 97 |             renderscript.srcDirs = ['src']
 98 |             res.srcDirs = ['res']
 99 |             assets.srcDirs = [project.ext.ASSET_DIR]
100 |             jniLibs.srcDirs = ['jniLibs']
101 |         }
102 | 
103 |         debug.setRoot('build-types/debug')
104 |         release.setRoot('build-types/release')
105 |     }
106 | }
107 | 
108 | //task buildNativeBazel(type: Exec) {
109 | //    workingDir '../../..'
110 | //    commandLine bazelLocation, 'build', '-c', 'opt',  \
111 | //         'tensorflow/examples/android:tensorflow_native_libs',  \
112 | //         '--crosstool_top=//external:android/crosstool',  \
113 | //         '--cpu=' + cpuType,  \
114 | //         '--host_crosstool_top=@bazel_tools//tools/cpp:toolchain'
115 | //}
116 | //
117 | //task buildNativeMake(type: Exec) {
118 | //    environment "NDK_ROOT", makeNdkRoot
119 | //    // Tip: install ccache and uncomment the following to speed up
120 | //    // builds significantly.
121 | //    // environment "CC_PREFIX", 'ccache'
122 | //    workingDir '../../..'
123 | //    commandLine 'tensorflow/contrib/makefile/build_all_android.sh',  \
124 | //         '-s',  \
125 | //         'tensorflow/contrib/makefile/sub_makefiles/android/Makefile.in',  \
126 | //         '-t',  \
127 | //         'libtensorflow_inference.so libtensorflow_demo.so'  \
128 | //         //, '-T'  // Uncomment to skip protobuf and speed up subsequent builds.
129 | //}
130 | //
131 | //
132 | //task copyNativeLibs(type: Copy) {
133 | //    from demoLibPath
134 | //    from inferenceLibPath
135 | //    into nativeOutDir
136 | //    duplicatesStrategy = 'include'
137 | //    dependsOn nativeBuildRule
138 | //    fileMode 0644
139 | //}
140 | //
141 | //assemble.dependsOn copyNativeLibs
142 | //afterEvaluate {
143 | //    assembleDebug.dependsOn copyNativeLibs
144 | //    assembleRelease.dependsOn copyNativeLibs
145 | //}
146 | 
147 | // Download default models; if you wish to use your own models then
148 | // place them in the "assets" directory and comment out this line.
149 | //apply from: "download-models.gradle"
150 | 
151 | dependencies {
152 |     compile fileTree(include: ['*.jar'], dir: 'libs')
153 |     compile 'com.android.support:appcompat-v7:23.4.0'
154 | }
155 | 


--------------------------------------------------------------------------------
/download-models.gradle:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * download-models.gradle
 3 |  *     Downloads model files from ${MODEL_URL} into application's asset folder
 4 |  * Input:
 5 |  *     project.ext.TMP_DIR: absolute path to hold downloaded zip files
 6 |  *     project.ext.ASSET_DIR: absolute path to save unzipped model files
 7 |  * Output:
 8 |  *     3 model files will be downloaded into given folder of ext.ASSET_DIR
 9 |  */
10 | // hard coded model files
11 | // LINT.IfChange
12 | def models = ['inception5h.zip',
13 |               'mobile_multibox_v1a.zip',
14 |               'stylize_v1.zip']
15 | // LINT.ThenChange(//tensorflow/examples/android/BUILD)
16 | 
17 | // Root URL for model archives
18 | def MODEL_URL = 'https://storage.googleapis.com/download.tensorflow.org/models'
19 | 
20 | buildscript {
21 |     repositories {
22 |         jcenter()
23 |     }
24 |     dependencies {
25 |         classpath 'de.undercouch:gradle-download-task:3.2.0'
26 |     }
27 | }
28 | 
29 | import de.undercouch.gradle.tasks.download.Download
30 | task downloadFile(type: Download){
31 |     for (f in models) {
32 |         src "${MODEL_URL}/" + f
33 |     }
34 |     dest new File(project.ext.TMP_DIR)
35 |     overwrite true
36 | }
37 | 
38 | task extractModels(type: Copy) {
39 |     for (f in models) {
40 |         from zipTree(project.ext.TMP_DIR + '/' + f)
41 |     }
42 | 
43 |     into file(project.ext.ASSET_DIR)
44 |     fileMode  0644
45 |     exclude '**/LICENSE'
46 | 
47 |     dependsOn downloadFile
48 | }
49 | 
50 | afterEvaluate {
51 |     // if models are not available, download & unzip them
52 |     def needDownload = false
53 |     for (f in models) {
54 |         if (!(new File(project.ext.TMP_DIR + '/' + f)).exists()) {
55 |             needDownload = true
56 |         }
57 |     }
58 | 
59 |     if (needDownload) {
60 |         assembleDebug.dependsOn extractModels
61 |         assembleRelease.dependsOn extractModels
62 |     }
63 | }
64 | 
65 | 


--------------------------------------------------------------------------------
/gradle.properties:
--------------------------------------------------------------------------------
 1 | ## Project-wide Gradle settings.
 2 | #
 3 | # For more details on how to configure your build environment visit
 4 | # http://www.gradle.org/docs/current/userguide/build_environment.html
 5 | #
 6 | # Specifies the JVM arguments used for the daemon process.
 7 | # The setting is particularly useful for tweaking memory settings.
 8 | # Default value: -Xmx1024m -XX:MaxPermSize=256m
 9 | # org.gradle.jvmargs=-Xmx2048m -XX:MaxPermSize=512m -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8
10 | #
11 | # When configured, Gradle will run in incubating parallel mode.
12 | # This option should only be used with decoupled projects. More details, visit
13 | # http://www.gradle.org/docs/current/userguide/multi_project_builds.html#sec:decoupled_projects
14 | # org.gradle.parallel=true
15 | #Sun Mar 26 13:48:36 GMT+08:00 2017
16 | systemProp.http.proxyHost=127.0.0.1
17 | systemProp.http.proxyPort=1080
18 | 


--------------------------------------------------------------------------------
/gradlew:
--------------------------------------------------------------------------------
  1 | #!/usr/bin/env bash
  2 | 
  3 | ##############################################################################
  4 | ##
  5 | ##  Gradle start up script for UN*X
  6 | ##
  7 | ##############################################################################
  8 | 
  9 | # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
 10 | DEFAULT_JVM_OPTS=""
 11 | 
 12 | APP_NAME="Gradle"
 13 | APP_BASE_NAME=`basename "$0"`
 14 | 
 15 | # Use the maximum available, or set MAX_FD != -1 to use that value.
 16 | MAX_FD="maximum"
 17 | 
 18 | warn ( ) {
 19 |     echo "$*"
 20 | }
 21 | 
 22 | die ( ) {
 23 |     echo
 24 |     echo "$*"
 25 |     echo
 26 |     exit 1
 27 | }
 28 | 
 29 | # OS specific support (must be 'true' or 'false').
 30 | cygwin=false
 31 | msys=false
 32 | darwin=false
 33 | case "`uname`" in
 34 |   CYGWIN* )
 35 |     cygwin=true
 36 |     ;;
 37 |   Darwin* )
 38 |     darwin=true
 39 |     ;;
 40 |   MINGW* )
 41 |     msys=true
 42 |     ;;
 43 | esac
 44 | 
 45 | # Attempt to set APP_HOME
 46 | # Resolve links: $0 may be a link
 47 | PRG="$0"
 48 | # Need this for relative symlinks.
 49 | while [ -h "$PRG" ] ; do
 50 |     ls=`ls -ld "$PRG"`
 51 |     link=`expr "$ls" : '.*-> \(.*\)$'`
 52 |     if expr "$link" : '/.*' > /dev/null; then
 53 |         PRG="$link"
 54 |     else
 55 |         PRG=`dirname "$PRG"`"/$link"
 56 |     fi
 57 | done
 58 | SAVED="`pwd`"
 59 | cd "`dirname \"$PRG\"`/" >/dev/null
 60 | APP_HOME="`pwd -P`"
 61 | cd "$SAVED" >/dev/null
 62 | 
 63 | CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 64 | 
 65 | # Determine the Java command to use to start the JVM.
 66 | if [ -n "$JAVA_HOME" ] ; then
 67 |     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
 68 |         # IBM's JDK on AIX uses strange locations for the executables
 69 |         JAVACMD="$JAVA_HOME/jre/sh/java"
 70 |     else
 71 |         JAVACMD="$JAVA_HOME/bin/java"
 72 |     fi
 73 |     if [ ! -x "$JAVACMD" ] ; then
 74 |         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
 75 | 
 76 | Please set the JAVA_HOME variable in your environment to match the
 77 | location of your Java installation."
 78 |     fi
 79 | else
 80 |     JAVACMD="java"
 81 |     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 82 | 
 83 | Please set the JAVA_HOME variable in your environment to match the
 84 | location of your Java installation."
 85 | fi
 86 | 
 87 | # Increase the maximum file descriptors if we can.
 88 | if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
 89 |     MAX_FD_LIMIT=`ulimit -H -n`
 90 |     if [ $? -eq 0 ] ; then
 91 |         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
 92 |             MAX_FD="$MAX_FD_LIMIT"
 93 |         fi
 94 |         ulimit -n $MAX_FD
 95 |         if [ $? -ne 0 ] ; then
 96 |             warn "Could not set maximum file descriptor limit: $MAX_FD"
 97 |         fi
 98 |     else
 99 |         warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
100 |     fi
101 | fi
102 | 
103 | # For Darwin, add options to specify how the application appears in the dock
104 | if $darwin; then
105 |     GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
106 | fi
107 | 
108 | # For Cygwin, switch paths to Windows format before running java
109 | if $cygwin ; then
110 |     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
111 |     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
112 |     JAVACMD=`cygpath --unix "$JAVACMD"`
113 | 
114 |     # We build the pattern for arguments to be converted via cygpath
115 |     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
116 |     SEP=""
117 |     for dir in $ROOTDIRSRAW ; do
118 |         ROOTDIRS="$ROOTDIRS$SEP$dir"
119 |         SEP="|"
120 |     done
121 |     OURCYGPATTERN="(^($ROOTDIRS))"
122 |     # Add a user-defined pattern to the cygpath arguments
123 |     if [ "$GRADLE_CYGPATTERN" != "" ] ; then
124 |         OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
125 |     fi
126 |     # Now convert the arguments - kludge to limit ourselves to /bin/sh
127 |     i=0
128 |     for arg in "$@" ; do
129 |         CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
130 |         CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
131 | 
132 |         if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
133 |             eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
134 |         else
135 |             eval `echo args$i`="\"$arg\""
136 |         fi
137 |         i=$((i+1))
138 |     done
139 |     case $i in
140 |         (0) set -- ;;
141 |         (1) set -- "$args0" ;;
142 |         (2) set -- "$args0" "$args1" ;;
143 |         (3) set -- "$args0" "$args1" "$args2" ;;
144 |         (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
145 |         (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
146 |         (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
147 |         (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
148 |         (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
149 |         (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
150 |     esac
151 | fi
152 | 
153 | # Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
154 | function splitJvmOpts() {
155 |     JVM_OPTS=("$@")
156 | }
157 | eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
158 | JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
159 | 
160 | exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
161 | 


--------------------------------------------------------------------------------
/gradlew.bat:
--------------------------------------------------------------------------------
 1 | @if "%DEBUG%" == "" @echo off
 2 | @rem ##########################################################################
 3 | @rem
 4 | @rem  Gradle startup script for Windows
 5 | @rem
 6 | @rem ##########################################################################
 7 | 
 8 | @rem Set local scope for the variables with windows NT shell
 9 | if "%OS%"=="Windows_NT" setlocal
10 | 
11 | @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
12 | set DEFAULT_JVM_OPTS=
13 | 
14 | set DIRNAME=%~dp0
15 | if "%DIRNAME%" == "" set DIRNAME=.
16 | set APP_BASE_NAME=%~n0
17 | set APP_HOME=%DIRNAME%
18 | 
19 | @rem Find java.exe
20 | if defined JAVA_HOME goto findJavaFromJavaHome
21 | 
22 | set JAVA_EXE=java.exe
23 | %JAVA_EXE% -version >NUL 2>&1
24 | if "%ERRORLEVEL%" == "0" goto init
25 | 
26 | echo.
27 | echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
28 | echo.
29 | echo Please set the JAVA_HOME variable in your environment to match the
30 | echo location of your Java installation.
31 | 
32 | goto fail
33 | 
34 | :findJavaFromJavaHome
35 | set JAVA_HOME=%JAVA_HOME:"=%
36 | set JAVA_EXE=%JAVA_HOME%/bin/java.exe
37 | 
38 | if exist "%JAVA_EXE%" goto init
39 | 
40 | echo.
41 | echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
42 | echo.
43 | echo Please set the JAVA_HOME variable in your environment to match the
44 | echo location of your Java installation.
45 | 
46 | goto fail
47 | 
48 | :init
49 | @rem Get command-line arguments, handling Windowz variants
50 | 
51 | if not "%OS%" == "Windows_NT" goto win9xME_args
52 | if "%@eval[2+2]" == "4" goto 4NT_args
53 | 
54 | :win9xME_args
55 | @rem Slurp the command line arguments.
56 | set CMD_LINE_ARGS=
57 | set _SKIP=2
58 | 
59 | :win9xME_args_slurp
60 | if "x%~1" == "x" goto execute
61 | 
62 | set CMD_LINE_ARGS=%*
63 | goto execute
64 | 
65 | :4NT_args
66 | @rem Get arguments from the 4NT Shell from JP Software
67 | set CMD_LINE_ARGS=%$
68 | 
69 | :execute
70 | @rem Setup the command line
71 | 
72 | set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
73 | 
74 | @rem Execute Gradle
75 | "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
76 | 
77 | :end
78 | @rem End local scope for the variables with windows NT shell
79 | if "%ERRORLEVEL%"=="0" goto mainEnd
80 | 
81 | :fail
82 | rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
83 | rem the _cmd.exe /c_ return code!
84 | if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
85 | exit /b 1
86 | 
87 | :mainEnd
88 | if "%OS%"=="Windows_NT" endlocal
89 | 
90 | :omega
91 | 


--------------------------------------------------------------------------------
/libs/libandroid_tensorflow_inference_java.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/libs/libandroid_tensorflow_inference_java.jar


--------------------------------------------------------------------------------
/local.properties:
--------------------------------------------------------------------------------
 1 | ## This file is automatically generated by Android Studio.
 2 | # Do not modify this file -- YOUR CHANGES WILL BE ERASED!
 3 | #
 4 | # This file must *NOT* be checked into Version Control Systems,
 5 | # as it contains information specific to your local configuration.
 6 | #
 7 | # Location of the SDK. This is only used by Gradle.
 8 | # For customization when using a Version Control System, please read the
 9 | # header note.
10 | #Sun Mar 26 13:48:34 GMT+08:00 2017
11 | ndk.dir=D\:\\Simon\\Software\\adt-bundle-windows-x86_64-20140321\\sdk\\ndk-bundle
12 | sdk.dir=D\:\\Simon\\Software\\adt-bundle-windows-x86_64-20140321\\sdk
13 | 


--------------------------------------------------------------------------------
/res/drawable-hdpi/ic_action_info.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/res/drawable-hdpi/ic_action_info.png


--------------------------------------------------------------------------------
/res/drawable-hdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/res/drawable-hdpi/ic_launcher.png


--------------------------------------------------------------------------------
/res/drawable-hdpi/tile.9.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/res/drawable-hdpi/tile.9.png


--------------------------------------------------------------------------------
/res/drawable-mdpi/ic_action_info.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/res/drawable-mdpi/ic_action_info.png


--------------------------------------------------------------------------------
/res/drawable-mdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/res/drawable-mdpi/ic_launcher.png


--------------------------------------------------------------------------------
/res/drawable-xhdpi/ic_action_info.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/res/drawable-xhdpi/ic_action_info.png


--------------------------------------------------------------------------------
/res/drawable-xhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/res/drawable-xhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/res/drawable-xxhdpi/ic_action_info.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/res/drawable-xxhdpi/ic_action_info.png


--------------------------------------------------------------------------------
/res/drawable-xxhdpi/ic_launcher.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/res/drawable-xxhdpi/ic_launcher.png


--------------------------------------------------------------------------------
/res/layout/activity_camera.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?><!--
 2 |  Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 3 | 
 4 |  Licensed under the Apache License, Version 2.0 (the "License");
 5 |  you may not use this file except in compliance with the License.
 6 |  You may obtain a copy of the License at
 7 | 
 8 |      http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 |  Unless required by applicable law or agreed to in writing, software
11 |  distributed under the License is distributed on an "AS IS" BASIS,
12 |  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  See the License for the specific language governing permissions and
14 |  limitations under the License.
15 | -->
16 | <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
17 |     xmlns:tools="http://schemas.android.com/tools"
18 |     android:id="@+id/container"
19 |     android:layout_width="match_parent"
20 |     android:layout_height="match_parent"
21 |     android:background="#000"
22 |     tools:context="org.tensorflow.demo.CameraActivity" />
23 | 


--------------------------------------------------------------------------------
/res/layout/activity_photo_stylize.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
 3 |     xmlns:tools="http://schemas.android.com/tools"
 4 |     android:id="@+id/activity_photo_stylize"
 5 |     android:layout_width="match_parent"
 6 |     android:layout_height="match_parent"
 7 |     android:background="@android:color/black"
 8 |     tools:context="org.tensorflow.demo.PhotoStylizeActivity">
 9 | 
10 |     <ImageView
11 |         android:id="@+id/iv_photo"
12 |         android:layout_width="300dp"
13 |         android:layout_height="300dp"
14 |         android:layout_centerHorizontal="true"
15 |         android:layout_marginTop="16dp"
16 |         android:scaleType="centerCrop"
17 |         android:src="@drawable/ic_launcher"/>
18 | 
19 |     <GridView
20 |         android:id="@+id/grid_layout"
21 |         android:numColumns="7"
22 |         android:stretchMode="columnWidth"
23 |         android:layout_above="@+id/layout_btn"
24 |         android:layout_marginBottom="5dp"
25 |         android:layout_width="match_parent"
26 |         android:layout_height="wrap_content" />
27 | 
28 |     <LinearLayout
29 |         android:id="@+id/layout_btn"
30 |         android:layout_width="match_parent"
31 |         android:layout_height="48dp"
32 |         android:layout_alignParentBottom="true">
33 | 
34 |         <Button
35 |             android:id="@+id/btn_reset"
36 |             android:layout_width="0dp"
37 |             android:layout_height="match_parent"
38 |             android:layout_weight="1"
39 |             android:text="Reset"/>
40 | 
41 |         <Button
42 |             android:id="@+id/btn_stylize"
43 |             android:layout_width="0dp"
44 |             android:layout_height="match_parent"
45 |             android:layout_weight="1"
46 |             android:text="Stylize"/>
47 |     </LinearLayout>
48 | 
49 |     <View
50 |         android:id="@+id/view_mask"
51 |         android:layout_width="match_parent"
52 |         android:layout_height="match_parent"
53 |         android:background="#80888888"
54 |         android:visibility="gone"
55 |         tools:visibility="visible"/>
56 | 
57 |     <ProgressBar
58 |         android:id="@+id/progress_bar"
59 |         android:layout_width="100dp"
60 |         android:layout_height="100dp"
61 |         android:layout_centerInParent="true"
62 |         android:indeterminate="true"
63 |         android:visibility="gone"/>
64 | </RelativeLayout>
65 | 


--------------------------------------------------------------------------------
/res/layout/camera_connection_fragment.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?><!--
 2 |  Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 3 | 
 4 |  Licensed under the Apache License, Version 2.0 (the "License");
 5 |  you may not use this file except in compliance with the License.
 6 |  You may obtain a copy of the License at
 7 | 
 8 |      http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 |  Unless required by applicable law or agreed to in writing, software
11 |  distributed under the License is distributed on an "AS IS" BASIS,
12 |  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  See the License for the specific language governing permissions and
14 |  limitations under the License.
15 | -->
16 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
17 |     android:layout_width="match_parent"
18 |     android:layout_height="match_parent">
19 | 
20 |     <org.tensorflow.demo.AutoFitTextureView
21 |         android:id="@+id/texture"
22 |         android:layout_width="wrap_content"
23 |         android:layout_height="wrap_content"
24 |         android:layout_alignParentBottom="true" />
25 | 
26 |     <org.tensorflow.demo.RecognitionScoreView
27 |         android:id="@+id/results"
28 |         android:layout_width="match_parent"
29 |         android:layout_height="112dp"
30 |         android:layout_alignParentTop="true" />
31 | 
32 |     <org.tensorflow.demo.OverlayView
33 |         android:id="@+id/debug_overlay"
34 |         android:layout_width="match_parent"
35 |         android:layout_height="match_parent"
36 |         android:layout_alignParentBottom="true" />
37 | 
38 | </RelativeLayout>
39 | 


--------------------------------------------------------------------------------
/res/layout/camera_connection_fragment_stylize.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?><!--
 2 |  Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 3 | 
 4 |  Licensed under the Apache License, Version 2.0 (the "License");
 5 |  you may not use this file except in compliance with the License.
 6 |  You may obtain a copy of the License at
 7 | 
 8 |      http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 |  Unless required by applicable law or agreed to in writing, software
11 |  distributed under the License is distributed on an "AS IS" BASIS,
12 |  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  See the License for the specific language governing permissions and
14 |  limitations under the License.
15 | -->
16 | <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
17 |       android:orientation="vertical"
18 |       android:layout_width="match_parent"
19 |       android:layout_height="match_parent">
20 |   <org.tensorflow.demo.AutoFitTextureView
21 |     android:id="@+id/texture"
22 |     android:layout_width="wrap_content"
23 |     android:layout_height="wrap_content"
24 |     android:layout_alignParentTop="true" />
25 | 
26 |   <RelativeLayout
27 |     android:id="@+id/black"
28 |     android:layout_width="match_parent"
29 |     android:layout_height="match_parent"
30 |     android:background="#FF000000" />
31 | 
32 |   <GridView
33 |     android:id="@+id/grid_layout"
34 |     android:numColumns="7"
35 |     android:stretchMode="columnWidth"
36 |     android:layout_alignParentBottom="true"
37 |     android:layout_width="match_parent"
38 |     android:layout_height="wrap_content" />
39 | 
40 |   <org.tensorflow.demo.OverlayView
41 |       android:id="@+id/overlay"
42 |       android:layout_width="match_parent"
43 |       android:layout_height="match_parent"
44 |       android:layout_alignParentTop="true" />
45 | 
46 |   <org.tensorflow.demo.OverlayView
47 |     android:id="@+id/debug_overlay"
48 |     android:layout_width="match_parent"
49 |     android:layout_height="match_parent"
50 |     android:layout_alignParentTop="true" />
51 | </RelativeLayout>
52 | 


--------------------------------------------------------------------------------
/res/layout/camera_connection_fragment_tracking.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?><!--
 2 |  Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 3 | 
 4 |  Licensed under the Apache License, Version 2.0 (the "License");
 5 |  you may not use this file except in compliance with the License.
 6 |  You may obtain a copy of the License at
 7 | 
 8 |      http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 |  Unless required by applicable law or agreed to in writing, software
11 |  distributed under the License is distributed on an "AS IS" BASIS,
12 |  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  See the License for the specific language governing permissions and
14 |  limitations under the License.
15 | -->
16 | <FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
17 |     android:layout_width="match_parent"
18 |     android:layout_height="match_parent">
19 | 
20 |       <org.tensorflow.demo.AutoFitTextureView
21 |           android:id="@+id/texture"
22 |           android:layout_width="wrap_content"
23 |           android:layout_height="wrap_content"/>
24 | 
25 |       <org.tensorflow.demo.OverlayView
26 |           android:id="@+id/tracking_overlay"
27 |           android:layout_width="match_parent"
28 |           android:layout_height="match_parent"/>
29 | 
30 |       <org.tensorflow.demo.OverlayView
31 |           android:id="@+id/debug_overlay"
32 |           android:layout_width="match_parent"
33 |           android:layout_height="match_parent"/>
34 | </FrameLayout>
35 | 


--------------------------------------------------------------------------------
/res/values-sw600dp/template-dimens.xml:
--------------------------------------------------------------------------------
 1 | <!--
 2 |   Copyright 2013 The TensorFlow Authors. All Rights Reserved.
 3 | 
 4 |   Licensed under the Apache License, Version 2.0 (the "License");
 5 |   you may not use this file except in compliance with the License.
 6 |   You may obtain a copy of the License at
 7 | 
 8 |       http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 |   Unless required by applicable law or agreed to in writing, software
11 |   distributed under the License is distributed on an "AS IS" BASIS,
12 |   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |   See the License for the specific language governing permissions and
14 |   limitations under the License.
15 |   -->
16 | 
17 | <resources>
18 | 
19 |     <!-- Semantic definitions -->
20 | 
21 |     <dimen name="horizontal_page_margin">@dimen/margin_huge</dimen>
22 |     <dimen name="vertical_page_margin">@dimen/margin_medium</dimen>
23 | 
24 | </resources>
25 | 


--------------------------------------------------------------------------------
/res/values-sw600dp/template-styles.xml:
--------------------------------------------------------------------------------
 1 | <!--
 2 |   Copyright 2013 The TensorFlow Authors. All Rights Reserved.
 3 | 
 4 |   Licensed under the Apache License, Version 2.0 (the "License");
 5 |   you may not use this file except in compliance with the License.
 6 |   You may obtain a copy of the License at
 7 | 
 8 |       http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 |   Unless required by applicable law or agreed to in writing, software
11 |   distributed under the License is distributed on an "AS IS" BASIS,
12 |   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |   See the License for the specific language governing permissions and
14 |   limitations under the License.
15 |   -->
16 | 
17 | <resources>
18 | 
19 |     <style name="Widget.SampleMessage">
20 |         <item name="android:textAppearance">?android:textAppearanceLarge</item>
21 |         <item name="android:lineSpacingMultiplier">1.2</item>
22 |         <item name="android:shadowDy">-6.5</item>
23 |     </style>
24 | 
25 | </resources>
26 | 


--------------------------------------------------------------------------------
/res/values-v11/styles.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <resources>
 3 | 
 4 |   <!--
 5 |         Base application theme for API 11+. This theme completely replaces
 6 |         AppBaseTheme from res/values/styles.xml on API 11+ devices.
 7 |   -->
 8 |   <style name="AppBaseTheme" parent="android:Theme.Holo.Light">
 9 |     <!-- API 11 theme customizations can go here. -->
10 |   </style>
11 | 
12 |   <style name="FullscreenTheme" parent="android:Theme.Holo">
13 |     <item name="android:actionBarStyle">@style/FullscreenActionBarStyle</item>
14 |     <item name="android:windowActionBarOverlay">true</item>
15 |     <item name="android:windowBackground">@null</item>
16 |     <item name="metaButtonBarStyle">?android:attr/buttonBarStyle</item>
17 |     <item name="metaButtonBarButtonStyle">?android:attr/buttonBarButtonStyle</item>
18 |   </style>
19 | 
20 |   <style name="FullscreenActionBarStyle" parent="android:Widget.Holo.ActionBar">
21 |     <!--  <item name="android:background">@color/black_overlay</item>  -->
22 |   </style>
23 | 
24 | </resources>
25 | 


--------------------------------------------------------------------------------
/res/values-v11/template-styles.xml:
--------------------------------------------------------------------------------
 1 | <!--
 2 |   Copyright 2013 The TensorFlow Authors. All Rights Reserved.
 3 | 
 4 |   Licensed under the Apache License, Version 2.0 (the "License");
 5 |   you may not use this file except in compliance with the License.
 6 |   You may obtain a copy of the License at
 7 | 
 8 |       http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 |   Unless required by applicable law or agreed to in writing, software
11 |   distributed under the License is distributed on an "AS IS" BASIS,
12 |   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |   See the License for the specific language governing permissions and
14 |   limitations under the License.
15 |   -->
16 | 
17 | <resources>
18 | 
19 |     <!-- Activity themes -->
20 |     <style name="Theme.Base" parent="android:Theme.Holo.Light" />
21 | 
22 | </resources>
23 | 


--------------------------------------------------------------------------------
/res/values-v14/styles.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 | 
 3 |   <!--
 4 |         Base application theme for API 14+. This theme completely replaces
 5 |         AppBaseTheme from BOTH res/values/styles.xml and
 6 |         res/values-v11/styles.xml on API 14+ devices.
 7 |   -->
 8 |   <style name="AppBaseTheme" parent="android:Theme.Holo.Light.DarkActionBar">
 9 |     <!-- API 14 theme customizations can go here. -->
10 |   </style>
11 | 
12 | </resources>
13 | 


--------------------------------------------------------------------------------
/res/values-v21/base-colors.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!--
 3 |  Copyright 2013 The TensorFlow Authors. All Rights Reserved.
 4 | 
 5 |  Licensed under the Apache License, Version 2.0 (the "License");
 6 |  you may not use this file except in compliance with the License.
 7 |  You may obtain a copy of the License at
 8 | 
 9 |      http://www.apache.org/licenses/LICENSE-2.0
10 | 
11 |  Unless required by applicable law or agreed to in writing, software
12 |  distributed under the License is distributed on an "AS IS" BASIS,
13 |  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 |  See the License for the specific language governing permissions and
15 |  limitations under the License.
16 | -->
17 | 
18 | <resources>
19 | 
20 | 
21 | </resources>
22 | 


--------------------------------------------------------------------------------
/res/values-v21/base-template-styles.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!--
 3 |  Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 4 | 
 5 |  Licensed under the Apache License, Version 2.0 (the "License");
 6 |  you may not use this file except in compliance with the License.
 7 |  You may obtain a copy of the License at
 8 | 
 9 |      http://www.apache.org/licenses/LICENSE-2.0
10 | 
11 |  Unless required by applicable law or agreed to in writing, software
12 |  distributed under the License is distributed on an "AS IS" BASIS,
13 |  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 |  See the License for the specific language governing permissions and
15 |  limitations under the License.
16 | -->
17 | 
18 | <resources>
19 | 
20 |     <!-- Activity themes -->
21 |     <style name="Theme.Base" parent="android:Theme.Material.Light">
22 |     </style>
23 | 
24 | </resources>
25 | 


--------------------------------------------------------------------------------
/res/values-w820dp/dimens.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <!-- Example customization of dimensions originally defined in res/values/dimens.xml
3 |          (such as screen margins) for screens with more than 820dp of available width. This
4 |          would include 7" and 10" devices in landscape (~960dp and ~1280dp respectively). -->
5 |     <dimen name="activity_horizontal_margin">64dp</dimen>
6 | </resources>
7 | 


--------------------------------------------------------------------------------
/res/values/attrs.xml:
--------------------------------------------------------------------------------
 1 | <resources>
 2 | 
 3 |   <!--
 4 |          Declare custom theme attributes that allow changing which styles are
 5 |          used for button bars depending on the API level.
 6 |          ?android:attr/buttonBarStyle is new as of API 11 so this is
 7 |          necessary to support previous API levels.
 8 |   -->
 9 |   <declare-styleable name="ButtonBarContainerTheme">
10 |     <attr name="metaButtonBarStyle" format="reference" />
11 |     <attr name="metaButtonBarButtonStyle" format="reference" />
12 |   </declare-styleable>
13 | 
14 | </resources>
15 | 


--------------------------------------------------------------------------------
/res/values/base-strings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <!--
 3 |  Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 4 | 
 5 |  Licensed under the Apache License, Version 2.0 (the "License");
 6 |  you may not use this file except in compliance with the License.
 7 |  You may obtain a copy of the License at
 8 | 
 9 |      http://www.apache.org/licenses/LICENSE-2.0
10 | 
11 |  Unless required by applicable law or agreed to in writing, software
12 |  distributed under the License is distributed on an "AS IS" BASIS,
13 |  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 |  See the License for the specific language governing permissions and
15 |  limitations under the License.
16 | -->
17 | 
18 | <resources>
19 |     <string name="app_name">TensorFlow Demo</string>
20 |     <string name="activity_name_classification">TF Classify</string>
21 |     <string name="activity_name_detection">TF Detect</string>
22 |     <string name="activity_name_stylize">TF Stylize</string>
23 |     <string name="activity_name_photo_stylize">Photo Stylize</string>
24 | </resources>
25 | 


--------------------------------------------------------------------------------
/res/values/colors.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?>
 2 | <!--
 3 |  Copyright 2015 The TensorFlow Authors. All Rights Reserved.
 4 | 
 5 |  Licensed under the Apache License, Version 2.0 (the "License");
 6 |  you may not use this file except in compliance with the License.
 7 |  You may obtain a copy of the License at
 8 | 
 9 |      http://www.apache.org/licenses/LICENSE-2.0
10 | 
11 |  Unless required by applicable law or agreed to in writing, software
12 |  distributed under the License is distributed on an "AS IS" BASIS,
13 |  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 |  See the License for the specific language governing permissions and
15 |  limitations under the License.
16 | -->
17 | <resources>
18 |     <color name="control_background">#cc4285f4</color>
19 | </resources>
20 | 


--------------------------------------------------------------------------------
/res/values/dimens.xml:
--------------------------------------------------------------------------------
1 | <resources>
2 |     <!-- Default screen margins, per the Android Design guidelines. -->
3 |     <dimen name="activity_horizontal_margin">16dp</dimen>
4 |     <dimen name="activity_vertical_margin">16dp</dimen>
5 | </resources>
6 | 


--------------------------------------------------------------------------------
/res/values/strings.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?><!--
 2 |  Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 3 | 
 4 |  Licensed under the Apache License, Version 2.0 (the "License");
 5 |  you may not use this file except in compliance with the License.
 6 |  You may obtain a copy of the License at
 7 | 
 8 |      http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 |  Unless required by applicable law or agreed to in writing, software
11 |  distributed under the License is distributed on an "AS IS" BASIS,
12 |  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  See the License for the specific language governing permissions and
14 |  limitations under the License.
15 | -->
16 | <resources>
17 |     <string name="description_info">Info</string>
18 |     <string name="request_permission">This sample needs camera permission.</string>
19 |     <string name="camera_error">This device doesn\'t support Camera2 API.</string>
20 | </resources>
21 | 


--------------------------------------------------------------------------------
/res/values/styles.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="utf-8"?><!--
 2 |  Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 3 | 
 4 |  Licensed under the Apache License, Version 2.0 (the "License");
 5 |  you may not use this file except in compliance with the License.
 6 |  You may obtain a copy of the License at
 7 | 
 8 |      http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 |  Unless required by applicable law or agreed to in writing, software
11 |  distributed under the License is distributed on an "AS IS" BASIS,
12 |  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  See the License for the specific language governing permissions and
14 |  limitations under the License.
15 | -->
16 | <resources>
17 |     <style name="MaterialTheme" parent="android:Theme.Material.Light.NoActionBar.Fullscreen" />
18 | </resources>
19 | 


--------------------------------------------------------------------------------
/res/values/template-dimens.xml:
--------------------------------------------------------------------------------
 1 | <!--
 2 |   Copyright 2013 The TensorFlow Authors. All Rights Reserved.
 3 | 
 4 |   Licensed under the Apache License, Version 2.0 (the "License");
 5 |   you may not use this file except in compliance with the License.
 6 |   You may obtain a copy of the License at
 7 | 
 8 |       http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 |   Unless required by applicable law or agreed to in writing, software
11 |   distributed under the License is distributed on an "AS IS" BASIS,
12 |   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |   See the License for the specific language governing permissions and
14 |   limitations under the License.
15 |   -->
16 | 
17 | <resources>
18 | 
19 |     <!-- Define standard dimensions to comply with Holo-style grids and rhythm. -->
20 | 
21 |     <dimen name="margin_tiny">4dp</dimen>
22 |     <dimen name="margin_small">8dp</dimen>
23 |     <dimen name="margin_medium">16dp</dimen>
24 |     <dimen name="margin_large">32dp</dimen>
25 |     <dimen name="margin_huge">64dp</dimen>
26 | 
27 |     <!-- Semantic definitions -->
28 | 
29 |     <dimen name="horizontal_page_margin">@dimen/margin_medium</dimen>
30 |     <dimen name="vertical_page_margin">@dimen/margin_medium</dimen>
31 | 
32 | </resources>
33 | 


--------------------------------------------------------------------------------
/res/values/template-styles.xml:
--------------------------------------------------------------------------------
 1 | <!--
 2 |   Copyright 2013 The TensorFlow Authors. All Rights Reserved.
 3 | 
 4 |   Licensed under the Apache License, Version 2.0 (the "License");
 5 |   you may not use this file except in compliance with the License.
 6 |   You may obtain a copy of the License at
 7 | 
 8 |       http://www.apache.org/licenses/LICENSE-2.0
 9 | 
10 |   Unless required by applicable law or agreed to in writing, software
11 |   distributed under the License is distributed on an "AS IS" BASIS,
12 |   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |   See the License for the specific language governing permissions and
14 |   limitations under the License.
15 |   -->
16 | 
17 | <resources>
18 | 
19 |     <!-- Activity themes -->
20 | 
21 |     <style name="Theme.Base" parent="android:Theme.Light" />
22 | 
23 |     <style name="Theme.Sample" parent="Theme.Base" />
24 | 
25 |     <style name="AppTheme" parent="Theme.Sample" />
26 |     <!-- Widget styling -->
27 | 
28 |     <style name="Widget" />
29 | 
30 |     <style name="Widget.SampleMessage">
31 |         <item name="android:textAppearance">?android:textAppearanceMedium</item>
32 |         <item name="android:lineSpacingMultiplier">1.1</item>
33 |     </style>
34 | 
35 |     <style name="Widget.SampleMessageTile">
36 |         <item name="android:background">@drawable/tile</item>
37 |         <item name="android:shadowColor">#7F000000</item>
38 |         <item name="android:shadowDy">-3.5</item>
39 |         <item name="android:shadowRadius">2</item>
40 |     </style>
41 | 
42 | </resources>
43 | 


--------------------------------------------------------------------------------
/sample_images/classify1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/sample_images/classify1.jpg


--------------------------------------------------------------------------------
/sample_images/detect1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/sample_images/detect1.jpg


--------------------------------------------------------------------------------
/sample_images/photo1.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/sample_images/photo1.png


--------------------------------------------------------------------------------
/sample_images/stylize1.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SimonCherryGZ/TensorFlow_Android/929cf902450ebbff3fc61bc161ceefcab8930342/sample_images/stylize1.jpg


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/AutoFitTextureView.java:
--------------------------------------------------------------------------------
 1 | /*
 2 |  * Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 3 |  *
 4 |  * Licensed under the Apache License, Version 2.0 (the "License");
 5 |  * you may not use this file except in compliance with the License.
 6 |  * You may obtain a copy of the License at
 7 |  *
 8 |  *       http://www.apache.org/licenses/LICENSE-2.0
 9 |  *
10 |  * Unless required by applicable law or agreed to in writing, software
11 |  * distributed under the License is distributed on an "AS IS" BASIS,
12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 |  * See the License for the specific language governing permissions and
14 |  * limitations under the License.
15 |  */
16 | 
17 | package org.tensorflow.demo;
18 | 
19 | import android.content.Context;
20 | import android.util.AttributeSet;
21 | import android.view.TextureView;
22 | 
23 | /**
24 |  * A {@link TextureView} that can be adjusted to a specified aspect ratio.
25 |  */
26 | public class AutoFitTextureView extends TextureView {
27 |   private int ratioWidth = 0;
28 |   private int ratioHeight = 0;
29 | 
30 |   public AutoFitTextureView(final Context context) {
31 |     this(context, null);
32 |   }
33 | 
34 |   public AutoFitTextureView(final Context context, final AttributeSet attrs) {
35 |     this(context, attrs, 0);
36 |   }
37 | 
38 |   public AutoFitTextureView(final Context context, final AttributeSet attrs, final int defStyle) {
39 |     super(context, attrs, defStyle);
40 |   }
41 | 
42 |   /**
43 |    * Sets the aspect ratio for this view. The size of the view will be measured based on the ratio
44 |    * calculated from the parameters. Note that the actual sizes of parameters don't matter, that
45 |    * is, calling setAspectRatio(2, 3) and setAspectRatio(4, 6) make the same result.
46 |    *
47 |    * @param width  Relative horizontal size
48 |    * @param height Relative vertical size
49 |    */
50 |   public void setAspectRatio(final int width, final int height) {
51 |     if (width < 0 || height < 0) {
52 |       throw new IllegalArgumentException("Size cannot be negative.");
53 |     }
54 |     ratioWidth = width;
55 |     ratioHeight = height;
56 |     requestLayout();
57 |   }
58 | 
59 |   @Override
60 |   protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
61 |     super.onMeasure(widthMeasureSpec, heightMeasureSpec);
62 |     final int width = MeasureSpec.getSize(widthMeasureSpec);
63 |     final int height = MeasureSpec.getSize(heightMeasureSpec);
64 |     if (0 == ratioWidth || 0 == ratioHeight) {
65 |       setMeasuredDimension(width, height);
66 |     } else {
67 |       if (width < height * ratioWidth / ratioHeight) {
68 |         setMeasuredDimension(width, width * ratioHeight / ratioWidth);
69 |       } else {
70 |         setMeasuredDimension(height * ratioWidth / ratioHeight, height);
71 |       }
72 |     }
73 |   }
74 | }
75 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/CameraActivity.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2016 The TensorFlow Authors. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *       http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | package org.tensorflow.demo;
 18 | 
 19 | import android.Manifest;
 20 | import android.app.Activity;
 21 | import android.app.Fragment;
 22 | import android.content.pm.PackageManager;
 23 | import android.media.Image.Plane;
 24 | import android.media.ImageReader.OnImageAvailableListener;
 25 | import android.os.Build;
 26 | import android.os.Bundle;
 27 | import android.os.Handler;
 28 | import android.os.HandlerThread;
 29 | import android.util.Size;
 30 | import android.view.KeyEvent;
 31 | import android.view.WindowManager;
 32 | import android.widget.Toast;
 33 | import java.nio.ByteBuffer;
 34 | import org.tensorflow.demo.env.Logger;
 35 | import org.tensorflow.demo.R;
 36 | 
 37 | public abstract class CameraActivity extends Activity implements OnImageAvailableListener {
 38 |   private static final Logger LOGGER = new Logger();
 39 | 
 40 |   private static final int PERMISSIONS_REQUEST = 1;
 41 | 
 42 |   private static final String PERMISSION_CAMERA = Manifest.permission.CAMERA;
 43 |   private static final String PERMISSION_STORAGE = Manifest.permission.WRITE_EXTERNAL_STORAGE;
 44 | 
 45 |   private boolean debug = false;
 46 | 
 47 |   private Handler handler;
 48 |   private HandlerThread handlerThread;
 49 | 
 50 |   @Override
 51 |   protected void onCreate(final Bundle savedInstanceState) {
 52 |     LOGGER.d("onCreate " + this);
 53 |     super.onCreate(null);
 54 |     getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
 55 | 
 56 |     setContentView(R.layout.activity_camera);
 57 | 
 58 |     if (hasPermission()) {
 59 |       setFragment();
 60 |     } else {
 61 |       requestPermission();
 62 |     }
 63 |   }
 64 | 
 65 |   @Override
 66 |   public synchronized void onStart() {
 67 |     LOGGER.d("onStart " + this);
 68 |     super.onStart();
 69 |   }
 70 | 
 71 |   @Override
 72 |   public synchronized void onResume() {
 73 |     LOGGER.d("onResume " + this);
 74 |     super.onResume();
 75 | 
 76 |     handlerThread = new HandlerThread("inference");
 77 |     handlerThread.start();
 78 |     handler = new Handler(handlerThread.getLooper());
 79 |   }
 80 | 
 81 |   @Override
 82 |   public synchronized void onPause() {
 83 |     LOGGER.d("onPause " + this);
 84 | 
 85 |     if (!isFinishing()) {
 86 |       LOGGER.d("Requesting finish");
 87 |       finish();
 88 |     }
 89 | 
 90 |     handlerThread.quitSafely();
 91 |     try {
 92 |       handlerThread.join();
 93 |       handlerThread = null;
 94 |       handler = null;
 95 |     } catch (final InterruptedException e) {
 96 |       LOGGER.e(e, "Exception!");
 97 |     }
 98 | 
 99 |     super.onPause();
100 |   }
101 | 
102 |   @Override
103 |   public synchronized void onStop() {
104 |     LOGGER.d("onStop " + this);
105 |     super.onStop();
106 |   }
107 | 
108 |   @Override
109 |   public synchronized void onDestroy() {
110 |     LOGGER.d("onDestroy " + this);
111 |     super.onDestroy();
112 |   }
113 | 
114 |   protected synchronized void runInBackground(final Runnable r) {
115 |     if (handler != null) {
116 |       handler.post(r);
117 |     }
118 |   }
119 | 
120 |   @Override
121 |   public void onRequestPermissionsResult(
122 |       final int requestCode, final String[] permissions, final int[] grantResults) {
123 |     switch (requestCode) {
124 |       case PERMISSIONS_REQUEST: {
125 |         if (grantResults.length > 0
126 |                 && grantResults[0] == PackageManager.PERMISSION_GRANTED
127 |                 && grantResults[1] == PackageManager.PERMISSION_GRANTED) {
128 |           setFragment();
129 |         } else {
130 |           requestPermission();
131 |         }
132 |       }
133 |     }
134 |   }
135 | 
136 |   private boolean hasPermission() {
137 |     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
138 |       return checkSelfPermission(PERMISSION_CAMERA) == PackageManager.PERMISSION_GRANTED && checkSelfPermission(PERMISSION_STORAGE) == PackageManager.PERMISSION_GRANTED;
139 |     } else {
140 |       return true;
141 |     }
142 |   }
143 | 
144 |   private void requestPermission() {
145 |     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
146 |       if (shouldShowRequestPermissionRationale(PERMISSION_CAMERA) || shouldShowRequestPermissionRationale(PERMISSION_STORAGE)) {
147 |         Toast.makeText(CameraActivity.this, "Camera AND storage permission are required for this demo", Toast.LENGTH_LONG).show();
148 |       }
149 |       requestPermissions(new String[] {PERMISSION_CAMERA, PERMISSION_STORAGE}, PERMISSIONS_REQUEST);
150 |     }
151 |   }
152 | 
153 |   protected void setFragment() {
154 |     final Fragment fragment = CameraConnectionFragment.newInstance(
155 |         new CameraConnectionFragment.ConnectionCallback(){
156 |           @Override
157 |           public void onPreviewSizeChosen(final Size size, final int rotation) {
158 |             CameraActivity.this.onPreviewSizeChosen(size, rotation);
159 |           }
160 |         },
161 |         this, getLayoutId(), getDesiredPreviewFrameSize());
162 | 
163 |     getFragmentManager()
164 |         .beginTransaction()
165 |         .replace(R.id.container, fragment)
166 |         .commit();
167 |   }
168 | 
169 |   protected void fillBytes(final Plane[] planes, final byte[][] yuvBytes) {
170 |     // Because of the variable row stride it's not possible to know in
171 |     // advance the actual necessary dimensions of the yuv planes.
172 |     for (int i = 0; i < planes.length; ++i) {
173 |       final ByteBuffer buffer = planes[i].getBuffer();
174 |       if (yuvBytes[i] == null) {
175 |         LOGGER.d("Initializing buffer %d at size %d", i, buffer.capacity());
176 |         yuvBytes[i] = new byte[buffer.capacity()];
177 |       }
178 |       buffer.get(yuvBytes[i]);
179 |     }
180 |   }
181 | 
182 |   public boolean isDebug() {
183 |     return debug;
184 |   }
185 | 
186 |   public void requestRender() {
187 |     final OverlayView overlay = (OverlayView) findViewById(R.id.debug_overlay);
188 |     if (overlay != null) {
189 |       overlay.postInvalidate();
190 |     }
191 |   }
192 | 
193 |   public void addCallback(final OverlayView.DrawCallback callback) {
194 |     final OverlayView overlay = (OverlayView) findViewById(R.id.debug_overlay);
195 |     if (overlay != null) {
196 |       overlay.addCallback(callback);
197 |     }
198 |   }
199 | 
200 |   public void onSetDebug(final boolean debug) {}
201 | 
202 |   @Override
203 |   public boolean onKeyDown(final int keyCode, final KeyEvent event) {
204 |     if (keyCode == KeyEvent.KEYCODE_VOLUME_DOWN || keyCode == KeyEvent.KEYCODE_VOLUME_UP) {
205 |       debug = !debug;
206 |       requestRender();
207 |       onSetDebug(debug);
208 |       return true;
209 |     }
210 |     return super.onKeyDown(keyCode, event);
211 |   }
212 | 
213 |   protected abstract void onPreviewSizeChosen(final Size size, final int rotation);
214 |   protected abstract int getLayoutId();
215 |   protected abstract int getDesiredPreviewFrameSize();
216 | }
217 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/Classifier.java:
--------------------------------------------------------------------------------
  1 | /* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
  2 | 
  3 | Licensed under the Apache License, Version 2.0 (the "License");
  4 | you may not use this file except in compliance with the License.
  5 | You may obtain a copy of the License at
  6 | 
  7 |     http://www.apache.org/licenses/LICENSE-2.0
  8 | 
  9 | Unless required by applicable law or agreed to in writing, software
 10 | distributed under the License is distributed on an "AS IS" BASIS,
 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | See the License for the specific language governing permissions and
 13 | limitations under the License.
 14 | ==============================================================================*/
 15 | 
 16 | package org.tensorflow.demo;
 17 | 
 18 | import android.graphics.Bitmap;
 19 | import android.graphics.RectF;
 20 | import java.util.List;
 21 | 
 22 | /**
 23 |  * Generic interface for interacting with different recognition engines.
 24 |  */
 25 | public interface Classifier {
 26 |   /**
 27 |    * An immutable result returned by a Classifier describing what was recognized.
 28 |    */
 29 |   public class Recognition {
 30 |     /**
 31 |      * A unique identifier for what has been recognized. Specific to the class, not the instance of
 32 |      * the object.
 33 |      */
 34 |     private final String id;
 35 | 
 36 |     /**
 37 |      * Display name for the recognition.
 38 |      */
 39 |     private final String title;
 40 | 
 41 |     /**
 42 |      * A sortable score for how good the recognition is relative to others. Higher should be better.
 43 |      */
 44 |     private final Float confidence;
 45 | 
 46 |     /** Optional location within the source image for the location of the recognized object. */
 47 |     private RectF location;
 48 | 
 49 |     public Recognition(
 50 |         final String id, final String title, final Float confidence, final RectF location) {
 51 |       this.id = id;
 52 |       this.title = title;
 53 |       this.confidence = confidence;
 54 |       this.location = location;
 55 |     }
 56 | 
 57 |     public String getId() {
 58 |       return id;
 59 |     }
 60 | 
 61 |     public String getTitle() {
 62 |       return title;
 63 |     }
 64 | 
 65 |     public Float getConfidence() {
 66 |       return confidence;
 67 |     }
 68 | 
 69 |     public RectF getLocation() {
 70 |       return new RectF(location);
 71 |     }
 72 | 
 73 |     public void setLocation(RectF location) {
 74 |       this.location = location;
 75 |     }
 76 | 
 77 |     @Override
 78 |     public String toString() {
 79 |       String resultString = "";
 80 |       if (id != null) {
 81 |         resultString += "[" + id + "] ";
 82 |       }
 83 | 
 84 |       if (title != null) {
 85 |         resultString += title + " ";
 86 |       }
 87 | 
 88 |       if (confidence != null) {
 89 |         resultString += String.format("(%.1f%%) ", confidence * 100.0f);
 90 |       }
 91 | 
 92 |       if (location != null) {
 93 |         resultString += location + " ";
 94 |       }
 95 | 
 96 |       return resultString.trim();
 97 |     }
 98 |   }
 99 | 
100 |   List<Recognition> recognizeImage(Bitmap bitmap);
101 | 
102 |   void enableStatLogging(final boolean debug);
103 |   
104 |   String getStatString();
105 | 
106 |   void close();
107 | }
108 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/ClassifierActivity.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2016 The TensorFlow Authors. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *       http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | package org.tensorflow.demo;
 18 | 
 19 | import android.graphics.Bitmap;
 20 | import android.graphics.Bitmap.Config;
 21 | import android.graphics.Canvas;
 22 | import android.graphics.Matrix;
 23 | import android.graphics.Paint;
 24 | import android.graphics.Typeface;
 25 | import android.media.Image;
 26 | import android.media.Image.Plane;
 27 | import android.media.ImageReader;
 28 | import android.media.ImageReader.OnImageAvailableListener;
 29 | import android.os.SystemClock;
 30 | import android.os.Trace;
 31 | import android.util.Size;
 32 | import android.util.TypedValue;
 33 | import android.view.Display;
 34 | import java.util.List;
 35 | import java.util.Vector;
 36 | import org.tensorflow.demo.OverlayView.DrawCallback;
 37 | import org.tensorflow.demo.env.BorderedText;
 38 | import org.tensorflow.demo.env.ImageUtils;
 39 | import org.tensorflow.demo.env.Logger;
 40 | import org.tensorflow.demo.R;
 41 | 
 42 | public class ClassifierActivity extends CameraActivity implements OnImageAvailableListener {
 43 |   private static final Logger LOGGER = new Logger();
 44 | 
 45 |   // These are the settings for the original v1 Inception model. If you want to
 46 |   // use a model that's been produced from the TensorFlow for Poets codelab,
 47 |   // you'll need to set IMAGE_SIZE = 299, IMAGE_MEAN = 128, IMAGE_STD = 128,
 48 |   // INPUT_NAME = "Mul", and OUTPUT_NAME = "final_result".
 49 |   // You'll also need to update the MODEL_FILE and LABEL_FILE paths to point to
 50 |   // the ones you produced.
 51 |   //
 52 |   // To use v3 Inception model, strip the DecodeJpeg Op from your retrained
 53 |   // model first:
 54 |   //
 55 |   // python strip_unused.py \
 56 |   // --input_graph=<retrained-pb-file> \
 57 |   // --output_graph=<your-stripped-pb-file> \
 58 |   // --input_node_names="Mul" \
 59 |   // --output_node_names="final_result" \
 60 |   // --input_binary=true
 61 |   private static final int INPUT_SIZE = 224;
 62 |   private static final int IMAGE_MEAN = 117;
 63 |   private static final float IMAGE_STD = 1;
 64 |   private static final String INPUT_NAME = "input";
 65 |   private static final String OUTPUT_NAME = "output";
 66 | 
 67 |   private static final String MODEL_FILE = "file:///android_asset/tensorflow_inception_graph.pb";
 68 |   private static final String LABEL_FILE =
 69 |       "file:///android_asset/imagenet_comp_graph_label_strings.txt";
 70 | 
 71 |   private static final boolean SAVE_PREVIEW_BITMAP = false;
 72 | 
 73 |   private static final boolean MAINTAIN_ASPECT = true;
 74 | 
 75 |   private Classifier classifier;
 76 | 
 77 |   private Integer sensorOrientation;
 78 | 
 79 |   private int previewWidth = 0;
 80 |   private int previewHeight = 0;
 81 |   private byte[][] yuvBytes;
 82 |   private int[] rgbBytes = null;
 83 |   private Bitmap rgbFrameBitmap = null;
 84 |   private Bitmap croppedBitmap = null;
 85 | 
 86 |   private Bitmap cropCopyBitmap;
 87 | 
 88 |   private boolean computing = false;
 89 | 
 90 |   private Matrix frameToCropTransform;
 91 |   private Matrix cropToFrameTransform;
 92 | 
 93 |   private ResultsView resultsView;
 94 | 
 95 |   private BorderedText borderedText;
 96 | 
 97 |   private long lastProcessingTimeMs;
 98 | 
 99 |   @Override
100 |   protected int getLayoutId() {
101 |     return R.layout.camera_connection_fragment;
102 |   }
103 | 
104 |   @Override
105 |   protected int getDesiredPreviewFrameSize() {
106 |     return INPUT_SIZE;
107 |   }
108 | 
109 |   private static final float TEXT_SIZE_DIP = 10;
110 | 
111 |   @Override
112 |   public void onPreviewSizeChosen(final Size size, final int rotation) {
113 |     final float textSizePx =
114 |         TypedValue.applyDimension(
115 |             TypedValue.COMPLEX_UNIT_DIP, TEXT_SIZE_DIP, getResources().getDisplayMetrics());
116 |     borderedText = new BorderedText(textSizePx);
117 |     borderedText.setTypeface(Typeface.MONOSPACE);
118 | 
119 |     classifier =
120 |         TensorFlowImageClassifier.create(
121 |             getAssets(),
122 |             MODEL_FILE,
123 |             LABEL_FILE,
124 |             INPUT_SIZE,
125 |             IMAGE_MEAN,
126 |             IMAGE_STD,
127 |             INPUT_NAME,
128 |             OUTPUT_NAME);
129 | 
130 |     resultsView = (ResultsView) findViewById(R.id.results);
131 |     previewWidth = size.getWidth();
132 |     previewHeight = size.getHeight();
133 | 
134 |     final Display display = getWindowManager().getDefaultDisplay();
135 |     final int screenOrientation = display.getRotation();
136 | 
137 |     LOGGER.i("Sensor orientation: %d, Screen orientation: %d", rotation, screenOrientation);
138 | 
139 |     sensorOrientation = rotation + screenOrientation;
140 | 
141 |     LOGGER.i("Initializing at size %dx%d", previewWidth, previewHeight);
142 |     rgbBytes = new int[previewWidth * previewHeight];
143 |     rgbFrameBitmap = Bitmap.createBitmap(previewWidth, previewHeight, Config.ARGB_8888);
144 |     croppedBitmap = Bitmap.createBitmap(INPUT_SIZE, INPUT_SIZE, Config.ARGB_8888);
145 | 
146 |     frameToCropTransform =
147 |         ImageUtils.getTransformationMatrix(
148 |             previewWidth, previewHeight,
149 |             INPUT_SIZE, INPUT_SIZE,
150 |             sensorOrientation, MAINTAIN_ASPECT);
151 | 
152 |     cropToFrameTransform = new Matrix();
153 |     frameToCropTransform.invert(cropToFrameTransform);
154 | 
155 |     yuvBytes = new byte[3][];
156 | 
157 |     addCallback(
158 |         new DrawCallback() {
159 |           @Override
160 |           public void drawCallback(final Canvas canvas) {
161 |             renderDebug(canvas);
162 |           }
163 |         });
164 |   }
165 | 
166 |   @Override
167 |   public void onImageAvailable(final ImageReader reader) {
168 |     Image image = null;
169 | 
170 |     try {
171 |       image = reader.acquireLatestImage();
172 | 
173 |       if (image == null) {
174 |         return;
175 |       }
176 | 
177 |       if (computing) {
178 |         image.close();
179 |         return;
180 |       }
181 |       computing = true;
182 | 
183 |       Trace.beginSection("imageAvailable");
184 | 
185 |       final Plane[] planes = image.getPlanes();
186 |       fillBytes(planes, yuvBytes);
187 | 
188 |       final int yRowStride = planes[0].getRowStride();
189 |       final int uvRowStride = planes[1].getRowStride();
190 |       final int uvPixelStride = planes[1].getPixelStride();
191 |       ImageUtils.convertYUV420ToARGB8888(
192 |           yuvBytes[0],
193 |           yuvBytes[1],
194 |           yuvBytes[2],
195 |           rgbBytes,
196 |           previewWidth,
197 |           previewHeight,
198 |           yRowStride,
199 |           uvRowStride,
200 |           uvPixelStride,
201 |           false);
202 | 
203 |       image.close();
204 |     } catch (final Exception e) {
205 |       if (image != null) {
206 |         image.close();
207 |       }
208 |       LOGGER.e(e, "Exception!");
209 |       Trace.endSection();
210 |       return;
211 |     }
212 | 
213 |     rgbFrameBitmap.setPixels(rgbBytes, 0, previewWidth, 0, 0, previewWidth, previewHeight);
214 |     final Canvas canvas = new Canvas(croppedBitmap);
215 |     canvas.drawBitmap(rgbFrameBitmap, frameToCropTransform, null);
216 | 
217 |     // For examining the actual TF input.
218 |     if (SAVE_PREVIEW_BITMAP) {
219 |       ImageUtils.saveBitmap(croppedBitmap);
220 |     }
221 | 
222 |     runInBackground(
223 |         new Runnable() {
224 |           @Override
225 |           public void run() {
226 |             final long startTime = SystemClock.uptimeMillis();
227 |             final List<Classifier.Recognition> results = classifier.recognizeImage(croppedBitmap);
228 |             lastProcessingTimeMs = SystemClock.uptimeMillis() - startTime;
229 | 
230 |             cropCopyBitmap = Bitmap.createBitmap(croppedBitmap);
231 |             resultsView.setResults(results);
232 |             requestRender();
233 |             computing = false;
234 |           }
235 |         });
236 | 
237 |     Trace.endSection();
238 |   }
239 | 
240 |   @Override
241 |   public void onSetDebug(boolean debug) {
242 |     classifier.enableStatLogging(debug);
243 |   }
244 | 
245 |   private void renderDebug(final Canvas canvas) {
246 |     if (!isDebug()) {
247 |       return;
248 |     }
249 |     final Bitmap copy = cropCopyBitmap;
250 |     if (copy != null) {
251 |       final Matrix matrix = new Matrix();
252 |       final float scaleFactor = 2;
253 |       matrix.postScale(scaleFactor, scaleFactor);
254 |       matrix.postTranslate(
255 |           canvas.getWidth() - copy.getWidth() * scaleFactor,
256 |           canvas.getHeight() - copy.getHeight() * scaleFactor);
257 |       canvas.drawBitmap(copy, matrix, new Paint());
258 | 
259 |       final Vector<String> lines = new Vector<String>();
260 |       if (classifier != null) {
261 |         String statString = classifier.getStatString();
262 |         String[] statLines = statString.split("\n");
263 |         for (String line : statLines) {
264 |           lines.add(line);
265 |         }
266 |       }
267 | 
268 |       lines.add("Frame: " + previewWidth + "x" + previewHeight);
269 |       lines.add("Crop: " + copy.getWidth() + "x" + copy.getHeight());
270 |       lines.add("View: " + canvas.getWidth() + "x" + canvas.getHeight());
271 |       lines.add("Rotation: " + sensorOrientation);
272 |       lines.add("Inference time: " + lastProcessingTimeMs + "ms");
273 | 
274 |       borderedText.drawLines(canvas, 10, canvas.getHeight() - 10, lines);
275 |     }
276 |   }
277 | }
278 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/DetectorActivity.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2016 The TensorFlow Authors. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *       http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | package org.tensorflow.demo;
 18 | 
 19 | import android.graphics.Bitmap;
 20 | import android.graphics.Bitmap.Config;
 21 | import android.graphics.Canvas;
 22 | import android.graphics.Color;
 23 | import android.graphics.Matrix;
 24 | import android.graphics.Paint;
 25 | import android.graphics.Paint.Style;
 26 | import android.graphics.RectF;
 27 | import android.graphics.Typeface;
 28 | import android.media.Image;
 29 | import android.media.Image.Plane;
 30 | import android.media.ImageReader;
 31 | import android.media.ImageReader.OnImageAvailableListener;
 32 | import android.os.SystemClock;
 33 | import android.os.Trace;
 34 | import android.util.Size;
 35 | import android.util.TypedValue;
 36 | import android.view.Display;
 37 | import java.util.LinkedList;
 38 | import java.util.List;
 39 | import java.util.Vector;
 40 | import org.tensorflow.demo.OverlayView.DrawCallback;
 41 | import org.tensorflow.demo.env.BorderedText;
 42 | import org.tensorflow.demo.env.ImageUtils;
 43 | import org.tensorflow.demo.env.Logger;
 44 | import org.tensorflow.demo.tracking.MultiBoxTracker;
 45 | import org.tensorflow.demo.R;
 46 | 
 47 | /**
 48 |  * An activity that uses a TensorFlowMultiBoxDetector and ObjectTracker to detect and then track
 49 |  * objects.
 50 |  */
 51 | public class DetectorActivity extends CameraActivity implements OnImageAvailableListener {
 52 |   private static final Logger LOGGER = new Logger();
 53 | 
 54 |   // Configuration values for the prepackaged multibox model.
 55 |   private static final int MB_INPUT_SIZE = 224;
 56 |   private static final int MB_IMAGE_MEAN = 128;
 57 |   private static final float MB_IMAGE_STD = 128;
 58 |   private static final String MB_INPUT_NAME = "ResizeBilinear";
 59 |   private static final String MB_OUTPUT_LOCATIONS_NAME = "output_locations/Reshape";
 60 |   private static final String MB_OUTPUT_SCORES_NAME = "output_scores/Reshape";
 61 |   private static final String MB_MODEL_FILE = "file:///android_asset/multibox_model.pb";
 62 |   private static final String MB_LOCATION_FILE =
 63 |       "file:///android_asset/multibox_location_priors.txt";
 64 | 
 65 |   // Configuration values for tiny-yolo-voc. Note that the graph is not included with TensorFlow and
 66 |   // must be manually placed in the assets/ directory by the user.
 67 |   // Graphs and models downloaded from http://pjreddie.com/darknet/yolo/ may be converted e.g. via
 68 |   // DarkFlow (https://github.com/thtrieu/darkflow). Sample command:
 69 |   // ./flow --model cfg/tiny-yolo-voc.cfg --load bin/tiny-yolo-voc.weights --savepb --verbalise=True
 70 |   private static final String YOLO_MODEL_FILE = "file:///android_asset/graph-tiny-yolo-voc.pb";
 71 |   private static final int YOLO_INPUT_SIZE = 416;
 72 |   private static final String YOLO_INPUT_NAME = "input";
 73 |   private static final String YOLO_OUTPUT_NAMES = "output";
 74 |   private static final int YOLO_BLOCK_SIZE = 32;
 75 | 
 76 |   // Default to the included multibox model.
 77 |   private static final boolean USE_YOLO = false;
 78 | 
 79 |   private static final int CROP_SIZE = USE_YOLO ? YOLO_INPUT_SIZE : MB_INPUT_SIZE;
 80 | 
 81 |   // Minimum detection confidence to track a detection.
 82 |   private static final float MINIMUM_CONFIDENCE = USE_YOLO ? 0.25f : 0.1f;
 83 | 
 84 |   private static final boolean MAINTAIN_ASPECT = USE_YOLO;
 85 | 
 86 |   private static final boolean SAVE_PREVIEW_BITMAP = false;
 87 |   private static final float TEXT_SIZE_DIP = 10;
 88 | 
 89 |   private Integer sensorOrientation;
 90 | 
 91 |   private Classifier detector;
 92 | 
 93 |   private int previewWidth = 0;
 94 |   private int previewHeight = 0;
 95 |   private byte[][] yuvBytes;
 96 |   private int[] rgbBytes = null;
 97 |   private Bitmap rgbFrameBitmap = null;
 98 |   private Bitmap croppedBitmap = null;
 99 | 
100 |   private boolean computing = false;
101 | 
102 |   private long timestamp = 0;
103 | 
104 |   private Matrix frameToCropTransform;
105 |   private Matrix cropToFrameTransform;
106 | 
107 |   private Bitmap cropCopyBitmap;
108 | 
109 |   private MultiBoxTracker tracker;
110 | 
111 |   private byte[] luminance;
112 | 
113 |   private BorderedText borderedText;
114 | 
115 |   private long lastProcessingTimeMs;
116 | 
117 |   @Override
118 |   public void onPreviewSizeChosen(final Size size, final int rotation) {
119 |     final float textSizePx =
120 |         TypedValue.applyDimension(
121 |             TypedValue.COMPLEX_UNIT_DIP, TEXT_SIZE_DIP, getResources().getDisplayMetrics());
122 |     borderedText = new BorderedText(textSizePx);
123 |     borderedText.setTypeface(Typeface.MONOSPACE);
124 | 
125 |     tracker = new MultiBoxTracker(getResources().getDisplayMetrics());
126 | 
127 |     if (USE_YOLO) {
128 |       detector =
129 |           TensorFlowYoloDetector.create(
130 |               getAssets(),
131 |               YOLO_MODEL_FILE,
132 |               YOLO_INPUT_SIZE,
133 |               YOLO_INPUT_NAME,
134 |               YOLO_OUTPUT_NAMES,
135 |               YOLO_BLOCK_SIZE);
136 |     } else {
137 |       detector =
138 |           TensorFlowMultiBoxDetector.create(
139 |               getAssets(),
140 |               MB_MODEL_FILE,
141 |               MB_LOCATION_FILE,
142 |               MB_IMAGE_MEAN,
143 |               MB_IMAGE_STD,
144 |               MB_INPUT_NAME,
145 |               MB_OUTPUT_LOCATIONS_NAME,
146 |               MB_OUTPUT_SCORES_NAME);
147 |     }
148 | 
149 |     previewWidth = size.getWidth();
150 |     previewHeight = size.getHeight();
151 | 
152 |     final Display display = getWindowManager().getDefaultDisplay();
153 |     final int screenOrientation = display.getRotation();
154 | 
155 |     LOGGER.i("Sensor orientation: %d, Screen orientation: %d", rotation, screenOrientation);
156 | 
157 |     sensorOrientation = rotation + screenOrientation;
158 | 
159 |     LOGGER.i("Initializing at size %dx%d", previewWidth, previewHeight);
160 |     rgbBytes = new int[previewWidth * previewHeight];
161 |     rgbFrameBitmap = Bitmap.createBitmap(previewWidth, previewHeight, Config.ARGB_8888);
162 |     croppedBitmap = Bitmap.createBitmap(CROP_SIZE, CROP_SIZE, Config.ARGB_8888);
163 | 
164 |     frameToCropTransform =
165 |         ImageUtils.getTransformationMatrix(
166 |             previewWidth, previewHeight,
167 |             CROP_SIZE, CROP_SIZE,
168 |             sensorOrientation, MAINTAIN_ASPECT);
169 | 
170 |     cropToFrameTransform = new Matrix();
171 |     frameToCropTransform.invert(cropToFrameTransform);
172 |     yuvBytes = new byte[3][];
173 | 
174 |     trackingOverlay = (OverlayView) findViewById(R.id.tracking_overlay);
175 |     trackingOverlay.addCallback(
176 |         new DrawCallback() {
177 |           @Override
178 |           public void drawCallback(final Canvas canvas) {
179 |             tracker.draw(canvas);
180 |             if (isDebug()) {
181 |               tracker.drawDebug(canvas);
182 |             }
183 |           }
184 |         });
185 | 
186 |     addCallback(
187 |         new DrawCallback() {
188 |           @Override
189 |           public void drawCallback(final Canvas canvas) {
190 |             if (!isDebug()) {
191 |               return;
192 |             }
193 |             final Bitmap copy = cropCopyBitmap;
194 |             if (copy == null) {
195 |               return;
196 |             }
197 | 
198 |             final int backgroundColor = Color.argb(100, 0, 0, 0);
199 |             canvas.drawColor(backgroundColor);
200 | 
201 |             final Matrix matrix = new Matrix();
202 |             final float scaleFactor = 2;
203 |             matrix.postScale(scaleFactor, scaleFactor);
204 |             matrix.postTranslate(
205 |                 canvas.getWidth() - copy.getWidth() * scaleFactor,
206 |                 canvas.getHeight() - copy.getHeight() * scaleFactor);
207 |             canvas.drawBitmap(copy, matrix, new Paint());
208 | 
209 |             final Vector<String> lines = new Vector<String>();
210 |             if (detector != null) {
211 |               final String statString = detector.getStatString();
212 |               final String[] statLines = statString.split("\n");
213 |               for (final String line : statLines) {
214 |                 lines.add(line);
215 |               }
216 |             }
217 |             lines.add("");
218 | 
219 |             lines.add("Frame: " + previewWidth + "x" + previewHeight);
220 |             lines.add("Crop: " + copy.getWidth() + "x" + copy.getHeight());
221 |             lines.add("View: " + canvas.getWidth() + "x" + canvas.getHeight());
222 |             lines.add("Rotation: " + sensorOrientation);
223 |             lines.add("Inference time: " + lastProcessingTimeMs + "ms");
224 | 
225 |             borderedText.drawLines(canvas, 10, canvas.getHeight() - 10, lines);
226 |           }
227 |         });
228 |   }
229 | 
230 |   OverlayView trackingOverlay;
231 | 
232 |   @Override
233 |   public void onImageAvailable(final ImageReader reader) {
234 |     Image image = null;
235 | 
236 |     ++timestamp;
237 |     final long currTimestamp = timestamp;
238 | 
239 |     try {
240 |       image = reader.acquireLatestImage();
241 | 
242 |       if (image == null) {
243 |         return;
244 |       }
245 | 
246 |       Trace.beginSection("imageAvailable");
247 | 
248 |       final Plane[] planes = image.getPlanes();
249 |       fillBytes(planes, yuvBytes);
250 | 
251 |       tracker.onFrame(
252 |           previewWidth,
253 |           previewHeight,
254 |           planes[0].getRowStride(),
255 |           sensorOrientation,
256 |           yuvBytes[0],
257 |           timestamp);
258 |       trackingOverlay.postInvalidate();
259 | 
260 |       // No mutex needed as this method is not reentrant.
261 |       if (computing) {
262 |         image.close();
263 |         return;
264 |       }
265 |       computing = true;
266 | 
267 |       final int yRowStride = planes[0].getRowStride();
268 |       final int uvRowStride = planes[1].getRowStride();
269 |       final int uvPixelStride = planes[1].getPixelStride();
270 |       ImageUtils.convertYUV420ToARGB8888(
271 |           yuvBytes[0],
272 |           yuvBytes[1],
273 |           yuvBytes[2],
274 |           rgbBytes,
275 |           previewWidth,
276 |           previewHeight,
277 |           yRowStride,
278 |           uvRowStride,
279 |           uvPixelStride,
280 |           false);
281 | 
282 |       image.close();
283 |     } catch (final Exception e) {
284 |       if (image != null) {
285 |         image.close();
286 |       }
287 |       LOGGER.e(e, "Exception!");
288 |       Trace.endSection();
289 |       return;
290 |     }
291 | 
292 |     rgbFrameBitmap.setPixels(rgbBytes, 0, previewWidth, 0, 0, previewWidth, previewHeight);
293 |     final Canvas canvas = new Canvas(croppedBitmap);
294 |     canvas.drawBitmap(rgbFrameBitmap, frameToCropTransform, null);
295 | 
296 |     // For examining the actual TF input.
297 |     if (SAVE_PREVIEW_BITMAP) {
298 |       ImageUtils.saveBitmap(croppedBitmap);
299 |     }
300 | 
301 |     if (luminance == null) {
302 |       luminance = new byte[yuvBytes[0].length];
303 |     }
304 |     System.arraycopy(yuvBytes[0], 0, luminance, 0, luminance.length);
305 | 
306 |     runInBackground(
307 |         new Runnable() {
308 |           @Override
309 |           public void run() {
310 |             final long startTime = SystemClock.uptimeMillis();
311 |             final List<Classifier.Recognition> results = detector.recognizeImage(croppedBitmap);
312 |             lastProcessingTimeMs = SystemClock.uptimeMillis() - startTime;
313 | 
314 |             cropCopyBitmap = Bitmap.createBitmap(croppedBitmap);
315 |             final Canvas canvas = new Canvas(cropCopyBitmap);
316 |             final Paint paint = new Paint();
317 |             paint.setColor(Color.RED);
318 |             paint.setStyle(Style.STROKE);
319 |             paint.setStrokeWidth(2.0f);
320 | 
321 |             final List<Classifier.Recognition> mappedRecognitions =
322 |                 new LinkedList<Classifier.Recognition>();
323 | 
324 |             for (final Classifier.Recognition result : results) {
325 |               final RectF location = result.getLocation();
326 |               if (location != null && result.getConfidence() >= MINIMUM_CONFIDENCE) {
327 |                 canvas.drawRect(location, paint);
328 | 
329 |                 cropToFrameTransform.mapRect(location);
330 |                 result.setLocation(location);
331 |                 mappedRecognitions.add(result);
332 |               }
333 |             }
334 | 
335 |             tracker.trackResults(mappedRecognitions, luminance, currTimestamp);
336 |             trackingOverlay.postInvalidate();
337 | 
338 |             requestRender();
339 |             computing = false;
340 |           }
341 |         });
342 | 
343 |     Trace.endSection();
344 |   }
345 | 
346 |   @Override
347 |   protected int getLayoutId() {
348 |     return R.layout.camera_connection_fragment_tracking;
349 |   }
350 | 
351 |   @Override
352 |   protected int getDesiredPreviewFrameSize() {
353 |     return CROP_SIZE;
354 |   }
355 | 
356 |   @Override
357 |   public void onSetDebug(final boolean debug) {
358 |     detector.enableStatLogging(debug);
359 |   }
360 | }
361 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/OverlayView.java:
--------------------------------------------------------------------------------
 1 | /* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 2 | 
 3 | Licensed under the Apache License, Version 2.0 (the "License");
 4 | you may not use this file except in compliance with the License.
 5 | You may obtain a copy of the License at
 6 | 
 7 |     http://www.apache.org/licenses/LICENSE-2.0
 8 | 
 9 | Unless required by applicable law or agreed to in writing, software
10 | distributed under the License is distributed on an "AS IS" BASIS,
11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | See the License for the specific language governing permissions and
13 | limitations under the License.
14 | ==============================================================================*/
15 | 
16 | package org.tensorflow.demo;
17 | 
18 | import android.content.Context;
19 | import android.graphics.Canvas;
20 | import android.util.AttributeSet;
21 | import android.view.View;
22 | import java.util.LinkedList;
23 | import java.util.List;
24 | 
25 | /**
26 |  * A simple View providing a render callback to other classes.
27 |  */
28 | public class OverlayView extends View {
29 |   private final List<DrawCallback> callbacks = new LinkedList<DrawCallback>();
30 | 
31 |   public OverlayView(final Context context, final AttributeSet attrs) {
32 |     super(context, attrs);
33 |   }
34 | 
35 |   /**
36 |    * Interface defining the callback for client classes.
37 |    */
38 |   public interface DrawCallback {
39 |     public void drawCallback(final Canvas canvas);
40 |   }
41 | 
42 |   public void addCallback(final DrawCallback callback) {
43 |     callbacks.add(callback);
44 |   }
45 | 
46 |   @Override
47 |   public synchronized void draw(final Canvas canvas) {
48 |     for (final DrawCallback callback : callbacks) {
49 |       callback.drawCallback(canvas);
50 |     }
51 |   }
52 | }
53 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/PhotoStylizeActivity.java:
--------------------------------------------------------------------------------
  1 | package org.tensorflow.demo;
  2 | 
  3 | import android.app.Activity;
  4 | import android.content.Context;
  5 | import android.content.Intent;
  6 | import android.graphics.Bitmap;
  7 | import android.graphics.Canvas;
  8 | import android.graphics.Color;
  9 | import android.graphics.Paint;
 10 | import android.graphics.Rect;
 11 | import android.net.Uri;
 12 | import android.os.AsyncTask;
 13 | import android.os.Bundle;
 14 | import android.os.Environment;
 15 | import android.view.MotionEvent;
 16 | import android.view.View;
 17 | import android.view.ViewGroup;
 18 | import android.webkit.MimeTypeMap;
 19 | import android.widget.BaseAdapter;
 20 | import android.widget.Button;
 21 | import android.widget.GridView;
 22 | import android.widget.ImageView;
 23 | import android.widget.ProgressBar;
 24 | import android.widget.Toast;
 25 | 
 26 | import org.tensorflow.contrib.android.TensorFlowInferenceInterface;
 27 | import org.tensorflow.demo.env.ImageUtils;
 28 | import org.tensorflow.demo.env.Logger;
 29 | import org.tensorflow.demo.util.BitmapUtil;
 30 | import org.tensorflow.demo.util.FileUtil;
 31 | import org.tensorflow.demo.util.MediaScanner;
 32 | 
 33 | import java.io.File;
 34 | import java.util.ArrayList;
 35 | 
 36 | import static org.tensorflow.demo.StylizeActivity.getBitmapFromAsset;
 37 | 
 38 | public class PhotoStylizeActivity extends Activity {
 39 | 
 40 |     static {
 41 |         System.loadLibrary("tensorflow_demo");
 42 |     }
 43 | 
 44 |     private static final Logger LOGGER = new Logger();
 45 | 
 46 |     private static final String MODEL_FILE = "file:///android_asset/stylize_quantized.pb";
 47 |     private static final String INPUT_NODE = "input";
 48 |     private static final String STYLE_NODE = "style_num";
 49 |     private static final String OUTPUT_NODE = "transformer/expand/conv3/conv/Sigmoid";
 50 |     private static final int NUM_STYLES = 26;
 51 | 
 52 |     // Whether to actively manipulate non-selected sliders so that sum of activations always appears
 53 |     // to be 1.0. The actual style input tensor will be normalized to sum to 1.0 regardless.
 54 |     private static final boolean NORMALIZE_SLIDERS = true;
 55 | 
 56 |     private static final boolean DEBUG_MODEL = false;
 57 | 
 58 |     private static final int[] SIZES = {32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024};
 59 | 
 60 |     // Start at a medium size, but let the user step up through smaller sizes so they don't get
 61 |     // immediately stuck processing a large image.
 62 |     private int desiredSizeIndex = -1;
 63 |     private int desiredSize = 256;
 64 | 
 65 |     private final float[] styleVals = new float[NUM_STYLES];
 66 | 
 67 |     private int frameNum = 0;
 68 | 
 69 |     private Bitmap srcBitmap;
 70 |     private Bitmap dstBitmap;
 71 | 
 72 |     private TensorFlowInferenceInterface inferenceInterface;
 73 | 
 74 |     private int lastOtherStyle = 1;
 75 | 
 76 |     private boolean allZero = false;
 77 | 
 78 |     private ImageGridAdapter adapter;
 79 |     private GridView grid;
 80 |     private ImageView ivPhoto;
 81 |     private ProgressBar progressBar;
 82 |     private View viewMask;
 83 | 
 84 |     private StylizeTask stylizeTask = new StylizeTask();
 85 | 
 86 | 
 87 |     @Override
 88 |     protected void onCreate(Bundle savedInstanceState) {
 89 |         super.onCreate(savedInstanceState);
 90 |         setContentView(R.layout.activity_photo_stylize);
 91 | 
 92 |         grid = (GridView) findViewById(R.id.grid_layout);
 93 |         ivPhoto = (ImageView) findViewById(R.id.iv_photo);
 94 |         progressBar = (ProgressBar) findViewById(R.id.progress_bar);
 95 |         viewMask = findViewById(R.id.view_mask);
 96 | 
 97 |         init();
 98 |     }
 99 | 
100 |     @Override
101 |     protected void onDestroy() {
102 |         super.onDestroy();
103 |         if (stylizeTask.getStatus() != AsyncTask.Status.FINISHED) {
104 |             stylizeTask.cancel(true);
105 |             stylizeTask = null;
106 |         }
107 |     }
108 | 
109 |     @Override
110 |     public void onWindowFocusChanged(boolean hasFocus) {
111 |         super.onWindowFocusChanged(hasFocus);
112 |         if (hasFocus) {
113 |             srcBitmap = getBitmapFromImageView(ivPhoto);
114 |             dstBitmap = Bitmap.createBitmap(srcBitmap);
115 |         }
116 |     }
117 | 
118 |     private void init() {
119 |         inferenceInterface = new TensorFlowInferenceInterface(getAssets(), MODEL_FILE);
120 |         initListener();
121 |         initStyleGrid();
122 |     }
123 | 
124 |     private void initListener() {
125 |         findViewById(R.id.btn_reset).setOnClickListener(new View.OnClickListener() {
126 |             @Override
127 |             public void onClick(View v) {
128 |                 if (stylizeTask.getStatus() != AsyncTask.Status.FINISHED) {
129 |                     stylizeTask.cancel(true);
130 |                 }
131 |                 ivPhoto.setImageBitmap(srcBitmap);
132 |             }
133 |         });
134 | 
135 |         findViewById(R.id.btn_stylize).setOnClickListener(new View.OnClickListener() {
136 |             @Override
137 |             public void onClick(View v) {
138 |                 if (stylizeTask.getStatus() == AsyncTask.Status.FINISHED) {
139 |                     stylizeTask = new StylizeTask();
140 |                 }
141 |                 if (stylizeTask.getStatus() != AsyncTask.Status.RUNNING) {
142 |                     progressBar.setVisibility(View.VISIBLE);
143 |                     viewMask.setVisibility(View.VISIBLE);
144 |                     stylizeTask.execute();
145 |                 }
146 |             }
147 |         });
148 | 
149 |         ivPhoto.setOnClickListener(new View.OnClickListener() {
150 |             @Override
151 |             public void onClick(View v) {
152 |                 startFileManager();
153 |             }
154 |         });
155 |     }
156 | 
157 |     /**
158 |      * 初始化Style表格
159 |      */
160 |     private void initStyleGrid() {
161 |         adapter = new ImageGridAdapter();
162 |         grid.setAdapter(adapter);
163 |         grid.setOnTouchListener(gridTouchAdapter);
164 | 
165 |         setStyle(adapter.items[0], 1.0f);
166 |     }
167 | 
168 |     /**
169 |      * 获取ImageView中的Bitmap
170 |      * @param imageView
171 |      * @return
172 |      */
173 |     private Bitmap getBitmapFromImageView(ImageView imageView) {
174 |         imageView.setDrawingCacheEnabled(true);
175 |         Bitmap bitmap = Bitmap.createBitmap(imageView.getDrawingCache());
176 |         imageView.setDrawingCacheEnabled(false);
177 |         return bitmap;
178 |     }
179 | 
180 |     /**
181 |      * 打开文件管理器
182 |      */
183 |     private void startFileManager() {
184 |         Intent intent = new Intent(Intent.ACTION_GET_CONTENT);
185 |         intent.setType("image/*");
186 |         intent.addCategory(Intent.CATEGORY_OPENABLE);
187 |         startActivityForResult(intent, 1024);
188 |     }
189 | 
190 |     @Override
191 |     protected void onActivityResult(int requestCode, int resultCode, Intent data) {
192 |         super.onActivityResult(requestCode, resultCode, data);
193 |         if (resultCode == RESULT_OK) {
194 |             if (requestCode == 1024) {
195 |                 Uri uri = data.getData();
196 |                 String path = FileUtil.getFileAbsolutePath(PhotoStylizeActivity.this, uri);
197 |                 if (path != null) {
198 |                     srcBitmap = BitmapUtil.decodeSampledBitmapFromFilePath(path, ivPhoto.getWidth(), ivPhoto.getHeight());
199 |                     ivPhoto.setImageBitmap(srcBitmap);
200 |                 } else {
201 |                     Toast.makeText(this, "cannot get path", Toast.LENGTH_SHORT).show();
202 |                 }
203 |             }
204 |         }
205 |     }
206 | 
207 |     /**
208 |      * 保存图片后，调用MediaScanner通知系统图库刷新
209 |      * @param fileName
210 |      */
211 |     private void callMediaScanner(String fileName) {
212 |         String root = Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "tensorflow";
213 |         String filePath = root + "/" + fileName;
214 | 
215 |         MediaScanner mediaScanner = new MediaScanner(getApplicationContext());
216 |         String[] filePaths = new String[]{filePath};
217 |         String[] mimeTypes = new String[]{MimeTypeMap.getSingleton().getMimeTypeFromExtension("png")};
218 |         mediaScanner.scanFiles(filePaths, mimeTypes);
219 |     }
220 | 
221 |     /**
222 |      * 设置Style
223 |      * @param slider
224 |      * @param value
225 |      */
226 |     private void setStyle(final ImageSlider slider, final float value) {
227 |         slider.setValue(value);
228 | 
229 |         if (NORMALIZE_SLIDERS) {
230 |             // Slider vals correspond directly to the input tensor vals, and normalization is visually
231 |             // maintained by remanipulating non-selected sliders.
232 |             float otherSum = 0.0f;
233 | 
234 |             for (int i = 0; i < NUM_STYLES; ++i) {
235 |                 if (adapter.items[i] != slider) {
236 |                     otherSum += adapter.items[i].value;
237 |                 }
238 |             }
239 | 
240 |             if (otherSum > 0.0) {
241 |                 float highestOtherVal = 0;
242 |                 final float factor = otherSum > 0.0f ? (1.0f - value) / otherSum : 0.0f;
243 |                 for (int i = 0; i < NUM_STYLES; ++i) {
244 |                     final ImageSlider child = adapter.items[i];
245 |                     if (child == slider) {
246 |                         continue;
247 |                     }
248 |                     final float newVal = child.value * factor;
249 |                     child.setValue(newVal > 0.01f ? newVal : 0.0f);
250 | 
251 |                     if (child.value > highestOtherVal) {
252 |                         lastOtherStyle = i;
253 |                         highestOtherVal = child.value;
254 |                     }
255 |                 }
256 |             } else {
257 |                 // Everything else is 0, so just pick a suitable slider to push up when the
258 |                 // selected one goes down.
259 |                 if (adapter.items[lastOtherStyle] == slider) {
260 |                     lastOtherStyle = (lastOtherStyle + 1) % NUM_STYLES;
261 |                 }
262 |                 adapter.items[lastOtherStyle].setValue(1.0f - value);
263 |             }
264 |         }
265 | 
266 |         final boolean lastAllZero = allZero;
267 |         float sum = 0.0f;
268 |         for (int i = 0; i < NUM_STYLES; ++i) {
269 |             sum += adapter.items[i].value;
270 |         }
271 |         allZero = sum == 0.0f;
272 | 
273 |         // Now update the values used for the input tensor. If nothing is set, mix in everything
274 |         // equally. Otherwise everything is normalized to sum to 1.0.
275 |         for (int i = 0; i < NUM_STYLES; ++i) {
276 |             styleVals[i] = allZero ? 1.0f / NUM_STYLES : adapter.items[i].value / sum;
277 | 
278 |             if (lastAllZero != allZero) {
279 |                 adapter.items[i].postInvalidate();
280 |             }
281 |         }
282 |     }
283 | 
284 |     /**
285 |      * 对指定Bitmap进行Stylize
286 |      * @param bitmap
287 |      * @return
288 |      */
289 |     private Bitmap stylizeImage(final Bitmap bitmap) {
290 |         desiredSize = bitmap.getWidth();
291 |         int[] intValues = new int[desiredSize * desiredSize];
292 |         float[] floatValues = new float[desiredSize * desiredSize * 3];
293 |         ++frameNum;
294 |         bitmap.getPixels(intValues, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
295 | 
296 |         if (DEBUG_MODEL) {
297 |             // Create a white square that steps through a black background 1 pixel per frame.
298 |             final int centerX = (frameNum + bitmap.getWidth() / 2) % bitmap.getWidth();
299 |             final int centerY = bitmap.getHeight() / 2;
300 |             final int squareSize = 10;
301 |             for (int i = 0; i < intValues.length; ++i) {
302 |                 final int x = i % bitmap.getWidth();
303 |                 final int y = i / bitmap.getHeight();
304 |                 final float val =
305 |                         Math.abs(x - centerX) < squareSize && Math.abs(y - centerY) < squareSize ? 1.0f : 0.0f;
306 |                 floatValues[i * 3] = val;
307 |                 floatValues[i * 3 + 1] = val;
308 |                 floatValues[i * 3 + 2] = val;
309 |             }
310 |         } else {
311 |             for (int i = 0; i < intValues.length; ++i) {
312 |                 final int val = intValues[i];
313 |                 floatValues[i * 3] = ((val >> 16) & 0xFF) / 255.0f;
314 |                 floatValues[i * 3 + 1] = ((val >> 8) & 0xFF) / 255.0f;
315 |                 floatValues[i * 3 + 2] = (val & 0xFF) / 255.0f;
316 |             }
317 |         }
318 | 
319 |         // Copy the input data into TensorFlow.
320 |         inferenceInterface.feed(
321 |                 INPUT_NODE, floatValues, 1, bitmap.getWidth(), bitmap.getHeight(), 3);
322 |         inferenceInterface.feed(STYLE_NODE, styleVals, NUM_STYLES);
323 | 
324 |         inferenceInterface.run(new String[] {OUTPUT_NODE}, false);
325 |         inferenceInterface.fetch(OUTPUT_NODE, floatValues);
326 | 
327 |         for (int i = 0; i < intValues.length; ++i) {
328 |             intValues[i] =
329 |                     0xFF000000
330 |                             | (((int) (floatValues[i * 3] * 255)) << 16)
331 |                             | (((int) (floatValues[i * 3 + 1] * 255)) << 8)
332 |                             | ((int) (floatValues[i * 3 + 2] * 255));
333 |         }
334 | 
335 |         //bitmap.setPixels(intValues, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
336 |         Bitmap newBitmap = Bitmap.createBitmap(bitmap);
337 |         newBitmap.setPixels(intValues, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
338 |         return newBitmap;
339 |     }
340 | 
341 |     /**
342 |      * 监听Style表格中的ImageSlider的滑动。根据滑动的百分比切换Style。可以多种Style混合。
343 |      */
344 |     private final View.OnTouchListener gridTouchAdapter =
345 |             new View.OnTouchListener() {
346 |                 ImageSlider slider = null;
347 | 
348 |                 @Override
349 |                 public boolean onTouch(final View v, final MotionEvent event) {
350 |                     switch (event.getActionMasked()) {
351 |                         case MotionEvent.ACTION_DOWN:
352 |                             for (int i = 0; i < NUM_STYLES; ++i) {
353 |                                 final ImageSlider child = adapter.items[i];
354 |                                 final Rect rect = new Rect();
355 |                                 child.getHitRect(rect);
356 |                                 if (rect.contains((int) event.getX(), (int) event.getY())) {
357 |                                     slider = child;
358 |                                     slider.setHilighted(true);
359 |                                 }
360 |                             }
361 |                             break;
362 | 
363 |                         case MotionEvent.ACTION_MOVE:
364 |                             if (slider != null) {
365 |                                 final Rect rect = new Rect();
366 |                                 slider.getHitRect(rect);
367 | 
368 |                                 final float newSliderVal =
369 |                                         (float)
370 |                                                 Math.min(
371 |                                                         1.0,
372 |                                                         Math.max(
373 |                                                                 0.0, 1.0 - (event.getY() - slider.getTop()) / slider.getHeight()));
374 | 
375 |                                 setStyle(slider, newSliderVal);
376 |                             }
377 |                             break;
378 | 
379 |                         case MotionEvent.ACTION_UP:
380 |                             if (slider != null) {
381 |                                 slider.setHilighted(false);
382 |                                 slider = null;
383 |                             }
384 |                             break;
385 | 
386 |                         default: // fall out
387 | 
388 |                     }
389 |                     return true;
390 |                 }
391 |             };
392 | 
393 |     /**
394 |      * Style表格的Item控件。
395 |      */
396 |     private class ImageSlider extends ImageView {
397 |         private float value = 0.0f;
398 |         private boolean hilighted = false;
399 | 
400 |         private final Paint boxPaint;
401 |         private final Paint linePaint;
402 | 
403 |         public ImageSlider(final Context context) {
404 |             super(context);
405 |             value = 0.0f;
406 | 
407 |             boxPaint = new Paint();
408 |             boxPaint.setColor(Color.BLACK);
409 |             boxPaint.setAlpha(128);
410 | 
411 |             linePaint = new Paint();
412 |             linePaint.setColor(Color.WHITE);
413 |             linePaint.setStrokeWidth(10.0f);
414 |             linePaint.setStyle(Paint.Style.STROKE);
415 |         }
416 | 
417 |         @Override
418 |         public void onDraw(final Canvas canvas) {
419 |             super.onDraw(canvas);
420 |             final float y = (1.0f - value) * canvas.getHeight();
421 | 
422 |             // If all sliders are zero, don't bother shading anything.
423 |             if (!allZero) {
424 |                 canvas.drawRect(0, 0, canvas.getWidth(), y, boxPaint);
425 |             }
426 | 
427 |             if (value > 0.0f) {
428 |                 canvas.drawLine(0, y, canvas.getWidth(), y, linePaint);
429 |             }
430 | 
431 |             if (hilighted) {
432 |                 canvas.drawRect(0, 0, getWidth(), getHeight(), linePaint);
433 |             }
434 |         }
435 | 
436 |         @Override
437 |         protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
438 |             super.onMeasure(widthMeasureSpec, heightMeasureSpec);
439 |             setMeasuredDimension(getMeasuredWidth(), getMeasuredWidth());
440 |         }
441 | 
442 |         public void setValue(final float value) {
443 |             this.value = value;
444 |             postInvalidate();
445 |         }
446 | 
447 |         public void setHilighted(final boolean highlighted) {
448 |             this.hilighted = highlighted;
449 |             this.postInvalidate();
450 |         }
451 |     }
452 | 
453 |     /**
454 |      * Style表格适配器
455 |      */
456 |     private class ImageGridAdapter extends BaseAdapter {
457 |         final ImageSlider[] items = new ImageSlider[NUM_STYLES];
458 |         final ArrayList<Button> buttons = new ArrayList<>();
459 | 
460 |         {
461 |             final Button sizeButton =
462 |                     new Button(PhotoStylizeActivity.this) {
463 |                         @Override
464 |                         protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
465 |                             super.onMeasure(widthMeasureSpec, heightMeasureSpec);
466 |                             setMeasuredDimension(getMeasuredWidth(), getMeasuredWidth());
467 |                         }
468 |                     };
469 |             sizeButton.setText(String.valueOf(desiredSize));
470 |             sizeButton.setOnClickListener(
471 |                     new View.OnClickListener() {
472 |                         @Override
473 |                         public void onClick(final View v) {
474 |                             desiredSizeIndex = (desiredSizeIndex + 1) % SIZES.length;
475 |                             desiredSize = SIZES[desiredSizeIndex];
476 |                             sizeButton.setText(String.valueOf(desiredSize));
477 |                             sizeButton.postInvalidate();
478 |                         }
479 |                     });
480 | 
481 |             final Button saveButton =
482 |                     new Button(PhotoStylizeActivity.this) {
483 |                         @Override
484 |                         protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
485 |                             super.onMeasure(widthMeasureSpec, heightMeasureSpec);
486 |                             setMeasuredDimension(getMeasuredWidth(), getMeasuredWidth());
487 |                         }
488 |                     };
489 |             saveButton.setText("Save");
490 |             saveButton.setOnClickListener(
491 |                     new View.OnClickListener() {
492 |                         @Override
493 |                         public void onClick(final View v) {
494 |                             if (dstBitmap != null) {
495 |                                 long timestamp = System.currentTimeMillis();
496 |                                 String fileName = "stylized_" + timestamp + ".png";
497 |                                 ImageUtils.saveBitmap(dstBitmap, fileName);
498 |                                 callMediaScanner(fileName);
499 | 
500 |                                 Toast.makeText(
501 |                                         PhotoStylizeActivity.this,
502 |                                         "Saved image to: /sdcard/tensorflow/" + fileName,
503 |                                         Toast.LENGTH_LONG)
504 |                                         .show();
505 |                             }
506 |                         }
507 |                     });
508 | 
509 |             buttons.add(sizeButton);
510 |             buttons.add(saveButton);
511 | 
512 |             for (int i = 0; i < NUM_STYLES; ++i) {
513 |                 LOGGER.v("Creating item %d", i);
514 | 
515 |                 if (items[i] == null) {
516 |                     final ImageSlider slider = new ImageSlider(PhotoStylizeActivity.this);
517 |                     final Bitmap bm =
518 |                             getBitmapFromAsset(PhotoStylizeActivity.this, "thumbnails/style" + i + ".jpg");
519 |                     slider.setImageBitmap(bm);
520 | 
521 |                     items[i] = slider;
522 |                 }
523 |             }
524 |         }
525 | 
526 |         @Override
527 |         public int getCount() {
528 |             return buttons.size() + NUM_STYLES;
529 |         }
530 | 
531 |         @Override
532 |         public Object getItem(final int position) {
533 |             if (position < buttons.size()) {
534 |                 return buttons.get(position);
535 |             } else {
536 |                 return items[position - buttons.size()];
537 |             }
538 |         }
539 | 
540 |         @Override
541 |         public long getItemId(final int position) {
542 |             return getItem(position).hashCode();
543 |         }
544 | 
545 |         @Override
546 |         public View getView(final int position, final View convertView, final ViewGroup parent) {
547 |             if (convertView != null) {
548 |                 return convertView;
549 |             }
550 |             return (View) getItem(position);
551 |         }
552 |     }
553 | 
554 |     /**
555 |      * 对图片进行Stylize的AsyncTask
556 |      */
557 |     private class StylizeTask extends AsyncTask<Bitmap, Void, Bitmap> {
558 | 
559 |         @Override
560 |         protected Bitmap doInBackground(Bitmap... params) {
561 |             return stylizeImage(srcBitmap);
562 |         }
563 | 
564 |         @Override
565 |         protected void onPostExecute(Bitmap bitmap) {
566 |             super.onPostExecute(bitmap);
567 |             progressBar.setVisibility(View.GONE);
568 |             viewMask.setVisibility(View.GONE);
569 |             dstBitmap = bitmap;
570 |             ivPhoto.setImageBitmap(dstBitmap);
571 |         }
572 |     }
573 | }
574 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/RecognitionScoreView.java:
--------------------------------------------------------------------------------
 1 | /* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
 2 | 
 3 | Licensed under the Apache License, Version 2.0 (the "License");
 4 | you may not use this file except in compliance with the License.
 5 | You may obtain a copy of the License at
 6 | 
 7 |     http://www.apache.org/licenses/LICENSE-2.0
 8 | 
 9 | Unless required by applicable law or agreed to in writing, software
10 | distributed under the License is distributed on an "AS IS" BASIS,
11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | See the License for the specific language governing permissions and
13 | limitations under the License.
14 | ==============================================================================*/
15 | 
16 | package org.tensorflow.demo;
17 | 
18 | import android.content.Context;
19 | import android.graphics.Canvas;
20 | import android.graphics.Paint;
21 | import android.util.AttributeSet;
22 | import android.util.TypedValue;
23 | import android.view.View;
24 | 
25 | import org.tensorflow.demo.Classifier.Recognition;
26 | 
27 | import java.util.List;
28 | 
29 | public class RecognitionScoreView extends View implements ResultsView {
30 |   private static final float TEXT_SIZE_DIP = 24;
31 |   private List<Recognition> results;
32 |   private final float textSizePx;
33 |   private final Paint fgPaint;
34 |   private final Paint bgPaint;
35 | 
36 |   public RecognitionScoreView(final Context context, final AttributeSet set) {
37 |     super(context, set);
38 | 
39 |     textSizePx =
40 |         TypedValue.applyDimension(
41 |             TypedValue.COMPLEX_UNIT_DIP, TEXT_SIZE_DIP, getResources().getDisplayMetrics());
42 |     fgPaint = new Paint();
43 |     fgPaint.setTextSize(textSizePx);
44 | 
45 |     bgPaint = new Paint();
46 |     bgPaint.setColor(0xcc4285f4);
47 |   }
48 | 
49 |   @Override
50 |   public void setResults(final List<Recognition> results) {
51 |     this.results = results;
52 |     postInvalidate();
53 |   }
54 | 
55 |   @Override
56 |   public void onDraw(final Canvas canvas) {
57 |     final int x = 10;
58 |     int y = (int) (fgPaint.getTextSize() * 1.5f);
59 | 
60 |     canvas.drawPaint(bgPaint);
61 | 
62 |     if (results != null) {
63 |       for (final Recognition recog : results) {
64 |         canvas.drawText(recog.getTitle() + ": " + recog.getConfidence(), x, y, fgPaint);
65 |         y += fgPaint.getTextSize() * 1.5f;
66 |       }
67 |     }
68 |   }
69 | }
70 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/ResultsView.java:
--------------------------------------------------------------------------------
 1 | /* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 2 | 
 3 | Licensed under the Apache License, Version 2.0 (the "License");
 4 | you may not use this file except in compliance with the License.
 5 | You may obtain a copy of the License at
 6 | 
 7 |     http://www.apache.org/licenses/LICENSE-2.0
 8 | 
 9 | Unless required by applicable law or agreed to in writing, software
10 | distributed under the License is distributed on an "AS IS" BASIS,
11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | See the License for the specific language governing permissions and
13 | limitations under the License.
14 | ==============================================================================*/
15 | 
16 | package org.tensorflow.demo;
17 | 
18 | import org.tensorflow.demo.Classifier.Recognition;
19 | 
20 | import java.util.List;
21 | 
22 | public interface ResultsView {
23 |   public void setResults(final List<Recognition> results);
24 | }
25 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/StylizeActivity.java:
--------------------------------------------------------------------------------
  1 | /*
  2 |  * Copyright 2017 The TensorFlow Authors. All Rights Reserved.
  3 |  *
  4 |  * Licensed under the Apache License, Version 2.0 (the "License");
  5 |  * you may not use this file except in compliance with the License.
  6 |  * You may obtain a copy of the License at
  7 |  *
  8 |  *       http://www.apache.org/licenses/LICENSE-2.0
  9 |  *
 10 |  * Unless required by applicable law or agreed to in writing, software
 11 |  * distributed under the License is distributed on an "AS IS" BASIS,
 12 |  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13 |  * See the License for the specific language governing permissions and
 14 |  * limitations under the License.
 15 |  */
 16 | 
 17 | package org.tensorflow.demo;
 18 | 
 19 | import android.content.Context;
 20 | import android.content.res.AssetManager;
 21 | import android.graphics.Bitmap;
 22 | import android.graphics.Bitmap.Config;
 23 | import android.graphics.BitmapFactory;
 24 | import android.graphics.Canvas;
 25 | import android.graphics.Color;
 26 | import android.graphics.Matrix;
 27 | import android.graphics.Paint;
 28 | import android.graphics.Paint.Style;
 29 | import android.graphics.Rect;
 30 | import android.graphics.Typeface;
 31 | import android.media.Image;
 32 | import android.media.Image.Plane;
 33 | import android.media.ImageReader;
 34 | import android.media.ImageReader.OnImageAvailableListener;
 35 | import android.os.Bundle;
 36 | import android.os.SystemClock;
 37 | import android.os.Trace;
 38 | import android.util.Size;
 39 | import android.util.TypedValue;
 40 | import android.view.Display;
 41 | import android.view.MotionEvent;
 42 | import android.view.View;
 43 | import android.view.View.OnClickListener;
 44 | import android.view.View.OnTouchListener;
 45 | import android.view.ViewGroup;
 46 | import android.widget.BaseAdapter;
 47 | import android.widget.Button;
 48 | import android.widget.GridView;
 49 | import android.widget.ImageView;
 50 | import android.widget.Toast;
 51 | import java.io.IOException;
 52 | import java.io.InputStream;
 53 | import java.util.ArrayList;
 54 | import java.util.Collections;
 55 | import java.util.Vector;
 56 | import org.tensorflow.contrib.android.TensorFlowInferenceInterface;
 57 | import org.tensorflow.demo.OverlayView.DrawCallback;
 58 | import org.tensorflow.demo.env.BorderedText;
 59 | import org.tensorflow.demo.env.ImageUtils;
 60 | import org.tensorflow.demo.env.Logger;
 61 | import org.tensorflow.demo.R;
 62 | 
 63 | /**
 64 |  * Sample activity that stylizes the camera preview according to "A Learned Representation For
 65 |  * Artistic Style" (https://arxiv.org/abs/1610.07629)
 66 |  */
 67 | public class StylizeActivity extends CameraActivity implements OnImageAvailableListener {
 68 |   static {
 69 |     System.loadLibrary("tensorflow_demo");
 70 |   }
 71 | 
 72 |   private static final Logger LOGGER = new Logger();
 73 | 
 74 |   private static final String MODEL_FILE = "file:///android_asset/stylize_quantized.pb";
 75 |   private static final String INPUT_NODE = "input";
 76 |   private static final String STYLE_NODE = "style_num";
 77 |   private static final String OUTPUT_NODE = "transformer/expand/conv3/conv/Sigmoid";
 78 |   private static final int NUM_STYLES = 26;
 79 | 
 80 |   private static final boolean SAVE_PREVIEW_BITMAP = false;
 81 | 
 82 |   // Whether to actively manipulate non-selected sliders so that sum of activations always appears
 83 |   // to be 1.0. The actual style input tensor will be normalized to sum to 1.0 regardless.
 84 |   private static final boolean NORMALIZE_SLIDERS = true;
 85 | 
 86 |   private static final float TEXT_SIZE_DIP = 12;
 87 | 
 88 |   private static final boolean DEBUG_MODEL = false;
 89 | 
 90 |   private static final int[] SIZES = {32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024};
 91 | 
 92 |   // Start at a medium size, but let the user step up through smaller sizes so they don't get
 93 |   // immediately stuck processing a large image.
 94 |   private int desiredSizeIndex = -1;
 95 |   private int desiredSize = 256;
 96 |   private int initializedSize = 0;
 97 | 
 98 |   private Integer sensorOrientation;
 99 | 
100 |   private int previewWidth = 0;
101 |   private int previewHeight = 0;
102 |   private byte[][] yuvBytes;
103 |   private int[] rgbBytes = null;
104 |   private Bitmap rgbFrameBitmap = null;
105 |   private Bitmap croppedBitmap = null;
106 | 
107 |   private final float[] styleVals = new float[NUM_STYLES];
108 |   private int[] intValues;
109 |   private float[] floatValues;
110 | 
111 |   private int frameNum = 0;
112 | 
113 |   private Bitmap cropCopyBitmap;
114 |   private Bitmap textureCopyBitmap;
115 | 
116 |   private boolean computing = false;
117 | 
118 |   private Matrix frameToCropTransform;
119 |   private Matrix cropToFrameTransform;
120 | 
121 |   private BorderedText borderedText;
122 | 
123 |   private long lastProcessingTimeMs;
124 | 
125 |   private TensorFlowInferenceInterface inferenceInterface;
126 | 
127 |   private int lastOtherStyle = 1;
128 | 
129 |   private boolean allZero = false;
130 | 
131 |   private ImageGridAdapter adapter;
132 |   private GridView grid;
133 | 
134 |   private final OnTouchListener gridTouchAdapter =
135 |       new OnTouchListener() {
136 |         ImageSlider slider = null;
137 | 
138 |         @Override
139 |         public boolean onTouch(final View v, final MotionEvent event) {
140 |           switch (event.getActionMasked()) {
141 |             case MotionEvent.ACTION_DOWN:
142 |               for (int i = 0; i < NUM_STYLES; ++i) {
143 |                 final ImageSlider child = adapter.items[i];
144 |                 final Rect rect = new Rect();
145 |                 child.getHitRect(rect);
146 |                 if (rect.contains((int) event.getX(), (int) event.getY())) {
147 |                   slider = child;
148 |                   slider.setHilighted(true);
149 |                 }
150 |               }
151 |               break;
152 | 
153 |             case MotionEvent.ACTION_MOVE:
154 |               if (slider != null) {
155 |                 final Rect rect = new Rect();
156 |                 slider.getHitRect(rect);
157 | 
158 |                 final float newSliderVal =
159 |                     (float)
160 |                         Math.min(
161 |                             1.0,
162 |                             Math.max(
163 |                                 0.0, 1.0 - (event.getY() - slider.getTop()) / slider.getHeight()));
164 | 
165 |                 setStyle(slider, newSliderVal);
166 |               }
167 |               break;
168 | 
169 |             case MotionEvent.ACTION_UP:
170 |               if (slider != null) {
171 |                 slider.setHilighted(false);
172 |                 slider = null;
173 |               }
174 |               break;
175 | 
176 |             default: // fall out
177 | 
178 |           }
179 |           return true;
180 |         }
181 |       };
182 | 
183 |   @Override
184 |   public void onCreate(final Bundle savedInstanceState) {
185 |     super.onCreate(savedInstanceState);
186 |   }
187 | 
188 |   @Override
189 |   protected int getLayoutId() {
190 |     return R.layout.camera_connection_fragment_stylize;
191 |   }
192 | 
193 |   @Override
194 |   protected int getDesiredPreviewFrameSize() {
195 |     return SIZES[SIZES.length - 1];
196 |   }
197 | 
198 |   public static Bitmap getBitmapFromAsset(final Context context, final String filePath) {
199 |     final AssetManager assetManager = context.getAssets();
200 | 
201 |     Bitmap bitmap = null;
202 |     try {
203 |       final InputStream inputStream = assetManager.open(filePath);
204 |       bitmap = BitmapFactory.decodeStream(inputStream);
205 |     } catch (final IOException e) {
206 |       LOGGER.e("Error opening bitmap!", e);
207 |     }
208 | 
209 |     return bitmap;
210 |   }
211 | 
212 |   private class ImageSlider extends ImageView {
213 |     private float value = 0.0f;
214 |     private boolean hilighted = false;
215 | 
216 |     private final Paint boxPaint;
217 |     private final Paint linePaint;
218 | 
219 |     public ImageSlider(final Context context) {
220 |       super(context);
221 |       value = 0.0f;
222 | 
223 |       boxPaint = new Paint();
224 |       boxPaint.setColor(Color.BLACK);
225 |       boxPaint.setAlpha(128);
226 | 
227 |       linePaint = new Paint();
228 |       linePaint.setColor(Color.WHITE);
229 |       linePaint.setStrokeWidth(10.0f);
230 |       linePaint.setStyle(Style.STROKE);
231 |     }
232 | 
233 |     @Override
234 |     public void onDraw(final Canvas canvas) {
235 |       super.onDraw(canvas);
236 |       final float y = (1.0f - value) * canvas.getHeight();
237 | 
238 |       // If all sliders are zero, don't bother shading anything.
239 |       if (!allZero) {
240 |         canvas.drawRect(0, 0, canvas.getWidth(), y, boxPaint);
241 |       }
242 | 
243 |       if (value > 0.0f) {
244 |         canvas.drawLine(0, y, canvas.getWidth(), y, linePaint);
245 |       }
246 | 
247 |       if (hilighted) {
248 |         canvas.drawRect(0, 0, getWidth(), getHeight(), linePaint);
249 |       }
250 |     }
251 | 
252 |     @Override
253 |     protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
254 |       super.onMeasure(widthMeasureSpec, heightMeasureSpec);
255 |       setMeasuredDimension(getMeasuredWidth(), getMeasuredWidth());
256 |     }
257 | 
258 |     public void setValue(final float value) {
259 |       this.value = value;
260 |       postInvalidate();
261 |     }
262 | 
263 |     public void setHilighted(final boolean highlighted) {
264 |       this.hilighted = highlighted;
265 |       this.postInvalidate();
266 |     }
267 |   }
268 | 
269 |   private class ImageGridAdapter extends BaseAdapter {
270 |     final ImageSlider[] items = new ImageSlider[NUM_STYLES];
271 |     final ArrayList<Button> buttons = new ArrayList<>();
272 | 
273 |     {
274 |       final Button sizeButton =
275 |           new Button(StylizeActivity.this) {
276 |             @Override
277 |             protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
278 |               super.onMeasure(widthMeasureSpec, heightMeasureSpec);
279 |               setMeasuredDimension(getMeasuredWidth(), getMeasuredWidth());
280 |             }
281 |           };
282 |       sizeButton.setText("" + desiredSize);
283 |       sizeButton.setOnClickListener(
284 |           new OnClickListener() {
285 |             @Override
286 |             public void onClick(final View v) {
287 |               desiredSizeIndex = (desiredSizeIndex + 1) % SIZES.length;
288 |               desiredSize = SIZES[desiredSizeIndex];
289 |               sizeButton.setText("" + desiredSize);
290 |               sizeButton.postInvalidate();
291 |             }
292 |           });
293 | 
294 |       final Button saveButton =
295 |           new Button(StylizeActivity.this) {
296 |             @Override
297 |             protected void onMeasure(final int widthMeasureSpec, final int heightMeasureSpec) {
298 |               super.onMeasure(widthMeasureSpec, heightMeasureSpec);
299 |               setMeasuredDimension(getMeasuredWidth(), getMeasuredWidth());
300 |             }
301 |           };
302 |       saveButton.setText("Save");
303 |       saveButton.setOnClickListener(
304 |           new OnClickListener() {
305 |             @Override
306 |             public void onClick(final View v) {
307 |               if (textureCopyBitmap != null) {
308 |                 // TODO(andrewharp): Save as jpeg with guaranteed unique filename.
309 |                 ImageUtils.saveBitmap(textureCopyBitmap, "stylized" + frameNum + ".png");
310 |                 Toast.makeText(
311 |                         StylizeActivity.this,
312 |                         "Saved image to: /sdcard/tensorflow/" + "stylized" + frameNum + ".png",
313 |                         Toast.LENGTH_LONG)
314 |                     .show();
315 |               }
316 |             }
317 |           });
318 | 
319 |       buttons.add(sizeButton);
320 |       buttons.add(saveButton);
321 | 
322 |       for (int i = 0; i < NUM_STYLES; ++i) {
323 |         LOGGER.v("Creating item %d", i);
324 | 
325 |         if (items[i] == null) {
326 |           final ImageSlider slider = new ImageSlider(StylizeActivity.this);
327 |           final Bitmap bm =
328 |               getBitmapFromAsset(StylizeActivity.this, "thumbnails/style" + i + ".jpg");
329 |           slider.setImageBitmap(bm);
330 | 
331 |           items[i] = slider;
332 |         }
333 |       }
334 |     }
335 | 
336 |     @Override
337 |     public int getCount() {
338 |       return buttons.size() + NUM_STYLES;
339 |     }
340 | 
341 |     @Override
342 |     public Object getItem(final int position) {
343 |       if (position < buttons.size()) {
344 |         return buttons.get(position);
345 |       } else {
346 |         return items[position - buttons.size()];
347 |       }
348 |     }
349 | 
350 |     @Override
351 |     public long getItemId(final int position) {
352 |       return getItem(position).hashCode();
353 |     }
354 | 
355 |     @Override
356 |     public View getView(final int position, final View convertView, final ViewGroup parent) {
357 |       if (convertView != null) {
358 |         return convertView;
359 |       }
360 |       return (View) getItem(position);
361 |     }
362 |   }
363 | 
364 |   @Override
365 |   public void onPreviewSizeChosen(final Size size, final int rotation) {
366 |     final float textSizePx =
367 |         TypedValue.applyDimension(
368 |             TypedValue.COMPLEX_UNIT_DIP, TEXT_SIZE_DIP, getResources().getDisplayMetrics());
369 |     borderedText = new BorderedText(textSizePx);
370 |     borderedText.setTypeface(Typeface.MONOSPACE);
371 | 
372 |     inferenceInterface = new TensorFlowInferenceInterface(getAssets(), MODEL_FILE);
373 | 
374 |     previewWidth = size.getWidth();
375 |     previewHeight = size.getHeight();
376 | 
377 |     final Display display = getWindowManager().getDefaultDisplay();
378 |     final int screenOrientation = display.getRotation();
379 | 
380 |     LOGGER.i("Sensor orientation: %d, Screen orientation: %d", rotation, screenOrientation);
381 | 
382 |     sensorOrientation = rotation + screenOrientation;
383 | 
384 |     addCallback(
385 |         new DrawCallback() {
386 |           @Override
387 |           public void drawCallback(final Canvas canvas) {
388 |             renderDebug(canvas);
389 |           }
390 |         });
391 | 
392 |     adapter = new ImageGridAdapter();
393 |     grid = (GridView) findViewById(R.id.grid_layout);
394 |     grid.setAdapter(adapter);
395 |     grid.setOnTouchListener(gridTouchAdapter);
396 | 
397 |     setStyle(adapter.items[0], 1.0f);
398 |   }
399 | 
400 |   private void setStyle(final ImageSlider slider, final float value) {
401 |     slider.setValue(value);
402 | 
403 |     if (NORMALIZE_SLIDERS) {
404 |       // Slider vals correspond directly to the input tensor vals, and normalization is visually
405 |       // maintained by remanipulating non-selected sliders.
406 |       float otherSum = 0.0f;
407 | 
408 |       for (int i = 0; i < NUM_STYLES; ++i) {
409 |         if (adapter.items[i] != slider) {
410 |           otherSum += adapter.items[i].value;
411 |         }
412 |       }
413 | 
414 |       if (otherSum > 0.0) {
415 |         float highestOtherVal = 0;
416 |         final float factor = otherSum > 0.0f ? (1.0f - value) / otherSum : 0.0f;
417 |         for (int i = 0; i < NUM_STYLES; ++i) {
418 |           final ImageSlider child = adapter.items[i];
419 |           if (child == slider) {
420 |             continue;
421 |           }
422 |           final float newVal = child.value * factor;
423 |           child.setValue(newVal > 0.01f ? newVal : 0.0f);
424 | 
425 |           if (child.value > highestOtherVal) {
426 |             lastOtherStyle = i;
427 |             highestOtherVal = child.value;
428 |           }
429 |         }
430 |       } else {
431 |         // Everything else is 0, so just pick a suitable slider to push up when the
432 |         // selected one goes down.
433 |         if (adapter.items[lastOtherStyle] == slider) {
434 |           lastOtherStyle = (lastOtherStyle + 1) % NUM_STYLES;
435 |         }
436 |         adapter.items[lastOtherStyle].setValue(1.0f - value);
437 |       }
438 |     }
439 | 
440 |     final boolean lastAllZero = allZero;
441 |     float sum = 0.0f;
442 |     for (int i = 0; i < NUM_STYLES; ++i) {
443 |       sum += adapter.items[i].value;
444 |     }
445 |     allZero = sum == 0.0f;
446 | 
447 |     // Now update the values used for the input tensor. If nothing is set, mix in everything
448 |     // equally. Otherwise everything is normalized to sum to 1.0.
449 |     for (int i = 0; i < NUM_STYLES; ++i) {
450 |       styleVals[i] = allZero ? 1.0f / NUM_STYLES : adapter.items[i].value / sum;
451 | 
452 |       if (lastAllZero != allZero) {
453 |         adapter.items[i].postInvalidate();
454 |       }
455 |     }
456 |   }
457 | 
458 |   @Override
459 |   public void onImageAvailable(final ImageReader reader) {
460 |     Image image = null;
461 | 
462 |     try {
463 |       image = reader.acquireLatestImage();
464 | 
465 |       if (image == null) {
466 |         return;
467 |       }
468 | 
469 |       if (computing) {
470 |         image.close();
471 |         return;
472 |       }
473 | 
474 |       if (desiredSize != initializedSize) {
475 |         LOGGER.i(
476 |             "Initializing at size preview size %dx%d, stylize size %d",
477 |             previewWidth, previewHeight, desiredSize);
478 |         rgbBytes = new int[previewWidth * previewHeight];
479 |         rgbFrameBitmap = Bitmap.createBitmap(previewWidth, previewHeight, Config.ARGB_8888);
480 |         croppedBitmap = Bitmap.createBitmap(desiredSize, desiredSize, Config.ARGB_8888);
481 | 
482 |         frameToCropTransform =
483 |             ImageUtils.getTransformationMatrix(
484 |                 previewWidth, previewHeight,
485 |                 desiredSize, desiredSize,
486 |                 sensorOrientation, true);
487 | 
488 |         cropToFrameTransform = new Matrix();
489 |         frameToCropTransform.invert(cropToFrameTransform);
490 | 
491 |         yuvBytes = new byte[3][];
492 | 
493 |         intValues = new int[desiredSize * desiredSize];
494 |         floatValues = new float[desiredSize * desiredSize * 3];
495 |         initializedSize = desiredSize;
496 |       }
497 | 
498 |       computing = true;
499 | 
500 |       Trace.beginSection("imageAvailable");
501 | 
502 |       final Plane[] planes = image.getPlanes();
503 |       fillBytes(planes, yuvBytes);
504 | 
505 |       final int yRowStride = planes[0].getRowStride();
506 |       final int uvRowStride = planes[1].getRowStride();
507 |       final int uvPixelStride = planes[1].getPixelStride();
508 |       ImageUtils.convertYUV420ToARGB8888(
509 |           yuvBytes[0],
510 |           yuvBytes[1],
511 |           yuvBytes[2],
512 |           rgbBytes,
513 |           previewWidth,
514 |           previewHeight,
515 |           yRowStride,
516 |           uvRowStride,
517 |           uvPixelStride,
518 |           false);
519 | 
520 |       image.close();
521 |     } catch (final Exception e) {
522 |       if (image != null) {
523 |         image.close();
524 |       }
525 |       LOGGER.e(e, "Exception!");
526 |       Trace.endSection();
527 |       return;
528 |     }
529 | 
530 |     rgbFrameBitmap.setPixels(rgbBytes, 0, previewWidth, 0, 0, previewWidth, previewHeight);
531 |     final Canvas canvas = new Canvas(croppedBitmap);
532 |     canvas.drawBitmap(rgbFrameBitmap, frameToCropTransform, null);
533 | 
534 |     // For examining the actual TF input.
535 |     if (SAVE_PREVIEW_BITMAP) {
536 |       ImageUtils.saveBitmap(croppedBitmap);
537 |     }
538 | 
539 |     runInBackground(
540 |         new Runnable() {
541 |           @Override
542 |           public void run() {
543 |             cropCopyBitmap = Bitmap.createBitmap(croppedBitmap);
544 | 
545 |             final long startTime = SystemClock.uptimeMillis();
546 |             stylizeImage(croppedBitmap);
547 |             lastProcessingTimeMs = SystemClock.uptimeMillis() - startTime;
548 | 
549 |             textureCopyBitmap = Bitmap.createBitmap(croppedBitmap);
550 | 
551 |             requestRender();
552 |             computing = false;
553 |           }
554 |         });
555 | 
556 |     Trace.endSection();
557 |   }
558 | 
559 |   private void stylizeImage(final Bitmap bitmap) {
560 |     ++frameNum;
561 |     bitmap.getPixels(intValues, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
562 | 
563 |     if (DEBUG_MODEL) {
564 |       // Create a white square that steps through a black background 1 pixel per frame.
565 |       final int centerX = (frameNum + bitmap.getWidth() / 2) % bitmap.getWidth();
566 |       final int centerY = bitmap.getHeight() / 2;
567 |       final int squareSize = 10;
568 |       for (int i = 0; i < intValues.length; ++i) {
569 |         final int x = i % bitmap.getWidth();
570 |         final int y = i / bitmap.getHeight();
571 |         final float val =
572 |             Math.abs(x - centerX) < squareSize && Math.abs(y - centerY) < squareSize ? 1.0f : 0.0f;
573 |         floatValues[i * 3] = val;
574 |         floatValues[i * 3 + 1] = val;
575 |         floatValues[i * 3 + 2] = val;
576 |       }
577 |     } else {
578 |       for (int i = 0; i < intValues.length; ++i) {
579 |         final int val = intValues[i];
580 |         floatValues[i * 3] = ((val >> 16) & 0xFF) / 255.0f;
581 |         floatValues[i * 3 + 1] = ((val >> 8) & 0xFF) / 255.0f;
582 |         floatValues[i * 3 + 2] = (val & 0xFF) / 255.0f;
583 |       }
584 |     }
585 | 
586 |     // Copy the input data into TensorFlow.
587 |     inferenceInterface.feed(
588 |         INPUT_NODE, floatValues, 1, bitmap.getWidth(), bitmap.getHeight(), 3);
589 |     inferenceInterface.feed(STYLE_NODE, styleVals, NUM_STYLES);
590 | 
591 |     inferenceInterface.run(new String[] {OUTPUT_NODE}, isDebug());
592 |     inferenceInterface.fetch(OUTPUT_NODE, floatValues);
593 | 
594 |     for (int i = 0; i < intValues.length; ++i) {
595 |       intValues[i] =
596 |           0xFF000000
597 |               | (((int) (floatValues[i * 3] * 255)) << 16)
598 |               | (((int) (floatValues[i * 3 + 1] * 255)) << 8)
599 |               | ((int) (floatValues[i * 3 + 2] * 255));
600 |     }
601 | 
602 |     bitmap.setPixels(intValues, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
603 |   }
604 | 
605 |   private void renderDebug(final Canvas canvas) {
606 |     // TODO(andrewharp): move result display to its own View instead of using debug overlay.
607 |     final Bitmap texture = textureCopyBitmap;
608 |     if (texture != null) {
609 |       final Matrix matrix = new Matrix();
610 |       final float scaleFactor =
611 |           DEBUG_MODEL
612 |               ? 4.0f
613 |               : Math.min(
614 |                   (float) canvas.getWidth() / texture.getWidth(),
615 |                   (float) canvas.getHeight() / texture.getHeight());
616 |       matrix.postScale(scaleFactor, scaleFactor);
617 |       canvas.drawBitmap(texture, matrix, new Paint());
618 |     }
619 | 
620 |     if (!isDebug()) {
621 |       return;
622 |     }
623 | 
624 |     final Bitmap copy = cropCopyBitmap;
625 |     if (copy == null) {
626 |       return;
627 |     }
628 | 
629 |     canvas.drawColor(0x55000000);
630 | 
631 |     final Matrix matrix = new Matrix();
632 |     final float scaleFactor = 2;
633 |     matrix.postScale(scaleFactor, scaleFactor);
634 |     matrix.postTranslate(
635 |         canvas.getWidth() - copy.getWidth() * scaleFactor,
636 |         canvas.getHeight() - copy.getHeight() * scaleFactor);
637 |     canvas.drawBitmap(copy, matrix, new Paint());
638 | 
639 |     final Vector<String> lines = new Vector<>();
640 | 
641 |     final String[] statLines = inferenceInterface.getStatString().split("\n");
642 |     Collections.addAll(lines, statLines);
643 | 
644 |     lines.add("");
645 | 
646 |     lines.add("Frame: " + previewWidth + "x" + previewHeight);
647 |     lines.add("Crop: " + copy.getWidth() + "x" + copy.getHeight());
648 |     lines.add("View: " + canvas.getWidth() + "x" + canvas.getHeight());
649 |     lines.add("Rotation: " + sensorOrientation);
650 |     lines.add("Inference time: " + lastProcessingTimeMs + "ms");
651 |     lines.add("Desired size: " + desiredSize);
652 |     lines.add("Initialized size: " + initializedSize);
653 | 
654 |     borderedText.drawLines(canvas, 10, canvas.getHeight() - 10, lines);
655 |   }
656 | }
657 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/TensorFlowImageClassifier.java:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
  2 | 
  3 | Licensed under the Apache License, Version 2.0 (the "License");
  4 | you may not use this file except in compliance with the License.
  5 | You may obtain a copy of the License at
  6 | 
  7 |     http://www.apache.org/licenses/LICENSE-2.0
  8 | 
  9 | Unless required by applicable law or agreed to in writing, software
 10 | distributed under the License is distributed on an "AS IS" BASIS,
 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | See the License for the specific language governing permissions and
 13 | limitations under the License.
 14 | ==============================================================================*/
 15 | 
 16 | package org.tensorflow.demo;
 17 | 
 18 | import android.content.res.AssetManager;
 19 | import android.graphics.Bitmap;
 20 | import android.os.Trace;
 21 | import android.util.Log;
 22 | import java.io.BufferedReader;
 23 | import java.io.IOException;
 24 | import java.io.InputStreamReader;
 25 | import java.util.ArrayList;
 26 | import java.util.Comparator;
 27 | import java.util.List;
 28 | import java.util.PriorityQueue;
 29 | import java.util.Vector;
 30 | import org.tensorflow.Operation;
 31 | import org.tensorflow.contrib.android.TensorFlowInferenceInterface;
 32 | 
 33 | /** A classifier specialized to label images using TensorFlow. */
 34 | public class TensorFlowImageClassifier implements Classifier {
 35 |   static {
 36 |     System.loadLibrary("tensorflow_demo");
 37 |   }
 38 | 
 39 |   private static final String TAG = "TensorFlowImageClassifier";
 40 | 
 41 |   // Only return this many results with at least this confidence.
 42 |   private static final int MAX_RESULTS = 3;
 43 |   private static final float THRESHOLD = 0.1f;
 44 | 
 45 |   // Config values.
 46 |   private String inputName;
 47 |   private String outputName;
 48 |   private int inputSize;
 49 |   private int imageMean;
 50 |   private float imageStd;
 51 | 
 52 |   // Pre-allocated buffers.
 53 |   private Vector<String> labels = new Vector<String>();
 54 |   private int[] intValues;
 55 |   private float[] floatValues;
 56 |   private float[] outputs;
 57 |   private String[] outputNames;
 58 | 
 59 |   private boolean logStats = false;
 60 | 
 61 |   private TensorFlowInferenceInterface inferenceInterface;
 62 | 
 63 |   private TensorFlowImageClassifier() {}
 64 | 
 65 |   /**
 66 |    * Initializes a native TensorFlow session for classifying images.
 67 |    *
 68 |    * @param assetManager The asset manager to be used to load assets.
 69 |    * @param modelFilename The filepath of the model GraphDef protocol buffer.
 70 |    * @param labelFilename The filepath of label file for classes.
 71 |    * @param inputSize The input size. A square image of inputSize x inputSize is assumed.
 72 |    * @param imageMean The assumed mean of the image values.
 73 |    * @param imageStd The assumed std of the image values.
 74 |    * @param inputName The label of the image input node.
 75 |    * @param outputName The label of the output node.
 76 |    * @throws IOException
 77 |    */
 78 |   public static Classifier create(
 79 |       AssetManager assetManager,
 80 |       String modelFilename,
 81 |       String labelFilename,
 82 |       int inputSize,
 83 |       int imageMean,
 84 |       float imageStd,
 85 |       String inputName,
 86 |       String outputName) {
 87 |     TensorFlowImageClassifier c = new TensorFlowImageClassifier();
 88 |     c.inputName = inputName;
 89 |     c.outputName = outputName;
 90 | 
 91 |     // Read the label names into memory.
 92 |     // TODO(andrewharp): make this handle non-assets.
 93 |     String actualFilename = labelFilename.split("file:///android_asset/")[1];
 94 |     Log.i(TAG, "Reading labels from: " + actualFilename);
 95 |     BufferedReader br = null;
 96 |     try {
 97 |       br = new BufferedReader(new InputStreamReader(assetManager.open(actualFilename)));
 98 |       String line;
 99 |       while ((line = br.readLine()) != null) {
100 |         c.labels.add(line);
101 |       }
102 |       br.close();
103 |     } catch (IOException e) {
104 |       throw new RuntimeException("Problem reading label file!" , e);
105 |     }
106 | 
107 |     c.inferenceInterface = new TensorFlowInferenceInterface(assetManager, modelFilename);
108 | 
109 |     // The shape of the output is [N, NUM_CLASSES], where N is the batch size.
110 |     final Operation operation = c.inferenceInterface.graphOperation(outputName);
111 |     final int numClasses = (int) operation.output(0).shape().size(1);
112 |     Log.i(TAG, "Read " + c.labels.size() + " labels, output layer size is " + numClasses);
113 | 
114 |     // Ideally, inputSize could have been retrieved from the shape of the input operation.  Alas,
115 |     // the placeholder node for input in the graphdef typically used does not specify a shape, so it
116 |     // must be passed in as a parameter.
117 |     c.inputSize = inputSize;
118 |     c.imageMean = imageMean;
119 |     c.imageStd = imageStd;
120 | 
121 |     // Pre-allocate buffers.
122 |     c.outputNames = new String[] {outputName};
123 |     c.intValues = new int[inputSize * inputSize];
124 |     c.floatValues = new float[inputSize * inputSize * 3];
125 |     c.outputs = new float[numClasses];
126 | 
127 |     return c;
128 |   }
129 | 
130 |   @Override
131 |   public List<Recognition> recognizeImage(final Bitmap bitmap) {
132 |     // Log this method so that it can be analyzed with systrace.
133 |     Trace.beginSection("recognizeImage");
134 | 
135 |     Trace.beginSection("preprocessBitmap");
136 |     // Preprocess the image data from 0-255 int to normalized float based
137 |     // on the provided parameters.
138 |     bitmap.getPixels(intValues, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
139 |     for (int i = 0; i < intValues.length; ++i) {
140 |       final int val = intValues[i];
141 |       floatValues[i * 3 + 0] = (((val >> 16) & 0xFF) - imageMean) / imageStd;
142 |       floatValues[i * 3 + 1] = (((val >> 8) & 0xFF) - imageMean) / imageStd;
143 |       floatValues[i * 3 + 2] = ((val & 0xFF) - imageMean) / imageStd;
144 |     }
145 |     Trace.endSection();
146 | 
147 |     // Copy the input data into TensorFlow.
148 |     Trace.beginSection("feed");
149 |     inferenceInterface.feed(inputName, floatValues, 1, inputSize, inputSize, 3);
150 |     Trace.endSection();
151 | 
152 |     // Run the inference call.
153 |     Trace.beginSection("run");
154 |     inferenceInterface.run(outputNames, logStats);
155 |     Trace.endSection();
156 | 
157 |     // Copy the output Tensor back into the output array.
158 |     Trace.beginSection("fetch");
159 |     inferenceInterface.fetch(outputName, outputs);
160 |     Trace.endSection();
161 | 
162 |     // Find the best classifications.
163 |     PriorityQueue<Recognition> pq =
164 |         new PriorityQueue<Recognition>(
165 |             3,
166 |             new Comparator<Recognition>() {
167 |               @Override
168 |               public int compare(Recognition lhs, Recognition rhs) {
169 |                 // Intentionally reversed to put high confidence at the head of the queue.
170 |                 return Float.compare(rhs.getConfidence(), lhs.getConfidence());
171 |               }
172 |             });
173 |     for (int i = 0; i < outputs.length; ++i) {
174 |       if (outputs[i] > THRESHOLD) {
175 |         pq.add(
176 |             new Recognition(
177 |                 "" + i, labels.size() > i ? labels.get(i) : "unknown", outputs[i], null));
178 |       }
179 |     }
180 |     final ArrayList<Recognition> recognitions = new ArrayList<Recognition>();
181 |     int recognitionsSize = Math.min(pq.size(), MAX_RESULTS);
182 |     for (int i = 0; i < recognitionsSize; ++i) {
183 |       recognitions.add(pq.poll());
184 |     }
185 |     Trace.endSection(); // "recognizeImage"
186 |     return recognitions;
187 |   }
188 | 
189 |   @Override
190 |   public void enableStatLogging(boolean logStats) {
191 |     this.logStats = logStats;
192 |   }
193 | 
194 |   @Override
195 |   public String getStatString() {
196 |     return inferenceInterface.getStatString();
197 |   }
198 | 
199 |   @Override
200 |   public void close() {
201 |     inferenceInterface.close();
202 |   }
203 | }
204 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/TensorFlowMultiBoxDetector.java:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
  2 | 
  3 | Licensed under the Apache License, Version 2.0 (the "License");
  4 | you may not use this file except in compliance with the License.
  5 | You may obtain a copy of the License at
  6 | 
  7 |     http://www.apache.org/licenses/LICENSE-2.0
  8 | 
  9 | Unless required by applicable law or agreed to in writing, software
 10 | distributed under the License is distributed on an "AS IS" BASIS,
 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | See the License for the specific language governing permissions and
 13 | limitations under the License.
 14 | ==============================================================================*/
 15 | 
 16 | package org.tensorflow.demo;
 17 | 
 18 | import android.content.res.AssetManager;
 19 | import android.graphics.Bitmap;
 20 | import android.graphics.RectF;
 21 | import android.os.Trace;
 22 | import java.io.BufferedReader;
 23 | import java.io.FileInputStream;
 24 | import java.io.IOException;
 25 | import java.io.InputStream;
 26 | import java.io.InputStreamReader;
 27 | import java.util.ArrayList;
 28 | import java.util.Comparator;
 29 | import java.util.List;
 30 | import java.util.PriorityQueue;
 31 | import java.util.StringTokenizer;
 32 | import org.tensorflow.Graph;
 33 | import org.tensorflow.Operation;
 34 | import org.tensorflow.contrib.android.TensorFlowInferenceInterface;
 35 | import org.tensorflow.demo.env.Logger;
 36 | 
 37 | /**
 38 |  * A detector for general purpose object detection as described in Scalable Object Detection using
 39 |  * Deep Neural Networks (https://arxiv.org/abs/1312.2249).
 40 |  */
 41 | public class TensorFlowMultiBoxDetector implements Classifier {
 42 |   private static final Logger LOGGER = new Logger();
 43 | 
 44 |   static {
 45 |     System.loadLibrary("tensorflow_demo");
 46 |   }
 47 | 
 48 |   // Only return this many results with at least this confidence.
 49 |   private static final int MAX_RESULTS = Integer.MAX_VALUE;
 50 | 
 51 |   // Config values.
 52 |   private String inputName;
 53 |   private int inputSize;
 54 |   private int imageMean;
 55 |   private float imageStd;
 56 | 
 57 |   // Pre-allocated buffers.
 58 |   private int[] intValues;
 59 |   private float[] floatValues;
 60 |   private float[] outputLocations;
 61 |   private float[] outputScores;
 62 |   private String[] outputNames;
 63 |   private int numLocations;
 64 | 
 65 |   private boolean logStats = false;
 66 | 
 67 |   private TensorFlowInferenceInterface inferenceInterface;
 68 | 
 69 |   private float[] boxPriors;
 70 | 
 71 |   /**
 72 |    * Initializes a native TensorFlow session for classifying images.
 73 |    *
 74 |    * @param assetManager The asset manager to be used to load assets.
 75 |    * @param modelFilename The filepath of the model GraphDef protocol buffer.
 76 |    * @param locationFilename The filepath of label file for classes.
 77 |    * @param inputSize The input size. A square image of inputSize x inputSize is assumed.
 78 |    * @param imageMean The assumed mean of the image values.
 79 |    * @param imageStd The assumed std of the image values.
 80 |    * @param inputName The label of the image input node.
 81 |    * @param outputName The label of the output node.
 82 |    */
 83 |   public static Classifier create(
 84 |       final AssetManager assetManager,
 85 |       final String modelFilename,
 86 |       final String locationFilename,
 87 |       final int imageMean,
 88 |       final float imageStd,
 89 |       final String inputName,
 90 |       final String outputLocationsName,
 91 |       final String outputScoresName) {
 92 |     final TensorFlowMultiBoxDetector d = new TensorFlowMultiBoxDetector();
 93 | 
 94 |     d.inferenceInterface = new TensorFlowInferenceInterface(assetManager, modelFilename);
 95 | 
 96 |     final Graph g = d.inferenceInterface.graph();
 97 | 
 98 |     d.inputName = inputName;
 99 |     // The inputName node has a shape of [N, H, W, C], where
100 |     // N is the batch size
101 |     // H = W are the height and width
102 |     // C is the number of channels (3 for our purposes - RGB)
103 |     final Operation inputOp = g.operation(inputName);
104 |     if (inputOp == null) {
105 |       throw new RuntimeException("Failed to find input Node '" + inputName + "'");
106 |     }
107 |     d.inputSize = (int) inputOp.output(0).shape().size(1);
108 |     d.imageMean = imageMean;
109 |     d.imageStd = imageStd;
110 |     // The outputScoresName node has a shape of [N, NumLocations], where N
111 |     // is the batch size.
112 |     final Operation outputOp = g.operation(outputScoresName);
113 |     if (outputOp == null) {
114 |       throw new RuntimeException("Failed to find output Node '" + outputScoresName + "'");
115 |     }
116 |     d.numLocations = (int) outputOp.output(0).shape().size(1);
117 | 
118 |     d.boxPriors = new float[d.numLocations * 8];
119 | 
120 |     try {
121 |       d.loadCoderOptions(assetManager, locationFilename, d.boxPriors);
122 |     } catch (final IOException e) {
123 |       throw new RuntimeException("Error initializing box priors from " + locationFilename);
124 |     }
125 | 
126 |     // Pre-allocate buffers.
127 |     d.outputNames = new String[] {outputLocationsName, outputScoresName};
128 |     d.intValues = new int[d.inputSize * d.inputSize];
129 |     d.floatValues = new float[d.inputSize * d.inputSize * 3];
130 |     d.outputScores = new float[d.numLocations];
131 |     d.outputLocations = new float[d.numLocations * 4];
132 | 
133 |     return d;
134 |   }
135 | 
136 |   private TensorFlowMultiBoxDetector() {}
137 | 
138 |   private void loadCoderOptions(
139 |       final AssetManager assetManager, final String locationFilename, final float[] boxPriors)
140 |       throws IOException {
141 |     // Try to be intelligent about opening from assets or sdcard depending on prefix.
142 |     final String assetPrefix = "file:///android_asset/";
143 |     InputStream is;
144 |     if (locationFilename.startsWith(assetPrefix)) {
145 |       is = assetManager.open(locationFilename.split(assetPrefix)[1]);
146 |     } else {
147 |       is = new FileInputStream(locationFilename);
148 |     }
149 | 
150 |     // Read values. Number of values per line doesn't matter, as long as they are separated
151 |     // by commas and/or whitespace, and there are exactly numLocations * 8 values total.
152 |     // Values are in the order mean, std for each consecutive corner of each box, for a total of 8
153 |     // per location.
154 |     final BufferedReader reader = new BufferedReader(new InputStreamReader(is));
155 |     int priorIndex = 0;
156 |     String line;
157 |     while ((line = reader.readLine()) != null) {
158 |       final StringTokenizer st = new StringTokenizer(line, ", ");
159 |       while (st.hasMoreTokens()) {
160 |         final String token = st.nextToken();
161 |         try {
162 |           final float number = Float.parseFloat(token);
163 |           boxPriors[priorIndex++] = number;
164 |         } catch (final NumberFormatException e) {
165 |           // Silently ignore.
166 |         }
167 |       }
168 |     }
169 |     if (priorIndex != boxPriors.length) {
170 |       throw new RuntimeException(
171 |           "BoxPrior length mismatch: " + priorIndex + " vs " + boxPriors.length);
172 |     }
173 |   }
174 | 
175 |   private float[] decodeLocationsEncoding(final float[] locationEncoding) {
176 |     final float[] locations = new float[locationEncoding.length];
177 |     boolean nonZero = false;
178 |     for (int i = 0; i < numLocations; ++i) {
179 |       for (int j = 0; j < 4; ++j) {
180 |         final float currEncoding = locationEncoding[4 * i + j];
181 |         nonZero = nonZero || currEncoding != 0.0f;
182 | 
183 |         final float mean = boxPriors[i * 8 + j * 2];
184 |         final float stdDev = boxPriors[i * 8 + j * 2 + 1];
185 |         float currentLocation = currEncoding * stdDev + mean;
186 |         currentLocation = Math.max(currentLocation, 0.0f);
187 |         currentLocation = Math.min(currentLocation, 1.0f);
188 |         locations[4 * i + j] = currentLocation;
189 |       }
190 |     }
191 | 
192 |     if (!nonZero) {
193 |       LOGGER.w("No non-zero encodings; check log for inference errors.");
194 |     }
195 |     return locations;
196 |   }
197 | 
198 |   private float[] decodeScoresEncoding(final float[] scoresEncoding) {
199 |     final float[] scores = new float[scoresEncoding.length];
200 |     for (int i = 0; i < scoresEncoding.length; ++i) {
201 |       scores[i] = 1 / ((float) (1 + Math.exp(-scoresEncoding[i])));
202 |     }
203 |     return scores;
204 |   }
205 | 
206 |   @Override
207 |   public List<Recognition> recognizeImage(final Bitmap bitmap) {
208 |     // Log this method so that it can be analyzed with systrace.
209 |     Trace.beginSection("recognizeImage");
210 | 
211 |     Trace.beginSection("preprocessBitmap");
212 |     // Preprocess the image data from 0-255 int to normalized float based
213 |     // on the provided parameters.
214 |     bitmap.getPixels(intValues, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
215 | 
216 |     for (int i = 0; i < intValues.length; ++i) {
217 |       floatValues[i * 3 + 0] = ((intValues[i] & 0xFF) - imageMean) / imageStd;
218 |       floatValues[i * 3 + 1] = (((intValues[i] >> 8) & 0xFF) - imageMean) / imageStd;
219 |       floatValues[i * 3 + 2] = (((intValues[i] >> 16) & 0xFF) - imageMean) / imageStd;
220 |     }
221 |     Trace.endSection(); // preprocessBitmap
222 | 
223 |     // Copy the input data into TensorFlow.
224 |     Trace.beginSection("feed");
225 |     inferenceInterface.feed(inputName, floatValues, 1, inputSize, inputSize, 3);
226 |     Trace.endSection();
227 | 
228 |     // Run the inference call.
229 |     Trace.beginSection("run");
230 |     inferenceInterface.run(outputNames, logStats);
231 |     Trace.endSection();
232 | 
233 |     // Copy the output Tensor back into the output array.
234 |     Trace.beginSection("fetch");
235 |     final float[] outputScoresEncoding = new float[numLocations];
236 |     final float[] outputLocationsEncoding = new float[numLocations * 4];
237 |     inferenceInterface.fetch(outputNames[0], outputLocationsEncoding);
238 |     inferenceInterface.fetch(outputNames[1], outputScoresEncoding);
239 |     Trace.endSection();
240 | 
241 |     outputLocations = decodeLocationsEncoding(outputLocationsEncoding);
242 |     outputScores = decodeScoresEncoding(outputScoresEncoding);
243 | 
244 |     // Find the best detections.
245 |     final PriorityQueue<Recognition> pq =
246 |         new PriorityQueue<Recognition>(
247 |             1,
248 |             new Comparator<Recognition>() {
249 |               @Override
250 |               public int compare(final Recognition lhs, final Recognition rhs) {
251 |                 // Intentionally reversed to put high confidence at the head of the queue.
252 |                 return Float.compare(rhs.getConfidence(), lhs.getConfidence());
253 |               }
254 |             });
255 | 
256 |     // Scale them back to the input size.
257 |     for (int i = 0; i < outputScores.length; ++i) {
258 |       final RectF detection =
259 |           new RectF(
260 |               outputLocations[4 * i] * inputSize,
261 |               outputLocations[4 * i + 1] * inputSize,
262 |               outputLocations[4 * i + 2] * inputSize,
263 |               outputLocations[4 * i + 3] * inputSize);
264 |       pq.add(new Recognition("" + i, null, outputScores[i], detection));
265 |     }
266 | 
267 |     final ArrayList<Recognition> recognitions = new ArrayList<Recognition>();
268 |     for (int i = 0; i < Math.min(pq.size(), MAX_RESULTS); ++i) {
269 |       recognitions.add(pq.poll());
270 |     }
271 |     Trace.endSection(); // "recognizeImage"
272 |     return recognitions;
273 |   }
274 | 
275 |   @Override
276 |   public void enableStatLogging(final boolean logStats) {
277 |     this.logStats = logStats;
278 |   }
279 | 
280 |   @Override
281 |   public String getStatString() {
282 |     return inferenceInterface.getStatString();
283 |   }
284 | 
285 |   @Override
286 |   public void close() {
287 |     inferenceInterface.close();
288 |   }
289 | }
290 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/TensorFlowYoloDetector.java:
--------------------------------------------------------------------------------
  1 | /* Copyright 2017 The TensorFlow Authors. All Rights Reserved.
  2 | 
  3 | Licensed under the Apache License, Version 2.0 (the "License");
  4 | you may not use this file except in compliance with the License.
  5 | You may obtain a copy of the License at
  6 | 
  7 |     http://www.apache.org/licenses/LICENSE-2.0
  8 | 
  9 | Unless required by applicable law or agreed to in writing, software
 10 | distributed under the License is distributed on an "AS IS" BASIS,
 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | See the License for the specific language governing permissions and
 13 | limitations under the License.
 14 | ==============================================================================*/
 15 | 
 16 | package org.tensorflow.demo;
 17 | 
 18 | import android.content.res.AssetManager;
 19 | import android.graphics.Bitmap;
 20 | import android.graphics.RectF;
 21 | import android.os.Trace;
 22 | import java.util.ArrayList;
 23 | import java.util.Comparator;
 24 | import java.util.List;
 25 | import java.util.PriorityQueue;
 26 | import org.tensorflow.contrib.android.TensorFlowInferenceInterface;
 27 | import org.tensorflow.demo.env.Logger;
 28 | import org.tensorflow.demo.env.SplitTimer;
 29 | 
 30 | /** An object detector that uses TF and a YOLO model to detect objects. */
 31 | public class TensorFlowYoloDetector implements Classifier {
 32 |   private static final Logger LOGGER = new Logger();
 33 | 
 34 |   static {
 35 |     System.loadLibrary("tensorflow_demo");
 36 |   }
 37 | 
 38 |   // Only return this many results with at least this confidence.
 39 |   private static final int MAX_RESULTS = 5;
 40 | 
 41 |   private static final int NUM_CLASSES = 20;
 42 | 
 43 |   private static final int NUM_BOXES_PER_BLOCK = 5;
 44 | 
 45 |   // TODO(andrewharp): allow loading anchors and classes
 46 |   // from files.
 47 |   private static final double[] ANCHORS = {
 48 |     1.08, 1.19,
 49 |     3.42, 4.41,
 50 |     6.63, 11.38,
 51 |     9.42, 5.11,
 52 |     16.62, 10.52
 53 |   };
 54 | 
 55 |   private static final String[] LABELS = {
 56 |     "aeroplane",
 57 |     "bicycle",
 58 |     "bird",
 59 |     "boat",
 60 |     "bottle",
 61 |     "bus",
 62 |     "car",
 63 |     "cat",
 64 |     "chair",
 65 |     "cow",
 66 |     "diningtable",
 67 |     "dog",
 68 |     "horse",
 69 |     "motorbike",
 70 |     "person",
 71 |     "pottedplant",
 72 |     "sheep",
 73 |     "sofa",
 74 |     "train",
 75 |     "tvmonitor"
 76 |   };
 77 | 
 78 |   // Config values.
 79 |   private String inputName;
 80 |   private int inputSize;
 81 | 
 82 |   // Pre-allocated buffers.
 83 |   private int[] intValues;
 84 |   private float[] floatValues;
 85 |   private String[] outputNames;
 86 | 
 87 |   private int blockSize;
 88 | 
 89 |   private boolean logStats = false;
 90 | 
 91 |   private TensorFlowInferenceInterface inferenceInterface;
 92 | 
 93 |   /** Initializes a native TensorFlow session for classifying images. */
 94 |   public static Classifier create(
 95 |       final AssetManager assetManager,
 96 |       final String modelFilename,
 97 |       final int inputSize,
 98 |       final String inputName,
 99 |       final String outputName,
100 |       final int blockSize) {
101 |     TensorFlowYoloDetector d = new TensorFlowYoloDetector();
102 |     d.inputName = inputName;
103 |     d.inputSize = inputSize;
104 | 
105 |     // Pre-allocate buffers.
106 |     d.outputNames = outputName.split(",");
107 |     d.intValues = new int[inputSize * inputSize];
108 |     d.floatValues = new float[inputSize * inputSize * 3];
109 |     d.blockSize = blockSize;
110 | 
111 |     d.inferenceInterface = new TensorFlowInferenceInterface(assetManager, modelFilename);
112 | 
113 |     return d;
114 |   }
115 | 
116 |   private TensorFlowYoloDetector() {}
117 | 
118 |   private float expit(final float x) {
119 |     return (float) (1. / (1. + Math.exp(-x)));
120 |   }
121 | 
122 |   private void softmax(final float[] vals) {
123 |     float max = Float.NEGATIVE_INFINITY;
124 |     for (final float val : vals) {
125 |       max = Math.max(max, val);
126 |     }
127 |     float sum = 0.0f;
128 |     for (int i = 0; i < vals.length; ++i) {
129 |       vals[i] = (float) Math.exp(vals[i] - max);
130 |       sum += vals[i];
131 |     }
132 |     for (int i = 0; i < vals.length; ++i) {
133 |       vals[i] = vals[i] / sum;
134 |     }
135 |   }
136 | 
137 |   @Override
138 |   public List<Recognition> recognizeImage(final Bitmap bitmap) {
139 |     final SplitTimer timer = new SplitTimer("recognizeImage");
140 | 
141 |     // Log this method so that it can be analyzed with systrace.
142 |     Trace.beginSection("recognizeImage");
143 | 
144 |     Trace.beginSection("preprocessBitmap");
145 |     // Preprocess the image data from 0-255 int to normalized float based
146 |     // on the provided parameters.
147 |     bitmap.getPixels(intValues, 0, bitmap.getWidth(), 0, 0, bitmap.getWidth(), bitmap.getHeight());
148 | 
149 |     for (int i = 0; i < intValues.length; ++i) {
150 |       floatValues[i * 3 + 0] = ((intValues[i] >> 16) & 0xFF) / 255.0f;
151 |       floatValues[i * 3 + 1] = ((intValues[i] >> 8) & 0xFF) / 255.0f;
152 |       floatValues[i * 3 + 2] = (intValues[i] & 0xFF) / 255.0f;
153 |     }
154 |     Trace.endSection(); // preprocessBitmap
155 | 
156 |     // Copy the input data into TensorFlow.
157 |     Trace.beginSection("feed");
158 |     inferenceInterface.feed(inputName, floatValues, 1, inputSize, inputSize, 3);
159 |     Trace.endSection();
160 | 
161 |     timer.endSplit("ready for inference");
162 | 
163 |     // Run the inference call.
164 |     Trace.beginSection("run");
165 |     inferenceInterface.run(outputNames, logStats);
166 |     Trace.endSection();
167 | 
168 |     timer.endSplit("ran inference");
169 | 
170 |     // Copy the output Tensor back into the output array.
171 |     Trace.beginSection("fetch");
172 |     final int gridWidth = bitmap.getWidth() / blockSize;
173 |     final int gridHeight = bitmap.getHeight() / blockSize;
174 |     final float[] output =
175 |         new float[gridWidth * gridHeight * (NUM_CLASSES + 5) * NUM_BOXES_PER_BLOCK];
176 |     inferenceInterface.fetch(outputNames[0], output);
177 |     Trace.endSection();
178 | 
179 |     // Find the best detections.
180 |     final PriorityQueue<Recognition> pq =
181 |         new PriorityQueue<Recognition>(
182 |             1,
183 |             new Comparator<Recognition>() {
184 |               @Override
185 |               public int compare(final Recognition lhs, final Recognition rhs) {
186 |                 // Intentionally reversed to put high confidence at the head of the queue.
187 |                 return Float.compare(rhs.getConfidence(), lhs.getConfidence());
188 |               }
189 |             });
190 | 
191 |     for (int y = 0; y < gridHeight; ++y) {
192 |       for (int x = 0; x < gridWidth; ++x) {
193 |         for (int b = 0; b < NUM_BOXES_PER_BLOCK; ++b) {
194 |           final int offset =
195 |               (gridWidth * (NUM_BOXES_PER_BLOCK * (NUM_CLASSES + 5))) * y
196 |                   + (NUM_BOXES_PER_BLOCK * (NUM_CLASSES + 5)) * x
197 |                   + (NUM_CLASSES + 5) * b;
198 | 
199 |           final float xPos = (x + expit(output[offset + 0])) * blockSize;
200 |           final float yPos = (y + expit(output[offset + 1])) * blockSize;
201 | 
202 |           final float w = (float) (Math.exp(output[offset + 2]) * ANCHORS[2 * b + 0]) * blockSize;
203 |           final float h = (float) (Math.exp(output[offset + 3]) * ANCHORS[2 * b + 1]) * blockSize;
204 | 
205 |           final RectF rect =
206 |               new RectF(
207 |                   Math.max(0, xPos - w / 2),
208 |                   Math.max(0, yPos - h / 2),
209 |                   Math.min(bitmap.getWidth() - 1, xPos + w / 2),
210 |                   Math.min(bitmap.getHeight() - 1, yPos + h / 2));
211 |           final float confidence = expit(output[offset + 4]);
212 | 
213 |           int detectedClass = -1;
214 |           float maxClass = 0;
215 | 
216 |           final float[] classes = new float[NUM_CLASSES];
217 |           for (int c = 0; c < NUM_CLASSES; ++c) {
218 |             classes[c] = output[offset + 5 + c];
219 |           }
220 |           softmax(classes);
221 | 
222 |           for (int c = 0; c < NUM_CLASSES; ++c) {
223 |             if (classes[c] > maxClass) {
224 |               detectedClass = c;
225 |               maxClass = classes[c];
226 |             }
227 |           }
228 | 
229 |           final float confidenceInClass = maxClass * confidence;
230 |           if (confidenceInClass > 0.01) {
231 |             LOGGER.i(
232 |                 "%s (%d) %f %s", LABELS[detectedClass], detectedClass, confidenceInClass, rect);
233 |             pq.add(new Recognition("" + offset, LABELS[detectedClass], confidenceInClass, rect));
234 |           }
235 |         }
236 |       }
237 |     }
238 |     timer.endSplit("decoded results");
239 | 
240 |     final ArrayList<Recognition> recognitions = new ArrayList<Recognition>();
241 |     for (int i = 0; i < Math.min(pq.size(), MAX_RESULTS); ++i) {
242 |       recognitions.add(pq.poll());
243 |     }
244 |     Trace.endSection(); // "recognizeImage"
245 | 
246 |     timer.endSplit("processed results");
247 | 
248 |     return recognitions;
249 |   }
250 | 
251 |   @Override
252 |   public void enableStatLogging(final boolean logStats) {
253 |     this.logStats = logStats;
254 |   }
255 | 
256 |   @Override
257 |   public String getStatString() {
258 |     return inferenceInterface.getStatString();
259 |   }
260 | 
261 |   @Override
262 |   public void close() {
263 |     inferenceInterface.close();
264 |   }
265 | }
266 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/env/BorderedText.java:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
  2 | 
  3 | Licensed under the Apache License, Version 2.0 (the "License");
  4 | you may not use this file except in compliance with the License.
  5 | You may obtain a copy of the License at
  6 | 
  7 |     http://www.apache.org/licenses/LICENSE-2.0
  8 | 
  9 | Unless required by applicable law or agreed to in writing, software
 10 | distributed under the License is distributed on an "AS IS" BASIS,
 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | See the License for the specific language governing permissions and
 13 | limitations under the License.
 14 | ==============================================================================*/
 15 | 
 16 | package org.tensorflow.demo.env;
 17 | 
 18 | import android.graphics.Canvas;
 19 | import android.graphics.Color;
 20 | import android.graphics.Paint;
 21 | import android.graphics.Paint.Align;
 22 | import android.graphics.Paint.Style;
 23 | import android.graphics.Rect;
 24 | import android.graphics.Typeface;
 25 | import java.util.Vector;
 26 | 
 27 | /**
 28 |  * A class that encapsulates the tedious bits of rendering legible, bordered text onto a canvas.
 29 |  */
 30 | public class BorderedText {
 31 |   private final Paint interiorPaint;
 32 |   private final Paint exteriorPaint;
 33 | 
 34 |   private final float textSize;
 35 | 
 36 |   /**
 37 |    * Creates a left-aligned bordered text object with a white interior, and a black exterior with
 38 |    * the specified text size.
 39 |    *
 40 |    * @param textSize text size in pixels
 41 |    */
 42 |   public BorderedText(final float textSize) {
 43 |     this(Color.WHITE, Color.BLACK, textSize);
 44 |   }
 45 | 
 46 |   /**
 47 |    * Create a bordered text object with the specified interior and exterior colors, text size and
 48 |    * alignment.
 49 |    *
 50 |    * @param interiorColor the interior text color
 51 |    * @param exteriorColor the exterior text color
 52 |    * @param textSize text size in pixels
 53 |    */
 54 |   public BorderedText(final int interiorColor, final int exteriorColor, final float textSize) {
 55 |     interiorPaint = new Paint();
 56 |     interiorPaint.setTextSize(textSize);
 57 |     interiorPaint.setColor(interiorColor);
 58 |     interiorPaint.setStyle(Style.FILL);
 59 |     interiorPaint.setAntiAlias(false);
 60 |     interiorPaint.setAlpha(255);
 61 | 
 62 |     exteriorPaint = new Paint();
 63 |     exteriorPaint.setTextSize(textSize);
 64 |     exteriorPaint.setColor(exteriorColor);
 65 |     exteriorPaint.setStyle(Style.FILL_AND_STROKE);
 66 |     exteriorPaint.setStrokeWidth(textSize / 8);
 67 |     exteriorPaint.setAntiAlias(false);
 68 |     exteriorPaint.setAlpha(255);
 69 | 
 70 |     this.textSize = textSize;
 71 |   }
 72 | 
 73 |   public void setTypeface(Typeface typeface) {
 74 |     interiorPaint.setTypeface(typeface);
 75 |     exteriorPaint.setTypeface(typeface);
 76 |   }
 77 | 
 78 |   public void drawText(final Canvas canvas, final float posX, final float posY, final String text) {
 79 |     canvas.drawText(text, posX, posY, exteriorPaint);
 80 |     canvas.drawText(text, posX, posY, interiorPaint);
 81 |   }
 82 | 
 83 |   public void drawLines(Canvas canvas, final float posX, final float posY, Vector<String> lines) {
 84 |     int lineNum = 0;
 85 |     for (final String line : lines) {
 86 |       drawText(canvas, posX, posY - getTextSize() * (lines.size() - lineNum - 1), line);
 87 |       ++lineNum;
 88 |     }
 89 |   }
 90 | 
 91 |   public void setInteriorColor(final int color) {
 92 |     interiorPaint.setColor(color);
 93 |   }
 94 | 
 95 |   public void setExteriorColor(final int color) {
 96 |     exteriorPaint.setColor(color);
 97 |   }
 98 | 
 99 |   public float getTextSize() {
100 |     return textSize;
101 |   }
102 | 
103 |   public void setAlpha(final int alpha) {
104 |     interiorPaint.setAlpha(alpha);
105 |     exteriorPaint.setAlpha(alpha);
106 |   }
107 | 
108 |   public void getTextBounds(
109 |       final String line, final int index, final int count, final Rect lineBounds) {
110 |     interiorPaint.getTextBounds(line, index, count, lineBounds);
111 |   }
112 | 
113 |   public void setTextAlign(final Align align) {
114 |     interiorPaint.setTextAlign(align);
115 |     exteriorPaint.setTextAlign(align);
116 |   }
117 | }
118 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/env/ImageUtils.java:
--------------------------------------------------------------------------------
  1 | /* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
  2 | 
  3 | Licensed under the Apache License, Version 2.0 (the "License");
  4 | you may not use this file except in compliance with the License.
  5 | You may obtain a copy of the License at
  6 | 
  7 |     http://www.apache.org/licenses/LICENSE-2.0
  8 | 
  9 | Unless required by applicable law or agreed to in writing, software
 10 | distributed under the License is distributed on an "AS IS" BASIS,
 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | See the License for the specific language governing permissions and
 13 | limitations under the License.
 14 | ==============================================================================*/
 15 | 
 16 | package org.tensorflow.demo.env;
 17 | 
 18 | import android.graphics.Bitmap;
 19 | import android.graphics.Matrix;
 20 | import android.os.Environment;
 21 | import java.io.File;
 22 | import java.io.FileOutputStream;
 23 | 
 24 | /**
 25 |  * Utility class for manipulating images.
 26 |  **/
 27 | public class ImageUtils {
 28 |   @SuppressWarnings("unused")
 29 |   private static final Logger LOGGER = new Logger();
 30 | 
 31 |   /**
 32 |    * Utility method to compute the allocated size in bytes of a YUV420SP image
 33 |    * of the given dimensions.
 34 |    */
 35 |   public static int getYUVByteSize(final int width, final int height) {
 36 |     // The luminance plane requires 1 byte per pixel.
 37 |     final int ySize = width * height;
 38 | 
 39 |     // The UV plane works on 2x2 blocks, so dimensions with odd size must be rounded up.
 40 |     // Each 2x2 block takes 2 bytes to encode, one each for U and V.
 41 |     final int uvSize = ((width + 1) / 2) * ((height + 1) / 2) * 2;
 42 | 
 43 |     return ySize + uvSize;
 44 |   }
 45 | 
 46 |   /**
 47 |    * Saves a Bitmap object to disk for analysis.
 48 |    *
 49 |    * @param bitmap The bitmap to save.
 50 |    */
 51 |   public static void saveBitmap(final Bitmap bitmap) {
 52 |     saveBitmap(bitmap, "preview.png");
 53 |   }
 54 | 
 55 |   /**
 56 |    * Saves a Bitmap object to disk for analysis.
 57 |    *
 58 |    * @param bitmap The bitmap to save.
 59 |    * @param filename The location to save the bitmap to.
 60 |    */
 61 |   public static void saveBitmap(final Bitmap bitmap, final String filename) {
 62 |     final String root =
 63 |         Environment.getExternalStorageDirectory().getAbsolutePath() + File.separator + "tensorflow";
 64 |     LOGGER.i("Saving %dx%d bitmap to %s.", bitmap.getWidth(), bitmap.getHeight(), root);
 65 |     final File myDir = new File(root);
 66 | 
 67 |     if (!myDir.mkdirs()) {
 68 |       LOGGER.i("Make dir failed");
 69 |     }
 70 | 
 71 |     final String fname = filename;
 72 |     final File file = new File(myDir, fname);
 73 |     if (file.exists()) {
 74 |       file.delete();
 75 |     }
 76 |     try {
 77 |       final FileOutputStream out = new FileOutputStream(file);
 78 |       bitmap.compress(Bitmap.CompressFormat.PNG, 99, out);
 79 |       out.flush();
 80 |       out.close();
 81 |     } catch (final Exception e) {
 82 |       LOGGER.e(e, "Exception!");
 83 |     }
 84 |   }
 85 | 
 86 |   /**
 87 |    * Converts YUV420 semi-planar data to ARGB 8888 data using the supplied width
 88 |    * and height. The input and output must already be allocated and non-null.
 89 |    * For efficiency, no error checking is performed.
 90 |    *
 91 |    * @param input The array of YUV 4:2:0 input data.
 92 |    * @param output A pre-allocated array for the ARGB 8:8:8:8 output data.
 93 |    * @param width The width of the input image.
 94 |    * @param height The height of the input image.
 95 |    * @param halfSize If true, downsample to 50% in each dimension, otherwise not.
 96 |    */
 97 |   public static native void convertYUV420SPToARGB8888(
 98 |       byte[] input, int[] output, int width, int height, boolean halfSize);
 99 | 
100 |   /**
101 |    * Converts YUV420 semi-planar data to ARGB 8888 data using the supplied width
102 |    * and height. The input and output must already be allocated and non-null.
103 |    * For efficiency, no error checking is performed.
104 |    *
105 |    * @param y
106 |    * @param u
107 |    * @param v
108 |    * @param uvPixelStride
109 |    * @param width The width of the input image.
110 |    * @param height The height of the input image.
111 |    * @param halfSize If true, downsample to 50% in each dimension, otherwise not.
112 |    * @param output A pre-allocated array for the ARGB 8:8:8:8 output data.
113 |    */
114 |   public static native void convertYUV420ToARGB8888(
115 |       byte[] y,
116 |       byte[] u,
117 |       byte[] v,
118 |       int[] output,
119 |       int width,
120 |       int height,
121 |       int yRowStride,
122 |       int uvRowStride,
123 |       int uvPixelStride,
124 |       boolean halfSize);
125 | 
126 |   /**
127 |    * Converts YUV420 semi-planar data to RGB 565 data using the supplied width
128 |    * and height. The input and output must already be allocated and non-null.
129 |    * For efficiency, no error checking is performed.
130 |    *
131 |    * @param input The array of YUV 4:2:0 input data.
132 |    * @param output A pre-allocated array for the RGB 5:6:5 output data.
133 |    * @param width The width of the input image.
134 |    * @param height The height of the input image.
135 |    */
136 |   public static native void convertYUV420SPToRGB565(
137 |       byte[] input, byte[] output, int width, int height);
138 | 
139 |   /**
140 |    * Converts 32-bit ARGB8888 image data to YUV420SP data.  This is useful, for
141 |    * instance, in creating data to feed the classes that rely on raw camera
142 |    * preview frames.
143 |    *
144 |    * @param input An array of input pixels in ARGB8888 format.
145 |    * @param output A pre-allocated array for the YUV420SP output data.
146 |    * @param width The width of the input image.
147 |    * @param height The height of the input image.
148 |    */
149 |   public static native void convertARGB8888ToYUV420SP(
150 |       int[] input, byte[] output, int width, int height);
151 | 
152 |   /**
153 |    * Converts 16-bit RGB565 image data to YUV420SP data.  This is useful, for
154 |    * instance, in creating data to feed the classes that rely on raw camera
155 |    * preview frames.
156 |    *
157 |    * @param input An array of input pixels in RGB565 format.
158 |    * @param output A pre-allocated array for the YUV420SP output data.
159 |    * @param width The width of the input image.
160 |    * @param height The height of the input image.
161 |    */
162 |   public static native void convertRGB565ToYUV420SP(
163 |       byte[] input, byte[] output, int width, int height);
164 | 
165 |   /**
166 |    * Returns a transformation matrix from one reference frame into another.
167 |    * Handles cropping (if maintaining aspect ratio is desired) and rotation.
168 |    *
169 |    * @param srcWidth Width of source frame.
170 |    * @param srcHeight Height of source frame.
171 |    * @param dstWidth Width of destination frame.
172 |    * @param dstHeight Height of destination frame.
173 |    * @param applyRotation Amount of rotation to apply from one frame to another.
174 |    *  Must be a multiple of 90.
175 |    * @param maintainAspectRatio If true, will ensure that scaling in x and y remains constant,
176 |    * cropping the image if necessary.
177 |    * @return The transformation fulfilling the desired requirements.
178 |    */
179 |   public static Matrix getTransformationMatrix(
180 |       final int srcWidth,
181 |       final int srcHeight,
182 |       final int dstWidth,
183 |       final int dstHeight,
184 |       final int applyRotation,
185 |       final boolean maintainAspectRatio) {
186 |     final Matrix matrix = new Matrix();
187 | 
188 |     if (applyRotation != 0) {
189 |       // Translate so center of image is at origin.
190 |       matrix.postTranslate(-srcWidth / 2.0f, -srcHeight / 2.0f);
191 | 
192 |       // Rotate around origin.
193 |       matrix.postRotate(applyRotation);
194 |     }
195 | 
196 |     // Account for the already applied rotation, if any, and then determine how
197 |     // much scaling is needed for each axis.
198 |     final boolean transpose = (Math.abs(applyRotation) + 90) % 180 == 0;
199 | 
200 |     final int inWidth = transpose ? srcHeight : srcWidth;
201 |     final int inHeight = transpose ? srcWidth : srcHeight;
202 | 
203 |     // Apply scaling if necessary.
204 |     if (inWidth != dstWidth || inHeight != dstHeight) {
205 |       final float scaleFactorX = dstWidth / (float) inWidth;
206 |       final float scaleFactorY = dstHeight / (float) inHeight;
207 | 
208 |       if (maintainAspectRatio) {
209 |         // Scale by minimum factor so that dst is filled completely while
210 |         // maintaining the aspect ratio. Some image may fall off the edge.
211 |         final float scaleFactor = Math.max(scaleFactorX, scaleFactorY);
212 |         matrix.postScale(scaleFactor, scaleFactor);
213 |       } else {
214 |         // Scale exactly to fill dst from src.
215 |         matrix.postScale(scaleFactorX, scaleFactorY);
216 |       }
217 |     }
218 | 
219 |     if (applyRotation != 0) {
220 |       // Translate back from origin centered reference to destination frame.
221 |       matrix.postTranslate(dstWidth / 2.0f, dstHeight / 2.0f);
222 |     }
223 | 
224 |     return matrix;
225 |   }
226 | }
227 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/env/Logger.java:
--------------------------------------------------------------------------------
  1 | /* Copyright 2015 The TensorFlow Authors. All Rights Reserved.
  2 | 
  3 | Licensed under the Apache License, Version 2.0 (the "License");
  4 | you may not use this file except in compliance with the License.
  5 | You may obtain a copy of the License at
  6 | 
  7 |     http://www.apache.org/licenses/LICENSE-2.0
  8 | 
  9 | Unless required by applicable law or agreed to in writing, software
 10 | distributed under the License is distributed on an "AS IS" BASIS,
 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | See the License for the specific language governing permissions and
 13 | limitations under the License.
 14 | ==============================================================================*/
 15 | 
 16 | package org.tensorflow.demo.env;
 17 | 
 18 | import android.util.Log;
 19 | 
 20 | import java.util.HashSet;
 21 | import java.util.Set;
 22 | 
 23 | /**
 24 |  * Wrapper for the platform log function, allows convenient message prefixing and log disabling.
 25 |  */
 26 | public final class Logger {
 27 |   private static final String DEFAULT_TAG = "tensorflow";
 28 |   private static final int DEFAULT_MIN_LOG_LEVEL = Log.DEBUG;
 29 | 
 30 |   // Classes to be ignored when examining the stack trace
 31 |   private static final Set<String> IGNORED_CLASS_NAMES;
 32 | 
 33 |   static {
 34 |     IGNORED_CLASS_NAMES = new HashSet<String>(3);
 35 |     IGNORED_CLASS_NAMES.add("dalvik.system.VMStack");
 36 |     IGNORED_CLASS_NAMES.add("java.lang.Thread");
 37 |     IGNORED_CLASS_NAMES.add(Logger.class.getCanonicalName());
 38 |   }
 39 | 
 40 |   private final String tag;
 41 |   private final String messagePrefix;
 42 |   private int minLogLevel = DEFAULT_MIN_LOG_LEVEL;
 43 | 
 44 |   /**
 45 |    * Creates a Logger using the class name as the message prefix.
 46 |    *
 47 |    * @param clazz the simple name of this class is used as the message prefix.
 48 |    */
 49 |   public Logger(final Class<?> clazz) {
 50 |     this(clazz.getSimpleName());
 51 |   }
 52 | 
 53 |   /**
 54 |    * Creates a Logger using the specified message prefix.
 55 |    *
 56 |    * @param messagePrefix is prepended to the text of every message.
 57 |    */
 58 |   public Logger(final String messagePrefix) {
 59 |     this(DEFAULT_TAG, messagePrefix);
 60 |   }
 61 | 
 62 |   /**
 63 |    * Creates a Logger with a custom tag and a custom message prefix. If the message prefix
 64 |    * is set to <pre>null</pre>, the caller's class name is used as the prefix.
 65 |    *
 66 |    * @param tag identifies the source of a log message.
 67 |    * @param messagePrefix prepended to every message if non-null. If null, the name of the caller is
 68 |    *                      being used
 69 |    */
 70 |   public Logger(final String tag, final String messagePrefix) {
 71 |     this.tag = tag;
 72 |     final String prefix = messagePrefix == null ? getCallerSimpleName() : messagePrefix;
 73 |     this.messagePrefix = (prefix.length() > 0) ? prefix + ": " : prefix;
 74 |   }
 75 | 
 76 |   /**
 77 |    * Creates a Logger using the caller's class name as the message prefix.
 78 |    */
 79 |   public Logger() {
 80 |     this(DEFAULT_TAG, null);
 81 |   }
 82 | 
 83 |   /**
 84 |    * Creates a Logger using the caller's class name as the message prefix.
 85 |    */
 86 |   public Logger(final int minLogLevel) {
 87 |     this(DEFAULT_TAG, null);
 88 |     this.minLogLevel = minLogLevel;
 89 |   }
 90 | 
 91 |   public void setMinLogLevel(final int minLogLevel) {
 92 |     this.minLogLevel = minLogLevel;
 93 |   }
 94 | 
 95 |   public boolean isLoggable(final int logLevel) {
 96 |     return logLevel >= minLogLevel || Log.isLoggable(tag, logLevel);
 97 |   }
 98 | 
 99 |   /**
100 |    * Return caller's simple name.
101 |    *
102 |    * Android getStackTrace() returns an array that looks like this:
103 |    *     stackTrace[0]: dalvik.system.VMStack
104 |    *     stackTrace[1]: java.lang.Thread
105 |    *     stackTrace[2]: com.google.android.apps.unveil.env.UnveilLogger
106 |    *     stackTrace[3]: com.google.android.apps.unveil.BaseApplication
107 |    *
108 |    * This function returns the simple version of the first non-filtered name.
109 |    *
110 |    * @return caller's simple name
111 |    */
112 |   private static String getCallerSimpleName() {
113 |     // Get the current callstack so we can pull the class of the caller off of it.
114 |     final StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
115 | 
116 |     for (final StackTraceElement elem : stackTrace) {
117 |       final String className = elem.getClassName();
118 |       if (!IGNORED_CLASS_NAMES.contains(className)) {
119 |         // We're only interested in the simple name of the class, not the complete package.
120 |         final String[] classParts = className.split("\\.");
121 |         return classParts[classParts.length - 1];
122 |       }
123 |     }
124 | 
125 |     return Logger.class.getSimpleName();
126 |   }
127 | 
128 |   private String toMessage(final String format, final Object... args) {
129 |     return messagePrefix + (args.length > 0 ? String.format(format, args) : format);
130 |   }
131 | 
132 |   public void v(final String format, final Object... args) {
133 |     if (isLoggable(Log.VERBOSE)) {
134 |       Log.v(tag, toMessage(format, args));
135 |     }
136 |   }
137 | 
138 |   public void v(final Throwable t, final String format, final Object... args) {
139 |     if (isLoggable(Log.VERBOSE)) {
140 |       Log.v(tag, toMessage(format, args), t);
141 |     }
142 |   }
143 | 
144 |   public void d(final String format, final Object... args) {
145 |     if (isLoggable(Log.DEBUG)) {
146 |       Log.d(tag, toMessage(format, args));
147 |     }
148 |   }
149 | 
150 |   public void d(final Throwable t, final String format, final Object... args) {
151 |     if (isLoggable(Log.DEBUG)) {
152 |       Log.d(tag, toMessage(format, args), t);
153 |     }
154 |   }
155 | 
156 |   public void i(final String format, final Object... args) {
157 |     if (isLoggable(Log.INFO)) {
158 |       Log.i(tag, toMessage(format, args));
159 |     }
160 |   }
161 | 
162 |   public void i(final Throwable t, final String format, final Object... args) {
163 |     if (isLoggable(Log.INFO)) {
164 |       Log.i(tag, toMessage(format, args), t);
165 |     }
166 |   }
167 | 
168 |   public void w(final String format, final Object... args) {
169 |     if (isLoggable(Log.WARN)) {
170 |       Log.w(tag, toMessage(format, args));
171 |     }
172 |   }
173 | 
174 |   public void w(final Throwable t, final String format, final Object... args) {
175 |     if (isLoggable(Log.WARN)) {
176 |       Log.w(tag, toMessage(format, args), t);
177 |     }
178 |   }
179 | 
180 |   public void e(final String format, final Object... args) {
181 |     if (isLoggable(Log.ERROR)) {
182 |       Log.e(tag, toMessage(format, args));
183 |     }
184 |   }
185 | 
186 |   public void e(final Throwable t, final String format, final Object... args) {
187 |     if (isLoggable(Log.ERROR)) {
188 |       Log.e(tag, toMessage(format, args), t);
189 |     }
190 |   }
191 | }
192 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/env/Size.java:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
  2 | 
  3 | Licensed under the Apache License, Version 2.0 (the "License");
  4 | you may not use this file except in compliance with the License.
  5 | You may obtain a copy of the License at
  6 | 
  7 |     http://www.apache.org/licenses/LICENSE-2.0
  8 | 
  9 | Unless required by applicable law or agreed to in writing, software
 10 | distributed under the License is distributed on an "AS IS" BASIS,
 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | See the License for the specific language governing permissions and
 13 | limitations under the License.
 14 | ==============================================================================*/
 15 | 
 16 | package org.tensorflow.demo.env;
 17 | 
 18 | import android.graphics.Bitmap;
 19 | import android.text.TextUtils;
 20 | import java.io.Serializable;
 21 | import java.util.ArrayList;
 22 | import java.util.List;
 23 | 
 24 | /**
 25 |  * Size class independent of a Camera object.
 26 |  */
 27 | public class Size implements Comparable<Size>, Serializable {
 28 | 
 29 |   // 1.4 went out with this UID so we'll need to maintain it to preserve pending queries when
 30 |   // upgrading.
 31 |   public static final long serialVersionUID = 7689808733290872361L;
 32 | 
 33 |   public final int width;
 34 |   public final int height;
 35 | 
 36 |   public Size(final int width, final int height) {
 37 |     this.width = width;
 38 |     this.height = height;
 39 |   }
 40 | 
 41 |   public Size(final Bitmap bmp) {
 42 |     this.width = bmp.getWidth();
 43 |     this.height = bmp.getHeight();
 44 |   }
 45 | 
 46 |   /**
 47 |    * Rotate a size by the given number of degrees.
 48 |    * @param size Size to rotate.
 49 |    * @param rotation Degrees {0, 90, 180, 270} to rotate the size.
 50 |    * @return Rotated size.
 51 |    */
 52 |   public static Size getRotatedSize(final Size size, final int rotation) {
 53 |     if (rotation % 180 != 0) {
 54 |       // The phone is portrait, therefore the camera is sideways and frame should be rotated.
 55 |       return new Size(size.height, size.width);
 56 |     }
 57 |     return size;
 58 |   }
 59 | 
 60 |   public static Size parseFromString(String sizeString) {
 61 |     if (TextUtils.isEmpty(sizeString)) {
 62 |       return null;
 63 |     }
 64 | 
 65 |     sizeString = sizeString.trim();
 66 | 
 67 |     // The expected format is "<width>x<height>".
 68 |     final String[] components = sizeString.split("x");
 69 |     if (components.length == 2) {
 70 |       try {
 71 |         final int width = Integer.parseInt(components[0]);
 72 |         final int height = Integer.parseInt(components[1]);
 73 |         return new Size(width, height);
 74 |       } catch (final NumberFormatException e) {
 75 |         return null;
 76 |       }
 77 |     } else {
 78 |       return null;
 79 |     }
 80 |   }
 81 | 
 82 |   public static List<Size> sizeStringToList(final String sizes) {
 83 |     final List<Size> sizeList = new ArrayList<Size>();
 84 |     if (sizes != null) {
 85 |       final String[] pairs = sizes.split(",");
 86 |       for (final String pair : pairs) {
 87 |         final Size size = Size.parseFromString(pair);
 88 |         if (size != null) {
 89 |           sizeList.add(size);
 90 |         }
 91 |       }
 92 |     }
 93 |     return sizeList;
 94 |   }
 95 | 
 96 |   public static String sizeListToString(final List<Size> sizes) {
 97 |     String sizesString = "";
 98 |     if (sizes != null && sizes.size() > 0) {
 99 |       sizesString = sizes.get(0).toString();
100 |       for (int i = 1; i < sizes.size(); i++) {
101 |         sizesString += "," + sizes.get(i).toString();
102 |       }
103 |     }
104 |     return sizesString;
105 |   }
106 | 
107 |   public final float aspectRatio() {
108 |     return (float) width / (float) height;
109 |   }
110 | 
111 |   @Override
112 |   public int compareTo(final Size other) {
113 |     return width * height - other.width * other.height;
114 |   }
115 | 
116 |   @Override
117 |   public boolean equals(final Object other) {
118 |     if (other == null) {
119 |       return false;
120 |     }
121 | 
122 |     if (!(other instanceof Size)) {
123 |       return false;
124 |     }
125 | 
126 |     final Size otherSize = (Size) other;
127 |     return (width == otherSize.width && height == otherSize.height);
128 |   }
129 | 
130 |   @Override
131 |   public int hashCode() {
132 |     return width * 32713 + height;
133 |   }
134 | 
135 |   @Override
136 |   public String toString() {
137 |     return dimensionsAsString(width, height);
138 |   }
139 | 
140 |   public static final String dimensionsAsString(final int width, final int height) {
141 |     return width + "x" + height;
142 |   }
143 | }
144 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/env/SplitTimer.java:
--------------------------------------------------------------------------------
 1 | /* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
 2 | 
 3 | Licensed under the Apache License, Version 2.0 (the "License");
 4 | you may not use this file except in compliance with the License.
 5 | You may obtain a copy of the License at
 6 | 
 7 |     http://www.apache.org/licenses/LICENSE-2.0
 8 | 
 9 | Unless required by applicable law or agreed to in writing, software
10 | distributed under the License is distributed on an "AS IS" BASIS,
11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 | See the License for the specific language governing permissions and
13 | limitations under the License.
14 | ==============================================================================*/
15 | 
16 | package org.tensorflow.demo.env;
17 | 
18 | import android.os.SystemClock;
19 | 
20 | /**
21 |  * A simple utility timer for measuring CPU time and wall-clock splits.
22 |  */
23 | public class SplitTimer {
24 |   private final Logger logger;
25 | 
26 |   private long lastWallTime;
27 |   private long lastCpuTime;
28 | 
29 |   public SplitTimer(final String name) {
30 |     logger = new Logger(name);
31 |     newSplit();
32 |   }
33 | 
34 |   public void newSplit() {
35 |     lastWallTime = SystemClock.uptimeMillis();
36 |     lastCpuTime = SystemClock.currentThreadTimeMillis();
37 |   }
38 | 
39 |   public void endSplit(final String splitName) {
40 |     final long currWallTime = SystemClock.uptimeMillis();
41 |     final long currCpuTime = SystemClock.currentThreadTimeMillis();
42 | 
43 |     logger.i(
44 |         "%s: cpu=%dms wall=%dms",
45 |         splitName, currCpuTime - lastCpuTime, currWallTime - lastWallTime);
46 | 
47 |     lastWallTime = currWallTime;
48 |     lastCpuTime = currCpuTime;
49 |   }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/tracking/MultiBoxTracker.java:
--------------------------------------------------------------------------------
  1 | /* Copyright 2016 The TensorFlow Authors. All Rights Reserved.
  2 | 
  3 | Licensed under the Apache License, Version 2.0 (the "License");
  4 | you may not use this file except in compliance with the License.
  5 | You may obtain a copy of the License at
  6 | 
  7 |     http://www.apache.org/licenses/LICENSE-2.0
  8 | 
  9 | Unless required by applicable law or agreed to in writing, software
 10 | distributed under the License is distributed on an "AS IS" BASIS,
 11 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12 | See the License for the specific language governing permissions and
 13 | limitations under the License.
 14 | ==============================================================================*/
 15 | 
 16 | package org.tensorflow.demo.tracking;
 17 | 
 18 | import android.graphics.Canvas;
 19 | import android.graphics.Color;
 20 | import android.graphics.Matrix;
 21 | import android.graphics.Paint;
 22 | import android.graphics.Paint.Cap;
 23 | import android.graphics.Paint.Join;
 24 | import android.graphics.Paint.Style;
 25 | import android.graphics.RectF;
 26 | import android.text.TextUtils;
 27 | import android.util.DisplayMetrics;
 28 | import android.util.Pair;
 29 | import android.util.TypedValue;
 30 | import java.util.LinkedList;
 31 | import java.util.List;
 32 | import java.util.Queue;
 33 | import org.tensorflow.demo.Classifier.Recognition;
 34 | import org.tensorflow.demo.env.BorderedText;
 35 | import org.tensorflow.demo.env.ImageUtils;
 36 | import org.tensorflow.demo.env.Logger;
 37 | 
 38 | /**
 39 |  * A tracker wrapping ObjectTracker that also handles non-max suppression and matching existing
 40 |  * objects to new detections.
 41 |  */
 42 | public class MultiBoxTracker {
 43 |   private final Logger logger = new Logger();
 44 | 
 45 |   private static final float TEXT_SIZE_DIP = 18;
 46 | 
 47 |   // Maximum percentage of a box that can be overlapped by another box at detection time. Otherwise
 48 |   // the lower scored box (new or old) will be removed.
 49 |   private static final float MAX_OVERLAP = 0.2f;
 50 | 
 51 |   private static final float MIN_SIZE = 16.0f;
 52 | 
 53 |   // Allow replacement of the tracked box with new results if
 54 |   // correlation has dropped below this level.
 55 |   private static final float MARGINAL_CORRELATION = 0.75f;
 56 | 
 57 |   // Consider object to be lost if correlation falls below this threshold.
 58 |   private static final float MIN_CORRELATION = 0.3f;
 59 | 
 60 |   private static final int[] COLORS = {
 61 |     Color.BLUE, Color.RED, Color.GREEN, Color.YELLOW, Color.CYAN, Color.MAGENTA
 62 |   };
 63 | 
 64 |   private final Queue<Integer> availableColors = new LinkedList<Integer>();
 65 | 
 66 |   public ObjectTracker objectTracker;
 67 | 
 68 |   final List<Pair<Float, RectF>> screenRects = new LinkedList<Pair<Float, RectF>>();
 69 | 
 70 |   private static class TrackedRecognition {
 71 |     ObjectTracker.TrackedObject trackedObject;
 72 |     float detectionConfidence;
 73 |     int color;
 74 |     String title;
 75 |   }
 76 | 
 77 |   private final List<TrackedRecognition> trackedObjects = new LinkedList<TrackedRecognition>();
 78 | 
 79 |   private final Paint boxPaint = new Paint();
 80 | 
 81 |   private final float textSizePx;
 82 |   private final BorderedText borderedText;
 83 | 
 84 |   private Matrix frameToCanvasMatrix;
 85 | 
 86 |   private int frameWidth;
 87 |   private int frameHeight;
 88 | 
 89 |   private int sensorOrientation;
 90 | 
 91 |   public MultiBoxTracker(final DisplayMetrics metrics) {
 92 |     for (final int color : COLORS) {
 93 |       availableColors.add(color);
 94 |     }
 95 | 
 96 |     boxPaint.setColor(Color.RED);
 97 |     boxPaint.setStyle(Style.STROKE);
 98 |     boxPaint.setStrokeWidth(12.0f);
 99 |     boxPaint.setStrokeCap(Cap.ROUND);
100 |     boxPaint.setStrokeJoin(Join.ROUND);
101 |     boxPaint.setStrokeMiter(100);
102 | 
103 |     textSizePx = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, TEXT_SIZE_DIP, metrics);
104 |     borderedText = new BorderedText(textSizePx);
105 |   }
106 | 
107 |   private Matrix getFrameToCanvasMatrix() {
108 |     return frameToCanvasMatrix;
109 |   }
110 | 
111 |   public synchronized void drawDebug(final Canvas canvas) {
112 |     final Paint textPaint = new Paint();
113 |     textPaint.setColor(Color.WHITE);
114 |     textPaint.setTextSize(60.0f);
115 | 
116 |     final Paint boxPaint = new Paint();
117 |     boxPaint.setColor(Color.RED);
118 |     boxPaint.setAlpha(200);
119 |     boxPaint.setStyle(Style.STROKE);
120 | 
121 |     for (final Pair<Float, RectF> detection : screenRects) {
122 |       final RectF rect = detection.second;
123 |       canvas.drawRect(rect, boxPaint);
124 |       canvas.drawText("" + detection.first, rect.left, rect.top, textPaint);
125 |       borderedText.drawText(canvas, rect.centerX(), rect.centerY(), "" + detection.first);
126 |     }
127 | 
128 |     if (objectTracker == null) {
129 |       return;
130 |     }
131 | 
132 |     // Draw correlations.
133 |     for (final TrackedRecognition recognition : trackedObjects) {
134 |       final ObjectTracker.TrackedObject trackedObject = recognition.trackedObject;
135 | 
136 |       final RectF trackedPos = trackedObject.getTrackedPositionInPreviewFrame();
137 | 
138 |       if (getFrameToCanvasMatrix().mapRect(trackedPos)) {
139 |         final String labelString = String.format("%.2f", trackedObject.getCurrentCorrelation());
140 |         borderedText.drawText(canvas, trackedPos.right, trackedPos.bottom, labelString);
141 |       }
142 |     }
143 | 
144 |     final Matrix matrix = getFrameToCanvasMatrix();
145 |     objectTracker.drawDebug(canvas, matrix);
146 |   }
147 | 
148 |   public synchronized void trackResults(
149 |       final List<Recognition> results, final byte[] frame, final long timestamp) {
150 |     logger.i("Processing %d results from %d", results.size(), timestamp);
151 |     processResults(timestamp, results, frame);
152 |   }
153 | 
154 |   public synchronized void draw(final Canvas canvas) {
155 |     if (objectTracker == null) {
156 |       return;
157 |     }
158 | 
159 |     // TODO(andrewharp): This may not work for non-90 deg rotations.
160 |     final float multiplier =
161 |         Math.min(canvas.getWidth() / (float) frameHeight, canvas.getHeight() / (float) frameWidth);
162 |     frameToCanvasMatrix =
163 |         ImageUtils.getTransformationMatrix(
164 |             frameWidth,
165 |             frameHeight,
166 |             (int) (multiplier * frameHeight),
167 |             (int) (multiplier * frameWidth),
168 |             sensorOrientation,
169 |             false);
170 |     for (final TrackedRecognition recognition : trackedObjects) {
171 |       final ObjectTracker.TrackedObject trackedObject = recognition.trackedObject;
172 | 
173 |       final RectF trackedPos = trackedObject.getTrackedPositionInPreviewFrame();
174 |       getFrameToCanvasMatrix().mapRect(trackedPos);
175 |       boxPaint.setColor(recognition.color);
176 | 
177 |       final float cornerSize = Math.min(trackedPos.width(), trackedPos.height()) / 8.0f;
178 |       canvas.drawRoundRect(trackedPos, cornerSize, cornerSize, boxPaint);
179 | 
180 |       final String labelString =
181 |           !TextUtils.isEmpty(recognition.title)
182 |               ? String.format("%s %.2f", recognition.title, recognition.detectionConfidence)
183 |               : String.format("%.2f", recognition.detectionConfidence);
184 |       borderedText.drawText(canvas, trackedPos.left + cornerSize, trackedPos.bottom, labelString);
185 |     }
186 |   }
187 | 
188 |   public synchronized void onFrame(
189 |       final int w,
190 |       final int h,
191 |       final int rowStride,
192 |       final int sensorOrienation,
193 |       final byte[] frame,
194 |       final long timestamp) {
195 |     if (objectTracker == null) {
196 |       ObjectTracker.clearInstance();
197 | 
198 |       logger.i("Initializing ObjectTracker: %dx%d", w, h);
199 |       objectTracker = ObjectTracker.getInstance(w, h, rowStride, true);
200 |       frameWidth = w;
201 |       frameHeight = h;
202 |       this.sensorOrientation = sensorOrienation;
203 |     }
204 | 
205 |     objectTracker.nextFrame(frame, null, timestamp, null, true);
206 | 
207 |     // Clean up any objects not worth tracking any more.
208 |     final LinkedList<TrackedRecognition> copyList =
209 |         new LinkedList<TrackedRecognition>(trackedObjects);
210 |     for (final TrackedRecognition recognition : copyList) {
211 |       final ObjectTracker.TrackedObject trackedObject = recognition.trackedObject;
212 |       final float correlation = trackedObject.getCurrentCorrelation();
213 |       if (correlation < MIN_CORRELATION) {
214 |         logger.v("Removing tracked object %s because NCC is %.2f", trackedObject, correlation);
215 |         trackedObject.stopTracking();
216 |         trackedObjects.remove(recognition);
217 | 
218 |         availableColors.add(recognition.color);
219 |       }
220 |     }
221 |   }
222 | 
223 |   private void processResults(
224 |       final long timestamp, final List<Recognition> results, final byte[] originalFrame) {
225 |     final List<Pair<Float, Recognition>> rectsToTrack = new LinkedList<Pair<Float, Recognition>>();
226 | 
227 |     screenRects.clear();
228 |     final Matrix rgbFrameToScreen = new Matrix(getFrameToCanvasMatrix());
229 | 
230 |     for (final Recognition result : results) {
231 |       if (result.getLocation() == null) {
232 |         continue;
233 |       }
234 |       final RectF detectionFrameRect = new RectF(result.getLocation());
235 | 
236 |       final RectF detectionScreenRect = new RectF();
237 |       rgbFrameToScreen.mapRect(detectionScreenRect, detectionFrameRect);
238 | 
239 |       logger.v(
240 |           "Result! Frame: " + result.getLocation() + " mapped to screen:" + detectionScreenRect);
241 | 
242 |       screenRects.add(new Pair<Float, RectF>(result.getConfidence(), detectionScreenRect));
243 | 
244 |       if (detectionFrameRect.width() < MIN_SIZE || detectionFrameRect.height() < MIN_SIZE) {
245 |         logger.w("Degenerate rectangle! " + detectionFrameRect);
246 |         continue;
247 |       }
248 | 
249 |       rectsToTrack.add(new Pair<Float, Recognition>(result.getConfidence(), result));
250 |     }
251 | 
252 |     if (rectsToTrack.isEmpty()) {
253 |       logger.v("Nothing to track, aborting.");
254 |       return;
255 |     }
256 | 
257 |     if (objectTracker == null) {
258 |       logger.w("No ObjectTracker, can't track anything!");
259 |       return;
260 |     }
261 | 
262 |     logger.i("%d rects to track", rectsToTrack.size());
263 |     for (final Pair<Float, Recognition> potential : rectsToTrack) {
264 |       handleDetection(originalFrame, timestamp, potential);
265 |     }
266 |   }
267 | 
268 |   private void handleDetection(
269 |       final byte[] frameCopy, final long timestamp, final Pair<Float, Recognition> potential) {
270 |     final ObjectTracker.TrackedObject potentialObject =
271 |         objectTracker.trackObject(potential.second.getLocation(), timestamp, frameCopy);
272 | 
273 |     final float potentialCorrelation = potentialObject.getCurrentCorrelation();
274 |     logger.v(
275 |         "Tracked object went from %s to %s with correlation %.2f",
276 |         potential.second, potentialObject.getTrackedPositionInPreviewFrame(), potentialCorrelation);
277 | 
278 |     if (potentialCorrelation < MARGINAL_CORRELATION) {
279 |       logger.v("Correlation too low to begin tracking %s.", potentialObject);
280 |       potentialObject.stopTracking();
281 |       return;
282 |     }
283 | 
284 |     final List<TrackedRecognition> removeList = new LinkedList<TrackedRecognition>();
285 | 
286 |     float maxIntersect = 0.0f;
287 | 
288 |     // This is the current tracked object whose color we will take. If left null we'll take the
289 |     // first one from the color queue.
290 |     TrackedRecognition recogToReplace = null;
291 | 
292 |     // Look for intersections that will be overridden by this object or an intersection that would
293 |     // prevent this one from being placed.
294 |     for (final TrackedRecognition trackedRecognition : trackedObjects) {
295 |       final RectF a = trackedRecognition.trackedObject.getTrackedPositionInPreviewFrame();
296 |       final RectF b = potentialObject.getTrackedPositionInPreviewFrame();
297 |       final RectF intersection = new RectF();
298 |       final boolean intersects = intersection.setIntersect(a, b);
299 | 
300 |       final float intersectArea = intersection.width() * intersection.height();
301 |       final float totalArea = a.width() * a.height() + b.width() * b.height() - intersectArea;
302 |       final float intersectOverUnion = intersectArea / totalArea;
303 | 
304 |       // If there is an intersection with this currently tracked box above the maximum overlap
305 |       // percentage allowed, either the new recognition needs to be dismissed or the old
306 |       // recognition needs to be removed and possibly replaced with the new one.
307 |       if (intersects && intersectOverUnion > MAX_OVERLAP) {
308 |         if (potential.first < trackedRecognition.detectionConfidence
309 |             && trackedRecognition.trackedObject.getCurrentCorrelation() > MARGINAL_CORRELATION) {
310 |           // If track for the existing object is still going strong and the detection score was
311 |           // good, reject this new object.
312 |           potentialObject.stopTracking();
313 |           return;
314 |         } else {
315 |           removeList.add(trackedRecognition);
316 | 
317 |           // Let the previously tracked object with max intersection amount donate its color to
318 |           // the new object.
319 |           if (intersectOverUnion > maxIntersect) {
320 |             maxIntersect = intersectOverUnion;
321 |             recogToReplace = trackedRecognition;
322 |           }
323 |         }
324 |       }
325 |     }
326 | 
327 |     // If we're already tracking the max object and no intersections were found to bump off,
328 |     // pick the worst current tracked object to remove, if it's also worse than this candidate
329 |     // object.
330 |     if (availableColors.isEmpty() && removeList.isEmpty()) {
331 |       for (final TrackedRecognition candidate : trackedObjects) {
332 |         if (candidate.detectionConfidence < potential.first) {
333 |           if (recogToReplace == null
334 |               || candidate.detectionConfidence < recogToReplace.detectionConfidence) {
335 |             // Save it so that we use this color for the new object.
336 |             recogToReplace = candidate;
337 |           }
338 |         }
339 |       }
340 |       if (recogToReplace != null) {
341 |         logger.v("Found non-intersecting object to remove.");
342 |         removeList.add(recogToReplace);
343 |       } else {
344 |         logger.v("No non-intersecting object found to remove");
345 |       }
346 |     }
347 | 
348 |     // Remove everything that got intersected.
349 |     for (final TrackedRecognition trackedRecognition : removeList) {
350 |       logger.v(
351 |           "Removing tracked object %s with detection confidence %.2f, correlation %.2f",
352 |           trackedRecognition.trackedObject,
353 |           trackedRecognition.detectionConfidence,
354 |           trackedRecognition.trackedObject.getCurrentCorrelation());
355 |       trackedRecognition.trackedObject.stopTracking();
356 |       trackedObjects.remove(trackedRecognition);
357 |       if (trackedRecognition != recogToReplace) {
358 |         availableColors.add(trackedRecognition.color);
359 |       }
360 |     }
361 | 
362 |     if (recogToReplace == null && availableColors.isEmpty()) {
363 |       logger.e("No room to track this object, aborting.");
364 |       potentialObject.stopTracking();
365 |       return;
366 |     }
367 | 
368 |     // Finally safe to say we can track this object.
369 |     logger.v(
370 |         "Tracking object %s (%s) with detection confidence %.2f at position %s",
371 |         potentialObject,
372 |         potential.second.getTitle(),
373 |         potential.first,
374 |         potential.second.getLocation());
375 |     final TrackedRecognition trackedRecognition = new TrackedRecognition();
376 |     trackedRecognition.detectionConfidence = potential.first;
377 |     trackedRecognition.trackedObject = potentialObject;
378 |     trackedRecognition.title = potential.second.getTitle();
379 | 
380 |     // Use the color from a replaced object before taking one from the color queue.
381 |     trackedRecognition.color =
382 |         recogToReplace != null ? recogToReplace.color : availableColors.poll();
383 |     trackedObjects.add(trackedRecognition);
384 |   }
385 | }
386 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/util/BitmapUtil.java:
--------------------------------------------------------------------------------
 1 | package org.tensorflow.demo.util;
 2 | 
 3 | import android.graphics.Bitmap;
 4 | import android.graphics.BitmapFactory;
 5 | 
 6 | /**
 7 |  * Created by Simon on 2017/3/26.
 8 |  */
 9 | 
10 | public class BitmapUtil {
11 | 
12 |     public static int calculateInSampleSize(
13 |             BitmapFactory.Options options, int reqWidth, int reqHeight) {
14 |         // Raw height and width of image
15 |         final int height = options.outHeight;
16 |         final int width = options.outWidth;
17 |         int inSampleSize = 1;
18 | 
19 |         if (height > reqHeight || width > reqWidth) {
20 | 
21 |             final int halfHeight = height / 2;
22 |             final int halfWidth = width / 2;
23 | 
24 |             // Calculate the largest inSampleSize value that is a power of 2 and keeps both
25 |             // height and width larger than the requested height and width.
26 |             while ((halfHeight / inSampleSize) >= reqHeight
27 |                     && (halfWidth / inSampleSize) >= reqWidth) {
28 |                 inSampleSize *= 2;
29 |             }
30 |         }
31 | 
32 |         return inSampleSize;
33 |     }
34 | 
35 |     public static Bitmap decodeSampledBitmapFromFilePath(String path, int reqWidth, int reqHeight) {
36 |         // First decode with inJustDecodeBounds=true to check dimensions
37 |         final BitmapFactory.Options options = new BitmapFactory.Options();
38 |         options.inJustDecodeBounds = true;
39 |         BitmapFactory.decodeFile(path, options);
40 | 
41 |         // Calculate inSampleSize
42 |         options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
43 | 
44 |         // Decode bitmap with inSampleSize set
45 |         options.inJustDecodeBounds = false;
46 |         return BitmapFactory.decodeFile(path, options);
47 |     }
48 | }
49 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/util/FileUtil.java:
--------------------------------------------------------------------------------
  1 | package org.tensorflow.demo.util;
  2 | 
  3 | import android.annotation.TargetApi;
  4 | import android.app.Activity;
  5 | import android.content.ContentUris;
  6 | import android.content.Context;
  7 | import android.database.Cursor;
  8 | import android.net.Uri;
  9 | import android.os.Environment;
 10 | import android.provider.DocumentsContract;
 11 | import android.provider.MediaStore;
 12 | 
 13 | import java.io.File;
 14 | import java.io.FileOutputStream;
 15 | import java.io.IOException;
 16 | import java.io.InputStream;
 17 | 
 18 | /**
 19 |  * Created by Simon on 2017/3/26.
 20 |  */
 21 | 
 22 | public class FileUtil {
 23 | 
 24 |     /**
 25 |      * 根据Uri获取文件的绝对路径，解决Android4.4以上版本Uri转换
 26 |      *
 27 |      * @param context
 28 |      * @param fileUri
 29 |      */
 30 |     @TargetApi(19)
 31 |     public static String getFileAbsolutePath(Activity context, Uri fileUri) {
 32 |         if (context == null || fileUri == null)
 33 |             return null;
 34 |         if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(context, fileUri)) {
 35 |             if (isExternalStorageDocument(fileUri)) {
 36 |                 String docId = DocumentsContract.getDocumentId(fileUri);
 37 |                 String[] split = docId.split(":");
 38 |                 String type = split[0];
 39 |                 if ("primary".equalsIgnoreCase(type)) {
 40 |                     return Environment.getExternalStorageDirectory() + "/" + split[1];
 41 |                 }
 42 |             } else if (isDownloadsDocument(fileUri)) {
 43 |                 String id = DocumentsContract.getDocumentId(fileUri);
 44 |                 Uri contentUri = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
 45 |                 return getDataColumn(context, contentUri, null, null);
 46 |             } else if (isMediaDocument(fileUri)) {
 47 |                 String docId = DocumentsContract.getDocumentId(fileUri);
 48 |                 String[] split = docId.split(":");
 49 |                 String type = split[0];
 50 |                 Uri contentUri = null;
 51 |                 if ("image".equals(type)) {
 52 |                     contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
 53 |                 } else if ("video".equals(type)) {
 54 |                     contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
 55 |                 } else if ("audio".equals(type)) {
 56 |                     contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
 57 |                 }
 58 |                 String selection = MediaStore.Images.Media._ID + "=?";
 59 |                 String[] selectionArgs = new String[] { split[1] };
 60 |                 return getDataColumn(context, contentUri, selection, selectionArgs);
 61 |             }
 62 |         } // MediaStore (and general)
 63 |         else if ("content".equalsIgnoreCase(fileUri.getScheme())) {
 64 |             // Return the remote address
 65 |             if (isGooglePhotosUri(fileUri))
 66 |                 return fileUri.getLastPathSegment();
 67 |             return getDataColumn(context, fileUri, null, null);
 68 |         }
 69 |         // File
 70 |         else if ("file".equalsIgnoreCase(fileUri.getScheme())) {
 71 |             return fileUri.getPath();
 72 |         }
 73 |         return null;
 74 |     }
 75 | 
 76 |     public static String getDataColumn(Context context, Uri uri, String selection, String[] selectionArgs) {
 77 |         Cursor cursor = null;
 78 |         String[] projection = { MediaStore.Images.Media.DATA };
 79 |         try {
 80 |             cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs, null);
 81 |             if (cursor != null && cursor.moveToFirst()) {
 82 |                 int index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
 83 |                 return cursor.getString(index);
 84 |             }
 85 |         } finally {
 86 |             if (cursor != null)
 87 |                 cursor.close();
 88 |         }
 89 |         return null;
 90 |     }
 91 | 
 92 |     /**
 93 |      * @param uri
 94 |      *            The Uri to check.
 95 |      * @return Whether the Uri authority is ExternalStorageProvider.
 96 |      */
 97 |     public static boolean isExternalStorageDocument(Uri uri) {
 98 |         return "com.android.externalstorage.documents".equals(uri.getAuthority());
 99 |     }
100 | 
101 |     /**
102 |      * @param uri
103 |      *            The Uri to check.
104 |      * @return Whether the Uri authority is DownloadsProvider.
105 |      */
106 |     public static boolean isDownloadsDocument(Uri uri) {
107 |         return "com.android.providers.downloads.documents".equals(uri.getAuthority());
108 |     }
109 | 
110 |     /**
111 |      * @param uri
112 |      *            The Uri to check.
113 |      * @return Whether the Uri authority is MediaProvider.
114 |      */
115 |     public static boolean isMediaDocument(Uri uri) {
116 |         return "com.android.providers.media.documents".equals(uri.getAuthority());
117 |     }
118 | 
119 |     /**
120 |      * @param uri
121 |      *            The Uri to check.
122 |      * @return Whether the Uri authority is Google Photos.
123 |      */
124 |     public static boolean isGooglePhotosUri(Uri uri) {
125 |         return "com.google.android.apps.photos.content".equals(uri.getAuthority());
126 |     }
127 | 
128 |     public static void saveResourceIntoFile(Context context, File file, Integer resource) {
129 |         try {
130 |             InputStream inputStream = context.getResources().openRawResource(resource);
131 |             FileOutputStream fileOutputStream = new FileOutputStream(file);
132 | 
133 |             byte buf[] = new byte[1024];
134 |             int len;
135 |             while ((len = inputStream.read(buf)) > 0) {
136 |                 fileOutputStream.write(buf, 0, len);
137 |             }
138 | 
139 |             fileOutputStream.close();
140 |             inputStream.close();
141 |         } catch (IOException e) {
142 |             e.printStackTrace();
143 |         }
144 |     }
145 | 
146 |     public static void writeResourceToFile(Context context, Integer resource, String fileName) {
147 |         File fileDir = context.getCacheDir();
148 |         File file = new File(fileDir + File.separator + fileName);
149 |         if (!file.exists()) {
150 |             saveResourceIntoFile(context, file, resource);
151 |         }
152 |     }
153 | 
154 |     public static File getResourceFile(Context context, String fileName) {
155 |         File fileDir = context.getCacheDir();
156 |         return new File(fileDir + File.separator + fileName);
157 |     }
158 | }
159 | 


--------------------------------------------------------------------------------
/src/org/tensorflow/demo/util/MediaScanner.java:
--------------------------------------------------------------------------------
 1 | package org.tensorflow.demo.util;
 2 | 
 3 | import android.content.Context;
 4 | import android.media.MediaScannerConnection;
 5 | import android.net.Uri;
 6 | 
 7 | /**
 8 |  * Created by Simon on 2017/3/26.
 9 |  */
10 | 
11 | public class MediaScanner implements MediaScannerConnection.MediaScannerConnectionClient {
12 | 
13 |     /**
14 |      * 扫描对象
15 |      */
16 |     private MediaScannerConnection mediaScanConn = null;
17 | 
18 |     public MediaScanner(Context context) {
19 |         //实例化
20 |         mediaScanConn = new MediaScannerConnection(context, this);
21 |     }
22 | 
23 |     /**文件路径集合**/
24 |     private String[] filePaths;
25 |     /**文件MimeType集合**/
26 |     private String[] mimeTypes;
27 | 
28 |     /**
29 |      * 扫描文件
30 |      * @author YOLANDA
31 |      * @param filePaths
32 |      * @param mimeTypes
33 |      */
34 |     public void scanFiles(String[] filePaths, String[] mimeTypes) {
35 |         this.filePaths = filePaths;
36 |         this.mimeTypes = mimeTypes;
37 |         mediaScanConn.connect();//连接扫描服务
38 |     }
39 | 
40 |     /**
41 |      * @author YOLANDA
42 |      */
43 |     @Override
44 |     public void onMediaScannerConnected() {
45 |         for (int i = 0; i < filePaths.length; i++) {
46 |             mediaScanConn.scanFile(filePaths[i], mimeTypes[i]);//服务回调执行扫描
47 |         }
48 |         filePaths = null;
49 |         mimeTypes = null;
50 |     }
51 | 
52 |     private int scanTimes = 0;
53 | 
54 |     /**
55 |      * 扫描一个文件完成
56 |      * @author YOLANDA
57 |      * @param path
58 |      * @param uri
59 |      */
60 |     @Override
61 |     public void onScanCompleted(String path, Uri uri) {
62 |         scanTimes ++;
63 |         if(scanTimes == filePaths.length) {//如果扫描完了全部文件
64 |             mediaScanConn.disconnect();//断开扫描服务
65 |             scanTimes = 0;//复位计数
66 |         }
67 |     }
68 | }
69 | 


--------------------------------------------------------------------------------