U3-ACTIVADAD-11-INVESTIGACION

 Analizador Diferencial Digital (DDA) se usa para la interpolación lineal de variables sobre un intervalo entre un punto de comienzo y un punto de fin. Los DDAs se usan para rastreo de lineas, triangulos y polígonos. En la implementación mas simple del algoritmo DDA interpola valores en intervalo [(x_inicio, y_inicio), (x_fin, y_fin)] por calculo para cada x_i las ecuaciones x_i = x_i−1+1, y_i = y_i−1 + Δy/Δx, donde Δx = x_fin − x_inicio y Δy = y_fin − y_inicio.

algoritmo

Si m>=0 (pendiente positiva)
  Si m<=1
    de izquierda a derecha
       * muestreo de x (Δx =1)
       * y_k+1 = redondeo(y_k + m) k=1,2,...
    de derecha a izquierda
       * muestreo de x (Δx =-1)
       * y_k+1 = redondeo(y_k - m) k=1,2,...
  Si m > 1 (para evitar la aparición de agujeros)
    de izquierda a derecha
       * muestreo de y (Δy =1)
       * x_k+1 = redondeo(x_k + 1/m) k=1,2,...
    de derecha a izquierda
       * muestreo de y (Δy =-1)
       * x_k+1 = redondeo(x_k - m) k=1,2,...
Si m<0 (pendiente negativa)
  Si |m|<1
    de izquierda a derecha
       * muestreo de x (Δx =1)
       * y_k+1 = redondeo(y_k + m) k=1,2,...
    de derecha a izquierda
       * muestreo de x (Δx =-1)
       * y_k+1 = redondeo(y_k - m) k=1,2,...
  Si |m| > 1 (para evitar la aparición de agujeros)
    de izquierda a derecha
       * muestreo de y (Δy =1)
       * x_k+1 = redondeo(x_k + 1/m) k=1,2,...
    de derecha a izquierda
       * muestreo de y (Δy =-1)
       * x_k+1 = redondeo(x_k - m) k=1,2,...

El algoritmo de Bresenham es un algoritmo creado para dibujar rectas en los dispositivos de gráficos rasterizados, como por ejemplo un monitor de ordenador, que determina qué pixeles se rellenarán, en función de la inclinación del ángulo de la recta a dibujar.

algoritmo

Si 0<|m|<1
  *Se capturan los extremos de la línea y se almacena el extremo izquierdo en (x₀,y₀).
  *Se carga (x₀,y₀) en el bufer de estructura (se traza el primer punto)
  *Se calculan las constantes Δx,Δy, 2Δy y 2Δy-Δx y se obtiene el valor inicial para el
    parametro de decisión p₀=2Δy-Δx.
  Para j=0 mientras j<Δx
  *En cada x_k a lo largo de la línea, que inicia en k=0 se efectúa la prueba siguiente:
      Si p_k<0
          *Trazamos (x_k+1,y_k).
          *Asignamos p_k+1= p_k+2Δy.
      Sino
          *Trazamos (x_k+1,y_k+1).
          *Asignamos p_k+1= p_k+2Δy-2Δx.
  Fin Para
Si |m|>1
   *Recorremos la dirección en pasos unitarios y calculamos los valores sucesivos   
     de x que se aproximen más a la trayectoria de la línea.

EJEMPLO DDA

#include <cstdlib>
#include <iostream>

#ifdef __APPLE__
#  include <GLUT/glut.h>
#else
#  include <GL/glut.h>
#endif

using namespace std;

// Draw a pixel as a point.
void pickPixel(int x, int y)
{
   glBegin(GL_POINTS);
      glVertex2i(x, y);
   glEnd();
}

// Round a float to a nearest integer.
int round(float z)
{
  int y;
     y = z > 0.0 ? int(z + 0.5) : int(z - 0.5);
  return y;
}

