experiments/evorobot/include/displaycontroller.h

/********************************************************************************
 *  FARSA Experiments Library                                                   *
 *  Copyright (C) 2007-2012                                                     *
 *  Stefano Nolfi <stefano.nolfi@istc.cnr.it>                                   *
 *  Onofrio Gigliotta <onofrio.gigliotta@istc.cnr.it>                           *
 *  Gianluca Massera <emmegian@yahoo.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 RENDNETWORK_H
#define RENDNETWORK_H

#include <QBrush>     // for rendnetwork
#include <QPen>     
#include <QPixmap>
#include <QWidget>
#include <QShortcut>

#include <QWidget>    // for NetworkDialog
#include <QGridLayout>
#include <QToolBar>
#include <QBoxLayout>
#include <QSlider>
#include "evonet.h"

namespace farsa {

class MixerDialog;
class RendNetwork;

/*
 * The dialog to show a widget within a window
 */
class FARSA_EXPERIMENTS_API NetworkDialog : public QWidget
{
    Q_OBJECT

public:

    RendNetwork *rendNetwork;      // The network rendering widget
    MixerDialog *mixerDialog;
    Evonet  *enet;
    int     drawblocks;            // whether we display or not the list of block  
    int     cneuron[4];            // selected neurons
    int     cneuronn;              // n. of selected cneurons
    int     rnrun;                 // the current cycle
    int     rnmousex;              // mouse left-clicked x position
    int     rnmousey;              // mouse left-clicked y position
    float   **graphicp;            // vector of parameter displayed through the graphic interface (max length = nneurons)
    int     ngp;                   // number of cirrently extracted parameters
    float   cscalex;               // x scale for the controller rendering
    float   cscaley;               // y scale for the controller rendering
    int     pseudomode;            // the display modality (0=label 1=delta, 2=weight, 3=biases, 4=gain)

    void    pseudo_activate_net(int dmode); // extract labels or values to be displayed

    //int load_net_blocks(char *filename, int mode); // load parameters from a configuration file
    //void save_net_blocks(char *filename);          // save the network description 

    float *freep;                  // pointer to free parameters             
    int nfreep;                    // number of free parameters 
    int ninputs;                   // n. input units                          
    int nhiddens;                  // n. hidden units                    
    int noutputs;                  // n. output units
    int nneurons;                  // total n. of neurons
    int net_nblocks;               // network number of connection blocks
    int net_block[Evonet::MAXN][5];        // blocks: 0=type (w,b,d), from 1 per 2 receive from 3 per 4
    int neuronbias[Evonet::MAXN];          // whether neurons have bias
    int neurontype[Evonet::MAXN];         // whether neurons have time constants
    int neurongain[Evonet::MAXN];          // whether neurons have gain parameters
    int neuronxy[Evonet::MAXN][2];         // neurons xy position in display space
    int neurondisplay[Evonet::MAXN];       // whether neurons should be displayed or not
    char neuronl[Evonet::MAXN][8];         // neurons labels (created in the robot_env module and used by the rend_network module)
    char neuroncl[Evonet::MAXN][8];        // neurons current labels (updated by pseudo_activate_net())
    float wrange;                  // weights range
    float grange;                  // gain range
    int  grid;                     // the step of the grid (0 = no grid)
    int nparameters;               // usefull to set GA parameters number of free parameters
    int nparambias;                // number of parametric bias to add to the number of genes need for the nnet
    int neuronlesions;             // whether some of the neurons has been lesioned or manually set
    float biases[Evonet::MAXN];            // biases value
    int   updated[Evonet::MAXN];           // the number of times a neuron is updated 


    void error(const char *emessage);    // display an error message
    void warning(const char *emessage);  // display a warning message


    // Constructor
    NetworkDialog(Evonet* net, QWidget* parent=0, Qt::WindowFlags flags=0);

    // destructor
    virtual ~NetworkDialog();

private:

    //void keyReleaseEvent(QKeyEvent* event);

    void shotWidget();

    QWidget *m_widget;

    QBoxLayout *m_mainLayout;

    QToolBar *m_toolBar;

    // create the toolbar
    void createToolBars();
    void createActions();

    QAction *set_neurondisplayAct;
    QAction *set_neurontypeAct;
    QAction *set_neurongainAct;
    QAction *set_neuronbiasAct;
    QAction *set_lesionAct;
    QAction *display_labelAct;
    QAction *display_weightAct;
    QAction *display_deltaAct;
    QAction *display_biasAct;
    QAction *display_gainAct;
    QAction *display_blocksAct;
    QAction *erase_netAct;
    QAction *add_ublockAct;
    QAction *add_cblockAct;
    QAction *add_gblockAct;
    QShortcut *increasevAct;
    QShortcut *decreasevAct;
    QAction *openAct;
    QAction *saveAct;
    QAction *randomfreepAct;
    QAction *mixerAct;

    private slots:

    void set_neurondisplay();
    void set_neuronbias();
    void set_neurontype();
    void set_neurongain();
    void set_lesion();
    void display_label();
    void display_weight();
    void display_delta();
    void display_bias();
    void display_gain();
    void display_blocks();
    void erase_net();
    void add_ublock(); 
    void add_cblock();
    void add_gblock();
    void increasev();
    void decreasev();
    void open(); 
    void save();
    void randomfreep();
    void openMixer();



};


/*
 * The network widget
 */
class FARSA_EXPERIMENTS_API RendNetwork : public QWidget
{
    Q_OBJECT

public:
    enum Shape { Line, Points, Polyline, Polygon, Rect, RoundRect, Ellipse, Arc,
                 Chord, Pie, Path, Text, Pixmap };

    RendNetwork( NetworkDialog* networkDialog, QWidget *parent = 0);

    QSize minimumSizeHint() const;
    QSize sizeHint() const;
    int     rnmousex;              // mouse left-clicked x position
    int     rnmousey;              // mouse left-clicked y position
    double mdist(float x, float y, float x1, float y1);  // distance between two points
    double segmentdist(float px,float py,float ax,float ay,float bx,float by); //distance beween a point and a segment 
    //NetworkDialog *networkDialog;


public slots:
    void setShape(Shape shape);
    void setPen(const QPen &pen);
    void setBrush(const QBrush &brush);
    void setAntialiased(bool antialiased);
    void setTransformed(bool transformed);

protected:
    void paintEvent(QPaintEvent *event);
    void mousePressEvent(QMouseEvent *event);
    void mouseMoveEvent(QMouseEvent *event);
    void mouseReleaseEvent(QMouseEvent *event);
    void mouseDoubleClickEvent(QMouseEvent *event);

private:
    Shape shape;
    QPen pen;
    QBrush brush;
    bool antialiased;
    bool transformed;
    QPixmap pixmap;
    NetworkDialog* networkDialog;
};

class FARSA_EXPERIMENTS_API EvoSlider : public QSlider
{
    Q_OBJECT
public:
    EvoSlider(double *ref, double rangemin=0, double rangemax=1, QWidget *parent=0);

private:
    double *vref;
private slots:
    void updateValue(int ival);

};

class FARSA_EXPERIMENTS_API MixerDialog : public QWidget
{
    Q_OBJECT

public:
    MixerDialog(Evonet *enet);
private:
    Evonet *evonet;
    void setUpMixer();
    double trialRef;
};

} //end namespace farsa

#endif