layer.cpp

Go to the documentation of this file.

# include <layer.h>
# include <network.h>
# include <qglviewer.h>
# include <inn.h>
# include <interface.h>
# include <qfont.h>

extern Network * network ;
extern Inn * inn ;

Layer::Layer(int _id) {
   id = _id;
   neurons = new list<Neuron*>();
   frame_ = new ManipulatedFrame() ;
}

int Layer::getId() {
        return id;
}

list<Neuron*>* Layer::getNeurons() {
        return neurons;
}

int Layer::getNum() {
        return network->getLayerNumFromLayerId( id ) ;
}

Neuron* Layer::getNeuronFromId(int id_neur) {
        list<Neuron*>::iterator iter;
        for (iter = neurons->begin(); iter != neurons->end(); iter++)
                if ((*iter)->getId() == id_neur) return (*iter);
        return NULL;
}

void Layer::draw( int selected, const bool names ) {    
        if(network->displaylayers()) {
                Vec position = frame_->position() ;
                position.y = (float)getNum() ;
                frame_->setPosition( position ) ;
                if( selected != id ) glColor4f( 0.3, 0.3, 1.0, 0.3 ) ;
                else glColor4f( 1.0, 0.0, 1.0, 0.3 ) ;
                drawLayer( names ) ;
        }
}

void Layer::drawNeurons( int selected, const bool names ) {
        list<Neuron*>::iterator iter;
        for (iter = neurons->begin(); iter != neurons->end(); iter++)
                (*iter)->draw( selected, names ) ;
}

void Layer::drawLayer( const bool names ) {
        glEnable(GL_BLEND) ;
        if( names ) glPushName(id) ;
                glPushMatrix() ;
                        glMultMatrixd(frame_->matrix());
                        glRotatef( 90, 1.0, 0.0, 0.0 ) ; 
                        GLUquadricObj * qobj = gluNewQuadric() ;
                        gluQuadricDrawStyle( qobj, GLU_FILL ) ;
                        gluQuadricNormals( qobj, GLU_SMOOTH ) ;
                        gluDisk(qobj, 0.0, 2.5, network->shininess(), network->shininess()) ;
                        glColor4f( 1.0, 1.0, 0.0, 0.4 ) ;
                        glutSolidTorus( 0.05, 2.5, network->shininess(), network->shininess()) ;
                        glColor3ub( 200, 200, 200 ) ;
                glPopMatrix() ;
        if( names ) glPopName() ;
}

ManipulatedFrame * Layer::frame( int id ) {
        if( id == this->id ) return frame_ ;
        list<Neuron*>::iterator iter;
        for (iter = neurons->begin(); iter != neurons->end(); iter++)
        if ((*iter)->getId() == id) return (*iter)->frame() ;
    return NULL ;
}

int Layer::nbNeurons() {
        return neurons->size();
}

void Layer::addNeuron(int id) {
        /* Pour le wizard */
        Neuron *n = new Neuron(id);
        neurons->push_back(n);
        updateNeuronsPos() ;
}

void Layer::addNeuron(int id, float x, float z) {
        /* Pour le reste */
        Neuron *n = new Neuron(id);
        n->setX(x);
        n->setZ(z);
        neurons->push_back(n);
        //updateNeuronsPos();
}

void Layer::removeNeuron(int id) {
        bool found = false;
        list<Neuron*>::iterator iter = neurons->begin();
        while (iter != neurons->end() && !found) {
                if((*iter)->getId() == id) found = true;
                if (!found) iter++;
        }
        if (iter != neurons->end()) {
                (*iter)->removeAxons();
                neurons->erase(iter);
                delete (*iter);
        }
}

void Layer::removeNeurons() {
        list<Neuron*>::iterator iter;
        for (iter = neurons->begin(); iter != neurons->end(); iter++) {
                (*iter)->removeAxons();
                delete (*iter);
        }
        neurons->clear();
}

bool Layer::existNeuron(int id) {
        list<Neuron*>::iterator iter;
        for (iter = neurons->begin(); iter != neurons->end(); iter++)
                if ((*iter)->getId() == id) return true;
        return false;
}

