vpPlot.cpp

/****************************************************************************
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2017 by Inria. All rights reserved.
 *
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact Inria about acquiring a ViSP Professional
 * Edition License.
 *
 * See http://visp.inria.fr for more information.
 *
 * This software was developed at:
 * Inria Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 *
 * If you have questions regarding the use of this file, please contact
 * Inria at visp@inria.fr
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 * Description:
 * Plot curves.
 *
 * Authors:
 * Nicolas Melchior
 *
 *****************************************************************************/



#include <visp3/core/vpConfig.h>

#if defined(VISP_HAVE_DISPLAY)
#include <visp3/gui/vpPlot.h>
#include <visp3/gui/vpDisplayOpenCV.h>
#include <visp3/gui/vpDisplayX.h>
#include <visp3/gui/vpDisplayGDI.h>
#include <visp3/gui/vpDisplayGTK.h>
#include <visp3/gui/vpDisplayD3D.h>
#include <visp3/core/vpMath.h>
#include <visp3/core/vpMeterPixelConversion.h>
#include <visp3/core/vpPixelMeterConversion.h>
#include <fstream>
#include <list>
#include <vector>

vpPlot::vpPlot() : I(), display(NULL), graphNbr(1), graphList(NULL), margei(30), margej(40),
  factori(1.f), factorj(1.)
{
}
vpPlot::vpPlot(const unsigned int graph_nbr,
           const unsigned int height, const unsigned int width, 
         const int x, const int y, const std::string &title)
  : I(), display(NULL), graphNbr(1), graphList(NULL), margei(30), margej(40),
    factori(1.f), factorj(1.)
{  
  init(graph_nbr, height, width, x, y, title);
}

void vpPlot::init(const unsigned int graph_nbr,
          const unsigned int height, const unsigned int width, 
      const int x, const int y, const std::string &title)
{
  I.init(height,width,255);
    
#if defined VISP_HAVE_X11
  display = new vpDisplayX;
#elif defined VISP_HAVE_GDI
  display = new vpDisplayGDI;
#elif defined VISP_HAVE_OPENCV
  display = new vpDisplayOpenCV;
#elif defined VISP_HAVE_GTK
  display = new vpDisplayGTK;
#elif defined VISP_HAVE_D3D9
  display = new vpDisplayD3D;
#endif

  display->init(I, x, y, title.c_str());
  
  vpDisplay::display(I);
    
  factori = height/700.0f;
  factorj = width/700.0f;
    
  initNbGraph(graph_nbr);
}

vpPlot::~vpPlot()
{
  if (graphList != NULL)
  {
    delete[] graphList;
    graphList = NULL;
  }
  if (display != NULL)
  {
    delete display;
    display = NULL;
  }
}

void
vpPlot::initNbGraph (unsigned int nbGraph)
{
  if(nbGraph > 4){
    throw vpException(vpException::dimensionError, "Cannot create more than 4 graphs");
  }
  graphList = new vpPlotGraph[nbGraph];
  graphNbr = nbGraph;
  
  switch (nbGraph)
  {
    case 1 : 
      graphList[0].initSize(vpImagePoint(0,0), (unsigned int)(700*factorj),(unsigned int)(700*factori),margei,margej);
      break;
    case 2 :
      graphList[0].initSize(vpImagePoint(0,0),(unsigned int)(700*factorj),(unsigned int)(350*factori),margei,margej);
      graphList[1].initSize(vpImagePoint((unsigned int)(350*factori),0),(unsigned int)(700*factorj),(unsigned int)(350*factori),margei,margej);
      break;
    case 3 :
      graphList[0].initSize(vpImagePoint(0,0),(unsigned int)(350*factorj),(unsigned int)(350*factori),margei,margej);
      graphList[1].initSize(vpImagePoint(0,(unsigned int)(350*factorj)),(unsigned int)(350*factorj),(unsigned int)(350*factori),margei,margej);
      graphList[2].initSize(vpImagePoint((unsigned int)(350*factori),0),(unsigned int)(700*factorj),(unsigned int)(350*factori),margei,margej);
      break;
    case 4 :
      graphList[0].initSize(vpImagePoint(0,0),(unsigned int)(350*factorj),(unsigned int)(350*factori),margei,margej);
      graphList[1].initSize(vpImagePoint(0,(unsigned int)(350*factorj)),(unsigned int)(350*factorj),(unsigned int)(350*factori),margei,margej);
      graphList[2].initSize(vpImagePoint((unsigned int)(350*factori),0),(unsigned int)(350*factorj),(unsigned int)(350*factori),margei,margej);
      graphList[3].initSize(vpImagePoint((unsigned int)(350*factori),(unsigned int)(350*factorj)),(unsigned int)(350*factorj),(unsigned int)(350*factori),margei,margej);
      break;
  }
  
  for (unsigned int i = 0; i < graphNbr; i++)
  {
    graphList[i].title.clear();
    graphList[i].unitx.clear();
    graphList[i].unity.clear();
    graphList[i].unitz.clear();
  }
}

