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

Go to the documentation of this file.

#ifndef FEATUREPLANEABSTRACT_H_INCLUDED
#define FEATUREPLANEABSTRACT_H_INCLUDED


class FeaturePlaneInput;

#include <vector>

#include <set>
#include <stdlib.h>
#include <string.h>
#include <QMutex>
#include <QSemaphore>

#include <QRunnable>
#include <QWaitCondition>
#include <QTextStream>
#include "common.h"
#include "nowarn.h"
#include "Observer.h"
#include "Viewable.h"
#include "Filter.h"
#include "OutputImage.h"
#include "FeaturePlaneHelpers.h"
#include "NotifyStrategyAbstract.h"
#include "Neuron.h"
#include "FPDesignerInfo.h"

typedef std::vector<FeaturePlaneInput*> PlaneInputs;

using namespace std;

class UI_NeuronTimeCourse;
class UI_FeaturePlane;

class NodeAbstract;
class NodeProxy;
class Neuron;
class Network;
class Layer;

#define DO_WTA (is_WTA &&  Network::doSTM_WTA)

class FeaturePlaneAbstract : public QRunnable, public Observer, public Viewable{
        friend class FeaturePlaneFactory;
        friend class ClientSocket;
        friend class UI_FeaturePlaneProp;
        friend class UI_FilterProp;
        friend class Network;
        friend class UI_DesignerPropDisplay;

public:
        ~FeaturePlaneAbstract();

        void run();

        void notify();
        void notify(bool functional);

        virtual void updateNN(Observer* sourceFP, bool functional);

        void attachProxy(NodeProxy* np);

        void addToHistory(OutputImage* tmpElement, set<OutputImage*>* tmpOutputHistory);

        void addToHistory(OutputImage* tmpElement, set<OutputImage*>* tmpOutputHistory, OutputImage **currOutput, QMutex *currOutputMutex);

        void emptyHistory( set<OutputImage*>* tmpOutputHistory);

        void StartThread();
        void PauseThread();

        void TerminateThread();

        void setName(QString* tmpName);
        double getDisplayScale();
        double getDisplayAngle();
        double getDisplayDelta();

        QString* getName();

        void setTheta(float t);

        void setLayerIndex(int l);

        int getLayerIndex();

        Layer* getLayer(int layerIndex);

        inline int getSpeeds(){return speeds;}
        inline int getSpeed(){return speed;}
        inline int getAngles(){return angles;}
        inline int getAngle(){return alpha;}

        void setFeatureBias(float tmpBias);
        float getFeatureBias();
        void setSpatialBias(Matrix * tmpSpatialBias);

        void setSpatialTaskBias(OutputImage* tmpSpatialBias);

        int getXSize();

        int getYSize();
        bool isWTA();

        virtual FeaturePlaneInput* addFilter(Filter* f, FeaturePlaneAbstract*fp, int type, int fpOutputIndex, bool wta){ return NULL;};
        virtual void editFeaturePlaneInput(FeaturePlaneInput *oldElement,FeaturePlaneInput *newElement) {};
        virtual void removeFeaturePlaneInput(FeaturePlaneInput *theElement) {};
        virtual void removeFeaturePlaneInput(FeaturePlaneAbstract *theElement) {};
        virtual void removeFeaturePlaneInputs() {};

        virtual OutputImage* getCurrentOutput(int index);
        OutputImage* getGatingControlOutput(int index);
        int getGatingControlOutputCount();
        int gatingControlInputCount;
        virtual void inhibitReturn();
        void initSelectiveTuning();
        Matrix* iorMap;

        virtual OutputImage* getCurrentOutput();

        OutputImage* getImage(){
                return getCurrentOutput();
        };

        Matrix* getMap(){
                return getGatingControl();
        }

        void releaseMap(){
                releaseGatingControl();
        }

