Google 致力于为黑人社区推动种族平等。查看具体举措
หน้านี้ได้รับการแปลโดย Cloud Translation API
Switch to English

ตรวจจับใบหน้าด้วย ML Kit บน Android

คุณสามารถใช้ ML Kit เพื่อตรวจจับใบหน้าในรูปภาพและวิดีโอ

ก่อนที่คุณจะเริ่ม

  1. เพิ่ม Firebase ในโปรเจ็กต์ Android ของคุณ หากยังไม่ได้ ทำ
  2. เพิ่มการอ้างอิงสำหรับไลบรารี ML Kit 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. ไม่บังคับ แต่แนะนำ : กำหนดค่าแอปของคุณให้ดาวน์โหลดรุ่น ML ไปยังอุปกรณ์โดยอัตโนมัติหลังจากติดตั้งแอปของคุณจาก 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>
    
    หากคุณไม่ได้เปิดใช้งานการดาวน์โหลดโมเดลเวลาติดตั้งโมเดลจะถูกดาวน์โหลดในครั้งแรกที่คุณเรียกใช้ตัวตรวจจับ คำขอที่คุณทำก่อนการดาวน์โหลดจะเสร็จสิ้นจะไม่เกิดผลลัพธ์ใด ๆ

คำแนะนำในการป้อนรูปภาพ

เพื่อให้ ML Kit ตรวจจับใบหน้าได้อย่างแม่นยำภาพที่ป้อนจะต้องมีใบหน้าที่แสดงโดยข้อมูลพิกเซลที่เพียงพอ โดยทั่วไปแต่ละใบหน้าที่คุณต้องการตรวจจับในภาพควรมีขนาดอย่างน้อย 100x100 พิกเซล หากคุณต้องการตรวจจับรูปทรงของใบหน้า ML Kit ต้องการการป้อนข้อมูลที่มีความละเอียดสูงกว่า: ใบหน้าแต่ละใบหน้าควรมีขนาดอย่างน้อย 200x200 พิกเซล

หากคุณกำลังตรวจจับใบหน้าในแอปพลิเคชันแบบเรียลไทม์คุณอาจต้องพิจารณาขนาดโดยรวมของภาพที่ป้อนด้วย ภาพขนาดเล็กสามารถประมวลผลได้เร็วขึ้นดังนั้นเพื่อลดเวลาในการตอบสนองให้จับภาพที่ความละเอียดต่ำ (โปรดคำนึงถึงข้อกำหนดด้านความแม่นยำข้างต้น) และตรวจสอบให้แน่ใจว่าใบหน้าของวัตถุตรงกับภาพมากที่สุด ดู คำแนะนำในการปรับปรุงประสิทธิภาพแบบเรียลไทม์

การโฟกัสภาพที่ไม่ดีอาจส่งผลเสียต่อความแม่นยำ หากคุณไม่ได้รับผลลัพธ์ที่ยอมรับได้ให้ลองขอให้ผู้ใช้บันทึกภาพอีกครั้ง

การวางแนวของใบหน้าที่สัมพันธ์กับกล้องอาจส่งผลต่อสิ่งที่คุณสมบัติใบหน้า ML Kit ตรวจพบ ดู แนวคิดการตรวจจับใบหน้า

1. กำหนดค่าเครื่องตรวจจับใบหน้า

ก่อนที่คุณจะใช้การตรวจจับใบหน้ากับรูปภาพหากคุณต้องการเปลี่ยนการตั้งค่าเริ่มต้นของเครื่องตรวจจับใบหน้าให้ระบุการตั้งค่าเหล่านั้นด้วยออบเจ็กต์ FirebaseVisionFaceDetectorOptions คุณสามารถเปลี่ยนการตั้งค่าต่อไปนี้:

การตั้งค่า
โหมดประสิทธิภาพ FAST (ค่าเริ่มต้น) | ACCURATE

ชอบความเร็วหรือความแม่นยำเมื่อตรวจจับใบหน้า

ตรวจจับจุดสังเกต NO_LANDMARKS (ค่าเริ่มต้น) | ALL_LANDMARKS

ไม่ว่าจะพยายามระบุ "จุดสังเกต" บนใบหน้า: ตาหูจมูกแก้มปากและอื่น ๆ

ตรวจจับรูปทรง NO_CONTOURS (ค่าเริ่มต้น) | ALL_CONTOURS

