---

xyaxlg.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xyaxlg.cpp                                                        */
/* Autores: Carlos Henrique Levy e Jaudênia Cavalcante                       */
/* Data: 02 maio 96                                                          */
/* Comentário:                                                               */
/*    Implementação de métodos da classe especializada que define um eixo    */
/* com escala logaritmica.                                                   */
/*****************************************************************************/

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

#include "xyaxlg.h"
#include "xysdlg.h"
                                                                
const char* xy_id_xyaxlg_cpp="$Id: xyaxlg.cpp,v 1.24 2003/01/03 16:10:34 clinio Exp $";
                                                                
XYLogAxis::XYLogAxis (double mn,
                            double mx,
                      XYCoordinate x,
                      XYCoordinate y,
                            long color,
                            double size,
                            double rot,
                            double step,
                              XYScaleDecorator* decorator,
                            XYText* title,
                            xybool arrow,
                            xybool visible)
                            : XYAxis (mn, mx, x, y, color, size, rot, step, decorator,
                                      title, arrow, visible)
{
}

XYLogAxis::XYLogAxis (double mn,
                            double mx,
                      XYCoordinate x,
                      XYCoordinate y,
                            long color,
                            double size,
                            double rot,
                            xybool arrow,
                            xybool visible)
                            : XYAxis (mn, mx, x, y, color, size, rot, arrow, visible)
{                                       
}

double XYLogAxis::transform (double e) const
{
   if (fabs(e) <= 1e-50) return -1000.0;
   double value = log10(e);
   return value;
}

double XYLogAxis::defineMinPoint(double value, int x0, int y0) const
{
   setWindow();
   setViewport();

   double dx0, dy0;
   wdCanvas2World(x0, y0, &dx0, &dy0);

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

   double min;

   if (rot_rad == 0.0)
      min = _mx - (_mx - value) * _size / (x2 - dx0);
   else
      min = _mx - (_mx - value) * _size / (y2 - dy0);

   return min;
}

double XYLogAxis::defineMaxPoint(double value, int x0, int y0) const
{
   setWindow();
   setViewport();

   double dx0, dy0;
   wdCanvas2World(x0, y0, &dx0, &dy0);

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

   double max;

   if (rot_rad == 0.0)
      max = _mn + (value - _mn) * size() / (dx0 - x1);
   else
      max = _mn + (value - _mn) * size() / (dy0 - y1);

   return max;
}

double XYLogAxis::valueInPoint(int x0, int y0) const
{
    // salva window e viewport para restaurar no final da funcao
   double ow_xmin,ow_xmax,ow_ymin,ow_ymax;
   int oc_xmin, ov_xmax, ov_ymin, ov_ymax;
   wdGetWindow(&ow_xmin,&ow_xmax,&ow_ymin,&ow_ymax);
   wdGetViewport(&oc_xmin,&ov_xmax,&ov_ymin,&ov_ymax);
 
   setWindow();
   setViewport();

   double dx0, dy0;
   wdCanvas2World(x0, y0, &dx0, &dy0);

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

   double value;

   if (rot_rad == 0.0)
      value = log10(_mn) + (dx0 - x1) * (log10(_mx) - log10(_mn)) / size();
   else
      value = log10(_mn) + (dy0 - y1) * (log10(_mx) - log10(_mn)) / size();

   wdWindow(ow_xmin,ow_xmax,ow_ymin,ow_ymax);
   wdViewport(oc_xmin, ov_xmax, ov_ymin, ov_ymax);

   return pow(10,value);
}

