tnmcube.h

 
//                                                                         // 
//  Header file of template of class nmmtr                                //
//                                                                         //
#ifndef _TCUBE_H_INCLUDED_
#define _TCUBE_H_INCLUDED_
 
#include "crtdbg.h"
//#ifdef __cplusplus
 
 
//#include "tmatrix.h"
#include <string.h>
    
 
 
template<class T> class tmtr
{
protected:
    T*  m_container;
public:
    int m_stride;
    int m_height, m_width;
    T  *m_data;
 
    tmtr(tmtr<T>& mtr)
    {
        m_stride = mtr.m_stride;
        m_height = mtr.m_height;
        m_width = mtr.m_width;
        
        m_container = new T[m_height*m_stride];
        m_data = m_container;
        memcpy(m_data, mtr.m_data, m_height*m_stride);
    }
 
 
    // constructor
    //explicit 
    tmtr(int nHeight, int nWidth, int nStride = 0) :m_height(nHeight), m_width(nWidth)
    {
 
 
        nStride == 0? m_stride = nWidth: m_stride = nStride;
        m_container = new T[m_height*m_stride];
        m_data = m_container;
    }
    //explicit
    tmtr(T* Data, int nHeight, int nWidth, int nStride=0) :m_data(Data), m_height(nHeight), m_width(nWidth)
    {
        nStride == 0 ? m_stride = m_width : m_stride = nStride;
        _ASSERTE(m_stride >= m_width);
        m_container = 0;
    };
 
    T* ref(int y, int x) {
        return m_data + y*m_stride + x;
    }
    ~tmtr()
    {
        if (m_container)
            delete m_container;
    }
 
    inline T* operator[](int row) const
    {
 
        //_ASSERTE(row < m_height + PADDING);
        //_ASSERTE(row >= -PADDING);
        return m_data + row*m_stride;
    }
    void fill(T& value) {
        T* p = m_data;
        for (int y = 0; y< m_height; y++, p += m_stride)
            for (int x = 0; x<m_width; x++)
                p[x] = value;
    }
};
 
//
// Class of nmmtres
//
 
 
    //--------------------------------------------------------------------
 
    //--------------------------------------------------------------------
    //--------------------------------------------------------------------
 
template<class T> class tcube
{
protected:
    T*      m_container;
public:
    int     m_height;
    int     m_width;
    int     m_depth;
    int     m_ystride;
    int     m_wstride;
    int     m_cstride;
    T*      m_data;
 
    
    tcube(tcube<T>& cube) 
    {
        m_height= cube.m_height;
        m_width= cube.m_width;
        m_depth= cube.m_depth;
        m_ystride= cube.m_ystride;
        m_wstride= cube.m_wstride;
        m_cstride= cube.m_cstride;
 
        m_container = new T[m_height*m_ystride];
        m_data = m_container;
        memcpy(m_data, cube.m_data, m_height*m_ystride);
    }
 
    explicit 
    tcube(int Height, int Width, int Depth, int WStride=0, int CStride=0):m_height(Height), m_width(Width), m_depth(Depth)
    {
        WStride == 0 ? m_wstride = m_width: m_wstride=WStride;
        CStride == 0 ? m_cstride = m_depth: m_cstride=CStride;
        _ASSERTE(m_width<=m_wstride);
        m_ystride = m_cstride*m_wstride;
        m_container=new T[m_height*m_ystride];
        m_data=m_container;
    }
 
    explicit 
    tcube(T* data, int Height, int Width, int Depth, int WStride = 0, int CStride = 0) :m_data (data), m_height(Height), m_width(Width), m_depth(Depth)
    {
        WStride == 0 ? m_wstride = m_width : m_wstride = WStride;
        CStride == 0 ? m_cstride = m_depth : m_cstride = CStride;
        m_ystride = m_cstride*m_wstride;
        m_container = 0;
    }
    tcube<T>& operator =(tcube<T>& cube) {
        _ASSERTE(cube.m_height == m_height);
        _ASSERTE(cube.m_width == m_width);
        _ASSERTE(cube.m_depth == m_depth);
        for (int y = 0; y < m_height; y++)
            for (int x = 0; x < m_width; x++)
                for (int c = 0; c < m_depth; c++)
                    (*this)[y][x][c] = cube[y][x][c];
 
        return *this;
    }
    inline tmtr<T> operator [](int y) const
    {
        //_ASSERTE(y>=-PADDING);
        //_ASSERTE(y<m_height+PADDING);
        return tmtr<T>(m_data+y*m_ystride, m_width, m_depth, m_cstride);
    }
    ~tcube() 
    {   
        if (m_container) {
            _ASSERTE(m_container != (T*)-1);
            delete m_container;
            m_container = (T*)-1;
        }
 
    }
    inline T* data() {
        return m_data;
    }
    
    void printChannel(int ch) {
        
        char str[32];
        int maxlen = 0;
        for (int h = 0; h < m_height; h++) {
            for (int w = 0; w < m_width; w++) {
                float v = (*this)[h][w][ch];
                sprintf(str, "%.2f ", v);
                int len = strlen(str);
                if (len>maxlen)
                    maxlen = len;
            }
        }
 
        char spaces[] = "          ";
        for (int h = 0; h < m_height; h++) {
            for (int w = 0; w < m_width; w++) {
                float v = (*this)[h][w][ch];
                sprintf(str, "%.2f ", v);
                int len = strlen(str);
                //strncat(str,spaces,maxlen-len);
                printf(spaces + 10 - (maxlen - len));
                printf(str);
            }
            printf("\n");
        }
 
    }
 
 
    void fill(T value)
    {
        T* layer = m_data;
        for (int y = 0; y < m_height; y++, layer += m_ystride) {
            tmtr<float> mtr(layer, m_width, m_depth, m_cstride);
            mtr.fill(value);
        }
 
    }
};
 
#endif