C:/Users/albertlr/projects/TarzaNN/TarzaNN/Array2D.h

Go to the documentation of this file.

/****************************************************************************
**
** Copyright C 2002-2012 Laboratory for Active and Attentive Vision (LAAV), Department of Computer Science and Engineering, York University, Toronto, ON, Canada.
** All rights reserved.
**
** This file is part of the TarzaNN Neural Network Simulator.
**
** This file may be distributed and/or modified under the terms of the
** GNU General Public License version 2 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.
**
** See http://www.tarzann.org/gpl/ for GPL licensing information.
**
** Contact info@tarzann.org if any conditions of this licensing are
** not clear to you.
**
** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
**
****************************************************************************/

#ifndef ARRAY2D_H_INCLUDED
#define ARRAY2D_H_INCLUDED
#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <stdint.h>

#include <QDebug>

//#include <execinfo.h>

#include "common.h"


enum
{
        kvImageNoFlags          =       0,
        kvImageLeaveAlphaUnchanged      =       1,      /* Operate on red, green and blue channels only. Alpha is copied from source to destination. For Interleaved formats only. */
        kvImageCopyInPlace              =       2,      /* Copy edge pixels */
        kvImageBackgroundColorFill      =       4,      /* Use the background color for missing pixels */
        kvImageEdgeExtend               =       8,      /* Extend border data elements */
        kvImageDoNotTile                =       16,     /* Pass to turn off internal tiling. Use this if you want to do your own tiling, or to use the Min/Max filters in place. */
        kvImageHighQualityResampling =  32      /* Use a higher quality, slower resampling filter for Geometry operations (shear, scale, rotate, affine transform, etc.) */
};

template <typename T>
class Array2D{
protected:


        /* Pointer to the top left pixel of the buffer.    */
        void* data;
        /* The height (in pixels) of the buffer        */
        uint32_t height;
        uint32_t width;
        /* The number of bytes in a pixel row        */
        uint32_t rowBytes;

        T** rows;

        uint32_t memorySize;

        Array2D(){
                data=NULL;
                width=-1;
                height=-1;
                rowBytes=-1;
                rows=NULL;
                memorySize=-1;
        }

public:
        Array2D( const int nXSize, const int nYSize){
                data=NULL;
                width=nXSize;
                height=nYSize;
                rowBytes=-1;
                rows=NULL;
                memorySize=-1;
        }

        ~Array2D(){
                free(data);
                free(rows);
        }


#ifdef __GNUC__
        __attribute__((always_inline))
#endif
                inline T& operator()(uint32_t col, uint32_t row){
                        //if(col>=width || row>=height || col<0 || row<0){
                        //      printf("ACCESS ERROR1 (%d %d) (%d %d)\n",col, row,width, height);

                        //      void* callstack[128];
                        //      int i, frames = backtrace(callstack, 128);
                        //      char** strs = backtrace_symbols(callstack, frames);
                        //      for (i = 0; i < frames; ++i) {
                        //              printf("%s\n", strs[i]);
                        //      }
                        //      free(strs);             
                        //      testfunc();
                        //                              
                        //}     //--EUGENE

                        T* temp=rows[row];
                        return temp[col];
        }

#ifdef __GNUC__
        __attribute__((always_inline)) 
#endif
                inline T operator()(uint32_t col, uint32_t row) const{
                        /*if(col>=width || row>=height || col<0 || row<0){
                        printf("ACCESS ERROR2 (%d %d) (%d %d)\n",col, row,width, height);

                        void* callstack[128];
                        int i, frames = backtrace(callstack, 128);
                        char** strs = backtrace_symbols(callstack, frames);
                        for (i = 0; i < frames; ++i) {
                        printf("%s\n", strs[i]);
                        }
                        free(strs);                     
                        testfunc();
                        }*/     //EUGENE
                        T* temp=rows[row];
                        return (temp)[col];
        }

        const uint32_t getXSize(){
                return width;
        }

        const uint32_t getYSize(){
                return height;
        }

        void testfunc(){
                printf("testfunc");
        }

        void init(){            
                rowBytes =width* sizeof(T);
                //Widen rowBytes out to a integer multiple of 16 bytes
                rowBytes = (rowBytes + 15) & ~15;
                //Make sure we are not an even power of 2 wide.
                //Will loop a few times for rowBytes <= 16.
                while( 0 == (rowBytes & (rowBytes - 1) ) )
                        rowBytes += 16; //grow rowBytes
                memorySize = rowBytes * height;
                //Set up the buffer
                data = calloc( 1, memorySize+4);

                if (!data){
                        qDebug() << "Matrix malloc error" << ERROR_LOCATION;
                        exit(-ERROR_MATRIX_ALLOC_ERROR);
                }

                rows=(T**)calloc(1, height*sizeof(T*));
                for (uint32_t i= 0; i<height; i++){
                        rows[ i] = &(((T*)(data))[i*rowBytes/sizeof(T)]);
                }
        }

};
#endif /*ARRAY2D_H_INCLUDED*/