---

sxy_chart.cpp

Go to the documentation of this file.

// =======================================================================

char *chart_cpp = "$Id: sxy_chart.cpp,v 1.9 2003/04/25 20:21:43 clinio Exp $";

// =======================================================================

#include <float.h>
#include <assert.h>

extern "C" {
#include <iup.h>
#include <cd.h>
#include <cdiup.h>
}

#include "sxy_chart.h"
#include "sxy_curve.h"
#include "sxy_utils.h"

#define MAX_AREAS   32
#define MAX_CURVES  64
#define MAX_AXIS    10

// =======================================================================

// .......................................................................

SXYChart::SXYChart(SXYGraph* gra, double nxmin, double nymin, 
double nxmax, double nymax) {
  xmulstep = 1;
  ymulstep = 1;

  graph = gra;
  assert(graph != NULL);

  xy_xgrid = NULL;
  xy_ygrid = NULL;

  areas_vector = new SXYVector<SXYArea*>(MAX_AREAS, NULL);
  curves_vector = new SXYVector<SXYCurve*>(MAX_CURVES, NULL);
  xaxes_vector = new SXYVector<SXYAxis*>(MAX_AXIS, NULL);
  yaxes_vector = new SXYVector<SXYAxis*>(MAX_AXIS, NULL);

  assert(areas_vector);
  assert(curves_vector);
  assert(xaxes_vector);
  assert(yaxes_vector);

  int ref_font_size = SXYChart::getFontSizeReference();

  /* Criação do título XY */
  xy_title = new XYRasterText("Título",
        XYCoordinate((double)0.5), XYCoordinate((double)0.98),
        XY_DARK_BLUE, ref_font_size+4,
        XYRasterText::helvetica, XYRasterText::bold,
        XYRasterText::north, XYRasterText::horizontal);

  /* Criação do subtítulo XY */
  xy_subtitle = new XYRasterText("Subtítulo",
        XYCoordinate((double)0.5), XYCoordinate((double)0.95),
        XY_BLUE, ref_font_size+2, XYRasterText::helvetica,
        XYRasterText::plain, XYRasterText::north, 
        XYRasterText::horizontal);

  assert(xy_title);
  assert(xy_subtitle);

  /* Criação dos eixos */
  xy_xgrid = new XYGrid(1., 100., 0., XY_DARK_GRAY, XYObject::dotted, 0.0, 1.);
  xy_ygrid = new XYGrid(1., 100., 0., XY_DARK_GRAY, XYObject::dotted, 90.0, 1.);
  assert(xy_xgrid);
  assert(xy_ygrid);

  /* Criação da legenda */
  int leg_nlines = 1;
  int leg_ncols = 1; 
  xy_legend = new XYLegend( 
        XYCoordinate((double)0.5), 
        XYCoordinate((double)0.15), 
        leg_nlines, leg_ncols, xytrue, xytrue);
  assert(xy_legend);
  xy_legend->frameColor(XY_BLACK);
  xy_legend->backgroundColor(XY_WHITE);

  /* Verificação do tamanho e posição do gráfico XY no canvas */
  double nw = fabs(nxmax - nxmin);
  double nh = fabs(nymax - nymin);
  double px = nxmin;
  double py = nymin;

  /* Criação do gráfico XY */
  cdCanvas *cdcnv = graph->getCdCanvas();
  assert(cdcnv);
  xy_graph = new XYCartesian(cdcnv, px, py, nw, nh, xy_xgrid, xy_ygrid);
  assert(xy_graph);

  setGridType( HORIZONTAL_GRID, LINEAR_GRID );
  setGridType( VERTICAL_GRID, LINEAR_GRID );

  /* Inserção dos objetos XY no gráfico */
  xy_graph->insert( xy_title );
  xy_graph->insert( xy_subtitle );
  xy_graph->legend( xy_legend );

  /* Ajuste de atributos default */
  xy_graph->backgroundColor( XY_GRAY );
  xy_graph->calcMaskArea();
  xy_graph->maskAreaColor( XY_WHITE );
  xy_graph->distortion( xytrue );
  xy_graph->doubleBuffering( xytrue );
}