void
vpPlot::initGraph (unsigned int graphNum, unsigned int curveNbr)
{
  (graphList+graphNum)->initGraph(curveNbr);
}


// void
// vpPlot::initRange (const int graphNum, 
//         double xmin, double xmax, double /*xdelt*/, 
//         double ymin, double ymax, double /*ydelt*/, 
//         const bool gx, const bool gy)
// {
//   (graphList+graphNum)->initScale(I,xmin,xmax,10,ymin,ymax,10,gx,gy);
// }

void
vpPlot::initRange (const unsigned int graphNum, 
           double xmin, double xmax, 
           double ymin, double ymax)
{
  (graphList+graphNum)->initScale(I,xmin,xmax,10,ymin,ymax,10,true,true);
}

void
vpPlot::initRange (const unsigned int graphNum, 
           double xmin, double xmax, double ymin, 
           double ymax, double zmin, double zmax)
{
  (graphList+graphNum)->initScale(I,xmin,xmax,10,ymin,ymax,10,zmin,zmax,10,true,true);
}

void
vpPlot::setColor (const unsigned int graphNum, const unsigned int curveNum, vpColor color)
{
  (graphList+graphNum)->setCurveColor(curveNum, color);
}

void
vpPlot::displayGrid()
{
  for (unsigned int i = 0; i < graphNbr; i++)
    graphList[i].displayGrid(I);
}

void
vpPlot::plot (const unsigned int graphNum, const unsigned int curveNum, const double x, const double y)
{
  (graphList+graphNum)->plot(I,curveNum,x,y);
}

void vpPlot::plot(const unsigned int graphNum,
                  const double x, const vpColVector &v_y)
{
  if((graphList+graphNum)->curveNbr == v_y.getRows())
  {
    for(unsigned int i = 0;i < v_y.getRows();++i)
      this->plot(graphNum, i, x, v_y[i]);
  }
  else
    vpTRACE("error in plot vector : not the right dimension");
}
void vpPlot::plot(const unsigned int graphNum,
                  const double x, const vpRowVector &v_y)
{
  if((graphList+graphNum)->curveNbr == v_y.getRows())
  {
    for(unsigned int i = 0;i < v_y.getRows();++i)
      this->plot(graphNum, i, x, v_y[i]);
  }
  else
    vpTRACE("error in plot vector : not the right dimension");
}

void vpPlot::plot(const unsigned int graphNum,
                  const double x, const vpPoseVector &v_y)
{
  if((graphList+graphNum)->curveNbr == v_y.getRows())
  {
    for(unsigned int i = 0;i < v_y.getRows();++i)
      this->plot(graphNum, i, x, v_y[i]);
  }
  else
    vpTRACE("error in plot vector : not the right dimension");
}
void vpPlot::plot(const unsigned int graphNum,
                  const double x, const vpTranslationVector &v_y)
{
  if((graphList+graphNum)->curveNbr == v_y.getRows())
  {
    for(unsigned int i = 0;i < v_y.getRows();++i)
      this->plot(graphNum, i, x, v_y[i]);
  }
  else
    vpTRACE("error in plot vector : not the right dimension");
}

void vpPlot::plot(const unsigned int graphNum,
                  const double x, const vpRotationVector &v_y)
{
  if((graphList+graphNum)->curveNbr == v_y.size())
  {
    for(unsigned int i = 0;i < v_y.size();++i)
      this->plot(graphNum, i, x, v_y[i]);
  }
  else
    vpTRACE("error in plot vector : not the right dimension");
}


