sources/libs/nvmultiobjecttracker/include/modules/NvMultiObjectTracker/NvTrackedObject.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 NVTRACKEDOBJECT_HPP_
#define NVTRACKEDOBJECT_HPP_
 
#include <cstdint>
#include <deque>
#include <list>
#include <unordered_map>
#include <mutex>
#include <queue>
#include <iomanip>
 
#include <atomic>
#include <limits>
#ifndef _WIN32
#include <unistd.h>
#include <sys/syscall.h>
#endif
#include <random>
 
#include "modules/utility/dataTypes.hpp"
#include "modules/utility/cv_functions.hpp"
#include "modules/Estimatorv2/estimator_factory2.hpp"
#include "modules/NvMultiObjectTracker/localizer.hpp"
#include "modules/NvMultiObjectTracker/NvMultiObjectTracker_common.hpp"
#include "modules/TrajectoryManager/NvTrajectoryManager.hpp"
#include "modules/ObjectModelProjector/ObjectModelProjector.hpp"
#include "modules/MultiViewAssociator/MultiViewAssociator_factory.hpp"
 
enum TRACKER_DELETE_MODE : uint {
    REGULAR_TERMINATION = 1, 
    EARLY_TERMINATION, 
    INSUFFICIENT_VISIBILITY, 
    DUPLICATE_TRACKER, 
    CORRUPTED_TRACKER, 
    TOO_SMALL_OBJECT, 
    TOO_LARGE_OBJECT, 
    REMOVED_STREAM_TRACKER, 
    FUSED_BY_REASSOCIATION 
};
 
enum REID4REASSOC_STATE : int {
    NOT_NEEDED, 
    TO_DO, 
    DONE 
};
 
struct TerminatedTrack
{
    TerminatedTrack () : targetID(0), classID(0), videoStreamId(0), state(TRACKER_STATE::EMPTY) {}
    TargetId targetID; 
    uint16_t classID; 
    NvMOTStreamId videoStreamId; 
    TRACKER_STATE state; 
    std::vector<TargetInfo> targetHistory; 
};
 
struct SegmentationInBatch
{
    float *segMaskInBatch_d; 
    NvMotDataTypes::Size size; 
};
 
struct assocDataIn_t
{
    const NvMOTStreamId videoStreamId; 
    const NvMOTFrameNum frameNum; 
    const NvMOTTimeMeta timeMeta; 
    bool isDetDone; 
    std::deque<const DetectedObjInfo *> detObjs; 
    std::map<TrackerIndex, std::shared_ptr<NvTrackedObject>> targets; 
    std::map<uint16_t, float> sumsCorrRespAtDetectedPt; 
    std::shared_ptr<IMultiViewAssociator> multiViewAssociator; 
};
 
struct assocDataOut_t
{
    NvMOTStreamId videoStreamId; 
    NvMOTFrameNum frameNum; 
    NvMOTTimeMeta timeMeta; 
    bool isAssocDone; 
    std::map<const TrackerIndex, const DetectedObjInfo*> unmatchedDetObjs; 
    std::deque<std::pair<const DetectedObjInfo *, TrackerIndex>> matchedPairs; 
    std::set<TrackerIndex> unmatchedTargets; 
};
 
struct reidServiceAssocInfo
{
    TargetId targetID; 
    int groupCount = 0; 
    float confidence = 0.0; 
    float expConfidence = 0.0; 
    float distance; 
    float distanceToCentroid; 
    float clusterVariance; 
};
 
#ifdef VIZ_DEBUG
 
class TrackerVizOutput;
#endif
 
class NvTrajectoryManager;
 
class NvTrackerParamsTargetManager : public NvTrackerParams
{
public:
    NvTrackerParamsTargetManager();
 
    NvTrackerParamsTargetManager(const std::string &configFilePath, const std::string moduleName);
 
    NvTrackerParamsTargetManager(const YAML::Node &fn);
 
    void read(const YAML::Node &fn) override;
 
