반응형



DLib를 사용하여  Android에서 얼굴 검출(Face Landmarks Detection)하는 방법을 진행하여 보았습니다. 



캡처 버튼을 클릭하여 사진을 찍고, 검출 버튼을 눌러서 얼굴을 검출합니다. 

인터넷에서 찾아본 결과와 달리 검출 시간이 오래 걸리는 편입니다.


속도를 최적화하는 방법은 찾아보면 있을듯합니다. 

이미지를 작게하면 빨라질 가능성도 있습니다. 




본 포스트는 다음처럼 구성으로 되어있습니다.




1. DLib 라이브러리 컴파일


2. 안드로이드 프로젝트 생성


3. 얼굴 검출(Face Landmarks Detection) 예제





마지막 업데이트

2018. 8. 24

2019. 5. 27  dlib 빌드 방법 수정 

2019. 7. 16  진행에 혼동을 줄 수 있는 build.gradle 복사본 수정

2020. 7. 23 최신 버전 Android SDK, NDK에 맞추어 동작하도록 수정



1. DLib 라이브러리 컴파일


진행하기 전에 SDK Manager에서 CMake와 NDK를 설치하세요.

 



아래쪽에 보이는 Show Package Details를 체크하고 21.3.6528147 버전을 설치했는지 확인해보세요. 

글 작성 시점에서 최신 버전입니다. 





글작성 시점에서 SDK Platform  최신버전인 Android API 30을 설치하여 사용합니다. 





1-1. 깃허브에서 Dlib 소스코드를 다운로드합니다. 

https://github.com/davisking/dlib/releases 





1-2. 압축을 풀어 작업 편의상 사용자 디렉토리( C:\Users\사용자)로 복사해줍니다.

압축 푸는 방법에 따라 dlib-19.20 폴더 안에 또 dlib-19.20 폴더가 있을 수 있으니 꼭 스크린샷처럼 보이는지 확인하세요. 





1-3. cmake 명령을 하기 전에 옵션으로 사용하는 디렉토리 위치를 확인합니다.


아래 경로에 있는 숫자로 된 폴더 중 하나를 선택합니다. 숫자 높은 것이 최신버전의 NDK입니다. 

C:\Users\사용자이름\AppData\Local\Android\Sdk\ndk\





여기에선 21.3.6528147 폴더를 선택하여 다음 두 옵션으로 사용합니다. 숫자 부분빼고는 동일한 경로입니다. 

ANDROID_NDK로 지정한 경로의 하위 디렉토리에  CMAKE_TOOLCHAIN_FILE에서 지정한 파일이 존재합니다. 


-DCMAKE_TOOLCHAIN_FILE=C:\Users\webnautes\AppData\Local\Android\Sdk\ndk\21.3.6528147\build\cmake\android.toolchain.cmake


-DANDROID_NDK=C:\Users\webnautes\AppData\Local\Android\Sdk\ndk\21.3.6528147



윈도우 키 + R을 누른후, cmd 엔터를 입력하여 명령 프롬프트 창을 실행합니다. 


소스 디렉토리로 이동 후, cmake를 실행합니다. 

  • 파란색 부분은 현재 윈도우에 로그인한 사용자 이름으로 변경하세요.

  • 빨간색 부분은 빌드하여 사용할 플랫폼 이름으로 변경하세요. 

  • 초록색 부분은 앞에서 살펴본 NDK 버전으로 일치해야 합니다. 


C:\Users\webnautes>cd dlib-19.20


C:\Users\webnautes\dlib-19.20>mkdir build


C:\Users\webnautes\dlib-19.20>cd build



ANDROID_PLATFORM으로 android-30을 사용합니다. 


C:\Users\webnautes\dlib-19.20\build>C:\Users\webnautes\AppData\Local\Android\Sdk\cmake\3.10.2.4988404\bin\cmake -DBUILD_SHARED_LIBS=1 -DCMAKE_TOOLCHAIN_FILE=C:\Users\webnautes\AppData\Local\Android\Sdk\ndk\21.3.6528147\build\cmake\android.toolchain.cmake -DANDROID_NDK=C:\Users\webnautes\AppData\Local\Android\Sdk\ndk\21.3.6528147 -GNinja  -DCMAKE_BUILD_TYPE=Release -DCMAKE_MAKE_PROGRAM=ninja -DCMAKE_CXX_FLAGS=-std=c++11 -frtti -fexceptions -DANDROID_ABI=arm64-v8a -DANDROID_PLATFORM=android-30  -DDLIB_NO_GUI_SUPPORT=OFF -DANDROID_TOOLCHAIN=clang  -DANDROID_STL=c++_shared -DANDROID_CPP_FEATURES=rtti exceptions -DCMAKE_INSTALL_PREFIX=C:\dlib-native  ..




문제 없으면 마지막에 다음처럼 출력됩니다.    


-- Configuring done

-- Generating done

-- Build files have been written to: C:/Users/webnautes/dlib-19.20/build




