FeatureList.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2018-2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: LicenseRef-NvidiaProprietary
 *
 * NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
 * property and proprietary rights in and to this material, related
 * documentation and any modifications thereto. Any use, reproduction,
 * disclosure or distribution of this material and related documentation
 * without an express license agreement from NVIDIA CORPORATION or
 * its affiliates is strictly prohibited.
 */
 
#ifndef DW_IMAGEPROCESSING_FEATURES_FEATURELIST_H_
#define DW_IMAGEPROCESSING_FEATURES_FEATURELIST_H_
 
#include <dw/core/base/Config.h>
#include <dw/core/base/Exports.h>
#include <dw/core/context/Context.h>
#include <dw/core/base/Types.h>
#include <dw/image/Image.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
typedef enum dwFeature2DStatus {
    DW_FEATURE2D_STATUS_INVALID = 0,
 
    DW_FEATURE2D_STATUS_DETECTED,
 
    DW_FEATURE2D_STATUS_TRACKED,
 
    DW_FEATURE2D_STATUS_TYPE_COUNT
} dwFeature2DStatus;
 
typedef struct dwFeatureHistoryArray
{
    dwFeature2DStatus* statuses; 
    uint32_t* ages;              
    float32_t* scales;           
    uint32_t* ids;               
    uint32_t* newToOldMap;       
    dwVector2f* locationHistory; 
    uint32_t* featureCount;      
    uint32_t* validTrackedCount; 
    uint32_t currentTimeIdx; 
    uint32_t maxHistory;     
    uint32_t maxFeatures;    
    uint32_t sensorId;       
    dwTime_t timestamp;      
    DW_DEPRECATED("use hostPointer or cudaDevicePointer instead")
    uint8_t* data; 
    void* hostPointer;   
    void* devicePointer; 
    size_t bytes; 
    dwMemoryType memoryType; 
} dwFeatureHistoryArray;
 
typedef struct dwFeatureArray
{
    dwFeature2DStatus* statuses; 
    uint32_t* ages;              
    float32_t* scales;           
    uint32_t* ids;               
    uint32_t* newToOldMap;       
    dwVector2f* locations;       
    uint32_t* featureCount;      
    uint32_t* validTrackedCount; 
    void* hostPointer;   
    void* devicePointer; 
    uint32_t timeIdx;     
    uint32_t maxFeatures; 
    uint32_t sensorId;    
    dwMemoryType memoryType; 
} dwFeatureArray;
 
// dwFeature2DList
DW_API_PUBLIC
DW_DEPRECATED("WARNING: will be removed in the next major release, use dwFeatureArray_createNew instead")
dwStatus dwFeatureArray_create(dwFeatureArray* featureArray,
                               const uint32_t maxFeatureCount,
                               const dwMemoryType memoryType,
                               dwContextHandle_t context);
 
DW_API_PUBLIC
dwStatus dwFeatureArray_createNew(dwFeatureArray* featureArray,
                                  const uint32_t maxFeatureCount,
                                  const dwMemoryType memoryType,
                                  cudaStream_t stream,
                                  dwContextHandle_t context);
 
DW_API_PUBLIC
dwStatus dwFeatureArray_destroy(dwFeatureArray featureArray);
 
DW_API_PUBLIC
dwStatus dwFeatureArray_reset(dwFeatureArray* featureArray,
                              cudaStream_t stream);
 
DW_API_PUBLIC
dwStatus dwFeatureArray_copyAsync(dwFeatureArray* dstFeatures,
                                  const dwFeatureArray* srcFeatures,
                                  cudaStream_t stream);
 
DW_API_PUBLIC
DW_DEPRECATED("WARNING: will be removed in the next major release, use dwFeatureHistoryArray_createNew instead")
dwStatus dwFeatureHistoryArray_create(dwFeatureHistoryArray* featureHistoryArray,
                                      const uint32_t maxFeatureCount,
                                      const uint32_t maxHistoryCapacity,
                                      const dwMemoryType memoryType,
                                      dwContextHandle_t context);
 
DW_API_PUBLIC
dwStatus dwFeatureHistoryArray_createNew(dwFeatureHistoryArray* featureHistoryArray,
                                         const uint32_t maxFeatureCount,
                                         const uint32_t maxHistoryCapacity,
                                         const dwMemoryType memoryType,
                                         cudaStream_t stream,
                                         dwContextHandle_t context);
 
DW_API_PUBLIC
dwStatus dwFeatureHistoryArray_destroy(dwFeatureHistoryArray featureHistoryArray);
 
DW_API_PUBLIC
dwStatus dwFeatureHistoryArray_reset(dwFeatureHistoryArray* featureHistoryArray,
                                     cudaStream_t stream);
 
DW_API_PUBLIC
dwStatus dwFeatureHistoryArray_getCurrent(dwFeatureArray* featureArray,
                                          dwFeatureHistoryArray const* featureHistoryArray);
 
DW_API_PUBLIC
dwStatus dwFeatureHistoryArray_getPrevious(dwFeatureArray* featureArray,
                                           dwFeatureHistoryArray const* featureHistoryArray);
 
DW_API_PUBLIC
dwStatus dwFeatureHistoryArray_get(dwFeatureArray* featureArray,
                                   const uint32_t historyIdx,
                                   dwFeatureHistoryArray const* featureHistoryArray);
 
DW_API_PUBLIC
dwStatus dwFeatureHistoryArray_copyAsync(dwFeatureHistoryArray* dstFeatureHistory,
                                         const dwFeatureHistoryArray* srcFeatureHistory,
                                         cudaStream_t stream);
DW_API_PUBLIC
dwStatus dwFeature_mergeNewToOldMap(uint32_t* d_newToOldMapC2A,
                                    const uint32_t* d_newToOldMapC2B,
                                    const uint32_t* d_newToOldMapB2A,
                                    const uint32_t* d_newToOldMapCount,
                                    const uint32_t maxFeatureCount,
                                    cudaStream_t stream);
 
#ifdef __cplusplus
}
#endif
 
#endif // DW_IMAGEPROCESSING_FEATURES_FEATURELIST_H_