        virtual PlaneInputs* getRegularInputList() {return NULL;}
        virtual PlaneInputs* getMaskingInputList() {return NULL;}
        virtual PlaneInputs* getNonFourierInputList() {return NULL;}
        virtual PlaneInputs* getGatingControlInputList() {return &gatingControlInputList;}
        virtual int getGatingControlInputListSize() {return gatingControlInputList.size();}
        virtual float getMaxActivation() {return 0.0f;}

        virtual bool isInputFP() {return false;}

        virtual Matrix* getGatingControl();
        virtual void releaseGatingControl();

        void setParameters(paramMap params);
        void XMLSerialize(int tabs, QTextStream *buf);

        int getID();

        void setNode(NodeAbstract* n);

        void setThreshold(float t);
        void setThresholdPercent(float t);
        void setThresholdBinarize(float t);

        void setFunction(pt2Function theFunction);

        static int getType(const QString name);
        static QString getType(int value);

        virtual bool moveHead(int deltaX, int deltaY, bool notify=true) {return true;} // InputControllerAbstract
        virtual void processTargetPlane() {} // InputControllerAbstract
        virtual OutputImage* getHeadImage(){return NULL;} //InputControllerAbstract
        virtual QImage* getVirtualImage(bool showRect){return NULL;} //InputVirtualFeaturePlane

        /**********************************************************************************************/


        // computation synchronization
        //    static bool useThreadSync;

        static QWaitCondition* workingThreadsCond;

        static QMutex workingThreadsMutex;
        static int currentLayer;
        static int workingThreads;
        static int totalWorkingThreads;

        int iterations;

        int fpType; // check the FP_ defines above

        NotifyStrategyAbstract* theNotifyStrategy; 
        Neuron* theNeuronStrategy; 

        FPDesignerInfo designerInfo; 

        //sort by layer predicate
        static bool CompareLayer(const FeaturePlaneAbstract* d1, const FeaturePlaneAbstract* d2){
                return d1->layerIndex < d2->layerIndex;
        }

        UI_FeaturePlane* fpViewerWindow;
        UI_NeuronTimeCourse* neuronTimeCourseWindow;

        void selectWinner(int selectX, int selectY);

private:
        QString* fpName;

        QVector<double> displayParameters;

protected:
        FeaturePlaneAbstract();

        FeaturePlaneAbstract( Network* net, int l, QString* n, int w, int h, int angles, int speeds, int alpha, int speed, bool isWTA, bool visible, NotifyStrategyAbstract* notify, Neuron* neuron=NULL);
        void init();

        Network* nn;
        int layerIndex;
        OutputImage* currentOutput;
        set<OutputImage*> outputHistory;
        QMutex currentOutputMutex;
        OutputImage** workOutputList;
        OutputImage** currentOutputList;
        OutputImage** currentGatingControlOutputList;
        int gatingControlOutputCount;
        QMutex currentOutputListMutex;
        QMutex gatingControlOutputListMutex;
        set<OutputImage*>** outputHistoryList;
        set<OutputImage*>** gatingControlHistoryList;   
        OutputImage* workOutput;

        QMutex gcMutex;
        PlaneInputs gatingControlInputList;
        OutputImage* theGatingControl;
        void createGatingControl();
        void applyGatingControl();

        int speeds;
        int angles;
        int speed;
        int alpha;

        int width, height;
        int outputs;
        int inputs;
        bool is_WTA;
        float theta;
        float threshold;
        float threshold_percent;
        float threshold_binarize;

        Matrix* spatialBias; //like alpha mask, only normalized 0-1
        float featureBias;

        int fpID;
        NodeAbstract* _parentNode;

        pt2Function functionCall; // the function that will be invoked once the current computation step is done
        paramMap initParams;
        void _XMLSerialize(int &tabs, QTextStream *buf, PlaneInputs* tmpList, int type);
        QMutex observerProxyMutex;
        list<NodeProxy*> _observersProxyList;   
};
#endif //FEATUREPLANEABSTRACT_H_INCLUDED