---

sxy_axis.cpp

Go to the documentation of this file.

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

char *axis_cpp = "$Id: sxy_axis.cpp,v 1.7 2003/03/10 19:27:11 clinio Exp $";

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

#include <math.h>
#include <float.h>

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

#include "sxy_chart.h"
#include "sxy_axis.h"
#include "sxy_utils.h"

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

static const double A_SECOND = 1.0;
static const double A_MINUTE = A_SECOND*60;
static const double A_HOUR = A_MINUTE*60;
static const double A_DAY = A_HOUR*24;
static const double A_MONTH = A_DAY*30;
static const double A_YEAR = A_MONTH*12;

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

SXYAxis::SXYAxis(SXYChart* cht, SXYAxisOrientation orient, SXYAxisType atype, 
double xpos, double ypos, double size) {
  orientation = orient;
  type = atype;
  chart = cht;
  precision = 0;

  XYCartesian* graph = cht->getXyGraph();
  assert(graph);

  int ref_font_size = SXYChart::getFontSizeReference();
  double angle;

  if (orientation==HORIZONTAL_AXIS) {
    angle = 00.0;
    xy_decor_text = new XYMultiRasterText(XY_BLACK, 
         ref_font_size, XYRasterText::helvetica, XYRasterText::plain,
         XYRasterText::north, XYRasterText::horizontal);

    xy_label = new XYRasterText("x",
         XYCoordinate(0.5), XYCoordinate(ypos),
         XY_BLUE, ref_font_size+2, XYRasterText::helvetica,
         XYRasterText::plain, XYRasterText::center,
         XYRasterText::horizontal); 
  } 
  else {
    angle = 90.0;
    xy_decor_text = new XYMultiRasterText(XY_BLACK, 
         ref_font_size, XYRasterText::helvetica, XYRasterText::plain,
         XYRasterText::south, XYRasterText::vertBotTop);

    xy_label = new XYRasterText("y",
          XYCoordinate(xpos), XYCoordinate((double)0.5),
          XY_BLUE, ref_font_size+2, XYRasterText::helvetica,
          XYRasterText::plain, XYRasterText::center,
          XYRasterText::vertBotTop); 
  }

  assert(xy_decor_text);
  assert(xy_label);

  buildDecoratorAxis(angle, xpos, ypos, size);

  assert(xy_decor);
  assert(xy_axis);

  title_style = AT_MIDDLE;
  scale_orientation = ALIGNED;

  updateTitleStyle();
  updateScaleOrientation();

  xy_axis->leftTick((orientation==HORIZONTAL_AXIS ? xyfalse : xytrue));
  //xy_axis->leftTick(xytrue);

  graph->insert( xy_axis );
  tryScalesAdjust();
  graph->calcMaskArea();
}

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

SXYAxisType SXYAxis::getType() { 
  return type;
}

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

void SXYAxis::setPrecision(int p) {
  if (p < 0) return;
  precision = p;
}

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

int SXYAxis::getPixelValue( double position ) {
  int xp, yp;
  xy_axis->pointInValue(position,xp,yp);
  SXYAxisOrientation ori = getOrientation();

  if (ori==HORIZONTAL_AXIS) return xp;
  if (ori==VERTICAL_AXIS) return yp;

  assert(0);
  return -9999;
}

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

double SXYAxis::getPositionValue( int pix ) {
  SXYAxisOrientation ori = getOrientation();
  int xp, yp;

  if (ori==HORIZONTAL_AXIS) {
    xp = pix; yp = -999;
    return xy_axis->valueInPoint(xp,yp);
  }
  else if (ori==VERTICAL_AXIS) {
    xp = -999; yp = pix;
    return xy_axis->valueInPoint(xp,yp);
  }

  assert(0);
  return FLT_MAX;
}

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

SXYAxisOrientation SXYAxis::getOrientation() { 
  return orientation;
}

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

void SXYAxis::setColor(long int col) { 
   xy_axis->color(col); 
}

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

