KLT Bounding Box Tracker

Overview

The Kanade-Lucas-Tomasi (KLT) Tracker algorithm estimates the 2D translation and scale changes of an image template between original template coordinates and a given reference image using the Inverse Compositional algorithm. For more information, see [1].

Inputs are an array of template bounding boxes, a translation and scale changes predictions array and a reference image. Additionally, a template image input is used to update template patches (see details below).

Outputs are the translation and scale changes estimations array from the input bounding box coordinates to the reference image coordinates and the template bounding box coordinates array in the reference image.

Frame #1	Frame #10

Implementation

Each template bounding box defines a template image patch stored internally with the function descriptor. These template patches are tracked in reference images based on predicted translation and scale changes. An estimation translation and scale changes from the original bounding box coordinates to reference image coordinates are computed. Each such estimation includes a tracking validity flag (tracking success or failure) and whether a template update is required, based on user-defined threshold parameters.

Usage

Note

Due to PVA restrictions, the created VPI arrays' capacity must be 128.

1. Initialization phase
   1. Include the header that defines the needed functions and structures.

      #include <vpi/algo/KLTBoundingBoxTracker.h>

   2. Define the stream on which the algorithm will be executed, the input frames and input bounding boxes. Refer to VPIBoundingBox documentation for instructions on how to properly fill each bounding box given an axis-aligned bounding box. and the reference frames, the input boxes and input predictions.

          VPIStream stream = /* ... */;
       
          size_t frame_count = /*... */;
          VPIImage *frames = /* ... */;
       
          size_t bbox_count = /* ... */;
          VPIBoundingBox *bboxes = /* ... */;

   3. Create the bounding box array with tracking information. For new bounding boxes, trackingStatus must be 0, indicating that bounding box tracking is valid. TemplateStatus must be 1, indicating that the template corresponding to this bounding box must be updated.

          VPIKLTTrackedBoundingBox tracked_bboxes[128];
       
          for(size_t b=0; b<bbox_count; ++b)
          {
              tracked_bboxes[b].bbox = bboxes[b];
              tracked_bboxes[b].trackingStatus = 0; // valid tracking
              tracked_bboxes[b].templateStatus = 1; // must update
          }

   4. Wrap the tracked bounding box into a VPIArray. The array type must be VPI_ARRAY_TYPE_KLT_TRACKED_BOUNDING_BOX

          VPIArrayData data_bboxes;
          memset(&data_bboxes, 0, sizeof(data_bboxes));
          data_bboxes.type = VPI_ARRAY_TYPE_KLT_TRACKED_BOUNDING_BOX;
          data_bboxes.capacity = 128;
          data_bboxes.size = bbox_count;
          data_bboxes.data = tracked_bboxes;
       
          VPIArray inputBoxList;
          vpiArrayWrapHostMem(&data_bboxes, 0, &inputBoxList);

   5. Create the bounding box transformation prediction array, initially filled with identity transforms, since the template matches exactly the bounding box contents in the template image.

          VPIHomographyTransform2D preds[128];
          for(size_t i=0; i<bbox_count; ++i)
          {
              VPIHomographyTransform2D *xform = preds + i;
       
              // Identity transform.
              memset(xform, 0, sizeof(*xform));
              xform->mat3[0][0] = 1;
              xform->mat3[1][1] = 1;
              xform->mat3[2][2] = 1;
          }

   6. Wrap this array into a VPIArray. The array type must be VPI_ARRAY_TYPE_HOMOGRAPHY_TRANSFORM_2D.

          VPIArrayData data_preds;
          memset(&data_preds, 0, sizeof(data_preds));
          data_preds.type = VPI_ARRAY_TYPE_HOMOGRAPHY_TRANSFORM_2D;
          data_preds.capacity = 128;
          data_preds.size = bbox_count;
          data_preds.data = preds;
       
          VPIArray inputPredList;
          vpiArrayWrapHostMem(&data_preds, 0, &inputPredList);

   7. Create the payload that will contain all temporary buffers needed for processing. It is assumed that all input frames have the same size, so the first frame dimensions and type are used to create the payload.

          VPIImageType imgType;
          vpiImageGetType(frames[0], &imgType);
       
          uint32_t width, height;
          vpiImageGetSize(frames[0], &width, &height);
       
          VPIPayload klt;
          vpiCreateKLTBoundingBoxTracker(stream, width, height, imgType, &klt);

   8. Define the configuration parameters that guide the KLT tracking process.

          VPIKLTBoundingBoxTrackerParams params = {};
          params.numberOfIterationsScaling      = 20;
          params.nccThresholdUpdate             = 0.8f;
          params.nccThresholdKill               = 0.6f;
          params.nccThresholdStop               = 1.0f;
          params.maxScaleChange                 = 0.2f;
          params.maxTranslationChange           = 1.5f;
          params.trackingType                   = VPI_KLT_INVERSE_COMPOSITIONAL;

   9. Create the output tracked bounding box array. It will contain the estimated current frame's bounding box based on previous frame and the template information gathered so far. It also contains the bounding box current tracking status.

          VPIArray outputBoxList;
          vpiArrayCreate(128, VPI_ARRAY_TYPE_KLT_TRACKED_BOUNDING_BOX, 0, &outputBoxList);

   10. Create the output estimated transforms. It will contain the transform that makes the bounding box template match the corresponding bounding box on the current (reference) frame.
