iOS पर ML Kit की मदद से चेहरों का पता लगाना

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

ध्यान दें: ML किट iOS एपीआई सिर्फ़ 64-बिट डिवाइस पर काम करते हैं. अगर आपका ऐप्लिकेशन 32-बिट सहायता की मदद से बनाया जाता है, तो इस एपीआई का इस्तेमाल करने से पहले डिवाइस का आर्किटेक्चर देखें.

इसे आज़माएं

• इस एपीआई के इस्तेमाल का उदाहरण देखने के लिए, ऐप्लिकेशन के नमूने का इस्तेमाल करें.
• कोडलैब की मदद से कोड को खुद आज़माएं.

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

1. अपनी Podfile में ये ML किट पॉड शामिल करें:

   pod 'GoogleMLKit/FaceDetection', '3.2.0'
   

2. अपने प्रोजेक्ट के पॉड इंस्टॉल करने या अपडेट करने के बाद, अपने .xcworkspaceकोड का इस्तेमाल करके Xcode प्रोजेक्ट खोलें. ML किट, Xcode के 12.4 या इसके बाद के वर्शन पर काम करती है.

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

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

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

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

कैमरे के मुकाबले चेहरे का ओरिएंटेशन इस बात पर असर डाल सकता है कि ML किट क्या पहचान सकता है. चेहरे की पहचान करने के कॉन्सेप्ट देखें.

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

किसी इमेज पर चेहरे की पहचान करने वाली सुविधा लागू करने से पहले, अगर आपको फ़ेस डिटेक्टर की किसी भी डिफ़ॉल्ट सेटिंग में बदलाव करना है, तो उन सेटिंग को FaceDetectorOptions ऑब्जेक्ट की मदद से बताएं. इन सेटिंग को बदला जा सकता है:

सेटिंग
performanceMode	fast (डिफ़ॉल्ट) | accurate चेहरों की पहचान करते समय उसकी गति या बिलकुल सही होना.
landmarkMode	none (डिफ़ॉल्ट) | all क्या चेहरे के "लैंडमार्क"—आंखों, कान, नाक, गाल, मुंह—सभी चेहरे की पहचान की जानी चाहिए.
contourMode	none (डिफ़ॉल्ट) | all चेहरे की बनावट के आकार का पता लगाना है या नहीं. कॉनटूर की पहचान इमेज में सिर्फ़ सबसे प्रमुख चेहरे के लिए होती है.
classificationMode	none (डिफ़ॉल्ट) | all चेहरे को "मुस्कुराता है" और "आंखें खुली हैं" कैटगरी में शामिल करना है या नहीं.
minFaceSize	CGFloat (डिफ़ॉल्ट: 0.1) चेहरे की सबसे छोटी साइज़ सेट करता है, जिसे सिर की चौड़ाई और इमेज की चौड़ाई के अनुपात के तौर पर दिखाया जाता है.
isTrackingEnabled	false (डिफ़ॉल्ट) | true चेहरे को आईडी असाइन करना है या नहीं, इसका इस्तेमाल इमेज में दिखने वाले चेहरों को ट्रैक करने के लिए किया जा सकता है. ध्यान दें कि 'कंटूर' की पहचान करने की सुविधा चालू होने पर, सिर्फ़ एक चेहरे की पहचान की जाती है. इसलिए, चेहरे की ट्रैकिंग से सही नतीजे नहीं मिलते. इसी वजह से, कॉन्टैक्ट डिटेक्शन और फ़ेस ट्रैकिंग, दोनों को चालू न करें. इस सुविधा की मदद से, स्पीड को बेहतर बनाया जा सकता है.

उदाहरण के लिए, नीचे दिए गए उदाहरणों में से किसी एक की तरह एक FaceDetectorOptions ऑब्जेक्ट बनाएं:

Swift

// High-accuracy landmark detection and face classification
let options = FaceDetectorOptions()
options.performanceMode = .accurate
options.landmarkMode = .all
options.classificationMode = .all

// Real-time contour detection of multiple faces
// options.contourMode = .all

