sources/libs/nvmultiobjecttracker/include/modules/NvMultiObjectTracker/NvMultiObjectTracker_common.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2021-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef NVMULTIOBJECTTRACKERLIB_NVMULTIOBJECTTRACKER_COMMON_HPP_
#define NVMULTIOBJECTTRACKERLIB_NVMULTIOBJECTTRACKER_COMMON_HPP_
 
#include "nvdstracker.h"
#include "nvds_tracker_meta.h"
 
#include <vector>
#include <map>
#include <deque>
#include <queue>
#include <utility>
#include <memory>
#include <thread>
#include <mutex>
#include <condition_variable>
 
#ifdef _WIN32
using uint = unsigned int;
#endif
 
#include "modules/utility/cv_functions.hpp"
#include "modules/NvMultiObjectTracker/localizer.hpp"
 
typedef uint64_t TargetId;
typedef uint32_t TrackerIndex;
typedef NvMOTStreamId StreamId;
 
typedef std::string CamId;
 
struct SourceFrameInfo
{
    SourceFrameInfo()
    {
        frameBatchNo = 0;
        isDetectionDonePerStream.clear();
    }
 
    // [Per-frame source parameters]
    uint64_t frameBatchNo; 
    std::map<NvMOTStreamId, std::pair<uint32_t, bool>> isDetectionDonePerStream; 
 
    // [Plugin configuration]
    NvBufSurfaceColorFormat colorFormat; 
    uint32_t maxStreams; 
    uint32_t maxBufSurfAddrSize; 
    NvMotDataTypes::Size originalSrcImageSize; 
    NvMotDataTypes::Size srcImageSize; 
    size_t srcImagePitch; 
};
 
struct DetectedObjInfo
{
    DetectedObjInfo(DetectedObjInfo&&) noexcept = default;
 
    DetectedObjInfo& operator=(DetectedObjInfo&&) noexcept = default;
 
    DetectedObjInfo(const DetectedObjInfo&) = default;
 
    DetectedObjInfo& operator=(const DetectedObjInfo&) = default;
 
    DetectedObjInfo()
    {
        objIn = nullptr;
        visibility = 1.f;
        pt_img_feet << -1, -1;
        pt_world_feet << -1, -1;
        convexHull.clear();
        distFromCam = std::numeric_limits<float>::max();
    }
 
    DetectedObjInfo(
        const NvMOTObjToTrack *objIn_, const uint16_t bboxInd_, NvMOTClassId classId_,
        float confidence_, NvMotDataTypes::Rect2f bbox_, Eigen::Vector2f loc_
    )
    : objIn(objIn_),
      bboxInd(bboxInd_),
      classId(classId_),
      confidence(confidence_),
      bbox(bbox_),
      origBbox(bbox_),
      loc(loc_)
    {
        visibility = 1.f;
        pt_img_feet << -1, -1;
        pt_world_feet << -1, -1;
        convexHull.clear();
    }
 
    DetectedObjInfo(const NvMOTObjToTrack *objIn_, const uint16_t bboxInd_)
    : objIn(objIn_), bboxInd(bboxInd_)
    {
        classId = objIn_->classId;
        confidence = objIn_->confidence;
        visibility = 1.f;
        distFromCam = std::numeric_limits<float>::max();
        bbox = CV_FUNCS::constructRect2f(objIn_->bbox.x, objIn_->bbox.y, objIn_->bbox.width, objIn_->bbox.height);
        origBbox = bbox;
        loc = CV_FUNCS::getBboxCenterPt(bbox);
        pt_img_feet << -1, -1;
        pt_world_feet << -1, -1;
        convexHull.clear();
    }
 
    const NvMOTObjToTrack *objIn; 
    uint16_t bboxInd; 
    NvMOTClassId classId; 
    float confidence; 
    float visibility; 
    float distFromCam; 
    NvMotDataTypes::Rect2f bbox; 
    NvMotDataTypes::Rect2f origBbox; 
    Eigen::Vector2f loc; 
    Eigen::Vector2f pt_img_feet; 
    Eigen::Vector2f pt_world_feet; 
    std::vector<Eigen::Vector2f> convexHull; 
};
 
struct TargetInfo
{
    TargetInfo(TargetInfo&&) noexcept = default;
 
    TargetInfo& operator=(TargetInfo&&) noexcept = default;
 
    TargetInfo(const TargetInfo&) = default;
 
    TargetInfo& operator=(const TargetInfo&) = default;
 
    TargetInfo(
        const DetectedObjInfo* detObjIn_ = nullptr, const NvMOTStreamId videoStreamId_ = 0,
        const NvMOTFrameNum frameNum_ = 0, const uint16_t classId_ = 0,
        const NvMotDataTypes::Rect2f bbox_ = NvMotDataTypes::Rect2f(), const NvMOTFrameNum age_ = 0,
        const NvMOTFrameNum shadowAge_ = 0, const TRACKER_STATE state = TRACKER_STATE::EMPTY
    )
    {
        matchedDetObjInfo = (DetectedObjInfo *) detObjIn_;
 
        videoStreamId = videoStreamId_;
        frameNum = frameNum_;
        classId = classId_;
        tBbox = bbox_;
        loc << float(tBbox.min()(0) + tBbox.sizes()(0)/2.f), float(tBbox.min()(1) + tBbox.sizes()(1)/2.f);
        age = age_;
 
        shadowTrackingAge = shadowAge_;
        trackerState = state;
 
        if(detObjIn_ != nullptr)
        {
            distFromCam = detObjIn_->distFromCam;
            origBbox = detObjIn_->origBbox;
            visibility = detObjIn_->visibility;
            convexHull = detObjIn_->convexHull;
            pt_img_feet = detObjIn_->pt_img_feet;
            pt_world_feet = detObjIn_->pt_world_feet;
        }
        else
        {
            distFromCam = std::numeric_limits<float>::max();
            origBbox = bbox_;
            visibility = 1.f;
            convexHull.clear();
            pt_img_feet << -1, -1;
            pt_world_feet << -1, -1;
        }
        pt_world_feet_cov = Eigen::Matrix2f::Identity();
        imgBorderCroppingVisibility = 1.f;
        confidence = 0.5f;
        height = 0.0f;
    }
 
