sensorcontrollers.h

/********************************************************************************
 *  FARSA Experimentes 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  *
 ********************************************************************************/

#ifndef SENSORCONTROLLERS_H
#define SENSORCONTROLLERS_H

#include "world.h"
#include "ownable.h"
#include "phyobject.h"
#include "phyfixed.h"

namespace farsa {

class FARSA_WSIM_API SensorController : public Ownable
{
public:
    SensorController(World* world);

    virtual ~SensorController();

    virtual void update() = 0;

    bool isEnabled()
    {
        return m_enabled;
    }

    void setEnabled(bool b)
    {
        m_enabled = b;
    }

    World* world()
    {
        return m_world;
    }

private:
    World* m_world;

    bool m_enabled;

    SensorController(const SensorController& other);

    SensorController& operator=(const SensorController& other);
};

class FARSA_WSIM_API IRSensorController : public SensorController
{
public:
    IRSensorController(World* world, unsigned int numSensors);

    virtual ~IRSensorController();

    int nSensors() const
    {
        return m_activations.size();
    }

    double activation(int i) const
    {
        return m_activations[i];
    }

protected:
    QVector<double> m_activations;
};

namespace __SingleIR_internal {
    class SingleIRGraphic;
}

class FARSA_WSIM_API SingleIR
{
public:
    SingleIR();

    SingleIR(WObject* obj, wMatrix mtr, double minDist, double maxDist, double aperture, unsigned int numRays);

    SingleIR(const SingleIR& other);

    SingleIR& operator=(const SingleIR& other);

    ~SingleIR();

    void update();

    const RayCastHit& getRayCastHit() const
    {
        return m_rayCastHit;
    }

    void set(WObject* obj, wMatrix mtr, double minDist, double maxDist, double aperture, unsigned int numRays);

    void setGraphicalProperties(bool drawSensor, bool drawRay = false, bool drawRealRay = false);

    const WObject* getObject() const
    {
        return m_object;
    }

    const wMatrix& getTransformation() const
    {
        return m_transformation;
    }

    double getMinDistance() const
    {
        return m_minDist;
    }

    double getMaxDistance() const
    {
        return m_maxDist;
    }

    double getAperture() const
    {
        return m_aperture;
    }

    unsigned int getNumRays() const
    {
        return m_numRays;
    }

    bool isValid() const
    {
        return ((m_object != NULL) && (m_numRays != 0));
    }

private:
    void computeRayPoints();

    void updateGraphicalRepresentation();

    WObject* m_object;

    wMatrix m_transformation;

    double m_minDist;

    double m_maxDist;

    double m_aperture;

    unsigned int m_numRays;

    bool m_drawSensor;

    bool m_drawRay;

    bool m_drawRealRay;

    QVector<wVector> m_startingRayPoints;

    QVector<wVector> m_endingRayPoints;

    RayCastHit m_rayCastHit;

    __SingleIR_internal::SingleIRGraphic* m_sensorGraphics;
};

class FARSA_WSIM_API SimulatedIRProximitySensorController : public IRSensorController
{
public:
    SimulatedIRProximitySensorController(World* world, const QVector<SingleIR>& sensors);

    ~SimulatedIRProximitySensorController();

    virtual void update();

    void setGraphicalProperties(bool drawSensor, bool drawRay = false, bool drawRealRay = false);

private:
    QVector<SingleIR> m_sensors;
};

class FARSA_WSIM_API SimulatedIRGroundSensorController : public IRSensorController
{
public:
    SimulatedIRGroundSensorController(World* world, const QVector<SingleIR>& sensors);

    ~SimulatedIRGroundSensorController();

    virtual void update();

    void setGraphicalProperties(bool drawSensor, bool drawRay = false, bool drawRealRay = false);

private:
    QVector<SingleIR> m_sensors;
};

class FARSA_WSIM_API TractionSensorController : public SensorController
{
public:
    TractionSensorController(World* world, const PhyFixed& j);

    ~TractionSensorController();

    virtual void update();

    wVector traction() const;

private:
    const PhyFixed& m_joint;
};

} // end namespace farsa

#endif