vpMouseButton::vpMouseButtonType
vpPlot::plot (const unsigned int graphNum, const unsigned int curveNum, const double x, const double y, const double z)
{
  return (graphList+graphNum)->plot(I,curveNum,x,y,z);
}

vpMouseButton::vpMouseButtonType
vpPlot::plot(const unsigned int graphNum, const double x, const vpColVector &v_y, const vpColVector &v_z)
{
  vpMouseButton::vpMouseButtonType button = vpMouseButton::none;
    if((graphList+graphNum)->curveNbr == v_y.getRows() && (graphList+graphNum)->curveNbr == v_z.getRows())
    {
        for(unsigned int i = 0;i < v_y.getRows();++i)
      button = this->plot(graphNum, i, x, v_y[i], v_z[i]);
    }
    else
        vpTRACE("error in plot vector : not the right dimension");
  return button;
}

void
vpPlot::navigate()
{
  vpMouseButton::vpMouseButtonType b = vpMouseButton::none;
  
  bool blocked = false;
  unsigned int iblocked = 0;
  vpImagePoint iP;
  
  while (b != vpMouseButton::button3)
  {
    if (!blocked)
    {
      vpDisplay::getPointerPosition(I,iP);
      for (unsigned int i = 0; i < graphNbr ; i++)
      {
        if (iP.inRectangle((graphList+i)->graphZone))
        {
          iblocked = i;
          break;
        }
      }
      if ((graphList+iblocked)->move(I, b))
      {
        (graphList+iblocked)->replot3D(I);
      }
      blocked = (graphList+iblocked)->blocked;
    }
    else
    {
      if ((graphList+iblocked)->move(I, b))
      {
        (graphList+iblocked)->replot3D(I);
      }
      blocked = (graphList+iblocked)->blocked;
    }
    vpTime::sleepMs(20);
  }
}

void
vpPlot::getPixelValue(const bool block)
{
  vpImagePoint iP;
  
  if (block)
    vpDisplay::getClick(I,iP);
  else
    vpDisplay::getPointerPosition(I,iP);
  
  for (unsigned int i = 0; i < graphNbr; i++)
  {
    if ((graphList+i)->getPixelValue(I,iP)) break;
  }
}

void
vpPlot::setTitle (const unsigned int graphNum, const std::string &title)
{
  (graphList+graphNum)->setTitle(title);
}

void
vpPlot::setUnitX (const unsigned int graphNum, const std::string &unitx)
{
  (graphList+graphNum)->setUnitX(unitx);
}

void
vpPlot::setUnitY (const unsigned int graphNum, const std::string &unity)
{
  (graphList+graphNum)->setUnitY(unity);
}

void
vpPlot::setUnitZ (const unsigned int graphNum, const std::string &unitz)
{
  (graphList+graphNum)->setUnitZ(unitz);
}

void
vpPlot::setLegend (const unsigned int graphNum, const unsigned int curveNum, const std::string &legend)
{
  (graphList+graphNum)->setLegend(curveNum, legend);
}

void 
vpPlot::resetPointList (const unsigned int graphNum)
{
  for (unsigned int i = 0; i < (graphList+graphNum)->curveNbr; i++)
    (graphList+graphNum)->resetPointList(i);
}

void
vpPlot::setThickness (const unsigned int graphNum, const unsigned int curveNum, const unsigned int thickness)
{
  (graphList+graphNum)->setCurveThickness(curveNum, thickness);
}

void
vpPlot::setGraphThickness (const unsigned int graphNum, const unsigned int thickness)
{
  for (unsigned int curveNum=0; curveNum < (graphList+graphNum)->curveNbr; curveNum++)
    (graphList+graphNum)->setCurveThickness(curveNum, thickness);
}

void
vpPlot::setGridThickness (const unsigned int graphNum, const unsigned int thickness)
{
  (graphList+graphNum)->setGridThickness(thickness);
}

void 
vpPlot::resetPointList (const unsigned int graphNum, const unsigned int curveNum)
{
  (graphList+graphNum)->resetPointList(curveNum);
}

