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

Go to the documentation of this file.

#ifndef STSOMFeaturePlane_H_INCLUDED
#define STSOMFeaturePlane_H_INCLUDED

#include  <qimage.h>

#include "nowarn.h"
#include "common.h"
#include <stdlib.h>

#include "OutputImage.h"
#include "LearningFeaturePlane.h"
#include "FilterBank.h"
#include "PlaneInputWindowSet.h"
#include "MatrixOfMatrix.h"

//#define LISSOM


class STSOMFeaturePlane : public LearningFeaturePlane {
        friend class GatingUnits;
        friend class FeaturePlaneFactory;
public:
    ~STSOMFeaturePlane();
        void read(QDataStream* inStream, QProgressDialog* progress, int* index);

        void save(QDataStream* outStream, QProgressDialog* progress, int* index);
        bool isLearning();
        
    FeaturePlaneInput* addFilter(Filter* f, FeaturePlaneAbstract*fp, int type, int fpOutputIndex, bool wta);
        void incWinCount(){
                winCount++;
        }
        int getWinCount(){
                return winCount;
        }

protected:
        
        STSOMFeaturePlane( Network* net, int l, QString* name, int w, int h, int angles, int speeds, int alpha, int speed, bool isWTA, bool visible, Neuron* neuron, NotifyStrategyAbstract* notify, bool learning);
        void step();
        
        float nonlinearity(Matrix* totalActivation, OutputImage* workOutput);
    void computeGatingUnits(); 
    
    //Total activation, to compute lateral contributions
    Matrix* getTotalActivation();
    //lateral interaction converged?
    bool hasConverged(){
        return isConverged;
    }

private:
        static const char* FilterFileName;
        static const char* EFilterFileName;
        static const char* IFilterFileName;
    static const char* DumpFileName;

        vector<RandomFilter*> theInputFilters;
        vector<RandomFilter*> excitatoryFilters;
        vector<RandomFilter*> inhibitoryFilters;
        void saveFilters(int step);

    int winCount;
        int stepCount;

    bool isInputSameAsLast();

#ifndef LISSOM
    QPoint lastWinner;
    Matrix* decision;
#endif


    //synchronize execution within layer
        void sync();
    static int localProgressThreads;
    static QWaitCondition localProgressCond;
    static QMutex localProgressMutex;

    //lateral interaction converged?
    bool isConverged;

        void learn();
        void learn(uint32_t x, uint32_t y);
        void updateWeights(RandomFilter* theFilter, Matrix* input, float alpha, uint32_t x, uint32_t y);
        void updateWeightsLateral(RandomFilter* theFilter, Matrix* input, float alpha, uint32_t x, uint32_t y);

    void addLateralContribution(Filter* filter, Matrix* currentOtherFPActivation, Matrix* workActivation, float factor, bool sameFP);
    void applyLateralInhibition(Matrix* workActivation);

    float alpha();
        static float surround(int step);
};
#endif //STSOMFeaturePlane_H_INCLUDED