---

xyax.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xyax.cpp                                                          */
/* Autores: Carlos Henrique Levy e Jaudênia Cavalcante                       */
/* Data: 26 fev 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe abstrata que define as característi */
/* cas de um eixo. Um eixo representa a escala de um tipo de coordenada. A   */
/* sua representação visual é composta de uma linha reta podendo ter ou não  */
/* terminador (seta), textos próximo a reta indicando a escala e por último  */
/* um título para o eixo.                                                    */
/*****************************************************************************/

#include <stdlib.h>
#include <math.h>
#include <stdio.h>

#include "xyax.h"

const char* xy_id_xyax_cpp="$Id: xyax.cpp,v 1.22 1999/12/09 21:47:46 rborges Exp $";                                                            
const double XYAxis::_arrow_size = 0.03;
                                                                
XYAxis::XYAxis (double mn,
                      double mx,
                XYCoordinate x,
                XYCoordinate y,
                      long color,
                      double size,
                      double rot,
                      double step,
                      XYScaleDecorator* decorator,
                      XYText* title,
                      xybool arrow,
                      xybool visible)
                      : XYObject(x, y, visible),
                        _mn(mn), _mx(mx), _color(color), _size(size), _rot(rot),
                        _step(step), _referenceTick(mn), _decor(decorator),
                        _title(title), _arrow(arrow), _leftTick(xytrue)
{
}

XYAxis::XYAxis (double mn,
                      double mx,
                XYCoordinate x,
                XYCoordinate y,
                      long color,
                      double size,
                      double rot,
                      xybool arrow,
                      xybool visible)
                      : XYObject(x, y, visible),
                        _mn(mn), _mx(mx), _color(color), _size(size), _rot(rot),
                        _step(0), _referenceTick(mn), _decor(NULL),
                        _title(NULL), _arrow(arrow), _leftTick(xytrue)
{
}

XYAxis::XYAxis (double mn,
                      double mx,
                XYCoordinate x,
                XYCoordinate y,
                      long color,
                      double size,
                      double rot,
                      double step,
                      xybool arrow,
                      xybool visible)
                      : XYObject(x, y, visible),
                        _mn(mn), _mx(mx), _color(color), _size(size), _rot(rot),
                       _step(step), _referenceTick(mn), _decor(NULL),
                       _title(NULL), _arrow(arrow), _leftTick(xytrue)
{
}

void XYAxis::min (double min)
{
   _mn = min;
}

double XYAxis::min (void) const
{
   return _mn;
}

void XYAxis::max (double max)
{
   _mx = max;
}

double XYAxis::max (void) const
{
   return _mx;
}

void XYAxis::color (long c)
{
   _color = c;
}

long XYAxis::color (void) const
{
   return _color;
}

void XYAxis::size (double sz)
{
   if ((0.0 <= sz) && (sz <= 1.0))
      _size = sz;
}

double XYAxis::size (void) const
{
   return _size;
}

void XYAxis::rotation (double rot)
{
   _rot = rot;
}

double XYAxis::rotation (void) const
{
   return _rot;
}

void XYAxis::step (double s)
{
   _step = s;
}

double XYAxis::step (void) const
{
   return _step;
}

void XYAxis::referenceTick (double f)
{
   _referenceTick = f;
}

double XYAxis::referenceTick (void) const
{
   return _referenceTick;
}

void XYAxis::leftTick (xybool left)
{
   _leftTick = left;
}

xybool XYAxis::leftTick (void) const
{
   return _leftTick;
}

double XYAxis::first (void) const
{
   double first = _referenceTick;

   if (_referenceTick < _mn)
     for ( ;first < _mn; first += _step)
        ;
   else
     //for ( ;first - _step > _mn; first -= _step)
     for ( ;mtLessEqual(_mn, first - _step); first -= _step)
        ;

   return first;
}

void XYAxis::scaleDecorator(XYScaleDecorator* decor)
{
   _decor = decor;
}

XYScaleDecorator* XYAxis::scaleDecorator(void) const
{
   return _decor;
}
                                
void XYAxis::arrow (xybool a)
{
   _arrow = a;
}

xybool XYAxis::arrow (void) const
{
   return _arrow;
}

void XYAxis::title (XYText* t)
{
   _title = t;
}

XYText* XYAxis::title (void) const
{
   return _title;
}

double XYAxis::transform (double e) const
{
   return e;
}

double XYAxis::defineMinPoint(double, int, int) const
{
   return _mn;
}

