---

xyaxpl.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xyaxpl.cpp                                                        */
/* Autor: Camilo da Foseca Freire                                            */
/* Data: 06 jul 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe especializada que define um eixo    */
/* polar.                                                                    */
/*****************************************************************************/

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

#include "xyaxpl.h"
#include "xysdnm.h"
                                                                
const char* xy_id_xyaxpl_cpp="$Id: xyaxpl.cpp,v 1.19 1999/12/09 21:47:46 rborges Exp $";
                                                                
XYPolarAxis::XYPolarAxis (double radius,
                          XYCoordinate x,
                          XYCoordinate y,
                                long color,
                                double size,
                                            double rot,
                                      double step,
                                XYScaleDecorator* decor,
                                XYText* title,
                                xybool arrow,
                                xybool visible)
                                : XYAxis (0., radius, x, y, color, size, rot, step,
                                                  decor, title, arrow, visible)
{
}

XYPolarAxis::XYPolarAxis (double radius,
                          XYCoordinate x,
                          XYCoordinate y,
                                          long color,
                                            double size,
                                            double rot,
                                            xybool arrow,
                                            xybool visible)
                                            : XYAxis (0., radius, x, y, color, size, rot,
                                                      arrow, visible)
{
}

void XYPolarAxis::polar2cart (double radius, double alpha, double& x,
                              double & y ) const
{
   x = radius * cos (alpha * XY_PI / 180.);
   y = radius * sin (alpha * XY_PI / 180.);
}

void XYPolarAxis::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;

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

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

   if (rot_rad > 0 && rot_rad <= XY_PI)
      mtRotate(tick_size, 0, rot_rad + XY_PI / 2.0, &tx2, &ty2);
   else
      mtRotate(tick_size, 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 XYPolarAxis::draw (void)
{
   draw (_xmin, _ymin, _xmax, _ymax);
}

void XYPolarAxis::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 mais fina possível e com cor definida
   // pelo usuário
   cdLineWidth (1);
   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 o 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, 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 / _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++;
      }
        
      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 os labels 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);
   // restaura região de clip anterior
   cdClipArea(oldclip_xmin, oldclip_xmax, oldclip_ymin, oldclip_ymax);
}

void XYPolarAxis::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 dos labels
      if (_decor)
         _decor -> boundingBox (this, bex1, bey1, bex2, bey2);

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

      // boundingBox em pixels
      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