Planificación global
CDC * PDC = CDC:: desde handle(hdc);
PDC->; mover a(PS); (PE);
La siguiente es una cita:
Algoritmo de conversión de escaneo para segmentos de línea recta
1 método de diferenciación numérica (DDA)
Según tengo entendido, un eje de coordenadas es el valor del paso (el incremento es 1) y la otra coordenada se basa en la pendiente de la línea (k).
El ordenador determina las coordenadas de cada punto incrementando y luego redondeando.
Algoritmo específico (uso OPENGL para simular)
void setPixel (flash xCoord, flash yCoord)
{
GL comenzar( GL _ POINTS);
glVertex2i(xCoord, yCoord);
glEnd();
}
Redondeo de enteros en línea (constante punto flotante a)
{
return int(a 0.5);
}
void lineDDA(int x0, int y0, int xEnd, int yEnd)
{
int dx = xEnd - x0, dy = yEnd - y0, número de pasos, k;
float xIncrement, yIncremento, x = x0, y = y0
if(abs(dx)>abs(dy))
{
Paso = ABS(dx);
}
Otro
{
Paso = ABS(dy);
}
Incremento Xin = float(dx)/float(pasos);
Incremento yin = float(dy)/float(pasos);
setPixel(round(x), round(y));
for(k = 0; k lt paso; k )
{
x = incremento Xin;
y = incremento yin;
setPixel(round(x), round(y));
}
}
2 Método de dibujo de línea de punto medio
Del mismo modo, el algoritmo que entiendo es tomar un eje de coordenadas con múltiples incrementos como valor de paso (1), y el otro valor de coordenadas
es 1. sin cambios, dependiendo de si el punto medio de los dos valores de coordenadas está por encima o por debajo de la línea recta.
El algoritmo específico es el siguiente:
void lineMiddle(int x0, int y0, int xEnd, int yEnd)
{
int a, b, c, d1, d2, d;
a = y0-yEnd
b = xEnd-x0; * a b; //Prueba discriminante (2a b es el valor inicial)
d 1 = 2 * a; //Incrementa el valor del punto medio debajo de la recta
D2 = 2 * a b; // Valor incremental del punto medio por encima de la recta verdadera
int x, y;
x = x0y = y0
setPixel(x, y);
while(x lt; xEnd)
{
if(d lt; 0)//El punto medio está debajo de la línea.
{
x;
y
d = D2; p>Else//El punto medio está por encima de la línea recta.
{
x;
d = d 1
}
setPixel(x, y) ;
}
}
3. Programa de algoritmo de dibujo lineal de Bresenham;
Utilice un eje de coordenadas como valor de paso (es decir, 1 ), si el otro eje de coordenadas suma 1 se determina en función de la pendiente (k), k.
Si es mayor que 0,5 suma 1, si es menor que 0,5 no lo modificas. Para facilitar el cálculo, si d es mayor que 1, disminúyalo en uno y devuélvalo a cero. Supongamos que e, e=d-0.5, por lo que hay e > 0, agregue 1, e
En la implementación de hardware.
El algoritmo se implementa de la siguiente manera:
void lineBresenham(int x0, int y0, int x1, int y1)
{
int x, y, dx, dy;
Punto flotante k, e;
dx = x 1-x0;
dy = y 1-y0 ;;
k =(flotación)dy/dx;
e =-0.5
x = x0
y = y0;
p>setPixel(x, y);
for(int I = 0; i ltdx; i)
{
x = x 1 ;
e = e k;
si (e gt=0)
{
y ;
e = e-1;
}
setPixel(x, y);
}
}