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"
#include "randomgenerator.h"

namespace farsa {

NoisyDevice::NoisyDevice( ConfigurationParameters& params, QString prefix ) :
    ParameterSettableInConstructor(params, prefix),
    noiseType(NoNoise),
    noiseRange(0.0),
    noiseParameter(0.0)
{
    QString noiseTypeStr = ConfigurationHelper::getString(params, prefix + "noiseType", "NoNoise").toUpper();
    if (noiseTypeStr == "NONOISE") {
        noiseType = NoNoise;
    } else if (noiseTypeStr == "UNIFORM") {
        noiseType = Uniform;
    } else if (noiseTypeStr == "GAUSSIAN") {
        noiseType = Gaussian;
    } else {
        ConfigurationHelper::throwUserConfigError("noiseType", params.getValue(prefix + "noiseType"), "The noiseType must be one of NoNoise, Uniform or Gaussian");
    }
    noiseRange = ConfigurationHelper::getDouble(params, prefix + "noiseRange", 0.0);
    if (noiseRange < 0.0) {
        ConfigurationHelper::throwUserConfigError("noiseRange", params.getValue(prefix + "noiseRange"), "The noiseRange parameter must be a real value greater or equal to 0");
    }

    // Computing the parameter used when applying noise. It depends on the type of noise to apply
    switch (noiseType) {
        case NoNoise:
            noiseParameter = 0.0;
            break;
        case Uniform:
            noiseParameter = noiseRange / 2.0;
            break;
        case Gaussian:
            noiseParameter = (noiseRange * noiseRange) / 16.0; // i.e. (noiseRange/4.0)^2
            break;
    }
}

NoisyDevice::~NoisyDevice()
{
}

void NoisyDevice::save( ConfigurationParameters& params, QString prefix )
{
    params.startObjectParameters( prefix, "NoisyDevice", this );
    QString noiseTypeStr;
    switch (noiseType) {
        case NoNoise:
            noiseTypeStr = "NoNoise";
            break;
        case Uniform:
            noiseTypeStr = "Uniform";
            break;
        case Gaussian:
            noiseTypeStr = "Gaussian";
            break;
    }
    params.createParameter(prefix, "noiseType", noiseTypeStr);
    params.createParameter(prefix, "noiseRange", QString::number(noiseRange));
}

void NoisyDevice::describe( QString type )
{
    Descriptor d = addTypeDescription( type, "Base class for all noisy devices (sensors and motors)" );
    d.describeEnum("noiseType").def("NoNoise").values(QStringList() << "NoNoise" << "Uniform" << "Gaussian").help("The type of noise to add to sensor readings", "This must be one of NoNoise, Uniform or Gaussian. Notice that not all sensors respect the value of this parameter (some may never add noise). See sensor description for more information");
    d.describeReal("noiseRange").def(0.0f).limits(0.0,+Infinity).help("The range of noise", "For uniform noise this is the actual range, (the distribution has zero mean and goes from -noiseRange/2 to noiseRange/2). For gaussian noise, this is four times the standard deviation (the distribution has zero mean and noiseRange/4 standard deviation: this means that about 95% of the values taken from the distribution will be between -noiseRange/2 and noiseRange/2)");
}

double NoisyDevice::applyNoise(double v, double minValue, double maxValue) const
{
    // Adding noise
    switch (noiseType) {
        case NoNoise:
            // Nothing to do
            break;
        case Uniform:
            v += globalRNG->getDouble(-noiseParameter, noiseParameter);
            break;
        case Gaussian:
            v += globalRNG->getGaussian(noiseParameter, 0.0);
            break;
    }

    // Restricting v between minValue and maxValue if we have to
    if (minValue <= maxValue) {
        if (v < minValue) {
            v = minValue;
        } else if (v > maxValue) {
            v = maxValue;
        }
    }

    return v;
}

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

Sensor::~Sensor() {
}

void Sensor::save( ConfigurationParameters& params, QString prefix ) {
    // Calling parent function
    NoisyDevice::save(params, 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 );
    }

    // Here we don't save the __resourcePrefix__ parameter because it is only used internally
}

void Sensor::describe( QString type ) {
    // Calling parent function
    NoisyDevice::describe(type);

    Descriptor d = addTypeDescription( type, "Base class for all Sensors" );
    d.describeString( "name" ).help( "The name of the sensor" );
    // Here we don't describe the __resourcePrefix__ parameter because it is only used internally
}

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;
}

QString Sensor::actualResourceNameForMultirobot(QString resourceName) const
{
    return resourcePrefix + resourceName;
}

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

Motor::~Motor() {
}

void Motor::save( ConfigurationParameters& params, QString prefix ) {
    // Calling parent function
    NoisyDevice::save(params, 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 );
    }
    // Here we don't save the __resourcePrefix__ parameter because it is only used internally
}

void Motor::describe( QString type ) {
    // Calling parent function
    NoisyDevice::describe(type);

    Descriptor d = addTypeDescription( type, "Base class for all Motors" );
    d.describeString( "name" ).help( "The name of the motor" );
    // Here we don't describe the __resourcePrefix__ parameter because it is only used internally
}

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;
}

QString Motor::actualResourceNameForMultirobot(QString resourceName) const
{
    return resourcePrefix + resourceName;
}

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;
}

Evonet* EvonetIterator::getEvonet() {
    return evonet;
}

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 ) ) {
        throw EvonetIteratorInvalidStatusException( "setCurrentBlock", QString("EvonetIterator - the block %1 does not exist").arg(blockName).toLatin1().data());
    }
    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::getInput() {
    checkCurrentStatus( "getInput" );

    return evonet->getInput( currIndex );
}

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.toLatin1().data() );
    evonet->neuronrange[ offsetIndex+currIndex ][0]  = minValue;
    evonet->neuronrange[ offsetIndex+currIndex ][1]  = maxValue;
    // FIXME: need to change how the color are handled into Evonet
    evonet->neurondcolor[ offsetIndex+currIndex ] = color;
    evonet->updateNeuronMonitor = true;
}

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

} // end namespace farsa