HeartRate.h

Go to the documentation of this file.

/*###############################################################################
#
# Copyright(c) 2021 NVIDIA CORPORATION. All Rights Reserved.
#
# NVIDIA CORPORATION and its licensors retain all intellectual property
# and proprietary rights in and to this software, related documentation
# and any modifications thereto. Any use, reproduction, disclosure or
# distribution of this software and related documentation without an express
# license agreement from NVIDIA CORPORATION is strictly prohibited.
#
###############################################################################*/
 
#ifndef CVCORE_HEARTRATE_H_
#define CVCORE_HEARTRATE_H_
 
#include <memory>
 
#include <cuda_runtime.h>
 
#include <cv/core/Model.h>
#include <cv/core/Array.h>
#include <cv/core/Tensor.h>
#include <cv/core/BBox.h>
 
namespace cvcore { namespace heartrate {
 
class HeartRate 
{
    public:
        static const ImagePreProcessingParams defaultPreProcessorParams;
 
        static const ModelInputParams defaultModelInputParams;
 
        static const ModelInferenceParams defaultInferenceParams;
 
        struct HeartRateParams
        {
            std::size_t cameraFps;          // FPS of the camera to map heart rate to time
            std::size_t heartRateMax;       // Maximum valid heart rate
            std::size_t heartRateMin;       // Minimum valid heart rate
            std::size_t estimationInterval; // The minimum number of seconds of inference 
                                            //     points to caluclate FFT heart rate
            std::size_t warmUpInterval;     // The minimum number of seconds of inferemence 
                                            //     samples to begin calculation
            std::size_t fftWindow;          // The size of the FFT lookback
            std::int32_t roiSnrThresh;      // The minimum SNR on the FFT window
            std::size_t maxConfidence;      // Maximum clamp confidence of the the inference
            std::size_t minConfidence;      // Minimum FFT confidence to provide a heart rate
            std::size_t validFpsGap;        // Maximum time variation in heart rate estimates
            float iouThresh;                // IoU threshold for determining if a persistent 
                                            //     object is present in frame
        };
        static const HeartRateParams defaultExtraParams;
 
 
        HeartRate() = delete;
 
        HeartRate(const ImagePreProcessingParams & preProcessorParams, 
                  const ModelInputParams & modelInputParams,
                  const ModelInferenceParams & inferenceParams,
                  const HeartRateParams & extraParams);
 
        ~HeartRate();
 
        void execute(Array<float> & heartRate,
                     const Tensor<NCHW, C3, U8> & faceImage,
                     const Array<BBox> & faceBBox,
                     cudaStream_t stream = 0);
        
        void execute(Array<float> & heartRate,
                     const Tensor<NHWC, C3, U8> & faceImage,
                     const Array<BBox> & faceBBox,
                     cudaStream_t stream = 0);
 
    private:
        struct HeartRateImpl;
 
        std::unique_ptr<HeartRateImpl> m_pImpl;
};
 
class HeartRatePreProcessor 
{
    public:
        HeartRatePreProcessor() = delete;
 
        HeartRatePreProcessor(const ImagePreProcessingParams & preProcessorParams, 
                              const ModelInputParams & modelInputParams,
                              const HeartRate::HeartRateParams & extraParams);
 
        ~HeartRatePreProcessor();
 
        void execute(Tensor<NCHW, C3, F32> & preProcessedFaceImage,
                     Tensor<NCHW, C3, F32> & preProcessedFaceMotion,
                     Array<bool> & entityInFrame,
                     const Tensor<NCHW, C3, U8> & faceImage,
                     const Array<BBox> & faceBBox,
                     cudaStream_t stream = 0);
 
        void execute(Tensor<NCHW, C3, F32> & preProcessedFaceImage,
                     Tensor<NCHW, C3, F32> & preProcessedFaceMotion,
                     Array<bool> & entityInFrame,
                     const Tensor<NHWC, C3, U8> & faceImage,
                     const Array<BBox> & faceBBox,
                     cudaStream_t stream = 0);
 
    private:
        struct HeartRatePreProcessorImpl;
 
        std::unique_ptr<HeartRatePreProcessorImpl> m_pImpl;
};
 
class HeartRatePostProcessor 
{
    public:
        HeartRatePostProcessor() = delete;
 
        HeartRatePostProcessor(const ModelInputParams & modelInputParams,
                               const HeartRate::HeartRateParams & extraParams);
 
        ~HeartRatePostProcessor();
 
        void execute(Array<float> & heartRate,
                     const Tensor<CL, CX, F32> & rawHeartRate,
                     const Array<bool> & entityInFrame,
                     cudaStream_t stream = 0);
 
    private:
        struct HeartRatePostProcessorImpl;
 
        std::unique_ptr<HeartRatePostProcessorImpl> m_pImpl;
};
 
}} // namespace cvcore::heartrate
 
#endif // CVCORE_HEARTRATE_H_