    int m_debugVerboseLevel; 
    bool m_preserveStreamUpdateOrder; 
    bool m_enableBboxUnClipping; 
    bool m_outputVisibility; 
    bool m_saveTerminatedTracks; 
    bool m_useVOTBasedTargetUpdate; 
    std::string m_terminatedTrackFilename; 
    std::string m_intermediateInfoFileName; 
    int m_maxTargetsPerStream; 
 
    // [Class match]
    bool m_checkClassMatch; 
 
    // [Creation & Termination Policy]
    float m_minDetectorConfidence; 
    float m_minTrackerConfidence; 
    int m_probationAge; 
    int m_maxShadowTrackingAge; 
    int m_maxActiveShadowTrackingAge; 
    int m_earlyTerminationAge; 
    float m_minIouDiff4NewTarget; 
    float m_searchRegionPaddingScale; 
 
    // [Trajectory Management]
    int m_maxTrajectoryBufferLength; 
    bool m_saveShadowTracks; 
 
    // [Debug parameters]
    int m_debugParamInt0;
    int m_debugParamInt1;
    int m_debugParamInt2;
    float m_debugParamFloat0;
    float m_debugParamFloat1;
    float m_debugParamFloat2;
 
    // [Runtime parameters]
    uint m_maxTargetsToTrack; 
    NvMotDataTypes::Rect2f originalSrcImageBox; 
    NvMotDataTypes::Rect2f srcImageBox; 
    bool m_isInit = false; 
};
 
class NvTrackedObject
{
public:
    NvTrackedObject(
        const std::string &configFilePath, const NvTrackerParamsTargetManager *params, const TrackerIndex trackerInd
    );
 
    virtual ~NvTrackedObject();
 
    void reset();
 
    void updateTargetStates(const NvMOTFrameNum frameNum, const DetectedObjInfo *debObj, TRACKER_STATE state);
 
    void updateTargetStates(const NvMOTFrameNum frameNum);
 
    void initializeQuasiActiveStates(const NvMOTFrameNum frameNum, const PeerTarget *peerTarget);
 
    void setLocalizationResults(
        const NvMOTFrameNum frameNum, const float trackingConfidence, const NvMotDataTypes::Rect2f& localizationBbox
    );
 
    void incrementShadowTrackingAge(const NvMOTFrameNum increment = 1) { m_targetInfo.shadowTrackingAge += increment; }
 
    void resetShadowTrackingAge() { m_targetInfo.shadowTrackingAge = 0; }
 
    void addPastFrameData();
 
    void resetPastFrameData() { return m_pastFrameDataBuffer.clear(); }
 
    const NvMotDataTypes::Rect2f defineSearchRegion(const NvMotDataTypes::Rect2f bbox) const;
 
    void updateTrajectoryBuffer();
 
    void purgeTrajectoryBufferUntilSpecified(const NvMOTFrameNum frameNum);
 
    void adoptTracklet(const std::list<TargetInfo> &tracklet);
 
    std::list<TargetInfo> fuseOverlappingTracklets(
        const std::list<TargetInfo> &tracklet, const std::list<TargetInfo> &peerTracklet
    );
 
    void adoptPastFrameData(const std::deque<TargetInfo> &pastFrameBuffer);
 
    std::map<NvMOTStreamId, std::deque<DetectedObjInfo>> generateTrackedObjects4Reid(
        const std::map<NvMOTStreamId, NvMOTFrame *> &inputMeta
    );
 
    void setVideoStreamId(const NvMOTStreamId videoStreamId) { m_targetInfo.videoStreamId = videoStreamId; }
 
    const NvMOTStreamId getVideoStreamId() { return m_targetInfo.videoStreamId; }
 
    const TrackerIndex &getTargetInd() { return m_targetInd; }
 
    const TargetInfo &getTargetInfo() { return m_targetInfo; }
 
    void setTargetInfo(const TargetInfo &tInfo) { m_targetInfo = tInfo; }
 
    const NvMotDataTypes::Rect2f getTargetBbox() const { return m_targetInfo.tBbox; }
 
    const NvMotDataTypes::Rect2f getSearchRegion() const { return m_searchRegion; }
 
    const NvMotDataTypes::Rect2f getPredictedSearchRegion() const { return m_predictedSearchRegion; }
 
