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

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

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

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

אני רוצה לנסות

אפשר לנסות את האפליקציה לדוגמה כדי לראות דוגמה לשימוש ב-API הזה.

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

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

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

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

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

1. יצירת מופע של `PoseDetector`

`PoseDetector` אפשרויות

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

מצב זיהוי

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

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

הגדרת החומרה

ב-PoseDetector יש תמיכה במספר הגדרות חומרה כדי לבצע אופטימיזציה לביצועים:

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

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

ערכת ML Kit תתחשב בזמינות, ביציבות, בנכונות ובזמן האחזור של כל הגדרה, ותבחר את ההגדרה הטובה ביותר מבין ההגדרות המועדפות. אם אף אחת מההגדרות המועדפות לא רלוונטית, ההגדרה CPU תשמש באופן אוטומטי כחלופה. ערכת ML Kit תבצע את הבדיקות האלה ואת ההכנה הנלווה ללא חסימה לפני שתפעיל האצה, ולכן סביר להניח שבפעם הראשונה שהמשתמש יפעיל את הגלאי, ייעשה שימוש ב-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 המוכן לשיטה 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.

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

אם לא זוהה אדם במסגרת, האובייקט 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 הזה.
אם משתמשים ב-API של Camera או camera2, אפשר לווסת קריאות לגלאי. אם מתפנה פריים חדש של וידאו בזמן שהמזהה פועל, צריך לשחרר אותו. כדי לראות דוגמה, אפשר לעיין בכיתה VisionProcessorBase באפליקציה לדוגמה של המדריך למתחילים.
אם אתם משתמשים ב-CameraX API, חשוב לוודא ששיטת הלחץ הזמני מוגדרת לערך ברירת המחדל שלה ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST. כך אפשר להבטיח שרק תמונה אחת תוצג לניתוח בכל פעם. אם נוצרות תמונות נוספות כשהניתוח עמוס, הן יושמטו באופן אוטומטי ולא ימתינו בתור למשלוח. לאחר סגירת התמונה שמנותחת על ידי קריאה ל-ImageProxy.close(), תוצג התמונה העדכנית ביותר הבאה.
אם משתמשים בפלט של הגלאי כדי להציג שכבות גרפיקה על תמונת הקלט, קודם מקבלים את התוצאה מ-ML Kit ואז מבצעים רינדור של התמונה ושכבת-העל בשלב אחד. הפעולה הזו מעבדת את הנתונים על פני השטח של התצוגה פעם אחת בלבד לכל מסגרת קלט. כדי לראות דוגמה, אפשר לעיין בכיתות CameraSourcePreview ו- GraphicOverlay באפליקציה לדוגמה של המדריך למתחילים.
אם משתמשים ב- Camera2 API, צריך לצלם תמונות בפורמט ImageFormat.YUV_420_888. אם משתמשים בגרסה הישנה של Camera 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`