void SXYAxis::buildDecoratorAxis(double angle, double xpos, double ypos,
double size) {
  SXYAxisType type = getType();

  if (type == LINEAR_AXIS) {
     xy_decor = new XYNumericalScaleDecorator("%.2f", xy_decor_text);

     xy_axis = new XYLinearAxis(0, 10.0, xpos, ypos, XY_BLACK,
           size, angle, 1.0, xy_decor, xy_label, xytrue, xytrue);
      
     xy_axis->min(0);
     xy_axis->max(100);
     xy_axis->step(10);
  }
  else if (type == LOG_AXIS) {
     xy_decor = new XYLogScaleDecorator("%.2f", xy_decor_text);

     xy_axis = new XYLogAxis(0, 10.0, xpos, ypos, XY_BLACK,
           size, angle, 1.0, xy_decor, xy_label, xytrue, xytrue);

     xy_axis->min(1);
     xy_axis->max(10);
     xy_axis->step(1);
  }
  else if (type == TIME_AXIS) {
     xy_decor = new XYDateScaleDecorator(xy_decor_text);

     xy_axis = new XYLinearAxis(0, 10.0, xpos, ypos, XY_BLACK,
           size, angle, 1.0, xy_decor, xy_label, xytrue, xytrue);
      
     xy_axis->min(0);
     xy_axis->max(A_DAY);
     xy_axis->step(A_HOUR);
  }
  else {
     assert(0);
  }
}

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

void SXYAxis::updateScaleOrientation(void) {
   if (orientation == HORIZONTAL_AXIS) {
      if (scale_orientation == ALIGNED) {
         xy_decor_text->orientation( XYText::horizontal );
         xy_decor_text->align( XYText::north );
      }
      else {
         xy_decor_text->orientation( XYText::vertBotTop );
         xy_decor_text->align( XYText::east );
      }
   }
   else {
      if (scale_orientation == ALIGNED) {
         xy_decor_text->orientation( XYText::vertBotTop );
         xy_decor_text->align( XYText::south );
      }
      else {
         xy_decor_text->orientation( XYText::horizontal );
         xy_decor_text->align( XYText::east );
      }
   }
}

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

void SXYAxis::updateTitleStyle(void) {
   double aposx, aposy;
   if (xy_axis == NULL) return;
   xy_axis->position(&aposx, &aposy); 
   double as = xy_axis->size(); 

   if (orientation == HORIZONTAL_AXIS) {
      if (title_style == AT_MIDDLE) {
         xy_label->position( aposx + as/2, aposy*2/3 );
         xy_label->align( XYText::north );
         xy_label->orientation( XYText::horizontal );
      }
      else if (title_style == AT_END) {
         xy_label->position( aposx+as+aposx/3, aposy );
         xy_label->align( XYText::west );
         xy_label->orientation( XYText::horizontal );
      }
      else if (title_style == AT_END_ROTATED) {
         xy_label->position( aposx+as+aposx/2, aposy );
         xy_label->align( XYText::west );
         xy_label->orientation( XYText::vertBotTop );
      }
   }
   else {
      if (title_style == AT_MIDDLE) {
         xy_label->position( aposx*2/3, aposy + as/2 );
         xy_label->align( XYText::south );
         xy_label->orientation( XYText::vertBotTop );
      }
      else if (title_style == AT_END) {
         xy_label->position( aposx, aposy+as+aposy/3 );
         xy_label->align( XYText::west );
         xy_label->orientation( XYText::vertBotTop );
      }
      else if (title_style == AT_END_ROTATED) {
         xy_label->position( aposx, aposy+as+aposy/2 );
         xy_label->align( XYText::west );
         xy_label->orientation( XYText::horizontal );
      }
   }
}

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

void  SXYAxis::setScaleOrientation(SXYAxisScaleOrientation ori) {
   scale_orientation = ori;
   updateScaleOrientation();
}

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

SXYAxisScaleOrientation SXYAxis::getScaleOrientation(void) {
   return scale_orientation;
}

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

void SXYAxis::setDirection(SXYAxisDirection direction) {
  assert(xy_axis!=NULL);
  double ang = 45.0;
  if (orientation == HORIZONTAL_AXIS) {
    if (direction == NORMAL_AXIS) {
        ang = 0.0;
        xy_axis->leftTick(xyfalse);
    }
    else {
       ang = 180.0;
       xy_axis->leftTick(xyfalse);
    }
  }
  else {
     if (direction == NORMAL_AXIS) {
        xy_axis->leftTick(xytrue);
        ang = 90.0;
     }
     else {
        ang = 270.0;
        xy_axis->leftTick(xytrue);
     }
  }
  xy_axis->rotation(ang); 
  updateScaleOrientation();
}

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

SXYAxisDirection SXYAxis::getDirection(void) {
  assert(xy_axis!=NULL);
  if (orientation == HORIZONTAL_AXIS) {
     double ang = xy_axis->rotation();
     return ang == 0.0 ? NORMAL_AXIS : INVERTED_AXIS;
  }
  else {
     double ang = xy_axis->rotation();
     return ang == 90.0 ? NORMAL_AXIS : INVERTED_AXIS;
  }
}

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