    const NvMotDataTypes::Rect2f getProgBbox() const { return m_progBbox; }
 
    void setProgBbox(const NvMotDataTypes::Rect2f& bbox) { m_progBbox = bbox; }
 
    const NvMOTFrameNum getAge() { return m_targetInfo.age; }
 
    const float getVisibility() { return m_targetInfo.visibility; }
 
    void setAge(const NvMOTFrameNum newAge) { m_targetInfo.age = newAge; }
 
    const TRACKER_STATE getTrackerState() { return m_targetInfo.trackerState; }
 
    void setTrackerState(const TRACKER_STATE state) { m_targetInfo.trackerState = state; }
 
    const NvMOTFrameNum getShadowTrackingAge() { return m_targetInfo.shadowTrackingAge; }
 
    const TargetId getTargetID() { return m_targetID; }
 
    void setTargetID(const TargetId newTargetID) { m_targetID = newTargetID; }
 
    const uint16_t getClassId() { return m_targetInfo.classId; }
 
    #ifdef VIZ_DEBUG
 
        const cv::Scalar getColor() { return m_color; }
    #endif
 
    const std::deque<TargetInfo> &getPastFrameData() { return m_pastFrameDataBuffer; }
 
    std::list<TargetInfo> &getTrajectoryBuffer() { return m_trajectoryBuffer; }
 
    void setTrajectoryBuffer(const std::list<TargetInfo> &traj) { m_trajectoryBuffer = traj; }
 
    const NvMotDataTypes::Rect2f getPredictedTargetBbox()
    {
        return CV_FUNCS::convertXToBbox(m_stateEstimator->getPredictedStates(), m_stateEstimator->useAspectRatio());
    }
 
    const TimeStamp getTargetIDTimeStamp() { return m_targetIDTimeStamp; }
 
    void setTargetIDTimeStamp(const TimeStamp time) { m_targetIDTimeStamp = time; }
 
    const bool becameActive() { return m_becameActive; }
 
    void setBecameActive(const bool flag) { m_becameActive = flag; }
 
    const bool acquiredID() { return m_acquiredID; }
 
    void setAcquiredID(const bool flag) { m_acquiredID = flag; }
 
    const std::vector<PeerTarget> getPeerTargets() { return m_peerTargets; }
 
    void setPeerTargets(const std::vector<PeerTarget> peerTargets) { m_peerTargets = peerTargets; }
 
    void setNeedTargetIDAssigned() { m_needToSetTargetID = true; }
 
    float getDistFromCam() { return m_targetInfo.distFromCam; }
 
    std::tuple<Eigen::VectorXd, Eigen::MatrixXd> getStatesWithCov()
    {
        return std::move(m_stateEstimator->getStatesWithCov());
    }
 
    std::tuple<Eigen::VectorXd, Eigen::MatrixXd> getPredictedStatesWithCov(const float dT = 1.f)
    {
        return std::move(m_stateEstimator->getPredictedStatesWithCov(dT));
    }
 
    std::tuple<Eigen::VectorXd, Eigen::MatrixXd> getPredictedMeasurementsWithCov()
    {
        return std::move(m_stateEstimator->getPredictedMeasurementsWithCov());
    }
 
    const float getTrackerConfidence() { return m_targetInfo.confidence; }
 
    const int getMatchedDetObjInd()
    {
        return m_targetInfo.matchedDetObjInfo ? int(m_targetInfo.matchedDetObjInfo->bboxInd) : -1;
    }
 
    const DetectedObjInfo* getMatchedDetObj() { return m_targetInfo.matchedDetObjInfo; }
 
    void setConfidenceCorrRespAtDetectedPts(const float *ptr, const size_t length)
    {
        m_confidenceCorrRespAtDetectedPts = std::vector<float>(ptr, ptr+length);
    }
 
    const std::vector<float> &getConfidenceCorrRespAtDetectedPts() { return m_confidenceCorrRespAtDetectedPts; }
 
    void setCorrRespAtDetectedPts(const float *ptr, const size_t length)
    {
        m_corrRespAtDetectedPts = std::vector<float>(ptr, ptr+length);
    }
 
