C:/Users/albertlr/projects/TarzaNN/TarzaNN/common.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 COMMON_H_INCLUDED
#define COMMON_H_INCLUDED

#define ERROR_LOCATION " (" << __FILE__ << ":" <<  __LINE__ << ")"
#define NOT_IMPLEMENTED qDebug() << "!!!ERROR: NOT IMPLEMENTED"  << ERROR_LOCATION;
#define FILE_LINE_ERROR printf("!!!ERROR: NOT IMPLEMENTED in file %s, line %i  \n",__FILE__,__LINE__)
#define INVALID_FUNCTION_CALL printf("!!!ERROR: INVALID FUNCTION CALL in file %s, line %i  \n",__FILE__,__LINE__)
#define PI 3.1415926

#if  defined(__i386__) && defined(__APPLE__)
#define MAC_OS_INTEL
#endif

#include <QHash>
#include <QMap>
#include <QMapIterator>
#include <QString>
#include <QPair>
#include "UI_Message.h"

#ifdef __APPLE__
#include "GLUT/glut.h"
#endif

using namespace std;

#define PERMANENT_GU

#define ST_CONVOLVE

/****************** DEFINED TYPES **************************************/
// Important
// each enum type has two static variables associated with it in common class
// every time you make changes (add / edit /remove) reflect the changes in common.cpp in the
// appropriate place !

typedef enum  {LAYER_DEFAULT=0, LAYER_MOTION=1} LayerTypes;

typedef enum  {FP_NOT_INITIALIZED=0, FP_DEFAULT=1, FP_INPUT=2, FP_INPUT_CONTROLLER=4, FP_INPUT_SOCKET=5, FP_INPUT_VIRTUAL=6, FP_INPUT_CONST=8, FP_INPUT_MULTIPLE=10, FP_PROXY=16, FP_MOTION=32, FP_MG_MOTION=64, FP_BP_LEARNING=128, FP_SOM_LEARNING=130, FP_STSOM_LEARNING=131, FP_CTSOM_LEARNING=132, FP_INPUT_LEARNING=256, FP_HISTOGRAM=512, FP_SALIENCY=513, FP_SALIENCYOUTPUT = 514, FP_FHM = 515, FP_INPUTCAMERA = 516, FP_INPUT_TASK=1024 } FPTypes;
// it is important that we maintain the number convention for FP_INPUT_*, 'cause there are some bitwise operations that depend on it
//note - I think this is obsolete (or at least not used anywhere except for UI_FeaturePlane.cpp for FP_INPUT_CONTROLLER, where it could be replaced with simple comparison)

enum {F_G=100, F_DOG=101, F_W=102, F_DOUBLEW=103, F_RETINAL=104, F_DEFAULT=105, F_LOG=106, F_FILE=107, F_AVG=107, F_IDENTITY=108, F_HISTOGRAM=109, F_RECT=110, F_RANDOM=111}; 

enum {INPUT_TYPE_REGULAR=200, INPUT_TYPE_MASKING=201, INPUT_TYPE_NON_FOURIER=202, INPUT_TYPE_GATING_CONTROL=203, INPUT_TYPE_ERROR=204};

//enum {NONE_PROXY=300, RECEIVER_PROXY=301, SENDER_PROXY=302}; // feature plane proxy

enum {NEURON_TYPE_SIGMOID=400, NEURON_TYPE_SPIKING=401, NEURON_TYPE_GENERIC=402, NEURON_TYPE_WILSON_COWAN=403, NEURON_TYPE_LINEAR_SIGMOID=404, NEURON_TYPE_TANH=405, NEURON_TYPE_LINEAR=406, NEURON_TYPE_ST=407 }; //neuron abstract

enum {SYNC_TYPE_SYNC=500, SYNC_TYPE_ASYNC=501}; // NotifyStrategyAbstract

enum { ERROR_NONE, 
        ERROR_EMPTY_OP_ARGUMENT, 
        ERROR_NO_FILTER_DEF_FOUND, 
        ERROR_MATRIX_ALLOC_ERROR, 
        ERROR_MATRIX_GATING_ERROR, 
        ERROR_INVALID_NEURON_TYPE,
        ERROR_INVALID_SYNC_TYPE,
        ERROR_INVALID_INPUT_POSITION,
    ERROR_INVALID_INPUT_CATEGORY,
    ERROR_IFP_FOUND,
        ERROR_HISTOGRAM,
        ERROR_CAMERA};

