דף זה תורגם על ידי Cloud Translation API.

זיהוי תנוחות באמצעות ML Kit ב-Android

ML Kit מספק שתי ערכות SDK שעברו אופטימיזציה לזיהוי תנוחה.

שם ה-SDK	pose-detection	pose-detection-accurate
הטמעה	הקוד והנכסים מקושרים לאפליקציה באופן סטטי בזמן ה-build.	הקוד והנכסים מקושרים לאפליקציה באופן סטטי בזמן ה-build.
ההשפעה של גודל האפליקציה (כולל קוד ונכסים)	כ-10.1MB	כ-13.3MB
ביצועים	Pixel 3XL: כ-30FPS	Pixel 3XL: כ-23 FPS עם מעבד (CPU) ו-30 FPS עם GPU

רוצה לנסות?

מומלץ לשחק עם האפליקציה לדוגמה כדי .

לפני שמתחילים

ל-API הזה נדרשת רמת API של Android 21 ומעלה. חשוב לוודא שה-build של האפליקציה משתמש בערך minSdkVersion של 21 ומעלה.

בקובץ build.gradle ברמת הפרויקט, חשוב לכלול את מאגר Maven של Google בקטע buildscript וגם בקטע allprojects.

מוסיפים את יחסי התלות של ספריות ML Kit Android לקובץ GRid ברמת האפליקציה של המודול, שהוא בדרך כלל app/build.gradle:

dependencies {
  // If you want to use the base sdk
  implementation 'com.google.mlkit:pose-detection:18.0.0-beta5'
  // If you want to use the accurate sdk
  implementation 'com.google.mlkit:pose-detection-accurate:18.0.0-beta5'
}

1. יצירת מכונה של `PoseDetector`

`PoseDetector` אפשרויות

כדי לזהות תנוחה בתמונה, קודם צריך ליצור מופע של PoseDetector לציין את הגדרות המזהה.

מצב זיהוי

המכשיר PoseDetector פועל בשני מצבי זיהוי. עליך לוודא שבחרת את המודעה המתאימה של התרחיש לדוגמה המבוקש.

‫STREAM_MODE (ברירת מחדל): מזהה התנוחה יזהה קודם את רוב האנשים האדם הבולט בתמונה, ולאחר מכן להפעיל זיהוי תנוחה. במסגרות הבאות, שלב זיהוי האדם לא יתבצע, אלא אם האדם מוסתרת או שהיא לא מזוהה יותר ברמת מהימנות גבוהה. מזהה התנוחה לנסות לעקוב אחרי האדם הבולט ביותר ולהחזיר את התנוחה שלו מסיקה. כך ניתן לקצר את זמן האחזור ולהחלק את הזיהוי. במצב הזה משתמשים שרוצים לזהות תנוחת וידאו בסטרימינג.
SINGLE_IMAGE_MODE: מזהה התנוחה יזהה אדם כלשהו ואז יריץ את התנוחה שלו זיהוי וזיהוי אובייקטים. השלב של זיהוי אדם יפעל בכל תמונה, כך שזמן האחזור יהיו גבוהות יותר, ואין מעקב אחר אדם. שימוש במצב הזה כשמשתמשים בתנוחה זיהוי תמונות סטטיות או במקומות שבהם לא רוצים לבצע מעקב.

הגדרת החומרה

PoseDetector תומך במספר תצורות חומרה לצורך אופטימיזציה ביצועים:

CPU: הפעלת הגלאי באמצעות מעבד (CPU) בלבד
CPU_GPU: הפעלת הגלאי באמצעות מעבד (CPU) ו-GPU

כשמפתחים את אפשרויות המזהה, אפשר להשתמש ב-API setPreferredHardwareConfigs כדי לשלוט בבחירת החומרה. כברירת מחדל, כל תצורות החומרה מוגדרות כמועדפות.

ל-ML Kit המערכת תשתמש בזמינות, ביציבות, בתיקון ובזמן האחזור של כל הגדרה בחשבון ולבחור את האפשרות הטובה ביותר מתוך ההגדרות המועדפות. אם אף אחד מהתנאים האלה ההגדרות המועדפות רלוונטיות, המערכת תשתמש בהגדרה CPU באופן אוטומטי כחלופה. ערכת למידת המכונה תבצע את הבדיקות האלה ואת ההכנות שקשורות אליהן ללא חסימה לפני הפעלת האצה כלשהי, לכן סביר להניח בפעם הראשונה שהמשתמש יפעיל את המזהה, הוא ישתמש ב-CPU. אחרי כל סיום ההכנה, ההגדרה הטובה ביותר תשמש ברצות הבאות.

