service-maker/includes/metadata.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2024-2026 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 NVIDIA_DEEPSTREAM_METADATA
#define NVIDIA_DEEPSTREAM_METADATA
 
#include <functional>
#include <memory>
#include <string>
 
#include "nvll_osd_struct.h"
#include "nvds_tracker_meta.h"
 
namespace deepstream {
 
#define USER_METADATA_START = (4096 + 4096 + 1)
 
class Metadata {
 public:
  Metadata(void* data);
 
  virtual ~Metadata();
 
  virtual operator bool() { return data_ != nullptr; }
 
 protected:
  void* data_; //> opaque data pointer
};
 
template <typename T>
class AbstractIterator {
 public:
  AbstractIterator(const T& data) : data_(data) {}
 
  virtual ~AbstractIterator() {}
 
  T& operator*() { return data_; }
 
  T* operator->() { return &data_; }
 
  T& get() { return data_; }
 
  virtual AbstractIterator<T>& next() = 0;
 
  virtual bool done() = 0;
 
  virtual bool operator==(const AbstractIterator<T>& other) const = 0;
 
  bool operator!=(const AbstractIterator<T>& other) const {
    return !(*this == other);
  }
 
 protected:
  T data_;
};
 
class UserMetadata : public Metadata {
 public:
  typedef std::unique_ptr<AbstractIterator<UserMetadata>> Iterator;
 
  UserMetadata(void*);
  virtual ~UserMetadata();
 
  virtual operator bool() override { return data_ != nullptr; }
 
  int metaType() const;
  void setMetaType(int type);
 
  void* userData() const;
  void setUserData(void* data, void*(*copy)(void*, void*), void(*release)(void*, void*));
 
  friend class BatchMetadata;
  friend class FrameMetadata;
  friend class ObjectMetadata;
 
 protected:
  void get_(void*&);
};
 
class ClassifierMetadata : public Metadata {
public:
  typedef std::unique_ptr<AbstractIterator<ClassifierMetadata>> Iterator;
 
  ClassifierMetadata(void* data = nullptr);
  virtual ~ClassifierMetadata();
 
  unsigned int nLabels() const;
  unsigned int uniqueComponentId() const;
  std::string getLabel(unsigned int nth) const;
 
};
 
class ObjectMetadata : public Metadata {
 public:
  typedef std::unique_ptr<AbstractIterator<ObjectMetadata>> Iterator;
 
  ObjectMetadata(void* data = nullptr);
  virtual ~ObjectMetadata();
 
  unsigned int uniqueComponentId() const;
  void setUniqueComponentId(unsigned int);
  unsigned int classId() const;
  void setClassId(unsigned int);
  unsigned long  int objectId() const;
  void setObjectId(unsigned long);
  float confidence() const;
  void setConfidence(float);
  float trackerConfidence() const;
  void setTrackerConfidence(float);
  NvOSD_RectParams& rectParams() const;
  void setRectParams(const NvOSD_RectParams&);
  NvOSD_MaskParams& maskParams() const;
  void setMaskParams(const NvOSD_MaskParams&);
  NvOSD_TextParams& textParams() const;
  void setTextParams(const NvOSD_TextParams&);
  std::string label() const;
  void setLabel(std::string);
  NvBbox_Coords& nvBboxInfo() const;
  void setNvBboxInfo(const NvBbox_Coords&);
 
  unsigned int iterate(const std::function<void(const ClassifierMetadata&)>& func) const;
  void initiateIterator(ClassifierMetadata::Iterator&) const;
 
  unsigned int iterate(const std::function<void(const UserMetadata&)>& func, int meta_type) const;
  void initiateIterator(UserMetadata::Iterator&, int meta_type) const;
 
  void append(const UserMetadata&);
 
 friend class FrameMetadata;
};
 
 
class FrameMetadata;
class EventMessageUserMetadata : public UserMetadata {
 public:
  EventMessageUserMetadata(void* data=nullptr);
  virtual ~EventMessageUserMetadata();
 
  void generate(
    const ObjectMetadata&,
    const FrameMetadata&,
    const std::string sensor="N/A",
    const std::string uri="N/A",
    const std::vector<std::string>labels=std::vector<std::string>());
};
 
class RoiMetadata : public Metadata {
 public:
  RoiMetadata(void* data=nullptr);
  virtual ~RoiMetadata();
 
  NvOSD_RectParams& rectParams() const;
 
  FrameMetadata frameMetadata() const;
 
  ObjectMetadata objectMetadata() const;
 
  unsigned int iterate(const std::function<void(const UserMetadata&)>& func, int meta_type) const;
  void initiateIterator(UserMetadata::Iterator&, int meta_type) const;
 