    const std::vector<float> &getCorrRespAtDetectedPts() { return m_corrRespAtDetectedPts; }
 
    void setConfidenceReidDets(const float *ptr, const size_t length)
    {
        m_confidenceReidDets = std::vector<float>(ptr, ptr+length);
    }
 
    void setConfidenceReidDets(std::vector<float> vec) { m_confidenceReidDets = std::move(vec); }
 
    const std::vector<float> &getConfidenceReidDets() { return m_confidenceReidDets; }
 
    void addConfidenceListReidDets(const float *ptr, const size_t length)
    {
        m_confidenceListReidDets.emplace_back(ptr, ptr+length);
    }
 
    std::vector<std::vector<float>> &getConfidenceListReidDets() { return m_confidenceListReidDets; }
 
    void setConfidenceReidDetsFrameNum(const std::vector<int> input) { m_confidenceReidDetsFrameNum = input; }
 
    const std::vector<int> &getConfidenceReidDetsFrameNum() { return m_confidenceReidDetsFrameNum; }
 
    void setDisMahalanobisDets(const std::vector<float> disVec) { m_disMahalanobisDets = disVec; }
 
    const std::vector<float> &getDisMahalanobisDets() { return m_disMahalanobisDets; }
 
    void setSegmentationMask(const NvMOTMask mask) { m_maskOriginal = mask; }
 
    const NvMOTMask &getSegmentationMask() { return m_maskOriginal; }
 
    void resetStateEstimator() { m_stateEstimator->reset(); }
 
    const NvMOTFrameNum getlastFrameinTraj() { return m_trajectoryBuffer.rbegin()->frameNum; }
 
    const std::vector<float> &getPose() { return m_targetInfo.pose25d; }
 
    void setPose25d(const float *ptr, const size_t length)
    {
        m_targetInfo.pose25d = std::vector<float>(ptr, ptr+length);
    }
 
    void setPose3d(const float *ptr, const size_t length) { m_targetInfo.pose3d = std::vector<float>(ptr, ptr+length); }
 
    void setObjModelProjector(std::shared_ptr<ObjectModelProjector> objModelProjector);
 
    std::shared_ptr<ObjectModelProjector> getObjModelProjector() { return m_objModelProjector; }
 
    bool isObjModelProjectorInitialized();
 
    void setBbox3D(const Eigen::Vector2d& pt_world_feet, NvDsObj3DBbox& bbox3DWorld, float (*bbox3DImg)[2]);
 
    const bool needTargetIDAssigned() { return m_needToSetTargetID; }
 
    void resetNeedTargetIDAssigned() { m_needToSetTargetID = false; }
 
    const bool ready4ReAssoc() { return m_ready4ReAssoc; }
 
    void resetReady4ReAssoc() { m_ready4ReAssoc = false; }
 
    const bool needToRemoveFromPendingReAssocDB() { return m_needToRemoveFromPendingReAssocDB; }
 
    void resetNeedToRemoveFromPendingReAssocDB() { m_needToRemoveFromPendingReAssocDB = false; }
 
    const bool getStateUseAspc() { return m_stateEstimator->useAspectRatio(); }
 
    void getReidFeaturesDet_h(const float **ptr, int &reidFeatureSize)
    {
        *ptr = m_reidFeaturesDet_h;
        reidFeatureSize = m_reidFeatureSize;
    }
 
    void setReidFeaturesDet_h(const float *ptr, int reidFeatureSize)
    {
        m_reidFeaturesDet_h = ptr; m_reidFeatureSize = reidFeatureSize;
        if (ptr && reidFeatureSize > 0) {
            m_persistentReidFeature.assign(ptr, ptr + reidFeatureSize);
        }
    }
 
    const std::vector<float>& getPersistentReidFeature() const { return m_persistentReidFeature; }
 
    float getTargetHeight() const
    {
        return (m_objModelProjector && m_objModelProjector->isInitialized())
            ? m_objModelProjector->getTargetHeight() : 1.6f;
    }
 
