एंड्रॉइड कैमरा 2 चेहरा पहचान

Question

कैमरा 2 चेहरा पहचान तंत्र के बारे में पर्याप्त जानकारी नहीं है। मैंने Google से कैमरा 2 नमूना का उपयोग किया: android-Camera2Basic

मैंने चेहरा पहचान मोड को पूर्ण करने के लिए सेट किया है।

int max_count = characteristics.get(
CameraCharacteristics.STATISTICS_INFO_MAX_FACE_COUNT); 
int modes [] = characteristics.get(
CameraCharacteristics.STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES); 

आउटपुट: MAXCOUNT: 5, मोड:

mPreviewRequestBuilder.set(CaptureRequest.STATISTICS_FACE_DETECT_MODE, 
            CameraMetadata.STATISTICS_FACE_DETECT_MODE_FULL); 

इसके अलावा, मैं

STATISTICS_INFO_MAX_FACE_COUNT और STATISTICS_INFO_AVAILABLE_FACE_DETECT_MODES जाँच [0, 2]

मेरे CaptureCallback:

private CameraCaptureSession.CaptureCallback mCaptureCallback 
= new CameraCaptureSession.CaptureCallback() { 

    private void process(CaptureResult result) { 
       Integer mode = result.get(CaptureResult.STATISTICS_FACE_DETECT_MODE); 
       Face [] faces = result.get(CaptureResult.STATISTICS_FACES); 
       if(faces != null && mode != null) 
        Log.e("tag", "faces : " + faces.length + " , mode : " + mode); 
    } 

    @Override 
    public void onCaptureProgressed(CameraCaptureSession session, CaptureRequest request, 
            CaptureResult partialResult) { 
     process(partialResult); 
    } 

    @Override 
    public void onCaptureCompleted(CameraCaptureSession session, CaptureRequest request, 
            TotalCaptureResult result) { 
     process(result); 
    } 

आउटपुट: चेहरे: 0, मोड: जैसे कि यह एक चेहरा ठीक से पहचान नहीं करता है या मैं कुछ याद किया 2

public static final int STATISTICS_FACE_DETECT_MODE_FULL = 2; 

चेहरे की लंबाई लगातार 0. है लगता है।

मुझे FaceDetector के साथ दृष्टिकोण पता है। मैं बस यह देखना चाहता था कि यह कैसे नए कैमरेके साथ काम करता है।

Answer 1

मेरे प्रयास एंड्रॉइड 5.0 (एपीआई 21) पर थे। 5.1 (एपीआई 22) के अपडेट के बाद यह कोड परिवर्तनों के बिना काम करना शुरू कर दिया।

Answer 2

https://github.com/rajktariya/Android-Camera2-Front-with-Face-Detection

चेहरे का पता लगाने

Answer 3

के साथ दोनों सामने कैमरे के लिए यह काम कर रहे नमूना पाया मुझे लगता है कि अपने फोन को गूगल चेहरा पहचान के साथ अच्छा काम नहीं कर रहा। क्या आप वाकई एचएएल 3 का उपयोग करते हैं और एपीआई 2 का उपयोग कर सकते हैं?

उदाहरण के लिए, मेरे कोड में मैं इस तरह बिना किसी समस्या के चेहरे का पता लगाने का उपयोग कर रहा:

private void checkFaces(Face[] faces) { 
    if (faces != null) { 
     CameraUtil.CustomFace[] mMappedCustomFaces; 
     mMappedCustomFaces = computeFacesFromCameraCoordinates(faces); 
     if (faces != null && faces.length > 0) { 
      mHandler.sendEmptyMessage(SHOW_FACES_MSG); 
      mLastTimeRenderingFaces = System.currentTimeMillis(); 
     } 
    } else { 
     if (System.currentTimeMillis() > (mLastTimeRenderingFaces + 100)) { 
      mHandler.sendEmptyMessage(HIDE_FACES_MSG); 
     } 
    } 
} 

अपने कस्टम चेहरा वर्ग:

private CameraCaptureSession.CaptureCallback mPhotoCaptureCallback 
      = new CameraCaptureSession.CaptureCallback() { 
//more code... 
    private void process(CaptureResult result) { 
      switch (mState) { 
       case STATE_PREVIEW: { 
        checkFaces(result.get(CaptureResult.STATISTICS_FACES)); 
        //more code.... 
        break; 
       } 
//more code... 
} 

यहाँ checkFaces विधि है

 // public static class CustomFace extends Camera.CustomFace{ 
public static class CustomFace { 
    private int score = 0; 
    private Rect rect = null; 

    public CustomFace(Rect rect, int score) { 
     this.score = score; 
     this.rect = rect; 
    } 

    public int getScore() { 
     return score; 
    } 

    public Rect getBounds() { 
     return rect; 
    } 
} 

आखिर में इस विधि के साथ आप चेहरों को सही तरीके से आकर्षित कर सकते हैं (आप डिफ़ॉल्ट एंड्रॉइड वन का उपयोग कर सकते हैं, बी 3 या 16:: ut आयतों 4 में इतना अच्छा काम नहीं करता है 9 आकार या आप फोन बारी बारी से जब:

public static RectF rectToRectF(Rect r) { 
    return new RectF(r.left, r.top, r.right, r.bottom); 
} 

    private CameraFaceUtil.CustomFace[] computeFacesFromCameraCoordinates(Face[] faces) { 
     CameraFaceUtil.CustomFace[] mappedFacesList = new CameraFaceUtil.CustomFace[faces.length]; 

     mCameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE); 

     float toStandardAspectRatio = ((float) mPreviewRect.bottom/(float) mPreviewRect.right)/AutoFitTextureView.RATIO_STANDARD; 
// 
     for (int i = 0; i < faces.length; i++) { 

      RectF mappedRect = new RectF(); 
      Log.i(TAG, "[computeFacesFromCameraCoordinates] toStandardAspectRatio: " + toStandardAspectRatio); 
      Log.i(TAG, "[computeFacesFromCameraCoordinates] preview rect: " + mPreviewRect); 
      Log.i(TAG, "[computeFacesFromCameraCoordinates] raw rect: " + faces[i].getBounds()); 

      mCameraToPreviewMatrix.mapRect(mappedRect, CameraUtil.rectToRectF(faces[i].getBounds())); 

      Log.i(TAG, "[computeFacesFromCameraCoordinates] mapped rect: " + mappedRect); 

      Rect auxRect = new Rect(CameraUtil.rectFToRect(mappedRect)); 


      Log.i(TAG, "[computeFacesFromCameraCoordinates] aux rect: " + auxRect); 

      int cameraSensorOrientation = mCameraCharacteristics.get(CameraCharacteristics.SENSOR_ORIENTATION); 
      Log.i(TAG, "[computeFacesFromCameraCoordinates] cameraSensorOrientation: " + cameraSensorOrientation); 
      switch (cameraSensorOrientation) { 
       case 90: 
        mappedRect.top = auxRect.left; 
        mappedRect.bottom = auxRect.right; 
        mappedRect.left = (mPreviewRect.right - auxRect.bottom); 
        mappedRect.right = (mPreviewRect.right - auxRect.top); 
        break; 

       case 180: 
        mappedRect.top = (mPreviewRect.bottom - auxRect.bottom) * toStandardAspectRatio; 
        mappedRect.bottom = (mPreviewRect.bottom - auxRect.top) * toStandardAspectRatio; 
        mappedRect.left = (mPreviewRect.right - auxRect.right) * toStandardAspectRatio; 
        mappedRect.right = (mPreviewRect.right - auxRect.left) * toStandardAspectRatio; 
        break; 

       case 270: 
        mappedRect.top = (mPreviewRect.bottom - auxRect.right) * toStandardAspectRatio; 
        mappedRect.bottom = (mPreviewRect.bottom - auxRect.left) * toStandardAspectRatio; 
        mappedRect.left = auxRect.top; 
        mappedRect.right = auxRect.bottom; 
        break; 
      } 

      Log.i(TAG, "[computeFacesFromCameraCoordinates] rotated by camera driver orientation rect without scale: " 
        + mappedRect + ", with score: " + faces[i].getScore()); 

      float topOffset = mappedRect.top; 
      float leftOffset = mappedRect.left; 

      mappedRect.top = mappedRect.top * toStandardAspectRatio; 
      mappedRect.bottom = mappedRect.bottom * toStandardAspectRatio; 
      mappedRect.left = mappedRect.left * toStandardAspectRatio; 
      mappedRect.right = mappedRect.right * toStandardAspectRatio; 


      Log.i(TAG, "[computeFacesFromCameraCoordinates] rotated by camera driver orientation rect with scale: " 
        + mappedRect + ", with score: " + faces[i].getScore()); 

      topOffset = mappedRect.top - topOffset; 
      leftOffset = mappedRect.left - leftOffset; 

      mappedRect.top -= topOffset /*- (mMirror ? mPreviewRect.height() : 0)*/; 
      mappedRect.bottom -= topOffset /* - (mMirror ? mPreviewRect.height() : 0)*/; 
      mappedRect.left -= leftOffset; 
      mappedRect.right -= leftOffset; 

      Log.i(TAG, "[computeFacesFromCameraCoordinates] rotated by camera driver orientation rect with offset: " 
        + mappedRect + " topOffset " + topOffset + " leftOffset " + leftOffset); 

      // set the new values to the mapping array to get rendered 
      mappedFacesList[i] = new CameraFaceUtil.CustomFace(CameraUtil.rectFToRect(mappedRect), faces[i].getScore()); 
     } 

     return mappedFacesList; 

    } 

क्या मैं कर रहा हूँ स्क्रीन अनुपात और आकार में आधारित चेहरे आ रहा है। यह एक भंगुर विचार कोड है, लेकिन मुझे उम्मीद है कि यह आपकी मदद करेगा!

एक अच्छा दिन है, यह पूछने के लिए स्वतंत्र महसूस करें कि क्या आपको कैमरा 2API के बारे में कुछ और चाहिए।

Answer 4

मैंने पाया कि केवल STATE_PREVIEW के मामले में, आप परिणामों को दसवीं चेहरे दिखाने के लिए संसाधित कर सकते हैं।Change from

private CameraCaptureSession.CaptureCallback mCaptureCallback 
     = new CameraCaptureSession.CaptureCallback() { 

    private void process(CaptureResult result) { 
     Integer mode = result.get(CaptureResult.STATISTICS_FACE_DETECT_MODE); 
     Face[] faces = result.get(CaptureResult.STATISTICS_FACES); 
     if(faces != null && mode != null) { 
      Log.e("tag", "faces : " + faces.length + " , mode : " + mode); 
     } 

     switch (mState) { 
      case STATE_PREVIEW: { 
       // We have nothing to do when the camera preview is working normally. 
       break; 
      } 
... 

private CameraCaptureSession.CaptureCallback mCaptureCallback 
     = new CameraCaptureSession.CaptureCallback() { 

    private void process(CaptureResult result) { 


     switch (mState) { 
      case STATE_PREVIEW: { 
       Face[] faces = result.get(CaptureResult.STATISTICS_FACES); 
       if (faces != null && faces.length > 0) { 
        Log.e("tag", "faces : " + faces.length); 
       } 
       break; 
      } 

के लिए अगर यह काम करता है देखने के लिए इस प्रयास करें।