plotter.h

/*************************************************************************************
 * MechSys - A C++ library to simulate (Continuum) Mechanical Systems                *
 * Copyright (C) 2005 Dorival de Moraes Pedroso <dorival.pedroso at gmail.com>       *
 * Copyright (C) 2005 Raul Dario Durand Farfan  <raul.durand at gmail.com>           *
 *                                                                                   *
 * This file is part of MechSys.                                                     *
 *                                                                                   *
 * MechSys 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.                                                                          *
 *                                                                                   *
 * MechSys 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      *
 * MechSys; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, *
 * Fifth Floor, Boston, MA 02110-1301, USA                                           *
 *************************************************************************************/

#ifndef MECHSYS_LABTESTSIM_PLOTTER_H
#define MECHSYS_LABTESTSIM_PLOTTER_H

#ifdef HAVE_CONFIG_H
  #include "config.h"
#else
  #ifndef REAL
    #define REAL double
  #endif
#endif

#include <gtkmm/dialog.h>
#include <gtkmm/notebook.h>
#include <gtkmm/table.h>
#include <gtkmm/stock.h>
#include <gtkmm/button.h>
#include <gtkmm/statusbar.h>

#include <plotmm/plot.h>
#include <plotmm/scalediv.h>
#include <plotmm/curve.h>
#include <plotmm/errorcurve.h>
#include <plotmm/symbol.h>
#include <plotmm/paint.h>
#include <plotmm/rectangle.h>

#include "util/array.h"
#include "util/string.h"
#include "util/exception.h"
#include "util/fileparser.h"
#include "util/util.h"

using Util::ToRad;
using Util::Signal;

namespace LabTestSim
{

// Structures
struct PlotInfo // {{{
{
    char const * Title;
    char const * X_label;
    char const * Y_label;
    char const * X_tag;
    char const * Y_tag;
    bool         X_ln;
    bool         Y_ln;
    bool         mult_Y; // use _cy?
    bool         Y_neg;
}; // struct PlotInfo // }}}

PlotInfo PlotterInfo[]={{"Stress-deviatoric strain   q versus Ed"   , "Ed (%)" , "q"       , "Ed", "q"  , false , false , true  , false },
                        {"Stress-volumetric strain   q versus Ev"   , "Ev (%)" , "q"       , "Ev", "q"  , false , false , true  , false },
                        {"Dilatancy   -Ev versus Ed"                , "Ed (%)" , "-Ev (%)" , "Ed", "Ev" , false , false , false , true  },
                        {"Compression/Expansion   -Ev versus ln(p)" , "ln(p)"  , "-Ev (%)" , "p" , "Ev" , true  , false , false , true  }};

class Plotter : public Gtk::Dialog
{
public:
    // Constructor
    Plotter(Array<String>            const * a_DAT             ,
            Array<FileParser::Table> const * a_Data            ,
            bool                             use_Cy    = true  ,
            bool                             use_Marks = false ,
            Array< Array<int> >      const * a_Marks   = NULL  ,
            bool                             use_Calc  = false ,
            Array<FileParser::Table> const * a_Calc    = NULL  ,
            bool                             use_CMarks= false ,
            Array< Array<int> >      const * a_CMarks  = NULL  );

    // Destructor
    ~Plotter();

private:
    // Data
    Array<String>         const * _names;
    bool                          _use_cy;     // coeficient to multiply Y values according to compression/extension
    bool                          _use_marks;  // Separate plots according to marks of different paths
    bool                          _use_calc;   // Plot calc values toghether to data values
    bool                          _use_cmarks; // Separate (calc) plots according to marks of different paths
    Gtk::Button                   _btn_close;
    Gtk::Notebook                 _nb;
    Gtk::Statusbar                _sbar;
    Array< Gtk::Table* >          _grids; 
    Array< Array<PlotMM::Plot*> > _plots; // 4 plots for each grid

    // Structures
    struct Coords
    {
        REAL * X;
        REAL * Y;
        int    size;
    }; // struct Coords
    
    // Methods
    void _setup_subplot            (int subplot_id, PlotMM::Plot * subplot);
    void _allocate_and_fill_coords (int subplot_id, FileParser::Table const & T, Coords & C);
    void _add_curves               (int subplot_id, Coords const & C, PlotMM::Plot * subplot, String const & color="blue");
    void _add_curves               (int subplot_id, Coords const & C, Array<int> const & Marks, PlotMM::Plot * subplot, String const & clr1="blue", String const & clr2="red");
    void _print_coords             (int subplot_id, int x, int y);