  unsigned int iterate(const std::function<void(const ClassifierMetadata&)>& func) const;
  void initiateIterator(ClassifierMetadata::Iterator&) const;
};
 
 
class Tensor;
class TensorOutputUserMetadata : public UserMetadata {
 public:
  TensorOutputUserMetadata(void* data=nullptr);
  TensorOutputUserMetadata(const UserMetadata&);
  virtual ~TensorOutputUserMetadata();
 
  unsigned int uniqueId() const;
  std::unordered_map<std::string, Tensor*> getLayers();
};
 
class SegmentationUserMetadata: public UserMetadata {
public:
  SegmentationUserMetadata(void* data=nullptr);
 
  SegmentationUserMetadata(const UserMetadata& other);
 
  virtual ~SegmentationUserMetadata();
 
  unsigned int uniqueId() const;
 
  unsigned int getClasses() const;
 
  unsigned int getWidth() const;
 
  unsigned int getHeight() const;
 
  const int* getClassMap() const;
 
  const float* getClassProbabilitiesMap() const;
};
 
template <class C, int N>
class UserMetadataTemplate : public UserMetadata {
 public:
  UserMetadataTemplate(void* data=nullptr) : UserMetadata(data) {}
  UserMetadataTemplate(const UserMetadata& other): UserMetadata(other) {}
  virtual ~UserMetadataTemplate() {}
 
 
  C& get() {
    void* p = nullptr;
    this->get_(p);
    return *((C*)p);
  }
 
  static void* copy(void* data, void* user_data) {
    void* p = nullptr;
    UserMetadataTemplate<C, N>(data).get_(p);
    C*& src = (C*&) p;
    C* dst = new C(*src);
    return dst;
  }
 
  static void free(void* data, void* user_data) {
    void* p = nullptr;
    UserMetadataTemplate<C, N>(data).get_(p);
    C*& src = (C*&) p;
    delete src;
    p = nullptr;
  }
};
 
class DisplayMetadata : public Metadata {
 public:
  typedef std::unique_ptr<AbstractIterator<DisplayMetadata>> Iterator;
 
  DisplayMetadata(void* data = nullptr);
  virtual ~DisplayMetadata();
 
  unsigned int nRects() const;
  unsigned int nLabels() const;
  unsigned int nLines() const;
  unsigned int nArrows() const;
  unsigned int nCircles() const;
 
  bool add(NvOSD_TextParams&);
  bool add(NvOSD_RectParams&);
  bool add(NvOSD_LineParams&);
  bool add(NvOSD_ArrowParams&);
  bool add(NvOSD_CircleParams&);
 
  friend class FrameMetadata;
};
 
class FrameMetadata : public Metadata {
 public:
  typedef std::unique_ptr<AbstractIterator<FrameMetadata>> Iterator;
 
  FrameMetadata(void* data=nullptr);
  virtual ~FrameMetadata();
 
  unsigned int iterate(const std::function<void(const ObjectMetadata&)>& func) const;
  void initiateIterator(ObjectMetadata::Iterator&) const;
 
  unsigned int iterate(const std::function<void(const DisplayMetadata&)>& func) const;
  void initiateIterator(DisplayMetadata::Iterator&) const;
 
  unsigned int iterate(const std::function<void(const UserMetadata&)>& func, int meta_type) const;
  void initiateIterator(UserMetadata::Iterator&, int meta_type) const;
 
  unsigned int padIndex() const;
  unsigned int batchId() const;
  int frameNum() const;
  unsigned int sourceId() const;
  unsigned int sourceWidth() const;
  unsigned int sourceHeight() const;
 
  unsigned int pipelineWidth() const;
  unsigned int pipelineHeight() const;
 
  uint64_t bufferPTS() const;
  uint64_t ntpTimestamp() const;
 
  void append(const DisplayMetadata&);
  void append(const UserMetadata&);
  void append(const ObjectMetadata&);
 
  friend class BatchMetadata;
};
 
class PreprocessTensorMetadata {
 public:
  PreprocessTensorMetadata(void* data=nullptr);
  virtual ~PreprocessTensorMetadata();
 
  std::string getName() const;
 
  unsigned int getMetaId() const;
 
  Tensor* getTensor() const;
 
  operator bool() const {
    return data_ != nullptr;
  }
 
 protected:
  void * data_;
};
 
 
class PreprocessBatchUserMetadata : public UserMetadata {
 public:
  PreprocessBatchUserMetadata(void* data=nullptr);
  PreprocessBatchUserMetadata(const UserMetadata&);
  virtual ~PreprocessBatchUserMetadata();
 
  std::vector<unsigned int> getTargetUniqueIds() const;
 
  std::vector<RoiMetadata> getRois() const;
 
  PreprocessTensorMetadata getPreprocessTensorMetadata() const;
 
