---

xymplmk.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xymplmk.cpp                                                       */
/* Autores: Carlos Henrique Levy e Jaudênia Cavalcante                       */
/* Data: 30 set 96                                                           */
/* Comentário:                                                               */
/*    Implementação de métodos da classe especializada que representa atra-  */
/* vés de marcas um conjunto de dados pontuais num gráfico polar.            */
/*****************************************************************************/

#include "xymplmk.h"

const char* xy_id_xymplmk_cpp="$Id: xymplmk.cpp,v 1.6 2000/06/14 19:13:40 camilo Exp $";
                                                                
XYPolarMarkMask::XYPolarMarkMask (XYText* name,
                                              XYSeries* series,
                                                    const XYPolarAxis* axis,
                                                    long color,
                                                    int size,
                                                    MarkStyle mark,
                                                    xybool  visible)
                                                    : XYPolarMask(name, series, axis, color,
                                                                  visible),
                                                      _size(size),
                                                      _mark(mark)
{
}

XYPolarMarkMask::XYPolarMarkMask (XYSeries* series,
                                                    const XYPolarAxis* axis,
                                                    long color,
                                                    int size,
                                                    MarkStyle mark,
                                                    xybool  visible)
                                                    : XYPolarMask(series, axis, color, visible),
                                                      _size(size),
                                                      _mark(mark)
{
}

void XYPolarMarkMask::size (int s)
{
   _size = s;
}

int XYPolarMarkMask::size (void) const
{
   return _size;
}

void XYPolarMarkMask::mark (XYMask::MarkStyle m)
{
   _mark = m;
}

int XYPolarMarkMask::mark (void) const
{
   return _mark;
}

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

xybool XYPolarMarkMask::pick (int x, int y)
{
   if (visible() == xyfalse)    // invisível!!!
      return xyfalse;

   XYSeries* s = (XYSeries *) _series;

   int npoints = s -> numPoints();

   // teste de inconsistência
   if ((npoints <= 1) || (x < _xmin) || (_xmax < x) || (y < _ymin) ||
       (_ymax < y))
      return xyfalse;

   setWindow (-_axis -> max(), _axis -> max(), -_axis -> max(), _axis -> max());
   setViewport();

   // guarda o atual modo de clipping
   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);

   // converte coordenadas (x, y) em pixels para coordenadas do mundo
   double px, py;
   wdCanvas2World (x, y, &px, &py);

   double r, a;
   s -> point(0, a, r);

   double x1, y1;
   _axis -> polar2cart (r, a, x1, y1);

   // define tolerância para 2 pixels calculado em relação ao y por causa da
   // função mtPointInLine
   double oldtol;
   oldtol=mtTolerance(2 * (2 * _axis -> max()) / (_ymax - _ymin + 1));

   double x2, y2;
   // verifica uma série
   for (int i = 1; i < npoints; ++i)
   {
      if ((px == x1) && (py == y1))
            {
         cdClip(mode);
                     // restaura a região de clip anterior
         cdClipArea(oldclip_xmin, oldclip_xmax, oldclip_ymin, oldclip_ymax);

         mtTolerance(oldtol);
         return xytrue;
            }

      s -> point(i, a, r);
      _axis -> polar2cart(r, a, x2, y2);

      x1 = x2;
      y1 = y2;
   }

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

   mtTolerance(oldtol);
   return xyfalse;
}

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

   // limites da menor caixa que contém uma máscara
   int x0, y0, x1, y1;
   boundingBox (x0, y0, x1, y1);

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

void XYPolarMarkMask::drawIcon (int xmin, int ymin, int xmax, int ymax) const
{
   int xmid = (int)((double)(xmax + xmin) / 2);
   int ymid = (int)((double)(ymax + ymin) / 2);

   // ativa estilo, tamanho e cor da marca usada para desenhar a série
   cdMarkType(_mark);
   wdMarkSize(_size*.25);
   cdForeground(_color);

   cdMark (xmid, ymid);
}

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

   XYSeries* s = (XYSeries *) _series;

   // define domínio da série nos limites da área a ser desenhada:

   // domínio original da série
   double old_begin, old_end;
   s -> domain(&old_begin, &old_end);

   // novo domínio
   double begin, end;

   // define os parâmetros de visualização para o domínio do eixos na
   // região de desenho das máscaras. Isto é necessário para se poder
   // calcular os novos limites do eixo X em coordenadas do mundo
   setWindow (-_axis -> min(), _axis -> max(), -_axis -> min(), _axis -> max());
   setViewport();

   // calcula os novos limites no eixo X, em coordenadas do mundo
   wdCanvas2World (xmin, 0, &begin, 0);
   wdCanvas2World (xmax, 0, &end, 0);

   // calcula o novo domínio para a série que é o domínio que está dentro
   // da região que vai ser desenhada. Agora, se a área não intercepta o
   // domínio, então retorna porque não há nada para ser desenhado
   if ((begin > old_end) || (end < old_begin))
      return;

   if (begin < old_begin)
      begin = old_begin;

   if (end > old_end)
      end = old_end;
        
   // define o novo domínio
   s -> domain(begin, end);

   // número de pontos na série
   int npoints = s -> numPoints();

   // teste de inconsistência
   if (npoints <= 1)
   {
      // restaura valores originais do domínio da série
      s -> domain(old_begin, old_end);
      return;
   }

   // começa a desenhar:

   // ativa estilo, tamanho e cor da marca usada para desenhar a série
   cdMarkType(_mark);
   wdMarkSize(_size*.25);
   cdForeground(_color);

   // guarda o atual modo de clipping
   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);

   cdWriteMode(CD_REPLACE);

   double r, a;
   double x, y;

   // desenha uma série
   for (int i = 0; i < npoints; ++i)
   {
      s -> point(i, a, r);
      _axis -> polar2cart(r, a, x, y);

      // desenha marca da série
      wdMark (x, y);
   }

   // restaura valores originais do domínio da série
   s -> domain(old_begin, old_end);

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

void XYPolarMarkMask::boundingBox (int& bxmin, int& bymin, int& bxmax,
                                   int& bymax) const
{
   if (visible() == xyfalse)  // invisível!!!
      return;

   XYSeries* s = (XYSeries *) _series;

   // número de pontos na série
   int npoints = s -> numPoints();

   double r, a, x, y;

   s -> point(0, a, r);
   _axis -> polar2cart(r, a, x, y);

   // inicializa boundingBox
   double txmin = x;
   double tymin = y;
   double txmax = x;
   double tymax = y;

   // verifica uma série
   for (int i = 1; i < npoints; ++i)
   {
      s -> point(i, a, r);
      _axis -> polar2cart(r, a, x, y);

      txmin = MIN(x, txmin);
      tymin = MIN(y, tymin);
      txmax = MAX(x, txmax);
      tymax = MAX(y, tymax);
   }

   wdWorld2Canvas(txmin, tymin, &bxmin, &bymin);
   wdWorld2Canvas(txmax, tymax, &bxmax, &bymax);

   // restringe a boundingBox a área de desenho da máscara,
   // caso ela a ultrapasse

   if (bxmin > _xmin)
      bxmin = _xmin;

   if (bxmax > _xmax)
      bxmax = _xmax;

   if (bymin > _ymin)
      bymin = _ymin;

   if (bymax > _ymax)
      bymax =_ymax;
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group