// .......................................................................

SXYChart::~SXYChart() {
  if (areas_vector) delete areas_vector;
  areas_vector = NULL;

  if (curves_vector) delete curves_vector;
  curves_vector = NULL;

  if (xaxes_vector) delete xaxes_vector;
  xaxes_vector = NULL;

  if (yaxes_vector) delete yaxes_vector;
  yaxes_vector = NULL;

  if (xy_title) delete xy_title; 
  xy_title = NULL;

  if (xy_subtitle) delete xy_subtitle; 
  xy_subtitle = NULL;

  if (xy_xgrid) delete xy_xgrid; 
  xy_xgrid = NULL;

  if (xy_ygrid) delete xy_ygrid; 
  xy_ygrid = NULL;

  if (xy_legend) delete xy_legend; 
  xy_legend = NULL;

  // Estamos com algum problema no XY...
  // delete xy_graph;  
  xy_graph = NULL;
}


// .......................................................................

long int SXYChart::getMainColor( void ) {
  return xy_graph->maskAreaColor();
}

// .......................................................................

void SXYChart::setMainColor( long int color ) {
  xy_graph->maskAreaColor( color );
}

// .......................................................................

long int SXYChart::getGridColor( void ) {
  return xy_xgrid->color();
}

// .......................................................................

void SXYChart::setGridColor( long int color ) {
  xy_xgrid->color( color );
  xy_ygrid->color( color );
}

// .......................................................................

long int SXYChart::getBackgroundColor( void ) {
  return xy_graph->backgroundColor();
}

// .......................................................................

void SXYChart::setBackgroundColor( long int color ) {
  xy_graph->backgroundColor( color );
}

// .......................................................................

void SXYChart::getLegendRelativePosition(double& x, double& y) {
   double px, py;
   xy_legend->position(&px,&py);
   x = px; y = py;
}

// .......................................................................

void SXYChart::setLegendRelativePosition(double x, double y) {
   xy_legend->position(x,y);
}

// .......................................................................

void SXYChart::setLegendVisibility(unsigned int flag) {
   xy_legend->visible( flag ? xytrue : xyfalse );
}

// .......................................................................

unsigned int SXYChart::getLegendVisibility(void) {
   return xy_legend->visible() ? 1 : 0;
}

// .......................................................................

XYRasterText* SXYChart::getXyTitle(void) {
   return xy_title;
}

// .......................................................................

XYRasterText* SXYChart::getXySubTitle(void) {
   return xy_subtitle;
}

// .......................................................................

XYLegend* SXYChart::getXyLegend(void) {
   return xy_legend;
}

// .......................................................................

SXYGraph* SXYChart::getGraph(void) {
  return graph;
}

// .......................................................................

void SXYChart::repaintChart(cdCanvas* cnv, SXYGraphDoubleBufferMode mode) {
  /* Redesenho do gráfico */
  xybool db = (mode == WITH_DOUBLE_BUFFER ? xytrue : xyfalse);
  xy_graph->setCdCanvas(cnv);
  rebuildMaskArea();
  xy_graph->doubleBuffering(db);
  xy_graph->clear();
  xy_graph->draw();
}

// .......................................................................

void SXYChart::rebuildMaskArea(void) {
  assert(xy_graph);
  xy_graph->calcMaskArea();
}

// .......................................................................

SXYArea* SXYChart::getArea(unsigned int a) {
   assert(areas_vector);
   return areas_vector->getElement(a);
}
// .......................................................................

unsigned int SXYChart::getNumAreas(void) {
   if (areas_vector == NULL) return 0;
   return areas_vector->getLength();
}

// .......................................................................

void SXYChart::insertArea(SXYArea* area) {
   assert(areas_vector);
   areas_vector->insertElement(area);
}