1-4. 빌드를 진행합니다.

  • -j 뒤에는 사용하는 CPU의 코어 갯수를 입력하세요.  빌드 속도가 빨라집니다. 

  • 파란색 부분은 현재 윈도우에 로그인한 사용자 이름으로 변경하세요.


C:\Users\webnautes\dlib-19.20\build>C:\Users\webnautes\AppData\Local\Android\Sdk\cmake\3.10.2.4988404\bin\ninja.exe -j4



문제 없으면 마지막에 다음처럼 출력됩니다.





1-5. 결과물을 설치합니다.  앞에서 cmake 실행시 옵션으로 지정한 C:\dlib-native에 라이브러리 파일과 헤더파일을 복사해줍니다. 

  • 파란색 부분은 현재 윈도우에 로그인한 사용자 이름으로 변경하세요.


C:\Users\webnautes\dlib-19.20\build>C:\Users\webnautes\AppData\Local\Android\Sdk\cmake\3.10.2.4988404\bin\ninja.exe install




1-6. 빌드 결과물이 다음 경로에 저장됩니다.




2. 안드로이드 프로젝트 생성


2-1. 프로젝트 생성시  Native C++을 선택합니다.





2-2.  Name 항목에 프로젝트 이름을 적어주고 Language를 Java로 합니다. 





3. 얼굴 검출(Face Landmarks Detection) 예제


4-0. 프로젝트가 생성되기를 기다립니다. 안드로이드 스튜디오 하단에 다음 메시지가 사라져야 합니다. 





프로젝트 창을 Project 뷰로 변경합니다. 





4-1. 프로젝트 창에서 app / src / main을 선택한 상태에서 마우스 우클릭하여 보이는 메뉴에서 New > Directory를 선택합니다. 





assets 라고 입력하고 OK 버튼을 누르면 assets 이름의 디렉토리가 생성됩니다. 






아래 링크에서 Download 버튼을 클릭하여 shape_predictor_68_face_landmarks.dat 파일을 다운로드합니다. 

https://github.com/AKSHAYUBHAT/TensorFace/blob/master/openface/models/dlib/shape_predictor_68_face_landmarks.dat


다운로드 받은 파일을 선택하고 Ctrl 키를 누른 상태에서 드래그해서 프로젝트 창의 assets 폴더에 놓으면 복사가 됩니다. 





4-2. 미리 빌드해놓은 dlib를 안드로이드 프로젝트로 복사해줍니다. 

Ctrl 키를 누른 채  dlib-native 폴더를 드래그하여  프로젝트 이름에 놓으면 복사가 됩니다. 





복사후 다음 위치에 있어야 합니다. 





4-3.activity_main.xml 파일의 내용을 다음 코드로 대체합니다.



<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/layout_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <SurfaceView
        android:id="@+id/camera_preview_main"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="bottom"
        android:orientation="vertical">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center_horizontal"
        android:orientation="horizontal">

        <ProgressBar
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:id="@+id/progress1" />
    </LinearLayout>


    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:gravity="center_horizontal"
        android:orientation="horizontal">
        <Button
            android:id="@+id/button_main_capture"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal"
            android:text="캡처" />

        <Button
            android:id="@+id/button_main_detection"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal"
            android:text="검출" />
    </LinearLayout>
    </LinearLayout>
</FrameLayout>




4-4. layout 폴더에 dialog.xml을 추가합니다.



<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:gravity="center"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content">

    <ImageView
        android:id="@+id/dialogImage"
        android:layout_width="wrap_content"
        android:layout_height="350dp"/>

</LinearLayout>




4-5. styles.xml에 노란색 코드를 추가합니다.



<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
        <!-- 타이틀 바를 안보이도록 합니다. -->
        <item name="windowActionBar">false</item>
        <item name="windowNoTitle">true</item>
    </style>

</resources>




4-6. build.gradle에 com.google.android.material을 추가합니다. 



dependencies {

    implementation fileTree(dir: "libs", include: ["*.jar"])

    implementation 'androidx.appcompat:appcompat:1.1.0'

    implementation 'androidx.constraintlayout:constraintlayout:1.1.3'

    implementation 'com.google.android.material:material:1.3.0-alpha01'

    testImplementation 'junit:junit:4.12'

    androidTestImplementation 'androidx.test.ext:junit:1.1.1'

    androidTestImplementation 'androidx.test.espresso:espresso-core:3.2.0'

}




build.gradle에 다음 옵션을 추가해주고 Sync Now를 눌러 적용해줍니다. 

기존에 있는 externalNativeBuild을 지우고 아래 노란색 줄로 바꿔주면됩니다. abiFilters에는 사용할 플랫폼만 적어줍니다.  

 

