sources/libs/nvmultiobjecttracker/include/modules/cuDCFv2/cuDCFFrameTransformTexture.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 cuDCFFrameTransform_HPP_
#define cuDCFFrameTransform_HPP_
 
#include "modules/FrameTransform/FrameTransform.hpp"
#include "modules/utility/dataTypes.hpp"
 
class cuDCFFrameTransformTexture : public FrameTransformTexture
{
public:
    cuDCFFrameTransformTexture();
 
    ~cuDCFFrameTransformTexture();
 
    void initialize(
        const int debugVerboseLevel, const int maxStreamNum, const int maxBufSurfAddrSize,
        const int maxTargetNum, const NvMotDataTypes::Size srcImgSize, const uint srcImgPitch,
        const NvBufSurfaceColorFormat colorFormatType, const NvMotDataTypes::Size dstImgSize,
        const bool needSecondaryScale = false, const float secondaryScaleFactor = 1.0
    );
 
    bool frameTransformInBatch(
        const std::map<NvMOTStreamId, std::vector<std::pair<uint, NvMotDataTypes::Rect2f> > > &roisInBatch,
        const uint lastBboxInd
    );
 
    bool frameTransformInBatch_NV12(
        const std::map<NvMOTStreamId, std::vector<std::pair<uint, NvMotDataTypes::Rect2f> > > &roisInBatch,
        const uint lastBboxInd, bool doMosaicing
    );
 
    void getOutputImagePatchPtrs(
        uint8_t* &dataPtr_d, uint &width, uint &height, uint2 &outBatchingGrid,
        uint &channels, uint &pitch, uint &imgNum, uint multiResInd
    );
 
    int getMultiResScaleNum() const { return m_multiResScaleNum; }
 
    uint2 getOutBatchingGrid() const { return m_outBatchingGrid; }
 
    bool isInitialized() const { return m_isInit; }
 
    #if defined(VIZ_DEBUG)
 
        const std::map<NvMOTStreamId, cv::Mat> &getSourceImagesAtHost() const
        {
            if(!m_frameInput)
            {
                throw std::runtime_error("frameInput is invalid");
            }
            const std::map<NvMOTStreamId, cv::Mat> & srcFramesAtHost = m_frameInput->getSrcFramesAtHost();
            if(srcFramesAtHost.size() == 0)
            {
                throw std::runtime_error("srcFramesAtHost is not prepared");
            }
            else
            {
                return srcFramesAtHost;
            }
        }
 
        std::map<NvMOTStreamId, std::map<uint, cv::Mat > > getImagePatches2Host_OCV_mosaic(uint multiResInd = 0);
 
        std::map<NvMOTStreamId, std::map<uint, cv::Mat > > getImagePatches2Host_OCV_batch(uint multiResInd = 0);
    #endif
 
private:
    void initialize4Output(const NvMotDataTypes::Size dstSize);
 
    void allocateOutputMemories();
 
    void deAllocateOutputMemories();
 
    bool m_isInit; 
    bool m_doMosaicing; 
 
    // [Output configuration specific to cuDCF]
    int m_width_out[CUDA_TEXTURE_MAX_MULTI_SCALE_NUM], m_height_out[CUDA_TEXTURE_MAX_MULTI_SCALE_NUM]; 
    uint2 m_outBatchingGrid; 
    int m_multiResScaleNum; 
    float m_multiResScaleFactors[CUDA_TEXTURE_MAX_MULTI_SCALE_NUM]; 
 
    // [Output memory specific to cuDCF]
    uint8_t* m_odataPL_d[CUDA_TEXTURE_MAX_MULTI_SCALE_NUM]; 
    size_t m_odataPL_d_pitch[CUDA_TEXTURE_MAX_MULTI_SCALE_NUM]; 
    uint8_t *m_odata_host[CUDA_TEXTURE_MAX_MULTI_SCALE_NUM]; 
};
 
#endif // cuDCFFrameTransform_HPP_