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 <openpose/core/macros.hpp>
#include <openpose/core/matrix.hpp>
#include <openpose/utilities/errorAndLog.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(const int size, T* const dataPtr);
 
        Array(const std::vector<int>& sizes, T* const dataPtr);
 
        Array(const Array<T>& array, const int index, const bool noCopy = false);
 
        template<typename T2>
        Array(const Array<T2>& array) :
            Array{array.getSize()}
        {
            try
            {
                // Copy
                for (auto i = 0u ; i < array.getVolume() ; i++)
                    pData[i] = T(array[i]);
            }
            catch (const std::exception& e)
            {
                error(e.what(), __LINE__, __FUNCTION__, __FILE__);
            }
        }
 
        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 reset(const int size, T* const dataPtr);
 
        void reset(const std::vector<int>& sizes, T* const dataPtr);
 
        void setFrom(const Matrix& cvMat);
 
        void setTo(const T value);
 
 
 
        // ------------------------------ Data Information Functions ------------------------------ //
        inline bool empty() const
        {
            return (mVolume == 0);
        }
 
        inline std::vector<int> getSize() const
        {
            return mSize;
        }
 
        int getSize(const int index) const;
 
        std::string printSize() 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 = -1) const;
 
        std::vector<int> getStride() const;
 
        int getStride(const int index) const;
 
 
 
        // ------------------------------ Data Access Functions And Operators ------------------------------ //
        inline T* getPtr()
        {
            return pData; // spData.get()
        }
 
        inline const T* getConstPtr() const
        {
            return pData; // spData.get()
        }
 
        inline T* getPseudoConstPtr() const
        {
            return pData; // spData.get()
        }
 
        const Matrix& getConstCvMat() const;
 
        Matrix& getCvMat();
 
        inline T& operator[](const int index)
        {
            #ifdef NDEBUG
                return pData[index]; // spData.get()[index]
            #else
                return at(index);
            #endif
        }
 
        inline const T& operator[](const int index) const
        {
            #ifdef NDEBUG
                return pData[index]; // 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;
        T* pData; // pData is a wrapper of spData. Used for Pybind11 binding.
        std::pair<bool, Matrix> mCvMatData;
 
        int getIndex(const std::vector<int>& indexes) const;
 
        int getIndexAndCheck(const std::vector<int>& indexes) const;
 
        T& commonAt(const int index) const;
 
        void resetAuxiliary(const std::vector<int>& sizes, T* const dataPtr = nullptr);
    };
 
    // Static methods
    OVERLOAD_C_OUT(Array)
}
 
#endif // OPENPOSE_CORE_ARRAY_HPP