android {

    compileSdkVersion 30

    buildToolsVersion "30.0.0"


    defaultConfig {

        applicationId "com.tistory.webnautes.dlibexample"

        minSdkVersion 21

        targetSdkVersion 30

        versionCode 1

        versionName "1.0"


        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

        externalNativeBuild {

            cmake {

                arguments "-DANDROID_STL=c++_shared" , "-DANDROID_TOOLCHAIN=clang"

                cppFlags "-std=c++11 -fexceptions"

            }

        }

        ndk {

            abiFilters "arm64-v8a"

        }


    }




4-7. MainActivity.java의 내용을 다음 코드로 변경합니다.


/*
*  https://github.com/josnidhin/Android-Camera-Example에 있는 코드를 수정했습니다.
*/

package com.tistory.webnautes.dlibexample;

import androidx.appcompat.app.AppCompatActivity;
import android.os.Bundle;
import android.Manifest;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.content.res.AssetManager;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.hardware.Camera;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Environment;
import androidx.annotation.NonNull;
import com.google.android.material.snackbar.Snackbar;
import androidx.core.app.ActivityCompat;
import androidx.core.content.ContextCompat;
import androidx.appcompat.app.AlertDialog;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.SurfaceView;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.ProgressBar;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;


public class MainActivity extends AppCompatActivity
        implements ActivityCompat.OnRequestPermissionsResultCallback {

    private static final String TAG = "android_camera_example";
    private static final int PERMISSIONS_REQUEST_CODE = 100;
    String[] REQUIRED_PERMISSIONS  = {Manifest.permission.CAMERA,
            Manifest.permission.WRITE_EXTERNAL_STORAGE};
    private static final int CAMERA_FACING =  Camera.CameraInfo.CAMERA_FACING_FRONT;//Camera.CameraInfo.CAMERA_FACING_BACK; //

    private SurfaceView surfaceView;
    private CameraPreview mCameraPreview;
    private View mLayout;  // Snackbar 사용하기 위해서는 View가 필요합니다.
    // (참고로 Toast에서는 Context가 필요했습니다.)
    private ProgressBar mProgressBar;

    public native void Detect();



    // Used to load the 'native-lib' library on application startup.
    static {
        System.loadLibrary("dlib");
        System.loadLibrary("native-lib");
    }


    private void copyFile(String filename) {
        String baseDir = Environment.getExternalStorageDirectory().getPath();
        String pathDir = baseDir + File.separator + filename;

        AssetManager assetManager = this.getAssets();

        InputStream inputStream = null;
        OutputStream outputStream = null;

        try {
            Log.d( TAG, "copyFile :: 다음 경로로 파일복사 "+ pathDir);
            inputStream = assetManager.open(filename);
            outputStream = new FileOutputStream(pathDir);

            byte[] buffer = new byte[1024];
            int read;
            while ((read = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, read);
            }
            inputStream.close();
            inputStream = null;
            outputStream.flush();
            outputStream.close();
            outputStream = null;
        } catch (Exception e) {
            Log.d(TAG, "copyFile :: 파일 복사 중 예외 발생 "+e.toString() );
        }

    }


    private class Task extends AsyncTask<Void, Void, Void> {

        @Override
        protected void onPreExecute() {
            super.onPreExecute();
            mProgressBar.setVisibility(View.VISIBLE);
        }

        @Override
        protected void onPostExecute(Void aVoid) {
            super.onPostExecute(aVoid);

            Log.d("MainActivity", "end");
            mProgressBar.setVisibility(View.GONE);



            // 갤러리에 반영
            File a = new File("/storage/emulated/0/camtest/output.bmp");
            Intent mediaScanIntent = new Intent( Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
            mediaScanIntent.setData(Uri.fromFile(a));
            sendBroadcast(mediaScanIntent);


            // stackoverflow.com/a/28128256
            AlertDialog.Builder builder = new AlertDialog.Builder(MainActivity.this);
            builder.setPositiveButton("Close", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                }
            });
            final AlertDialog dialog = builder.create();
            LayoutInflater inflater = getLayoutInflater();
            View dialogLayout = inflater.inflate(R.layout.dialog, null);
            dialog.setView(dialogLayout);
            dialog.requestWindowFeature(Window.FEATURE_NO_TITLE);


            dialog.setOnShowListener(new DialogInterface.OnShowListener() {
                @Override
                public void onShow(DialogInterface d) {
                    ImageView imageView = (ImageView) dialog.findViewById(R.id.dialogImage);

                    File imgFile = new  File("/storage/emulated/0/camtest/output.bmp");
                    Bitmap bitmap = BitmapFactory.decodeFile(imgFile.getAbsolutePath());
                    int height = bitmap.getHeight();
                    int width = bitmap.getWidth();

                    Bitmap resized = null;

                    float dpi =  getResources().getDisplayMetrics().density;
                    int px = (int)(350 * dpi);

                    if(width > px) {
                        resized = Bitmap.createScaledBitmap(bitmap, (width * px) / height, px, true);//http://javalove.egloos.com/m/67828
                        height = resized.getHeight();
                        width = resized.getWidth();
                        imageView.setImageBitmap(resized);
                    }
                    else imageView.setImageBitmap(bitmap);



                    Log.d("@@@", px + " " + width + " " + height );

                }
            });
            dialog.show();
        }

        @Override
        protected Void doInBackground(Void... voids) {


            Detect();



            return null;
        }
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // 상태바를 안보이도록 합니다.
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);

        // 화면 켜진 상태를 유지합니다.
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON,
                WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

        setContentView(R.layout.activity_main);

        copyFile("shape_predictor_68_face_landmarks.dat");

        mLayout = findViewById(R.id.layout_main);
        surfaceView = findViewById(R.id.camera_preview_main);
        mProgressBar = findViewById(R.id.progress1);


        // 런타임 퍼미션 완료될때 까지 화면에서 보이지 않게 해야합니다.
        surfaceView.setVisibility(View.GONE);


        mProgressBar.setVisibility(View.GONE);






        Button button1 = findViewById(R.id.button_main_capture);
        button1.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                mCameraPreview.takePicture();

            }
        });

        Button button2 = findViewById(R.id.button_main_detection);
        button2.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {

                new Task().execute();
            }
        });

        if (getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)) {

            int cameraPermission = ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA);
            int writeExternalStoragePermission = ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE);


            if ( cameraPermission == PackageManager.PERMISSION_GRANTED
                    && writeExternalStoragePermission == PackageManager.PERMISSION_GRANTED) {
                startCamera();


            }else {
                if (ActivityCompat.shouldShowRequestPermissionRationale(this, REQUIRED_PERMISSIONS[0])
                        || ActivityCompat.shouldShowRequestPermissionRationale(this, REQUIRED_PERMISSIONS[1])) {

                    Snackbar.make(mLayout, "이 앱을 실행하려면 카메라와 외부 저장소 접근 권한이 필요합니다.",
                            Snackbar.LENGTH_INDEFINITE).setAction("확인", new View.OnClickListener() {

                        @Override
                        public void onClick(View view) {

                            ActivityCompat.requestPermissions( MainActivity.this, REQUIRED_PERMISSIONS,
                                    PERMISSIONS_REQUEST_CODE);
                        }
                    }).show();


                } else {
                    // 2. 사용자가 퍼미션 거부를 한 적이 없는 경우에는 퍼미션 요청을 바로 합니다.
                    // 요청 결과는 onRequestPermissionResult에서 수신됩니다.
                    ActivityCompat.requestPermissions( this, REQUIRED_PERMISSIONS,
                            PERMISSIONS_REQUEST_CODE);
                }

            }

        } else {

            final Snackbar snackbar = Snackbar.make(mLayout, "디바이스가 카메라를 지원하지 않습니다.",
                    Snackbar.LENGTH_INDEFINITE);
            snackbar.setAction("확인", new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    snackbar.dismiss();
                }
            });
            snackbar.show();
        }


    }



    void startCamera(){

        // Create the Preview view and set it as the content of this Activity.
        mCameraPreview = new CameraPreview(this, this, CAMERA_FACING, surfaceView);

    }



    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grandResults) {

        if ( requestCode == PERMISSIONS_REQUEST_CODE && grandResults.length == REQUIRED_PERMISSIONS.length) {

            boolean check_result = true;

            for (int result : grandResults) {
                if (result != PackageManager.PERMISSION_GRANTED) {
                    check_result = false;
                    break;
                }
            }

            if ( check_result ) {

                startCamera();
            }
            else {

                if (ActivityCompat.shouldShowRequestPermissionRationale(this, REQUIRED_PERMISSIONS[0])
                        || ActivityCompat.shouldShowRequestPermissionRationale(this, REQUIRED_PERMISSIONS[1])) {

                    Snackbar.make(mLayout, "퍼미션이 거부되었습니다. 앱을 다시 실행하여 퍼미션을 허용해주세요. ",
                            Snackbar.LENGTH_INDEFINITE).setAction("확인", new View.OnClickListener() {

                        @Override
                        public void onClick(View view) {

                            finish();
                        }
                    }).show();

                }else {

                    Snackbar.make(mLayout, "설정(앱 정보)에서 퍼미션을 허용해야 합니다. ",
                            Snackbar.LENGTH_INDEFINITE).setAction("확인", new View.OnClickListener() {

                        @Override
                        public void onClick(View view) {

                            finish();
                        }
                    }).show();
                }
            }

        }


    }
}




