TemplateTracker.h

Go to the documentation of this file.

// This code contains NVIDIA Confidential Information and is disclosed
// under the Mutual Non-Disclosure Agreement.
//
// Notice
// ALL NVIDIA DESIGN SPECIFICATIONS AND CODE ("MATERIALS") ARE PROVIDED "AS IS" NVIDIA MAKES
// NO REPRESENTATIONS, WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
// THE MATERIALS, AND EXPRESSLY DISCLAIMS ANY IMPLIED WARRANTIES OF NONINFRINGEMENT,
// MERCHANTABILITY, OR FITNESS FOR A PARTICULAR PURPOSE.
//
// NVIDIA Corporation assumes no responsibility for the consequences of use of such
// information or for any infringement of patents or other rights of third parties that may
// result from its use. No license is granted by implication or otherwise under any patent
// or patent rights of NVIDIA Corporation. No third party distribution is allowed unless
// expressly authorized by NVIDIA.  Details are subject to change without notice.
// This code supersedes and replaces all information previously supplied.
// NVIDIA Corporation products are not authorized for use as critical
// components in life support devices or systems without express written approval of
// NVIDIA Corporation.
//
// Copyright (c) 2019 NVIDIA Corporation. All rights reserved.
//
// NVIDIA Corporation and its licensors retain all intellectual property and proprietary
// rights in and to this software and related documentation and any modifications thereto.
// Any use, reproduction, disclosure or distribution of this software and related
// documentation without an express license agreement from NVIDIA Corporation is
// strictly prohibited.
//

#ifndef DW_IMAGEPROCESSING_TEMPLATE_TRACKER_H_
#define DW_IMAGEPROCESSING_TEMPLATE_TRACKER_H_

// C api
#include <dw/core/Config.h>
#include <dw/core/context/Context.h>
#include <dw/core/base/Types.h>
#include <dw/image/Image.h>
#include <dw/imageprocessing/features/FeatureList.h>
#include <dw/imageprocessing/filtering/Pyramid.h>

#ifdef __cplusplus
extern "C" {
#endif

#define DW_MAX_TEMPLATE2D_SIZE 128

typedef struct dwTemplateTrackerObject* dwTemplateTrackerHandle_t;

typedef struct dwTemplateTrackerObject const* dwConstTemplateTrackerHandle_t;

typedef enum dwTemplateTrackerAlgorithm {
    DW_TEMPLATE_TRACKER_ALGORITHM_IA = 0, 
    DW_TEMPLATE_TRACKER_ALGORITHM_IC      
} dwTemplateTrackerAlgorithm;

typedef struct dwTemplateTrackerParameters
{
    dwTemplateTrackerAlgorithm algorithm;

    uint32_t maxTemplateCount;

    uint32_t maxPyramidLevel;

    uint32_t imageWidth;

    uint32_t imageHeight;

    uint32_t numIterationsFine;

    uint32_t numIterationsCoarse;

    float32_t thresholdUpdate;

    float32_t thresholdKill;

    float32_t thresholdStop;

    float32_t maxScaleChange;

    float32_t validWidth;

    float32_t validHeight;

    dwProcessorType processorType;
} dwTemplateTrackerParameters;

typedef struct dwTemplateArray
{
    dwRectf* bboxes;             
    dwFeature2DStatus* statuses; 
    uint32_t* ids;               
    uint32_t* ages;              
    float32_t* scaleFactors;     
    uint32_t* newToOldMap;       
    uint32_t* templateCount; 
    uint32_t maxTemplates;   
    uint8_t* data; 
    size_t bytes;  
    dwMemoryType memoryType; 
} dwTemplateArray;


DW_API_PUBLIC
dwStatus dwTemplateArray_create(dwTemplateArray* templateArray,
                                const uint32_t maxTemplateCount,
                                const dwMemoryType memoryType,
                                dwContextHandle_t context);

DW_API_PUBLIC
dwStatus dwTemplateArray_destroy(dwTemplateArray templateArray);

DW_API_PUBLIC
dwStatus dwTemplateArray_reset(dwTemplateArray* templateArray);

DW_API_PUBLIC
dwStatus dwTemplateArray_copyAsync(dwTemplateArray* dstTemplateArray,
                                   const dwTemplateArray* srcTemplateArray,
                                   cudaStream_t stream);
DW_API_PUBLIC
dwStatus dwTemplateTracker_initDefaultParams(dwTemplateTrackerParameters* params);

DW_API_PUBLIC
dwStatus dwTemplateTracker_initialize(dwTemplateTrackerHandle_t* obj,
                                      const dwTemplateTrackerParameters* params,
                                      cudaStream_t stream, dwContextHandle_t context);

DW_API_PUBLIC
dwStatus dwTemplateTracker_reset(dwTemplateTrackerHandle_t obj);

DW_API_PUBLIC
dwStatus dwTemplateTracker_release(dwTemplateTrackerHandle_t obj);

DW_API_PUBLIC
dwStatus dwTemplateTracker_setCUDAStream(cudaStream_t cudaStream,
                                         dwTemplateTrackerHandle_t obj);

DW_API_PUBLIC
dwStatus dwTemplateTracker_getCUDAStream(cudaStream_t* cudaStream,
                                         dwTemplateTrackerHandle_t obj);

DW_API_PUBLIC
dwStatus dwTemplateTracker_trackImage(dwTemplateArray* templateArray,
                                      const dwImageCUDA* currentImage,
                                      const dwImageCUDA* previousImage,
                                      dwTemplateTrackerHandle_t obj);

DW_API_PUBLIC
dwStatus dwTemplateTracker_trackPyramid(dwTemplateArray* templateArray,
                                        const dwPyramidImage* currentPyramid,
                                        const dwPyramidImage* previousPyramid,
                                        dwTemplateTrackerHandle_t obj);

#ifdef __cplusplus
}
#endif

#endif // DW_IMAGEPROCESSING_TEMPLATE_TRACKER_H_