Catch up on highlights from Firebase at Google I/O 2023. Learn more

आईओएस पर एमएल किट के साथ चेहरे का पता लगाएं

छवियों और वीडियो में चेहरों का पता लगाने के लिए आप एमएल किट का उपयोग कर सकते हैं।

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

  1. यदि आपने पहले से अपने ऐप में Firebase नहीं जोड़ा है, तो आरंभ करने की मार्गदर्शिका में दिए गए चरणों का पालन करके ऐसा करें।
  2. अपने पॉडफाइल में एमएल किट लाइब्रेरी शामिल करें:
    pod 'Firebase/MLVision', '6.25.0'
    # If you want to detect face contours (landmark detection and classification
    # don't require this additional model):
    pod 'Firebase/MLVisionFaceModel', '6.25.0'
    
    अपने प्रोजेक्ट के पॉड्स को इंस्टॉल या अपडेट करने के बाद, अपने एक्सकोड प्रोजेक्ट को इसके .xcworkspace का उपयोग करके खोलना सुनिश्चित करें।
  3. अपने ऐप्लिकेशन में, Firebase आयात करें:

    तीव्र

    import Firebase

    उद्देश्य सी

    @import Firebase;

इनपुट छवि दिशानिर्देश

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

यदि आप रीयल-टाइम एप्लिकेशन में चेहरों का पता लगा रहे हैं, तो आप इनपुट छवियों के समग्र आयामों पर भी विचार कर सकते हैं। छोटी छवियों को तेजी से संसाधित किया जा सकता है, इसलिए विलंबता को कम करने के लिए, कम रिज़ॉल्यूशन पर छवियों को कैप्चर करें (उपरोक्त सटीकता आवश्यकताओं को ध्यान में रखते हुए) और सुनिश्चित करें कि विषय का चेहरा जितना संभव हो उतना छवि पर कब्जा कर लेता है। रीयल-टाइम प्रदर्शन को बेहतर बनाने के लिए युक्तियाँ भी देखें।

खराब छवि फोकस सटीकता को नुकसान पहुंचा सकता है। यदि आपको स्वीकार्य परिणाम नहीं मिल रहे हैं, तो उपयोगकर्ता से छवि को पुनः प्राप्त करने के लिए कहने का प्रयास करें।

कैमरे के सापेक्ष किसी चेहरे का अभिविन्यास भी प्रभावित कर सकता है कि एमएल किट किन चेहरे की विशेषताओं का पता लगाता है। फेस डिटेक्शन कॉन्सेप्ट देखें।

1. फेस डिटेक्टर को कॉन्फ़िगर करें

किसी छवि पर चेहरा पहचान लागू करने से पहले, यदि आप किसी भी फेस डिटेक्टर की डिफ़ॉल्ट सेटिंग्स को बदलना चाहते हैं, तो उन सेटिंग्स को VisionFaceDetectorOptions ऑब्जेक्ट के साथ निर्दिष्ट करें। आप निम्न सेटिंग बदल सकते हैं:

समायोजन
performanceMode fast (डिफ़ॉल्ट) | accurate

चेहरों का पता लगाते समय गति या सटीकता का पक्ष लें।

landmarkMode none (डिफ़ॉल्ट) | all

क्या चेहरे के "स्थलों" का पता लगाने का प्रयास करना है - आंख, कान, नाक, गाल, मुंह - सभी पहचाने गए चेहरों का।

contourMode none (डिफ़ॉल्ट) | all

चेहरे की विशेषताओं की रूपरेखा का पता लगाना है या नहीं। किसी छवि में केवल सबसे प्रमुख चेहरे के लिए आकृति का पता लगाया जाता है।

classificationMode none (डिफ़ॉल्ट) | all

चेहरों को "मुस्कुराते हुए", और "आँखें खुली" जैसी श्रेणियों में वर्गीकृत करना है या नहीं।

minFaceSize CGFloat (डिफ़ॉल्ट: 0.1 )

छवि के सापेक्ष न्यूनतम आकार, चेहरों का पता लगाने के लिए।

isTrackingEnabled false (डिफ़ॉल्ट) | true

चेहरों को एक आईडी असाइन करना है या नहीं, जिसका उपयोग छवियों में चेहरों को ट्रैक करने के लिए किया जा सकता है।

