---

xymath.cpp

Go to the documentation of this file.

/*****************************************************************************/
/* Módulo: xymath.cpp                                                        */
/* Autores: Carlos Henrique Levy e Jaudênia Cavalcante                       */
/* Data: 08 mar 96                                                           */
/*****************************************************************************/

#include "xymath.h"
#include <stdlib.h>

const char* xy_id_xymath_cpp="$Id: xymath.cpp,v 1.13 2002/01/23 16:10:20 clinio Exp $";                                                         
static double Tol = 1e-7;

int mtDecade(double val)
{
   double l = log10(val);
   return (int)floor(l);
}

double mtTolerance(double v)
{
   double oldtol = Tol;
   Tol = v;
   return oldtol;
}

// verifica se v1 e v2 são iguais
xybool mtEqual(double v1, double v2)
{
   return (fabs(v2 - v1) < Tol);
}

// verifica se v1 e v2 são iguais numa tolerância
xybool mtEqual(double v1, double v2, double tol)
{
   return (fabs(v2 - v1) < tol);
}

// verifica se v1 é menor ou igual a v2 numa tolerância
xybool mtLessEqual(double v1, double v2, double tol)
{
   return (v1<v2) || mtEqual(v1, v2, tol); // (); 
}

// verifica se v1 é menor ou igual a v2 numa tolerância
xybool mtLessEqual(double v1, double v2)
{
   return (v1<v2) || mtEqual(v1, v2); // (); 
}

// retorna a distância entre os pontos (x0, y0) e (x1, y1)
double mtDistance(double x0, double y0, double x1, double y1)
{
   return sqrt(fabs((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)));
}

// retorna a distância entre os pontos (x0, y0) e (x1, y1)
double mtDistance(int x0, int y0, int x1, int y1)
{
   return sqrt((double) abs((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)));
}

// faz a rotação no ponto (xi, yi) de um certo ângulo, resultando (xr, yr)
void mtRotate(double xi, double yi, double angle, double* xr, double* yr)       
{
   *xr = xi * cos(angle) - yi * sin(angle);
   *yr = xi * sin(angle) + yi * cos(angle);
}

// faz a rotação no ponto (xi, yi) de um certo ângulo, resultando (xr, yr)
void mtRotate(int xi, int yi, double angle, int* xr, int* yr)   
{
   *xr = (int) (xi * cos(angle) - yi * sin(angle));
   *yr = (int) (xi * sin(angle) + yi * cos(angle));
}

// verifica a interseção entre áreas
xybool mtIntercept(double xmin1, double ymin1, double xmax1, double ymax1,
                double xmin2, double ymin2, double xmax2, double ymax2)
{
   if      (xmin1 > xmax2) return 0;
   else if (xmax1 < xmin2) return 0;
   else if (ymin1 > ymax2) return 0;
   else if (ymax1 < ymin2) return 0;
   else                    return 1;
}

// verifica a interseção entre áreas
xybool mtIntercept(int xmin1, int ymin1, int xmax1, int ymax1,
                int xmin2, int ymin2, int xmax2, int ymax2)
{
   if      (xmin1 > xmax2) return 0;
   else if (xmax1 < xmin2) return 0;
   else if (ymin1 > ymax2) return 0;
   else if (ymax1 < ymin2) return 0;
   else                    return 1;
}

// verifica a inclusão entre duas áreas
xybool mtInclude(double xmin1, double ymin1, double xmax1, double ymax1,
              double xmin2, double ymin2, double xmax2, double ymax2)
{
   if ((xmin2 < xmin1) && (xmax1 < xmax2) && (ymin2 < ymin1) &&
       (ymax1 < ymax2))
          return xytrue;
   else
      return xyfalse;
}

// verifica a inclusão entre duas áreas
xybool mtInclude(int xmin1, int ymin1, int xmax1, int ymax1,
              int xmin2, int ymin2, int xmax2, int ymax2)
{
   if ((xmin2 < xmin1) && (xmax1 < xmax2) && (ymin2 < ymin1) &&
       (ymax1 < ymax2))
          return xytrue;
   else
      return xyfalse;
}

