Android पर एमएल किट की मदद से चेहरों की पहचान करना

इमेज और वीडियो में चेहरों की पहचान करने के लिए, एमएल किट का इस्तेमाल किया जा सकता है.

शुरू करने से पहले

1. अगर आपने अब तक ऐसा नहीं किया है, तो अपने Android प्रोजेक्ट में Firebase जोड़ें.
2. अपने मॉड्यूल में एमएल किट Android लाइब्रेरी के लिए डिपेंडेंसी जोड़ें (ऐप्लिकेशन-लेवल) Gradle फ़ाइल (आम तौर पर app/build.gradle):

   apply plugin: 'com.android.application'
   apply plugin: 'com.google.gms.google-services'
   
   dependencies {
     // ...
   
     implementation 'com.google.firebase:firebase-ml-vision:24.0.3'
     // If you want to detect face contours (landmark detection and classification
     // don't require this additional model):
     implementation 'com.google.firebase:firebase-ml-vision-face-model:20.0.1'
   }

3. ज़रूरी नहीं, लेकिन इसका सुझाव दिया जाता है: अपने ऐप्लिकेशन को इस तरह कॉन्फ़िगर करें, ताकि वह अपने-आप डाउनलोड हो सके Play Store से आपका ऐप्लिकेशन इंस्टॉल होने के बाद, डिवाइस पर एमएल मॉडल की जानकारी जोड़ देगा.

   ऐसा करने के लिए, अपने ऐप्लिकेशन की जानकारी में यह एलान जोड़ें AndroidManifest.xml फ़ाइल:

   <application ...>
     ...
     <meta-data
         android:name="com.google.firebase.ml.vision.DEPENDENCIES"
         android:value="face" />
     <!-- To use multiple models: android:value="face,model2,model3" -->
   </application>

   अगर इंस्टॉल के समय मॉडल डाउनलोड करने की सुविधा चालू नहीं की जाती है, तो मॉडल पहली बार डिटेक्टर चलाने पर डाउनलोड किया गया. इस तारीख से पहले किए जाने वाले अनुरोध डाउनलोड पूरा हो गया है, कोई परिणाम नहीं मिलेगा.

इनपुट इमेज के लिए दिशा-निर्देश

एमएल किट में चेहरों की सटीक पहचान हो, इसके लिए इनपुट इमेज में चेहरे होने चाहिए जिन्हें काफ़ी पिक्सल डेटा से दिखाया जाता है. आम तौर पर, आपके हिसाब से बनाया गया हर चेहरा ताकि इमेज कम से कम 100x100 पिक्सल की हो. अगर आपको यह पता लगाना है कि चेहरों की बनावट, ML किट में हाई रिज़ॉल्यूशन इनपुट की ज़रूरत होती है: हर एक चेहरे यह कम से कम 200x200 पिक्सल का होना चाहिए.

अगर रीयल-टाइम ऐप्लिकेशन में चेहरों का पता लगाया जा रहा है, तो आपको इनपुट इमेज के कुल डाइमेंशन पर विचार किया जा सकता है. छोटी इमेज तेज़ी से प्रोसेस होता है, इसलिए इंतज़ार का समय कम करने के लिए, इमेज कम रिज़ॉल्यूशन में कैप्चर करें (ऊपर बताई गई सटीक जानकारी से जुड़ी ज़रूरी शर्तों को ध्यान में रखते हुए) और पक्का करें कि सब्जेक्ट का चेहरा, इमेज के ज़्यादातर हिस्से को घेर लेता है. यह भी देखें रीयल-टाइम में परफ़ॉर्मेंस को बेहतर बनाने के लिए सलाह.

खराब इमेज फ़ोकस की वजह से सटीक जानकारी पर असर पड़ सकता है. अगर आपको मान्य नतीजे नहीं मिल रहे हैं, तो उपयोगकर्ता से इमेज को फिर से कैप्चर करने के लिए कहें.

कैमरे के हिसाब से किसी चेहरे का ओरिएंटेशन इस बात पर भी असर डाल सकता है कि चेहरे की ML Kit की मदद से पता लगाना. यहां जाएं: चेहरे की पहचान Concepts.

1. चेहरे की पहचान करने वाली सुविधा को कॉन्फ़िगर करें

उदाहरण के लिए:

// High-accuracy landmark detection and face classification
FirebaseVisionFaceDetectorOptions highAccuracyOpts =
        new FirebaseVisionFaceDetectorOptions.Builder()
                .setPerformanceMode(FirebaseVisionFaceDetectorOptions.ACCURATE)
                .setLandmarkMode(FirebaseVisionFaceDetectorOptions.ALL_LANDMARKS)
                .setClassificationMode(FirebaseVisionFaceDetectorOptions.ALL_CLASSIFICATIONS)
                .build();

// Real-time contour detection of multiple faces
FirebaseVisionFaceDetectorOptions realTimeOpts =
        new FirebaseVisionFaceDetectorOptions.Builder()
                .setContourMode(FirebaseVisionFaceDetectorOptions.ALL_CONTOURS)
                .build();

// High-accuracy landmark detection and face classification
val highAccuracyOpts = FirebaseVisionFaceDetectorOptions.Builder()
        .setPerformanceMode(FirebaseVisionFaceDetectorOptions.ACCURATE)
        .setLandmarkMode(FirebaseVisionFaceDetectorOptions.ALL_LANDMARKS)
        .setClassificationMode(FirebaseVisionFaceDetectorOptions.ALL_CLASSIFICATIONS)
        .build()

// Real-time contour detection of multiple faces
val realTimeOpts = FirebaseVisionFaceDetectorOptions.Builder()
        .setContourMode(FirebaseVisionFaceDetectorOptions.ALL_CONTOURS)
        .build()

2. चेहरे की पहचान करने वाला टूल चलाएं

चेहरा पहचानने के लिए, आपको कम से कम के आयाम वाली इमेज का इस्तेमाल करना चाहिए 480x360 पिक्सल. अगर रीयल टाइम में चेहरों की पहचान की जा रही है, तो फ़्रेम कैप्चर किए जा रहे हैं इस कम से कम रिज़ॉल्यूशन पर, इंतज़ार के समय को कम करने में मदद मिल सकती है.