    void update(
        const NvMOTFrameNum frameNum_, const DetectedObjInfo *detObjIn_,
        const NvMotDataTypes::Rect2f bbox_, const float imgBorderCroppingVisibility_
    )
    {
        matchedDetObjInfo = (DetectedObjInfo *) detObjIn_;
 
        frameNum = frameNum_;
        classId = detObjIn_->classId;
        tBbox = bbox_;
        loc << float(tBbox.min()(0) + tBbox.sizes()(0)/2.f), float(tBbox.min()(1) + tBbox.sizes()(1)/2.f);
        distFromCam = detObjIn_->distFromCam;
        origBbox = detObjIn_->origBbox;
        visibility = detObjIn_->visibility;
        convexHull = detObjIn_->convexHull;
        imgBorderCroppingVisibility = imgBorderCroppingVisibility_;
        age++;
 
        pt_img_feet = detObjIn_->pt_img_feet;
        pt_world_feet = detObjIn_->pt_world_feet;
    }
 
    void update(
        const NvMOTFrameNum frameNum_, const NvMotDataTypes::Rect2f bbox_, const float imgBorderCroppingVisibility_
    )
    {
        matchedDetObjInfo = nullptr;
 
        frameNum = frameNum_;
        tBbox = bbox_;
        loc << float(tBbox.min()(0) + tBbox.sizes()(0)/2.f), float(tBbox.min()(1) + tBbox.sizes()(1)/2.f);
        distFromCam = std::numeric_limits<float>::max();
        origBbox = bbox_;
        visibility = 0.f;
        imgBorderCroppingVisibility = imgBorderCroppingVisibility_;
        age++;
    }
 
    void setLocation(const NvMotDataTypes::Rect2f bbox_)
    {
        tBbox = bbox_;
        loc << float(tBbox.min()(0) + tBbox.sizes()(0)/2.f), float(tBbox.min()(1) + tBbox.sizes()(1)/2.f);
    }
 
    NvMOTObjToTrack* getMatchedDetObjIn() const
    {
        return (NvMOTObjToTrack *) (matchedDetObjInfo ? matchedDetObjInfo->objIn : nullptr);
    }
 
    DetectedObjInfo *matchedDetObjInfo; 
    NvMOTStreamId videoStreamId; 
    NvMOTFrameNum frameNum; 
    NvMOTClassId classId; 
    NvMotDataTypes::Rect2f tBbox; 
    NvMotDataTypes::Rect2f origBbox; 
    Eigen::Vector2f loc; 
    float confidence; 
    float distFromCam; 
    float height; 
    float imgBorderCroppingVisibility; 
    float visibility; 
    NvMOTFrameNum age; 
    Eigen::Vector2f pt_img_feet; 
    Eigen::Vector2f pt_world_feet; 
    Eigen::Matrix2f pt_world_feet_cov; 
    std::vector<Eigen::Vector2f> convexHull; 
    std::vector<float> pose25d; 
    std::vector<float> pose3d; 
    uint32_t shadowTrackingAge; 
    TRACKER_STATE trackerState; 
};
 
class NvTrackedObject;
typedef std::map<TrackerIndex, std::shared_ptr<NvTrackedObject>> NvTrackedObjectList;
 
struct Trajectory4Archive
{
    uint32_t frameNumTerminated; 
    uint32_t lastFrameMatched; 
    std::list<TargetInfo> tracklet; 
    bool isReported; 
    std::vector<float> reidEmbedding; 
 
    #ifdef VIZ_DEBUG
        bool isVisualized; 
    #endif
};
 
typedef std::pair<const std::map<NvMOTStreamId, NvMOTFrame *> *, \
        std::map<NvMOTStreamId, std::deque<DetectedObjInfo>> *> DisMahalanobisIn;
 
template <typename T> class NvTrackerMultiThreadWorker
{
public:
 
    // [Worker thread operations]
    bool m_isInit; 
    std::mutex m_inputLock; 
    std::mutex m_outputLock; 
    std::condition_variable m_cond4In; 
    std::condition_variable m_cond4Out; 
    std::queue<T> m_inputQueue; 
    std::vector<std::thread> m_threadList; 
    bool m_persistThreadRunning; 
    uint m_submittedJobCnt; 
    uint m_finishedJobCnt; 
    std::function<void(T)> m_funcPerThread; 
 
    NvTrackerMultiThreadWorker();
 
    ~NvTrackerMultiThreadWorker();
 
    void initialize(const uint numThreads, std::function<void(T)> funcPerThread);
 
    void submitInput(T inData);
 
    void waitToFinish();
 
    void threadLoopFunc();
 
    bool isInitialized() { return m_isInit; }
};
 
#endif // NVMULTIOBJECTTRACKERLIB_NVMULTIOBJECTTRACKER_COMMON_HPP_