void vpPlot::saveData(const unsigned int graphNum, const std::string &dataFile, const std::string &title_prefix)
{
  std::ofstream fichier;
  fichier.open(dataFile.c_str());

  unsigned int ind;
  double *p = new double[3];
  bool end=false;

  std::vector< std::list<double>::const_iterator > vec_iter_pointListx((graphList+graphNum)->curveNbr);
  std::vector< std::list<double>::const_iterator > vec_iter_pointListy((graphList+graphNum)->curveNbr);
  std::vector< std::list<double>::const_iterator > vec_iter_pointListz((graphList+graphNum)->curveNbr);

  fichier << title_prefix << (graphList+graphNum)->title << std::endl;

  for(ind=0;ind<(graphList+graphNum)->curveNbr;ind++)
  {
    vec_iter_pointListx[ind] = (graphList+graphNum)->curveList[ind].pointListx.begin();
    vec_iter_pointListy[ind] = (graphList+graphNum)->curveList[ind].pointListy.begin();
    vec_iter_pointListz[ind] = (graphList+graphNum)->curveList[ind].pointListz.begin();
//    (graphList+graphNum)->curveList[ind].pointListx.front();
//    (graphList+graphNum)->curveList[ind].pointListy.front();
//    (graphList+graphNum)->curveList[ind].pointListz.front();
  }

  while (end == false)
  {
    end = true;
    for(ind=0;ind<(graphList+graphNum)->curveNbr;ind++)
    {
//      if (!(graphList+graphNum)->curveList[ind].pointListx.outside()
//          && !(graphList+graphNum)->curveList[ind].pointListy.outside()
//          && !(graphList+graphNum)->curveList[ind].pointListz.outside())
      if((vec_iter_pointListx[ind] != (graphList+graphNum)->curveList[ind].pointListx.end())
        && (vec_iter_pointListy[ind] != (graphList+graphNum)->curveList[ind].pointListy.end())
        && (vec_iter_pointListz[ind] != (graphList+graphNum)->curveList[ind].pointListz.end()))
      {
        p[0] = *vec_iter_pointListx[ind];
        p[1] = *vec_iter_pointListy[ind];
        p[2] = *vec_iter_pointListz[ind];
//        p[0] = (graphList+graphNum)->curveList[ind].pointListx.value();
//        p[1] = (graphList+graphNum)->curveList[ind].pointListy.value();
//        p[2] = (graphList+graphNum)->curveList[ind].pointListz.value();

        fichier << p[0] << "\t" << p[1] << "\t" << p[2] << "\t";
        ++vec_iter_pointListx[ind];
        ++vec_iter_pointListy[ind];
        ++vec_iter_pointListz[ind];
//        (graphList+graphNum)->curveList[ind].pointListx.next();
//        (graphList+graphNum)->curveList[ind].pointListy.next();
//        (graphList+graphNum)->curveList[ind].pointListz.next();
//        if(!(graphList+graphNum)->curveList[ind].pointListx.nextOutside()
//           && !(graphList+graphNum)->curveList[ind].pointListy.nextOutside()
//           && !(graphList+graphNum)->curveList[ind].pointListz.nextOutside())
        if((vec_iter_pointListx[ind] != (graphList+graphNum)->curveList[ind].pointListx.end())
          && (vec_iter_pointListy[ind] != (graphList+graphNum)->curveList[ind].pointListy.end())
          && (vec_iter_pointListz[ind] != (graphList+graphNum)->curveList[ind].pointListz.end()))
          end = false;
      }
      else
      {
//        p[0] = (graphList+graphNum)->curveList[ind].pointListx.value();
//        p[1] = (graphList+graphNum)->curveList[ind].pointListy.value();
//        p[2] = (graphList+graphNum)->curveList[ind].pointListz.value();
        p[0] = (graphList+graphNum)->curveList[ind].pointListx.back();
        p[1] = (graphList+graphNum)->curveList[ind].pointListy.back();
        p[2] = (graphList+graphNum)->curveList[ind].pointListz.back();
        fichier << p[0] << "\t" << p[1] << "\t" << p[2] << "\t";
      }
    }
    fichier << std::endl;
  }

  delete[] p;
  fichier.close();
}

#elif !defined(VISP_BUILD_SHARED_LIBS)
// Work arround to avoid warning: libvisp_core.a(vpPlot.cpp.o) has no symbols
void dummy_vpPlot() {};
#endif