// verifica se o ponto está no retângulo
xybool mtPointInRect(int px, int py, int x1, int y1, int x2, int y2)
{
   return ((x1 <= px) && (px <= x2) && (y1 <= py) && (py <= y2));
}

// verifica se o ponto está no retângulo
xybool mtPointInRect(double px, double py, double x1, double y1,
                   double x2, double y2)
{
   return ((x1 <= px) && (px <= x2) && (y1 <= py) && ( py <= y2));
}

// verifica se o ponto está sobre a linha
xybool mtPointInLine(double px, double py, double x1, double y1,double x2, double y2)
{
   if ((x1 < px) && (px < x2))
      return mtEqual((y2 - y1) / (x2 - x1) * (px - x1) + y1, py);
   else
      return xyfalse;
}

// verifica se o ponto está sobre a linha (+ robusto) em pixel
xybool mtPointInLineEx(int px, int py, int x1, int y1, int x2, int y2)
{
   // modulo da linha
   double sz = mtDistance((double)x1, (double)y1, (double)x2, (double)y2);

   // menor que 1 pixel ? usa pick de ponto
   if ( sz <= 1.0 )
     return mtPointInsideCircle(px, py, x1, y1, (int)Tol);
   
   // direcao e normal da linha normalizadas
   double dx = (x2 - x1)/sz;
   double dy = (y2 - y1)/sz;
   double nx = dy;
   double ny = -dx;
   
   // menor distancia do ponto a reta
   double dist = (px - x1)*nx + (py - y1)*ny;
    
   // dentro da tolerancia ?
   if (mtEqual(dist,0.0))
   {
     // projecao na reta
     double proj = (px - x1)*dx + (py - y1)*dy;

     // dentro da reta ?
     if (proj > 0.0 && proj < sz)
       return xytrue;
   }   
   
   return xyfalse;
}

// verifica se o ponto está sobre a linha (+ robusto) em world
xybool mtPointInLineEx(double px, double py, double x1, double y1,double x2, double y2)
{
   // modulo da linha
   double sz = mtDistance(x1, y1, x2, y2);

   // direcao e normal da linha normalizadas
   double dx = (x2 - x1)/sz;
   double dy = (y2 - y1)/sz;
   double nx = dy;
   double ny = -dx;
   
   // menor distancia do ponto a reta
   double dist = (px - x1)*nx + (py - y1)*ny;
    
   // dentro da tolerancia ?
   if (mtEqual(dist,0))
   {
     // projecao na reta
     double proj = (px - x1)*dx + (py - y1)*dy;

     // dentro da reta ?
     if (proj > 0.0 && proj < sz)
       return xytrue;
   }   
   
   return xyfalse;
}

// verifica se o ponto está sobre uma marca
xybool mtPointInMark(int px, int py, int x1, int y1, int tol)
{
   // limites de tolerância para a igualdade
   int xmn = x1 - tol;
   int xmx = x1 + tol;
   int ymn = y1 - tol;
   int ymx = y1 + tol;

   if ((xmn < px) && (px < xmx) && (ymn < py) && (py < ymx))
      return xytrue;
   else
      return xyfalse;
}


// verifica se ponto está dentro um círculo
xybool mtPointInsideCircle (int px, int py, int cx, int cy, int radius)
{
   double dist = mtDistance ((double)px, (double)py, (double)cx, (double)cy);

   if ( dist < radius )
      return xytrue;

   return xyfalse;
}

// verifica se ponto está sobre um círculo
xybool mtPointInCircle (int px, int py, int x0, int y0, int x1, int y1)
{
   // distância entre os pontos (x0, y0) e (x1, y1), raio do círculo
   double radius = mtDistance (x0, y0, x1, y1);

   // distância entre (x0, y0) e (px, py)
   double distance = mtDistance (x0, y0, px, py);

   // verifica se a distâncias de (px, py) ao centro do círculo é igual
   // ao raio; se for igual o ponto está sobre o círculo
   if (mtEqual(distance, radius))
      return xytrue;

   return xyfalse;
}

---

XY
Tecgraf / PUC-Rio - Computer Graphics Technology Group