Thick LINE

[Petr]

Hi.
When drawing in QB64, it is sometimes necessary to use a thick line. I developed this program for drawing it. The question is: How to do it better?


Thick line started from above:

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(800, 600, 32)
2. cx = 400: cy = 300
3.  
4. 'fat circle test
5. FOR c = 0 TO _PI(2) STEP .01
6.     X = cx + SIN(c) * 200
7.     Y = cy + COS(c) * 200
8.     X2 = cx + SIN(c + .01) * 200
9.     Y2 = cy + COS(c + .01) * 200
10.     TLine X, Y, X2, Y2, &HFFFF0000, 15
11. NEXT
12. _DISPLAY
13. PCOPY _DISPLAY, 1
14.  
15.  
16. 'thick line
17. DO
18.     PCOPY 1, _DISPLAY
19.     WHILE _MOUSEINPUT: WEND
20.     ex = _MOUSEX
21.     ey = _MOUSEY
22.     LINE (cx, cy)-(ex, ey), &HFFFF0000
23.     TLine cx, cy, ex, ey, &H59FFE1CC, 10
24.     _DISPLAY
25.     _LIMIT 20
26. LOOP
27.  
28.  
29.  
30.  
31.  
32. SUB TLine (x1, y1, x2, y2, kolor~&, size)
33.     lenght = SQR((x2 - x1) ^ 2 + (y2 - y1) ^ 2)
34.     angle = JK!(x1, y1, x2, y2, lenght)
35.  
36.     x3 = x1 + SIN(angle + _PI(.5)) * size 'Calculation of perpendicular vector. The default vector is X1, Y1 to X2, Y2. The JK function returns the angle of rotation of the vector, the perpendicular vector is shift by 90 degrees, (or PI /2) in radians.
37.     y3 = y1 + COS(angle + _PI(.5)) * size
38.     x4 = x2 + SIN(angle + _PI(.5)) * size
39.     y4 = y2 + COS(angle + _PI(.5)) * size
40.  
41.     v = _NEWIMAGE(10, 10, 32)
42.     d = _DEST
43.     _DEST v
44.     CLS , kolor~&
45.     _DEST d
46.     _MAPTRIANGLE (1, 1)-(9, 1)-(1, 9), v TO(x1, y1)-(x2, y2)-(x3, y3), _DEST, _SMOOTH
47.     _MAPTRIANGLE (9, 1)-(1, 9)-(9, 9), v TO(x2, y2)-(x3, y3)-(x4, y4), _DEST, _SMOOTH
48.     _FREEIMAGE v
49. END SUB
50.  
51.  
52.  
53.  
54.  
55. FUNCTION JK! (cx, cy, px, py, R!)
56.     LenX! = cx - px
57.     LenY! = cy - py
58.     jR! = 1 / R!
59.     jX! = LenX! * jR!
60.     jY! = LenY! * jR!
61.  
62.     sinusAlfa! = jX!
63.     Alfa! = ABS(_ASIN(sinusAlfa!))
64.  
65.     Q = 1
66.     IF px >= cx AND py >= cy THEN Q = 1 ' select angle to quadrant
67.     IF px >= cx AND py <= cy THEN Q = 2
68.     IF px <= cx AND py <= cy THEN Q = 3
69.     IF px <= cx AND py >= cy THEN Q = 4
70.     SELECT CASE Q
71.         CASE 1: alfaB! = Alfa!
72.         CASE 2: alfaB! = _PI / 2 + (_PI / 2 - Alfa!)
73.         CASE 3: alfaB! = _PI + Alfa!
74.         CASE 4: alfaB! = _PI(1.5) + (_PI / 2 - Alfa!)
75.     END SELECT
76.     JK! = alfaB!
77.     IF JK! = 0 THEN BEEP
78. END FUNCTION
79.  

