try orientation with exif

visionSamples/FaceTracker/app/src/main/cpp/native-lib.cpp

@@ -325,51 +325,48 @@ Java_dlib_android_FaceRecognizer_recognizeFace(JNIEnv *env, jobject instance, jo
     }
 
     //todo: smth wrong with colors
-    //dlib::save_bmp(img, "/storage/emulated/0/Download/test.bmp");
-
-    std::vector<dlib::rectangle> dets = detector(img);
-    LOGI("detected size %d", dets.size());
-
-    float min_dist = 0.0;
-    if(dets.size() > 0 ){
-        auto face = dets.front();
-        std::vector<matrix<rgb_pixel>> faces;
-        int x = face.left();
-        int y = face.top();
-        int width = face.width();
-        int height = face.height();
-
-        auto shape = sp(img, face);
-        matrix<rgb_pixel> face_chip;
-        extract_image_chip(img, get_face_chip_details(shape, 150, 0.25), face_chip);
-        faces.push_back(move(face_chip));
-
-        std::vector<matrix<float, 0, 1>> face_descriptors = net(faces);
-
-        if (face_descriptors.size() > 0)
-        {
-            matrix<float, 0, 1> face_desc = face_descriptors[0];
-            for (auto& i : known_faces) {
-                float dist = length(face_desc -  i.second );
-                if (dist < min_dist){
-                    min_dist = dist;
-                }
-                if( dist < FACE_RECOGNIZE_THRESH) //todo: extract thresh
-                {
-                    LOGI("recognized");
-                    return env->NewStringUTF(i.first.c_str());
-                }
-            }
-        }
-        LOGI("not recognized, max dist %0.2f", min_dist);
-    }
-
+    dlib::save_bmp(img, "/sdcard/Download/res.bmp");
+
+//    std::vector<dlib::rectangle> dets = detector(img);
+//    LOGI("detected size %d", dets.size());
+//
+//    float min_dist = 0.0;
+//    if(dets.size() > 0 ){
+//        auto face = dets.front();
+//        std::vector<matrix<rgb_pixel>> faces;
+//        int x = face.left();
+//        int y = face.top();
+//        int width = face.width();
+//        int height = face.height();
+//
+//        auto shape = sp(img, face);
+//        matrix<rgb_pixel> face_chip;
+//        extract_image_chip(img, get_face_chip_details(shape, 150, 0.25), face_chip);
+//        faces.push_back(move(face_chip));
+//
+//        std::vector<matrix<float, 0, 1>> face_descriptors = net(faces);
+//
+//        if (face_descriptors.size() > 0)
+//        {
+//            matrix<float, 0, 1> face_desc = face_descriptors[0];
+//            for (auto& i : known_faces) {
+//                float dist = length(face_desc -  i.second );
+//                if (dist < min_dist){
+//                    min_dist = dist;
+//                }
+//                if( dist < FACE_RECOGNIZE_THRESH) //todo: extract thresh
+//                {
+//                    LOGI("recognized");
+//                    return env->NewStringUTF(i.first.c_str());
+//                }
+//            }
+//        }
+//        LOGI("not recognized, max dist %0.2f", min_dist);
+//    }
+//
     LOGI("unlocking pixels");
     AndroidBitmap_unlockPixels(env, bmp);
 
-    //std::string returnValue = "Unknown"  + std::to_string(min_dist);
-
-
     std::string returnValue = "Unknown";
     return env->NewStringUTF(returnValue.c_str());
 }

visionSamples/FaceTracker/app/src/main/java/com/google/android/gms/samples/vision/face/facetracker/CustomDetector.java

@@ -19,6 +19,7 @@
 import java.io.FileWriter;
 import java.io.IOException;
 
+import dlib.android.Exif;
 import dlib.android.FaceRecognizer;
 
 import static android.os.Environment.getExternalStorageDirectory;