ध्यान दें कि जब समोच्च पहचान सक्षम होती है, तो केवल एक चेहरे का पता लगाया जाता है, इसलिए चेहरा ट्रैकिंग उपयोगी परिणाम नहीं देती है। इस कारण से, और पता लगाने की गति में सुधार करने के लिए, समोच्च पहचान और चेहरा ट्रैकिंग दोनों को सक्षम न करें।

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

तीव्र

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

// Real-time contour detection of multiple faces
let options = VisionFaceDetectorOptions()
options.contourMode = .all

उद्देश्य सी

// High-accuracy landmark detection and face classification
FIRVisionFaceDetectorOptions *options = [[FIRVisionFaceDetectorOptions alloc] init];
options.performanceMode = FIRVisionFaceDetectorPerformanceModeAccurate;
options.landmarkMode = FIRVisionFaceDetectorLandmarkModeAll;
options.classificationMode = FIRVisionFaceDetectorClassificationModeAll;

// Real-time contour detection of multiple faces
FIRVisionFaceDetectorOptions *options = [[FIRVisionFaceDetectorOptions alloc] init];
options.contourMode = FIRVisionFaceDetectorContourModeAll;

2. फेस डिटेक्टर चलाएं

किसी छवि में चेहरों का पता लगाने के लिए, छवि को UIImage या CMSampleBufferRef के रूप में VisionFaceDetector की detect(in:) विधि में पास करें:

  1. VisionFaceDetector का एक उदाहरण प्राप्त करें:

    तीव्र

    lazy var vision = Vision.vision()
    
    let faceDetector = vision.faceDetector(options: options)
    

    उद्देश्य सी

    FIRVision *vision = [FIRVision vision];
    FIRVisionFaceDetector *faceDetector = [vision faceDetector];
    // Or, to change the default settings:
    // FIRVisionFaceDetector *faceDetector =
    //     [vision faceDetectorWithOptions:options];
    
  2. UIImage या CMSampleBufferRef का उपयोग करके एक VisionImage ऑब्जेक्ट बनाएं।

    UIImage का उपयोग करने के लिए:

    1. यदि आवश्यक हो, तो छवि को घुमाएं ताकि उसकी छवि imageOrientation गुण .up
    2. सही ढंग से घुमाए गए UIImage का उपयोग करके एक VisionImage ऑब्जेक्ट बनाएं। कोई रोटेशन मेटाडेटा निर्दिष्ट न करें—डिफ़ॉल्ट मान, .topLeft , का उपयोग किया जाना चाहिए।

      तीव्र

      let image = VisionImage(image: uiImage)

      उद्देश्य सी

      FIRVisionImage *image = [[FIRVisionImage alloc] initWithImage:uiImage];

    CMSampleBufferRef का उपयोग करने के लिए:

    1. एक VisionImageMetadata ऑब्जेक्ट बनाएं जो CMSampleBufferRef बफ़र में निहित छवि डेटा के उन्मुखीकरण को निर्दिष्ट करता है।

      छवि अभिविन्यास प्राप्त करने के लिए:

      तीव्र

      func imageOrientation(
          deviceOrientation: UIDeviceOrientation,
          cameraPosition: AVCaptureDevice.Position
          ) -> VisionDetectorImageOrientation {
          switch deviceOrientation {
          case .portrait:
              return cameraPosition == .front ? .leftTop : .rightTop
          case .landscapeLeft:
              return cameraPosition == .front ? .bottomLeft : .topLeft
          case .portraitUpsideDown:
              return cameraPosition == .front ? .rightBottom : .leftBottom
          case .landscapeRight:
              return cameraPosition == .front ? .topRight : .bottomRight
          case .faceDown, .faceUp, .unknown:
              return .leftTop
          }
      }

      उद्देश्य सी

      - (FIRVisionDetectorImageOrientation)
          imageOrientationFromDeviceOrientation:(UIDeviceOrientation)deviceOrientation
                                 cameraPosition:(AVCaptureDevicePosition)cameraPosition {
        switch (deviceOrientation) {
          case UIDeviceOrientationPortrait:
            if (cameraPosition == AVCaptureDevicePositionFront) {
              return FIRVisionDetectorImageOrientationLeftTop;
            } else {
              return FIRVisionDetectorImageOrientationRightTop;
            }
          case UIDeviceOrientationLandscapeLeft:
            if (cameraPosition == AVCaptureDevicePositionFront) {
              return FIRVisionDetectorImageOrientationBottomLeft;
            } else {
              return FIRVisionDetectorImageOrientationTopLeft;
            }
          case UIDeviceOrientationPortraitUpsideDown:
            if (cameraPosition == AVCaptureDevicePositionFront) {
              return FIRVisionDetectorImageOrientationRightBottom;
            } else {
              return FIRVisionDetectorImageOrientationLeftBottom;
            }
          case UIDeviceOrientationLandscapeRight:
            if (cameraPosition == AVCaptureDevicePositionFront) {
              return FIRVisionDetectorImageOrientationTopRight;
            } else {
              return FIRVisionDetectorImageOrientationBottomRight;
            }
          default:
            return FIRVisionDetectorImageOrientationTopLeft;
        }
      }

      फिर, मेटाडेटा ऑब्जेक्ट बनाएं:

      तीव्र

      let cameraPosition = AVCaptureDevice.Position.back  // Set to the capture device you used.
      let metadata = VisionImageMetadata()
      metadata.orientation = imageOrientation(
          deviceOrientation: UIDevice.current.orientation,
          cameraPosition: cameraPosition
      )

      उद्देश्य सी

      FIRVisionImageMetadata *metadata = [[FIRVisionImageMetadata alloc] init];
      AVCaptureDevicePosition cameraPosition =
          AVCaptureDevicePositionBack;  // Set to the capture device you used.
      metadata.orientation =
          [self imageOrientationFromDeviceOrientation:UIDevice.currentDevice.orientation
                                       cameraPosition:cameraPosition];
    2. CMSampleBufferRef ऑब्जेक्ट और रोटेशन मेटाडेटा का उपयोग करके एक VisionImage ऑब्जेक्ट बनाएं:

      तीव्र

      let image = VisionImage(buffer: sampleBuffer)
      image.metadata = metadata

      उद्देश्य सी

      FIRVisionImage *image = [[FIRVisionImage alloc] initWithBuffer:sampleBuffer];
      image.metadata = metadata;
  3. फिर, इमेज को detect(in:) मेथड में पास करें:

    तीव्र

    faceDetector.process(visionImage) { faces, error in
      guard error == nil, let faces = faces, !faces.isEmpty else {
        // ...
        return
      }
    
      // Faces detected
      // ...
    }
    

    उद्देश्य सी

    [faceDetector detectInImage:image
                     completion:^(NSArray<FIRVisionFace *> *faces,
                                  NSError *error) {
      if (error != nil) {
        return;
      } else if (faces != nil) {
        // Recognized faces
      }
    }];
    

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

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

