C:/Users/albertlr/projects/TarzaNN/TarzaNN/MatrixOfMatrix.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 MatrixOfMatrix_H_INCLUDED
#define MatrixOfMatrix_H_INCLUDED
#include <stdio.h>
#include <assert.h>
#include "Array2D.h"
#include <QApplication>
#include <QDataStream>
#include <QDebug>
#include <QProgressDialog>
#include <exception>
using namespace std;

template <typename T>
        class MatrixOfMatrix:public Array2D<T*>{
        protected:
    int filterWidth, filterHeight;
    int inputWidth, inputHeight;
    static void getMemorySize(int& row, int& total, int width, int height){
    }

public:
    MatrixOfMatrix( const uint32_t nXSize, const uint32_t nYSize, const uint32_t filterSizeX, const uint32_t filterSizeY, const uint32_t inputSizeX=0, const uint32_t inputSizeY=0)
        : Array2D<T*>(nXSize, nYSize), filterWidth(filterSizeX), filterHeight(filterSizeY),inputWidth(inputSizeX), inputHeight(inputSizeY){

        Array2D<T*>::memorySize= nXSize* nYSize*sizeof(T*);
        Array2D<T*>::data = calloc( 1, Array2D<T*>::memorySize+4);
        if (!Array2D<T*>::data){
            qDebug() << "Gating malloc error";
            exit(-ERROR_MATRIX_GATING_ERROR);
        }
        //              try{
        Array2D<T*>::rows= new T**[nYSize];
        //              }
        //              catch (std::bad_alloc&){
        //                      printf("Error allocating memory.\n");fflush(stdout);
        //                      exit(-1);
        //              }

        for (int i= 0; i<Array2D<T*>::height; i++)
            Array2D<T*>::rows[ i] = &(((T**)(Array2D<T*>::data))[i*Array2D<T*>::width]);

        for(int i=0; i<Array2D<T*>::height; i++)
            for(int j=0; j<Array2D<T*>::width; j++)
                (Array2D<T*>::rows[i])[j]= new T(filterSizeX, filterSizeY);
    }

    ~MatrixOfMatrix(){
        for(uint32_t i=0; i<Array2D<T*>::height; i++)
            for(uint32_t j=0; j<Array2D<T*>::width; j++)
                delete (Array2D<T*>::rows[i])[j];
    }

#ifdef __GNUC__
    __attribute__((always_inline))
#endif
            inline void setGU(uint32_t iuX, uint32_t iuY, uint32_t guX, uint32_t guY, float value){
        Array2D<float>* tempX=NULL;
        try {
            tempX=(*this)(iuX,iuY);
            (*tempX)(guX,guY)=value;
        }
        catch (...) {
            printf("%d %d %d %d %d %d\n", tempX->getXSize() , tempX->getYSize(), iuX, iuY, guX, guY);
            printf("EXCEPTION2\n");
            throw;
        }
    }

#ifdef __GNUC__
    __attribute__((always_inline))
#endif
            inline float getGU(uint32_t iuX, uint32_t iuY, uint32_t guX, uint32_t guY){
        Array2D<float>* tempX=(*this)(iuX,iuY);
        return (*tempX)(guX,guY);
    }
    //overloaded for more generic name
#ifdef __GNUC__
    __attribute__((always_inline))
#endif
            inline void set(uint32_t iuX, uint32_t iuY, uint32_t guX, uint32_t guY, float value){
        setGU( iuX, iuY, guX, guY, value);
    }
    //overloaded for more generic name
#ifdef __GNUC__
    __attribute__((always_inline))
#endif
            inline float get(uint32_t iuX, uint32_t iuY, uint32_t guX, uint32_t guY){
        return getGU( iuX, iuY, guX, guY);

    }

    uint32_t getInputWidth(){return inputWidth;}
    uint32_t getInputHeight(){return inputHeight;}
    uint32_t getFilterWidth(){return filterWidth;}
    uint32_t getFilterHeight(){return filterHeight;}
    void dump(){
        for(uint32_t i=0; i<Array2D<T*>::height; i++){
            for(uint32_t j=0; j<Array2D<T*>::width; j++){
                printf("FB or GU (%d, %d)\n", i,j);
                (Array2D<T*>::rows[i])[j]->printContent();
            }
        }
    }

    void save(QDataStream* outStream, QProgressDialog* progress, int* index){

        for(uint32_t i=0; i<Array2D<T*>::height; i++){
            for(uint32_t j=0; j<Array2D<T*>::width; j++){
                if(progress)
                    progress->setValue(++(*index));
                qApp->processEvents();
                (Array2D<T*>::rows[i])[j]->save(outStream);
            }
        }
    }

    void read(QDataStream* inStream, QProgressDialog* progress, int* index){

        for(uint32_t i=0; i<Array2D<T*>::height; i++){
            for(uint32_t j=0; j<Array2D<T*>::width; j++){
                progress->setValue(++(*index));
                qApp->processEvents();
                (Array2D<T*>::rows[i])[j]->read(inStream);
            }
        }
    }
};
#endif /*MatrixOfMatrix_H_INCLUDED*/