    // Callbacks
    void _on_close_clicked() { this->hide(); }
    void _on_switch_page(GtkNotebookPage * page, guint page_num);
    void _on_plot0_mouse_move(int x, int y, GdkEventMotion * ev);
    void _on_plot1_mouse_move(int x, int y, GdkEventMotion * ev);
    void _on_plot2_mouse_move(int x, int y, GdkEventMotion * ev);
    void _on_plot3_mouse_move(int x, int y, GdkEventMotion * ev);

}; // class Plotter




inline Plotter::Plotter(Array<String>            const * a_DAT     , // {{{
                        Array<FileParser::Table> const * a_Data    ,
                        bool                             use_Cy    ,
                        bool                             use_Marks ,
                        Array< Array<int> >      const * a_Marks   ,
                        bool                             use_Calc  ,
                        Array<FileParser::Table> const * a_Calc    ,
                        bool                             use_CMarks,
                        Array< Array<int> >      const * a_CMarks  )
    : _names     (a_DAT)     ,
      _use_cy    (use_Cy)    ,
      _use_marks (use_Marks) ,
      _use_calc  (use_Calc)  ,
      _use_cmarks(use_CMarks),
      _btn_close (Gtk::Stock::CLOSE)
{
    // Check-up
    if (_names->size()!=a_Data->size())
        throw new Fatal(_("Plotter::SetData: Array with Data filenames must have size (%d) equal to the array with data (%d)"), _names->size(), a_Data->size());
    if (_names->size()<1)
        throw new Fatal(_("Plotter::SetData: The number of data filenames must be greater than 0"));
    if (_use_marks && a_Marks==NULL)
        throw new Fatal (_("Plotter::Plotter: When using Marks, the pointer to an array with marks (a_Marks) must be non-NULL"));
    if (_use_cmarks && a_CMarks==NULL)
        throw new Fatal (_("Plotter::Plotter: When using CMarks, the pointer to an array with cmarks (a_CMarks) must be non-NULL"));

    // Resize plots and grids
    _grids.resize(_names->size());
    _plots.resize(_names->size());

    // Loop along the number of plots
    for (size_t i=0; i<_names->size(); ++i)
    {
        // Allocate grids
        _grids[i] = new Gtk::Table (2,2, true); // true => homogeneous

        // Allocate and generate plots
        _plots[i].resize(4);
        for (int j=0; j<4; ++j)
        {
            // allocate
            _plots[i][j] = new PlotMM::Plot;

            // setup
            _setup_subplot(j, _plots[i][j]);

            // add data curves
            Coords D;
            _allocate_and_fill_coords(j, (*a_Data)[i], D);
            if (_use_marks) _add_curves(j, D, (*a_Marks)[i], _plots[i][j]);
            else            _add_curves(j, D,                _plots[i][j]);
            delete [] D.X;
            delete [] D.Y;

            // add calc curves
            if (_use_calc)
            {
                Coords C;
                _allocate_and_fill_coords(j, (*a_Calc)[i], C);
                if (_use_cmarks) _add_curves(j, C, (*a_CMarks)[i], _plots[i][j], "LimeGreen", "OliveDrab");
                else             _add_curves(j, C, _plots[i][j],                 "OliveDrab");
                delete [] C.X;
                delete [] C.Y;
            }
            
        }

        // Add plots to grid
        _grids[i]->attach((*_plots[i][0]),0,1,0,1);
        _grids[i]->attach((*_plots[i][1]),1,2,0,1);
        _grids[i]->attach((*_plots[i][2]),0,1,1,2);
        _grids[i]->attach((*_plots[i][3]),1,2,1,2);
        
        // Add plot widgets to notebook
        _nb.append_page((*_grids[i]), (*_names)[i]);

        // Set callbacks
        _plots[i][0]->signal_plot_mouse_move().connect(sigc::mem_fun(*this,&Plotter::_on_plot0_mouse_move));
        _plots[i][1]->signal_plot_mouse_move().connect(sigc::mem_fun(*this,&Plotter::_on_plot1_mouse_move));
        _plots[i][2]->signal_plot_mouse_move().connect(sigc::mem_fun(*this,&Plotter::_on_plot2_mouse_move));
        _plots[i][3]->signal_plot_mouse_move().connect(sigc::mem_fun(*this,&Plotter::_on_plot3_mouse_move));
    }

    // Add statusbar, button and notebook to dialog
    get_vbox()->pack_end(_sbar     , false, true);  // noexpand, fill
    get_vbox()->pack_end(_btn_close, false, false); // noexpand, nofill
    get_vbox()->pack_end(_nb,        true,  true);  // expand,   fill
    get_vbox()->set_homogeneous(false);
    show_all_children();

    // Set callbacks
    _btn_close.signal_clicked().connect(sigc::mem_fun(*this, &Plotter::_on_close_clicked));
    _nb.signal_switch_page()   .connect(sigc::mem_fun(*this, &Plotter::_on_switch_page));

} // }}}

inline Plotter::~Plotter() // {{{
{
#ifdef DO_DEBUG
    std::cout << "Plotter::~Plotter() Destructor called\n";
#endif
    for (size_t i=0; i<_plots.size(); ++i)
    {
        // Delete grids
        delete _grids[i];

        // Delete plots
        for (int j=0; j<4; ++j)
            delete _plots[i][j];
    }
} // }}}

inline void Plotter::_setup_subplot(int subplot_id, PlotMM::Plot * subplot) // {{{
{
    // Set title and axis labels
    subplot->title()->set_text(PlotterInfo[subplot_id].Title);
    subplot->title()->set_enabled(true);
    subplot->label(PlotMM::AXIS_BOTTOM)->set_text(PlotterInfo[subplot_id].X_label);
    subplot->label(PlotMM::AXIS_LEFT  )->set_text(PlotterInfo[subplot_id].Y_label);
    subplot->label(PlotMM::AXIS_BOTTOM)->set_enabled(true);
    subplot->label(PlotMM::AXIS_LEFT  )->set_enabled(true);

    // Set scale style
    subplot->scale(PlotMM::AXIS_TOP   )->set_enabled  (false);
    subplot->scale(PlotMM::AXIS_RIGHT )->set_enabled  (false);
    subplot->scale(PlotMM::AXIS_LEFT  )->set_enabled  (true);
    subplot->scale(PlotMM::AXIS_BOTTOM)->set_enabled  (true);
    subplot->scale(PlotMM::AXIS_LEFT  )->set_autoscale(true);
    subplot->scale(PlotMM::AXIS_BOTTOM)->set_autoscale(true);

} // }}}

inline void Plotter::_allocate_and_fill_coords(int subplot_id, FileParser::Table const & T, Coords & C) // {{{
{
    // X values
    FileParser::Table::const_iterator x_it = T.find(PlotterInfo[subplot_id].X_tag);
    if (x_it==T.end()) throw new Fatal(_("Plotter::_allocate_and_fill_X_and_Y: Could not find tag < %s >"), PlotterInfo[subplot_id].X_tag);

    // Y values
    FileParser::Table::const_iterator y_it = T.find(PlotterInfo[subplot_id].Y_tag);
    if (y_it==T.end()) throw new Fatal(_("Plotter::_allocate_and_fill_X_and_Y: Could not find tag < %s >"), PlotterInfo[subplot_id].Y_tag);

    // Cy
    String cy_tag;
    FileParser::Table::const_iterator tmp1_it = T.find("sin3th");
    if (tmp1_it==T.end())
    {
        FileParser::Table::const_iterator tmp2_it = T.find("th");
        if (tmp2_it==T.end()) cy_tag = "sin3th_or_th_was_not_found";
        else                  cy_tag = "th";
    }
    else cy_tag = "sin3th";
    FileParser::Table::const_iterator cy_it = T.find(cy_tag);

    // Allocate and fill X and Y arrays
    C.size = x_it->second.size();
    C.X = new REAL [C.size];
    C.Y = new REAL [C.size];
    for (int j=0; j<C.size; ++j)
    {
        // X values
        if (PlotterInfo[subplot_id].X_ln) C.X[j] = log(x_it->second[j]);
        else                              C.X[j] =     x_it->second[j] ;
        // Y values
        if (PlotterInfo[subplot_id].Y_ln) C.Y[j] = log(y_it->second[j]);
        else                              C.Y[j] =     y_it->second[j] ;
        if (PlotterInfo[subplot_id].mult_Y)
        {
            if (cy_it==T.end()) throw new Fatal(_("Plotter::_allocate_and_fill_X_and_Y: Could not find tag < %s >"), cy_tag.c_str());
            REAL sgn;
            if (cy_tag=="sin3th") sgn = Signal(              cy_it->second[j]  , 1.0e-10);
            else                  sgn = Signal(sin(3.0*ToRad(cy_it->second[j])), 1.0e-10);
            if (fabs(sgn)>0.0) C.Y[j] = sgn * C.Y[j];
        }
        if (PlotterInfo[subplot_id].Y_neg) C.Y[j] = -C.Y[j];
    }
} // }}}

inline void Plotter::_add_curves(int subplot_id, Coords const & C, PlotMM::Plot * subplot, String const & color) // {{{
{
    char tit[100];
    sprintf(tit, "%s x %s", PlotterInfo[subplot_id].Y_tag, PlotterInfo[subplot_id].X_tag);
    Glib::RefPtr<PlotMM::Curve> c = Glib::RefPtr<PlotMM::Curve>(new PlotMM::Curve(tit));
    c->set_data(C.X, C.Y, C.size);
    c->paint()->set_pen_color(Gdk::Color(color));
    subplot->add_curve(c);
} // }}}

inline void Plotter::_add_curves(int subplot_id, Coords const & C, Array<int> const & Marks, PlotMM::Plot * subplot, String const & clr1, String const & clr2) // {{{
{
    int start=0; bool red=false;
    for (size_t j=0; j<Marks.size(); ++j)
    {
        char tit[100];
        sprintf(tit, "%s x %s path# %d, mrk=%d", PlotterInfo[subplot_id].Y_tag, PlotterInfo[subplot_id].X_tag, j, Marks[j]);
        Glib::RefPtr<PlotMM::Curve> c = Glib::RefPtr<PlotMM::Curve>(new PlotMM::Curve(tit));
        int len = Marks[j] - start;
        if (start+len>C.size) throw new Fatal(_("Plotter::_add_curves: There is an inconsistency with the array of marks"));
        c->set_data(&(C.X[start]),&(C.Y[start]),len);
        start += len - 1;
        if (red) { c->paint()->set_pen_color(Gdk::Color(clr1)); red=false; }
        else     { c->paint()->set_pen_color(Gdk::Color(clr2)); red=true;  }
        subplot->add_curve(c);
    }
} // }}}

inline void Plotter::_print_coords(int subplot_id, int x, int y) // {{{
{
    int plot_id = _nb.get_current_page();
    char tmp[1000];
    sprintf(tmp, "%s  |  %s = %.3f  |  %s = %.3f", (*_names)[plot_id].c_str(),
        PlotterInfo[subplot_id].X_label,
        _plots[plot_id][subplot_id]->scale(PlotMM::AXIS_BOTTOM)->scale_map().inv_transform(x),
        PlotterInfo[subplot_id].Y_label,
        _plots[plot_id][subplot_id]->scale(PlotMM::AXIS_LEFT  )->scale_map().inv_transform(y));
    _sbar.pop();
    _sbar.push(tmp);
} // }}}

inline void Plotter::_on_switch_page(GtkNotebookPage * page, guint page_num) // {{{
{
    _sbar.pop();
    _sbar.push((*_names)[page_num]);
} // }}}

inline void Plotter::_on_plot0_mouse_move(int x, int y, GdkEventMotion * ev) // {{{
{
    _print_coords(0, x,y);
} // }}}

inline void Plotter::_on_plot1_mouse_move(int x, int y, GdkEventMotion * ev) // {{{
{
    _print_coords(1, x,y);
} // }}}

inline void Plotter::_on_plot2_mouse_move(int x, int y, GdkEventMotion * ev) // {{{
{
    _print_coords(2, x,y);
} // }}}

inline void Plotter::_on_plot3_mouse_move(int x, int y, GdkEventMotion * ev) // {{{
{
    _print_coords(3, x,y);
} // }}}

}; // namespace LabTestSim

#endif // MECHSYS_LABTESTSIM_PLOTTER_H

// vim:fdm=marker

---