    float getHeightConfidence() const
    {
        return (m_objModelProjector && m_objModelProjector->isInitialized())
            ? m_objModelProjector->getHeightConfidence() : 0.f;
    }
 
    void setTargetHeight(float height, float confidence, bool force = false)
    {
        if (m_objModelProjector && m_objModelProjector->isInitialized()) {
            m_objModelProjector->setTargetHeight(height, confidence, force);
        }
    }
 
    float getMinPoseConfidence() const
    {
        return (m_objModelProjector && m_objModelProjector->isInitialized())
            ? m_objModelProjector->getMinPoseConfidence() : 0.5f;
    }
 
    Eigen::Matrix2d getLocCovariance() const
    {
        return m_stateEstimator->getMeasurementNoiseCovariance().block<2,2>(0,0);
    }
 
    bool usesProjectiveEstimator() const
    {
        return m_stateEstimator->getStateEstimatorType() == STATE_ESTIMATOR_TYPES::LOCATION_ESTIMATOR_PROJECTIVE;
    }
 
    bool hasBeenActive() const { return m_hasBeenActive; }
 
    const bool needToReAssocFromReidService() { return m_needToReAssocFromReidService; }
 
    void setNeedToReAssocFromReidService(const bool flag) { m_needToReAssocFromReidService = flag; }
 
    void resetNeedToReAssocFromReidService() { m_needToReAssocFromReidService = false; }
 
    const bool adoptedReidServiceID() { return m_adoptedReidServiceID; }
 
    void setAdoptedReidServiceID(const bool flag) { m_adoptedReidServiceID = flag; }
 
    const TargetId getTargetIDBeforeAdoption() { return m_targetIDBeforeAdoption; }
 
    void setTargetIDBeforeAdoption(const TargetId targetID) { m_targetIDBeforeAdoption = targetID; }
 
    const TargetId getTargetIDFromReidService() { return m_targetIDFromReidService; }
 
    void setTargetIDFromReidService(const TargetId targetID) { m_targetIDFromReidService = targetID; }
 
    void setReidServiceAssocResponse(const std::map<TargetId, reidServiceAssocInfo> reidServiceAssocResponseMap)
    {
        m_reidServiceAssocResponseMap = reidServiceAssocResponseMap;
    }
 
    const std::map<TargetId, reidServiceAssocInfo> &getReidServiceAssocResponse()
    {
        return m_reidServiceAssocResponseMap;
    }
 
    float getReidServiceMatchConfidence(const TargetId targetID)
    {
        return (
            m_reidServiceAssocResponseMap.find(targetID) != m_reidServiceAssocResponseMap.end()
                ? m_reidServiceAssocResponseMap.at(targetID).expConfidence : 0.0
        );
    }
protected:
 
    // [Configuration]
    const NvTrackerParamsTargetManager *m_params; 
    std::shared_ptr<ObjectModelProjector> m_objModelProjector; 
    const TrackerIndex m_targetInd; 
    TargetInfo m_targetInfo; 
 
    // [Multi-view association and fusion]
    std::atomic<TargetId> m_targetID; 
    std::atomic<TimeStamp> m_targetIDTimeStamp; 
    std::atomic<bool> m_becameActive; 
    bool m_hasBeenActive; 
    std::atomic<bool> m_acquiredID; 
    std::vector<PeerTarget> m_peerTargets; 
    MultiViewAssociatorParams m_multiViewParams; 
    NvMotDataTypes::Rect2f m_searchRegion; 
    NvMotDataTypes::Rect2f m_predictedSearchRegion; 
    NvMotDataTypes::Rect2f m_progBbox; 
    NvMOTMask m_maskOriginal; 
    bool m_needToSetTargetID; 
    bool m_ready4ReAssoc; 
    bool m_needToRemoveFromPendingReAssocDB; 
 
    // [Reassociation from ReID service]
    bool m_needToReAssocFromReidService; 
    TargetId m_targetIDFromReidService; 
    std::map<TargetId, reidServiceAssocInfo> m_reidServiceAssocResponseMap; 
    bool m_adoptedReidServiceID; 
    TargetId m_targetIDBeforeAdoption; 
 
