NeuronGroup.h

Go to the documentation of this file.

#ifndef NEURONGROUP_H
#define NEURONGROUP_H

//SpikeStream includes
#include "Box.h"
#include "NeuronGroupInfo.h"
#include "Neuron.h"
using namespace spikestream;

//Qt includes
#include <stdint.h>
#include <QMap>

typedef QHash<unsigned int, Neuron*> NeuronMap;

typedef QMap<uint64_t, Neuron*>::iterator NeuronPositionIterator;

typedef NeuronMap::iterator NeuronIterator;

namespace spikestream {

    class NeuronGroup {
                public:
                        NeuronGroup(const NeuronGroupInfo& info);
                        ~NeuronGroup();
                        void addLayer(int width, int height, int xPos, int yPos, int zPos);
                        Neuron* addNeuron(float xPos, float yPos, float zPos);
                        NeuronMap::iterator begin() { return neuronMap->begin(); }
                        NeuronMap::iterator end() { return neuronMap->end(); }
                        NeuronPositionIterator positionBegin();
                        NeuronPositionIterator positionEnd();
                        void buildPositionMap();
                        void clearNeurons();
                        bool contains(unsigned int neurID);
                        bool contains(unsigned int neurID, float x, float y, float z);
                        Box getBoundingBox();
                        unsigned int getID();
                        NeuronGroupInfo getInfo() {return info;}
                        Neuron* getNearestNeuron(const Point3D& point);
                        unsigned int getNeuronIDAtLocation(const Point3D& location);
                        QList<unsigned int> getNeuronIDs() { return neuronMap->keys(); }
                        Point3D& getNeuronLocation(unsigned int neuronID);
                        NeuronMap* getNeuronMap() { return neuronMap; }
                        QList<Neuron*> getNeurons(const Box& box);
                        unsigned getNeuronTypeID();
                        double getParameter(const QString& key);
                        QHash<QString, double> getParameters() { return parameterMap; }
                        static Point3D getPointFromPositionKey(uint64_t positionKey);
                        static uint64_t getPositionKey(int xPos, int yPos, int zPos);
                        unsigned int getStartNeuronID() { return startNeuronID; }
                        bool isWeightless();
                        bool parametersSet();
                        void print();
                        void setID(unsigned int id);
                        void setDescription(const QString& description);
                        void setName(const QString& name);
                        void setNeuronMap(NeuronMap* newMap);
                        void setParameters(QHash<QString, double>& paramMap);
                        void setStartNeuronID(unsigned int id) { this->startNeuronID = id; }
                        int size();


                private:
                        //==========================  VARIABLES  =========================
                        NeuronGroupInfo info;

                        NeuronMap* neuronMap;

                        QMap<uint64_t, Neuron*> neuronPositionMap;

                        bool positionMapBuilt;

                        unsigned int startNeuronID;

                        QHash<QString, double> parameterMap;

                        Box boundingBox;

                        bool calculateBoundingBox;

                        static unsigned neuronIDCounter;


                        //====================  METHODS  ==========================
                        unsigned getTemporaryID();
                        void neuronGroupChanged();
                        NeuronGroup(const NeuronGroup& connGrp);
                        NeuronGroup& operator=(const NeuronGroup& rhs);
    };

}

#endif//NEURONGROUP_H