double XYAxis::defineMaxPoint(double, int, int) const
{
   return _mx;
}

double XYAxis::valueInPoint(int, int) const
{
   return (_mx - _mn) / 2;
}

double XYAxis::valueInPoint(double, double) const
{
   return (_mx - _mn) / 2;
}

xybool XYAxis::pick (int px, int py)
{
   if (visible() == xyfalse)    // invisível!!!
      return xyfalse;

   // limites da menor caixa que contém um eixo
   int x1, y1, x2, y2;
   boundingBox (x1, y1, x2, y2);

   return mtPointInRect (px, py, x1, y1, x2, y2);
}

xybool XYAxis::fence (int x2, int y2, int x3, int y3)
{
   if (visible() == xyfalse)           // invisível!!!
      return xyfalse;

   // limites da menor caixa que contém um eixo
   int x0, y0, x1, y1;
   boundingBox (x0, y0, x1, y1);

   return mtInclude (x0, y0, x1, y1, x2, y2, x3, y3);
}

void XYAxis::firstTick (double& tx1, double& ty1, double& tx2, double& ty2)
                                    const
{
   double tick_size = 0.01;

   // ângulo de rotação em radianos
   double rot_rad = _rot * XY_PI / 180.0;

   // primeira posição normalizada no eixo em relação ao canvas
   double f = (first() - _mn) * _size / (_mx - _mn);

   // consulta posição de desenho do eixo
   double x0, y0;
   position (&x0, &y0);

   // (x1, y1) ponto inferior esquerdo no eixo
   double x1 = x0 + f * cos (rot_rad);
   double y1 = y0 + f * sin (rot_rad);

   // (x2, y2) ponto superior direito no eixo
   double x2 = x1 + _size * cos (rot_rad);
   double y2 = y1 + _size * sin (rot_rad);

   // controle de ponto flutuante
   if (mtEqual(x1, x2))
      x2 = x1;
   if (mtEqual(y1, y2))
      y2 = y1;

   // (tx1, ty1) coordenadas sobre o eixo
   tx1 = x1;
   ty1 = y1;

   if (_leftTick)
      mtRotate(tick_size, 0.0, rot_rad + XY_PI / 2.0, &tx2, &ty2);
   else
      mtRotate(tick_size, 0.0, rot_rad - XY_PI / 2.0, &tx2, &ty2);

   tx2 += x1;
   ty2 += y1;

   // controle de ponto flutuante
   if (mtEqual(tx1, tx2))
      tx2 = tx1;
   if (mtEqual(ty1, ty2))
      ty2 = ty1;
}

void XYAxis::drawArrow(double x0, double y0, double x1, double y1) const
{
   // intervalo normalizado em relação as direções x e y
   double ca = (x1 - x0) / mtDistance(x0, y0, x1, y1);
   double sa = (y1 - y0) / mtDistance(x0, y0, x1, y1);

   // tamanho da seta em relação às coordenadas da janela
   double as = mtDistance(x0, y0, x1, y1) * _arrow_size;

   //desenha a seta
   wdBegin (CD_FILL);
   wdVertex(x1 + 0.3333 * as * sa, y1 - 0.3333 * as * ca);
   wdVertex(x1 + as * ca, y1 + as * sa);
   wdVertex(x1 - 0.3333 * as * sa, y1 + 0.3333 * as * ca);
   wdEnd();
}

void XYAxis::boxArrow(double x0, double y0, double x1, double y1, double& xmin,
                                  double& ymin, double& xmax, double& ymax) const
{
   // intervalo normalizado em relação as direções x e y
   double ca = (x1 - x0) / mtDistance(x0, y0, x1, y1);
   double sa = (y1 - y0) / mtDistance(x0, y0, x1, y1);

   // tamanho da seta em relação às coordenadas da janela
   double as = mtDistance(x0, y0, x1, y1) * _arrow_size;

   // boundinBox da seta
   xmin = xmax = x1 + 0.3333 * as * sa;

   if (x1 + as * ca < xmin)
      xmin = x1 + as * ca;
   else if (x1 + as * ca > xmax)
      xmax = x1 + as * ca;

   if ((x1 - 0.3333 * as * sa) < xmin)
      xmin = x1 - 0.3333 * as * sa;
   else if ((x1 - 0.3333 * as * sa) > xmax)
      xmax = x1 - 0.3333 * as * sa;

   ymin = ymax = y1 + 0.3333 * as * ca;

   if (y1 + as * sa < ymin)
      ymin = y1 + as * sa;
   else if (y1 + as * sa > ymax)
      ymax = y1 + as * sa;

   if ((y1 - 0.3333 * as * ca) < ymin)
      ymin = y1 - 0.3333 * as * ca;
   else if ((y1 - 0.3333 * as * ca) > ymax)
      ymax = y1 - 0.3333 * as * ca;
}

