datum.hpp

Go to the documentation of this file.

#ifndef OPENPOSE_CORE_DATUM_HPP
#define OPENPOSE_CORE_DATUM_HPP

#ifdef USE_EIGEN
    #include <Eigen/Core>
#endif
#include <opencv2/core/core.hpp> // cv::Mat
#include <openpose/core/common.hpp>

namespace op
{
    struct OP_API Datum
    {
        // ---------------------------------------- ID parameters ---------------------------------------- //
        unsigned long long id; 
        unsigned long long subId; 
        unsigned long long subIdMax; 
        std::string name;

        unsigned long long frameNumber;

        // ------------------------------ Input image and rendered version parameters ------------------------------ //
        cv::Mat cvInputData;

        std::vector<Array<float>> inputNetData;

        Array<float> outputData;

        cv::Mat cvOutputData;

        // ------------------------------ Resulting Array<float> data parameters ------------------------------ //
        Array<float> poseKeypoints;

        Array<long long> poseIds;

        Array<float> poseScores;

        Array<float> poseHeatMaps;

        std::vector<std::vector<std::array<float,3>>> poseCandidates;

        std::vector<Rectangle<float>> faceRectangles;

        Array<float> faceKeypoints;

        Array<float> faceHeatMaps;

        std::vector<std::array<Rectangle<float>, 2>> handRectangles;

        std::array<Array<float>, 2> handKeypoints;

        std::array<Array<float>, 2> handHeatMaps;

        // ---------------------------------------- 3-D Reconstruction parameters ---------------------------------------- //
        Array<float> poseKeypoints3D;

        Array<float> faceKeypoints3D;

        std::array<Array<float>, 2> handKeypoints3D;

        cv::Mat cameraMatrix;

        cv::Mat cameraExtrinsics;

        cv::Mat cameraIntrinsics;

        // ---------------------------------------- Other (internal) parameters ---------------------------------------- //
        std::vector<double> scaleInputToNetInputs;

        std::vector<Point<int>> netInputSizes;

        double scaleInputToOutput;

        Point<int> netOutputSize;

        double scaleNetToOutput;

        std::pair<int, std::string> elementRendered;

        // 3D/Adam parameters
        // Adam/Unity params
        std::vector<double> adamPosePtr;
        int adamPoseRows;
        std::vector<double> adamTranslationPtr;
        std::vector<double> vtVecPtr;
        int vtVecRows;
        std::vector<double> j0VecPtr;
        int j0VecRows;
        std::vector<double> adamFaceCoeffsExpPtr;
        int adamFaceCoeffsExpRows;
        #ifdef USE_EIGEN
            // Adam/Unity params
            Eigen::Matrix<double, 62, 3, Eigen::RowMajor> adamPose;
            Eigen::Vector3d adamTranslation;
            // Adam params (Jacobians)
            Eigen::Matrix<double, Eigen::Dynamic, 1> vtVec;
            Eigen::Matrix<double, Eigen::Dynamic, 1> j0Vec;
            Eigen::VectorXd adamFaceCoeffsExp;
        #endif





        // ---------------------------------------- Functions ---------------------------------------- //
        explicit Datum();

        Datum(const Datum& datum);

        Datum& operator=(const Datum& datum);

        Datum(Datum&& datum);

        Datum& operator=(Datum&& datum);

        virtual ~Datum();

        Datum clone() const;





        // ---------------------------------------- Comparison operators ---------------------------------------- //
        inline bool operator<(const Datum& datum) const
        {
            // return id < datum.id;
            return id < datum.id || (id == datum.id && subId < datum.subId);
        }
        inline bool operator>(const Datum& datum) const
        {
            // return id > datum.id;
            return id > datum.id || (id == datum.id && subId > datum.subId);
        }
        inline bool operator<=(const Datum& datum) const
        {
            // return id <= datum.id;
            return id < datum.id || (id == datum.id && subId <= datum.subId);
        }
        inline bool operator>=(const Datum& datum) const
        {
            // return id >= datum.id;
            return id > datum.id || (id == datum.id && subId >= datum.subId);
        }
        inline bool operator==(const Datum& datum) const
        {
            // return id == datum.id;
            return id == datum.id && subId == datum.subId;
        }
        inline bool operator!=(const Datum& datum) const
        {
            // return id != datum.id;
            return id != datum.id || subId != datum.subId;
        }
    };

    // Defines for Datum. Added here rather than in `macros.hpp` to avoid circular dependencies
    #define DATUM_BASE_NO_PTR std::vector<Datum>
    #define DATUM_BASE std::shared_ptr<DATUM_BASE_NO_PTR>
    #define DEFINE_TEMPLATE_DATUM(templateName) template class OP_API templateName<DATUM_BASE>
    #define COMPILE_TEMPLATE_DATUM(templateName) extern DEFINE_TEMPLATE_DATUM(templateName)
}

#endif // OPENPOSE_CORE_DATUM_HPP