אפשר להשתמש ב-ML Kit כדי לזהות פנים בתמונות ובסרטונים.
תכונה | לא חלק מהחבילה | בחבילה |
---|---|---|
הטמעה | הורדת המודל מתבצעת באופן דינמי דרך Google Play Services. | המודל מקושר באופן סטטי לאפליקציה בזמן ה-build. |
גודל האפליקציה | הגדלה של כ-800KB. | הגדלה של כ-6.9MB. |
זמן האתחול | יכול להיות שתצטרכו להמתין להורדת המודל לפני השימוש הראשון. | הדגם זמין באופן מיידי |
אני רוצה לנסות
- מומלץ להתנסות באפליקציה לדוגמה כדי לראות דוגמה לשימוש ב-API הזה.
- אתם יכולים לנסות את הקוד בעצמכם באמצעות Codelab.
לפני שמתחילים
בקובץ
build.gradle
ברמת הפרויקט, חשוב לכלול את מאגר Maven של Google בקטעbuildscript
וגם בקטעallprojects
.מוסיפים את יחסי התלות של ספריות ML Kit Android לקובץ GRid ברמת האפליקציה של המודול, בדרך כלל
app/build.gradle
. תוכלו לבחור באחד מיחסי התלות הבאים בהתאם לצרכים שלכם:כדי לקבץ את המודל עם האפליקציה:
dependencies { // ... // Use this dependency to bundle the model with your app implementation 'com.google.mlkit:face-detection:16.1.6' }
כדי להשתמש במודל ב-Google Play Services:
dependencies { // ... // Use this dependency to use the dynamically downloaded model in Google Play Services implementation 'com.google.android.gms:play-services-mlkit-face-detection:17.1.0' }
אם תבחרו להשתמש במודל ב-Google Play Services, תוכלו להגדיר שהאפליקציה תוריד את המודל באופן אוטומטי למכשיר אחרי התקנת האפליקציה מחנות Play. כדי לעשות את זה, צריך להוסיף את ההצהרה הבאה לקובץ
AndroidManifest.xml
של האפליקציה:<application ...> ... <meta-data android:name="com.google.mlkit.vision.DEPENDENCIES" android:value="face" > <!-- To use multiple models: android:value="face,model2,model3" --> </application>
תוכלו גם לבדוק באופן מפורש את זמינות המודל ולבקש הורדה דרך ModuleInstallClient API של Google Play Services.
אם לא מפעילים הורדות של מודלים בזמן ההתקנה או מבקשים הורדה מפורשת, הורדת המודל מתבצעת בפעם הראשונה שתפעילו את הגלאי. בקשות שמבצעים לפני סיום ההורדה לא מובילות לתוצאות.
הנחיות להוספת תמונה
לצורך זיהוי פנים, עליך להשתמש בתמונה במידות של 480x360 פיקסלים לפחות. כדי ש-ML Kit תזהה פנים באופן מדויק, תמונות הקלט חייבות להכיל פנים שמיוצגות על ידי נתוני פיקסלים מספיקים. באופן כללי, הגודל של כל פנים שרוצים לזהות בתמונה צריך להיות לפחות 100x100 פיקסלים. כדי לזהות את קווי המתאר של הפנים, נדרשת ל-ML Kit קלט ברזולוציה גבוהה יותר: כל משטח צריך להיות בגודל של 200x200 פיקסלים לפחות.
אם מזהים פנים באפליקציה בזמן אמת, כדאי להביא בחשבון גם את המידות הכוללות של תמונות הקלט. אפשר לעבד תמונות קטנות יותר מהר יותר. לכן, כדי לצמצם את זמן האחזור, לצלם תמונות ברזולוציות נמוכות יותר. עם זאת, חשוב לזכור את דרישות הדיוק המפורטות למעלה ולוודא שפנים של נושא התמונה תופסות חלק גדול ככל האפשר מהתמונה. אפשר למצוא גם טיפים לשיפור הביצועים בזמן אמת.
גם מיקוד תמונה לא טוב יכול להשפיע על רמת הדיוק. אם לא מתקבלות תוצאות מקובלות, עליך לבקש מהמשתמש לצלם מחדש את התמונה.
הכיוון של הפנים ביחס למצלמה יכול להשפיע גם על תכונות הפנים שזוהו ב-ML Kit. ראו מושגים של זיהוי פנים.
1. הגדרת גלאי הפנים
לפני שמחילים זיהוי פנים על תמונה, אם רוצים לשנות את הגדרות ברירת המחדל של מזהה הפנים, צריך לציין את ההגדרות האלה באמצעות אובייקטFaceDetectorOptions
.
אפשר לשנות את ההגדרות הבאות:
הגדרות | |
---|---|
setPerformanceMode
|
PERFORMANCE_MODE_FAST (ברירת מחדל)
|
PERFORMANCE_MODE_ACCURATE
העדפה של המהירות או הדיוק בזיהוי פנים. |
setLandmarkMode
|
LANDMARK_MODE_NONE (ברירת מחדל)
|
LANDMARK_MODE_ALL
האם לנסות לזהות "סימני דרך" לפנים: עיניים, אוזניים, אף, לחיים, פה וכו'. |
setContourMode
|
CONTOUR_MODE_NONE (ברירת מחדל)
|
CONTOUR_MODE_ALL
הגדרה שקובעת אם לזהות את קווי המתאר של תווי הפנים. המערכת מזהה קווי מתאר רק לפי הפנים הבולטות ביותר בתמונה. |
setClassificationMode
|
CLASSIFICATION_MODE_NONE (ברירת מחדל)
|
CLASSIFICATION_MODE_ALL
האם לסווג פנים לקטגוריות כמו 'חיוך' ו'עיניים פקוחות'. |
setMinFaceSize
|
float (ברירת המחדל: 0.1f )
מגדירה את גודל הפנים הקטן ביותר הרצוי, מבוטא כיחס בין רוחב הראש לרוחב התמונה. |
enableTracking
|
false (ברירת מחדל) | true
האם להקצות מזהה לזיהוי פנים, או לא, כדי לעקוב אחר פנים בתמונות. חשוב לשים לב שכשזיהוי קווי מתאר מופעל, המערכת מזהה רק פנים אחד, ולכן המעקב אחר הפנים לא מספק תוצאות מועילות. לכן וכדי לשפר את מהירות הזיהוי, אין להפעיל גם את זיהוי קווי המתאר וגם את המעקב אחר הפנים. |
למשל:
Kotlin
// High-accuracy landmark detection and face classification val highAccuracyOpts = FaceDetectorOptions.Builder() .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE) .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL) .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL) .build() // Real-time contour detection val realTimeOpts = FaceDetectorOptions.Builder() .setContourMode(FaceDetectorOptions.CONTOUR_MODE_ALL) .build()
Java
// High-accuracy landmark detection and face classification FaceDetectorOptions highAccuracyOpts = new FaceDetectorOptions.Builder() .setPerformanceMode(FaceDetectorOptions.PERFORMANCE_MODE_ACCURATE) .setLandmarkMode(FaceDetectorOptions.LANDMARK_MODE_ALL) .setClassificationMode(FaceDetectorOptions.CLASSIFICATION_MODE_ALL) .build(); // Real-time contour detection FaceDetectorOptions realTimeOpts = new FaceDetectorOptions.Builder() .setContourMode(FaceDetectorOptions.CONTOUR_MODE_ALL) .build();
2. הכנת תמונת הקלט
כדי לזהות פנים בתמונה, צריך ליצור אובייקטInputImage
מ-Bitmap
, מ-media.Image
, מ-ByteBuffer
, ממערך בייטים או מקובץ במכשיר. לאחר מכן מעבירים את האובייקט InputImage
ל-method process
של FaceDetector
.
לזיהוי פנים, צריך להשתמש בתמונה במידות של 480x360 פיקסלים לפחות. אם אתם מזהים פנים בזמן אמת, צילום פריימים ברזולוציה המינימלית הזו יכול לקצר את זמן האחזור.
אפשר ליצור אובייקט InputImage
ממקורות שונים, כפי שמוסבר בהמשך.
באמצעות media.Image
כדי ליצור אובייקט InputImage
מאובייקט media.Image
, למשל כשמצלמים תמונה ממצלמה של מכשיר, מעבירים את האובייקט media.Image
ואת הסיבוב של התמונה אל InputImage.fromMediaImage()
.
אם משתמשים בספריית
CameraX, המחלקות OnImageCapturedListener
ו-ImageAnalysis.Analyzer
תחשבות את ערך הסיבוב
בשבילכם.
Kotlin
private class YourImageAnalyzer : ImageAnalysis.Analyzer { override fun analyze(imageProxy: ImageProxy) { val mediaImage = imageProxy.image if (mediaImage != null) { val image = InputImage.fromMediaImage(mediaImage, imageProxy.imageInfo.rotationDegrees) // Pass image to an ML Kit Vision API // ... } } }
Java
private class YourAnalyzer implements ImageAnalysis.Analyzer { @Override public void analyze(ImageProxy imageProxy) { Image mediaImage = imageProxy.getImage(); if (mediaImage != null) { InputImage image = InputImage.fromMediaImage(mediaImage, imageProxy.getImageInfo().getRotationDegrees()); // Pass image to an ML Kit Vision API // ... } } }
אם לא משתמשים בספריית מצלמה שמאפשרת לקבוע את זווית הסיבוב של התמונה, אפשר לחשב אותה לפי זווית הסיבוב של המכשיר והכיוון של חיישן המצלמה:
Kotlin
private val ORIENTATIONS = SparseIntArray() init { ORIENTATIONS.append(Surface.ROTATION_0, 0) ORIENTATIONS.append(Surface.ROTATION_90, 90) ORIENTATIONS.append(Surface.ROTATION_180, 180) ORIENTATIONS.append(Surface.ROTATION_270, 270) } /** * 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, isFrontFacing: Boolean): 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) // Get the device's sensor orientation. val cameraManager = activity.getSystemService(CAMERA_SERVICE) as CameraManager val sensorOrientation = cameraManager .getCameraCharacteristics(cameraId) .get(CameraCharacteristics.SENSOR_ORIENTATION)!! if (isFrontFacing) { rotationCompensation = (sensorOrientation + rotationCompensation) % 360 } else { // back-facing rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360 } return rotationCompensation }
Java
private static final SparseIntArray ORIENTATIONS = new SparseIntArray(); static { ORIENTATIONS.append(Surface.ROTATION_0, 0); ORIENTATIONS.append(Surface.ROTATION_90, 90); ORIENTATIONS.append(Surface.ROTATION_180, 180); ORIENTATIONS.append(Surface.ROTATION_270, 270); } /** * 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, boolean isFrontFacing) 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); // Get the device's sensor orientation. CameraManager cameraManager = (CameraManager) activity.getSystemService(CAMERA_SERVICE); int sensorOrientation = cameraManager .getCameraCharacteristics(cameraId) .get(CameraCharacteristics.SENSOR_ORIENTATION); if (isFrontFacing) { rotationCompensation = (sensorOrientation + rotationCompensation) % 360; } else { // back-facing rotationCompensation = (sensorOrientation - rotationCompensation + 360) % 360; } return rotationCompensation; }
לאחר מכן, מעבירים את האובייקט media.Image
ואת ערך מידת הסיבוב ל-InputImage.fromMediaImage()
:
Kotlin
val image = InputImage.fromMediaImage(mediaImage, rotation)
Java
InputImage image = InputImage.fromMediaImage(mediaImage, rotation);
שימוש ב-URI של קובץ
כדי ליצור אובייקט InputImage
מ-URI של קובץ, מעבירים את ההקשר של האפליקציה ואת ה-URI של הקובץ ל-InputImage.fromFilePath()
. האפשרות הזו שימושית כשמשתמשים
ב-Intent של ACTION_GET_CONTENT
כדי לבקש מהמשתמש לבחור
תמונה מאפליקציית הגלריה.
Kotlin
val image: InputImage try { image = InputImage.fromFilePath(context, uri) } catch (e: IOException) { e.printStackTrace() }
Java
InputImage image; try { image = InputImage.fromFilePath(context, uri); } catch (IOException e) { e.printStackTrace(); }
שימוש ב-ByteBuffer
או ב-ByteArray
כדי ליצור אובייקט InputImage
מ-ByteBuffer
או מ-ByteArray
, קודם צריך לחשב את מידת הסיבוב של התמונה כפי שתואר קודם לכן לקלט media.Image
.
לאחר מכן, יוצרים את האובייקט InputImage
עם מאגר הנתונים הזמני או המערך, יחד עם הגובה, הרוחב, פורמט קידוד הצבע ורמת הסיבוב של התמונה:
Kotlin
val image = InputImage.fromByteBuffer( byteBuffer, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 ) // Or: val image = InputImage.fromByteArray( byteArray, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 )
Java
InputImage image = InputImage.fromByteBuffer(byteBuffer, /* image width */ 480, /* image height */ 360, rotationDegrees, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 ); // Or: InputImage image = InputImage.fromByteArray( byteArray, /* image width */480, /* image height */360, rotation, InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12 );
באמצעות Bitmap
כדי ליצור אובייקט InputImage
מאובייקט Bitmap
, צריך להשתמש בהצהרה הבאה:
Kotlin
val image = InputImage.fromBitmap(bitmap, 0)
Java
InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);
התמונה מיוצגת על ידי אובייקט Bitmap
ביחד עם מעלות סיבוב.
3. קבלת מופע של FaceDetector
Kotlin
val detector = FaceDetection.getClient(options) // Or, to use the default option: // val detector = FaceDetection.getClient();
Java
FaceDetector detector = FaceDetection.getClient(options); // Or use the default options: // FaceDetector detector = FaceDetection.getClient();
4. עיבוד התמונה
מעבירים את התמונה ל-methodprocess
:
Kotlin
val result = detector.process(image) .addOnSuccessListener { faces -> // Task completed successfully // ... } .addOnFailureListener { e -> // Task failed with an exception // ... }
Java
Task<List<Face>> result = detector.process(image) .addOnSuccessListener( new OnSuccessListener<List<Face>>() { @Override public void onSuccess(List<Face> faces) { // Task completed successfully // ... } }) .addOnFailureListener( new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { // Task failed with an exception // ... } });
5. קבלת מידע על פנים שזוהו
אם פעולת זיהוי הפנים מצליחה, מועברת רשימה של אובייקטים ב-Face
למאזינים שהצליחו. כל אובייקט Face
מייצג פנים שאותרו בתמונה. לכל פנים אפשר לראות את הקואורדינטות התוחמות שלהן בתמונת הקלט, וגם כל מידע אחר שהגדרתם שגלאי הפנים ימצא. למשל:
Kotlin
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(FaceLandmark.LEFT_EAR) leftEar?.let { val leftEarPos = leftEar.position } // If contour detection was enabled: val leftEyeContour = face.getContour(FaceContour.LEFT_EYE)?.points val upperLipBottomContour = face.getContour(FaceContour.UPPER_LIP_BOTTOM)?.points // If classification was enabled: if (face.smilingProbability != null) { val smileProb = face.smilingProbability } if (face.rightEyeOpenProbability != null) { val rightEyeOpenProb = face.rightEyeOpenProbability } // If face tracking was enabled: if (face.trackingId != null) { val id = face.trackingId } }
Java
for (Face 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): FaceLandmark leftEar = face.getLandmark(FaceLandmark.LEFT_EAR); if (leftEar != null) { PointF leftEarPos = leftEar.getPosition(); } // If contour detection was enabled: List<PointF> leftEyeContour = face.getContour(FaceContour.LEFT_EYE).getPoints(); List<PointF> upperLipBottomContour = face.getContour(FaceContour.UPPER_LIP_BOTTOM).getPoints(); // If classification was enabled: if (face.getSmilingProbability() != null) { float smileProb = face.getSmilingProbability(); } if (face.getRightEyeOpenProbability() != null) { float rightEyeOpenProb = face.getRightEyeOpenProbability(); } // If face tracking was enabled: if (face.getTrackingId() != null) { int id = face.getTrackingId(); } }
דוגמה לקווי מתאר של הפנים
כשמפעילים את התכונה 'זיהוי קווי מתאר של הפנים', מקבלים רשימה של נקודות לכל תכונת פנים שזוהתה. הנקודות האלה מייצגות את הצורה של הישות. לפרטים על האופן שבו קווי המתאר מיוצגים, ראו מושגי זיהוי פנים.
התמונה הבאה ממחישה איך הנקודות האלה ממופות לפנים. צריך ללחוץ על התמונה כדי להגדיל אותה:
זיהוי פנים בזמן אמת
אם אתם רוצים להשתמש בזיהוי פנים באפליקציה בזמן אמת, עליכם לפעול לפי ההנחיות הבאות כדי להשיג את קצב הפריימים הטוב ביותר:
צריך להגדיר את גלאי הפנים לשימוש בזיהוי קווי פנים או בסיווג ובזיהוי של ציוני דרך, אבל לא בשניהם:
זיהוי קווי מתאר
זיהוי ציוני דרך
סיווג
זיהוי וסיווג של ציוני דרך
זיהוי קווי מתאר וזיהוי של ציוני דרך
זיהוי וסיווג של קווי מתאר
זיהוי קווי מתאר, זיהוי של ציוני דרך וסיווגהפעלה של מצב
FAST
(מופעל כברירת מחדל).כדאי לצלם תמונות ברזולוציה נמוכה יותר. עם זאת, חשוב לזכור גם את הדרישות לגבי מידות התמונה של ה-API הזה.
Camera
או
camera2
,
צריך לווסת את הקריאות למזהה. אם פריים חדש
בווידאו הופך לזמין בזמן שהגלאי פועל, משחררים את הפריים. לדוגמה, תוכלו לעיין בשיעור
VisionProcessorBase
באפליקציה לדוגמה של המדריך למתחילים.
CameraX
,
צריך לוודא שאסטרטגיית לחיצה לאחור מוגדרת לערך ברירת המחדל שלה
ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST
.
כך אפשר להבטיח שרק תמונה אחת תוצג לניתוח בכל פעם. אם יופקו עוד תמונות
כשהכלי לניתוח נתונים עמוס, הן יוסרו באופן אוטומטי ולא ימתינו לתור למשלוח. לאחר סגירת התמונה שמנתחת על ידי קריאה ל-ImageProxy.close(), מתקבלת התמונה העדכנית ביותר.
CameraSourcePreview
ו-
GraphicOverlay
באפליקציה לדוגמה של המדריך למתחילים.
ImageFormat.YUV_420_888
. אם משתמשים בגרסה הקודמת של Camera API, צריך לצלם תמונות
בפורמט ImageFormat.NV21
.