// .......................................................................

void SXYChart::removeArea(SXYArea* area) {
   assert(areas_vector);
   areas_vector->removeElement(area);
}

// .......................................................................

SXYCurve* SXYChart::getCurve(unsigned int c) {
   assert(curves_vector);
   return curves_vector->getElement(c);
}
// .......................................................................

unsigned int SXYChart::getNumCurves(void) {
   if (curves_vector == NULL) return 0;
   return curves_vector->getLength();
}

// .......................................................................

void SXYChart::insertCurve(SXYCurve* curve) {
   assert(curves_vector);
   curves_vector->insertElement(curve);
   assert(xy_legend);
   xy_legend->lines(getNumCurves());
}

// .......................................................................

void SXYChart::removeCurve(SXYCurve* curve) {
   assert(curves_vector);
   curves_vector->removeElement(curve);
   assert(xy_legend);
   xy_legend->lines(getNumCurves());
}

// .......................................................................

SXYAxis* SXYChart::getAxis(SXYAxisOrientation orientation, unsigned int a) {
   if (orientation == HORIZONTAL_AXIS) {
      assert(xaxes_vector);
      return xaxes_vector->getElement(a);
   } 
   else {
      assert(yaxes_vector);
      return yaxes_vector->getElement(a);
   }
}
// .......................................................................

unsigned int SXYChart::getNumAxes(SXYAxisOrientation orientation) {
   if (orientation == HORIZONTAL_AXIS) {
      assert(xaxes_vector);
      return xaxes_vector->getLength();
   } 
   else {
      assert(yaxes_vector);
      return yaxes_vector->getLength();
   }
}

// .......................................................................

void SXYChart::insertAxis(SXYAxisOrientation orientation, SXYAxis* axis) {
   if (orientation == HORIZONTAL_AXIS) {
      assert(xaxes_vector);
      xaxes_vector->insertElement(axis);
   } 
   else {
      assert(yaxes_vector);
      yaxes_vector->insertElement(axis);
   }
}

// .......................................................................

void SXYChart::removeAxis(SXYAxisOrientation orientation, SXYAxis* axis) {
   if (orientation == HORIZONTAL_AXIS) {
      assert(xaxes_vector);
      xaxes_vector->removeElement(axis);
   } 
   else {
      assert(yaxes_vector);
      yaxes_vector->removeElement(axis);
   }
}

// .......................................................................

char* SXYChart::getTitle(void) {
  assert(xy_title);
  return xy_title->text();
}

// .......................................................................

char* SXYChart::getSubTitle(void) {
  assert(xy_subtitle);
  return xy_subtitle->text();
}

// .......................................................................

void SXYChart::setTitle(char* txt) {
   xy_title->text( (const char*)txt );
}

// .......................................................................

void SXYChart::setSubTitle(char* txt) {
   xy_subtitle->text( (const char*)txt );
}

// .......................................................................

XYCartesian* SXYChart::getXyGraph(void) {
   return xy_graph;
}

// .......................................................................

int SXYChart::getFontSizeReference(void) {
   return 8;
}

// .......................................................................

long int SXYChart::getTitleColor(void) {
   assert(xy_title);
   return xy_title->color();
}

// .......................................................................

long int SXYChart::getSubTitleColor(void) {
   assert(xy_subtitle);
   return xy_subtitle->color();
}

// .......................................................................