तीव्र

for face in faces {
  let frame = face.frame
  if face.hasHeadEulerAngleY {
    let rotY = face.headEulerAngleY  // Head is rotated to the right rotY degrees
  }
  if face.hasHeadEulerAngleZ {
    let rotZ = face.headEulerAngleZ  // Head is rotated upward 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
  }
}

उद्देश्य सी

for (FIRVisionFace *face in faces) {
  // Boundaries of face in image
  CGRect frame = face.frame;

  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):
  FIRVisionFaceLandmark *leftEar = [face landmarkOfType:FIRFaceLandmarkTypeLeftEar];
  if (leftEar != nil) {
    FIRVisionPoint *leftEarPosition = leftEar.position;
  }

  // If contour detection was enabled:
  FIRVisionFaceContour *upperLipBottomContour = [face contourOfType:FIRFaceContourTypeUpperLipBottom];
  if (upperLipBottomContour != nil) {
    NSArray<FIRVisionPoint *> *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 मोड सक्षम करें (डिफ़ॉल्ट रूप से सक्षम)।

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

  • डिटेक्टर को थ्रॉटल कॉल। यदि डिटेक्टर के चलने के दौरान कोई नया वीडियो फ़्रेम उपलब्ध हो जाता है, तो फ़्रेम को छोड़ दें।
  • यदि आप इनपुट छवि पर ग्राफिक्स को ओवरले करने के लिए डिटेक्टर के आउटपुट का उपयोग कर रहे हैं, तो पहले एमएल किट से परिणाम प्राप्त करें, फिर एक ही चरण में छवि और ओवरले को प्रस्तुत करें। ऐसा करने से, आप प्रत्येक इनपुट फ्रेम के लिए केवल एक बार प्रदर्शन सतह पर प्रस्तुत करते हैं। उदाहरण के लिए शोकेस सैंपल ऐप में प्रीव्यूऑवरलेव्यू और एफआईआरडिटेक्शनऑवरलेव्यू क्लासेस देखें।