4-8. CameraPreview.java를 추가하여 다음 코드를 입력합니다.



package com.tistory.webnautes.dlibexample;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.List;

import android.content.Context;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.hardware.Camera;
import android.hardware.Camera.Size;
import android.net.Uri;
import android.os.AsyncTask;
import android.os.Environment;
import androidx.appcompat.app.AppCompatActivity;
import android.util.Log;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.ViewGroup;



// 카메라에서 가져온 영상을 보여주는 카메라 프리뷰 클래스
class CameraPreview extends ViewGroup implements SurfaceHolder.Callback {

    private final String TAG = "CameraPreview";

    private int mCameraID;
    private SurfaceView mSurfaceView;
    private SurfaceHolder mHolder;
    private Camera mCamera;
    private Camera.CameraInfo mCameraInfo;
    private int mDisplayOrientation;
    private List<Size> mSupportedPreviewSizes;
    private Size mPreviewSize;
    private boolean isPreview = false;

    private AppCompatActivity mActivity;


    public CameraPreview(Context context, AppCompatActivity activity, int cameraID, SurfaceView surfaceView) {
        super(context);


        Log.d("@@@", "Preview");



        mActivity = activity;
        mCameraID = cameraID;
        mSurfaceView = surfaceView;


        mSurfaceView.setVisibility(View.VISIBLE);


        // SurfaceHolder.Callback를 등록하여 surface의 생성 및 해제 시점을 감지
        mHolder = mSurfaceView.getHolder();
        mHolder.addCallback(this);

    }





    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        // We purposely disregard child measurements because act as a
        // wrapper to a SurfaceView that centers the camera preview instead
        // of stretching it.
        final int width = resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec);
        final int height = resolveSize(getSuggestedMinimumHeight(), heightMeasureSpec);
        setMeasuredDimension(width, height);

        if (mSupportedPreviewSizes != null) {
            mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, width, height);
        }
    }



    @Override
    protected void onLayout(boolean changed, int l, int t, int r, int b) {
        if (changed && getChildCount() > 0) {
            final View child = getChildAt(0);

            final int width = r - l;
            final int height = b - t;

            int previewWidth = width;
            int previewHeight = height;
            if (mPreviewSize != null) {
                previewWidth = mPreviewSize.width;
                previewHeight = mPreviewSize.height;
            }

            // Center the child SurfaceView within the parent.
            if (width * previewHeight > height * previewWidth) {
                final int scaledChildWidth = previewWidth * height / previewHeight;
                child.layout((width - scaledChildWidth) / 2, 0,
                        (width + scaledChildWidth) / 2, height);
            } else {
                final int scaledChildHeight = previewHeight * width / previewWidth;
                child.layout(0, (height - scaledChildHeight) / 2,
                        width, (height + scaledChildHeight) / 2);
            }
        }
    }



    // Surface가 생성되었을 때 어디에 화면에 프리뷰를 출력할지 알려줘야 한다.
    public void surfaceCreated(SurfaceHolder holder) {

        // Open an instance of the camera
        try {
            mCamera = Camera.open(mCameraID); // attempt to get a Camera instance
        } catch (Exception e) {
            // Camera is not available (in use or does not exist)
            Log.e(TAG, "Camera " + mCameraID + " is not available: " + e.getMessage());
        }


        // retrieve camera's info.
        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
        Camera.getCameraInfo(mCameraID, cameraInfo);

        mCameraInfo = cameraInfo;
        mDisplayOrientation = mActivity.getWindowManager().getDefaultDisplay().getRotation();

        int orientation = calculatePreviewOrientation(mCameraInfo, mDisplayOrientation);
        mCamera.setDisplayOrientation(orientation);



        mSupportedPreviewSizes =  mCamera.getParameters().getSupportedPreviewSizes();
        requestLayout();

        // get Camera parameters
        Camera.Parameters params = mCamera.getParameters();

        List<String> focusModes = params.getSupportedFocusModes();
        if (focusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
            // set the focus mode
            params.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
            // set Camera parameters
            mCamera.setParameters(params);
        }


        try {

            mCamera.setPreviewDisplay(holder);


            // Important: Call startPreview() to start updating the preview
            // surface. Preview must be started before you can take a picture.
            mCamera.startPreview();
            isPreview = true;
            Log.d(TAG, "Camera preview started.");
        } catch (IOException e) {
            Log.d(TAG, "Error setting camera preview: " + e.getMessage());
        }

    }



    public void surfaceDestroyed(SurfaceHolder holder) {
        // Surface will be destroyed when we return, so stop the preview.
        // Release the camera for other applications.
        if (mCamera != null) {
            if (isPreview)
                mCamera.stopPreview();
            mCamera.release();
            mCamera = null;
            isPreview = false;
        }

    }


    private Size getOptimalPreviewSize(List<Size> sizes, int w, int h) {
        final double ASPECT_TOLERANCE = 0.1;
        double targetRatio = (double) w / h;
        if (sizes == null) return null;

        Size optimalSize = null;
        double minDiff = Double.MAX_VALUE;

        int targetHeight = h;

        // Try to find an size match aspect ratio and size
        for (Size size : sizes) {
            double ratio = (double) size.width / size.height;
            if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) continue;
            if (Math.abs(size.height - targetHeight) < minDiff) {
                optimalSize = size;
                minDiff = Math.abs(size.height - targetHeight);
            }
        }

        // Cannot find the one match the aspect ratio, ignore the requirement
        if (optimalSize == null) {
            minDiff = Double.MAX_VALUE;
            for (Size size : sizes) {
                if (Math.abs(size.height - targetHeight) < minDiff) {
                    optimalSize = size;
                    minDiff = Math.abs(size.height - targetHeight);
                }
            }
        }
        return optimalSize;
    }



    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {

        // If your preview can change or rotate, take care of those events here.
        // Make sure to stop the preview before resizing or reformatting it.

        if (mHolder.getSurface() == null) {
            // preview surface does not exist
            Log.d(TAG, "Preview surface does not exist");
            return;
        }


        // stop preview before making changes
        try {
            mCamera.stopPreview();
            Log.d(TAG, "Preview stopped.");
        } catch (Exception e) {
            // ignore: tried to stop a non-existent preview
            Log.d(TAG, "Error starting camera preview: " + e.getMessage());
        }

        int orientation = calculatePreviewOrientation(mCameraInfo, mDisplayOrientation);
        mCamera.setDisplayOrientation(orientation);

        try {
            mCamera.setPreviewDisplay(mHolder);
            mCamera.startPreview();
            Log.d(TAG, "Camera preview started.");
        } catch (Exception e) {
            Log.d(TAG, "Error starting camera preview: " + e.getMessage());
        }

    }



    /**
    * 안드로이드 디바이스 방향에 맞는 카메라 프리뷰를 화면에 보여주기 위해 계산합니다.
    */
    public static int calculatePreviewOrientation(Camera.CameraInfo info, int rotation) {
        int degrees = 0;

        switch (rotation) {
            case Surface.ROTATION_0:
                degrees = 0;
                break;
            case Surface.ROTATION_90:
                degrees = 90;
                break;
            case Surface.ROTATION_180:
                degrees = 180;
                break;
            case Surface.ROTATION_270:
                degrees = 270;
                break;
        }

        int result;
        if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            result = (info.orientation + degrees) % 360;
            result = (360 - result) % 360// compensate the mirror
        } else// back-facing
            result = (info.orientation - degrees + 360) % 360;
        }

        return result;
    }



    public void takePicture(){

        mCamera.takePicture(shutterCallback, rawCallback, jpegCallback);
    }


    Camera.ShutterCallback shutterCallback = new Camera.ShutterCallback() {
        public void onShutter() {

        }
    };

    Camera.PictureCallback rawCallback = new Camera.PictureCallback() {
        public void onPictureTaken(byte[] data, Camera camera) {

        }
    };


    //참고 : http://stackoverflow.com/q/37135675
    Camera.PictureCallback jpegCallback = new Camera.PictureCallback() {
        public void onPictureTaken(byte[] data, Camera camera) {

            //이미지의 너비와 높이 결정
            int w = camera.getParameters().getPictureSize().width;
            int h = camera.getParameters().getPictureSize().height;
            int orientation = calculatePreviewOrientation(mCameraInfo, mDisplayOrientation);


            //byte array를 bitmap으로 변환
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inPreferredConfig = Bitmap.Config.ARGB_8888;
            Bitmap bitmap = BitmapFactory.decodeByteArray( data, 0, data.length, options);


            //이미지를 디바이스 방향으로 회전
            Matrix matrix = new Matrix();
            matrix.postRotate(orientation);
            bitmap =  Bitmap.createBitmap(bitmap, 0, 0, w, h, matrix, true);

            //bitmap을 byte array로 변환
            //ByteArrayOutputStream stream = new ByteArrayOutputStream();
            //bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);
            //bitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);
            //byte[] currentData = stream.toByteArray();

            //파일로 저장
            //new SaveImageTask().execute(currentData);
            new SaveImageTask().execute(FlipVertically(bitmap));

        }
    };



    private class SaveImageTask extends AsyncTask<Bitmap, Void, Void> {
        String fullpath;

        @Override
        protected void onPostExecute(Void aVoid) {
            super.onPostExecute(aVoid);

            mCamera.startPreview();


            // 갤러리에 반영
            File a = new File(fullpath);
            Intent mediaScanIntent = new Intent( Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
            mediaScanIntent.setData(Uri.fromFile(a));
            getContext().sendBroadcast(mediaScanIntent);



            try {
                mCamera.setPreviewDisplay(mHolder);
                mCamera.startPreview();
                Log.d(TAG, "Camera preview started.");
            } catch (Exception e) {
                Log.d(TAG, "Error starting camera preview: " + e.getMessage());
            }
        }

        @Override
        protected Void doInBackground(Bitmap... data) {
            FileOutputStream outStream = null;


            try {


                File path = new File (Environment.getExternalStorageDirectory().getAbsolutePath() + "/camtest/");
                if (!path.exists()) {
                    path.mkdirs();
                }

                String filepath = Environment.getExternalStorageDirectory().getAbsolutePath() + "/camtest/" + "1.bmp";
                save(data[0], filepath);

                fullpath = filepath;

                // String fileName = String.format("%d.jpg", System.currentTimeMillis());
//                File outputFile = new File(path, "1.jpg");
//
//                outStream = new FileOutputStream(outputFile);
//                outStream.write(data[0]);
//                outStream.flush();
//                outStream.close();

                Log.d(TAG, "onPictureTaken - wrote bytes: " + data.length + " to "
                        + path);






            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }

            return null;
        }

    }


    // whats-online.info/science-and-tutorials/134/Android-code-How-to-Flip-an-Image-vertically-programmatically/
    public Bitmap FlipVertically(Bitmap originalImage) {
        // The gap we want between the flipped image and the original image
        final int flipGap = 4;


        int width = originalImage.getWidth();
        int height = originalImage.getHeight();

        // This will not scale but will flip on the Y axis
        Matrix matrix = new Matrix();
        matrix.preScale(1, -1);

        // Create a Bitmap with the flip matrix applied to it.
        // We only want the bottom half of the image
        Bitmap flipImage = Bitmap.createBitmap(originalImage, 0,0 , width, height, matrix, true);

        // Create a new bitmap with same width but taller to fit reflection
        Bitmap bitmapWithFlip = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);

        // Create a new Canvas with the bitmap that's big enough for
        Canvas canvas = new Canvas(bitmapWithFlip);
//
//        //Draw original image
//        canvas.drawBitmap(originalImage, 0, height+flipGap, null);

        //Draw the Flipped Image
        canvas.drawBitmap(flipImage, 0, 0, null);


        return bitmapWithFlip;
    }

    //https://stackoverflow.com/a/22914268
    private static final int BMP_WIDTH_OF_TIMES = 4;
    private static final int BYTE_PER_PIXEL = 3;

    /**
    * Android Bitmap Object to Window's v3 24bit Bmp Format File
    * @param orgBitmap
    * @param filePath
    * @return file saved result
    */
    public static boolean save(Bitmap orgBitmap, String filePath) throws IOException {
        long start = System.currentTimeMillis();
        if(orgBitmap == null){
            return false;
        }

        if(filePath == null){
            return false;
        }

        boolean isSaveSuccess = true;

        //image size
        int width = orgBitmap.getWidth();
        int height = orgBitmap.getHeight();

        //image dummy data size
        //reason : the amount of bytes per image row must be a multiple of 4 (requirements of bmp format)
        byte[] dummyBytesPerRow = null;
        boolean hasDummy = false;
        int rowWidthInBytes = BYTE_PER_PIXEL * width; //source image width * number of bytes to encode one pixel.
        if(rowWidthInBytes%BMP_WIDTH_OF_TIMES>0){
            hasDummy=true;
            //the number of dummy bytes we need to add on each row
            dummyBytesPerRow = new byte[(BMP_WIDTH_OF_TIMES-(rowWidthInBytes%BMP_WIDTH_OF_TIMES))];
            //just fill an array with the dummy bytes we need to append at the end of each row
            for(int i = 0; i < dummyBytesPerRow.length; i++){
                dummyBytesPerRow[i] = (byte)0xFF;
            }
        }

        //an array to receive the pixels from the source image
        int[] pixels = new int[width * height];

        //the number of bytes used in the file to store raw image data (excluding file headers)
        int imageSize = (rowWidthInBytes+(hasDummy?dummyBytesPerRow.length:0)) * height;
        //file headers size
        int imageDataOffset = 0x36;

        //final size of the file
        int fileSize = imageSize + imageDataOffset;

        //Android Bitmap Image Data
        orgBitmap.getPixels(pixels, 0, width, 0, 0, width, height);

        //ByteArrayOutputStream baos = new ByteArrayOutputStream(fileSize);
        ByteBuffer buffer = ByteBuffer.allocate(fileSize);

        /**
        * BITMAP FILE HEADER Write Start
        **/
        buffer.put((byte)0x42);
        buffer.put((byte)0x4D);

        //size
        buffer.put(writeInt(fileSize));

        //reserved
        buffer.put(writeShort((short)0));
        buffer.put(writeShort((short)0));

        //image data start offset
        buffer.put(writeInt(imageDataOffset));

        /** BITMAP FILE HEADER Write End */

        //*******************************************

        /** BITMAP INFO HEADER Write Start */
        //size
        buffer.put(writeInt(0x28));

        //width, height
        //if we add 3 dummy bytes per row : it means we add a pixel (and the image width is modified.
        buffer.put(writeInt(width+(hasDummy?(dummyBytesPerRow.length==3?1:0):0)));
        buffer.put(writeInt(height));

        //planes
        buffer.put(writeShort((short)1));

        //bit count
        buffer.put(writeShort((short)24));

        //bit compression
        buffer.put(writeInt(0));

        //image data size
        buffer.put(writeInt(imageSize));

        //horizontal resolution in pixels per meter
        buffer.put(writeInt(0));

        //vertical resolution in pixels per meter (unreliable)
        buffer.put(writeInt(0));

        buffer.put(writeInt(0));

        buffer.put(writeInt(0));

        /** BITMAP INFO HEADER Write End */

        int row = height;
        int col = width;
        int startPosition = (row - 1) * col;
        int endPosition = row * col;
        while( row > 0 ){
            for(int i = startPosition; i < endPosition; i++ ){
                buffer.put((byte)(pixels[i] & 0x000000FF));
                buffer.put((byte)((pixels[i] & 0x0000FF00) >> 8));
                buffer.put((byte)((pixels[i] & 0x00FF0000) >> 16));
            }
            if(hasDummy){
                buffer.put(dummyBytesPerRow);
            }
            row--;
            endPosition = startPosition;
            startPosition = startPosition - col;
        }

        FileOutputStream fos = new FileOutputStream(filePath);
        fos.write(buffer.array());
        fos.close();
        Log.v("AndroidBmpUtil" ,System.currentTimeMillis()-start+" ms");

        return isSaveSuccess;
    }

    /**
    * Write integer to little-endian
    * @param value
    * @return
    * @throws IOException
    */
    private static byte[] writeInt(int value) throws IOException {
        byte[] b = new byte[4];

        b[0] = (byte)(value & 0x000000FF);
        b[1] = (byte)((value & 0x0000FF00) >> 8);
        b[2] = (byte)((value & 0x00FF0000) >> 16);
        b[3] = (byte)((value & 0xFF000000) >> 24);

        return b;
    }

    /**
    * Write short to little-endian byte array
    * @param value
    * @return
    * @throws IOException
    */
    private static byte[] writeShort(short value) throws IOException {
        byte[] b = new byte[2];

        b[0] = (byte)(value & 0x00FF);
        b[1] = (byte)((value & 0xFF00) >> 8);

        return b;
    }
}




