---

xyaxln.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xyaxln.cpp                                                        */
/* Autores: Carlos Henrique Levy e Jaudênia Cavalcante                       */
/* Data: 06 mar 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe especializada que define um eixo    */
/* linear com escala decimal.                                                */
/*****************************************************************************/

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

#include "xyaxln.h"
#include "xysdnm.h"
                                                                
const char* xy_id_xyaxln_cpp="$Id: xyaxln.cpp,v 1.24 2001/06/04 21:23:48 clinio Exp $";
                                                                
XYLinearAxis::XYLinearAxis (double mn,
                                  double mx,
                            XYCoordinate x,
                            XYCoordinate y,
                                        long color,
                                        double size,
                                        double rot,
                                        double step,
                                        XYScaleDecorator* decorator,
                                        XYText* title,
                                        xybool arrow,
                                        xybool visible)
                                        : XYAxis (mn, mx, x, y, color, size, rot, step,
                                                        decorator, title, arrow, visible)
{
}

XYLinearAxis::XYLinearAxis (double mn,
                                  double mx,
                            XYCoordinate x,
                            XYCoordinate y,
                                        long color,
                                        double size,
                                        double rot,
                                        xybool arrow,
                                        xybool visible)
                                        : XYAxis (mn, mx, x, y, color, size, rot, arrow,
                                                  visible)
{
}

double XYLinearAxis::defineMinPoint(double value, int x0, int y0) const
{
   setWindow();
   setViewport();

   double dx0, dy0;
   wdCanvas2World(x0, y0, &dx0, &dy0);

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

   // (x1, y1) ponto inferior esquerdo no eixo
   double x1, y1;
   position (&x1, &y1);

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

   if (mtEqual(rot_rad, 0.0))
      return _mx - (_mx - value) * _size / (x2 - dx0);
   else
      return _mx - (_mx - value) * _size / (y2 - dy0);
}

double XYLinearAxis::defineMaxPoint(double value, int x0, int y0) const
{
   setWindow();
   setViewport();

   double dx0, dy0;
   wdCanvas2World(x0, y0, &dx0, &dy0);

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

   // (x1, y1) ponto inferior esquerdo no eixo
   double x1, y1;
   position (&x1, &y1);

   if (mtEqual(sin(rot_rad), 0.0))
     return _mn + (value - _mn) * size() / (dx0 - x1);
   else
     return _mn + (value - _mn) * size() / (dy0 - y1);
}

double XYLinearAxis::valueInPoint(int x0, int y0) const
{
   // salva window e viewport para restaurar no final da funcao
   double ow_xmin,ow_xmax,ow_ymin,ow_ymax;
   int oc_xmin, ov_xmax, ov_ymin, ov_ymax;
   wdGetWindow(&ow_xmin,&ow_xmax,&ow_ymin,&ow_ymax);
   wdGetViewport(&oc_xmin,&ov_xmax,&ov_ymin,&ov_ymax);
   setWindow();
   setViewport();

   double dx0, dy0;
   wdCanvas2World(x0, y0, &dx0, &dy0);

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

   // (x1, y1) ponto inferior esquerdo no eixo
   double x1, y1;
   position (&x1, &y1);
   
   double value;
   if (mtEqual(sin(rot_rad), 0.0))
      value = _mn + (dx0 - x1) * (_mx - _mn) / size();
   else
      value = _mn + (dy0 - y1) * (_mx - _mn) / size();

   wdWindow(ow_xmin,ow_xmax,ow_ymin,ow_ymax);
   wdViewport(oc_xmin, ov_xmax, ov_ymin, ov_ymax);

   return value;
}

double XYLinearAxis::valueInPoint(double x0, double y0) const
{
   // salva window e viewport para restaurar no final da funcao
   double ow_xmin,ow_xmax,ow_ymin,ow_ymax;
   int oc_xmin, ov_xmax, ov_ymin, ov_ymax;
   wdGetWindow(&ow_xmin,&ow_xmax,&ow_ymin,&ow_ymax);
   wdGetViewport(&oc_xmin,&ov_xmax,&ov_ymin,&ov_ymax);

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

   // (x1, y1) ponto inferior esquerdo no eixo
   double x1, y1;
   position (&x1, &y1);

   double value;
   if (mtEqual(sin(rot_rad), 0.0))
      value = _mn + (x0 - x1) * (_mx - _mn) / size();
   else
      value = _mn + (y0 - y1) * (_mx - _mn) / size();

   wdWindow(ow_xmin,ow_xmax,ow_ymin,ow_ymax);
   wdViewport(oc_xmin, ov_xmax, ov_ymin, ov_ymax);

   return value;
}

