experiments/src/neuroninterfaces.cpp

/********************************************************************************
 *  FARSA Experiments Library                                                   *
 *  Copyright (C) 2007-2012                                                     *
 *  Gianluca Massera <emmegian@yahoo.it>                                        *
 *  Stefano Nolfi <stefano.nolfi@istc.cnr.it>                                   *
 *  Tomassino Ferrauto <tomassino.ferrauto@istc.cnr.it>                         *
 *                                                                              *
 *  This program is free software; you can redistribute it and/or modify        *
 *  it under the terms of the GNU General Public License as published by        *
 *  the Free Software Foundation; either version 2 of the License, or           *
 *  (at your option) any later version.                                         *
 *                                                                              *
 *  This program is distributed in the hope that it will be useful,             *
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of              *
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the               *
 *  GNU General Public License for more details.                                *
 *                                                                              *
 *  You should have received a copy of the GNU General Public License           *
 *  along with this program; if not, write to the Free Software                 *
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA  *
 ********************************************************************************/

#include "neuroninterfaces.h"
#include "evonet.h"
#include "configurationhelper.h"
#include "logger.h"

namespace farsa {

Sensor::Sensor( ConfigurationParameters& params, QString prefix ) :
    ParameterSettableInConstructor(params, prefix),
    allNeededResourcesExist(false)
{
    setName( ConfigurationHelper::getString( params, prefix+"name", "unnamed" ) );
}

Sensor::~Sensor() {
}

void Sensor::save( ConfigurationParameters& params, QString prefix ) {
    params.startObjectParameters( prefix, "Sensor", this );
    // if Sensor name startsWith "Sensor:" means that the name has been
    // configured by EvoRobotExperiment automatically
    if ( sensorName != "unnamed" || !sensorName.startsWith("Sensor:") ) {
        params.createParameter( prefix, "name", sensorName );
    }
}

void Sensor::describe( QString type ) {
    Descriptor d = addTypeDescription( type, "Base class for all Sensors" );
    d.describeString( "name" ).help( "The name of the sensor" );
}

QString Sensor::name() {
    return sensorName;
}

void Sensor::setName( QString name ) {
    sensorName = name;
}

void Sensor::checkAllNeededResourcesExist() {
    if (allNeededResourcesExist) {
        return;
    }

    // We do the check only if allNeededResourcesExist is false, if it is true we already did the
    // check and we will be notified when a resource gets deleted
    QStringList nonExistingResources;
    if (!usedResourcesExist(&nonExistingResources)) {
        ConfigurationHelper::throwUserMissingResourceError(nonExistingResources.join(", "), "Some required resource do not exist, cannot use " + sensorName + " anymore");
    }

    allNeededResourcesExist = true;
}

void Sensor::resetNeededResourcesCheck()
{
    allNeededResourcesExist = false;
}

Motor::Motor( ConfigurationParameters& params, QString prefix ) :
    ParameterSettableInConstructor(params, prefix),
    allNeededResourcesExist(false)
{
    setName( ConfigurationHelper::getString( params, prefix+"name", "unnamed" ) );
}

Motor::~Motor() {
}

void Motor::save( ConfigurationParameters& params, QString prefix ) {
    params.startObjectParameters( prefix, "Motor", this );
    // if Motor name startsWith "Motor:" means that the name has been
    // configured by EvoRobotExperiment automatically
    if ( motorName != "unnamed" || !motorName.startsWith("Motor:") ) {
        params.createParameter( prefix, "name", motorName );
    }
}

void Motor::describe( QString type ) {
    Descriptor d = addTypeDescription( type, "Base class for all Motors" );
    d.describeString( "name" ).help( "The name of the motor" );
}

QString Motor::name() {
    return motorName;
}

void Motor::setName( QString name ) {
    motorName = name;
}

void Motor::checkAllNeededResourcesExist() {
    if (allNeededResourcesExist) {
        return;
    }

    // We do the check only if allNeededResourcesExist is false, if it is true we already did the
    // check and we will be notified when a resource gets deleted
    QStringList nonExistingResources;
    if (!usedResourcesExist(&nonExistingResources)) {
        ConfigurationHelper::throwUserMissingResourceError(nonExistingResources.join(", "), "Some required resource do not exist, cannot use " + motorName + " anymore");
    }

    allNeededResourcesExist = true;
}

void Motor::resetNeededResourcesCheck()
{
    allNeededResourcesExist = false;
}

EvonetIterator::EvonetIterator() :
    blocks(),
    currLayer(InputLayer),
    currStartIndex(-1),
    currEndIndex(0),
    currIndex(0),
    evonet(NULL) {
}

EvonetIterator::~EvonetIterator() {
    /* nothing to do */
}

void EvonetIterator::setEvonet( Evonet* evonet ) {
    this->evonet = evonet;
    blocks.clear();
    currStartIndex = -1;
    currEndIndex = 0;
    currIndex = 0;
}

void EvonetIterator::defineBlock( QString name, layer_t layer, int startIndex, int size ) {
    BlockInfo binfo;
    binfo.layer = layer;
    binfo.startIndex = startIndex;
    binfo.endIndex = startIndex + size;
    blocks[name] = binfo;
}

bool EvonetIterator::setCurrentBlock( QString blockName ) {
    if ( !blocks.contains( blockName ) ) {
        Logger::error( QString("EvonetIterator - the block %1 does not exist").arg(blockName) );
        return false;
    }
    BlockInfo binfo = blocks[blockName];
    currLayer = binfo.layer;
    currStartIndex = binfo.startIndex;
    currEndIndex = binfo.endIndex;
    currIndex = currStartIndex;
    return true;
}

bool EvonetIterator::nextNeuron() {
    checkCurrentStatus( "nextNeuron" );

    currIndex++;
    if ( currIndex >= currEndIndex ) {
        return false;
    }
    return true;
}

void EvonetIterator::setInput( double value ) {
    checkCurrentStatus( "setInput" );

    evonet->setInput( currIndex, value );
}

double EvonetIterator::getOutput() {
    checkCurrentStatus( "getOutput" );

    return evonet->getOutput( currIndex );
}

void EvonetIterator::setGraphicProperties( QString label, double minValue, double maxValue, QColor color ) {
    checkCurrentStatus( "setGraphicProperties" );

    label.truncate( 9 );
    int offsetIndex = 0;
    if ( currLayer == OutputLayer ) {
        offsetIndex = evonet->getNoInputs() + evonet->getNoHiddens();
    }
    sprintf( evonet->neuronl[ offsetIndex+currIndex ], "%s", label.toAscii().data() );
    evonet->neuronrange[ offsetIndex+currIndex ][0]  = 0.0;
    evonet->neuronrange[ offsetIndex+currIndex ][1]  = 1.0;
    // FIXME: need to change how the color are handled into Evonet
    evonet->neurondcolor[ offsetIndex+currIndex ] = color;
}

void EvonetIterator::checkCurrentStatus( const QString& funcName ) const {
    if ( !evonet ) {
        throw EvonetIteratorInvalidStatusException( funcName.toAscii().data(), "no Evonet object has ben set");
    }
    if ( currStartIndex < 0 ) {
        throw EvonetIteratorInvalidStatusException( funcName.toAscii().data(), "you should call setCurrentBlock first");
    }
    if ( currIndex >= currEndIndex ) {
        throw EvonetIteratorInvalidStatusException( funcName.toAscii().data(), "attempt to access beyond the size of the current block");
    }
}

} // end namespace farsa