1. एक FirebaseVisionImage ऑब्जेक्ट इमेज.

   • किसीFirebaseVisionImage media.Image ऑब्जेक्ट, जैसे कि किसी ऑब्जेक्ट से इमेज कैप्चर करते समय करने के लिए, media.Image ऑब्जेक्ट को पास करें और चित्र के FirebaseVisionImage.fromMediaImage() पर घुमाया गया.

     अगर आपको CameraX लाइब्रेरी, OnImageCapturedListener, और ImageAnalysis.Analyzer क्लास, रोटेशन वैल्यू को कैलकुलेट करती हैं आपके लिए है, इसलिए आपको रोटेशन को सिर्फ़ एक ML किट के रूप में बदलना होगा कॉल करने से पहले ROTATION_ कॉन्सटेंट FirebaseVisionImage.fromMediaImage():

     Java

     private class YourAnalyzer implements ImageAnalysis.Analyzer {
     
         private int degreesToFirebaseRotation(int degrees) {
             switch (degrees) {
                 case 0:
                     return FirebaseVisionImageMetadata.ROTATION_0;
                 case 90:
                     return FirebaseVisionImageMetadata.ROTATION_90;
                 case 180:
                     return FirebaseVisionImageMetadata.ROTATION_180;
                 case 270:
                     return FirebaseVisionImageMetadata.ROTATION_270;
                 default:
                     throw new IllegalArgumentException(
                             "Rotation must be 0, 90, 180, or 270.");
             }
         }
     
         @Override
         public void analyze(ImageProxy imageProxy, int degrees) {
             if (imageProxy == null || imageProxy.getImage() == null) {
                 return;
             }
             Image mediaImage = imageProxy.getImage();
             int rotation = degreesToFirebaseRotation(degrees);
             FirebaseVisionImage image =
                     FirebaseVisionImage.fromMediaImage(mediaImage, rotation);
             // Pass image to an ML Kit Vision API
             // ...
         }
     }

     Kotlin+KTX

     private class YourImageAnalyzer : ImageAnalysis.Analyzer {
         private fun degreesToFirebaseRotation(degrees: Int): Int = when(degrees) {
             0 -> FirebaseVisionImageMetadata.ROTATION_0
             90 -> FirebaseVisionImageMetadata.ROTATION_90
             180 -> FirebaseVisionImageMetadata.ROTATION_180
             270 -> FirebaseVisionImageMetadata.ROTATION_270
             else -> throw Exception("Rotation must be 0, 90, 180, or 270.")
         }
     
         override fun analyze(imageProxy: ImageProxy?, degrees: Int) {
             val mediaImage = imageProxy?.image
             val imageRotation = degreesToFirebaseRotation(degrees)
             if (mediaImage != null) {
                 val image = FirebaseVisionImage.fromMediaImage(mediaImage, imageRotation)
                 // Pass image to an ML Kit Vision API
                 // ...
             }
         }
     }

     अगर इमेज को घुमाने की सुविधा देने वाली कैमरा लाइब्रेरी का इस्तेमाल नहीं किया जाता है, तो डिवाइस के रोटेशन और कैमरे के ओरिएंटेशन से इसका हिसाब लगा सकता है डिवाइस में सेंसर:

     Java

     private static final SparseIntArray ORIENTATIONS = new SparseIntArray();
     static {
         ORIENTATIONS.append(Surface.ROTATION_0, 90);
         ORIENTATIONS.append(Surface.ROTATION_90, 0);
         ORIENTATIONS.append(Surface.ROTATION_180, 270);
         ORIENTATIONS.append(Surface.ROTATION_270, 180);
     }
     
     /**
      * Get the angle by which an image must be rotated given the device's current
      * orientation.
      */
     @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
     private int getRotationCompensation(String cameraId, Activity activity, Context context)
             throws CameraAccessException {
         // Get the device's current rotation relative to its "native" orientation.
         // Then, from the ORIENTATIONS table, look up the angle the image must be
         // rotated to compensate for the device's rotation.
         int deviceRotation = activity.getWindowManager().getDefaultDisplay().getRotation();
         int rotationCompensation = ORIENTATIONS.get(deviceRotation);
     
         // On most devices, the sensor orientation is 90 degrees, but for some
         // devices it is 270 degrees. For devices with a sensor orientation of
         // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
         CameraManager cameraManager = (CameraManager) context.getSystemService(CAMERA_SERVICE);
         int sensorOrientation = cameraManager
                 .getCameraCharacteristics(cameraId)
                 .get(CameraCharacteristics.SENSOR_ORIENTATION);
         rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360;
     
         // Return the corresponding FirebaseVisionImageMetadata rotation value.
         int result;
         switch (rotationCompensation) {
             case 0:
                 result = FirebaseVisionImageMetadata.ROTATION_0;
                 break;
             case 90:
                 result = FirebaseVisionImageMetadata.ROTATION_90;
                 break;
             case 180:
                 result = FirebaseVisionImageMetadata.ROTATION_180;
                 break;
             case 270:
                 result = FirebaseVisionImageMetadata.ROTATION_270;
                 break;
             default:
                 result = FirebaseVisionImageMetadata.ROTATION_0;
                 Log.e(TAG, "Bad rotation value: " + rotationCompensation);
         }
         return result;
     }
     VisionImage.java

     Kotlin+KTX

     private val ORIENTATIONS = SparseIntArray()
     
     init {
         ORIENTATIONS.append(Surface.ROTATION_0, 90)
         ORIENTATIONS.append(Surface.ROTATION_90, 0)
         ORIENTATIONS.append(Surface.ROTATION_180, 270)
         ORIENTATIONS.append(Surface.ROTATION_270, 180)
     }
     /**
      * Get the angle by which an image must be rotated given the device's current
      * orientation.
      */
     @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
     @Throws(CameraAccessException::class)
     private fun getRotationCompensation(cameraId: String, activity: Activity, context: Context): Int {
         // Get the device's current rotation relative to its "native" orientation.
         // Then, from the ORIENTATIONS table, look up the angle the image must be
         // rotated to compensate for the device's rotation.
         val deviceRotation = activity.windowManager.defaultDisplay.rotation
         var rotationCompensation = ORIENTATIONS.get(deviceRotation)
     
         // On most devices, the sensor orientation is 90 degrees, but for some
         // devices it is 270 degrees. For devices with a sensor orientation of
         // 270, rotate the image an additional 180 ((270 + 270) % 360) degrees.
         val cameraManager = context.getSystemService(CAMERA_SERVICE) as CameraManager
         val sensorOrientation = cameraManager
                 .getCameraCharacteristics(cameraId)
                 .get(CameraCharacteristics.SENSOR_ORIENTATION)!!
         rotationCompensation = (rotationCompensation + sensorOrientation + 270) % 360
     
         // Return the corresponding FirebaseVisionImageMetadata rotation value.
         val result: Int
         when (rotationCompensation) {
             0 -> result = FirebaseVisionImageMetadata.ROTATION_0
             90 -> result = FirebaseVisionImageMetadata.ROTATION_90
             180 -> result = FirebaseVisionImageMetadata.ROTATION_180
             270 -> result = FirebaseVisionImageMetadata.ROTATION_270
             else -> {
                 result = FirebaseVisionImageMetadata.ROTATION_0
                 Log.e(TAG, "Bad rotation value: $rotationCompensation")
             }
         }
         return result
     }
     VisionImage.kt

     इसके बाद, media.Image ऑब्जेक्ट को पास करें और FirebaseVisionImage.fromMediaImage() का रोटेशन मान:

     Java

     FirebaseVisionImage image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation);
     VisionImage.java

     Kotlin+KTX

     val image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation)
     VisionImage.kt

   • किसी फ़ाइल यूआरआई से FirebaseVisionImage ऑब्जेक्ट बनाने के लिए, पास करें ऐप्लिकेशन का कॉन्टेक्स्ट और फ़ाइल यूआरआई को FirebaseVisionImage.fromFilePath(). यह तब काम आता है, जब उपयोगकर्ता को चुनने का प्रॉम्प्ट भेजने के लिए, ACTION_GET_CONTENT इंटेंट का इस्तेमाल करें अपने गैलरी ऐप्लिकेशन से मिली इमेज शामिल करेगा.

     Java

     FirebaseVisionImage image;
     try {
         image = FirebaseVisionImage.fromFilePath(context, uri);
     } catch (IOException e) {
         e.printStackTrace();
     }
     VisionImage.java

     Kotlin+KTX

     val image: FirebaseVisionImage
     try {
         image = FirebaseVisionImage.fromFilePath(context, uri)
     } catch (e: IOException) {
         e.printStackTrace()
     }
     VisionImage.kt

   • किसीFirebaseVisionImage ByteBuffer या बाइट अरे, पहले चित्र की गणना करें media.Image इनपुट के लिए ऊपर बताए गए तरीके से रोटेशन.

     इसके बाद, FirebaseVisionImageMetadata ऑब्जेक्ट बनाएं जिसमें इमेज की ऊंचाई, चौड़ाई, कलर एन्कोडिंग फ़ॉर्मैट, और रोटेशन:

     Java

     FirebaseVisionImageMetadata metadata = new FirebaseVisionImageMetadata.Builder()
             .setWidth(480)   // 480x360 is typically sufficient for
             .setHeight(360)  // image recognition
             .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
             .setRotation(rotation)
             .build();
     VisionImage.java

     Kotlin+KTX

     val metadata = FirebaseVisionImageMetadata.Builder()
             .setWidth(480) // 480x360 is typically sufficient for
             .setHeight(360) // image recognition
             .setFormat(FirebaseVisionImageMetadata.IMAGE_FORMAT_NV21)
             .setRotation(rotation)
             .build()
     VisionImage.kt

     बफ़र या अरे और मेटाडेटा ऑब्जेक्ट का इस्तेमाल करके, FirebaseVisionImage ऑब्जेक्ट:

     Java

     FirebaseVisionImage image = FirebaseVisionImage.fromByteBuffer(buffer, metadata);
     // Or: FirebaseVisionImage image = FirebaseVisionImage.fromByteArray(byteArray, metadata);
     VisionImage.java

     Kotlin+KTX

     val image = FirebaseVisionImage.fromByteBuffer(buffer, metadata)
     // Or: val image = FirebaseVisionImage.fromByteArray(byteArray, metadata)
     VisionImage.kt

   • किसीFirebaseVisionImage Bitmap ऑब्जेक्ट:

     Java

     FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap);
     VisionImage.java

     Kotlin+KTX

     val image = FirebaseVisionImage.fromBitmap(bitmap)
     VisionImage.kt

     Bitmap ऑब्जेक्ट के ज़रिए दिखाई जाने वाली इमेज में सीधा होना चाहिए, इसके लिए किसी अतिरिक्त रोटेशन की आवश्यकता नहीं होगी.