void XYLinearAxis::pointInValue(double value, int& x0, int& y0) const
{
   // salva window e viewport para restaurar no final da funcao
   double ow_xmin,ow_xmax,ow_ymin,ow_ymax;
   int oc_xmin, ov_xmax, ov_ymin, ov_ymax;
   wdGetWindow(&ow_xmin,&ow_xmax,&ow_ymin,&ow_ymax);
   wdGetViewport(&oc_xmin,&ov_xmax,&ov_ymin,&ov_ymax);

   setWindow();
   setViewport();

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

   // (x1, y1) ponto inferior esquerdo no eixo
   double x1, y1;
   position (&x1, &y1);

   // (x1, y1) ponto inicial do marcador em relação a área de desenho
   double dx0 = x1 + (value - _mn) * _size / (_mx - _mn) * cos (rot_rad);
   double dy0 = y1 + (value - _mn) * _size / (_mx - _mn) * sin (rot_rad);

   wdWorld2Canvas(dx0, dy0, &x0, &y0);

   wdWindow(ow_xmin,ow_xmax,ow_ymin,ow_ymax);
   wdViewport(oc_xmin, ov_xmax, ov_ymin, ov_ymax);
}

void XYLinearAxis::pointInValue(double value, double& x0, double& y0) const
{
   // salva window e viewport para restaurar no final da funcao
   double ow_xmin,ow_xmax,ow_ymin,ow_ymax;
   int oc_xmin, ov_xmax, ov_ymin, ov_ymax;
   wdGetWindow(&ow_xmin,&ow_xmax,&ow_ymin,&ow_ymax);
   wdGetViewport(&oc_xmin,&ov_xmax,&ov_ymin,&ov_ymax);

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

   // (x1, y1) ponto inferior esquerdo no eixo
   double x1, y1;
   position (&x1, &y1);

   // (x1, y1) ponto inicial do marcador em relação a área de desenho
   x0 = x1 + (value - _mn) * _size / (_mx - _mn) * cos (rot_rad);
   y0 = y1 + (value - _mn) * _size / (_mx - _mn) * sin (rot_rad);

   wdWindow(ow_xmin,ow_xmax,ow_ymin,ow_ymax);
   wdViewport(oc_xmin, ov_xmax, ov_ymin, ov_ymax);
}

void XYLinearAxis::draw (void)
{
   draw (_xmin, _ymin, _xmax, _ymax);
}