void XYAxis::adjustSize (void)
{
   if ((_xmin == _xmax) && (_ymin == _ymax))
      return;

   // passo normalizado na grade em relação ao canvas
   double step_n = _step * _size / (_mx - _mn);

   // ângulo de rotação em radianos
   double rot_rad = _rot * XY_PI / 180.0;

   // intervalo de deslocamento em relação as direções x e y
   double dx;
   double dy;
   mtRotate (step_n, 0, rot_rad, &dx, &dy);

   // calcula o passo, em pixels
   int pdx, pdy;
   wdWorld2Canvas (dx, dy, &pdx, &pdy);

   // volta o passo para normalizado para recalcular o novo tamanho
   wdCanvas2World (pdx, pdy, &dx, &dy);

   step_n = mtDistance (dx, 0.0, 0.0, dy);

   _size = (_mx - _mn) * step_n / _step;

   int pdx1;
   wdWorld2Canvas (_step * _size / (_mx - _mn), 0, &pdx1, 0);

   // fprintf (logfile, "\nXYAxis::adjustSize pdx = %d %d", pdx, pdx1);
}

void XYAxis::calcMinMax(double *min, double *max, double *step) const
{
   #define OCUP_MIN   0.8 // taxa de ocupação no eixo
   #define MAX_DIGIT  8   // dígitos representados num inteiro
   #define MIN_MARCAS 4   // número mínimo de ticks
   #define MAX_MARCAS 12  // número máximo de ticks

   double y, expo;
   int expoente, passo, i;
   int imax, imin, resid, rmin, zero, zmin, exces, emin;

   if (*max == *min)
      if (*max == 0)
      {
               *max = (double)  1.0;
               *min = (double) -1.0;
      }
      else
      {
               *max += (double) (0.1 * fabs(*max));
               *min -= (double) (0.1 * fabs(*min));
      }

   if (*max + *min >= 0.0)
      y = *max;
   else
      y = - *min;

   expoente = (int) floor(log10(y));
   expo = (double) pow(10.0, expoente);

   imax = 0;

   if (*max >= 0.0)
      while (imax * expo < *max) imax++;
   else
      while ((imax - 1) * expo >= *max) imax--;

   imin = 0;

   if (*min > 0.0)
      while ((imin + 1) * expo <= *min) imin++;
   else
      while (imin * expo > *min) imin--;

   i = 1;

   while (((*max - *min) < OCUP_MIN * (imax - imin) * expo) && (i < MAX_DIGIT))
   {
      i++;
      expoente--;
      expo = (double) pow(10.0, expoente);

      imax = 10 * imax;
      imin = 10 * imin;

      while ((imax - 1) * expo >= *max)
               imax--;
      while ((imin + 1) * expo <= *min)
               imin++;
   }

   *step = (double) (imax - imin + 1);

   if (*step > MAX_MARCAS)
   {
      *step = (double) 0;
      zmin = 30000;
      rmin = 30000;
      emin = 30000;

      for (i = MIN_MARCAS; i <= MAX_MARCAS; i++)
      {
               passo = (int) ceil((double) (imax - imin) / (i - 1));

               if (imax >= 0 && imin <= 0)
              zero = (int) (imin + passo * ceil(- (double) imin / passo));
               else
                  zero = 0;

               resid = (i - 1) * passo - (imax - imin);

               if (resid >= zero)
                  exces = 0;
               else
                  exces = zero = resid;

               if ((emin != 0 && exces == 0) || ( resid <= rmin && ((emin != 0) ||
                   (emin == 0 && exces == 0 ))))
               {
                  *step = (double) i;
                  emin = exces;
                  rmin = resid;
                  zmin = zero;
               }
      }

      if (emin == 0)
      {
               imin -= zmin;
               imax += rmin - zmin;
      }
      else
         imin -= rmin;
   }
   else
      while (*step < MIN_MARCAS)
         *step += *step - 1;

   *max = imax * expo;
   *min = imin * expo;
   *step = (*max - *min) / (*step - 1);
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group