Seeking best ellipse fill function. (For everyone's sake.)

[Pete]

Steve, Yes, I thought of using STATIC that way, too, but no go, because all of those values are subject to change when a new different sized ellipse is made. I mean as a constant, sure w2 will always be a * a, but each time a new ellipse is made, with a new value for a, that equation has to be redone in the sub.

Mark, I'll get rid of the GOTO. Thanks for testing that.

This looks like my finished modifications. I also removed the y = 0 part, as I presume if this gets put into the tool box forum we will talk about renaming the variables to less commonly used names, names unique to the sub.

Code: QB64: [Select]

1. SUB FlatEllipseFill (ox AS INTEGER, oy AS INTEGER, a AS INTEGER, b AS INTEGER, col AS _UNSIGNED LONG)
2. IF a = 0 OR b = 0 THEN EXIT SUB
3. DIM h2 AS _INTEGER64
4. DIM w2 AS _INTEGER64
5. DIM h2w2 AS _INTEGER64
6. DIM yyw2 AS _INTEGER64
7. DIM x AS INTEGER
8. DIM y AS INTEGER
9. w2 = a * a
10. h2 = b * b
11. h2w2 = h2 * w2
12. x = a
13. LINE (ox - a, oy)-(ox + a, oy), col, BF
14. DO
15.     y = y + 1
16.     yyw2 = y * y * w2
17.     x = SQR((h2w2 - yyw2) / h2)
18.     LINE (ox - x, oy + y)-(ox + x, oy + y), col, BF
19.     LINE (ox - x, oy - y)-(ox + x, oy - y), col, BF
20. LOOP UNTIL y = b
21. END SUB

Pete

[STxAxTIC]

I'm blown away that a version of the function that includes SQR is actually performing quickly!

A deep bow for having the balls to try that out again!

As for variable names - scope should save us. As part of good design, we should avoid globals (DIM SHAREDs) whenever possible, and there should be no collision whatsoever between simple variables like "y" causing interference. If it's *other* functions/subs/elements in someone's program that cause a problem with variable names, we shouldn't be obligated to hold their hand on this. Then again, qb64 functions have a bug (I refuse to call this a feature, it's a genuine "bad part") where functions can edit variables passed to them. Just terrible, and I always code to avoid being bitten by this. If we need to muck around with variable names to save people from being confused, then so be it I suppose.

[bplus]

Code: QB64: [Select]