    #ifdef VIZ_DEBUG
        cv::Scalar m_color; 
    #endif
 
    float m_peakCorrResp_long; 
    float m_peakCorrResp_short; 
    std::deque<TargetInfo> m_pastFrameDataBuffer; 
    std::list<TargetInfo> m_trajectoryBuffer; 
    int m_trajectorySkipInterval; 
    std::shared_ptr<IEstimator2> m_stateEstimator; 
    std::vector<std::tuple<Eigen::VectorXd, Eigen::Matrix2d, bool>> m_measList; 
    std::vector<float> m_confidenceCorrRespAtDetectedPts; 
    std::vector<float> m_corrRespAtDetectedPts; 
    std::vector<float> m_confidenceReidDets; 
    std::vector<std::vector<float>> m_confidenceListReidDets; 
    std::vector<int> m_confidenceReidDetsFrameNum; 
    std::vector<float> m_disMahalanobisDets; 
    const float *m_reidFeaturesDet_h; 
    int m_reidFeatureSize = 0; 
    std::vector<float> m_persistentReidFeature; 
 
    bool m_isOffline = false; 
 
    #ifdef VIZ_DEBUG
        friend class TrackerVizOutput;
    #endif
};
 
typedef std::map< std::shared_ptr<NvTrackedObject>, std::pair<std::shared_ptr<NvTrackedObject>, int> > FusedObjectList;
 
class NvTrackedObjectManager
{
public:
    NvTrackedObjectManager(const std::string &configFilePath);
 
    ~NvTrackedObjectManager();
 
    void initialize(const SourceFrameInfo &frameInfo);
 
    void queryParams(NvMOTQuery &paramsQuery);
 
    void updateInputInfo(const std::map<NvMOTStreamId, NvMOTFrame *> &inputMeta);
 
    void cleanPreviousBatchData();
 
    void updatePerStream(const assocDataOut_t& assocOut, const REID4REASSOC_STATE reid4reAssocState=NOT_NEEDED);
 
    void updateTargets();
 
    void updateTrajectoryManager();
 
    bool addStreamSubModules(
        const std::map<NvMOTStreamId, NvMOTFrame *> &inputMeta, const NvMotDataTypes::Size& srcImageSize
    );
 
    void recoverDefaultModelFromBbox(
        const NvMOTStreamId videoStreamId, const NvMOTFrameNum frameNum, DetectedObjInfo &detObjInfo
    );
 
    void updateParams(const YAML::Node &fn);
 
    void resetStream(const NvMOTStreamId videoStreamId);
 
    void resetAllStreams();
 
    void removeStream(const NvMOTStreamId videoStreamId);
 
    void removeAllStreams();
 
    std::map<NvMOTStreamId, std::deque<DetectedObjInfo>> generateTrackedObjects4Reid(
        const std::map<NvMOTStreamId, NvMOTFrame *> &inputMeta
    );
 
    bool isInitialized() { return m_isInit; }
 
    const std::map<NvMOTStreamId, std::shared_ptr<NvTrackedObjectList>> &getTrackedObjectsInUseList()
    {
        return m_TrackedObjectsInUse;
    }
 
    NvTrackedObjectList getTrackedObjectsInUseList(const NvMOTStreamId streamId);
 
    const std::map<NvMOTStreamId, std::vector<std::shared_ptr<NvTrackedObject>>> & \
        getTrackedObjectsTerminated() { return m_trackedObjectsTerminated; }
 
    const int getLastTargetInd() { return m_lastTrackerInd; }
 
    const float getTargetCapacityUtilization() { return m_targetCapacityUtilization; }
 
    const uint getMaxTargetsPerStream() { return m_params.m_maxTargetsPerStream; }
 
    const std::map<NvMOTStreamId, FusedObjectList> &getTrackedObjectsFused() { return m_trackedObjectsFused; }
 
    std::map<const NvMOTStreamId, std::shared_ptr<ObjectModelProjector>>& getObjModelProjectors()
    {
        return m_defaultModelProjectors;
    }
 
    const float getMinVisibility4TrajDump();
 
    const bool getDumpDetectorBboxes();
 