ตรวจจับรูปทรงของใบหน้าหรือไม่ ระบบตรวจจับรูปทรงสำหรับใบหน้าที่โดดเด่นที่สุดในรูปภาพเท่านั้น

จำแนกใบหน้า NO_CLASSIFICATIONS (ค่าเริ่มต้น) | ALL_CLASSIFICATIONS

ไม่ว่าจะจำแนกใบหน้าเป็นหมวดหมู่เช่น "ยิ้ม" และ "ลืมตา"

ขนาดใบหน้าขั้นต่ำ float (ค่าเริ่มต้น: 0.1f )

ขนาดต่ำสุดเทียบกับรูปภาพของใบหน้าที่จะตรวจจับ

เปิดใช้งานการติดตามใบหน้า false (ค่าเริ่มต้น) | true

กำหนด ID ใบหน้าหรือไม่ซึ่งสามารถใช้เพื่อติดตามใบหน้าข้ามรูปภาพได้

โปรดทราบว่าเมื่อเปิดใช้งานการตรวจจับรูปร่างจะตรวจพบใบหน้าเพียงใบหน้าเดียวดังนั้นการติดตามใบหน้าจึงไม่ได้ผลลัพธ์ที่เป็นประโยชน์ ด้วยเหตุนี้และเพื่อปรับปรุงความเร็วในการตรวจจับอย่าเปิดใช้งานทั้งการตรวจจับรูปร่างและการติดตามใบหน้า

ตัวอย่างเช่น:

Java

// 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();

โคตรลิน + KTX

// 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. เรียกใช้เครื่องตรวจจับใบหน้า

ในการตรวจจับใบหน้าในรูปภาพให้สร้างออบเจ็กต์ FirebaseVisionImage จาก Bitmap , media.Image , ByteBuffer , byte array หรือไฟล์บนอุปกรณ์ จากนั้นส่งออบเจ็กต์ FirebaseVisionImage ไปยังเมธอด detectInImage ของ FirebaseVisionFaceDetector

สำหรับการจดจำใบหน้าคุณควรใช้รูปภาพที่มีขนาดอย่างน้อย 480x360 พิกเซล หากคุณจดจำใบหน้าแบบเรียลไทม์การจับภาพเฟรมที่ความละเอียดขั้นต่ำนี้สามารถช่วยลดเวลาในการตอบสนองได้

  1. สร้างออบเจ็กต์ FirebaseVisionImage จากรูปภาพของคุณ

    • ในการสร้างวัตถุ FirebaseVisionImage จาก media.Image วัตถุภาพเช่นเมื่อจับภาพจากกล้องของอุปกรณ์ให้ส่ง media.Image วัตถุภาพและการหมุนของภาพไปยัง FirebaseVisionImage.fromMediaImage()

      หากคุณใช้ไลบรารี CameraX OnImageCapturedListener และ ImageAnalysis.Analyzer คำนวณค่าการหมุนให้คุณดังนั้นคุณต้องแปลงการหมุนเป็นค่าคงที่ ROTATION_ ของ ML Kit ก่อนที่จะเรียก 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
              // ...
          }
      }
      

      โคตรลิน + 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;
      }

      โคตรลิน + 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
      }

      จากนั้นส่งผ่านวัตถุ media.Image และค่าการหมุนไปยัง FirebaseVisionImage.fromMediaImage() :

      Java

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

      โคตรลิน + KTX

      val image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation)
    • ในการสร้างออบเจ็กต์ FirebaseVisionImage จากไฟล์ URI ให้ส่งบริบทของแอปและ URI ไปยัง FirebaseVisionImage.fromFilePath() สิ่งนี้มีประโยชน์เมื่อคุณใช้ ACTION_GET_CONTENT เจตนาเพื่อแจ้งให้ผู้ใช้เลือกภาพจากแอปแกลเลอรีของตน

      Java

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

      โคตรลิน + KTX

      val image: FirebaseVisionImage
      try {
          image = FirebaseVisionImage.fromFilePath(context, uri)
      } catch (e: IOException) {
          e.printStackTrace()
      }
    • ในการสร้างออบเจ็กต์ 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();

      โคตรลิน + KTX

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

      ใช้บัฟเฟอร์หรืออาร์เรย์และออบเจ็กต์ข้อมูลเมตาเพื่อสร้างออบเจ็กต์ FirebaseVisionImage :

      Java

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

      โคตรลิน + KTX

      val image = FirebaseVisionImage.fromByteBuffer(buffer, metadata)
      // Or: val image = FirebaseVisionImage.fromByteArray(byteArray, metadata)
    • ในการสร้างออบเจ็กต์ FirebaseVisionImage จากอ็อบเจ็กต์ Bitmap :

      Java

      FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap);

      โคตรลิน + KTX

      val image = FirebaseVisionImage.fromBitmap(bitmap)
      รูปภาพที่แสดงโดยอ็อบเจ็กต์ Bitmap จะต้องตั้งตรงโดยไม่จำเป็นต้องหมุนเพิ่มเติม
  2. รับอินสแตนซ์ของ FirebaseVisionFaceDetector :

    Java

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

    โคตรลิน + 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
                                    // ...
                                }
                            });

    โคตรลิน + KTX

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