1. _TITLE "STATIC Ellipse Fill versus Steve Circle Fill"
2. DEFINT A-Z
3. SCREEN _NEWIMAGE(1220, 680, 32)
4. _SCREENMOVE 100, 20
5. _DELAY 1
6.  
7. FlatEllipseFill 915, 305, 300, 300, _RGBA32(0, 100, 0, 40)
8. FlatEllipseFill 915, 305, 300, 300, _RGBA32(0, 100, 0, 40)
9. INPUT "Flat EllipseFill overlap test, press enter to continue "; wate$
10. LINE (0, 0)-(600, 20), _RGB32(0, 0, 0), BF
11. start## = TIMER
12. FOR i = 1 TO 10000
13.     FlatEllipseFill 915, 305, 300, 300, _RGBA32(0, 100, 0, 100)
14. NEXT
15. EllipseTime## = TIMER - start##
16. _PRINTSTRING (800, 615), "Time for 10000 Flat Ellipse Fills:" + STR$(EllipseTime##)
17.  
18.  
19. ' ==================================================== compare to the old gold standard
20.  
21. CircleFill 305, 305, 300, _RGBA32(0, 100, 0, 40)
22. CircleFill 305, 305, 300, _RGBA32(0, 100, 0, 40)
23. LOCATE 1, 1: INPUT "CircleFill overlap test, press enter to continue "; wate$
24. LINE (0, 0)-(600, 20), _RGB32(0, 0, 0), BF
25.  
26. start## = TIMER
27. FOR i = 1 TO 10000
28.     CircleFill 305, 305, 300, _RGBA32(0, 100, 0, 100)
29. NEXT
30. OldCircleTime## = TIMER - start##
31. _PRINTSTRING (200, 615), "Time for 10000 Circle Fills:" + STR$(OldCircleTime##)
32.  
33. 'old circle fill
34. SUB CircleFill (CX AS INTEGER, CY AS INTEGER, R AS INTEGER, C AS _UNSIGNED LONG)
35.     DIM Radius AS INTEGER, RadiusError AS INTEGER
36.     DIM X AS INTEGER, Y AS INTEGER
37.  
38.     Radius = ABS(R)
39.     RadiusError = -Radius
40.     X = Radius
41.     Y = 0
42.  
43.     IF Radius = 0 THEN PSET (CX, CY), C: EXIT SUB
44.  
45.     ' Draw the middle span here so we don't draw it twice in the main loop,
46.     ' which would be a problem with blending turned on.
47.     LINE (CX - X, CY)-(CX + X, CY), C, BF
48.  
49.     WHILE X > Y
50.         RadiusError = RadiusError + Y * 2 + 1
51.         IF RadiusError >= 0 THEN
52.             IF X <> Y + 1 THEN
53.                 LINE (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
54.                 LINE (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
55.             END IF
56.             X = X - 1
57.             RadiusError = RadiusError - X * 2
58.         END IF
59.         Y = Y + 1
60.         LINE (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
61.         LINE (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
62.     WEND
63.  
64. END SUB
65.  
66. SUB FlatEllipseFill (ox AS _INTEGER64, oy AS _INTEGER64, a AS _INTEGER64, b AS _INTEGER64, col AS _UNSIGNED LONG)
67.     DIM h2 AS _INTEGER64
68.     DIM w2 AS _INTEGER64
69.     DIM h2w2 AS _INTEGER64
70.     DIM xi AS _INTEGER64
71.     DIM dx AS _INTEGER64
72.     DIM x AS _INTEGER64
73.     DIM y AS _INTEGER64
74.     IF a = 0 OR b = 0 THEN EXIT SUB ' B+ added this
75.     w2 = a * a
76.     h2 = b * b
77.     h2w2 = h2 * w2
78.     xi = a
79.     dx = 0
80.     LINE (ox - a, oy)-(ox + a, oy), col, BF
81.     ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''' y = 0 ' B+ added this to eliminate FOR loop
82.     WHILE y < b 'b+ no FOR loop
83.         y = y + 1
84.         x = xi - dx + 2
85.         WHILE x >= 1
86.             x = x - 1
87.             IF x * x * h2 + y * y * w2 <= h2w2 THEN EXIT WHILE
88.         WEND
89.         dx = xi - x
90.         xi = x
91.         LINE (ox - xi, oy + y)-(ox + xi, oy + y), col, BF
92.         LINE (ox - xi, oy - y)-(ox + xi, oy - y), col, BF
93.     WEND
94. END SUB
95.  
96.  

I commented out one line in above code and now it is consistently matching or beating the Gold Standard Circle fill AND matching Circle fill's lowest time.

Here is the code for test I am using:

Code: QB64: [Select]

1. _TITLE "STATIC Ellipse Fill versus Steve Circle Fill"
2. '2019-02-12 add Pete's variation
3.  
4.  
5. SCREEN _NEWIMAGE(1220, 680, 32)
6. _SCREENMOVE 100, 20
7. _DELAY 1
8.  
9. FlatEllipseFill 915, 305, 300, 300, _RGBA32(0, 100, 0, 40)
10. FlatEllipseFill 915, 305, 300, 300, _RGBA32(0, 100, 0, 40)
11. INPUT "Flat EllipseFill overlap test, press enter to continue "; wate$
12. LINE (0, 0)-(600, 20), _RGB32(0, 0, 0), BF
13. start## = TIMER
14. FOR i = 1 TO 10000
15.     FlatEllipseFill 915, 305, 300, 300, _RGBA32(0, 100, 0, 100)
16. NEXT
17. EllipseTime## = TIMER - start##
18. _PRINTSTRING (800, 615), "Time for 10000 Flat Ellipse Fills:" + STR$(EllipseTime##)
19.  
20.  
21. ' ==================================================== compare to the old gold standard
22.  
23. CircleFill 305, 305, 300, _RGBA32(0, 100, 0, 40)
24. CircleFill 305, 305, 300, _RGBA32(0, 100, 0, 40)
25. LOCATE 1, 1: INPUT "CircleFill overlap test, press enter to continue "; wate$
26. LINE (0, 0)-(600, 20), _RGB32(0, 0, 0), BF
27.  
28. start## = TIMER
29. FOR i = 1 TO 10000
30.     CircleFill 305, 305, 300, _RGBA32(0, 100, 0, 100)
31. NEXT
32. OldCircleTime## = TIMER - start##
33. _PRINTSTRING (200, 615), "Time for 10000 Circle Fills:" + STR$(OldCircleTime##)
34.  
35. 'old circle fill
36. SUB CircleFill (CX AS INTEGER, CY AS INTEGER, R AS INTEGER, C AS _UNSIGNED LONG)
37.     DIM Radius AS INTEGER, RadiusError AS INTEGER
38.     DIM X AS INTEGER, Y AS INTEGER
39.  
40.     Radius = ABS(R)
41.     RadiusError = -Radius
42.     X = Radius
43.     Y = 0
44.  
45.     IF Radius = 0 THEN PSET (CX, CY), C: EXIT SUB
46.  
47.     ' Draw the middle span here so we don't draw it twice in the main loop,
48.     ' which would be a problem with blending turned on.
49.     LINE (CX - X, CY)-(CX + X, CY), C, BF
50.  
51.     WHILE X > Y
52.         RadiusError = RadiusError + Y * 2 + 1
53.         IF RadiusError >= 0 THEN
54.             IF X <> Y + 1 THEN
55.                 LINE (CX - Y, CY - X)-(CX + Y, CY - X), C, BF
56.                 LINE (CX - Y, CY + X)-(CX + Y, CY + X), C, BF
57.             END IF
58.             X = X - 1
59.             RadiusError = RadiusError - X * 2
60.         END IF
61.         Y = Y + 1
62.         LINE (CX - X, CY - Y)-(CX + X, CY - Y), C, BF
63.         LINE (CX - X, CY + Y)-(CX + X, CY + Y), C, BF
64.     WEND
65.  
66. END SUB
67.  
68. SUB FlatEllipseFill (ox AS _INTEGER64, oy AS _INTEGER64, a AS _INTEGER64, b AS _INTEGER64, col AS _UNSIGNED LONG)
69.     DIM h2 AS _INTEGER64
70.     DIM w2 AS _INTEGER64
71.     DIM h2w2 AS _INTEGER64
72.     DIM xi AS _INTEGER64
73.     DIM dx AS _INTEGER64
74.     DIM x AS _INTEGER64
75.     DIM y AS _INTEGER64
76.     IF a = 0 OR b = 0 THEN EXIT SUB ' B+ added this
77.     w2 = a * a
78.     h2 = b * b
79.     h2w2 = h2 * w2
80.     xi = a
81.     dx = 0
82.     LINE (ox - a, oy)-(ox + a, oy), col, BF
83.     'y = 0 ' B+ added this to eliminate FOR loop
84.     WHILE y < b 'b+ no FOR loop
85.         y = y + 1
86.         x = xi - dx + 2
87.         WHILE x >= 1
88.             x = x - 1
89.             IF x * x * h2 + y * y * w2 <= h2w2 THEN EXIT WHILE
90.         WEND
91.         dx = xi - x
92.         xi = x
93.         LINE (ox - xi, oy + y)-(ox + xi, oy + y), col, BF
94.         LINE (ox - xi, oy - y)-(ox + xi, oy - y), col, BF
95.     WEND
96. END SUB
97.  
98. 'pete's variation 2019-02-12
99. SUB FlatEllipseFill1 (ox AS INTEGER, oy AS INTEGER, a AS INTEGER, b AS INTEGER, col AS _UNSIGNED LONG)
100.     IF a = 0 OR b = 0 THEN EXIT SUB
101.     DIM h2 AS _INTEGER64
102.     DIM w2 AS _INTEGER64
103.     DIM h2w2 AS _INTEGER64
104.     DIM yyw2 AS _INTEGER64
105.     DIM xi AS INTEGER
106.     DIM dx AS INTEGER
107.     DIM x AS INTEGER
108.     DIM y AS INTEGER
109.     w2 = a * a
110.     h2 = b * b
111.     h2w2 = h2 * w2
112.     xi = a
113.     dx = 0
114.     y = 0
115.     LINE (ox - a, oy)-(ox + a, oy), col, BF
116.     DO
117.         y = y + 1
118.         yyw2 = y * y * w2
119.         x = xi - dx + 1
120.         DO
121.             IF x * x * h2 + yyw2 <= h2w2 THEN EXIT DO
122.             x = x - 1
123.         LOOP
124.         dx = xi - x
125.         xi = x
126.         LINE (ox - xi, oy + y)-(ox + xi, oy + y), col, BF
127.         LINE (ox - xi, oy - y)-(ox + xi, oy - y), col, BF
128.     LOOP UNTIL y = b
129. END SUB
130.  
131. 'vince variation on Steve  2019-02-12
132. SUB FlatEllipseFill2 (x0, y0, rx, ry, c AS _UNSIGNED LONG)
133.     a = 2 * rx * rx
134.     b = 2 * ry * ry
135.  
136.  
137.     x = 0
138.     y = ry
139.     dx = ry * ry
140.     dy = rx * rx * (1 - 2 * ry)
141.     e = 0
142.     sx = 0
143.     sy = a * ry
144.  
145.     DO WHILE sx <= sy
146.         LINE (x0 - x, y0 + y)-STEP(2 * x, 0), c, BF
147.         LINE (x0 - x, y0 - y)-STEP(2 * x, 0), c, BF
148.  
149.         x = x + 1
150.         sx = sx + b
151.         e = e + dx
152.         dx = dx + b
153.  
154.         IF 2 * e + dy > 0 THEN
155.             y = y - 1
156.             sy = sy - a
157.             e = e + dy
158.             dy = dy + a
159.         END IF
160.     LOOP
161.  
162.     x1 = x0 - x
163.     x2 = x0 + x
164.     y1 = y0 - y
165.  
166.     x = rx
167.     y = 0
168.     dx = ry * ry * (1 - 2 * rx)
169.     dy = rx * rx
170.     e = 0
171.     sx = b * rx
172.     sy = 0
173.  
174.     x3 = x0 - x
175.  
176.     DO WHILE sx >= sy
177.         LINE (x0 - x, y0 + y)-(x1, y0 + y), c, BF
178.         LINE (x0 - x, y0 - y)-(x1, y0 - y), c, BF
179.         LINE (x0 + x, y0 + y)-(x2, y0 + y), c, BF
180.         LINE (x0 + x, y0 - y)-(x2, y0 - y), c, BF
181.  
182.         y = y + 1
183.         sy = sy + a
184.         e = e + dy
185.         dy = dy + a
186.  
187.         IF 2 * e + dx > 0 THEN
188.             x = x - 1
189.             sx = sx - b
190.             e = e + dx
191.             dx = dx + b
192.         END IF
193.     LOOP
194.  
195.     LINE (x1, y1)-(x2, y0 + y), c, BF
196.  
197. END SUB
198.  
199.  
200. 'pete's reversion back to SQR   WTH? it's fine time wise!
201. 'pete's final? 2019-02-12  variation
202. SUB FlatEllipseFill3 (ox AS INTEGER, oy AS INTEGER, a AS INTEGER, b AS INTEGER, col AS _UNSIGNED LONG)
203.     IF a = 0 OR b = 0 THEN EXIT SUB
204.     DIM h2 AS _INTEGER64
205.     DIM w2 AS _INTEGER64
206.     DIM h2w2 AS _INTEGER64
207.     DIM yyw2 AS _INTEGER64
208.     DIM x AS INTEGER
209.     DIM y AS INTEGER
210.     w2 = a * a
211.     h2 = b * b
212.     h2w2 = h2 * w2
213.     x = a
214.     LINE (ox - a, oy)-(ox + a, oy), col, BF
215.     DO
216.         y = y + 1
217.         yyw2 = y * y * w2
218.         x = SQR((h2w2 - yyw2) / h2)
219.         LINE (ox - x, oy + y)-(ox + x, oy + y), col, BF
220.         LINE (ox - x, oy - y)-(ox + x, oy - y), col, BF
221.     LOOP UNTIL y = b
222. END SUB
223.  
224. 'bplus reversion back to SQR  nope over twice the time!
225. SUB FlatEllipseFill4 (CX AS LONG, CY AS LONG, xRadius AS LONG, yRadius AS LONG, c AS _UNSIGNED LONG)
226.     DIM scale AS SINGLE, x AS LONG, y AS LONG, xr2 AS LONG
227.     IF xRadius = 0 OR yRadius = 0 THEN EXIT SUB '<<<<<<<<<<<<< really do need to skip out with 0
228.     scale = yRadius / xRadius
229.     LINE (CX, CY - yRadius)-(CX, CY + yRadius), c, BF
230.     xr2 = xRadius * xRadius
231.     FOR x = 1 TO xRadius
232.         y = scale * SQR(xr2 - x * x)
233.         LINE (CX + x, CY - y)-(CX + x, CY + y), c, BF
234.         LINE (CX - x, CY - y)-(CX - x, CY + y), c, BF
235.     NEXT
236. END SUB
237.  
238.  
239.  

HA! I see a Y = 0 in circle fill code, maybe we could apply what we have learned to optimize it more. Radius = ABS(R) ???

[Pete]

Mark, I tried your test program against my ellipse fill, #3 in your list, and got a better speed test than circle fill...

[bplus]

Dang! what's your system, my tests are running well under 17 secs.

I will try this in 32 bit QB64.

BTW, be sure to run tests with Browser OFF.

[Pete]

LOL. My kid has the gaming computers. I'm on a $200 laptop that can't keep up with my typing most of the time! :D

OK 3 more tests with browser off. 225 total seconds for 3 runs for mine, 227 total seconds for Circle Fill. Basically a tie of 75 seconds each. Funny that both were slower with the browser off, but with so many things in Windows running in the background, who knows?

Pete

[bplus]

OK I wrote timings down. This ran allot closer than I expected.

My system is Windows 10 64 bit laptop, intel core i5

Running tests on QB64, 32 bit version
circle Fill      Pete's Fill
14.3945         14.5039
14.3945         14.3984
14.2891         14.3945
14.2851         14.3984
14.3945         14.4039

circle Fill    STATIC Fill mod B+
14.2305         14.4531
14.2891         14.4492
14.3945         14.4531
14.1758         14.3984
14.2305         14.3984


Running tests on QB64, 64 bit version
circle Fill      Pete's Fill
16.8672         17.0313
16.9258         16.8672
16.8125         16.9219
16.8125         16.8125
16.8711         17.0352

circle Fill      STATIC Fill mod B+
16.9219         16.9766
16.9258         16.9766
16.8164         16.8711
16.8125         16.8672
16.8125         16.8125      

[Pete]

No real speed variance with SQR, pretty cool! Mark, if you wondered why your try at SQR was twice as slow, it was because if used SQR in a loop. Mine just uses it it once per every two lines.

The double draw method Steve submitted is about 20% slower, and the changes Vince made slowed it down about 20% more. Oops. Feel free to challenge that, anyone.

I don't think I want to bother making a hash table form here, but that's where I'd go next to remove SQR from my modification. If we can establish that there is a limit for how wide an ellipse can be, then that's certainly possible. I'm only presuming it would be faster though, I don't know for certain.

I favor the SQR one I came up with, just because it is so simplistic. It would also piss off the C people who posted the other one Bill found, with the inner x loop. Pissing off C people with BASIC just makes me happy!  Oh, if you guys think I'm the only one, check this out, it's hilarious... https://social.microsoft.com/Forums/en-US/ed0e97aa-ea86-49dd-b5b0-01fd41c82cf2/using-com-port-with-qb64

Although... who knows, maybe someone will post some other method that eats our collective lunch. Stay tuned!

Pete

[STxAxTIC]

Weird, I wasn't aware that I found my function somewhere, because I remember using a whiteboard and the equation of the ellipse to derive my most recent submission. Once a function is simple enough though, it becomes an irreducible mousetrap, and sortof a universal truth. Translation: I bet other smart people derived the same thing, it just *has* to be true. We're too late in computing history to have actually discovered something here.

[Pete]

https://stackoverflow.com/questions/10322341/simple-algorithm-for-drawing-filled-ellipse-in-c-c

That's why I like to use unique variables, like pete!

Well kudos for grinding it out on your own! I was about half way there, when you posted. After that, I looked around at some stuff on the net and determined I was just heading in the same direction, except that SQR thing was bugging me, so I went on with that after making some tests to see if Steve's find was out of the running. I couldn't see how working on the boob effect would be productive, if the routine ended up being slower, which it is. So on to this single draw system, which looks like the one we will wind up with, unless someone

This is fun stuff, and again kudos. What we need now is either a new method or a way to speed up that SQR calculation in my modification. I wonder how much the internal works grinds out the SQR calculations? It only needs to be rounded as an integer. I mean we could use a square root algorithm to do that, since a hash table is a bit of overkill. It's still a bit tricky to calculate square roots, and requires loops to approximate, even with the "trick" division.

Pete

[STxAxTIC]

Say, there's a mother load of info!

The one with the ascii *-characters in the curved shape is a dead ringer for my method. They even use the same Leibnitz "dx" notation for the tiny increments because this is the same exact setup used to find the area of the ellipse. Calculus is a language after all, you say certain things the same way. Staring at it harder: yikes, do they not have a LINE statement?

I see someone even attempted to do the tilted case but chickened out before arriving at any code. I know exactly why this is, and is why I was so stubborn about solving that issue this week too. The reason? A tilted ellipse does not permit (that I could derive) a strict XY-equation for its position - there's always an extra parameter. After conceding to this, I unleashed the tilted function that takes the punch and uses an extra variable.

At this exact point, I'm not even sure which is the fastest anymore. As the dust settles on this, can anyone (namely Pete or bplus) paste the newest and the greatest below this? Are we going to need a separate function for just circles?

[Pete]

Bill: I don't think we need a separate circle routine. As long as the height and the width are the same... BAM, circle. Every bit as fast, too.

The two fastest routines are yours, as modified with different variable types and DO/LOOP replacing FOR/NEXT, and yours with my modifications to substitute SQR for the inner loop. The SQR one is just a tad faster in my tests.

Guys: Do you know in th e last loop x is always zero? That means this routine puts down a horizontal line and dots the top and bottom of any ellipse. I hope that's OK with everyone. Oh, to see what I'm yacking about, here are the numbers...

Code: QB64: [Select]

1. FOR a = 1 TO 10
2.     FOR b = 1 TO 10
3.         CALL p(a, b)
4.     NEXT
5. NEXT
6.  
7. SUB p (a, b)
8. DIM h2 AS _INTEGER64
9. DIM w2 AS _INTEGER64
10. DIM h2w2 AS _INTEGER64
11. DIM yyw2 AS _INTEGER64
12. DIM x AS INTEGER
13. DIM y AS INTEGER
14. w2 = a * a
15. h2 = b * b
16. h2w2 = h2 * w2
17. DO
18.     y = y + 1
19.     yyw2 = y * y * w2
20.     x = SQR((h2w2 - yyw2) / h2)
21.     PRINT y; a; b; x; (h2w2 - yyw2) / h2
22.     SLEEP
23. LOOP UNTIL y = b
24. PRINT "============================="
25. END SUB
26.  

I got rid of one more line and a variable in my SQR code. I'll repost it here. What I want to do now is compare it with ellipses of varying size. I also want to make sure I'm getting the same x values as the one that avoids SQR with an inner loop.

Latest SQR code:

Code: QB64: [Select]

1. SUB FlatEllipseFill5 (ox AS INTEGER, oy AS INTEGER, a AS INTEGER, b AS INTEGER, col AS _UNSIGNED LONG)
2. IF a = 0 OR b = 0 THEN EXIT SUB
3. DIM h2 AS _INTEGER64
4. DIM w2 AS _INTEGER64
5. DIM h2w2 AS _INTEGER64
6. DIM x AS INTEGER
7. DIM y AS INTEGER
8. w2 = a * a
9. h2 = b * b
10. h2w2 = h2 * w2
11. LINE (ox - a, oy)-(ox + a, oy), col, BF
12. DO WHILE y < b
13.     y = y + 1
14.     x = SQR((h2w2 - y * y * w2) / h2)
15.     LINE (ox - x, oy + y)-(ox + x, oy + y), col, BF
16.     LINE (ox - x, oy - y)-(ox + x, oy - y), col, BF
17. LOOP
18. END SUB
19.  

You have to admit, it's pretty freakin' optimized.

Edit: removed unnecessary x = a statement. Thanks Mark!

Pete

[bplus]

You don't need x = a either but won't count for much.

[Pete]

Wow, thanks. I forgot that the single line uses a, not x. Woohoo, another one bites the dust. I'm putting together a test now just to make sure the SQR one does the same size lines as the loop one. I'll let you guys know the results soon.

Pete

[SMcNeill]

Change the division to integer division.  It shaves off about a second on my test runs and still doesn't generate any duplicate lines from my preliminary testing:

Code: QB64: [Select]

1. SUB FlatEllipseFill6 (ox AS INTEGER, oy AS INTEGER, a AS INTEGER, b AS INTEGER, col AS _UNSIGNED LONG)
2.     IF a = 0 OR b = 0 THEN EXIT SUB
3.     DIM h2 AS _INTEGER64
4.     DIM w2 AS _INTEGER64
5.     DIM h2w2 AS _INTEGER64
6.     DIM x AS INTEGER
7.     DIM y AS INTEGER
8.     w2 = a * a
9.     h2 = b * b
10.     h2w2 = h2 * w2
11.     LINE (ox - a, oy)-(ox + a, oy), col, BF
12.     DO WHILE y < b
13.         y = y + 1
14.         x = SQR((h2w2 - y * y * w2) \ h2) ' <<<< HERE
15.         LINE (ox - x, oy + y)-(ox + x, oy + y), col, BF
16.         LINE (ox - x, oy - y)-(ox + x, oy - y), col, BF
17.     LOOP
18. END SUB