void SXYChart::setGridType(SXYGridOrientation orientation, SXYGridType type) {
  if ( orientation == HORIZONTAL_GRID ) {
     if (xy_xgrid != NULL) { delete xy_xgrid; xy_xgrid = NULL; }

     if (type == LOG_GRID) {
        xy_xgrid = new XYGridLog(1., 100., 1., XY_DARK_GRAY, 
              XYObject::dotted, 0.0, 1.);
        xy_xgrid->min(.1); xy_xgrid->max(10.); xy_xgrid->step(.5);
     }
     else if ( type == LINEAR_GRID ) {
        xy_xgrid = new XYGrid(0., 100., 0., XY_DARK_GRAY, 
              XYObject::dotted, 0.0, 1.);
        xy_xgrid->min(0.); xy_xgrid->max(100.); xy_xgrid->step(10.);
     }
     else {
        assert(0);
     }
     assert( xy_xgrid );
     xy_xgrid->visible( xytrue );
     xy_graph->setGridH( xy_xgrid );
     xgrid_type = type;
  }
  else if (orientation == VERTICAL_GRID ) {
     if (xy_ygrid != NULL) { delete xy_ygrid; xy_ygrid = NULL; }

     if (type == LOG_GRID) {
        xy_ygrid = new XYGridLog(1., 100., 1., XY_DARK_GRAY, 
              XYObject::dotted, 90.0, 1.);
        xy_ygrid->min(.1); xy_ygrid->max(10.); xy_ygrid->step(.5);
     }
     else if ( type == LINEAR_GRID ) {
        xy_ygrid = new XYGrid(0., 100., 0., XY_DARK_GRAY, 
              XYObject::dotted, 90.0, 1.);
        xy_ygrid->min(0.); xy_ygrid->max(100.); xy_ygrid->step(10.);
     }
     else {
        assert(0);
     }
     assert( xy_ygrid );
     xy_ygrid->visible( xytrue );
     xy_graph->setGridV( xy_ygrid );
     ygrid_type = type;
  }
  else {
     assert(0);
  }
}

// .......................................................................

void SXYChart::setGridPosition(SXYGridOrientation orientation,
double xp, double yp) {
  if (orientation == HORIZONTAL_GRID) {
     assert(xy_xgrid);
     xy_xgrid->position(xp, yp);
  }
  else {
     assert(xy_ygrid);
     xy_ygrid->position(xp, yp);
  }
}

// .......................................................................

void SXYChart::setGridDirection(SXYGridOrientation orientation,
SXYGridDirection direction) {
  XYGrid* xygr = orientation == HORIZONTAL_GRID ? xy_xgrid : xy_ygrid;
  assert(xygr);
  double ang = 45.0;
  if (orientation == HORIZONTAL_GRID) {
     if (direction == NORMAL_GRID) {
       ang = 0.0;
       xygr->leftTick(xyfalse);
    }
    else {
       ang = 180.0;
       xygr->leftTick(xyfalse);
    }
  }
  else {
    if (direction == NORMAL_GRID) {
       xygr->leftTick(xytrue);
       ang = 90.0;
    }
    else {
       ang = 270.0;
       xygr->leftTick(xytrue);
    }
  }
  xygr->rotation(ang);
}

// .......................................................................

SXYGridDirection SXYChart::getGridDirection(SXYGridOrientation orientation) {
  XYGrid* xygr = orientation == HORIZONTAL_GRID ? xy_xgrid : xy_ygrid;
  assert(xygr);
  if (orientation == HORIZONTAL_GRID) {
     double ang = xygr->rotation();
     return ang == 0.0 ? NORMAL_GRID : INVERTED_GRID;
  }
  else {
     double ang = xygr->rotation();
     return ang == 90.0 ? NORMAL_GRID : INVERTED_GRID;
  }
}

// .......................................................................

SXYGridType SXYChart::getGridType(SXYGridOrientation orientation) {
  return orientation == HORIZONTAL_GRID ? xgrid_type : ygrid_type;
}

// .......................................................................

unsigned int SXYChart::getGridVisibility(SXYGridOrientation orientation) {
  XYGrid* xygr = orientation == HORIZONTAL_GRID ? xy_xgrid : xy_ygrid;
  assert(xygr);
  return xygr->visible() == xytrue ? 1 : 0;
}

// .......................................................................

