זיהוי ועקוב אחר אובייקטים בעזרת ערכת ML ב- Android

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

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

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

  1. אם לא עשית זאת עדיין, להוסיף Firebase לפרויקט Android שלך .
  2. מוסיפים את התלות עבור ספריות אנדרואיד קיט ML למודול שלך (ברמת האפליקציה) קובץ 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 למקרי שימוש אלה:

    ג'אווה

    // 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 :

    ג'אווה

    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. הפעל את גלאי האובייקטים

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

עבור כל מסגרת וידאו או תמונה ברצף, בצע את הפעולות הבאות:

  1. צור FirebaseVisionImage אובייקט מתוך התמונה שלך.

    • כדי ליצור FirebaseVisionImage האובייקט מנקודת media.Image אובייקט, כגון בעת לכידת תמונה מתוך המצלמה של המכשיר, להעביר את media.Image האובייקט ואת הסיבוב של התמונה FirebaseVisionImage.fromMediaImage() .

      אם אתה משתמש CameraX הספרייה, OnImageCapturedListener ו ImageAnalysis.Analyzer הכיתות לחשב את ערך הסיבוב בשבילך, כך שאתה רק צריך להמיר את הסיבוב לאחד של ML קיט ROTATION_ קבוע לפני פניית FirebaseVisionImage.fromMediaImage() :

      ג'אווה

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

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

      ג'אווה

      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() :

      ג'אווה

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

      Kotlin+KTX

      val image = FirebaseVisionImage.fromMediaImage(mediaImage, rotation)
    • כדי ליצור FirebaseVisionImage אובייקט מקובץ URI, להעביר את הקשר אפליקצית קובץ אורי FirebaseVisionImage.fromFilePath() . תכונה זו שימושית כאשר אתה משתמש ACTION_GET_CONTENT כוונה מהמשתמש לבחור תמונה מאפליקציית הגלריה שלהם.

      ג'אווה

      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 אובייקט המכיל את פורמט גובה, רוחב, צבע קידוד של תמונה, וסיבוב:

      ג'אווה

      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 אובייקט:

      ג'אווה

      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 האובייקט:

      ג'אווה

      FirebaseVisionImage image = FirebaseVisionImage.fromBitmap(bitmap);

      Kotlin+KTX

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

    ג'אווה

    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() מצליחה, רשימת FirebaseVisionObject הים הועבר מאזין ההצלחה.

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

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

    ג'אווה

    // 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 קיט חומר עיצוב חלון ראווה אפליקציות] [ראווה-link] {: .external} ואת עיצוב חומר דפוסי עבור תכונות המכונה המופעל למידה אוסף.

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

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

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

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

    אם אתה משתמש ב- API המצלמה המבוגרת, ללכוד תמונות ב ImageFormat.NV21 פורמט.