post_processor_struct.h

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: MIT
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */
 
#ifndef __POST_PROCESS_STRUCT_HPP__
#define __POST_PROCESS_STRUCT_HPP__
 
#include <iostream>
#include <vector>
#include <memory>
#include "gstnvdsinfer.h"
 
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define _PATH_MAX 4096
#define _MAX_STR_LENGTH 1024
 
#define getDimsCHWFromDims(dimsCHW,dims) \
  do { \
    (dimsCHW).c = (dims).d[0]; \
    (dimsCHW).h = (dims).d[1]; \
    (dimsCHW).w = (dims).d[2]; \
  } while (0)
 
#define getDimsHWCFromDims(dimsCHW,dims) \
  do { \
    (dimsCHW).h = (dims).d[0]; \
    (dimsCHW).w = (dims).d[1]; \
    (dimsCHW).c = (dims).d[2]; \
  } while (0)
 
#define DIVIDE_AND_ROUND_UP(a, b) ((a + b - 1) / b)
 
inline const char *safeStr(const std::string &str)
{
  return str.c_str();
}
 
inline bool string_empty(const char* str) {
  return !str || strlen(str) == 0;
}
 
constexpr float DEFAULT_PRE_CLUSTER_THRESHOLD = 0.2;
constexpr float DEFAULT_POST_CLUSTER_THRESHOLD = 0.0;
constexpr float DEFAULT_EPS = 0.0;
constexpr int DEFAULT_GROUP_THRESHOLD = 0;
constexpr int DEFAULT_MIN_BOXES = 0;
constexpr float DEFAULT_DBSCAN_MIN_SCORE = 0;
constexpr float DEFAULT_NMS_IOU_THRESHOLD = 0.3;
constexpr int DEFAULT_TOP_K = -1;
constexpr bool ATHR_ENABLED = true;
constexpr float ATHR_THRESHOLD = 60.0;
constexpr int PROCESS_MODEL_FULL_FRAME = 1;
constexpr int PROCESS_MODEL_OBJECTS = 2;
 
typedef enum {
    NVDSPOSTPROCESS_SUCCESS = 0,
    NVDSPOSTPROCESS_CONFIG_FAILED,
    NVDSPOSTPROCESS_CUSTOM_LIB_FAILED,
    NVDSPOSTPROCESS_INVALID_PARAMS,
    NVDSPOSTPROCESS_OUTPUT_PARSING_FAILED,
    NVDSPOSTPROCESS_CUDA_ERROR,
    NVDSPOSTPROCESS_RESOURCE_ERROR,
    NVDSPOSTPROCESS_UNKNOWN_ERROR
} NvDsPostProcessStatus;
 
 
typedef enum {
    NVDSPOSTPROCESS_LOG_ERROR = 0,
    NVDSPOSTPROCESS_LOG_WARNING,
    NVDSPOSTPROCESS_LOG_INFO,
    NVDSPOSTPROCESS_LOG_DEBUG,
} NvDsPostProcesLogLevel;
 