void SXYChart::getGridScales(SXYGridOrientation orientation,
double& min, double& max) {
  XYGrid* xygr = orientation == HORIZONTAL_GRID ? xy_xgrid : xy_ygrid;
  assert(xygr);
  min = xygr->min();
  max = xygr->max();
}

// .......................................................................

double SXYChart::getGridStep(SXYGridOrientation orientation) {
  XYGrid* xygr = orientation == HORIZONTAL_GRID ? xy_xgrid : xy_ygrid;
  assert(xygr);
  return xygr->step();
}

// .......................................................................

void SXYChart::setTitleColor(long int col) {
   assert(xy_title);
   xy_title->color(col);
}

// .......................................................................

void SXYChart::setSubTitleColor(long int col) {
   assert(xy_subtitle);
   xy_subtitle->color(col);
}

// .......................................................................

void SXYChart::setGridVisibility(SXYGridOrientation orientation, 
unsigned int flag) {
  XYGrid* xygr = orientation == HORIZONTAL_GRID ? xy_xgrid : xy_ygrid;
  assert(xygr);
  xygr->visible(flag ? xytrue : xyfalse);
}

// .......................................................................

double SXYChart::getGridAutoMultipleStep(SXYGridOrientation orientation ) {
  double mst = orientation == HORIZONTAL_GRID ? xmulstep : ymulstep;
  return mst; 
}

// .......................................................................

void SXYChart::setGridAutoMultipleStep(SXYGridOrientation orientation, 
double mulstep ) {
  if (orientation == HORIZONTAL_GRID) xmulstep = mulstep;
  else ymulstep = mulstep;
}

// .......................................................................

void SXYChart::setGridScales(SXYGridOrientation orientation, 
double min, double max) {
  XYGrid* xygr = orientation == HORIZONTAL_GRID ? xy_xgrid : xy_ygrid;
  assert(xygr);
  xygr->min(min);
  xygr->max(max);
}

// .......................................................................

void SXYChart::tryGridAdjust(void) {
  SXYAxis* xax = getAxis(HORIZONTAL_AXIS, 0);
  double xmin, xmax; 
  xax->getScales(xmin, xmax);
  double xstep = xax->getStep();
  setGridScales(HORIZONTAL_GRID, xmin, xmax);
  setGridStep(HORIZONTAL_GRID, xstep*xmulstep);
  setGridDirection(HORIZONTAL_GRID, (SXYGridDirection)xax->getDirection());

  SXYAxis* yax = getAxis(VERTICAL_AXIS, 0);
  double ymin, ymax; 
  yax->getScales(ymin, ymax);
  double ystep = yax->getStep();
  setGridScales(VERTICAL_GRID, ymin, ymax);
  setGridStep(VERTICAL_GRID, ystep*ymulstep);
  setGridDirection(VERTICAL_GRID, (SXYGridDirection)yax->getDirection());
}

// .......................................................................

void SXYChart::setZoom(double xratio, double yratio) {
  unsigned int nxaxes = getNumAxes(HORIZONTAL_AXIS);
  for (unsigned int ix = 0; ix < nxaxes; ix++) {
    SXYAxis* xax = getAxis(HORIZONTAL_AXIS, ix);
    xax->setZoom(xratio);
  }
  unsigned int nyaxes = getNumAxes(VERTICAL_AXIS);
  for (unsigned int iy = 0; iy < nyaxes; iy++) {
    SXYAxis* yax = getAxis(VERTICAL_AXIS, iy);
    yax->setZoom(yratio);
  }
  tryGridAdjust();
}

// .......................................................................

void SXYChart::setGridSize(SXYGridOrientation orientation, double size) {
  XYGrid* xygr = orientation == HORIZONTAL_GRID ? xy_xgrid : xy_ygrid;
  assert(xygr);
  xygr->size(size);
}

// .......................................................................

void SXYChart::setGridStep(SXYGridOrientation orientation, double val) {
  XYGrid* xygr = orientation == HORIZONTAL_GRID ? xy_xgrid : xy_ygrid;
  assert(xygr);
  xygr->step(val);
}