2. FirebaseVisionFaceDetector का इंस्टेंस पाएं:

   Java

   FirebaseVisionFaceDetector detector = FirebaseVision.getInstance()
           .getVisionFaceDetector(options);

   Kotlin+KTX

   val detector = FirebaseVision.getInstance()
           .getVisionFaceDetector(options)

3. आखिर में, इमेज को detectInImage तरीके से पास करें:

   Java

   Task<List<FirebaseVisionFace>> result =
           detector.detectInImage(image)
                   .addOnSuccessListener(
                           new OnSuccessListener<List<FirebaseVisionFace>>() {
                               @Override
                               public void onSuccess(List<FirebaseVisionFace> faces) {
                                   // Task completed successfully
                                   // ...
                               }
                           })
                   .addOnFailureListener(
                           new OnFailureListener() {
                               @Override
                               public void onFailure(@NonNull Exception e) {
                                   // Task failed with an exception
                                   // ...
                               }
                           });

   Kotlin+KTX

   val result = detector.detectInImage(image)
           .addOnSuccessListener { faces ->
               // Task completed successfully
               // ...
           }
           .addOnFailureListener { e ->
               // Task failed with an exception
               // ...
           }

3. पहचाने गए चेहरों की जानकारी पाएं

for (FirebaseVisionFace face : faces) {
    Rect bounds = face.getBoundingBox();
    float rotY = face.getHeadEulerAngleY();  // Head is rotated to the right rotY degrees
    float rotZ = face.getHeadEulerAngleZ();  // Head is tilted sideways rotZ degrees

    // If landmark detection was enabled (mouth, ears, eyes, cheeks, and
    // nose available):
    FirebaseVisionFaceLandmark leftEar = face.getLandmark(FirebaseVisionFaceLandmark.LEFT_EAR);
    if (leftEar != null) {
        FirebaseVisionPoint leftEarPos = leftEar.getPosition();
    }

    // If contour detection was enabled:
    List<FirebaseVisionPoint> leftEyeContour =
            face.getContour(FirebaseVisionFaceContour.LEFT_EYE).getPoints();
    List<FirebaseVisionPoint> upperLipBottomContour =
            face.getContour(FirebaseVisionFaceContour.UPPER_LIP_BOTTOM).getPoints();

    // If classification was enabled:
    if (face.getSmilingProbability() != FirebaseVisionFace.UNCOMPUTED_PROBABILITY) {
        float smileProb = face.getSmilingProbability();
    }
    if (face.getRightEyeOpenProbability() != FirebaseVisionFace.UNCOMPUTED_PROBABILITY) {
        float rightEyeOpenProb = face.getRightEyeOpenProbability();
    }

    // If face tracking was enabled:
    if (face.getTrackingId() != FirebaseVisionFace.INVALID_ID) {
        int id = face.getTrackingId();
    }
}