#define printMsg(level, tag_str, fmt, ...)                                  \
    do {                                                                    \
        char* baseName = strrchr((char*)__FILE__, '/');                     \
        baseName = (baseName) ? (baseName + 1) : (char*)__FILE__;           \
        char logMsgBuffer[5 * _MAX_STR_LENGTH + 1];                             \
        snprintf(logMsgBuffer, 5 * _MAX_STR_LENGTH,                             \
            tag_str " NvDsPostProcess::%s() <%s:%d> : " fmt, \
            __func__, baseName, __LINE__, ##__VA_ARGS__);       \
        fprintf(stderr, "%s\n", logMsgBuffer);                          \
    } while (0)
 
#define printError(fmt, ...) \
    do { \
        printMsg (NVDSINFER_LOG_ERROR, "Error in", fmt, ##__VA_ARGS__); \
    } while (0)
 
#define printWarning(fmt, ...) \
    do { \
        printMsg (NVDSINFER_LOG_WARNING, "Warning from", fmt, ##__VA_ARGS__); \
    } while (0)
 
#define printInfo(fmt, ...) \
    do { \
        printMsg (NVDSINFER_LOG_INFO, "Info from", fmt, ##__VA_ARGS__); \
    } while (0)
 
#define printDebug(fmt, ...) \
    do { \
        printMsg (NVDSINFER_LOG_DEBUG, "DEBUG", fmt, ##__VA_ARGS__); \
    } while (0)
 
typedef struct
{
  unsigned int roiTopOffset;
  unsigned int roiBottomOffset;
  unsigned int detectionMinWidth;
  unsigned int detectionMinHeight;
  unsigned int detectionMaxWidth;
  unsigned int detectionMaxHeight;
} NvDsPostProcessDetectionFilterParams;
 
typedef struct
{
  int have_border_color;
  NvOSD_ColorParams border_color;
 
  int have_bg_color;
  NvOSD_ColorParams bg_color;
} NvDsPostProcessColorParams;
 
 
typedef enum
{
    NVDSPOSTPROCESS_CLUSTER_GROUP_RECTANGLES = 0,
    NVDSPOSTPROCESS_CLUSTER_DBSCAN,
    NVDSPOSTPROCESS_CLUSTER_NMS,
    NVDSPOSTPROCESS_CLUSTER_DBSCAN_NMS_HYBRID,
    NVDSPOSTPROCESS_CLUSTER_NONE
} NvDsPostProcessClusterMode;
 
typedef enum {
    NvDsPostProcessTensorOrder_kNCHW,
    NvDsPostProcessTensorOrder_kNHWC,
    NvDsPostProcessTensorOrder_kNC,
} NvDsPostProcessTensorOrder;
 
 
typedef enum
{
    NvDsPostProcessNetworkType_Detector,
    NvDsPostProcessNetworkType_Classifier,
    NvDsPostProcessNetworkType_Segmentation,
    NvDsPostProcessNetworkType_InstanceSegmentation,
    NvDsPostProcessNetworkType_Other = 100
} NvDsPostProcessNetworkType;
 
typedef struct
{
    float preClusterThreshold;
 
    float postClusterThreshold;
 
    float eps;
    int minBoxes;
    int groupThreshold;
    float minScore;
    float nmsIOUThreshold;
    int topK;
 
    unsigned int roiTopOffset;
    unsigned int roiBottomOffset;
    unsigned int detectionMinWidth;
    unsigned int detectionMinHeight;
    unsigned int detectionMaxWidth;
    unsigned int detectionMaxHeight;
    NvDsPostProcessColorParams color_params;
 
} NvDsPostProcessDetectionParams;
 
 
 
typedef struct _NvDsPostProcessContextInitParams
{
    unsigned int uniqueID;
 
    unsigned int maxBatchSize;
 
    char labelsFilePath[_PATH_MAX];
 
 
    NvDsPostProcessNetworkType networkType;
 
    unsigned int numDetectedClasses;
 
    NvDsPostProcessDetectionParams *perClassDetectionParams;
 
    float classifierThreshold;
 
    float segmentationThreshold;
 
    char ** outputLayerNames;
    unsigned int numOutputLayers;
 
    unsigned int gpuID;
 
    NvDsInferDimsCHW inferInputDims;
 
    NvDsPostProcessClusterMode clusterMode;
 
    char customBBoxInstanceMaskParseFuncName[_MAX_STR_LENGTH];
 
    char customBBoxParseFuncName[_MAX_STR_LENGTH];
    char customClassifierParseFuncName[_MAX_STR_LENGTH];
 
    NvDsPostProcessTensorOrder segmentationOutputOrder;
 
    char *classifier_type;
} NvDsPostProcessContextInitParams;
 
typedef struct
{
  unsigned int classId;
 
  float left;
  float top;
  float width;
  float height;
 
  float detectionConfidence;
} NvDsPostProcessObjectDetectionInfo;
 
typedef struct
{
    unsigned int attributeIndex;
    unsigned int attributeValue;
    float attributeConfidence;
    char *attributeLabel;
} NvDsPostProcessAttribute;
 
 
typedef NvDsPostProcessObjectDetectionInfo NvDsPostProcessParseObjectInfo;
 
typedef struct
{
  unsigned int classId;
 
  float left;
  float top;
  float width;
  float height;
 
  float detectionConfidence;
 
  float *mask;
  unsigned int mask_width;
  unsigned int mask_height;
  unsigned int mask_size;
} NvDsPostProcessInstanceMaskInfo;
 
typedef struct
{
    float left;
    float top;
    float width;
    float height;
    int classIndex;
    char *label;
    /* confidence score of the detected object. */
    float confidence;
    /* Instance mask information for the object. */
    float *mask;
    unsigned int mask_width;
    unsigned int mask_height;
    unsigned int mask_size;
} NvDsPostProcessObject;
 
typedef struct
{
    NvDsPostProcessObject *objects;
    unsigned int numObjects;
} NvDsPostProcessDetectionOutput;
 
typedef struct
{
    NvDsPostProcessAttribute *attributes;
    unsigned int numAttributes;
    char *label;
} NvDsPostProcessClassificationOutput;
 
typedef struct
{
    unsigned int width;
    unsigned int height;
    unsigned int classes;
    int *class_map;
    float *class_probability_map;
} NvDsPostProcessSegmentationOutput;
 
typedef struct
{
    NvDsPostProcessNetworkType outputType;
    union
    {
        NvDsPostProcessDetectionOutput detectionOutput;
        NvDsPostProcessClassificationOutput classificationOutput;
        NvDsPostProcessSegmentationOutput segmentationOutput;
    };
} NvDsPostProcessFrameOutput;
 
typedef struct
{
    NvDsPostProcessFrameOutput *frames;
    unsigned int numFrames;
 
    void **outputDeviceBuffers;
    unsigned int numOutputDeviceBuffers;
 
    void **hostBuffers;
    unsigned int numHostBuffers;
 
    void* priv;
} NvDsPostProcessBatchOutput;
 
#ifdef __cplusplus
}
#endif
 
typedef struct
{
  unsigned int numClassesConfigured;
  std::vector<float> perClassPreclusterThreshold;
  /* Per-class threshold to be applied after the clustering operation. */
  std::vector<float> perClassPostclusterThreshold;
 
} NvDsPostProcessParseDetectionParams;
 
 
struct NvDsPostProcessObjectInfo {
  std::vector<NvDsPostProcessAttribute> attributes;
  std::string label;
 
  NvDsPostProcessObjectInfo(const NvDsPostProcessObjectInfo&) = delete;
  NvDsPostProcessObjectInfo() = default;
  ~NvDsPostProcessObjectInfo(){
    for (auto &attr : attributes) {
      if (attr.attributeLabel)
        free (attr.attributeLabel);
    }
  }
};
 
 
typedef struct _NvDsPostProcessObjectHistory
{
  int under_inference;
  NvOSD_RectParams last_inferred_coords;
  unsigned long last_inferred_frame_num;
  unsigned long last_accessed_frame_num;
  NvDsPostProcessObjectInfo cached_info;
} NvDsPostProcessObjectHistory;
 
 
#endif