3. รับข้อมูลเกี่ยวกับใบหน้าที่ตรวจพบ

หากการดำเนินการจดจำใบหน้าสำเร็จรายการของออบเจ็กต์ FirebaseVisionFace จะถูกส่งต่อไปยังผู้ฟังที่ประสบความสำเร็จ ออบเจ็กต์ FirebaseVisionFace แต่ละชิ้นแสดงใบหน้าที่ตรวจพบในรูปภาพ สำหรับแต่ละใบหน้าคุณจะได้รับพิกัดขอบเขตในภาพอินพุตรวมถึงข้อมูลอื่น ๆ ที่คุณกำหนดค่าให้เครื่องตรวจจับใบหน้าค้นหา ตัวอย่างเช่น:

Java

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();
    }
}

โคตรลิน + KTX

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
    }
}

ตัวอย่างรูปทรงใบหน้า

เมื่อคุณเปิดใช้งานการตรวจจับรูปร่างใบหน้าคุณจะได้รับรายการจุดสำหรับแต่ละลักษณะใบหน้าที่ตรวจพบ จุดเหล่านี้แสดงถึงรูปร่างของสถานที่ ดู ภาพรวมแนวคิดการตรวจจับใบหน้า สำหรับรายละเอียดเกี่ยวกับการแสดงรูปทรง

ภาพต่อไปนี้แสดงให้เห็นว่าจุดเหล่านี้จับคู่กับใบหน้าอย่างไร (คลิกที่ภาพเพื่อขยาย):

การตรวจจับใบหน้าแบบเรียลไทม์

หากคุณต้องการใช้การตรวจจับใบหน้าในแอปพลิเคชันแบบเรียลไทม์ให้ปฏิบัติตามคำแนะนำเหล่านี้เพื่อให้ได้เฟรมเรตที่ดีที่สุด:

  • กำหนดค่าเครื่องตรวจจับใบหน้า ให้ใช้การตรวจจับรูปร่างใบหน้าหรือการจำแนกและการตรวจจับจุดสังเกต แต่ไม่ใช่ทั้งสองอย่าง:

    การตรวจจับรูปร่าง
    การตรวจจับจุดสังเกต
    การจำแนกประเภท
    การตรวจจับและการจำแนกสถานที่สำคัญ
    การตรวจจับรูปร่างและการตรวจจับจุดสังเกต
    การตรวจจับและการจำแนกรูปร่าง
    การตรวจจับรูปร่างการตรวจจับจุดสังเกตและการจำแนกประเภท

  • เปิดใช้งานโหมด FAST (เปิดใช้งานโดยค่าเริ่มต้น)

  • ลองจับภาพที่ความละเอียดต่ำกว่านี้ อย่างไรก็ตามโปรดคำนึงถึงข้อกำหนดขนาดรูปภาพของ API นี้ด้วย

  • เค้นเรียกเครื่องตรวจจับ หากเฟรมวิดีโอใหม่พร้อมใช้งานในขณะที่อุปกรณ์ตรวจจับกำลังทำงานอยู่ให้วางเฟรมลง
  • หากคุณใช้เอาต์พุตของตัวตรวจจับเพื่อซ้อนทับกราฟิกบนภาพอินพุตก่อนอื่นให้รับผลลัพธ์จาก ML Kit จากนั้นแสดงภาพและวางซ้อนในขั้นตอนเดียว โดยการทำเช่นนี้คุณจะแสดงไปที่พื้นผิวการแสดงผลเพียงครั้งเดียวสำหรับแต่ละเฟรมอินพุต
  • หากคุณใช้ Camera2 API ให้จับภาพในรูปแบบ ImageFormat.YUV_420_888

    หากคุณใช้ Camera API รุ่นเก่าให้จับภาพในรูปแบบ ImageFormat.NV21