void XYLinearAxis::draw (int xmin, int ymin, int xmax, int ymax) const
{
   if (visible() == xyfalse)    // invisível!!!
      return;

   int mode = cdClip(CD_CLIPON);

   // guarda a região de clip corrente
   int oldclip_xmin, oldclip_xmax, oldclip_ymin, oldclip_ymax;
   cdGetClipArea (&oldclip_xmin, &oldclip_xmax, &oldclip_ymin, &oldclip_ymax);
   // define nova região de clip
   cdClipArea(xmin, xmax, ymin, ymax);

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

   // (x1, y1) ponto inferior esquerdo no eixo
   double x1, y1;
   position (&x1, &y1);

   // (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;

   // desenha eixo com linha sólida e com cor definida
   // pelo usuário
   cdLineWidth (2);
   cdLineStyle (continuous);
   cdForeground (_color);

   // desenha eixo
   wdLine (x1, y1, x2, y2);

   // desenha seta no eixo
   if (_arrow == xytrue)
   {
      cdInteriorStyle (CD_SOLID);
      drawArrow(x1, y1, x2, y2);
   }

   // desenha a escala se ela foi definida e se passo tem um valor válido
   if (_step > 0.0)
   {
      // calcula coordenadas do primeiro tick
      double ex1, ey1, ex2, ey2;
      firstTick (ex1, ey1, ex2, ey2);

      // intervalos de deslocamento em relação as direções x e y
      double dx, dy;
      mtRotate (_step * _size / (_mx - _mn), 0.0, rot_rad, &dx, &dy);

      // calcula qual é o último tick a ser desenhado, o método é verificar,
      // a partir do último, qual é o primeiro tick que está dentro da área
      // a ser redesenhada
      int last_tick = (int) floor ((_mx - first()) / _step);

      // inicializa com posição do último tick
      double tex1 = ex1 + dx * last_tick;
      double tey1 = ey1 + dy * last_tick;
      double tex2 = ex2 + dx * last_tick;
      double tey2 = ey2 + dy * last_tick;

      // normalizando a área de desenho
      double pxmin = (double) (xmin - _xmin) / (_xmax - _xmin);
      double pymin = (double) (ymin - _ymin) / (_ymax - _ymin);
      double pxmax = (double) (xmax - _xmin) / (_xmax - _xmin);
      double pymax = (double) (ymax - _ymin) / (_ymax - _ymin);

      // verifica se tick está dentro da área a ser redesenhada
      while ((mtPointInRect(tex1, tey1, pxmin, pymin, pxmax, pymax) != xytrue)
             && (last_tick >= 0))
      {
         // próximo tick
         tex1 -= dx;
         tex2 -= dx;
         tey1 -= dy;
         tey2 -= dy;

         // atualiza número do último tick
         last_tick--;
      }

      // retorna, se não há tick para ser desenhado
      if (last_tick < 0)
            {
               cdClip(mode);
         // restaura a região de clip anterior
         cdClipArea(oldclip_xmin, oldclip_xmax, oldclip_ymin, oldclip_ymax);
               return;
            }

      // calcula qual é o primeiro tick a ser desenhado, o método é verificar,
      // a partir do primeiro, qual é o primeiro tick que está dentro da área
      // a ser redesenhada
      int first_tick = 0;

      // verifica se tick está dentro da área a ser redesenhada
      while ((mtPointInRect(ex1, ey1, pxmin, pymin, pxmax, pymax) != xytrue)
             && (first_tick < last_tick))
      {
         // próximo tick
         ex1 += dx;
         ex2 += dx;
         ey1 += dy;
         ey2 += dy;

         // atualiza número do primeiro tick
         first_tick++;
      }
        
      // desenha todos ticks presentes na area de redesenho
      for (int ntick = first_tick; ntick <= last_tick; ++ntick)
      {
         // desenha tick
         wdLine(ex1, ey1, ex2, ey2);

         // próximo tick
         ex1 += dx;
               ex2 += dx;
               ey1 += dy;
               ey2 += dy;
      }

      // desenha a decoração da escala
      if (_decor)
         _decor -> draw (this, first_tick, last_tick);
   }

   // desenha título se o mesmo foi definido, indicando localização na linha,
   // se direita, centro ou esquerda
   if (_title)
   {
      // consulta área do gráfico para desenho do eixo
      int xmn, ymn, xmx, ymx;
      getViewport(xmn, xmx, ymn, ymx);

      // define área do gráfico para desenho do título do eixo
      _title -> setViewport(xmn, xmx, ymn, ymx);
      _title -> draw();
   }

   cdClip(mode);
   cdClipArea(oldclip_xmin, oldclip_xmax, oldclip_ymin, oldclip_ymax);
}

void XYLinearAxis::boundingBox (int& bxmin, int& bymin, int& bxmax, int& bymax)
                                            const
{
   // ângulo de rotação em radianos
   double rot_rad = _rot * XY_PI / 180.0;

   // (x1, y1) ponto inferior esquerdo no eixo
   double x1, y1;
   position (&x1, &y1);

   // (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;

   // inicializando boundingBox com coordenadas do eixo
   double xmin = MIN(x1, x2);
   double ymin = MIN(y1, y2);
   double xmax = MAX(x1, x2);
   double ymax = MAX(y1, y2);

   // calcula boundingBox da seta do eixo
   if (_arrow == xytrue)
   {
      double bx1, bx2, by1, by2;
      boxArrow(x1, y1, x2, y2, bx1, by1, bx2, by2);

      xmin = MIN(bx1, xmin);
      xmax = MAX(bx2, xmax);
      ymin = MIN(by1, ymin);
      ymax = MAX(by2, ymax);
   }

   // contabiliza boundingBox da escala se a mesma foi definida e se passo tem
   // um valor válido
   if (_step > 0.0)
   {
      // atualiza boundingBox com as coordenadas do primeiro tick
      double ex1, ey1, ex2, ey2;
      firstTick (ex1, ey1, ex2, ey2);

      xmin = MIN3 (xmin, ex1, ex2);
      xmax = MAX3 (xmax, ex1, ex2);
      ymin = MIN3 (ymin, ey1, ey2);
      ymax = MAX3 (ymax, ey1, ey2);

      int bex1, bey1, bex2, bey2;

      // atualiza boundingBox com as coordenadas da decoração da escala
      if (_decor)
         _decor -> boundingBox (this, bex1, bey1, bex2, bey2);

      wdCanvas2World (bex1, bey1, &ex1, &ey1);
      wdCanvas2World (bex2, bey2, &ex2, &ey2);

      xmin = MIN3 (xmin, ex1, ex2);
      xmax = MAX3 (xmax, ex1, ex2);
      ymin = MIN3 (ymin, ey1, ey2);
      ymax = MAX3 (ymax, ey1, ey2);
   }

   // boundingBox em pixels
   wdWorld2Canvas (xmin, ymin, &bxmin, &bymin);
   wdWorld2Canvas (xmax, ymax, &bxmax, &bymax);
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group