שימושים לדוגמה ב-setPreferredHardwareConfigs:

כדי לאפשר ל-ML Kit לבחור את ההגדרה הטובה ביותר, אין לקרוא ל-API הזה.
אם אינך רוצה להפעיל האצה כלשהי, עליך להעביר רק את CPU.
אם רוצים להשתמש ב-GPU כדי להפחית את העומס על המעבד (CPU), גם אם ה-GPU עשוי להיות איטי יותר, מעבירים תוך CPU_GPU בלבד.

הגדרת האפשרויות של מזהה התנוחה:

Kotlin

// Base pose detector with streaming frames, when depending on the pose-detection sdk
val options = PoseDetectorOptions.Builder()
    .setDetectorMode(PoseDetectorOptions.STREAM_MODE)
    .build()

// Accurate pose detector on static images, when depending on the pose-detection-accurate sdk
val options = AccuratePoseDetectorOptions.Builder()
    .setDetectorMode(AccuratePoseDetectorOptions.SINGLE_IMAGE_MODE)
    .build()

Java

// Base pose detector with streaming frames, when depending on the pose-detection sdk
PoseDetectorOptions options =
   new PoseDetectorOptions.Builder()
       .setDetectorMode(PoseDetectorOptions.STREAM_MODE)
       .build();

// Accurate pose detector on static images, when depending on the pose-detection-accurate sdk
AccuratePoseDetectorOptions options =
   new AccuratePoseDetectorOptions.Builder()
       .setDetectorMode(AccuratePoseDetectorOptions.SINGLE_IMAGE_MODE)
       .build();

לבסוף, יוצרים מופע של PoseDetector. מעבירים את האפשרויות שציינתם:

Kotlin

val poseDetector = PoseDetection.getClient(options)

Java

PoseDetector poseDetector = PoseDetection.getClient(options);

2. הכנת תמונת הקלט

כדי לזהות תנוחות בתמונה, צריך ליצור אובייקט InputImage מ-Bitmap, media.Image, ByteBuffer, ממערך בייטים או מקובץ במכשיר. לאחר מכן מעבירים את האובייקט InputImage אל PoseDetector.

לזיהוי תנוחה, עליך להשתמש בתמונה במידות של לפחות 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
}MLKitVisionImage.kt

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)MLKitVisionImage.kt

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()
}MLKitVisionImage.kt

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
)MLKitVisionImage.kt
// Or:
val image = InputImage.fromByteArray(
        byteArray,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
)
MLKitVisionImage.kt

Java

InputImage image = InputImage.fromByteBuffer(byteBuffer,
        /* image width */ 480,
        /* image height */ 360,
        rotationDegrees,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);MLKitVisionImage.java
// Or:
InputImage image = InputImage.fromByteArray(
        byteArray,
        /* image width */480,
        /* image height */360,
        rotation,
        InputImage.IMAGE_FORMAT_NV21 // or IMAGE_FORMAT_YV12
);MLKitVisionImage.java

באמצעות `Bitmap`

כדי ליצור InputImage מאובייקט Bitmap, צריך ליצור את ההצהרה הבאה:

Kotlin

val image = InputImage.fromBitmap(bitmap, 0)MLKitVisionImage.kt

Java

InputImage image = InputImage.fromBitmap(bitmap, rotationDegree);MLKitVisionImage.java

התמונה מיוצגת על ידי אובייקט Bitmap ביחד עם מעלות סיבוב.

3. עיבוד התמונה

מעבירים את האובייקט InputImage המוכן ל-method process של PoseDetector.

Kotlin

Task<Pose> result = poseDetector.process(image)
       .addOnSuccessListener { results ->
           // Task completed successfully
           // ...
       }
       .addOnFailureListener { e ->
           // Task failed with an exception
           // ...
       }

Java

Task<Pose> result =
        poseDetector.process(image)
                .addOnSuccessListener(
                        new OnSuccessListener<Pose>() {
                            @Override
                            public void onSuccess(Pose pose) {
                                // Task completed successfully
                                // ...
                            }
                        })
                .addOnFailureListener(
                        new OnFailureListener() {
                            @Override
                            public void onFailure(@NonNull Exception e) {
                                // Task failed with an exception
                                // ...
                            }
                        });

