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

Go to the documentation of this file.

#ifndef NETWORK_H_INCLUDED
#define NETWORK_H_INCLUDED
#include <map>
#include <vector>

#include <QTextStream>
#include <QFile>
class FeaturePlaneAbstract;
class FeaturePlaneProxy;
class InputFeaturePlane;
class ConstantInputFeaturePlane;
class InputSocketFeaturePlane;
class InputVirtualFeaturePlane;
class LearningFeaturePlane;
class STSOMFeaturePlane;
class SOMFeaturePlane;

#include "Layer.h"
#include "Node.h"
#include "NodeProxy.h"

class Network;
class UI_MainWindow;
class Monitor;
typedef void (Network::*pt2Member)(QObject*, char*);

#ifdef PREDEFINED
enum{NN_XML, NN_2sand5s, NN_ACTIVE_VISION, NN_ROBOT_SOCKET, NN_ROBOT_VIRTUAL, NN_SPIKING, NN_NUM};
#endif /*PREDEFINED*/

using namespace std;

class Network {
public:

#ifdef PREDEFINED
        Network(UI_MainWindow *theMainWindow, QObject *app, int configurationNo, char* inputFileName=NULL);
#else
        Network(UI_MainWindow *theMainWindow, QObject *app, char* inputFileName=NULL);
#endif /*PREDEFINED*/

        ~Network();
        void run();
        void terminate();

        void save(QString filename);
        void load(char* inputFileName);

        void resetLayers();
        void assignLayers();

        void XMLSerialize(int tabs, QTextStream *buf);
        static void tabulate(int tabs, QTextStream *buf);

    static Network* theNetworkInstance;

        static Network* getNetwork(){
        return theNetworkInstance;
    }
        static void setNetwork(Network* nn){
        theNetworkInstance=nn;
    }

        FeaturePlaneAbstract* addFeaturePlane(QString* newName, QString newFPType, paramMap newParams, int l);
        FeaturePlaneAbstract* editFeaturePlane(FeaturePlaneAbstract* theOld, QString* newName, QString newFPType, paramMap newParams, int l);
        void deleteFeaturePlane(FeaturePlaneAbstract* oldFP);

        FeaturePlaneInput* addFeaturePlaneInput(FeaturePlaneAbstract *FPSource, FeaturePlaneAbstract *FPDest, QString newFType, paramMap newParams, int newInputType, int newOutputIndex);
        FeaturePlaneInput* editFeaturePlaneInput(FeaturePlaneInput* oldElement, QString newFType, paramMap newParams, int newInputType, int newOutputIndex);
        void deleteFeaturePlaneInput(FeaturePlaneInput* theElement);

        vector<NodeProxy*> _nodeList;
        vector<FeaturePlaneAbstract*> _featurePlaneList;
        vector<FeaturePlaneAbstract*>* _learningFeaturePlanes;
        vector<Layer*> _featurePlaneLayers;
        QMutex* _featurePlaneLayerMutex;
        QWaitCondition* _featurePlaneLayerCond;

        static bool useStepByStep;
        static bool useLayerByLayer;

        // simulation status -> pause, terminate
        static QWaitCondition pauseWaitCond;
        static QMutex threadStatus;
        static bool shouldPause;


        int addLayer(QString name, int dirs, int scales, int type = 0);
        void addToLayer(FeaturePlaneAbstract* cur, int count);
        void setMonitor(Monitor* m);
        Monitor* getMonitor();
        void setLearningOutputFP(LearningFeaturePlane* fp);
        LearningFeaturePlane* getLearningOutputFP();
        void setLearningWinner(Matrix* c);
        Matrix* getLearningWinner();
        FeaturePlaneAbstract* getInputFP();
        FeaturePlaneAbstract* getFPByName(QString searchName);

        void applyIOR();

        int getLayerCount();
        Layer* getLayer(int layerIndex){
                return _featurePlaneLayers[layerIndex];
        }

        int getDepth();

        void readLearningLayer();
        void readLearningLayer(QString s);
        void saveLearningLayer();
        void saveLearningLayer(QString s);

        UI_MainWindow* mainWindow;
        static bool doSTM_WTA;
        bool changed;

        bool isPaused(){return paused;}
        void setPaused(bool status){paused=status;}

        void notifyChangeDisplay();

        //*************************************************
        //** Executive controller
        //** might move to its own class at some point
        //*************************************************

#define THRESHOLD_PERCENT 0.5f
#define BIAS_PASS 1.0f
#define BIAS_INHIBIT 0.2f
#define BIAS_ZERO 0.0f

        void setupFeatureTask();
        void setupSpatialTask(OutputImage* tmpSpatialBias);




private:
        void nn_xml(QObject* app, char* inputFileName=NULL);

        void _editFeaturePlaneHelper1(FeaturePlaneAbstract *theOld, FeaturePlaneAbstract *theNew, PlaneInputs* inputList, int type);
        void _editFeaturePlaneHelper2(FeaturePlaneAbstract *theOld, FeaturePlaneAbstract *theNew, PlaneInputs* inputList);

        void replaceFP(FeaturePlaneAbstract *theOld, FeaturePlaneAbstract *theNew);
        void removeFilter(Filter* theF);
        void _replaceFilter(Filter* theOld, Filter* theNew, PlaneInputs* inputList);
        void replaceFilter(Filter* oldF, Filter* newF);

        void _replaceFPHelper1(FeaturePlaneAbstract *theOld, FeaturePlaneAbstract *theNew, PlaneInputs* inputList, int type);
        void _replaceFPHelper2(FeaturePlaneAbstract *theOld, FeaturePlaneAbstract *theNew, PlaneInputs* inputList);

        Monitor* theMonitor;
        Matrix* learningWinner;
        LearningFeaturePlane* learningOutputFP;

        void traverseNetwork();
        void traverseNetwork(FeaturePlaneAbstract* theFP, int layerIndex, vector<FeaturePlaneAbstract*>*visited);
        int depth;

        bool paused;

#ifdef PREDEFINED
        void nn_2sand5s(QObject* app, char* inputFileName=NULL);
        void nn_active_vision(QObject* app, char* inputFileName=NULL);
        void nn_spiking(QObject* app, char* inputFileName=NULL);
        void nn_robot_socket(QObject* app, char* inputFileName=NULL);
        void nn_robot_virtual(QObject* app, char* inputFileName=NULL);

        pt2Member function_table[NN_NUM];
#endif /*PREDEFINED*/

};
#endif //NETWORK_H_INCLUDED