// DDA line rasterizer.
void DDA(int i1, int j1, int i2, int j2) // Assume i2 > i1.
{
   float y = j1;
   float m = float(j2 - j1)/(i2 - i1); // Assume -1 <= m <= 1.
   for(int x = i1; x <= i2; x++)
   {
      pickPixel(x, round(y));
   y += m;
   }
}

// Drawing routine.
void drawScene(void)
{ 
   glClear(GL_COLOR_BUFFER_BIT);

   glColor3f(0.0, 0.0, 0.0);

   DDA(100, 100, 300, 200);

   glFlush();
}

// Initialization routine.
void setup(void)
{
   glClearColor(1.0, 1.0, 1.0, 0.0);
}

// OpenGL window reshape routine.
void resize(int w, int h)
{
   glViewport(0, 0, (GLsizei)w, (GLsizei)h);
   glMatrixMode(GL_PROJECTION);
   glLoadIdentity();

   // The height/width of the ortho-box match that of the OpenGL window,
   // resulting in a point-to-pixel correspondence.
   gluOrtho2D(0.0, 500.0, 0.0, 500.0);
  
   glMatrixMode(GL_MODELVIEW);
   glLoadIdentity();
}

// Keyboard input processing routine.
void keyInput(unsigned char key, int x, int y)
{
   switch(key)
   {
      case 27:
         exit(0);
         break;
      default:
         break;
   }
}

// Main routine.
int main(int argc, char **argv)
{
   glutInit(&argc, argv);
   glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
   glutInitWindowSize(500, 500);
   glutInitWindowPosition(100, 100);
   glutCreateWindow("Ruben De La Cruz Venegas-DDA.cpp");
   setup();
   glutDisplayFunc(drawScene);
   glutReshapeFunc(resize); 
   glutKeyboardFunc(keyInput);
   glutMainLoop();

   return 0; 

}

EJEMPLO BRESENHAN

#include <GL/glut.h>
#include <stdio.h>
#define BLACK 0
void draw_pixel(int ix, int iy, int value)
{
glBegin(GL_POINTS);
glVertex2i( ix, iy);
glEnd();
}
void bres(int x1,int y1,int x2,int y2)
{
int dx, dy, i, e;
int incx, incy, inc1, inc2;
int x,y;
dx = x2 - x1;
dy = y2 - y1;
if(dx < 0) dx = -dx;
if(dy < 0) dy = -dy;
incx = 1;
if(x2 < x1) incx = -1;
incy = 1;
if(y2 < y1) incy = -1;
x=x1;
y=y1;
if(dx > dy)
{
draw_pixel(x,y, BLACK);
e = 2*dy - dx;
inc1 = 2*( dy -dx);
inc2 = 2*dy;
for(i = 0; i < dx; i++)
{
if(e >= 0)
{
y += incy;
e += inc1;
}
else e += inc2;
x += incx;
draw_pixel(x,y, BLACK);
}
}
else
{
draw_pixel(x,y, BLACK);
e = 2*dx - dy;
inc1 = 2*( dx - dy);
inc2 = 2*dx;
for(i = 0; i < dy; i++)
{
if(e >= 0)
{
x += incx;
e += inc1;
}
else e += inc2;
y += incy;
draw_pixel(x,y, BLACK);
}
}
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT);
bres(200, 200, 100, 100);
glFlush();
}
void myinit()
{
glClearColor(1.0, 1.0, 1.0, 1.0);
glColor3f(1.0, 0.0, 0.0);
glPointSize(1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 499.0, 0.0, 499.0);
}
void main(int argc, char** argv)
{
/* Inicializacion GLUT estándar*/
glutInit(&argc,argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB); 
glutInitWindowSize(500,500); /* ventana 500x500 pixeles */
glutInitWindowPosition(0,0); /* coloca la ventana de despliegue en esq. sup. izq */
glutCreateWindow("Ruben De La Cruz Venegas-Bresenham"); /* título de la ventana*/
glutDisplayFunc(display); /*llama a la funcion display cuando se abre la ventana */
myinit(); /* fija o establece los atributos */
glutMainLoop(); /* entra a un ciclo de evento */

}