הערה: אם אתה משתמש ב API של CameraX, חשוב לסגור את ImageProxy בסיום השימוש בו. למשל, על ידי הוספה של OnCompleteListener אל Task שהוחזר שיטת process. לצפייה VisionProcessorBase באפליקציה לדוגמה של המדריך למתחילים.

4. קבלת מידע על התנוחה שזוהתה

אם מזוהה אדם בתמונה, ה-API לזיהוי התנוחה יחזיר Pose אובייקט עם 33 רכיבי PoseLandmark.

אם האדם לא היה בתוך התמונה במלואה, המודל מקצה את נקודות הציון החסרות, הקואורדינטות מחוץ למסגרת ערכי מהימנות של InFrame.

אם לא זוהה אף אדם במסגרת, Pose האובייקט לא מכיל תווי PoseLandmark.

Kotlin

// Get all PoseLandmarks. If no person was detected, the list will be empty
val allPoseLandmarks = pose.getAllPoseLandmarks()

// Or get specific PoseLandmarks individually. These will all be null if no person
// was detected
val leftShoulder = pose.getPoseLandmark(PoseLandmark.LEFT_SHOULDER)
val rightShoulder = pose.getPoseLandmark(PoseLandmark.RIGHT_SHOULDER)
val leftElbow = pose.getPoseLandmark(PoseLandmark.LEFT_ELBOW)
val rightElbow = pose.getPoseLandmark(PoseLandmark.RIGHT_ELBOW)
val leftWrist = pose.getPoseLandmark(PoseLandmark.LEFT_WRIST)
val rightWrist = pose.getPoseLandmark(PoseLandmark.RIGHT_WRIST)
val leftHip = pose.getPoseLandmark(PoseLandmark.LEFT_HIP)
val rightHip = pose.getPoseLandmark(PoseLandmark.RIGHT_HIP)
val leftKnee = pose.getPoseLandmark(PoseLandmark.LEFT_KNEE)
val rightKnee = pose.getPoseLandmark(PoseLandmark.RIGHT_KNEE)
val leftAnkle = pose.getPoseLandmark(PoseLandmark.LEFT_ANKLE)
val rightAnkle = pose.getPoseLandmark(PoseLandmark.RIGHT_ANKLE)
val leftPinky = pose.getPoseLandmark(PoseLandmark.LEFT_PINKY)
val rightPinky = pose.getPoseLandmark(PoseLandmark.RIGHT_PINKY)
val leftIndex = pose.getPoseLandmark(PoseLandmark.LEFT_INDEX)
val rightIndex = pose.getPoseLandmark(PoseLandmark.RIGHT_INDEX)
val leftThumb = pose.getPoseLandmark(PoseLandmark.LEFT_THUMB)
val rightThumb = pose.getPoseLandmark(PoseLandmark.RIGHT_THUMB)
val leftHeel = pose.getPoseLandmark(PoseLandmark.LEFT_HEEL)
val rightHeel = pose.getPoseLandmark(PoseLandmark.RIGHT_HEEL)
val leftFootIndex = pose.getPoseLandmark(PoseLandmark.LEFT_FOOT_INDEX)
val rightFootIndex = pose.getPoseLandmark(PoseLandmark.RIGHT_FOOT_INDEX)
val nose = pose.getPoseLandmark(PoseLandmark.NOSE)
val leftEyeInner = pose.getPoseLandmark(PoseLandmark.LEFT_EYE_INNER)
val leftEye = pose.getPoseLandmark(PoseLandmark.LEFT_EYE)
val leftEyeOuter = pose.getPoseLandmark(PoseLandmark.LEFT_EYE_OUTER)
val rightEyeInner = pose.getPoseLandmark(PoseLandmark.RIGHT_EYE_INNER)
val rightEye = pose.getPoseLandmark(PoseLandmark.RIGHT_EYE)
val rightEyeOuter = pose.getPoseLandmark(PoseLandmark.RIGHT_EYE_OUTER)
val leftEar = pose.getPoseLandmark(PoseLandmark.LEFT_EAR)
val rightEar = pose.getPoseLandmark(PoseLandmark.RIGHT_EAR)
val leftMouth = pose.getPoseLandmark(PoseLandmark.LEFT_MOUTH)
val rightMouth = pose.getPoseLandmark(PoseLandmark.RIGHT_MOUTH)

