Draw line 1 pixel width

[albertofll]

Hello I begin to playing with this library to check the possibility of using it for a drawing and text editor. The come from GDI and drawing a line with this code:

`img.AntiAliased:= false;

path2[0].X:= 50;
path2[0].Y:= 150;

path2[1].X:= 400;
path2[1].Y:= 150;

DrawLine(img, path2, 1, Color32(clBlack), esPolygon);`

I get a two pixels width. Other line with this code : DrawLine(img, path2, 4, Color32(clBlack), esPolygon); draws the line with 4 pixels. I try to set img.AntiAliased:= false , but it seems doesn't affect to this. How can I draw that line with one pixel width?

[AngusJohnson]

Thanks for the feedback.

What's currently happening is that the renderer is drawing a line at Y = 149.5, so it's splitting the line between Y = 149 and Y = 150.
Of course this isn't a good long term solution, but for the moment you'll need to offset your lines by 0.5 both horizontally and vertically to get the 1px width full density lines you're expecting.

Why is this offset there? Because when antialiasing is enabled, mixing perfectly solid 1px horizontal and vertical lines with other antialiased lines looks odd. But when antialias is disabled, I can see that this 0.5px offset is unhelpful and should be fixed.

[KarlheinzJansen]

Angus,
the lines are drawn with 1 pt and zoom is done inside TImage32Panel.
I believe the double line belong to this discussion.
How can I improve it?
I am thinking of not to zoom in pixel mode and to zoom the path and draw with 1 pt line new.

[AngusJohnson]

the lines are drawn with 1 pt and zoom is done inside TImage32Panel.
I believe the double line belong to this discussion.
How can I improve it?

The only way to avoid 1 pt lines being drawn over 2 lines is to disable anti-aliasing.
As I explained above, this is deliberate because doing otherwise very often produces undesireable results where axis aligned straight segments appear thinner than other (anti-aliased) line segments.

For example:

  img : TImage32;
  p   : TPathD;
  r   : TRectD;
begin
  img := TImage32.Create(100,100);
  r := RectD(5, 5, 95, 95);
  p := RoundRect(r, 20);
  DrawLine(img, p, 1, clBlack32, esClosed);
  img.SaveToFile('c:\temp\test2.png');
  img.Free;

Single pixel width line that's anti-aliased over 2 lines:

Single pixel width line that only anti-aliased at rounded corners:

[andersmelander]

I think there's something wrong with your AA coverage calculation; A 1 pixel wide vertical line covering two pixel columns should result in two vertical lines each with 50% alpha (~$7F000000). As far as I can tell, from your attachments, your two lines have ~62% alpha ($9F000000).
The same inaccuracy can be seen in the corners of the lower image.

I suspect that if you fix this then the smudgy artifacts in the pixel aligned corners (lower image) will be gone

[AngusJohnson]

As far as I can tell, from your attachments, your two lines have ~62% alpha ($9F000000).

Antialiasing does indeed have a 25% weighting.
And that's deliberate as it mostly prevents background bleedthrough between 2 antialiased polgons sharing a common edge.

Image32/source/Img32.Draw.pas

Lines 1361 to 1362 in 1f1cec0

	// a 25% weighting has been added to the alpha channel to minimize any
	// background bleed-through where polygons join with a common edge.

  img := TImage32.Create(80,80);
  p := MakePath([0,80, 0,0, 80,0]);
  p2 := MakePath([80,0, 80,80, 0,80]);
  DrawPolygon(img, p, frNonZero, clBlack32);
  DrawPolygon(img, p2, frNonZero, clBlack32);
  img.SaveToFile('c:\temp\test2.png');
  img.Free;

This is without the 25% weighting:

This is with the 25% weighting:

See also:

Image32/source/Img32.Draw.pas

Line 1148 in 1f1cec0

lastValue := Trunc(Abs(accum) * 318);

Image32/source/Img32.Draw.pas

Lines 1099 to 1103 in 1f1cec0

	// EvenOdd
	lastValue := Trunc(Abs(accum) * 1275) mod 2550; // mul 5
	if lastValue > 1275 then
	lastValue := (2550 - lastValue) shr 2 else // div 4
	lastValue := lastValue shr 2; // div 4

I suspect that if you fix this then the smudgy artifacts in the pixel aligned corners (lower image) will be gone

I wouldn't describe antialiasing as an artifact, since the apparent blurring it produces is unavoidable.
Nevertheless, even when this blurring is lessened by 25% (by removing the weighting I mentioned above), it's still there.

[andersmelander]

Antialiasing does indeed have a 25% weighting.
And that's deliberate as it mostly prevents background bleedthrough between 2 antialiased polgons sharing a common edge.

I see. I also struggled with that problem when I tried to solve the stroke-and-fill problem. In theory it should be solvable by lessening rounding errors so the alpha-sum of the two edges becomes 100% but in practice that quickly becomes unfeasible. I don't have a good solution.

I wouldn't describe antialiasing as an artifact, since the apparent blurring it produces is unavoidable.

I didn't mean AA in general. I was talking about the smudge where the straight lines transitions to an arc:

Nevertheless, even when this blurring is lessened by 25% (by removing the weighting I mentioned above), it's still there.

FWIW, to me that last image looks much better than either of the other two but I guess I'm biased; Here's what the same shape looks like in "that other library":

Image32 - 25%	"other"

[AngusJohnson]

FWIW, to me that last image looks much better than either of the other two but I guess I'm biased; Here's what the same shape looks like in "that other library":

OK, I'll reconsider my current approach.
And I may well only enhance polygon antialiasing (ie not lines too).

And I have no objection at all if you (or others) wish to mention attributes of the Graphics32 library (or any other graphics library).

[AngusJohnson]

Here's what the same shape looks like in "that other library"

Comparing RoundRect drawing between Image32 and Graphics32, I get virtually identical rendering (when removing the 25% antialias enhancement in Image32 as discussed above).

Image32 - 25%	"Graphics32"

  img := TImage32.Create(100,100);
  p := RoundRect(RectD(5, 5, 95, 95), 20);
  DrawLine(img, p, 1, clBlack32, esClosed);
  img.SaveToFile('c:\temp\img32_roundrect_1.png');
  img.Free;

  bmp := TBitmap32.create(100,100);
  path := GR32_VectorUtils.RoundRect(FloatRect(5, 5, 95, 95), 20);
  PolylineFS(bmp, path, clBlack32, true, 1);
  bmp.SaveToFile('c:\temp\gr32_roundrect_1.bmp');
  bmp.free;

And in both libraries, translating the paths right & down by 0.5 px again produces virtually identical (but slightly crisper) rendering:

Image32 - 25%	"Graphics32"

[andersmelander]

I get virtually identical rendering (when removing the 25% antialias enhancement in Image32 as discussed above).

Yes; That's as expected and confirms my observation.

[AngusJohnson]

https://www.angusj.com/image32/Docs/Units/Img32.Draw/Routines/DrawPolygon.htm