Estoy jugando con FireMonkey para ver si la pintura gráfica es más rápida que GDI o Graphics32 (mi biblioteca preferida en este momento).¿Por qué dibujar una línea de menos de 1,5 píxeles de grosor dos veces más lenta que dibujar una línea de 10 píxeles de grosor?
Para ver lo rápido que es, he realizado algunas pruebas, pero me encuentro con algún comportamiento extraño:
dibujar líneas finas (1,5 < píxeles de ancho) que parece ser extremadamente lentas líneas más gruesas en comparación: 
- eje vertical: cpu garrapatas para pintar 1000 líneas
- eje horizontal: Tickness línea *
Los resultados son bastante estables; el dibujo siempre se vuelve mucho más rápido una vez que el grosor de la línea es más de 1 píxel de ancho.
En otras bibliotecas parece haber algoritmos rápidos para líneas individuales, y las líneas gruesas son más lentas porque primero se crea un polígono, entonces ¿por qué FireMonkey es al revés?
Principalmente necesito líneas de un píxel, así que ¿debería pintar líneas de una manera diferente?
Las pruebas se realizaron con este código:
// draw random lines, and copy result to clipboard, to paste in excel
procedure TForm5.PaintBox1Paint(Sender: TObject; Canvas: TCanvas);
var
i,iWidth:Integer;
p1,p2: TPointF;
sw:TStopWatch;
const
cLineCount=1000;
begin
Memo1.Lines.Clear;
// draw 1000 different widths, from tickness 0.01 to 10
for iWidth := 1 to 1000 do
begin
Caption := IntToStr(iWidth);
Canvas.BeginScene;
Canvas.Clear(claLightgray);
Canvas.Stroke.Kind := TBrushKind.bkSolid;
Canvas.Stroke.Color := $55000000;
Canvas.StrokeThickness :=iWidth/100;
sw := sw.StartNew;
// draw 1000 random lines
for I := 1 to cLineCount do
begin
p1.Create(Random*Canvas.Width,Random*Canvas.Height);
p2.Create(Random*Canvas.Width,Random*Canvas.Height);
Canvas.DrawLine(p1,p2,0.5);
end;
Canvas.EndScene;
sw.Stop;
Memo1.Lines.Add(Format('%f'#9'%d', [Canvas.StrokeThickness, Round(sw.ElapsedTicks/cLineCount)]));
end;
Clipboard.AsText := Memo1.Text;
end;
actualización
@Steve Wellens: De hecho, las líneas verticales y las líneas horizontales son mucho más rápido. De hecho, hay una diferencia entre los horizontales y los verticales:
líneas diagonales:, líneas horizontales de color azul: verde, líneas verticales: rojo
con líneas verticales, hay una diferencia clara entre las líneas que son menos de 1 píxel de ancho Con las líneas diagonales hay una pendiente entre 1.0 y 1.5.
Lo extraño es que apenas hay diferencia entre pintar una línea horizontal de 1 píxel y pintar uno de 20 píxeles. Supongo que aquí es donde la aceleración del hardware comienza a marcar la diferencia.
¿Es posible hacer algún tipo de decisiones anti-aliasing, como decidir si cualquier píxel * * de la línea debe ser dibujada? –
Estoy de acuerdo (tal vez no está usando el algoritmo de línea Bresenham). Puede probar esto dibujando una línea vertical u horizontal pura. –
@SteveWellens, usa el algoritmo antialias de Wu – OnTheFly