void  SXYAxis::setTitleStyle(SXYAxisTitleStyle sty) {
   title_style = sty;
   updateTitleStyle();
}

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

SXYAxisTitleStyle SXYAxis::getTitleStyle(void) {
   return title_style;
}

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

long int SXYAxis::getColor(void) { 
   return xy_axis->color(); 
}

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

void SXYAxis::setTitleColor(long int col) { 
   xy_label->color(col); 
}

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

long int SXYAxis::getTitleColor(void) { 
   return xy_label->color(); 
}

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

void SXYAxis::setScaleColor(long int col) { 
   xy_decor_text->color(col); 
}

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

long int SXYAxis::getScaleColor(void) { 
   return xy_decor_text->color(); 
}

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

void SXYAxis::setPosition(double posx, double posy) { 
   xy_axis->position( posx, posy ); 
   updateTitleStyle();
   updateScaleOrientation();
}

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

void SXYAxis::getPosition(double& posx, double& posy) { 
   double px, py;
   xy_axis->position(&px, &py); 
   posx = px;
   posy = py;
}

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

void SXYAxis::setArrowVisibility(int vis) { 
   xy_axis->arrow(vis == 1 ? xytrue : xyfalse); 
}

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

int SXYAxis::getArrowVisibility(void) { 
   return xy_axis->arrow() == xytrue ? 1 : 0; 
}


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

void SXYAxis::setSize(double siz) { 
   xy_axis->size(siz); 
}

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

double SXYAxis::getSize(void) { 
   return xy_axis->size(); 
}

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

SXYAxis::~SXYAxis() {
   delete xy_decor_text;
   xy_decor_text = NULL;

   delete xy_decor;
   xy_decor = NULL;

   delete xy_label;
   xy_label = NULL;

   delete xy_axis;
   xy_axis = NULL;
}

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

void SXYAxis::setTitle(char* txt) {
  xy_label->text( (const char*)txt );
}

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

char* SXYAxis::getTitle(void) {
  return xy_label->text();
}

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

void SXYAxis::getScales(double& minimum, double& maximum) {
  assert(xy_axis != NULL);
//minimum = getDirection() == INVERTED_AXIS ? xy_axis->max() : xy_axis->min();
//maximum = getDirection() == INVERTED_AXIS ? xy_axis->min() : xy_axis->max();
  minimum = xy_axis->min();
  maximum = xy_axis->max();
}

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

void SXYAxis::setZoom(double ratio) {
  double vmin, vmax;
  getScales(vmin, vmax);

  if ( getType() == LOG_AXIS ) {
    double va = log10(vmin);
    double vb = log10(vmax);
    double dv = ( vb - va ) * -ratio;
    va = va - dv;
    vb = vb + dv;
    vmin = pow( 10, va );
    vmax = pow( 10, vb );
    if (vmin < 1) setScales(1, vmax);
    else setScales(vmin, vmax);
  } 
  else {
    double dv = (vmax - vmin) * -ratio;
    setScales(vmin-dv, vmax+dv);
  }
}

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

void SXYAxis::calcPrecision() {
  SXYAxisType type = getType();
  if (type == LOG_AXIS) {
     setFormat("%.0f");
  }
  else if (type == LINEAR_AXIS){
    double min, max;
    getScales(min, max);
    char prec[30];
    int precision = SXYUtil::calcPrecision(min, max);
    sprintf(prec, "%%.%df", precision);
    setFormat(prec);
  }
}

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

double SXYAxis::getStep(void) {
  assert(xy_axis != NULL);
  return xy_axis->step();
}

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

void SXYAxis::tryStepAdjust(void) {
  SXYAxisType type = getType();
  if (type == LOG_AXIS) {
     setStep(1.0);
  }
  else if (type == LINEAR_AXIS) {
    double vmin, vmax;
    getScales(vmin, vmax);
    double dv = fabs(vmax - vmin) / 10;
    setStep(dv);
  }
  else if (type == TIME_AXIS) {
    double vmin, vmax;
    getScales(vmin, vmax);
    double dv = fabs(vmax - vmin);
    if (dv >= A_YEAR) dv = A_MONTH;
    else if (dv >= A_MONTH) dv = A_DAY;
    else if (dv >= A_DAY) dv = A_HOUR;
    else if (dv >= A_HOUR) dv = A_MINUTE;
    else dv = dv/6;
    setStep(dv);
  }
}

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

