Minimum/Maximum Location

Overview

The Minimum/Maximum Location algorithm performs a 2D search operation on the input image. The algorithm looks for the minimum and maximum values of the pixels, which results in two sets of pixel locations for the minimum and maximum values. The locations are the \((x,y)\) coordinates of the pixels matching exactly the global minimum or maximum value. This operation is useful to locate peaks on an image, either highest or lowest or both.

This example shows an input image on the left with its corresponding minimum (blue) and maximum (red) locations on the right.

Input	Output

Implementation

The algorithm searches for the minimum and maximum values in the input image. Each pixel matching the minimum value has its location stored in an output array. The same is done for the maximum value in a second output array. Multiple locations of the same value, either minimum or maximum, may be found.

The location in the image is a keypoint with \((x, y)\) coordinates, corresponding to the \((j, i)\) matrix-based coordinates, respectively. The locations are stored in the user-provided output array up to the array capacity, which is defined upon array creation. This is done for both minimum and maximum output arrays. The maximum number of locations returned may be different for each array, as their corresponding capacity might differ. The user may choose not to provide an output array (by passing NULL in the argument) in which case the corresponding locations will not be searched for.

C API functions

For list of limitations, constraints and backends that implements the algorithm, consult reference documentation of the following functions:

Function	Description
vpiCreateMinMaxLoc	Creates payload for vpiSubmitMinMaxLoc.
vpiSubmitMinMaxLoc	Finds minimum and maximum value locations in an image.

Usage

Language: C/C++ Python

1. Import VPI module

   import vpi

2. Run MinMaxLoc search on the input image using the CPU backend. Input is a VPI image.

   with vpi.Backend.CPU:
       min_coords, max_coords = input.minmaxloc(min_capacity=10000, max_capacity=10000)

3. Optionally, retrieve the minimum and maximum values.
   1. Lock the input image and the minimum/maximum output arrays to efficiently access their contents.

      with input.rlock_cpu() as in_data, min_coords.rlock_cpu() as min_data, max_coords.rlock_cpu() as max_data:

   2. Retrieve the coordinates of the first pixels with minimum and maximum values. The (x,y) coordinates are being swapped to (y,x) and converted into a tuple, suitable for 2D numpy array indexing.

          min_loc = tuple(min_data[0].astype(int)[::-1])
          max_loc = tuple(max_data[0].astype(int)[::-1])

   3. Use the first of these coordinates to retrieve the minimum/maximum pixel value.

          min_value = in_data[min_loc]
          max_value = in_data[max_loc]

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

      #include <vpi/algo/MinMaxLoc.h>

   2. Define the input image object.

          VPIImage input = /*...*/;

   3. Create the payload that will contain all temporary buffers needed for processing. Payload creation requires input's dimensions and format.

          VPIImageFormat format;
          vpiImageGetFormat(input, &format);
       
          int width, height;
          vpiImageGetSize(input, &width, &height);
       
          VPIPayload payload;
          vpiCreateMinMaxLoc(VPI_BACKEND_CPU, width, height, format, &payload);

   4. Create the output arrays for coordinates with minimum and maximum values. In this example, their capacity it set to 10,000, which limits the number of locations to be found.

          VPIArray minCoords;
          vpiArrayCreate(10000, VPI_ARRAY_TYPE_KEYPOINT_F32, 0, &minCoords);
       
          VPIArray maxCoords;
          vpiArrayCreate(10000, VPI_ARRAY_TYPE_KEYPOINT_F32, 0, &maxCoords);

   5. Create the stream where the algorithm will be submitted for execution.

          VPIStream stream;
          vpiStreamCreate(0, &stream);

2. Processing phase
   1. Submit the algorithm to the stream, passing the input image and output arrays. In this example, it will be executed by the CPU backend.

          vpiSubmitMinMaxLoc(stream, VPI_BACKEND_CPU, payload, input, minCoords, maxCoords);

   2. Optionally, retrieve the minimum and maximum values.
      1. Synchronize the stream to make sure the operation is completed

             vpiStreamSync(stream);

      2. Lock the input image and the minimum/maximum output arrays.

             VPIImageData inputImageData;
             vpiImageLockData(input, VPI_LOCK_READ, VPI_IMAGE_BUFFER_HOST_PITCH_LINEAR, &inputImageData);
          
             VPIArrayData minCoordsData, maxCoordsData;
             vpiArrayLockData(minCoords, VPI_LOCK_READ, VPI_ARRAY_BUFFER_HOST_AOS, &minCoordsData);
             vpiArrayLockData(maxCoords, VPI_LOCK_READ, VPI_ARRAY_BUFFER_HOST_AOS, &maxCoordsData);

      3. Retrieve the coordinates of the first minimum and maximum found.

             VPIKeypointF32 *min_coords = (VPIKeypointF32 *)minCoordsData.buffer.aos.data;
             VPIKeypointF32 *max_coords = (VPIKeypointF32 *)maxCoordsData.buffer.aos.data;
          
             int min_i = min_coords[0].y;
             int min_j = min_coords[0].x;
          
             int max_i = max_coords[0].y;
             int max_j = max_coords[0].x;

      4. Use these coordinates as a 2D index to the input image contents to retrieve the minimum/maximum pixel value. Here it's assumed that the input image format is VPI_IMAGE_FORMAT_U8. Different indexing must be employed for other formats.

             // Assuming that the input image is grayscale (only one plane).
             assert(inputImageData.buffer.pitch.numPlanes == 1);
          
             void *imgData     = inputImageData.buffer.pitch.planes[0].data;
             int imgPitchBytes = inputImageData.buffer.pitch.planes[0].pitchBytes;
          
             // Assuming that the plane has 8-bit unsigned int type.
             assert(inputImageData.buffer.pitch.planes[0].pixelType == VPI_PIXEL_TYPE_U8);
             typedef unsigned char Pixel;
             typedef unsigned char Byte;
          
             const Pixel *min_row = (const Pixel *)((const Byte *)imgData + min_i * imgPitchBytes);
             const Pixel *max_row = (const Pixel *)((const Byte *)imgData + max_i * imgPitchBytes);
          
             unsigned char min_value = min_row[min_j];
             unsigned char max_value = max_row[max_j];

      5. Since the image and array contents aren't needed anymore, they must be unlocked.

             vpiArrayUnlock(maxCoords);
             vpiArrayUnlock(minCoords);
             vpiImageUnlock(input);

3. Cleanup phase
   1. Free resources held by the stream, the payload and the input image and output arrays.

          vpiStreamDestroy(stream);
          vpiPayloadDestroy(payload);
          vpiImageDestroy(input);
          vpiArrayDestroy(minCoords);
          vpiArrayDestroy(maxCoords);

For more information, see MinMaxLoc in the "C API Reference" section of VPI - Vision Programming Interface.

Performance

For information on how to use the performance table below, see Algorithm Performance Tables.
Before comparing measurements, consult Comparing Algorithm Elapsed Times.
For further information on how performance was benchmarked, see Performance Benchmark.

clear filters Device: Jetson AGX Orin  -  Streams: 1 2 4 8