2. Processing phase
   1. Start of the processing loop from the second frame. The previous frame is where the algorithm fetches the tracked templates from, the current frame is the where these templates are matched against.

          for(int idframe = 1; idframe<frame_count; ++idframe)
          {
              VPIImage imgTemplate = frames[idframe-1];
              VPIImage imgReference = frames[idframe];

   2. Submit the algorithm. The first time it's run, it will go through all input bounding boxes, crop them from the template frame and store them in the payload. Subsequent runs will either repeat the cropping and storing process for new bounding boxes added (doesn't happen in this example, but happens in the sample application), or perform the template matching on the reference frame.

              VPI_CHECK_STATUS(vpiSubmitKLTBoundingBoxTracker(klt, imgTemplate, inputBoxList, inputPredList,
                                                              imgReference, outputBoxList, outputEstimList, &params));

   3. Wait until the processing is done

              vpiStreamSync(stream);

   4. Lock the output arrays to retrieve the updated bounding boxes and the estimated transforms.

              VPIArrayData updatedBBoxData;
              vpiArrayLock(outputBoxList, VPI_LOCK_READ, &updatedBBoxData);
       
              VPIArrayData estimData;
              vpiArrayLock(outputEstimList, VPI_LOCK_READ, &estimData);
       
              VPIKLTTrackedBoundingBox *updated_bbox = (VPIKLTTrackedBoundingBox *)updatedBBoxData.data;
              VPIHomographyTransform2D *estim = (VPIHomographyTransform2D *)estimData.data;

   5. Loop through all bounding boxes.

              for(size_t b=0; b<bbox_count; ++b)
              {

   6. Update bounding box statuses. If tracking was lost (trackingStatus==1), the input bounding box must also be marked as such so that next KLT iterations ignore it. If template needs update (templateStatus==1), next iteration will do the updating, or else it'll perform the template matching.

                  tracked_bboxes[b].trackingStatus = updated_bbox[b].trackingStatus;
                  tracked_bboxes[b].templateStatus = updated_bbox[b].templateStatus;

   7. Skip bounding boxes that aren't being tracked.

                  if(updated_bbox[b].trackingStatus)
                  {
                      continue;
                  }

   8. If template for this bounding box must be updated in next KLT iteration, user must re-define the bounding box. There are several ways to do it. One can use a feature detector such as Harris keypoint detector to help fetch a brand-new bounding box, use updated_bbox[b] and either refine it through other means to avoid accumulating tracking errors, or simply use it as-is, which is less robust approach, but still yields decent results. This examples chooses this last, simpler approach.

                  if(updated_bbox[b].templateStatus)
                  {
                      tracked_bboxes[b] = updated_bbox[b];

   9. Also reset the corresponding input predicted transforms, setting it to identity, as it's now assumed that the input bounding box matches exactly the object being tracked.

                      memset(&preds[b], 0, sizeof(preds[b]));
                      preds[b].mat3[0][0] = 1;
                      preds[b].mat3[1][1] = 1;
                      preds[b].mat3[2][2] = 1;
                  }

   10. If the template doesn't need to be updated, set the input predicted transform to the one estimated by this KLT iteration.

                   else
                   {
                       preds[b] = estim[b];
                   }
               }

   11. Once all bounding boxes were updated, unlock the output arrays as they aren't needed by this iteration anymore.

               vpiArrayUnlock(outputBoxList);
               vpiArrayUnlock(outputEstimList);

   12. Since the input arrays content were modified externally, invalidate them so that VPI discard the content of any copies it might have made internally.

               vpiArrayInvalidate(inputBoxList);
               vpiArrayInvalidate(inputPredList);
           }

3. Cleanup phase
   1. Free all VPI resources at once by destroying the context.

          vpiContextDestroy(ctx);

Limitations and Constraints

Constraints for specific backends superceed the ones specified for all backends.

All Backends

• reference and template frames must have same dimensions and type, and they must match what was defined during payload construction.
• Accepted input types:
  • VPI_IMAGE_TYPE_Y8
  • VPI_IMAGE_TYPE_Y8I
  • VPI_IMAGE_TYPE_Y16
  • VPI_IMAGE_TYPE_Y16I
• Input and output bounding box arrays must have type VPI_ARRAY_TYPE_KLT_TRACKED_BOUNDING_BOX.
• Input predictions and output estimations must have type VPI_ARRAY_TYPE_HOMOGRAPHY_TRANSFORM_2D.
• Accepted tracking types:
  • VPI_KLT_INVERSE_COMPOSITIONAL
• Constraint: 0 < nccThresholdUpdate <= 1.
• Constraint: 0 < nccThresholdKill <= 1.
• Constraint: 0 < nccThresholdStop <= 1.
• Constraint: nccThresholdKill > nccThresholdUpdate > nccThresholdStop.
• Constraint: maxScaleChange >= 0.
• Constraint: maxTranslationChange >= 0.
• Bounding box sizes must be between 4x4 and 64x64

PVA

• Input images' dimensions must be between 65x65 and 3264x2448.
• Maximum scale change is 0.2.
• Minimum input and output array capacities is 128.
• Maximum number of bounding boxes is 64.
• Maximum numberOfIterationsScaling is 20.
• Only accepts VPI_IMAGE_TYPE_Y16 inputs whose pixel values' range is between 0 and 255.

References

1. Simon Baker, Iain Matthew, "Lucas-Kanade 20 Years On: A Unified Framework".
   International Journal of Computer Vision, February 2004, Volume 56, issue 3, pp 221-255.