---

xysdlg.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xysdlog.cpp                                                      */
/* Autores: Carlos Henrique Levy e Jaudênia Cavalcante                       */
/* Data: 08 jul 96                                                           */
/* Comentário:                                                                                                                                                         */
/*    Implementação de métodos da classe especializada onde decorações loga  */
/* rítmicas são formatadas, ou seja, a numeração aparece como resultado de   */
/* potências de 10, onde os índices estão de acordo com o eixo logaritmico   */
/* definido pelo usuário.                                                    */
/*****************************************************************************/

#include "xysdlg.h"
#include "xyaxlg.h"

const char* xy_id_xyscdtlg_cpp="$Id: xysdlg.cpp,v 1.11 2002/01/23 16:13:05 clinio Exp $";
                                                                
XYLogScaleDecorator::XYLogScaleDecorator (char *format, 
                                                      XYText* scale)
                                                                      : _format(format),
                                                                    _scale(scale)
{
}

XYLogScaleDecorator::~XYLogScaleDecorator (void)
{
}

void XYLogScaleDecorator::format (char* f)
{
   _format = f;
}

char* XYLogScaleDecorator::format (void) const
{
   return _format;
}

void XYLogScaleDecorator::draw (const XYAxis *axis, int first_tick,
                                int last_tick) const
{
   XYLogAxis* lgax = (XYLogAxis*) axis;
   int last_bxmin = -9, last_bymin = -9, last_bxmax = -9, last_bymax = -9;
   int bxmin = -5, bymin = -5, bxmax = -5, bymax = -5;

   // consulta área do gráfico para o eixo
   int xmn, ymn, xmx, ymx;
   axis -> getViewport(xmn, xmx, ymn, ymx);
   
   // decide área no gráfico para a escala
   _scale -> setViewport(xmn, xmx, ymn, ymx);
   
   double mn   = lgax->min();
   double mx   = lgax->max();
   double step = lgax->step();
   double size = lgax->size();

   // intervalos de deslocamento em relação as direções x e y
   double rot_rad = lgax -> rotation() * XY_PI / 180.0;

   if (step > 0.0)
   {
      double xorigin, yorigin; 
      lgax->position(&xorigin, &yorigin);

      double decade_step;
      for( double val = mn; val <= mx; val += decade_step )// *step )
      {
        int current_decade = mtDecade(val);
        decade_step = pow( 10, current_decade );
        double dx, dy;
        mtRotate( (log10(val)-log10(mn))*size / (log10(mx)-log10(mn)), 0.0,
                rot_rad, &dx, &dy);

        double xtick = xorigin + dx;
        double ytick = yorigin + dy;

        static char c[80];
        sprintf (c, _format, val);
       
        _scale->text (c);
        _scale->position(xtick, ytick);
        _scale->boundingBox(bxmin,bymin,bxmax,bymax);
        if ( !mtIntercept(bxmin,bymin,bxmax,bymax,
              last_bxmin,last_bymin,last_bxmax,last_bymax) ) {
           _scale->draw(xmn, ymn, xmx, ymx);
           int dx = (bxmax-bxmin)/10;
           int dy = (bymax-bymin)/10;
           last_bxmin = bxmin-dx; last_bxmax = bxmax+dx;
           last_bymin = bymin-dy; last_bymax = bymax+dy;
        }
     }
  }
}