Objective-C

// High-accuracy landmark detection and face classification
MLKFaceDetectorOptions *options = [[MLKFaceDetectorOptions alloc] init];
options.performanceMode = MLKFaceDetectorPerformanceModeAccurate;
options.landmarkMode = MLKFaceDetectorLandmarkModeAll;
options.classificationMode = MLKFaceDetectorClassificationModeAll;

// Real-time contour detection of multiple faces
// options.contourMode = MLKFaceDetectorContourModeAll;

2. इनपुट इमेज तैयार करें

UIImage किसी चेहरे की पहचान करने के लिए, process(_:completion:) या results(in:) वाले तरीके का इस्तेमाल करके FaceDetector या UIImage को इमेज भेजें:

UIImage या CMSampleBuffer का इस्तेमाल करके, VisionImage ऑब्जेक्ट बनाएं.

अगर आप UIImage का इस्तेमाल करते हैं, तो यह तरीका अपनाएं:

• UIImage के साथ एक VisionImage ऑब्जेक्ट बनाएं. .orientation का सही नाम डालना न भूलें.

  Swift

  let image = VisionImage(image: UIImage)
  visionImage.orientation = image.imageOrientation

  Objective-C

  MLKVisionImage *visionImage = [[MLKVisionImage alloc] initWithImage:image];
  visionImage.orientation = image.imageOrientation;

अगर आप CMSampleBuffer का इस्तेमाल करते हैं, तो यह तरीका अपनाएं:

• CMSampleBuffer में शामिल इमेज डेटा का ओरिएंटेशन बताएं.

  इमेज का ओरिएंटेशन पाने के लिए:

  Swift

  func imageOrientation(
    deviceOrientation: UIDeviceOrientation,
    cameraPosition: AVCaptureDevice.Position
  ) -> UIImage.Orientation {
    switch deviceOrientation {
    case .portrait:
      return cameraPosition == .front ? .leftMirrored : .right
    case .landscapeLeft:
      return cameraPosition == .front ? .downMirrored : .up
    case .portraitUpsideDown:
      return cameraPosition == .front ? .rightMirrored : .left
    case .landscapeRight:
      return cameraPosition == .front ? .upMirrored : .down
    case .faceDown, .faceUp, .unknown:
      return .up
    }
  }
        

  Objective-C

  - (UIImageOrientation)
    imageOrientationFromDeviceOrientation:(UIDeviceOrientation)deviceOrientation
                           cameraPosition:(AVCaptureDevicePosition)cameraPosition {
    switch (deviceOrientation) {
      case UIDeviceOrientationPortrait:
        return cameraPosition == AVCaptureDevicePositionFront ? UIImageOrientationLeftMirrored
                                                              : UIImageOrientationRight;
  
      case UIDeviceOrientationLandscapeLeft:
        return cameraPosition == AVCaptureDevicePositionFront ? UIImageOrientationDownMirrored
                                                              : UIImageOrientationUp;
      case UIDeviceOrientationPortraitUpsideDown:
        return cameraPosition == AVCaptureDevicePositionFront ? UIImageOrientationRightMirrored
                                                              : UIImageOrientationLeft;
      case UIDeviceOrientationLandscapeRight:
        return cameraPosition == AVCaptureDevicePositionFront ? UIImageOrientationUpMirrored
                                                              : UIImageOrientationDown;
      case UIDeviceOrientationUnknown:
      case UIDeviceOrientationFaceUp:
      case UIDeviceOrientationFaceDown:
        return UIImageOrientationUp;
    }
  }
        

• CMSampleBuffer ऑब्जेक्ट और ओरिएंटेशन का इस्तेमाल करके VisionImage ऑब्जेक्ट बनाएं:

  Swift

  let image = VisionImage(buffer: sampleBuffer)
  image.orientation = imageOrientation(
    deviceOrientation: UIDevice.current.orientation,
    cameraPosition: cameraPosition)

  Objective-C

   MLKVisionImage *image = [[MLKVisionImage alloc] initWithBuffer:sampleBuffer];
   image.orientation =
     [self imageOrientationFromDeviceOrientation:UIDevice.currentDevice.orientation
                                  cameraPosition:cameraPosition];