Thick line is centered:

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(800, 600, 32)
2. cx = 400: cy = 300
3.  
4. 'thick circle test
5. FOR c = 0 TO _PI(2) STEP .01
6.     X = cx + SIN(c) * 200
7.     Y = cy + COS(c) * 200
8.     X2 = cx + SIN(c + .01) * 200
9.     Y2 = cy + COS(c + .01) * 200
10.     TLine X, Y, X2, Y2, &HFFFF0000, 15
11. NEXT
12. _DISPLAY
13. PCOPY _DISPLAY, 1
14.  
15.  
16. 'Thick line
17. DO
18.     PCOPY 1, _DISPLAY
19.     WHILE _MOUSEINPUT: WEND
20.     ex = _MOUSEX
21.     ey = _MOUSEY
22.     LINE (cx, cy)-(ex, ey), &HFFFF0000
23.     TLine cx, cy, ex, ey, &H59FFE1CC, 10
24.     _DISPLAY
25.     _LIMIT 20
26. LOOP
27.  
28.  
29.  
30.  
31.  
32. SUB TLine (x1, y1, x2, y2, kolor~&, size)
33.     lenght = SQR((x2 - x1) ^ 2 + (y2 - y1) ^ 2)
34.     angle = JK!(x1, y1, x2, y2, lenght)
35.  
36.     x5 = x1 + SIN(angle - _PI(.5)) * size / 2
37.     y5 = y1 + COS(angle - _PI(.5)) * size / 2
38.     x6 = x2 + SIN(angle - _PI(.5)) * size / 2
39.     y6 = y2 + COS(angle - _PI(.5)) * size / 2
40.  
41.     x3 = x1 + SIN(angle + _PI(.5)) * size / 2 'Calculation of perpendicular vector. The default vector is X1, Y1 to X2, Y2. The JK function returns the angle of rotation of the vector, the perpendicular vector is shift by 90 degrees, (or PI /2) in radians.
42.     y3 = y1 + COS(angle + _PI(.5)) * size / 2
43.     x4 = x2 + SIN(angle + _PI(.5)) * size / 2
44.     y4 = y2 + COS(angle + _PI(.5)) * size / 2
45.  
46.     v = _NEWIMAGE(10, 10, 32)
47.     d = _DEST
48.     _DEST v
49.     CLS , kolor~&
50.     _DEST d
51.     _MAPTRIANGLE (1, 1)-(9, 1)-(1, 9), v TO(x5, y5)-(x6, y6)-(x3, y3), _DEST, _SMOOTH
52.     _MAPTRIANGLE (9, 1)-(1, 9)-(9, 9), v TO(x6, y6)-(x3, y3)-(x4, y4), _DEST, _SMOOTH
53.     _FREEIMAGE v
54. END SUB
55.  
56.  
57.  
58.  
59.  
60. FUNCTION JK! (cx, cy, px, py, R!)
61.     LenX! = cx - px
62.     LenY! = cy - py
63.     jR! = 1 / R!
64.     jX! = LenX! * jR!
65.     jY! = LenY! * jR!
66.  
67.     sinusAlfa! = jX!
68.     Alfa! = ABS(_ASIN(sinusAlfa!))
69.  
70.     Q = 1
71.     IF px >= cx AND py >= cy THEN Q = 1 ' select angle to quadrant
72.     IF px >= cx AND py <= cy THEN Q = 2
73.     IF px <= cx AND py <= cy THEN Q = 3
74.     IF px <= cx AND py >= cy THEN Q = 4
75.     SELECT CASE Q
76.         CASE 1: alfaB! = Alfa!
77.         CASE 2: alfaB! = _PI / 2 + (_PI / 2 - Alfa!)
78.         CASE 3: alfaB! = _PI + Alfa!
79.         CASE 4: alfaB! = _PI(1.5) + (_PI / 2 - Alfa!)
80.     END SELECT
81.     JK! = alfaB!
82.     IF JK! = 0 THEN BEEP
83. END FUNCTION
84.  

Corrected thread name and function due to wrong (english) name.

[bplus]

Hi Petr,

I've been using this:

Code: QB64: [Select]

1. SUB thic (x1, y1, x2, y2, thick, K AS _UNSIGNED LONG)
2.     'need const PD2 = _PI(.5)
3.     DIM t2 AS SINGLE, a AS SINGLE, x3 AS SINGLE, y3 AS SINGLE, x4 AS SINGLE, y4 AS SINGLE
4.     DIM x5 AS SINGLE, y5 AS SINGLE, x6 AS SINGLE, y6 AS SINGLE
5.     t2 = thick / 2
6.     IF t2 < 1 THEN t2 = 1
7.     a = _ATAN2(y2 - y1, x2 - x1)
8.     x3 = x1 + t2 * COS(a + PD2)
9.     y3 = y1 + t2 * SIN(a + PD2)
10.     x4 = x1 + t2 * COS(a - PD2)
11.     y4 = y1 + t2 * SIN(a - PD2)
12.     x5 = x2 + t2 * COS(a + PD2)
13.     y5 = y2 + t2 * SIN(a + PD2)
14.     x6 = x2 + t2 * COS(a - PD2)
15.     y6 = y2 + t2 * SIN(a - PD2)
16.     ftri x6, y6, x4, y4, x3, y3, K
17.     ftri x3, y3, x5, y5, x6, y6, K
18. END SUB
19.  
20. '2019-11-20 Steve saves some time with STATIC and saves and restores last dest
21. SUB ftri (x1, y1, x2, y2, x3, y3, K AS _UNSIGNED LONG)
22.     DIM D AS LONG
23.     STATIC a&
24.     D = _DEST
25.     IF a& = 0 THEN a& = _NEWIMAGE(1, 1, 32)
26.     _DEST a&
27.     PSET (0, 0), K
28.     _DEST D
29.     _MAPTRIANGLE _SEAMLESS(0, 0)-(0, 0)-(0, 0), a& TO(x1, y1)-(x2, y2)-(x3, y3)
30. END SUB
31.  

But with _MAPTRIANGLE you could fill with image, I think, like paintImage?

Oh, also there is question of whether to round the ends of the lines or not, part of the answer depends if you want to preserve clean transparencies or not.

I've also done circle rings and thick arcs attempting to preserve transparencies..

[Petr]

Thank you, BPlus. Yes, it can be fill with images, but i test it now for colors. I was initially just making thick lines. Texturing is an added and welcome feature in addition. I see, ATAN2 easily replaces my JK function in two lines. How I struggled before I wrote it...
I started to calculate the angle from position 90 degrees lower than _ATAN2 and then I calculated the angles upside down (for the shift of SIN in X and for COS in Y), but that doesn't matter ....
Thank you for your solution. Basically, two functions can be constructed from this. One on solid lines, another on textured lines.

