datum.hpp

Go to the documentation of this file.

#ifndef OPENPOSE_CORE_DATUM_HPP
#define OPENPOSE_CORE_DATUM_HPP
 
#ifdef USE_3D_ADAM_MODEL
    #ifdef USE_EIGEN
        #include <Eigen/Core>
    #endif
#endif
#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 ------------------------------ //
        Matrix cvInputData;
 
        std::vector<Array<float>> inputNetData;
 
        Array<float> outputData;
 
        Matrix cvOutputData;
 
        Matrix cvOutputData3D;
 
        // ------------------------------ 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;
 
        Matrix cameraMatrix;
 
        Matrix cameraExtrinsics;
 
        Matrix cameraIntrinsics;
 
        Array<float> poseNetOutput;
 
        // ---------------------------------------- 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 (experimental code not meant to be publicly used)
        #ifdef USE_3D_ADAM_MODEL
            // 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
        #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 BASE_DATUM Datum
    #define BASE_DATUMS std::vector<std::shared_ptr<BASE_DATUM>>
    #define BASE_DATUMS_SH std::shared_ptr<BASE_DATUMS>
    #define DEFINE_TEMPLATE_DATUM(templateName) template class OP_API templateName<BASE_DATUMS_SH>
    #define COMPILE_TEMPLATE_DATUM(templateName) extern template class templateName<BASE_DATUMS_SH>
}
 
#endif // OPENPOSE_CORE_DATUM_HPP