4-9. MainActivity.java의 Detect를 클릭하면 왼쪽에 보이는 빨간 전구를 클릭합니다.




메뉴에서 Create JNI function을 선택합니다.





native-lib.cpp에 함수가 추가됩니다. 





4-10. native-lib.cpp 파일을 다음처럼 수정합니다. 

기존 코드에서 필요없는 부분을 주석처리하고 추가로 코드를 복사해주면됩니다. 


dlib 라이브러리가 아직 인식안되어 해당 코드들이 빨간색으로 보입니다. 다음 단계를 진행하고 나면 해결됩니다. 


#include <jni.h>
//#include <string>
#include <dlib/image_processing/frontal_face_detector.h>
#include <dlib/image_processing/render_face_detections.h>
#include <dlib/image_processing.h>
#include <dlib/image_transforms.h>
#include <dlib/image_io.h>
#include <iostream>
#include <android/log.h>

using namespace dlib;
using namespace std;


//extern "C" JNIEXPORT jstring JNICALL
//Java_com_tistory_webnautes_dlibexample_MainActivity_stringFromJNI(
//        JNIEnv* env,
//        jobject /* this */) {
//    std::string hello = "Hello from C++";
//    return env->NewStringUTF(hello.c_str());
//}
extern "C"
JNIEXPORT void JNICALL
Java_com_tistory_webnautes_dlibexample_MainActivity_Detect(JNIEnv *env, jobject instance) {

    __android_log_print(ANDROID_LOG_DEBUG, "native-lib :: ",
                        "start");

    try {
        // We need a face detector.  We will use this to get bounding boxes for
        // each face in an image.
        frontal_face_detector detector = get_frontal_face_detector();


        // And we also need a shape_predictor.  This is the tool that will predict face
        // landmark positions given an image and face bounding box.  Here we are just
        // loading the model from the shape_predictor_68_face_landmarks.dat file you gave
        // as a command line argument.
        shape_predictor sp;
        deserialize("/storage/emulated/0/shape_predictor_68_face_landmarks.dat") >> sp;


        //image_window win, win_faces;
        // Loop over all the images provided on the command line.
        __android_log_print(ANDROID_LOG_DEBUG, "native-lib :: ",
                            "load shape_predictor_68_face_landmarks");

        array2d<rgb_pixel> img;
        load_image(img, "/storage/emulated/0/camtest/1.bmp");

        // Make the image larger so we can detect small faces.
        // pyramid_up(img);

        __android_log_print(ANDROID_LOG_DEBUG, "native-lib :: ",
                            "load image %d x %d");

        array2d<rgb_pixel> sizeImg(1280, 960);
        resize_image(img, sizeImg);
        ;

        __android_log_print(ANDROID_LOG_DEBUG, "native-lib :: ",
                            "start detect");

        // Now tell the face detector to give us a list of bounding boxes
        // around all the faces in the image.
        std::vector<rectangle> dets = detector(sizeImg, 0);
        __android_log_print(ANDROID_LOG_DEBUG, "native-lib :: ",
                            "Number of faces detected:  %d", (int) dets.size());

        for ( auto & rect : dets)
            dlib :: draw_rectangle (sizeImg, rect, dlib :: rgb_pixel ( 255 , 0 , 0 ), 3 );



        // Now we will go ask the shape_predictor to tell us the pose of
        // each face we detected.
        std::vector<full_object_detection> shapes;
        for (unsigned long j = 0; j < dets.size(); ++j)
        {
            full_object_detection shape = sp(img, dets[j]);
            cout << "number of parts: "<< shape.num_parts() <<