// .......................................................................

void SXYChart::fitScale(SXYAxisOrientation orientation) {
  unsigned int naxis = getNumAxes(orientation);
  for( unsigned int i = 0; i < naxis; i++ ) {
    double xmin = FLT_MAX, xmax = -FLT_MAX, ymin = FLT_MAX, ymax = -FLT_MAX;
    SXYAxis *axis = getAxis(orientation, i);
    unsigned int ncurves = getNumCurvesWithAxis(axis, orientation);

    /* Se não houver curvas, não é necessário mais testar nada. */
    if (ncurves == 0) continue;

    /* Loop sobre todas as curvas */
    for (unsigned int j = 0; j < ncurves; j++) {
      double xi, xa, yi, ya;
      SXYCurve *curve = getCurveFromAxis(j, axis, orientation);
      curve->getLimits(xi, xa, yi, ya);
      if (xi < xmin) xmin = xi;
      if (xa > xmax) xmax = xa;
      if (yi < ymin) ymin = yi;
      if (ya > ymax) ymax = ya;
    }

    /* Cálculos dos ajustes finais das escalas */
    //SXYUtil::calcMinMax(xmin, xmax, ymin, ymax);
    if (orientation == HORIZONTAL_AXIS) {
       if (axis->getType() == LINEAR_AXIS) SXYUtil::calcZoomOut(xmin, xmax);
       axis->setScales(xmin, xmax);
    }
    else {
       if (axis->getType() == LINEAR_AXIS) SXYUtil::calcZoomOut(ymin, ymax);
       axis->setScales(ymin, ymax);
    }
    axis->tryScalesAdjust();
    tryGridAdjust();
  }
}

// .......................................................................

void SXYChart::setAllAxis(SXYAxisOrientation orientation, 
double vmin, double vmax) {
  unsigned int naxis = getNumAxes(orientation);
  for( unsigned int i = 0; i < naxis; i++ ) {
    SXYAxis *axis = getAxis(orientation, i);
    axis->setScales(vmin, vmax);
    axis->tryScalesAdjust();
    tryGridAdjust();
  }
}

// .......................................................................

SXYCurve* SXYChart::getCurveFromAxis(int n, SXYAxis *axis, 
SXYAxisOrientation orientation) {
  int found = 0;
  for (unsigned int i = 0; i < getNumCurves(); i++) {
    SXYAxis *a = NULL;
    SXYCurve *curve = getCurve(i);

    if (orientation == HORIZONTAL_AXIS) a = curve->getHorizontalAxis();
    else a = curve->getVerticalAxis();

    if (a == axis) {
      if (found == n) return curve;
      else found++;
    }
  }
  return NULL;
}

// .......................................................................

unsigned int SXYChart::getNumCurvesWithAxis(SXYAxis* axis, 
SXYAxisOrientation orientation) {
  unsigned int ncurves = getNumCurves();
  int tot = 0;
  assert(axis);

  for (unsigned int c = 0; c < ncurves; c++) {
    SXYAxis *a = NULL;
    SXYCurve *curve = getCurve(c);

    if (orientation == HORIZONTAL_AXIS) a = curve->getHorizontalAxis();
    else a = curve->getVerticalAxis();

    if (a == axis) tot++;
  }

  return tot;
}

// .......................................................................

void SXYChart::setLayoutFrom(SXYChart* other) {
   setTitle( other->getTitle() );
   setSubTitle( other->getSubTitle() );
   setTitleColor( other->getTitleColor() );
   setSubTitleColor( other->getSubTitleColor() );
               
   setBackgroundColor( other->getBackgroundColor() );
   setGridColor( other->getGridColor() );
   setMainColor( other->getMainColor() );

   double px, py;
   other->getLegendRelativePosition(px, py);
   setLegendRelativePosition(px, py);
}


// .......................................................................

---

SXY
Tecgraf / PUC-Rio - Computer Graphics Technology Group