Java

// Get all PoseLandmarks. If no person was detected, the list will be empty
List<PoseLandmark> allPoseLandmarks = pose.getAllPoseLandmarks();

// Or get specific PoseLandmarks individually. These will all be null if no person
// was detected
PoseLandmark leftShoulder = pose.getPoseLandmark(PoseLandmark.LEFT_SHOULDER);
PoseLandmark rightShoulder = pose.getPoseLandmark(PoseLandmark.RIGHT_SHOULDER);
PoseLandmark leftElbow = pose.getPoseLandmark(PoseLandmark.LEFT_ELBOW);
PoseLandmark rightElbow = pose.getPoseLandmark(PoseLandmark.RIGHT_ELBOW);
PoseLandmark leftWrist = pose.getPoseLandmark(PoseLandmark.LEFT_WRIST);
PoseLandmark rightWrist = pose.getPoseLandmark(PoseLandmark.RIGHT_WRIST);
PoseLandmark leftHip = pose.getPoseLandmark(PoseLandmark.LEFT_HIP);
PoseLandmark rightHip = pose.getPoseLandmark(PoseLandmark.RIGHT_HIP);
PoseLandmark leftKnee = pose.getPoseLandmark(PoseLandmark.LEFT_KNEE);
PoseLandmark rightKnee = pose.getPoseLandmark(PoseLandmark.RIGHT_KNEE);
PoseLandmark leftAnkle = pose.getPoseLandmark(PoseLandmark.LEFT_ANKLE);
PoseLandmark rightAnkle = pose.getPoseLandmark(PoseLandmark.RIGHT_ANKLE);
PoseLandmark leftPinky = pose.getPoseLandmark(PoseLandmark.LEFT_PINKY);
PoseLandmark rightPinky = pose.getPoseLandmark(PoseLandmark.RIGHT_PINKY);
PoseLandmark leftIndex = pose.getPoseLandmark(PoseLandmark.LEFT_INDEX);
PoseLandmark rightIndex = pose.getPoseLandmark(PoseLandmark.RIGHT_INDEX);
PoseLandmark leftThumb = pose.getPoseLandmark(PoseLandmark.LEFT_THUMB);
PoseLandmark rightThumb = pose.getPoseLandmark(PoseLandmark.RIGHT_THUMB);
PoseLandmark leftHeel = pose.getPoseLandmark(PoseLandmark.LEFT_HEEL);
PoseLandmark rightHeel = pose.getPoseLandmark(PoseLandmark.RIGHT_HEEL);
PoseLandmark leftFootIndex = pose.getPoseLandmark(PoseLandmark.LEFT_FOOT_INDEX);
PoseLandmark rightFootIndex = pose.getPoseLandmark(PoseLandmark.RIGHT_FOOT_INDEX);
PoseLandmark nose = pose.getPoseLandmark(PoseLandmark.NOSE);
PoseLandmark leftEyeInner = pose.getPoseLandmark(PoseLandmark.LEFT_EYE_INNER);
PoseLandmark leftEye = pose.getPoseLandmark(PoseLandmark.LEFT_EYE);
PoseLandmark leftEyeOuter = pose.getPoseLandmark(PoseLandmark.LEFT_EYE_OUTER);
PoseLandmark rightEyeInner = pose.getPoseLandmark(PoseLandmark.RIGHT_EYE_INNER);
PoseLandmark rightEye = pose.getPoseLandmark(PoseLandmark.RIGHT_EYE);
PoseLandmark rightEyeOuter = pose.getPoseLandmark(PoseLandmark.RIGHT_EYE_OUTER);
PoseLandmark leftEar = pose.getPoseLandmark(PoseLandmark.LEFT_EAR);
PoseLandmark rightEar = pose.getPoseLandmark(PoseLandmark.RIGHT_EAR);
PoseLandmark leftMouth = pose.getPoseLandmark(PoseLandmark.LEFT_MOUTH);
PoseLandmark rightMouth = pose.getPoseLandmark(PoseLandmark.RIGHT_MOUTH);

טיפים לשיפור הביצועים

איכות התוצאות תלויה באיכות של תמונת הקלט:

