C:/Users/albertlr/projects/TarzaNN/TarzaNN/Matrix.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 MATRIX_H_INCLUDED
#define MATRIX_H_INCLUDED
#include <stdio.h>
#include <assert.h>
#include <vector>
using namespace std;
#include "common.h"

#include "Array2D.h"

class Matrix :  public Array2D<float>{
        typedef  int (Matrix::*ChangeOp)(int x, int y);
protected:
        void serialize(char* buf);
        Matrix( char* buf);
        Matrix( QString fileName, int fileType);
        int getSendSize();
        void createKernel(float* kernel);

        bool created;
        Matrix( );

public:         
        Matrix( const int nXSize, const int nYSize);
        Matrix( const Matrix& matrix); 

        Matrix& operator = ( const Matrix& matrix);
        Matrix& copyData ( const Matrix& matrix);

        void* getImage();

        void* getImageCopy(uint32_t* x, uint32_t* y, uint32_t* size, void* p);

        bool isZero();
        QPoint* getNonZero();
        inline void setValue(float value){
                uint32_t i,j;

                for (j= 0; j<height; j++)
                        for (i= 0; i<width; i++)
                                (*this)(i,j)= value;
        }
        inline void setZero(){
                memset( data, 0, memorySize);
        }
        inline void setOne(){
                memset( data, 1, memorySize);
        }
        void multiplyScalar(float item);
        void addScalar(float item);
        void addMatrix(Matrix* input);
        bool equals(Matrix* input);
        bool equals(Matrix* input, int tol);
        void subtractMatrix(Matrix* input);
        void dotSquare();
        void punch_out(int window);
        void circularMask();

        void clamp(float the_value);
        void applyGatingControl(Matrix* theGatingControl);
        void applyIOR(Matrix* theIORMap);

        void applyThreshold(float the_value);
        void applyThresholdBinarize(float the_value);
        void applyThresholdAndMark(float value, Matrix* gc);
        void setPixels(unsigned char* data);
        void setPixels(int* data);
        void downsample(Matrix* input);
        void downsample_skip(Matrix* input);
        void upsample(Matrix* input);
        void upsample_skip(Matrix* input, float fill=0);
        void resample(Matrix* input, bool skip=false, float fill=0);
        float average();
        void setZeroMean();
        void setOneSum();
        void normalize(float scale);
        void printContent(); //debug function
        void printContentMap(); //debug function
        void save(QDataStream* outStream);
        void read(QDataStream* inStream);
        void saveActivations(char* filename);
        QImage* toSTMQImage(int max=255);

        void scaleValues(float minScaleValue, float maxScaleValue); //rescales the values within those boundaries

        void dotProduct(Matrix *otherMatrix);
        void rectangleCopy(uint32_t r_w, uint32_t r_h, uint32_t x1,uint32_t y1, Matrix* otherMatrix, uint32_t o_x1, uint32_t o_y1);
        void shift(int dx, int dy, int fillOption=0);
        void rectangleFill(uint32_t x, uint32_t y, uint32_t w, uint32_t h, float theValue);

        inline float sumAll(){
                float sum = 0;
                uint32_t i,j;

                for (j= 0; j<height; j++)
                        for (i= 0; i<width; i++)
                                sum += (*this)(i,j);
                return sum;
        }

        inline float sumAllPositive(){
                float sum = 0;
                uint32_t i,j;

                for (j= 0; j<height; j++)
                        for (i= 0; i<width; i++)
                                if((*this)(i,j)>0)
                                        sum += (*this)(i,j);
                return sum;
        }

        inline float getMaxValue(){
                float maxValue = (float)((float*)(data))[0];
                uint32_t i,j;

                for (j= 0; j<height; j++)
                        for (i= 0; i<width; i++)
                                if ((*this)(i,j)>maxValue)
                                        maxValue = (*this)(i,j);
                return maxValue;
        }


        float getMinValue();
        float sumAllAbsolute();
        void addNoise();

        QPoint* getMaxCoords();
    QPoint* getMaxCoordsSpiral();


        /*UTILITIES */
        inline int changeBrightnessOp( int value, int brightness );
        inline int changeContrastOp( int value, int contrast );
        inline int changeGammaOp( int value, int gamma );
        inline int changeUsingTable( int value, const int table[] );    
        QImage changeImage( ChangeOp changeOp, const QImage& image, int value );
        QImage changeBrightness( const QImage& image, int brightness );
        QImage changeContrast( const QImage& image, int contrast );
        QImage changeGamma( const QImage& image, int gamma );

};
typedef vector<Matrix*> MatrixVector;
#endif /*MATRIX_H_DEFINED*/