3. फ़ेस डिटेक्टर का उदाहरण पाएं

FaceDetector का एक उदाहरण पाएं:

Swift

let faceDetector = FaceDetector.faceDetector(options: options)
ViewController.swift

Objective-C

MLKFaceDetector *faceDetector = [MLKFaceDetector faceDetectorWithOptions:options];
      

4. इमेज को प्रोसेस करें

इसके बाद, इमेज को process() वाले तरीके पर भेजें:

Swift

weak var weakSelf = self
faceDetector.process(visionImage) { faces, error in
  guard let strongSelf = weakSelf else {
    print("Self is nil!")
    return
  }
  guard error == nil, let faces = faces, !faces.isEmpty else {
    // ...
    return
  }

  // Faces detected
  // ...
}
ViewController.swift

Objective-C

[faceDetector processImage:image
                completion:^(NSArray<MLKFace *> *faces,
                             NSError *error) {
  if (error != nil) {
    return;
  }
  if (faces.count > 0) {
    // Recognized faces
  }
}];

5. जिन चेहरों की पहचान की गई है उनके बारे में जानकारी पाएं

अगर चेहरे की पहचान करने वाली कार्रवाई सफल होती है, तो चेहरे की पहचान करने वाला Face ऑब्जेक्ट को पूरा करने के हैंडलर को एक श्रेणी में भेज देता है. हर Face ऑब्जेक्ट, उस चेहरे के बारे में बताता है जो इमेज में मिला था. हर चेहरे के लिए, आपको इनपुट इमेज में इसके बाउंडिंग कोऑर्डिनेट मिल सकते हैं. साथ ही, इसे ढूंढने के लिए फ़ेस डिटेक्टर को कॉन्फ़िगर करने वाली कोई भी दूसरी जानकारी ली जा सकती है. उदाहरण के लिए :

Swift

for face in faces {
  let frame = face.frame
  if face.hasHeadEulerAngleX {
    let rotX = face.headEulerAngleX  // Head is rotated to the uptoward rotX degrees
  }
  if face.hasHeadEulerAngleY {
    let rotY = face.headEulerAngleY  // Head is rotated to the right rotY degrees
  }
  if face.hasHeadEulerAngleZ {
    let rotZ = face.headEulerAngleZ  // Head is tilted sideways rotZ degrees
  }

  // If landmark detection was enabled (mouth, ears, eyes, cheeks, and
  // nose available):
  if let leftEye = face.landmark(ofType: .leftEye) {
    let leftEyePosition = leftEye.position
  }

  // If contour detection was enabled:
  if let leftEyeContour = face.contour(ofType: .leftEye) {
    let leftEyePoints = leftEyeContour.points
  }
  if let upperLipBottomContour = face.contour(ofType: .upperLipBottom) {
    let upperLipBottomPoints = upperLipBottomContour.points
  }

  // If classification was enabled:
  if face.hasSmilingProbability {
    let smileProb = face.smilingProbability
  }
  if face.hasRightEyeOpenProbability {
    let rightEyeOpenProb = face.rightEyeOpenProbability
  }

  // If face tracking was enabled:
  if face.hasTrackingID {
    let trackingId = face.trackingID
  }
}

Objective-C