for (face in faces) {
    val bounds = face.boundingBox
    val rotY = face.headEulerAngleY // Head is rotated to the right rotY degrees
    val rotZ = face.headEulerAngleZ // Head is tilted sideways rotZ degrees

    // If landmark detection was enabled (mouth, ears, eyes, cheeks, and
    // nose available):
    val leftEar = face.getLandmark(FirebaseVisionFaceLandmark.LEFT_EAR)
    leftEar?.let {
        val leftEarPos = leftEar.position
    }

    // If contour detection was enabled:
    val leftEyeContour = face.getContour(FirebaseVisionFaceContour.LEFT_EYE).points
    val upperLipBottomContour = face.getContour(FirebaseVisionFaceContour.UPPER_LIP_BOTTOM).points

    // If classification was enabled:
    if (face.smilingProbability != FirebaseVisionFace.UNCOMPUTED_PROBABILITY) {
        val smileProb = face.smilingProbability
    }
    if (face.rightEyeOpenProbability != FirebaseVisionFace.UNCOMPUTED_PROBABILITY) {
        val rightEyeOpenProb = face.rightEyeOpenProbability
    }

    // If face tracking was enabled:
    if (face.trackingId != FirebaseVisionFace.INVALID_ID) {
        val id = face.trackingId
    }
}

चेहरे की बनावट के उदाहरण

चेहरे की बनावट की पहचान करने वाली सुविधा चालू होने पर, आपको हर चेहरे की पहचान कर ली गई थी. ये बिंदु दिखाते हैं कि सुविधा. चेहरा देखें कंटूर के तरीके के बारे में जानने के लिए, डिटेक्शन कॉन्सेप्ट की खास जानकारी बताया गया है.

निम्न चित्र दिखाता है कि ये बिंदु किसी चेहरे से कैसे मैप होते हैं ( इमेज को बड़ा करने के लिए):