void XYLogScaleDecorator::boundingBox (const XYAxis *axis, int& bxmin,
                                                               int& bymin, int& bxmax,
                                                               int& bymax) const
{
   XYLogAxis* eixo = (XYLogAxis*) axis;

   // intervalos de deslocamento em relação as direções x e y
   double dx, dy;
   double rot_rad = eixo -> rotation() * XY_PI / 180.0;

   mtRotate ((eixo -> step() * eixo -> size()) / (eixo -> max()
             - eixo -> min()), 0.0, rot_rad, &dx, &dy);

   double ex1, ey1, ex2, ey2;
   eixo -> firstTick (ex1, ey1, ex2, ey2);

   // consulta área do gráfico para o eixo
   int xmn, ymn, xmx, ymx;
   eixo -> getViewport(xmn, xmx, ymn, ymx);

   // decide área no gráfico para a escala
   _scale -> setViewport(xmn, xmx, ymn, ymx);

   double tex2 = ex2;
   double tey2 = ey2;

   int ftx1, ftx2, fty1, fty2;
   int ltx1, ltx2, lty1, lty2;

   // calcula ticks que receberão labels para não haver sobreposição de labels,
   // o metodo é calcular boundindBox do maior label em ticks consecutivos e
   // verificar quando deixa de ocorrer sobreposição

   // consulta o boundingBox do primeiro texto na escala
   char c[80];
   sprintf (c, _format, (int)(eixo -> min() + pow (10, 0)));

   _scale -> text (c);
   _scale -> position (tex2, tey2);
   _scale -> boundingBox(ftx1, fty1, ftx2, fty2);

   // quantidade total de ticks
   int total = (int) log10 (eixo -> max() - eixo -> min());

   // consulta o boundingBox do último texto na escala
   sprintf (c, _format, (int)(eixo -> min() + pow (10, total)));

   _scale -> text (c);
   _scale -> position (tex2 + dx * total, tey2 + dy * total);
   _scale -> boundingBox(ltx1, lty1, ltx2, lty2);

   // determina qual é o maior boundingBox, se o do primeiro ou o do último
   // texto na escala
   double mor = ((ltx2 - ltx1) > (ftx2 - ftx1)) ? eixo -> min()
                  + pow (10, total) : eixo -> min() + pow (10, 0);

   // maior texto na escala colocado no primeiro tick
   sprintf (c, _format, (int) mor);

   _scale -> text (c);
   _scale -> position (tex2, tey2);
   _scale -> boundingBox(ftx1, fty1, ftx2, fty2);

   // próximo tick
   tex2 += dx;
   tey2 += dy;

   // maior texto na escala colocado no segundo tick
   sprintf (c, _format, (int) mor);

   _scale -> text (c);
   _scale -> position (tex2, tey2);
   _scale -> boundingBox(ltx1, lty1, ltx2, lty2);

   // guarda quantidade de ticks sem texto
   int test_intercept = 1;

   // maior texto na escala colocado nos demais ticks até que não haja
   // interseção do seu boundingBox no tick anterior com o tick atual
   while (mtIntercept (ftx1, fty1, ftx2, fty2, ltx1, lty1, ltx2, lty2) != 0)
   {
      ++test_intercept;

      // próximo tick
      tex2 += dx;
      tey2 += dy;

      // maior texto na escala colocado nos demais ticks
      sprintf (c, _format, (int) mor);

      _scale -> text (c);
      _scale -> position (tex2, tey2);
      _scale -> boundingBox(ltx1, lty1, ltx2, lty2);
   }

   // inicializa boundingBox com posição de referência do primeiro texto
   double xmin = ex2;
   double xmax = ex2;
   double ymin = ey2;
   double ymax = ey2;

   int x1, x2, y1, y2;
   double wx1, wy1, wx2, wy2;

   for (int ntick = 0; ntick <= total; ++ntick)
   {
      if ((ntick % test_intercept) == 0)
      {
         // formata o  texto
         sprintf (c, _format, (int)(eixo -> min() + pow (10, ntick)));

               // define o texto
               _scale -> text (c);
         _scale -> position (ex2, ey2);

               // calcula boundingBox do texto
           _scale -> boundingBox (x1, y1, x2, y2);

               wdCanvas2World (x1, y1, &wx1, &wy1);
               wdCanvas2World (x2, y2, &wx2, &wy2);

           // atualiza boundingBox total
           xmin = MIN3 (xmin, wx1, wx2);
           xmax = MAX3 (xmax, wx1, wx2);
               ymin = MIN3 (ymin, wy1, wy2);
           ymax = MAX3 (ymax, wy1, wy2);
      }

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

   wdWorld2Canvas (xmin, ymin, &bxmin, &bymin);
   wdWorld2Canvas (xmax, ymax, &bxmax, &bymax);
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group