double XYLogAxis::valueInPoint(double x0, double y0) const
{
   // salva window e viewport para restaurar no final da funcao
   double ow_xmin,ow_xmax,ow_ymin,ow_ymax;
   int oc_xmin, ov_xmax, ov_ymin, ov_ymax;
   wdGetWindow(&ow_xmin,&ow_xmax,&ow_ymin,&ow_ymax);
   wdGetViewport(&oc_xmin,&ov_xmax,&ov_ymin,&ov_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);

   double value;
   if (rot_rad == 0.0)
      value = log10(_mn) + (x0 - x1) * ( log10(_mx) - log10(_mn) ) / size();
   else
      value = log10(_mn) + (y0 - y1) * ( log10(_mx) - log10(_mn) ) / size();

   wdWindow(ow_xmin,ow_xmax,ow_ymin,ow_ymax);
   wdViewport(oc_xmin, ov_xmax, ov_ymin, ov_ymax);

   return pow(10,value);
}

void XYLogAxis::pointInValue(double value, int& x0, int& y0) const
{
   // salva window e viewport para restaurar no final da funcao
   double ow_xmin,ow_xmax,ow_ymin,ow_ymax;
   int oc_xmin, ov_xmax, ov_ymin, ov_ymax;
   wdGetWindow(&ow_xmin,&ow_xmax,&ow_ymin,&ow_ymax);
   wdGetViewport(&oc_xmin,&ov_xmax,&ov_ymin,&ov_ymax);

   setWindow();
   setViewport();

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

   // (x1, y1) ponto inicial do marcador em relação a área de desenho
   double dx0 = x1 + (log10(value) - log10(_mn)) * _size / (log10(_mx) - log10(_mn)) * cos (rot_rad);
   double dy0 = y1 + (log10(value) - log10(_mn)) * _size / (log10(_mx) - log10(_mn)) * sin (rot_rad);

   wdWorld2Canvas(dx0, dy0, &x0, &y0);
   // x0 = (int)pow(10,x0);
   // y0 = (int)pow(10,y0);

   wdWindow(ow_xmin,ow_xmax,ow_ymin,ow_ymax);
   wdViewport(oc_xmin, ov_xmax, ov_ymin, ov_ymax);

}

void XYLogAxis::pointInValue(double value, double& x0, double& y0) const
{
   // salva window e viewport para restaurar no final da funcao
   double ow_xmin,ow_xmax,ow_ymin,ow_ymax;
   int oc_xmin, ov_xmax, ov_ymin, ov_ymax;
   wdGetWindow(&ow_xmin,&ow_xmax,&ow_ymin,&ow_ymax);
   wdGetViewport(&oc_xmin,&ov_xmax,&ov_ymin,&ov_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);

   // (x1, y1) ponto inicial do marcador em relação a área de desenho
   x0 = x1 + (log10(value) - log10(_mn)) * _size / (log10(_mx) - log10(_mn)) * cos (rot_rad);
   y0 = y1 + (log10(value) - log10(_mn)) * _size / (log10(_mx) - log10(_mn)) * sin (rot_rad);

   // x0 = pow(10,x0);
   // y0 = pow(10,y0);

   wdWindow(ow_xmin,ow_xmax,ow_ymin,ow_ymax);
   wdViewport(oc_xmin, ov_xmax, ov_ymin, ov_ymax);
}

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

void XYLogAxis::draw (int xmin, int ymin, int xmax, int ymax) const
{
   if (visible() == xyfalse) 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 (2);
   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 passo tem um valor válido
   if (_step > 0.0)
   {
      double xorigin, yorigin;
      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;

        cdMarkType( CD_PLUS );
        wdMarkSize( 1.0 );
             wdMark(xtick, ytick);
             // printf( "%f %f\n", val, decade_step *_step ); fflush(stdout);
      }
      
      // desenha a decoração da escala
       if (_decor)
           _decor -> draw(this, 0, 0 ); // 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 a região de clip anterior
   cdClipArea(oldclip_xmin, oldclip_xmax, oldclip_ymin, oldclip_ymax);
}
                                                        
void XYLogAxis::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 boundinBox 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 boundinBox 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 da decoração da escala
      if (_decor)
         _decor -> boundingBox (this, bex1, bey1, bex2, bey2);

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

      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