Here is the same program with your (BPlus) vector angle method. See, that in this case are variables X calculated as COS and Y as SIN, with my version it is X using SIN and Y using COS:

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(800, 600, 32)
2. cx = 400: cy = 300
3.  
4. 'thick circle test
5. FOR c = 0 TO _PI(2) STEP .1
6.     X = cx + SIN(c) * 200
7.     Y = cy + COS(c) * 200
8.     X2 = cx + SIN(c + .1) * 200
9.     Y2 = cy + COS(c + .1) * 200
10.     TLine X, Y, X2, Y2, &HFFFF0000, 15
11. NEXT
12.  
13.  
14. TLine 100, 110, 560, 466, &H88FFFFFF, 60
15.  
16.  
17. _DISPLAY
18. PCOPY _DISPLAY, 1
19.  
20.  
21. 'Thick line
22. DO
23.     PCOPY 1, _DISPLAY
24.     WHILE _MOUSEINPUT: WEND
25.     ex = _MOUSEX
26.     ey = _MOUSEY
27.     LINE (cx, cy)-(ex, ey), &HFFFF0000
28.     TLine cx, cy, ex, ey, &H59FFE1CC, 10
29.     _DISPLAY
30.     _LIMIT 20
31. LOOP
32.  
33.  
34.  
35.  
36.  
37. SUB TLine (x1, y1, x2, y2, kolor~&, size)
38.     lenght = SQR((x2 - x1) ^ 2 + (y2 - y1) ^ 2)
39.     '    angle = JK!(x1, y1, x2, y2, lenght)
40.     angle = JK2!(x1, y1, x2, y2)
41.  
42.     x5 = x1 + COS(angle - _PI(.5)) * size / 2
43.     y5 = y1 + SIN(angle - _PI(.5)) * size / 2
44.     x6 = x2 + COS(angle - _PI(.5)) * size / 2
45.     y6 = y2 + SIN(angle - _PI(.5)) * size / 2
46.  
47.     x3 = x1 + COS(angle + _PI(.5)) * size / 2 'Calculation of perpendicular vector. The default vector is X1, Y1 to X2, Y2. The JK function returns the angle of rotation of the vector, the perpendicular vector is shift by 90 degrees, (or PI /2) in radians.
48.     y3 = y1 + SIN(angle + _PI(.5)) * size / 2
49.     x4 = x2 + COS(angle + _PI(.5)) * size / 2
50.     y4 = y2 + SIN(angle + _PI(.5)) * size / 2
51.  
52.     v = _NEWIMAGE(100, 100, 32)
53.     d = _DEST
54.     _DEST v
55.     CLS , kolor~&
56.     _DEST d
57.  
58.     IF lenght THEN
59.         _MAPTRIANGLE (1, 1)-(99, 1)-(1, 99), v TO(x5, y5)-(x6, y6)-(x3, y3), _DEST, _SMOOTH
60.         _MAPTRIANGLE (99, 1)-(1, 99)-(99, 99), v TO(x6, y6)-(x3, y3)-(x4, y4), _DEST, _SMOOTH
61.     END IF
62.     _FREEIMAGE v
63. END SUB
64.  
65.  
66.  
67. FUNCTION JK2! (x1, y1, x2, y2) 'X = cos, Y = sin              BPlus method
68.     JK2! = _ATAN2(y1 - y2, x1 - x2)
69.     IF JK2! < 0 THEN JK2! = _PI(2) + JK2!
70. END FUNCTION
71.  

So textured lines:

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(800, 600, 32)
2. cx = 400: cy = 300
3.  
4. texture = _NEWIMAGE(800, 90, 32)
5. f = _LOADFONT("arial.ttf", 20, "monospace")
6.  
7. d = _DEST
8. _DEST texture
9. _FONT f, texture
10. CLS , &HFF91EF11
11. _PRINTMODE _KEEPBACKGROUND
12. COLOR &HFF000000
13. _PRINTSTRING (150, 35), "Thank you, BPlus alias B+!"
14. _DEST d
15.  
16. DO
17.     TLineTex 566, 100, 110, 466, texture, 100
18.     _DISPLAY
19. LOOP
20.  
21.  
22. SUB TLineTex (x1, y1, x2, y2, texture, size)
23.     lenght = SQR((x2 - x1) ^ 2 + (y2 - y1) ^ 2)
24.     '    angle = JK!(x1, y1, x2, y2, lenght)
25.     angle = JK2!(x1, y1, x2, y2)
26.  
27.     x5 = x1 + COS(angle + _PI(.5)) * size / 2
28.     y5 = y1 + SIN(angle + _PI(.5)) * size / 2
29.     x6 = x2 + COS(angle + _PI(.5)) * size / 2
30.     y6 = y2 + SIN(angle + _PI(.5)) * size / 2
31.  
32.     x3 = x1 + COS(angle - _PI(.5)) * size / 2 'Calculation of perpendicular vector. The default vector is X1, Y1 to X2, Y2. The JK function returns the angle of rotation of the vector, the perpendicular vector is shift by 90 degrees, (or PI /2) in radians.
33.     y3 = y1 + SIN(angle - _PI(.5)) * size / 2
34.     x4 = x2 + COS(angle - _PI(.5)) * size / 2
35.     y4 = y2 + SIN(angle - _PI(.5)) * size / 2
36.     W = _WIDTH(texture)
37.     H = _HEIGHT(texture)
38.  
39.     IF lenght THEN
40.         _MAPTRIANGLE (W - 1, H - 1)-(0, H - 1)-(W - 1, 0), texture TO(x5, y5)-(x6, y6)-(x3, y3), _DEST, _SMOOTH
41.         _MAPTRIANGLE (0, H - 1)-(W - 1, 0)-(0, 0), texture TO(x6, y6)-(x3, y3)-(x4, y4), _DEST, _SMOOTH
42.     END IF
43.  
44. END SUB
45.  
46.  
47.  
48. FUNCTION JK2! (x1, y1, x2, y2) 'X = cos, Y = sin
49.     JK2! = _ATAN2(y1 - y2, x1 - x2)
50.     IF JK2! < 0 THEN JK2! = _PI(2) + JK2!
51. END FUNCTION
52.  
53.  

 

