Programación de dibujo de Windows
CDC * PDC = CDC::from handle(hdc);
PDC->; pasar 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));
}
}
Método de dibujo de línea de 2 puntos medios
Del mismo modo, el algoritmo que entiendo es tomar un eje de coordenadas con múltiples incrementos como valor de paso (1) y otro eje de coordenadas
El valor es 1 o no cambia, dependiendo de si el punto medio de los dos valores de coordenadas está por encima o por debajo de la línea.
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; //Incrementa el valor del punto medio sobre la recta real
int x, y;
x = x0y = y0
setPixel(x, y );
while(x & lt; xEnd)
{
if(d & lt;0)//El punto medio es 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, déjalo sin cambios. Para facilitar el cálculo, si d es mayor que 1, disminúyalo en uno y devuélvalo a cero. Supongamos 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<dx;i++)
{
x = x +1;
e = e+k;
Si (e & gt=0)
{
y++;
p>
e = e-1;
}
setPixel(x, y);
}
}