    const PeerTargetDB getPeerTargets(const NvMOTStreamId streamId);
 
    const std::shared_ptr<IMultiViewAssociator> getMultiViewAssociators(const NvMOTStreamId streamId)
    {
        if (m_multiViewAssociators.find(streamId) != m_multiViewAssociators.end())
        {
            return m_multiViewAssociators.at(streamId);
        }
        else
        {
            return nullptr;
        }
    };
 
    bool getOutputTerminatedTracks(const NvMOTStreamId streamId, std::list<TerminatedTrack>* & pTerminatedList)
    {
        if(m_terminatedTrackOutputMap_.find(streamId) != m_terminatedTrackOutputMap_.end())
        {
            pTerminatedList = &m_terminatedTrackOutputMap_[streamId];
            return true;
        }
        return false;
    }
 
    void clearOutputTerminatedTracks()
    {
        if(!m_params.m_saveTerminatedTracks)
        {
            return;
        }
 
        for( auto curStreamIter = m_terminatedTrackOutputMap_.begin(); curStreamIter != m_terminatedTrackOutputMap_.end(); curStreamIter++ )
        {
            std::list<TerminatedTrack> & curtermTrackList = curStreamIter->second;
            curtermTrackList.clear();
        }
    }
 
    void terminateTrackerPublic(
        const std::shared_ptr<NvTrackedObject> target, const TRACKER_DELETE_MODE deleteMode,
        const std::shared_ptr<NvTrackedObject> peer=nullptr
    )
    {
        terminateTracker(target, deleteMode, peer);
    }
 
    void dumpTerminatedTracks();
 
    void dumpIntermediateTargetInfo(const assocDataOut_t& assocOut);
 
    std::set<std::shared_ptr<NvTrackedObject>> & getShadowTracks(const NvMOTStreamId streamId)
    {
        return m_shadowTracks[streamId];
    }
 
    void clearShadowTracks() { m_shadowTracks.clear(); }
 
    void setSegmentationBatchInfo(SegmentationInBatch segInfo) { m_segInfo = segInfo; }
 
    const SegmentationInBatch &getSegmentationBatchInfo() { return m_segInfo; }
 
    NvTrackerParamsTargetManager m_params; 
    MultiViewAssociatorParams m_multiViewParams; 
 
    struct TM_Stats
    {
        std::atomic<uint64_t> term_reg_total{0}; 
        std::atomic<uint64_t> term_reg_was_active{0}; 
        std::atomic<uint64_t> term_reg_shadow_1{0}; 
        std::atomic<uint64_t> term_reg_shadow_2{0}; 
        std::atomic<uint64_t> term_reg_shadow_3{0}; 
        std::atomic<uint64_t> term_reg_shadow_4{0}; 
        std::atomic<uint64_t> term_reg_shadow_5{0}; 
        std::atomic<uint64_t> term_reg_shadow_6{0}; 
        std::atomic<uint64_t> term_reg_shadow_7{0}; 
        std::atomic<uint64_t> term_reg_shadow_8{0}; 
        std::atomic<uint64_t> term_reg_shadow_9plus{0}; 
        std::atomic<uint64_t> term_reg_young{0}; 
        std::atomic<uint64_t> term_reg_mature{0}; 
 
        // [Shadow rescues]
        std::atomic<uint64_t> shadow_rescue_6{0}; 
        std::atomic<uint64_t> shadow_rescue_7{0}; 
        std::atomic<uint64_t> shadow_rescue_8plus{0}; 
 
        // [TENTATIVE terminations]
        std::atomic<uint64_t> term_tent_total{0}; 
        std::atomic<uint64_t> term_tent_age_le2{0}; 
        std::atomic<uint64_t> term_tent_age_3_4{0}; 
        std::atomic<uint64_t> term_tent_age_5_7{0}; 
        std::atomic<uint64_t> term_tent_age_8_10{0}; 
        std::atomic<uint64_t> term_tent_age_11plus{0}; 
    } m_tm_stats;
 
protected:
 
    bool m_isInit; 
 
    // [Configuration]
    const std::string m_configFilePath; 
 