void SXYAxis::tryScalesAdjust(void) {
  SXYAxisType type = getType();
  if (type == LOG_AXIS) {
    double vmin, vmax;
    getScales(vmin, vmax);
    int imin = (int)floor(log10(vmin));
    int imax = (int)ceil(log10(vmax));
    if (imin == imax) imax = imin +1;
    vmin = pow(10, imin);
    vmax = pow(10, imax);
    setScales(vmin, vmax);
  }
  else if (type == LINEAR_AXIS) {
    double vmin, vmax;
    getScales(vmin, vmax);
    double dv = (vmax - vmin) / 10;
    if (dv > 1) {
       vmin = floor(vmin);
       vmax = ceil(vmax);
    }
    setScales(vmin, vmax);
  }
  else if (type == TIME_AXIS) {
    double vmin, vmax;
    getScales(vmin, vmax);
    double dv = (vmax - vmin);
    if (dv < A_HOUR) {
       vmin = floor(vmin/A_MINUTE)*A_MINUTE;
       vmax = ceil(vmax/A_MINUTE)*A_MINUTE;
    }
    else if (dv < A_DAY) {
       vmin = floor(vmin/A_HOUR)*A_HOUR;
       vmax = ceil(vmax/A_HOUR)*A_HOUR;
    }
    else {
       vmin = floor(vmin/A_DAY)*A_DAY;
       vmax = ceil(vmax/A_DAY)*A_DAY;
    }
    setScales(vmin, vmax);
  }

  tryStepAdjust();
  if (precision == 0) {
     calcPrecision();
  }
  else {
    SXYAxisType type = getType();
    if (type == LOG_AXIS) {
       setFormat("%.0f");
    }
    else if (type == LINEAR_AXIS) {
      char prec[30];
      sprintf(prec, "%%.%df", precision);
      setFormat(prec);
    }
  }
}

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

void SXYAxis::setVisibility(int flag) {
  assert(xy_axis);
  xy_axis->visible(flag ? xytrue : xyfalse);
}

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

int SXYAxis::getVisibility(void) {
  assert(xy_axis);
  return xy_axis->visible() == xytrue ? 1 : 0;
}

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

void SXYAxis::setFormat(char* fmt) {
  assert(xy_decor);
  if (type == LINEAR_AXIS) {
      ((XYNumericalScaleDecorator*)xy_decor)->format(fmt);
  }
  else if (type == LOG_AXIS) {
     ((XYLogScaleDecorator*)xy_decor)->format(fmt);
  }
  else {
    assert(type != TIME_AXIS);
    assert(0);
  }
}

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

char* SXYAxis::getFormat(void) {
  assert(xy_decor);
  if (type == LINEAR_AXIS) 
     return ((XYNumericalScaleDecorator*)xy_decor)->format();
  else 
     return ((XYLogScaleDecorator*)xy_decor)->format();

  assert(0);
  return NULL;
}


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

void SXYAxis::setScales(double minimum, double maximum) {
  assert(xy_axis != NULL);
  assert(minimum < maximum);
  if (type == LOG_AXIS && minimum < 1e-15) minimum = 1;
// double mi = getDirection() == INVERTED_AXIS ? maximum : minimum;
// double ma = getDirection() == INVERTED_AXIS ? minimum : maximum;
//printf( "%d) min=%f, max=%f\n", (int)orientation, mi, ma );
//fflush(stdout);
  xy_axis->min(minimum);
  xy_axis->max(maximum);
}

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

void SXYAxis::setStep(double step) {
  assert(xy_axis != NULL);
  xy_axis->step( fabs(step) );
}

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

XYRasterText* SXYAxis::getXyDecorator(void) { 
  return xy_decor_text; 
}

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

XYRasterText* SXYAxis::getXyTitle(void) { 
  return xy_label; 
}

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

XYAxis* SXYAxis::getXyAxis(void) { 
  return xy_axis; 
}

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

void SXYAxis::setLayoutFrom(SXYAxis* other) {
   setTitle( other->getTitle() );
   setVisibility( other->getVisibility() );
   setArrowVisibility( other->getArrowVisibility() );
   setTitleStyle( other->getTitleStyle() );
   setScaleOrientation( other->getScaleOrientation() );

   setSize( other->getSize() );

   double posx, posy;
   other->getPosition(posx, posy);
   setPosition(posx, posy);
   setDirection(other->getDirection());

   setColor( other->getColor() );
   setScaleColor( other->getScaleColor() );
   setTitleColor( other->getTitleColor() );
}

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

SXYChart* SXYAxis::getChart(void) { 
  return chart; 
}

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

---

SXY
Tecgraf / PUC-Rio - Computer Graphics Technology Group