  bool initPreprocessTensorMetadata(const std::string& name, unsigned int meta_id, unsigned int unique_id, Tensor* tensor);
};
 
class ObjectVisibilityUserMetadata : public UserMetadata {
 public:
  ObjectVisibilityUserMetadata(void* data=nullptr);
  ObjectVisibilityUserMetadata(const UserMetadata& user_meta);
  virtual ~ObjectVisibilityUserMetadata();
 
  float getVisibility() const;
};
 
class ObjectImageFootLocationUserMetadata : public UserMetadata {
 public:
  ObjectImageFootLocationUserMetadata(void* data=nullptr);
  ObjectImageFootLocationUserMetadata(const UserMetadata& user_meta);
  virtual ~ObjectImageFootLocationUserMetadata();
 
  std::pair<float, float> getImageFootLocation() const;
};
 
class Object3DBBoxUserMetadata : public UserMetadata {
  public:
    Object3DBBoxUserMetadata(void* data=nullptr);
    Object3DBBoxUserMetadata(const UserMetadata& user_meta);
    virtual ~Object3DBBoxUserMetadata();
    NvDsObj3DBbox* get3DBbox() const;
};
 
class TrackerPastFrameUserMetadata : public UserMetadata {  
  public:
    TrackerPastFrameUserMetadata(void* data=nullptr);
    TrackerPastFrameUserMetadata(const UserMetadata& user_meta);
    virtual ~TrackerPastFrameUserMetadata();
    NvDsTargetMiscDataBatch* getTrackerMiscDataBatch() const;
};
 
class StructureUserMetadata: public UserMetadata {
public:
  StructureUserMetadata(void* data=nullptr);
  StructureUserMetadata(const UserMetadata& user_meta);
  virtual ~StructureUserMetadata();
  void* getStructureUserMetadata() const;
  int getStructureUserMetatype() const;
};
 
class ObjectReidUserMetadata : public UserMetadata {
 public:
  ObjectReidUserMetadata(void* data=nullptr);
  ObjectReidUserMetadata(const UserMetadata& user_meta);
  ObjectReidUserMetadata& operator=(const ObjectReidUserMetadata&);
  virtual ~ObjectReidUserMetadata();
 
  unsigned int featureSize() const;
 
  const float* featureVector() const;
 
  void setFeatureVector(const float* features, unsigned int size);
};
 
class AnalyticsObjInfo: public UserMetadata {
public:
  AnalyticsObjInfo(void* data=nullptr);
 
  AnalyticsObjInfo(const UserMetadata& user_meta);
 
  virtual ~AnalyticsObjInfo();
 
  std::vector<std::string> getRoiStatus() const;
 
  std::vector<std::string> getOcStatus() const;
 
  std::vector<std::string> getLcStatus() const;
 
  std::string getDirStatus() const;
 
  unsigned int getUniqueId() const;
 
  std::string getObjStatus() const;
};
 
class AnalyticsFrameMeta: public UserMetadata {
public:
  AnalyticsFrameMeta(void* data=nullptr);
 
  AnalyticsFrameMeta(const UserMetadata& user_meta);
  virtual ~AnalyticsFrameMeta();
 
  std::unordered_map<std::string, bool> getOcStatus() const;
 
  std::unordered_map<std::string, uint32_t> getObjInROIcnt() const;
 
  std::unordered_map<std::string, uint64_t> getObjLCCurrCnt() const;
 
  std::unordered_map<std::string, uint64_t> getObjLCCumCnt() const;
 
  unsigned int getUniqueId() const;
 
  std::unordered_map<int, uint32_t> getObjCnt() const;
};
 
class BatchMetadata : public Metadata {
 public:
  BatchMetadata(void *data = nullptr);
 
  virtual ~BatchMetadata();
 
  unsigned int iterate(const std::function<void(const FrameMetadata&)>& func) const;
  void initiateIterator(FrameMetadata::Iterator&) const;
 
  unsigned int iterate(const std::function<void(const UserMetadata&)>& func, int meta_type) const;
  void initiateIterator(UserMetadata::Iterator&, int meta_type) const;
 
  bool acquire(DisplayMetadata&);
  bool acquire(FrameMetadata&);
  bool acquire(ObjectMetadata&);
  bool acquire(EventMessageUserMetadata&);
  bool acquire(PreprocessBatchUserMetadata&);
  bool acquire(UserMetadata&);
  bool acquire(ObjectReidUserMetadata&);
  template<class C, int N>
  bool acquire(UserMetadataTemplate<C, N>& user_meta) {
    user_meta = acquireUserMetadata_(
        new C, N, UserMetadataTemplate<C, N>::copy, UserMetadataTemplate<C, N>::free
    );
    return user_meta ? true : false;
  }
 
  void append(const FrameMetadata&);
  void append(const UserMetadata&);
 
  unsigned int nFrames() const;
 
 protected:
  UserMetadata acquireUserMetadata_(
    void* data, unsigned int type, void*(*copy)(void*, void*), void(*free)(void*, void*)
  );
};
 
 
}
 
#endif