---

xygrid.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xygrid.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 tipo    */
/* especial de eixo que desenha linhas perpendiculares ao ângulo de rotação  */
/* em toda a região de desenho das máscaras do gráfico (mask area), começan  */
/* do numa posição específica com intervalo entre as linhas definido pelo    */
/* usuário.                                                                  */
/*****************************************************************************/

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

#include "xygrid.h"

const char* xy_id_xygrid_cpp="$Id: xygrid.cpp,v 1.16 1999/12/09 21:47:46 rborges Exp $";
                                                                
XYGrid::XYGrid (double mn,
                      double mx,
                      double p,
                      long color,
                      double rot,
                      double step,
                      xybool visible)
                      : XYAxis(mn, mx, 0., 0., color, 1.0, rot, step, xyfalse, visible),
                              _limit(0.),
                                    _style(continuous)
{
   referenceTick(p);
}

XYGrid::XYGrid (double mn,
                      double mx,
                      double p,
                      long color,
                int style,
                      double rot,
                      double step,
                      xybool visible)
                      : XYAxis(mn, mx, 0., 0., color, 1.0, rot, step, xyfalse, visible),
                              _limit(0.),
                                    _style(style)
{
   referenceTick(p);
}

void XYGrid::limit (double h)
{
   _limit = h;
}

double XYGrid::limit (void) const
{
   return _limit;
}

void XYGrid::style (int s)
{
   _style = s;
}

int XYGrid::style (void) const
{
   return _style;
}

xybool XYGrid::pointInGrid (int px, int py, int x0, int y0, int x1, int y1)
{
   if ((x0 == x1) && (x1 == px))
      if ((y0 <= py) && (py <= y1))
               return xytrue;

   if ((y0 == y1) && (y1 == py))
      if ((x0 <= px) && (px <= x1))
               return xytrue;

   return xyfalse;
}

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

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

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

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

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

   // (x0, y0) ponto inferior esquerdo da grade em relação ao canvas
   double x0, y0;
   position (&x0, &y0);

   // (x1, y1) ponto inferior esquerdo da primeira linha da grade, 
   // em coordenadas normalizadas
   double x1 = x0 + f * cos (rot_rad);
   double y1 = y0 + f * sin (rot_rad);

   // (x2, y2) ponto superior direito da primeira linha da grade, 
   // em coordenadas normalizadas
   double x2 = x1 + limit() * sin (rot_rad);
   double y2 = y1 + limit() * cos (rot_rad);

   // posição no eixo da primeira linha da grade
   double first = this -> first();

   // posição no eixo da última linha da grade
   double q = _mx;                                              

   int px1, py1, px2, py2;

   for (double p = first; p <= q; p += _step)
   {
      // controle de ponto flutuante
      if (mtEqual(x1, x2))
         x2 = x1;
      if (mtEqual(y1, y2))
         y2 = y1;

      // converte coordenadas do mundo para coordenadas em pixels
      wdWorld2Canvas (x1, y1, &px1, &py1);
      wdWorld2Canvas (x2, y2, &px2, &py2);

      // verifica se o ponto está sobre uma linha da grade
      if (pointInGrid(px, py, px1, py1, px2, py2))
         return xytrue;

      // próxima linha da grade
      x1 += dx;
      x2 += dx;
      y1 += dy;
      y2 += dy;
   }

   return xyfalse;
}

