array.hpp

Go to the documentation of this file.

#ifndef OPENPOSE_CORE_ARRAY_HPP
#define OPENPOSE_CORE_ARRAY_HPP

#include <memory> // std::shared_ptr
#include <vector>
#include <opencv2/core/core.hpp> // cv::Mat
#include <openpose/core/macros.hpp>

namespace op
{
    template<typename T>
    class Array
    {
    public:
        // ------------------------------ Constructors and Data Allocator Functions ------------------------------ //
        explicit Array(const int size);

        explicit Array(const std::vector<int>& sizes = {});

        Array(const int size, const T value);

        Array(const std::vector<int>& sizes, const T value);

        Array<T>(const Array<T>& array);

        Array<T>& operator=(const Array<T>& array);

        Array<T>(Array<T>&& array);

        Array<T>& operator=(Array<T>&& array);

        Array<T> clone() const;

        void reset(const int size);

        void reset(const std::vector<int>& sizes = {});

        void reset(const int size, const T value);

        void reset(const std::vector<int>& sizes, const T value);

        void setFrom(const cv::Mat& cvMat);

        void setTo(const T value);



        // ------------------------------ Data Information Functions ------------------------------ //
        inline bool empty() const
        {
            return (mVolume == 0);
        }

        inline std::vector<int> getSize() const
        {
            return mSize;
        }

        std::string printSize() const;

        int getSize(const int index) const;

        inline size_t getNumberDimensions() const
        {
            return mSize.size();
        }

        inline size_t getVolume() const
        {
            return mVolume;
        }

        size_t getVolume(const int indexA, const int indexB) const;



        // ------------------------------ Data Access Functions And Operators ------------------------------ //
        inline T* getPtr()
        {
            return spData.get();
        }

        inline const T* getConstPtr() const
        {
            return spData.get();
        }

        const cv::Mat& getConstCvMat() const;

        cv::Mat& getCvMat();

        inline T& operator[](const int index)
        {
            #ifdef NDEBUG
                return spData.get()[index];
            #else
                return at(index);
            #endif
        }

        inline const T& operator[](const int index) const
        {
            #ifdef NDEBUG
                return spData.get()[index];
            #else
                return at(index);
            #endif
        }

        inline T& operator[](const std::vector<int>& indexes)
        {
            return operator[](getIndex(indexes));
        }

        inline const T& operator[](const std::vector<int>& indexes) const
        {
            return operator[](getIndex(indexes));
        }

        inline T& at(const int index)
        {
            return commonAt(index);
        }

        inline const T& at(const int index) const
        {
            return commonAt(index);
        }

        inline T& at(const std::vector<int>& indexes)
        {
            return at(getIndexAndCheck(indexes));
        }

        inline const T& at(const std::vector<int>& indexes) const
        {
            return at(getIndexAndCheck(indexes));
        }

        const std::string toString() const;

    private:
        std::vector<int> mSize;
        size_t mVolume;
        std::shared_ptr<T> spData;
        std::pair<bool, cv::Mat> mCvMatData;

        int getIndex(const std::vector<int>& indexes) const;

        int getIndexAndCheck(const std::vector<int>& indexes) const;

        T& commonAt(const int index) const;

        void setCvMatFromSharedPtr();
    };

    // Static methods
    OVERLOAD_C_OUT(Array)
}

#endif // OPENPOSE_CORE_ARRAY_HPP