[bplus]

Yeah Petr, nice work with image!

[STxAxTIC]

Look at all that trig! I'm sure bplus would rewrite this using only vectors if forced...

(Nice work anyway!)

XD

[SierraKen]

Something for very, very beginners, that looks like using a chalk:
Use arrow keys and number key 1 to make smaller and 2 to make larger.
Esc to quit.

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(800, 600, 32)
2. X=400
3. Y=300
4. W=1
5. DO
6. A$=INKEY$
7. IF A$=CHR$(0)+CHR$(72) THEN Y=Y-1 'Up arrow key.
8. IF A$=CHR$(0)+CHR$(80) THEN Y=Y+1 'Down arrow key.
9. IF A$=CHR$(0)+CHR$(77) THEN X=X+1 'Right arrow key.
10. IF A$=CHR$(0)+CHR$(75) THEN X=X-1 'Left arrow key.
11. IF A$="1" THEN W=W-1 'Make line thinner.
12. IF A$="2" THEN W=W+1 'Make line thicker.
13. IF A$=CHR$(27) THEN END 'Esc to quit.
14. IF W>200 THEN W=200
15. IF W<1 THEN W=1
16. CIRCLE (X,Y),W,_RGB32(255,255,255) 'White circle is drawn.
17. LOOP
18.  

[bplus]

Yeah, I remember doing thick lines with filled circles, I made a whole font with them.

[SMcNeill]

Heck, I thought I'd try this just by thinking outside the box -- how to make a thick line without using any math more complicated than basic addition or subtraction.  What I've played around with and came up with is this little snippet:

Code: QB64: [Select]

1. _DEFINE A-Z AS _FLOAT
2. SCREEN _NEWIMAGE(640, 480, 32)
3.  
4. ThickLine 100, 100, 300, 300, 10, &HFFFF0000
5. ThickLine 300, 100, 100, 300, 15, &HFF00FF00
6. ThickLine 200, 400, 400, 300, 20, &HFF0000FF
7.  
8. SUB ThickLine (X1, Y1, X2, Y2, Thick, Kolor AS _UNSIGNED LONG)
9.     Rise = Y2 - Y1: Runn = X2 - X1: Slope = Rise / Runn
10.     FOR i = 0 TO Thick
11.         X3 = X1 + i * Slope: Y3 = Y1 - ABS(i * Slope)
12.         X4 = X2 + i * Slope: Y4 = Y2 - ABS(i * Slope)
13.         LINE (X3, Y3)-(X4, Y4), Kolor
14.     NEXT
15. END SUB

I'm certain the math guys here can tell us why this doesn't work, and why it appears to give a dotted line pattern rather than a solid fill block, but I thought the results were pretty interesting, myself.  I personally dunno WHY it's doing what it's doing, but I kind of like it...

Anywho, I thought I'd share, just as a way to pass time and try something different than all the rest.  ;)

[FellippeHeitor]

In trying it different, here's how I once did it:

Code: QB64: [Select]

1. SUB thickLine (x1!, y1!, x2!, y2!, lineWidth%)
2.     DIM angle%, distance%, halfThickness%
3.     angle% = INT(_R2D(_ATAN2(y2! - y1!, x2! - x1!)))
4.     distance% = _HYPOT((x2! - x1!), (y2! - y1!))
5.     halfThickness% = lineWidth% / 2
6.     IF halfThickness% < 1 THEN halfThickness% = 1
7.     IF halfThickness% = 1 THEN
8.         DRAW "bm" + STR$(x1!) + "," + STR$(y1!) + " TA" + STR$(-angle%) + " R" + STR$(distance%)
9.     ELSE
10.         DRAW "bm" + STR$(x1!) + "," + STR$(y1!) + " TA" + STR$(-angle%) + "U" + STR$(halfThickness%) + " R" + STR$(distance%) + "D" + STR$(halfThickness% * 2) + " L" + STR$(distance%) + "U" + STR$(halfThickness%) + " B R" + STR$(distance% / 2) + "P" + STR$(_DEFAULTCOLOR) + "," + STR$(_DEFAULTCOLOR)
11.     END IF
12. END SUB

And an example using it:

Code: QB64: [Select]