int XYGrid::worldSize2PixelSize (double w) const
{
   // ângulo de rotação em radianos
   double rot_rad = _rot * XY_PI / 180.0;

   w = (transform(w) - transform(_mn)) * _size
     / (transform(_mx) - transform(_mn));

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

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

   return (int) mtDistance(pdx, 0, 0, pdy);
}

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

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

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

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

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

   // verifica se a grade é muito compacta
   if (s <= 0.01)
      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);

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

   // (x0, y0) ponto inferior esquerdo da grade em relação ao canvas
   double x0, y0;
   position (&x0, &y0);

   // (x1, y1) ponto inferior esquerdo da primeira linha da grade,
   // em coordenadas normalizadas 
   double x1 = x0 + f * cos (rot_rad);
   double y1 = y0 + f * sin (rot_rad);

   // (x2, y2) ponto superior direito da primeira linha da grade,
   // em coordenadas normalizadas
   double x2 = x1 + limit() * sin (rot_rad);
   double y2 = y1 + limit() * cos (rot_rad);

   // posição no eixo da primeira linha da grade
   double first = this -> first();

   // posição no eixo da última linha da grade
   double mx;

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

   // se x2 igual a x1 calcula novos limites para otimizar o desenho na área
   // definida por (pxmin, pymin) e (pxmax, pymax)
   if (mtEqual(x1, x2))
   {
      // calcula posição da primeira linha a ser desenhada com sendo 
      // a primeira linha que aparece na área definida por (pxmin, pymin)
      // e (pxmax, pymax)
      while (x1 < pxmin)
      {
         // coordenada normalizada
         x1 += dx;

         // coordenada no eixo
               first += _step;
      }

      // faz x2 acompanhar o valor de x1
      x2 = x1;

      // calcula posição da última linha a ser desenhada com sendo a última
      // linha que aparece na área definida por (pxmin, pymin) e 
      // (pxmax, pymax)

      // coordenada no eixo
      mx = first;
      
      while ((x1 < pxmax) && (mx < _mx) && !mtEqual(_mx, mx))
      {
         // coordenada normalizada
         x1 += dx;

         // coordenada no eixo
               mx += _step;
      }

      // faz x1 voltar ao valor de coordenada da primeira linha da grade
      x1 = x2;
        
      // clipa coordenadas y da linha contra a área definida por (pxmin, pymin)
      // e (pxmax, pymax)
      if (y1 < pymin)
         y1 = pymin;

      if (y2 > pymax)
         y2 = pymax;
   }
   // se y2 igual a y1 calcula novos limites para otimizar o desenho na área
   // definida por (pxmin, pymin) e (pxmax, pymax)
   else if (mtEqual(y1, y2))
   {
      // calcula posição da primeira linha a ser desenhada com sendo 
      // a primeira linha que aparece na área definida por (pxmin, pymin)
      // e (pxmax, pymax)
      while (y1 < pymin)
      {
         // coordenada normalizada
         y1 += dy;

         // coordenada no eixo
               first += _step;
      }

      // faz y2 acompanhar o valor de y1
      y2 = y1;

      // redefine última linha a ser desenhada com sendo a última linha que
      // aparece na área definida por (pxmin, pymin) e (pxmax, pymax)

      // coordenada no eixo
      mx = first;
      
      while ((y1 < pymax) && (mx < _mx) && !mtEqual(_mx, mx))
      {
         // coordenada normalizada
         y1 += dy;

         // coordenada no eixo
               mx += _step;
      }

      // faz y1 voltar ao valor de coordenada da primeira linha da grade
      y1 = y2;

      // clipa coordenadas x da linha contra a área definida por (pxmin, pymin)
      // e (pxmax, pymax)
      if (x1 < pxmin)
         x1 = pxmin;

      if (x2 > pxmax)
         x2 = pxmax;
   }

   // desenha grade cor e estilo de linha definidos pelo usuário e com linha 
   // sólida mais fina possível
   cdLineWidth  (1);
   cdLineStyle  (_style);
   cdForeground (_color);

   // desenho da grade
   //for (double p = first; p <= _mx; p += _step)  // isLessEqual(p, mx)
   for (double p = first; mtLessEqual(p, _mx); p += _step)  // isLessEqual(p, mx)
   {
      // desenha linha da grade
      wdLine(x1, y1, x2, y2);

      // próxima linha da grade
      x1 += dx;
      x2 += dx;
      y1 += dy;
      y2 += dy;
   }

   cdClip(mode);
   
   // restaura a região de clip anterior
   cdClipArea(oldclip_xmin, oldclip_xmax, oldclip_ymin, oldclip_ymax);
}

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

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

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

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

   // verifica se a grade é muito compacta
   if (s <= 0.01)
      return;

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

   // (x0, y0) ponto inferior esquerdo da grade em relação ao canvas
   double x0, y0;
   position (&x0, &y0);

   // (x1, y1) ponto inferior esquerdo da primeira linha da grade,
   // em coordenadas normalizadas
   double x1 = x0 + f * cos (rot_rad);
   double y1 = y0 + f * sin (rot_rad);

   // (x2, y2) ponto superior direito da primeira linha da grade,
   // em coordenadas normalizadas
   double x2 = x1 + limit() * sin (rot_rad);
   double y2 = y1 + limit() * cos (rot_rad);

   int bx1, by1, bx2, by2;

   // transforma valores de coordenadas do mundo em pixel
   wdWorld2Canvas (x1, y1, &bx1, &by1);
   wdWorld2Canvas (x2, y2, &bx2, &by2);

   // inicializa boundingBox
   xmin = MIN(bx1, bx2);
   ymin = MIN(by1, by2);
   xmax = MAX(bx1, bx2);
   ymax = MAX(by1, by2);

   // calcula boundingBox
   for (double p = first(); p < _mx; p += _step)
   {
      // próxima linha da grade
      x1 += dx;
      x2 += dx;
      y1 += dy;
      y2 += dy;

      // transforma valores de coordenadas do mundo em pixel
      wdWorld2Canvas (x1, y1, &bx1, &by1);
      wdWorld2Canvas (x2, y2, &bx2, &by2);

      // boundingBox da grade
      xmin = MIN3(bx1, bx2, xmin);
      ymin = MIN3(by1, by2, ymin);
      xmax = MAX3(bx1, bx2, xmax);
      ymax = MAX3(by1, by2, ymax);
   }
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group