@@ -83,6 +84,8 @@ public SparseArray<Face> detect(Frame frame) {
             yuvImage.compressToJpeg(new Rect(0, 0, frame.getMetadata().getWidth(),
                     frame.getMetadata().getHeight()), 100, byteArrayOutputStream);
             byte[] jpegArray = byteArrayOutputStream.toByteArray();
+            int orientation = Exif.getOrientation(jpegArray);
+            Log.w(TAG, String.format("Orientation %d", orientation));
             Bitmap tmpBitmap = BitmapFactory.decodeByteArray(jpegArray, 0, jpegArray.length);
             final Bitmap cropped = Bitmap.createBitmap(tmpBitmap, x, y, w, h);
 //            try {

visionSamples/FaceTracker/app/src/main/java/com/google/android/gms/samples/vision/face/facetracker/FaceTrackerActivity.java

@@ -62,7 +62,7 @@ public final class FaceTrackerActivity extends AppCompatActivity {
     private GraphicOverlay mGraphicOverlay;
     private Button mBtnDetect;
     private CustomDetector customDetector;
-    private FaceDetector mPictureDetector;
+    //private FaceDetector mPictureDetector;
 
     private static final int RC_HANDLE_GMS = 9001;
     // permission request codes need to be < 256
@@ -185,16 +185,16 @@ private void createCameraSource() {
                 .setClassificationType(FaceDetector.NO_CLASSIFICATIONS)
                 .setProminentFaceOnly(false)
                 .setMode(FaceDetector.ACCURATE_MODE)
-                .setMinFaceSize(0.05f)
+                .setMinFaceSize(0.015f)
                 .build();
 
-        mPictureDetector = new FaceDetector.Builder(context)
-                .setTrackingEnabled(false)
-                .setProminentFaceOnly(false)
-                .setMinFaceSize(0.015f)  // 80 / 5312 detect up to 80 pixels head width
-                .setMode(FaceDetector.ACCURATE_MODE)
-                .setClassificationType(FaceDetector.NO_CLASSIFICATIONS)
-                .build();
+//        mPictureDetector = new FaceDetector.Builder(context)
+//                .setTrackingEnabled(false)
+//                .setProminentFaceOnly(false)
+//                .setMinFaceSize(0.015f)  // 80 / 5312 detect up to 80 pixels head width
+//                .setMode(FaceDetector.ACCURATE_MODE)
+//                .setClassificationType(FaceDetector.NO_CLASSIFICATIONS)
+//                .build();
 
         //mFaceRecognizer
         customDetector = new CustomDetector(detector, mFaceRecognizer);
@@ -215,9 +215,9 @@ private void createCameraSource() {
             Log.w(TAG, "Face detector dependencies are not yet available.");
         }
 
-        if (!mPictureDetector.isOperational()) {
-            Log.w(TAG, "mPictureDetector dependencies are not yet available.");
-        }
+//        if (!mPictureDetector.isOperational()) {
+//            Log.w(TAG, "mPictureDetector dependencies are not yet available.");
+//        }
 
         //.setRequestedPreviewSize(640, 480)
         //.setRequestedFps(30.0f)

visionSamples/FaceTracker/app/src/main/java/dlib/android/Exif.java

@@ -0,0 +1,122 @@
+package dlib.android;
+
+import android.util.Log;
+
+//https://github.com/googlesamples/android-vision/issues/124
+public class Exif {
+    private static final String TAG = "CameraExif";
+
+    // Returns the degrees in clockwise. Values are 0, 90, 180, or 270.
+    public static int getOrientation(byte[] jpeg) {
+        if (jpeg == null) {
+            return 0;
+        }
+
+        int offset = 0;
+        int length = 0;
+
+        // ISO/IEC 10918-1:1993(E)
+        while (offset + 3 < jpeg.length && (jpeg[offset++] & 0xFF) == 0xFF) {
+            int marker = jpeg[offset] & 0xFF;
+
+            // Check if the marker is a padding.
+            if (marker == 0xFF) {
+                continue;
+            }
+            offset++;
+
+            // Check if the marker is SOI or TEM.
+            if (marker == 0xD8 || marker == 0x01) {
+                continue;
+            }
+            // Check if the marker is EOI or SOS.
+            if (marker == 0xD9 || marker == 0xDA) {
+                break;
+            }
+
+            // Get the length and check if it is reasonable.
+            length = pack(jpeg, offset, 2, false);
+            if (length < 2 || offset + length > jpeg.length) {
+                Log.e(TAG, "Invalid length");
+                return 0;
+            }
+
+            // Break if the marker is EXIF in APP1.
+            if (marker == 0xE1 && length >= 8 &&
+                    pack(jpeg, offset + 2, 4, false) == 0x45786966 &&
+                    pack(jpeg, offset + 6, 2, false) == 0) {
+                offset += 8;
+                length -= 8;
+                break;
+            }
+
+            // Skip other markers.
+            offset += length;
+            length = 0;
+        }
+
+        // JEITA CP-3451 Exif Version 2.2
+        if (length > 8) {
+            // Identify the byte order.
+            int tag = pack(jpeg, offset, 4, false);
+            if (tag != 0x49492A00 && tag != 0x4D4D002A) {
+                Log.e(TAG, "Invalid byte order");
+                return 0;
+            }
+            boolean littleEndian = (tag == 0x49492A00);
+
+            // Get the offset and check if it is reasonable.
+            int count = pack(jpeg, offset + 4, 4, littleEndian) + 2;
+            if (count < 10 || count > length) {
+                Log.e(TAG, "Invalid offset");
+                return 0;
+            }
+            offset += count;
+            length -= count;
+
+            // Get the count and go through all the elements.
+            count = pack(jpeg, offset - 2, 2, littleEndian);
+            while (count-- > 0 && length >= 12) {
+                // Get the tag and check if it is orientation.
+                tag = pack(jpeg, offset, 2, littleEndian);
+                if (tag == 0x0112) {
+                    // We do not really care about type and count, do we?
+                    int orientation = pack(jpeg, offset + 8, 2, littleEndian);
+                    switch (orientation) {
+                        case 1:
+                            return 0;
+                        case 3:
+                            return 180;
+                        case 6:
+                            return 90;
+                        case 8:
+                            return 270;
+                    }
+                    Log.i(TAG, "Unsupported orientation");
+                    return 0;
+                }
+                offset += 12;
+                length -= 12;
+            }
+        }
+
+        Log.i(TAG, "Orientation not found");
+        return 0;
+    }
+
+    private static int pack(byte[] bytes, int offset, int length,
+                            boolean littleEndian) {
+        int step = 1;
+        if (littleEndian) {
+            offset += length - 1;
+            step = -1;
+        }
+
+        int value = 0;
+        while (length-- > 0) {
+            value = (value << 8) | (bytes[offset] & 0xFF);
+            offset += step;
+        }
+        return value;
+    }
+}