TransformModule.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2010 RobotCub Consortium, European Commission FP6 Project IST-004370
 * author:  Arjan Gijsberts
 * email:   arjan.gijsberts@iit.it
 * website: www.robotcub.org
 * Permission is granted to copy, distribute, and/or modify this program
 * under the terms of the GNU General Public License, version 2 or any
 * later version published by the Free Software Foundation.
 *
 * A copy of the license can be found at
 * http://www.robotcub.org/icub/license/gpl.txt
 *
 * 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
 */
 
#ifndef LM_TRANSFORMMODULE__
#define LM_TRANSFORMMODULE__
 
#include <yarp/os/PortablePair.h>
 
#include "iCub/learningMachine/IMachineLearnerModule.h"
#include "iCub/learningMachine/TransformerPortable.h"
 
 
namespace iCub {
namespace learningmachine {
 
class ITransformProcessor {
protected:
    TransformerPortable& transformerPortable;
 
public:
    ITransformProcessor(TransformerPortable& tp) : transformerPortable(tp) { }
 
    virtual TransformerPortable& getTransformerPortable() {
        return this->transformerPortable;
    }
 
    virtual ITransformer& getTransformer() {
        return this->getTransformerPortable().getWrapped();
    }
};
 
class TransformPredictProcessor : public ITransformProcessor, public yarp::os::PortReader {
protected:
    yarp::os::Port& predictRelay_inout;
 
public:
    TransformPredictProcessor(TransformerPortable& tp, yarp::os::Port& p)
      : ITransformProcessor(tp), predictRelay_inout(p) { }
 
    /*
     * Inherited from PortReader.
     */
    virtual bool read(yarp::os::ConnectionReader& connection);
 
    virtual yarp::os::Port& getOutputPort() {
        return this->predictRelay_inout;
    }
 
};
 
 
class TransformTrainProcessor
  : public ITransformProcessor, public yarp::os::TypedReaderCallback< yarp::os::PortablePair<yarp::sig::Vector,yarp::sig::Vector> > {
private:
    yarp::os::BufferedPort<yarp::os::PortablePair<yarp::sig::Vector,yarp::sig::Vector> >& train_out;
 
public:
    TransformTrainProcessor(TransformerPortable& tp,
                            yarp::os::BufferedPort< yarp::os::PortablePair<yarp::sig::Vector,yarp::sig::Vector> >& p)
      : ITransformProcessor(tp), train_out(p) { }
 
    /*
     * Inherited from TypedReaderCallback.
     */
    virtual void onRead(yarp::os::PortablePair<yarp::sig::Vector,yarp::sig::Vector>& input);
 
    virtual yarp::os::BufferedPort<yarp::os::PortablePair<yarp::sig::Vector,yarp::sig::Vector> >& getOutputPort() {
        return this->train_out;
    }
 
};
 
 
 
 
class TransformModule : public IMachineLearnerModule {
private:
    TransformerPortable transformerPortable;
 
    yarp::os::BufferedPort<yarp::os::PortablePair<yarp::sig::Vector,yarp::sig::Vector> > train_in;
 
    yarp::os::BufferedPort<yarp::os::PortablePair<yarp::sig::Vector,yarp::sig::Vector> > train_out;
 
    yarp::os::BufferedPort<yarp::sig::Vector> predict_inout;
 
    yarp::os::Port predictRelay_inout;
 
    TransformTrainProcessor trainProcessor;
 
    TransformPredictProcessor predictProcessor;
 
    TransformModule(const TransformModule& other);
 
    TransformModule& operator=(const TransformModule& other);
 
    /*
     * Inherited from IMachineLearnerModule.
     */
    void registerAllPorts();
 
    /*
     * Inherited from IMachineLearnerModule.
     */
    void unregisterAllPorts();
 
    /*
     * Inherited from IMachineLearnerModule.
     */
    void printOptions(std::string error = "");
 
    void printTransformerList();
 
public:
    TransformModule(std::string pp = "/lm/transform")
      : IMachineLearnerModule(pp), transformerPortable((ITransformer*) 0),
        trainProcessor(transformerPortable, train_out),
        predictProcessor(transformerPortable, predictRelay_inout) {
    }
 
    virtual ~TransformModule() { }
 
    /*
     * Inherited from IMachineLearnerModule.
     */
    virtual bool configure(yarp::os::ResourceFinder& opt);
 
    /*
     * Inherited from IMachineLearnerModule.
     */
    virtual bool interruptModule();
 
    /*
     * Inherited from IMachineLearnerModule.
     */
    virtual bool respond(const yarp::os::Bottle& cmd, yarp::os::Bottle& reply);
 
    virtual ITransformer& getTransformer() {
        return this->getTransformerPortable().getWrapped();
    }
 
    virtual TransformerPortable& getTransformerPortable() {
        return this->transformerPortable;
    }
 
};
 
} // learningmachine
} // iCub
 
#endif