1. CONST false = 0, true = NOT false
2.  
3. DIM x1, y1, x2, y2
4. DIM mouseDown AS _BYTE
5. DIM totalDots AS INTEGER
6. DIM thickness AS INTEGER
7.  
8. thickness = 10
9.  
10. SCREEN _NEWIMAGE(800, 600, 32)
11.  
12. DO
13.     WHILE _MOUSEINPUT: thickness = thickness + _MOUSEWHEEL: WEND
14.  
15.     IF thickness < 1 THEN thickness = 1
16.  
17.     IF _MOUSEBUTTON(1) THEN
18.         IF NOT mouseDown THEN
19.             mouseDown = true
20.             totalDots = totalDots + 1
21.             IF totalDots > 2 THEN totalDots = 1
22.             SELECT CASE totalDots
23.                 CASE 1
24.                     x1 = _MOUSEX
25.                     y1 = _MOUSEY
26.                 CASE 2
27.                     x2 = _MOUSEX
28.                     y2 = _MOUSEY
29.             END SELECT
30.         END IF
31.     ELSE
32.         mouseDown = false
33.     END IF
34.  
35.     CLS
36.     PRINT "Click to set the initial line coordinate,"
37.     PRINT "click again to set the final line coordinate."
38.     PRINT "Use the mousewheel to make the line thicker/thinner."
39.     PRINT "Current thickness:"; thickness
40.  
41.     IF totalDots = 1 THEN
42.         PSET (x1, y1)
43.     ELSE
44.         thickLine x1, y1, x2, y2, thickness
45.     END IF
46.     _DISPLAY
47.     _LIMIT 30
48. LOOP
49.  
50. SUB thickLine (x1!, y1!, x2!, y2!, lineWidth%)
51.     DIM angle%, distance%, halfThickness%
52.     angle% = INT(_R2D(_ATAN2(y2! - y1!, x2! - x1!)))
53.     distance% = _HYPOT((x2! - x1!), (y2! - y1!))
54.     halfThickness% = lineWidth% / 2
55.     IF halfThickness% < 1 THEN halfThickness% = 1
56.     IF halfThickness% = 1 THEN
57.         DRAW "bm" + STR$(x1!) + "," + STR$(y1!) + " TA" + STR$(-angle%) + " R" + STR$(distance%)
58.     ELSE
59.         DRAW "bm" + STR$(x1!) + "," + STR$(y1!) + " TA" + STR$(-angle%) + "U" + STR$(halfThickness%) + " R" + STR$(distance%) + "D" + STR$(halfThickness% * 2) + " L" + STR$(distance%) + "U" + STR$(halfThickness%) + " B R" + STR$(distance% / 2) + "P" + STR$(_DEFAULTCOLOR) + "," + STR$(_DEFAULTCOLOR)
60.     END IF
61. END SUB

[SMcNeill]

Here's another attempt at something different -- this one starts with the single line, then simply pads it thicker as many times as we want it to.

Code: QB64: [Select]

1. SCREEN _NEWIMAGE(640, 480, 32)
2.  
3.  
4. ThickLine 100, 100, 300, 300, 10, &HFFFF0000
5. ThickLine 300, 100, 100, 300, 35, &HFF00FF00
6. ThickLine 200, 400, 400, 300, 30, &HFF0000FF
7.  
8.  
9.  
10. SUB ThickLine (X1, Y1, X2, Y2, Thick, Kolor AS _UNSIGNED LONG)
11.     $CHECKING:OFF
12.     STATIC temp
13.     DIM Array(_WIDTH, _HEIGHT) AS _UNSIGNED LONG
14.     STATIC m AS _MEM, m1 AS _MEM
15.     D = _DEST
16.     IF temp = 0 THEN temp = _NEWIMAGE(_WIDTH, _HEIGHT, 32): _DEST temp ELSE _DEST temp: CLS , 0
17.     m = _MEMIMAGE(temp)
18.     m1 = _MEM(Array())
19.     LINE (X1, Y1)-(X2, Y2), Kolor
20.     FOR i = 1 TO Thick
21.         FOR x = 0 TO _WIDTH - 1
22.             FOR y = 0 TO _HEIGHT - 1
23.                 IF _MEMGET(m, m.OFFSET + (y * _WIDTH + x) * 4, _UNSIGNED LONG) <> 0 THEN
24.                     _MEMPUT m1, m1.OFFSET + (y * _WIDTH + x + 1) * 4, Kolor
25.                     _MEMPUT m1, m1.OFFSET + (y * _WIDTH + x - 1) * 4, Kolor
26.                     _MEMPUT m1, m1.OFFSET + ((y + 1) * _WIDTH + x) * 4, Kolor
27.                     _MEMPUT m1, m1.OFFSET + ((y - 1) * _WIDTH + x) * 4, Kolor
28.                 END IF
29.             NEXT
30.         NEXT
31.         o = 0
32.         DO UNTIL o >= m.SIZE
33.             IF _MEMGET(m1, m1.OFFSET + o, _UNSIGNED LONG) <> 0 THEN _MEMPUT m, m.OFFSET + o, Kolor
34.             o = o + 4
35.         LOOP
36.         _PUTIMAGE , temp, D: SLEEP 'comment this line out if you don't want to watch the process at work
37.     NEXT
38.     _DEST D
39.     _PUTIMAGE , temp, D
40.     $CHECKING:ON
41. END SUB

Once again, not perfect results (the 3rd test line ends up almost looking like a 3D blue box of sorts, for my display), but they're interesting (to me at least)! 

[bplus]

Thick line, thick arc and font:

Code: QB64: [Select]

