Actualmente estoy usando el algoritmo de Bresenham para dibujar líneas, pero tienen (por supuesto) un píxel de grosor. Mi pregunta es ¿cuál es la forma más eficiente de dibujar líneas de grosor arbitrario?¿cómo creo una línea de espesor arbitrario con Bresenham?
El lenguaje que estoy usando es C.
Creo que la mejor forma de hacerlo es dibujar un rectángulo en lugar de una línea desde una línea con anchura es un objeto bidimensional. Tratar de dibujar un conjunto de líneas paralelas para evitar sobregiros (para reducir el ancho de banda de escritura) y underdraw (píxeles faltantes) sería bastante complejo. No es demasiado difícil calcular los puntos de esquina del rectángulo desde el punto inicial y final y el ancho.
No obtuve su solución. ¿Puedes elaborar por favor? – sdkie
Aquí hay una versión modificada del algoritmo de Bresenham para dibujar líneas engrosadas.
Es posible que también desee echar un vistazo a Anti-Grain Geometry, una biblioteca para la representación de software de gráficos de alta calidad y alto rendimiento. Eche un vistazo a demo page para tener una idea de lo que puede hacer.
Algunas rutas fácil de usar:
Asumo que fueras a robar tramos horizontales de una línea de delimitación a otro, y calcular el valor de x en cada una de las líneas por el método de Bresenham a medida que avanza (en una sola lazo).
No lo he intentado.
Es posible que los puntos finales necesiten un poco de atención, para que no parezcan extrañamente cortados.
sí, esta fue la estrategia que también tenía en mente y estoy de acuerdo en que los puntos finales necesitarán algo de reflexión. – horseyguy
Para mi aplicación de impresora térmica integrada, utilizando el algoritmo de Bresenham, la línea era demasiado delgada. No tengo GL ni nada elegante. Terminé simplemente decrementando el valor de Y y dibujando más líneas debajo del primero. Cada número de espesor agregó otra línea. Muy rápido de implementar y hecho para los resultados deseados, imprimiendo desde mapas de bits monocromáticos hasta los térmicos.
Me gustó tu idea, ¿cómo has probado/calculado la distancia deseada entre líneas para que puedas imitar el grosor? fue por ensayo y error? –
Cada punto tiene otro punto debajo ... sin cálculos; la línea era visiblemente más gruesa. Terminé usando 3 líneas, cada una con un valor Y menor que el anterior. Cualquier mínimo y menor que y fue cambiado a Y mínimo. –
Lo siento, extraño confundir sobre el control del grosor y el control del ancho de la línea. –
Tome otro bucle de Bresenham y utilícelo para modificar la posición inicial y final de la línea original en dirección rectangular. El problema es encontrar eficientemente el punto de inicio correcto y no dibujar ningún píxel dos veces (u omitir un píxel) mientras dibuja la siguiente línea.
El código C en funcionamiento y probado está disponible en Github C code.
Aquí una página de prueba que incluye algunas líneas de muestra creadas por este código. Los píxeles negros son los puntos de partida para el algoritmo.
Si pudiera, votaría más esta respuesta, porque es la única que dirige al lector a una implementación limpia y funcional en C, tal como solicitó el OP. – msteiger
¡Eso es tan inteligente! – hexaflexagonal
http://members.chello.at/~easyfilter/bresenham.html
El ejemplo en la parte inferior de este enlace es javascript, pero debería ser bastante fácil de adaptar a C. Es un algoritmo de suavizado bastante sencillo para dibujar líneas de espesor variable.
Para una mejor precisión, y también un buen rendimiento para líneas más gruesas, especialmente, puede dibujar la línea como un polígono. Algunos pseudo código:
draw_line(x1,y1,x2,y2,thickness)
Point p[4];
angle = atan2(y2-y1,x2-x1);
p[0].x = x1 + thickness*cos(angle+PI/2);
p[0].y = y1 + thickness*sin(angle+PI/2);
p[1].x = x1 + thickness*cos(angle-PI/2);
p[1].y = y1 + thickness*sin(angle-PI/2);
p[2].x = x2 + thickness*cos(angle-PI/2);
p[2].y = y2 + thickness*sin(angle-PI/2);
p[3].x = x2 + thickness*cos(angle+PI/2);
p[3].y = y2 + thickness*sin(angle+PI/2);
draw_polygon(p,4)
y, opcionalmente, un círculo se pueden extraer en cada punto final.
En cierto modo, esto reduce el problema a uno más complejo. Para que funcione (en Python), tuve que ajustar las cosas, sin embargo: a) intercambiar el pecado y el cos. b) en lugar de multiplicar por grosor, multiplica por grosor/2.0. – Ant6n
@ Antón Creo que es el * ángulo * que está mal. Esto debería ser 'atan2 (y2-y1, x2-x1)'. – colinta
@colina Se arregló. – Fabel
Hago esto bastante a menudo para generar imágenes de fibras y esferas para simulaciones de medios porosos. Tengo una forma muy simple de hacer esto utilizando una técnica de análisis de imágenes muy estándar conocida como la "transformación a distancia". Esto requiere tener acceso a un paquete de análisis de imagen. Yo uso Python con Scipy, así que esto no es problema. He aquí una demostración para convertir puntos distribuidos aleatoriamente en dos esferas:
import scipy as sp
import scipy.ndimage as spim
im1 = sp.rand(100, 100) < 0.995 # Create random points in space
dt = spim.distance_transform_edt(im1)
im2 = dt < 5 # To create sphere with a radius of 5
Y eso es todo! La transformación de distancia puede ser lenta para imágenes muy grandes, pero hay una versión eficiente por ahí. Por ejemplo, ImageJ tiene una paralelizada. Obviamente, para crear fibras gruesas, solo crea su imagen de delgadas, luego aplique los pasos 2 y 3 anteriores.
Reetiquetado "independiente del idioma" ya que el lenguaje de implementación no es realmente relevante. –
aquí hay una pregunta relacionada con esto: http://stackoverflow.com/questions/101718/drawing-a-variable-width-line-in-opengl-no-gllinewidth –
@banister: ¿tiene alguna demo para compartir con nosotros? – sdkie