---

xyagrid.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xyagrid.cpp                                                       */
/* Autor: Camilo da Foseca Freire                                            */
/* Data: 11 jul 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe que define um tipo especial de eixo */
/* que desenha raios a partir da origem do eixo, em intervalos angulares de- */
/* finidos pelo usuário.                                                       */
/*****************************************************************************/

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

#include "xyagrid.h"
                                                                
const char* xy_id_xyagrid_cpp="$Id: xyagrid.cpp,v 1.8 1999/12/09 21:47:46 rborges Exp $";
                                                                
XYAngGrid::XYAngGrid (double radius,
                      double referenceAngle,
                            long color,
                      double size,
                            double rot,
                            double step,
                            xybool visible)
                            : XYAxis(0., radius, .5, .5, color, size, 0., step,
                                     xyfalse, visible),
                                    _radius(radius),
                                    _referenceAngle(referenceAngle),
                                    _first(rot),
                                          _style(continuous)
{
}

void XYAngGrid::radius (double r)
{
   _radius = r;
}

double XYAngGrid::radius (void) const
{
   return _radius;
}

void XYAngGrid::referenceAngle (double r)
{
   _referenceAngle = r;
}

double XYAngGrid::referenceAngle (void) const
{
   return _referenceAngle;
}

void XYAngGrid::first (double f)
{
   _first = f;
}

double XYAngGrid::first (void) const
{
   return _first;
}

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

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

xybool XYAngGrid::pointInGrid (int px, int py, int x0, int y0, int x1, int y1)
{
   // distância entre os pontos extremos do segmento (x0, y0) - (x1, y1)
   double distance = mtDistance (x0, y0, x1, y1);

   // distância entre (x0, y0) e (px, py)
   double dist1 = mtDistance (x0, y0, px, py);
   // distância entre (px, py) e (x1, y1)
   double dist2 = mtDistance (px, py, x1, y1);

   // verifica se a soma das distâncias de (px, py) aos extremos do
   // intervalo é igual a distância entre esses extremos
   if (mtEqual(dist1 + dist2, distance, 0.1))
      return xytrue;

   return xyfalse;
}

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

   // tamanho normalizado em relação ao canvas
   double s = _radius * _size / (_mx - _mn);

   // (x0, y0) posição inicial da grade
   double x0, y0;
   position (&x0, &y0);

   int px0, py0, px1, py1;
   double x1, y1;

   for (double p = 0.; p <= 360; p += _step)
   {
      x1 = x0 + (s * cos(p * XY_PI / 180.));
      y1 = y0 + (s * sin(p * XY_PI / 180.));

      // converte coordenadas do mundo para coordenadas em pixel
      wdWorld2Canvas (x0, y0, &px0, &py0);
      wdWorld2Canvas (x1, y1, &px1, &py1);

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

   return xyfalse;
}

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

void XYAngGrid::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);

   // tamanho normalizado em relação ao canvas
   double s = _radius * _size / (_mx - _mn);

   // verifica se a grade é muito compacta
   if (_step <= 1.0)
      return;

   // (x0, y0) posição inicial da grade
   double x0, y0;
   position (&x0, &y0);

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

   for (double p = _referenceAngle; p <= 360+_referenceAngle; p += _step)
      // desenha raio da grade
      wdLine(x0, y0, x0 + (s * cos(p * XY_PI / 180.)),
             y0 + (s * sin(p * XY_PI / 180.)));

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

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

   // tamanho normalizado em relação ao canvas
   double s = _radius * _size / (_mx - _mn);

   // verifica se a grade é muito compacta
   if (_step <= 1.0)
      return;

   // (x0, y0) posição inicial da grade
   double x0, y0;
   position (&x0, &y0);

   int bx1, by1;
   wdWorld2Canvas (x0, y0, &bx1, &by1);

   // inicializa boundingBox
   xmin = bx1;
   ymin = by1;
   xmax = bx1;
   ymax = by1;

   double x1, y1;

   for (double p = 0.; p <= 360; p += _step)
   {
      x1 = x0 + (s * cos(p * XY_PI / 180.));
      y1 = y0 + (s * sin(p * XY_PI / 180.));

      wdWorld2Canvas (x1, y1, &bx1, &by1);

      // boundingBox da grade
      xmin = MIN(bx1, xmin);
      ymin = MIN(by1, ymin);
      xmax = MAX(bx1, xmax);
      ymax = MAX(by1, ymax);
   }
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group