void Layer::setNeuronsLinePos( int n, list<Neuron*>::iterator *iter, float z ) {
        int i;
        if (n==1) {
                Vec position ;
                position.x = 0.0;
                position.y = (float)this->getNum();
                position.z = z;
                (*(*iter))->frame()->setPosition( position );
        } else if( n>1 && (n%2)==0 ) {
                int nbL = n / 2;
                for (i = nbL; i > 0; i--) {
                        Vec position ;
                position.x = -((i*2)-1)*(2*network->neuronsize());
                position.y = (float)this->getNum() ;
                position.z = z ;
                (*(*iter))->frame()->setPosition( position ) ;
                (*iter)++;
                }
                for (i = 1; i <= nbL; i++) {
                        Vec position ;
                position.x = ((i*2)-1)*(2*network->neuronsize());
                position.y = (float)this->getNum() ;
                position.z = z ;
                (*(*iter))->frame()->setPosition( position ) ;
                (*iter)++;
                }
        } else if( n>1 && (n%2)!=0 ) {
                int nbL = n / 2;
                for (i = nbL; i > 0; i--) {
                        Vec position ;
                position.x = (-i*2)*(2*network->neuronsize());
                position.y = (float)this->getNum() ;
                position.z = z ;
                (*(*iter))->frame()->setPosition( position ) ;
                (*iter)++;
                }
                for (i = 0; i <= nbL; i++) {
                        Vec position ;
                position.x = (i*2)*(2*network->neuronsize());
                position.y = (float)this->getNum() ;
                position.z = z ;
                (*(*iter))->frame()->setPosition( position ) ;
                (*iter)++;
                }
        }
}

void Layer::updateNeuronsPos( void ) {
        int i;
        int n = neurons->size() ;
        int nbNeuronsPerLine = (int)ceil(sqrt((double)n));
        int nbFullLines = n / nbNeuronsPerLine;
        int nbNeuronsOnLastLine = n - (nbFullLines * nbNeuronsPerLine);
        int nbLines;
        if (nbNeuronsOnLastLine == 0)
                nbLines = nbFullLines; 
        else nbLines = nbFullLines + 1;
        list<Neuron*>::iterator iter = neurons->begin();
        int countLines = 0;
        
        if (nbLines == 1) {
                setNeuronsLinePos(n, &iter, 0.0);
        } else if (nbLines>1 && (nbLines%2)==0) {
                int nbF = nbLines / 2;
                for (i = nbF; i > 0; i--) {
                        countLines++;
                double z = ((i*2)-1)*(2*network->neuronsize());
                setNeuronsLinePos(nbNeuronsPerLine, &iter, z);
                }
                for (i = 1; i <= nbF; i++) {
                        countLines++;
                        double z = -((i*2)-1)*(2*network->neuronsize());
                        if (nbNeuronsOnLastLine != 0 && countLines == nbLines)
                                setNeuronsLinePos(nbNeuronsOnLastLine, &iter, z);
                else setNeuronsLinePos(nbNeuronsPerLine, &iter, z);
                }
        } else if( nbLines>1 && (nbLines%2)!=0 ) {
                int nbF = nbLines / 2;
                for (i = nbF; i > 0; i--) {
                        countLines++;
                        double z = (i*2)*(2*network->neuronsize());
                setNeuronsLinePos(nbNeuronsPerLine, &iter, z);
                }
                for (i = 0; i <= nbF; i++) {
                        countLines++;
                        double z = (-i*2)*(2*network->neuronsize());
                if (nbNeuronsOnLastLine != 0 && countLines == nbLines)
                        setNeuronsLinePos(nbNeuronsOnLastLine, &iter, z);
                else setNeuronsLinePos(nbNeuronsPerLine, &iter, z);
                }
        }
}

void Layer::clearAxons() {
        list<Neuron*>::iterator iter;
        for (iter = neurons->begin(); iter != neurons->end(); iter++)
                (*iter)->removeAxons();
}

void Layer::resetAllValues() {
        list<Neuron*>::iterator iter;
        for (iter = neurons->begin(); iter != neurons->end(); iter++) {
                (*iter)->setOutValue(0.0);
                (*iter)->setGradientValue(0.0);
                (*iter)->setOutValueTemp(0.0);
                (*iter)->setGradientValueTemp(0.0);
        }
}

void Layer::resetTempValues() {
        list<Neuron*>::iterator iter;
        for (iter = neurons->begin(); iter != neurons->end(); iter++) {
                (*iter)->setOutValueTemp(0.0);
                (*iter)->setGradientValueTemp(0.0);
        }
}

void Layer::forwardPropagation() {
        list<Neuron*>::iterator iter;
        for (iter = neurons->begin(); iter != neurons->end(); iter++)
                (*iter)->forwardPropagation();
}

void Layer::gradientBackPropagation() {
        list<Neuron*>::iterator iter;
        for (iter = neurons->begin(); iter != neurons->end(); iter++)
                (*iter)->gradientBackPropagation();
}

void Layer::description() {
        cout << "    Layer id =  " << id << " / Nb neurons = " << neurons->size() << endl;
}

---