1. _TITLE "Bplus font" 'B+ 2019-11-29 trans from
2. ' Plasma Deluxe.bas  SmallBASIC 0.12.6 [B+=MGA] 2016-05-16
3.  
4. CONST xmax = 1200, ymax = 600, pi = 3.141592654
5. DIM SHARED dr, thick, lx, ly
6. SCREEN _NEWIMAGE(xmax, ymax, 32)
7. _SCREENMOVE 90, 60
8. DIM clr AS _UNSIGNED LONG
9. clr = &HFFAACCFF
10. post i, i, 10, clr, "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvXxYyZz1234567890?!.,"
11. post 0, i + 20, 20, clr, "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvXxYyZz1234567890?!.,"
12. post 0, i + 50, 30, clr, "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvXxYyZz1234567890?!.,"
13. post 0, i + 90, 40, clr, "AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvXxYyZz1234567890?!.,"
14. _DELAY 7
15.  
16. WHILE _KEYDOWN(27) = 0
17.     COLOR 0, 0: CLS
18.     b = RND ^ 2: c = RND ^ 2: d = RND ^ 2
19.     FOR i = 1 TO 400
20.         post i, i, 100, clr, "Bplus Font"
21.         clr = _RGB32(127 + 127 * SIN(b * i), 127 + 127 * SIN(c * i), 127 + 127 * SIN(d * i))
22.         _DISPLAY
23.         _LIMIT 60
24.     NEXT
25. WEND
26.  
27.  
28. SUB post (x, y, scale, fore AS _UNSIGNED LONG, mess$)
29.     'local lm,i,c,p1,p2,p3,p4,px,gf
30.     thick = 1 / 40 * scale
31.     dr = scale / 6 - thick / 2
32.     gf = .04 * scale
33.     COLOR fore
34.     p1 = .16 * scale: p2 = .32 * scale: p3 = .48 * scale: p4 = .64 * scale
35.     lm = LEN(mess$): py = y + .5 * thick
36.     IF lm * scale * .5 + x - xmax > 0 THEN BEEP 'draw it anyway
37.     FOR i = 1 TO lm
38.         c$ = MID$(mess$, i, 1)
39.         px = x + (i - 1) * scale * .5 + .5 * thick
40.         SELECT CASE c$
41.             CASE "a": ac px + p1, py + p3, 0, 360: lx = px + p2: ly = py + p2 - gf: tl 0, p2: tl 0, 2 * gf
42.             CASE "b": ac px + p1, py + p3, 0, 360: lx = px: ly = py: tl 0, p4
43.             CASE "c": ac px + p1, py + p3, 40, 320
44.             CASE "d": ac px + p1, py + p3, 0, 360: lx = px + p2: ly = py: tl 0, p4
45.             CASE "e": ac px + p1, py + p3, 45, 360: lx = px: ly = py + p3: tl p2, 0
46.             CASE "f": ac px + p2, py + p1 + gf, 180, 270: lx = px: ly = py + p2: tl p2, 0: lx = px + p1: ly = py + p1: tl 0, p3
47.             CASE "g": ac px + p1, py + p3, 0, 360: lx = px + p2: ly = py + p2: tl 0, p2: ac px + p1, py + p4, 0, 90: lx = px: ly = py + p4 + p1: tl p1, 0
48.             CASE "h": ac px + p1, py + p3, 180, 360: lx = px: ly = py: tl 0, p4: lx = px + p2: ly = py + p3: tl 0, p1
49.             CASE "i": lx = px + p1 - gf: ly = py + p2: tl gf, 0: tl 0, p2: tl -gf, 0: tl 2 * gf, 0
50.                 lx = px + p1 - gf: ly = py + p1: tl gf, 0: tl 0, -gf: tl -gf, 0: tl 0, gf
51.             CASE "j": lx = px + p1 - gf: ly = py + p2: tl gf, 0: tl 0, p2: ac px, py + p4, 0, 120
52.                 lx = px + p1 - gf: ly = py + p1: tl gf, 0: tl 0, -gf: tl -gf, 0: tl 0, gf
53.             CASE "k": lx = px: ly = py: tl 0, p4: lx = px + p2: ly = py + p2: tl -p2, p1: tl p2, p1
54.             CASE "l": lx = px + p1 - gf: ly = py: tl gf, 0: tl 0, p4: tl gf, 0: tl -2 * gf, 0
55.             CASE "m": lx = px: ly = py + p2: tl 0, p2: lx = px + p1: ly = py + p4: tl 0, -p2: tl -p1, p1: lx = px + p2: ly = py + p4: tl 0, -p2: tl -p1, p1
56.             CASE "n": ac px + p1, py + p3, 180, 360: lx = px: ly = py + p2 - gf: tl 0, p2 + gf: lx = px + p2: ly = py + p3: tl 0, p1
57.             CASE "o": ac px + p1, py + p3, 0, 360
58.             CASE "p": ac px + p1, py + p3, 0, 360: lx = px: ly = py + p2 - gf: tl 0, p4 - 2 * gf
59.             CASE "q": ac px + p1, py + p3, 0, 360: lx = px + p2: ly = py + p2 - gf: tl 0, p4 - 2 * gf: tl 2 * gf, 0
60.             CASE "r": lx = px: ly = py + p2: tl 0, p2: ac px + p1, py + p3, 180, 340
61.             CASE "s": dr = 1 / 12 * scale: ac px + .5 * p1, py + p2 + dr, 90, 270: ac px + 1.5 * p1, py + p3 + dr, 270, 450: dr = 1 / 6 * scale
62.                 lx = px + .5 * p1: ly = py + p2: tl p1 * 1.5, 0: lx = px: ly = py + p4: tl p1 * 1.5, 0: lx = px + .5 * p1: ly = py + p3: tl p1, 0
63.             CASE "t": lx = px + p1: ly = py: tl 0, p4: tl 2 * gf, 0: lx = px: ly = py + p2: tl p2, 0
64.             CASE "u": ac px + p1, py + p3, 0, 180: lx = px: ly = py + p2: tl 0, p1 * 1.5: lx = px + p2: ly = py + p2: tl 0, p2 + gf
65.             CASE "v": lx = px: ly = py + p2: tl p1, p2 + gf: tl p1, -p2 - 1.5 * gf
66.             CASE "w": lx = px - gf: ly = py + p2: tl gf + p1 * .5, p2: tl .5 * p1, -p2: tl p1 * .5, p2: tl p1 * .5 + gf, -p2
67.             CASE "x": lx = px: ly = py + p2: tl p2, p2: lx = px: ly = py + p4: tl p2, -p2
68.             CASE "y": lx = px: ly = py + p2: tl p1, p2: lx = px + p2: ly = py + p2: tl -p2, p3 + gf
69.             CASE "z": lx = px: ly = py + p2: tl p2, 0: tl -p2, p2: tl p2, 0
70.             CASE "A": lx = px: ly = py + p4: tl p1 - gf, -p4: tl 2 * gf, 0: tl p1 - gf, p4: lx = px + p1 - 2 * gf: ly = py + p2: tl p1, 0
71.             CASE "B": ac px + p1, py + p1, 270, 450: ac px + p1, py + p3, 270, 450
72.                 lx = px: ly = py: tl 0, p4: tl p1, 0: lx = px: ly = py + p2: tl p1, 0: lx = px: ly = py: tl p1, 0
73.             CASE "C": ac px + p1, py + p1, 180, 320: ac px + p1, py + p3, 40, 180: lx = px: ly = py + p1: tl 0, p2
74.             CASE "D": ac px + p1, py + p1, 270, 360: ac px + p1, py + p3, 0, 90
75.                 lx = px + p1: ly = py: tl -p1, 0: tl 0, p4: tl p1, 0: lx = px + p2: ly = py + p1: tl 0, p2
76.             CASE "E": lx = px + p2: ly = py: tl -p2, 0: tl 0, p4: tl p2, 0: lx = px: ly = py + p2: tl p1 + 2 * gf, 0
77.             CASE "F": lx = px + p2: ly = py: tl -p2, 0: tl 0, p4: lx = px: ly = py + p2: tl p1 + 2 * gf, 0
78.             CASE "G": ac px + p1, py + p1, 180, 345: ac px + p1, py + p3, 0, 180
79.                 lx = px: ly = py + p1: tl 0, p2: lx = px + p2: ly = py + p4 + gf: tl 0, -p2 - gf: tl -p1, 0
80.             CASE "H": lx = px: ly = py: tl 0, p4: tl 0, -p2: tl p2, 0: tl 0, p2: tl 0, -p4
81.             CASE "I": lx = px + p1 * .5: ly = py: tl p1, 0: lx = px + p1 * .5: ly = py + p4: tl p1, 0: lx = px + p1: ly = py: tl 0, p4
82.             CASE "J": ac px + p1, py + p3, 0, 180: lx = px + p1 * 1.5: ly = py: tl p1 * .5, 0: tl 0, p3
83.             CASE "K": lx = px: ly = py: tl 0, p4: lx = px + p2: ly = py: tl -p2, p2: tl p2, p2
84.             CASE "L": lx = px: ly = py: tl 0, p4: tl p2, 0
85.             CASE "M": lx = px: ly = py + p4: tl 0, -p4: tl p1, p2: tl p1, -p2: tl 0, p4
86.             CASE "N": lx = px: ly = py + p4: tl 0, -p4: tl p2, p4: tl 0, -p4
87.             CASE "O": ac px + p1, py + p1, 180, 360: ac px + p1, py + p3, 0, 180: lx = px: ly = py + p1: tl 0, p2: lx = px + p2: ly = py + p1: tl 0, p2
88.             CASE "P": ac px + p1, py + p1, 270, 450: lx = px + p1: ly = py: tl -p1, 0: tl 0, p4: lx = px: ly = py + p2: tl p1, 0
89.             CASE "Q": ac px + p1, py + p1, 180, 360: ac px + p1, py + p3, 0, 180
90.                 lx = px: ly = py + p1: tl 0, p2: lx = px + p2: ly = py + p1: tl 0, p2: lx = px + p1: ly = py + p2: tl p1 + gf, p2 + gf
91.             CASE "R": ac px + p1, py + p1, 270, 450: lx = px + p1: ly = py: tl -p1, 0: tl 0, p4: lx = px: ly = py + p2: tl p1, 0: tl p1, p2
92.             CASE "S": ac px + p1, py + p1, 90, 360: ac px + p1, py + p3, 270, 540
93.             CASE "T": lx = px: ly = py: tl p2, 0: lx = px + p1: ly = py: tl 0, p4
94.             CASE "U": ac px + p1, py + p3, 0, 180: lx = px: ly = py: tl 0, p3: lx = px + p2: ly = py: tl 0, p3
95.             CASE "V": lx = px: ly = py: tl p1, p4: tl p1, -p4
96.             CASE "W": lx = px - gf: ly = py: tl gf, p4: tl p1, -p2: tl p1, p2: tl gf, -p4
97.             CASE "X": lx = px: ly = py: tl p2, p4: lx = px + p2: ly = py: tl -p2, p4
98.             CASE "Y": lx = px: ly = py: tl p1, p2: tl 0, p2: lx = px + p2: ly = py: tl -p1, p2
99.             CASE "Z": lx = px: ly = py: tl p2, 0: tl -p2, p4: tl p2, 0
100.  
101.             CASE "0": ac px + p1, py + p1, 180, 360: ac px + p1, py + p3, 0, 180: lx = px: ly = py + p1: tl 0, p2: tl p2, -p2: tl 0, p2
102.             CASE "1": lx = px: ly = py + p1: tl p1, -p1: tl 0, p4: tl -p1, 0: tl p2, 0
103.             CASE "2": ac px + p1, py + p1, 180, 360: lx = px + p2: ly = py + p1: tl -p2, p3: tl p2, 0
104.             CASE "3": ac px + p1, py + p1, 180, 450: ac px + p1, py + p3, 270, 540
105.             CASE "4": lx = px + p1: ly = py: tl -p1, p2: tl p2, 0: tl 0, p2: lx = px + p2: ly = py: tl 0, p2
106.             CASE "5": ac px + p1, py + p3, 270, 520: lx = px + p1: tl -p1, 0: tl 0, -p2: tl p2, 0
107.             CASE "6": ac px + p1, py + p3, 0, 360: lx = px: ly = py + p3: tl p1, -p3
108.             CASE "7": lx = px: ly = py: tl p2, 0: tl -p1, p4
109.             CASE "8": ac px + p1, py + p1, 0, 360: ac px + p1, py + p3, 0, 360
110.             CASE "9": ac px + p1, py + p1, 0, 360: lx = px + p2: ly = py + p1: tl -p1, p3
111.             CASE ".": lx = px: ly = py + p4: tl gf, 0: tl 0, -gf: tl -gf, 0: tl 0, gf
112.             CASE "!": lx = px: ly = py + p4: tl gf, 0: tl 0, -gf: tl -gf, 0: tl 0, gf:: lx = px: ly = py: tl 0, p2
113.             CASE ",": lx = px + gf: ly = py + p4: tl -gf, 0: tl 0, -gf: tl gf, 0: tl 0, gf: tl -gf, .5 * p1 + gf
114.             CASE "?": lx = px + p1: ly = py + p4: tl gf, 0: tl 0, -gf: tl -gf, 0: tl 0, gf: ac px + p1, py + p1, 180, 450: lx = px + p1: ly = py + p2: tl 0, p1 - gf
115.         END SELECT
116.     NEXT
117. END SUB
118.  
119. 'ac is for arc, x,y is radius center, das=degree angle start, dae=degree angle end
120. SUB ac (x, y, das, dae)
121.     'note dr, drawing radius has to be global, use COLOR globally sets color
122.     'note thick also made globals by POST sub
123.     'local a,x1,y1,stepper
124.     IF dr THEN
125.         IF INT(thick) = 0 THEN stepper = 1 / (dr * pi) ELSE stepper = (thick / 2) / (dr * pi / 2)
126.         FOR a = das TO dae STEP stepper
127.             x1 = dr * COS(_D2R(a)): y1 = dr * SIN(_D2R(a))
128.             'IF INT(thick) < 1 THEN PSET (x + x1, y + y1) ELSE fcirc x + x1, y + y1, thick, _DEFAULTCOLOR
129.             fcirc x + x1, y + y1, thick, _DEFAULTCOLOR
130.         NEXT
131.     END IF
132. END SUB
133.  
134. 'tl stands for thick line in the LINE STEP x,y format
135. SUB tl (stepx, stepy) 'tl=thickline
136.     'lastx, lasty globals for last drawn position
137.     'thick has to be global
138.     'note thick=0 still draws a line, use COLOR so line is drawn from this global
139.     'local length,dx,dy,i
140.     length = ((stepx) ^ 2 + (stepy) ^ 2) ^ .5
141.     IF length THEN
142.         dx = stepx / (length * 2): dy = stepy / (length * 2)
143.         FOR i = 0 TO length * 2
144.             fcirc lx + dx * i, ly + dy * i, thick, _DEFAULTCOLOR
145.         NEXT
146.     END IF
147.     lx = lx + stepx: ly = ly + stepy
148. END SUB
149.  
150. SUB fcirc (CX AS INTEGER, CY AS INTEGER, R AS INTEGER, C AS _UNSIGNED LONG)
151.     DIM Radius AS INTEGER, RadiusError AS INTEGER
152.     DIM X AS INTEGER, Y AS INTEGER
153.     Radius = ABS(R): RadiusError = -Radius: X = Radius: Y = 0
154.     IF Radius = 0 THEN PSET (CX, CY), C: EXIT SUB
155.     LINE (CX - X, CY)-(CX + X, CY), C, BF
156.     WHILE X > Y
157.         RadiusError = RadiusError + Y * 2 + 1
158.         IF RadiusError >= 0 THEN
159.             IF X <> Y + 1 THEN
160.                 LINE (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
161.                 LINE (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
162.             END IF
163.             X = X - 1
164.             RadiusError = RadiusError - X * 2
165.         END IF
166.         Y = Y + 1
167.         LINE (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
168.         LINE (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
169.     WEND
170. END SUB
171.  

[Petr]

Thank you all for your examples! Now (after lunch) I will deal with a thick-line program, that ends thick line with an arc.