//typedef QMap<myOrderedString, QString> paramMap;
typedef QMap<QString, QString> paramMap;
typedef QMap< int,QString> enumMap;
typedef QMapIterator< int,QString> enumMapIterator;

class common {
public:
        static QStringList layerTypeList;
        static QStringList featurePlaneTypeList;
        static QStringList filterTypeList;
        static QStringList proxyTypeList;
        static QStringList neuronTypeList;
        static QStringList neuronInputTypeList;
        static QStringList syncTypeList;
        static QStringList boolTypeList;
        
        static enumMap layerTypes;
        static enumMap featurePlaneTypes;
        static enumMap filterTypes;
        static enumMap proxyTypes;
        static enumMap neuronTypes;
        static enumMap neuronInputTypes;
        static enumMap syncTypes;
        
        
        static void initializeTypes();
        static QString  getType(enumMap* theList, int value);
        static int getType(enumMap* theList, const QString & name);     
        
private:
        static void setupTypeList(enumMap* theMap, QStringList *theList);
};

/*activate to get predefined networks*/
/*OLD code, not maintained*/
//#define PREDEFINED

#define VISIBLE true
#define NOT_VISIBLE false
#define IS_WTA true
#define NOT_WTA false

// ******************** SVD *********************************************
// the following defines are for the functions below, used by svd - from numerical methods
#define ROUND(_AA) ((_AA) > 0 ? (uint32_t)((_AA)+0.5) : (uint32_t)((_AA)-0.5)) 
#define SIGN(_AA,_BB) (((_BB)>0)?fabs(_AA):(-1)*fabs(_AA))
#define FMAX(_AA,_BB) (((_AA)>(_BB))?(_AA):(_BB))
#define FMIN(_AA,_BB) (((_AA)<(_BB))?(_AA):(_BB))
#define IMIN(_AA,_BB) (((_AA)<(_BB))?(_AA):(_BB))
#define SQR(_AA) ((_AA)*(_AA))
#define IN_RANGE(A,LOWER,UPPER) (((A)>=(LOWER)) && ((A) <= (UPPER)))
#define PYTHAGORA(X,Y) sqrt((double)((X)*(X)+(Y)*(Y)))
#define DIST(X1,Y1,X2,Y2) sqrt((double)(((X1)-(X2))*((X1)-(X2)) + ((Y1)-(Y2))*((Y1)-(Y2))))


// **************** TRACE *********************************************
#define TRACE_THREADING 5
#define TRACE_MACRO

#ifndef TRACE_LEVEL
#define TRACE_LEVEL 1
#endif /*TRACE_LEVEL*/

#ifdef TRACE_MACRO
#define TRACE(LEVEL,X) ((LEVEL) > TRACE_LEVEL) ? printf(""); : X
#else
#define TRACE(LEVEL,X) ;
#endif

// **************** OPEN GL ERROR *********************************************
#define OPENGL_ERROR {int e=GL_NO_ERROR;\
        e=glGetError();\
        if(e!=GL_NO_ERROR){\
                printf("OPEN GL ERROR  %s (%s line %i)\n", gluErrorString(e),__FILE__,__LINE__);fflush(stdout);}\
}

// *************** Clear vector of pointers ***********
 template <class Vector>
  void clearPtrVector(Vector &a)
  {
    for(size_t i = 0; i < a.size(); i++)
         delete a[i];

    a.clear();
  }


// *************** BIG ENDIAN LITTLE ENDIAN HELPER FUNCTIONS ***********
int networkToHost(int value);
void networkToHost(char *data,int length);
int hostToNetwork(int value);
void hostToNetwork(char *data,int length);

#if defined(Q_WS_X11) || defined(Q_WS_WIN)
#define HTON(X,Y) hostToNetwork((X),(Y));
#define NTOH(X,Y) networkToHost((X),(Y));
#else
#define HTON(X,Y) ;
#define NTOH(X,Y) ;
#endif

// ************** PLATFORM SPECIFIC **********************************
#ifdef WIN32
#define FILE_DELIM '\\'
#define SLEEP(X) Sleep(X)
#include <windows.h>
#elif defined __linux__
#include <unistd.h>
#define FILE_DELIM '/'
#define SLEEP(X) usleep(1000*X)
#else
#define FILE_DELIM '/'
#define SLEEP(X) sleep(X)
#endif/*Q_OS_WIN*/

#endif /*COMMON_H_INCLUDED*/