    // [Worker-thread shared state]
    std::mutex m_trackedObjectsLock; 
    NvTrackedObjectList m_TrackedObjectsInPool; 
    std::map<NvMOTStreamId, std::vector<std::shared_ptr<NvTrackedObject>>> m_trackedObjectsTerminated; 
    std::map<NvMOTStreamId, FusedObjectList> m_trackedObjectsFused; 
    std::map<NvMOTStreamId, assocDataOut_t> m_assocOuts; 
    int m_lastTrackerInd; 
    std::map<NvMOTStreamId, bool> m_isFileTerminatedDumpCreated; 
    std::map<NvMOTStreamId, std::ofstream> m_fileTerminatedDump; 
    std::map<NvMOTStreamId, std::ofstream> m_fileIntermediateDetDump; 
    std::map<NvMOTStreamId, std::ofstream> m_fileIntermediateTrackDump; 
    std::map<NvMOTStreamId, std::list<TerminatedTrack>> m_terminatedTrackOutputMap_; 
    std::map<NvMOTStreamId, std::set<std::shared_ptr<NvTrackedObject>>> m_shadowTracks; 
    std::map<NvMOTStreamId, std::shared_ptr<NvTrackedObjectList>> m_TrackedObjectsInUse; 
 
    float m_targetCapacityUtilization; 
    std::shared_ptr<NvTrajectoryManager> m_trajectoryManager; 
    std::map<const NvMOTStreamId, std::shared_ptr<ObjectModelProjector>> m_defaultModelProjectors; 
    SegmentationInBatch m_segInfo; 
    std::map<NvMOTStreamId, std::shared_ptr<IMultiViewAssociator>> m_multiViewAssociators; 
 
    void updateTargetsPerStream(const assocDataOut_t& assocOut);
 
    void updateMatched(
        const NvMOTStreamId videoStreamId, const NvMOTFrameNum frameNum,
        const std::deque<std::pair<const DetectedObjInfo *, TrackerIndex >> &matchedPairs
    );
 
    void updateUnMatched(
        const NvMOTStreamId videoStreamId, const NvMOTFrameNum frameNum, const std::set<TrackerIndex> &unmatchedTargets
    );
 
    void addTargetsBatch(
        const NvMOTStreamId videoStreamId, const NvMOTFrameNum frameNum,
        const std::map<const TrackerIndex, const DetectedObjInfo*> &unmatchedDetObjs
    );
 
    void addSeeThroughTargets(const NvMOTStreamId videoStreamId, const NvMOTFrameNum frameNum);
 
    bool addTarget(
        const NvMOTStreamId videoStreamId, const NvMOTFrameNum frameNum,
        const DetectedObjInfo *detObj, const PeerTarget *peerTarget=nullptr
    );
 
    void checkToTerminateTracker(const std::shared_ptr<NvTrackedObject> target);
 
    void terminateTracker(
        const std::shared_ptr<NvTrackedObject> target, const TRACKER_DELETE_MODE deleteMode,
        const std::shared_ptr<NvTrackedObject> peer=nullptr
    );
 
    virtual void updateTrajectoryManagerPerStream(const assocDataOut_t& assocOut);
 
    void updateTrajectoryBuffers(const NvMOTStreamId videoStreamId);
 
    void updateTargetCapacityUtilization();
 
    void saveShadowTrackInfo();
 
    void addTargetInShadowTrack(std::shared_ptr<NvTrackedObject> target);
 
    const std::string dumpAllTargetStates();
 
    TerminatedTrack createTerminatedTrack(const std::shared_ptr<NvTrackedObject> terminatedTarget);
 
    void removeStreamSubModules(const NvMOTStreamId videoStreamId);
 
    void createMultiViewAssociators();
 
    void addTerminatedTrackToBufferPerStream(TerminatedTrack& newTermTrack);
 
    uint getSizeTrackedObjectsInPool() const { return m_TrackedObjectsInPool.size(); }
 
    #ifdef VIZ_DEBUG
        friend class TrackerVizOutput;
    #endif
};
 
#endif // NVTRACKEDOBJECT_HPP_