sources/libs/nvmultiobjecttracker/include/modules/ReIDService/ReIDService.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: Copyright (c) 2025-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 REIDSERVICE_HPP_
#define REIDSERVICE_HPP_
 
#include <deque>
#include <map>
#include "modules/ReIDService/IReIDService.hpp"
#include <curl/curl.h>
 
class ReIDServiceConfigParams : public NvTrackerParams
{
public:
    ReIDServiceConfigParams();
 
    ReIDServiceConfigParams(const std::string &configFilePath, const std::string moduleName);
 
    ReIDServiceConfigParams(const YAML::Node &fn);
 
    void read(const YAML::Node &fn) override;
 
    REID_SERVICE_TYPES m_reidServiceType; 
    int m_debugVerboseLevel; 
    bool m_enableBlocking; 
    float m_minTopClusterConfidence; 
    float m_minSecondClusterConfidence; 
    float m_maxClusterVariance; 
    int m_topK; 
    int m_maxGroupCount; 
    float m_minVisibility4ReidServiceQuery; 
    std::string m_serviceAddress; 
    int m_servicePort; 
    std::vector<int> m_operateOnClassIds; 
    bool m_enableIDCorrection; 
    int m_minAssociationCount4IDCorrection; 
    float m_maxIou4IDCorrection; 
    int m_maxInFlightRequests; 
    int m_curlConnectTimeout; 
    int m_curlRequestTimeout; 
};
 
struct remoteTargetInfo
{
    NvMOTStreamId streamId; 
    TrackerIndex targetIndex; 
    TargetId originalTargetID; 
    TargetId remoteTargetID; 
    bool validRemoteTargetID; 
    std::map<TargetId, reidServiceAssocInfo> reidServiceAssocResponseMap; 
};
 
struct CurlRequestTargetInfo {
    NvMOTStreamId streamId; 
    TrackerIndex targetIndex; 
    TargetId targetID; 
    std::string jsonPayload; 
    std::string response; 
    struct curl_slist *headers = nullptr; 
};
 
class ReIDService: public IReIDService
{
public:
    ReIDService(const std::string &configFilePath);
 
    virtual ~ReIDService();
 
    void initialize(
        const SourceFrameInfo &frameInfo, const uint maxTargetsPerStream,
        const std::shared_ptr<NvTrackedObjectManager> &targetManager
    ) override;
 
    void queryParams(NvMOTQuery &paramsQuery);
 
    void query(const std::map<NvMOTStreamId, NvMOTFrame *> &inputMeta) override;
 
    void updateTargetIDs() override;
 
    const REID_SERVICE_TYPES getReIDServiceType() override {return m_params.m_reidServiceType; }
 
protected:
    bool m_isInit; 
    ReIDServiceConfigParams m_params; 
    std::shared_ptr<NvTrackedObjectManager> m_targetManager; 
    std::map<CURL*, CurlRequestTargetInfo> m_curlRequestInfoMap; 
    CURLM *m_curlMultiHandle; 
    std::string m_curlRequestUrl; 
 
    // [Thread-related variables]
    std::thread m_workerThread; 
    std::atomic<bool> m_persistThreadRunning; 
    std::mutex m_inputLock; 
    std::condition_variable m_cond4In; 
    std::queue<CurlRequestTargetInfo> m_inputQueue; 
 
    void workerThread();
 
    std::mutex m_outputLock; 
    std::condition_variable m_cond4Out; 
    std::queue<remoteTargetInfo> m_outputQueue; 
    std::atomic<uint32_t> m_submittedReqCnt; 
    std::atomic<uint32_t> m_finishedReqCnt; 
 
    void waitToFinish();
 
    // [ID correction]
    std::map<NvMOTStreamId, std::map<TargetId, std::pair<TargetId, int>>> m_idCorrectionMap; 
 
    bool tryIDCorrection(
        const std::shared_ptr<NvTrackedObject> targetToBeCorrected,
        const std::shared_ptr<NvTrackedObject> existingTarget, TargetId associatedTargetID
    );
 
    std::string convertReidFeaturesToJson(const float* reidFeatures, int reidFeatureSize);
 
    std::string send_post_request(const std::string& jsonPayload);
 
    remoteTargetInfo parseResponseForTargetID(const std::string& response);
 
    bool appendCurlRequest(const CurlRequestTargetInfo &curlRequestInfoInput);
 
    void processCompletedCurlRequest(CURLMsg *msg);
};
 
#endif // REIDSERVICE_HPP_