זיהוי ועקוב אחר אובייקטים עם ערכת ML באנדרואיד

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

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

לפני שאתה מתחיל

  1. אם עדיין לא עשית זאת, הוסף את Firebase לפרויקט Android שלך .
  2. הוסף את התלות של ספריות אנדרואיד של ML Kit לקובץ 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'
      implementation 'com.google.firebase:firebase-ml-vision-object-detection-model:19.0.6'
    }
    

1. הגדר את גלאי האובייקטים

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

  1. הגדר את גלאי האובייקטים למקרה השימוש שלך עם אובייקט FirebaseVisionObjectDetectorOptions . אתה יכול לשנות את ההגדרות הבאות:

    הגדרות גלאי אובייקטים
    מצב זיהוי STREAM_MODE (ברירת מחדל) | SINGLE_IMAGE_MODE

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

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

    זיהוי ומעקב אחר אובייקטים מרובים false (ברירת מחדל) | true

    האם לזהות ולעקוב אחר עד חמישה אובייקטים או רק האובייקט הבולט ביותר (ברירת מחדל).

    סיווג חפצים false (ברירת מחדל) | true

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

    ממשק ה-API לזיהוי ומעקב אובייקטים מותאם לשני מקרי שימוש הליבה האלה:

    • זיהוי ומעקב בזמן אמת אחר האובייקט הבולט ביותר בעינית המצלמה
    • זיהוי של מספר עצמים מתוך תמונה סטטית

    כדי להגדיר את ה-API עבור מקרי שימוש אלה:

    Java

    // Live detection and tracking
    FirebaseVisionObjectDetectorOptions options =
            new FirebaseVisionObjectDetectorOptions.Builder()
                    .setDetectorMode(FirebaseVisionObjectDetectorOptions.STREAM_MODE)
                    .enableClassification()  // Optional
                    .build();
    
    // Multiple object detection in static images
    FirebaseVisionObjectDetectorOptions options =
            new FirebaseVisionObjectDetectorOptions.Builder()
                    .setDetectorMode(FirebaseVisionObjectDetectorOptions.SINGLE_IMAGE_MODE)
                    .enableMultipleObjects()
                    .enableClassification()  // Optional
                    .build();
    

    Kotlin+KTX

    // Live detection and tracking
    val options = FirebaseVisionObjectDetectorOptions.Builder()
            .setDetectorMode(FirebaseVisionObjectDetectorOptions.STREAM_MODE)
            .enableClassification()  // Optional
            .build()
    
    // Multiple object detection in static images
    val options = FirebaseVisionObjectDetectorOptions.Builder()
            .setDetectorMode(FirebaseVisionObjectDetectorOptions.SINGLE_IMAGE_MODE)
            .enableMultipleObjects()
            .enableClassification()  // Optional
            .build()
    
  2. קבל מופע של FirebaseVisionObjectDetector :

    Java

    FirebaseVisionObjectDetector objectDetector =
            FirebaseVision.getInstance().getOnDeviceObjectDetector();
    
    // Or, to change the default settings:
    FirebaseVisionObjectDetector objectDetector =
            FirebaseVision.getInstance().getOnDeviceObjectDetector(options);
    

    Kotlin+KTX

    val objectDetector = FirebaseVision.getInstance().getOnDeviceObjectDetector()
    
    // Or, to change the default settings:
    val objectDetector = FirebaseVision.getInstance().getOnDeviceObjectDetector(options)
    

2. הפעל את גלאי האובייקטים

כדי לזהות ולעקוב אחר אובייקטים, העבר תמונות לשיטת processImage() של מופע FirebaseVisionObjectDetector .

עבור כל פריים של סרטון או תמונה ברצף, בצע את הפעולות הבאות:

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

      Kotlin+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;
      }

      Kotlin+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);

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

      Kotlin+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();

      Kotlin+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);

      Kotlin+KTX

      val image = FirebaseVisionImage.fromByteBuffer(buffer, metadata)
      // Or: val image = FirebaseVisionImage.fromByteArray(byteArray, metadata)
    • כדי ליצור אובייקט FirebaseVisionImage מאובייקט Bitmap :

      Java

      FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap);

      Kotlin+KTX

      val image = FirebaseVisionImage.fromBitmap(bitmap)
      התמונה המיוצגת על ידי אובייקט Bitmap חייבת להיות זקופה, ללא צורך בסיבוב נוסף.
  2. העבירו את התמונה לשיטת processImage() :

    Java

    objectDetector.processImage(image)
            .addOnSuccessListener(
                    new OnSuccessListener<List<FirebaseVisionObject>>() {
                        @Override
                        public void onSuccess(List<FirebaseVisionObject> detectedObjects) {
                            // Task completed successfully
                            // ...
                        }
                    })
            .addOnFailureListener(
                    new OnFailureListener() {
                        @Override
                        public void onFailure(@NonNull Exception e) {
                            // Task failed with an exception
                            // ...
                        }
                    });
    

    Kotlin+KTX

    objectDetector.processImage(image)
            .addOnSuccessListener { detectedObjects ->
                // Task completed successfully
                // ...
            }
            .addOnFailureListener { e ->
                // Task failed with an exception
                // ...
            }
    
  3. אם הקריאה ל- processImage() מצליחה, רשימה של s FirebaseVisionObject מועברת למאזין ההצלחה.

    כל FirebaseVisionObject מכיל את המאפיינים הבאים:

    תיבה תוחמת A Rect המציין את מיקום האובייקט בתמונה.
    מזהה מעקב מספר שלם המזהה את האובייקט על פני תמונות. ריק ב-SINGLE_IMAGE_MODE.
    קטגוריה הקטגוריה הגסה של האובייקט. אם לגלאי האובייקטים אין סיווג מופעל, זה תמיד FirebaseVisionObject.CATEGORY_UNKNOWN .
    אֵמוּן ערך הביטחון של סיווג האובייקט. אם לגלאי האובייקטים אין סיווג מופעל, או שהאובייקט מסווג כלא ידוע, זהו null .

    Java

    // The list of detected objects contains one item if multiple object detection wasn't enabled.
    for (FirebaseVisionObject obj : detectedObjects) {
        Integer id = obj.getTrackingId();
        Rect bounds = obj.getBoundingBox();
    
        // If classification was enabled:
        int category = obj.getClassificationCategory();
        Float confidence = obj.getClassificationConfidence();
    }
    

    Kotlin+KTX

    // The list of detected objects contains one item if multiple object detection wasn't enabled.
    for (obj in detectedObjects) {
        val id = obj.trackingId       // A number that identifies the object across images
        val bounds = obj.boundingBox  // The object's position in the image
    
        // If classification was enabled:
        val category = obj.classificationCategory
        val confidence = obj.classificationConfidence
    }
    

שיפור השימושיות והביצועים

לחוויית המשתמש הטובה ביותר, פעל לפי ההנחיות הבאות באפליקציה שלך:

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

כמו כן, בדוק את [ML Kit Material Design showcase app][showcase-link]{: .external } ואת אוסף התכונות של Material Design Patterns for Machine Learning .

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

  • אל תשתמש בזיהוי אובייקטים מרובים במצב סטרימינג, מכיוון שרוב המכשירים לא יוכלו לייצר קצבי פריימים נאותים.

  • השבת את הסיווג אם אינך זקוק לו.

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

    אם אתה משתמש ב-Camera API הישן יותר, צלם תמונות בפורמט ImageFormat.NV21 .