for (MLKFace *face in faces) {
  // Boundaries of face in image
  CGRect frame = face.frame;
  if (face.hasHeadEulerAngleX) {
    CGFloat rotX = face.headEulerAngleX;  // Head is rotated to the upward rotX degrees
  }
  if (face.hasHeadEulerAngleY) {
    CGFloat rotY = face.headEulerAngleY;  // Head is rotated to the right rotY degrees
  }
  if (face.hasHeadEulerAngleZ) {
    CGFloat rotZ = face.headEulerAngleZ;  // Head is tilted sideways rotZ degrees
  }

  // If landmark detection was enabled (mouth, ears, eyes, cheeks, and
  // nose available):
  MLKFaceLandmark *leftEar = [face landmarkOfType:FIRFaceLandmarkTypeLeftEar];
  if (leftEar != nil) {
    MLKVisionPoint *leftEarPosition = leftEar.position;
  }

  // If contour detection was enabled:
  MLKFaceContour *upperLipBottomContour = [face contourOfType:FIRFaceContourTypeUpperLipBottom];
  if (upperLipBottomContour != nil) {
    NSArray<MLKVisionPoint *> *upperLipBottomPoints = upperLipBottomContour.points;
    if (upperLipBottomPoints.count > 0) {
      NSLog("Detected the bottom contour of the subject's upper lip.")
    }
  }

  // If classification was enabled:
  if (face.hasSmilingProbability) {
    CGFloat smileProb = face.smilingProbability;
  }
  if (face.hasRightEyeOpenProbability) {
    CGFloat rightEyeOpenProb = face.rightEyeOpenProbability;
  }

  // If face tracking was enabled:
  if (face.hasTrackingID) {
    NSInteger trackingID = face.trackingID;
  }
}

चेहरे के आकार का उदाहरण

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

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

रीयल-टाइम में चेहरे की पहचान

अगर आप रीयल-टाइम ऐप्लिकेशन में चेहरे की पहचान करने वाली सुविधा का इस्तेमाल करना चाहते हैं, तो सबसे अच्छे फ़्रेम रेट पाने के लिए, इन दिशा-निर्देशों का पालन करें:

• चेहरे की पहचान करने वाले को कॉन्फ़िगर करें, ताकि चेहरे की बनावट की पहचान की जा सके या चीज़ों की कैटगरी तय की जा सके. साथ ही, लैंडमार्क की पहचान करने की सुविधा का इस्तेमाल किया जा सके.

  कंटूर की पहचान
  लैंडमार्क की पहचान
  क्लासिफ़िकेशन
  लैंडमार्क की पहचान करना और उसे अलग-अलग कैटगरी में बांटना
  कंटूर की पहचान और लैंडमार्क की पहचान करना
  कंटूर की पहचान और उसे अलग-अलग कैटगरी में बांटना
  कंटूर की पहचान और उसका पता लगाना
  

• fast मोड चालू करें (डिफ़ॉल्ट रूप से चालू होता है).

• कम रिज़ॉल्यूशन में इमेज कैप्चर करें. हालांकि, इस एपीआई की इमेज डाइमेंशन से जुड़ी ज़रूरी शर्तों का भी ध्यान रखें.

• वीडियो फ़्रेम प्रोसेस करने के लिए, डिटेक्टर के results(in:) सिंक्रोनस एपीआई का इस्तेमाल करें. दिए गए वीडियो फ़्रेम से सिंक्रोनस रूप से परिणाम पाने के लिए AVCaptureVideoDataOutputSampleBufferDelegate के captureOutput(_, didOutput:from:) फ़ंक्शन से इस विधि को कॉल करें. AVCaptureVideoDataOutput की alwaysDiscardsLateVideoFrames को true के तौर पर रखें, ताकि डिटेक्टर को कॉल थ्रॉटल किए जा सकें. अगर डिटेक्टर चलने के दौरान नया वीडियो फ़्रेम उपलब्ध हो जाता है, तो उसे छोड़ दिया जाएगा.
• अगर आप इनपुट इमेज पर ग्राफ़िक ओवरले करने के लिए डिटेक्टर के आउटपुट का इस्तेमाल करते हैं, तो पहले ML किट से नतीजा पाएं. इसके बाद, इमेज और ओवरले को एक ही चरण में रेंडर करें. ऐसा करके, आप हर प्रोसेस किए गए इनपुट फ़्रेम के लिए डिसप्ले को सिर्फ़ एक बार रेंडर करते हैं. उदाहरण के लिए, ML किट क्विकस्टार्ट सैंपल में updatepreviewOverlayViewWithLastFrame देखें.