כדי ש-ML Kit תזהה במדויק את התנוחה, האדם שמופיע בתמונה צריך להיות מיוצגים באמצעות נתוני פיקסלים מספיקים. כדי להשיג את הביצועים הכי טובים, הנושא להיות לפחות 256x256 פיקסלים.
אם מזהה תנוחה מסוימת באפליקציה בזמן אמת, כדאי גם לבדוק את הממדים הכוללים של תמונות הקלט. אפשר לעבד תמונות קטנות יותר מהר יותר, כדי להפחית את זמן האחזור, לצלם תמונות ברזולוציה נמוכה יותר לעמוד בדרישות הפתרון שהוזכרו למעלה, ולוודא שהנושא עוסק חלק גדול ככל האפשר מהתמונה.
גם מיקוד תמונה לא טוב יכול להשפיע על רמת הדיוק. אם אתם לא מקבלים תוצאות מקובלות, לבקש מהמשתמש לצלם מחדש את התמונה.

אם אתם רוצים להשתמש בזיהוי תנוחה באפליקציה בזמן אמת, צריך לפעול לפי ההנחיות הבאות כדי להשיג את קצב הפריימים הטוב ביותר:

יש להשתמש ב-SDK לזיהוי תנוחת הבסיס וב-STREAM_MODE.
כדאי לצלם תמונות ברזולוציה נמוכה יותר. עם זאת, חשוב לזכור גם את הדרישות בנוגע למידות תמונה ב-API הזה.
אם משתמשים Camera או camera2 API, הפעלות של הגלאי באמצעות ויסות נתונים (throttle). אם מדובר בסרטון חדש הופכת לזמינה כשהגלאי פועל, משחררים את הפריים. לצפייה VisionProcessorBase באפליקציה לדוגמה של המדריך למתחילים.
אם אתם משתמשים ב-API של CameraX, יש לוודא שאסטרטגיית הלחץ החוזר מוגדרת לערך ברירת המחדל שלה ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST כך אפשר להבטיח שרק תמונה אחת תוצג לניתוח בכל פעם. אם עוד תמונות שנוצרות כשהכלי לניתוח נתונים עמוס, הוא יוסר באופן אוטומטי ולא ימתין בתור משלוח. לאחר שהתמונה שמנתחת נסגרת על ידי קריאה ImageProxy.close(), התמונה האחרונה הבאה תישלח.
אם משתמשים בפלט של הגלאי כדי להציג גרפיקה בשכבת-על מקבלים קודם את התוצאה מ-ML Kit ואז מעבדים את התמונה וליצור שכבת-על בשלב אחד. הוא מוצג לפני השטח של המסך פעם אחת בלבד לכל מסגרת קלט. לצפייה CameraSourcePreview וגם GraphicOverlay, באפליקציה לדוגמה של המדריך למתחילים.
אם משתמשים ב- Camera2 API, מצלמים תמונות ב פורמט של ImageFormat.YUV_420_888. אם משתמשים בגרסה הישנה של ה-API של המצלמה, מצלמים תמונות ב פורמט של ImageFormat.NV21.

השלבים הבאים

כדי ללמוד איך להשתמש בציוני דרך שמבוססים על ציוני דרך שמבוססים על תנוחות, כדאי לעיין בטיפים לסיווג פוזה.

זיהוי תנוחות באמצעות ML Kit ב-Android

רוצה לנסות?

לפני שמתחילים

1. יצירת מכונה של PoseDetector

PoseDetector אפשרויות

מצב זיהוי

הגדרת החומרה

Kotlin

Java

Kotlin

Java

2. הכנת תמונת הקלט

באמצעות media.Image

Kotlin

Java

Kotlin

Java

Kotlin

Java

שימוש ב-URI של קובץ

Kotlin

Java

שימוש ב-ByteBuffer או ב-ByteArray

Kotlin

Java

באמצעות Bitmap

Kotlin

Java

3. עיבוד התמונה

Kotlin

Java

4. קבלת מידע על התנוחה שזוהתה

Kotlin

Java

טיפים לשיפור הביצועים

השלבים הבאים

1. יצירת מכונה של `PoseDetector`

`PoseDetector` אפשרויות

באמצעות `media.Image`

שימוש ב-`ByteBuffer` או ב-`ByteArray`

באמצעות `Bitmap`