Space Filling with Polygons

[Ashish]

Hey everyone!

This program fills the space with a polygon (triangles, squares, etc) in such a way that any two polygon must not overlap/collide.
The polygon size gradually reduces and it try to fill as much space as possible.
The color of polygon also changes gradually, resulting in a beautiful pattern. :)

I took some help for concepts behind this from here - http://paulbourke.net/fractals/randomtile/

Run the program & Enjoy.

Instruction :  Enter the number of sides of the polygon you want to fill with (of course, it must greater than 2). Higher values will result
in slow speed. :)

Code: QB64: [Select]

1. 'Space Filling with Polygon
2. 'By Ashish
3.  
4. RANDOMIZE TIMER
5. TYPE XY
6.     x AS SINGLE
7.     y AS SINGLE
8. END TYPE
9.  
10. _TITLE "Space Filling with Polygon"
11. SCREEN _NEWIMAGE(800, 600, 32)
12.  
13. INPUT "Enter the number of side for a polygon (must be greater than 2) : ", x%
14. IF x% < 3 THEN PRINT "It must be greate than 2!, taking default value of 3. Hit ENTER.": SLEEP: x% = 3
15. polySides = x%
16. DIM tempPoly1(polySides - 1) AS XY, tempPoly2(polySides - 1) AS XY
17. REDIM polys(polySides - 1) AS XY
18.  
19.  
20. init = 0
21. poly_index = 0
22. i = 1
23. c = 1.1
24. failed = 0
25. CLS
26. DO
27.     IF init = 0 THEN
28.         r = p5random(150, 200)
29.         ox = p5random(r, _WIDTH - r)
30.         oy = p5random(r, _HEIGHT - r)
31.         offAng = p5random(-_PI, _PI)
32.         FOR j = 0 TO polySides - 1
33.             polys(j).x = ox + COS(j * (_PI(2 / polySides)) + offAng) * r
34.             polys(j).y = oy + SIN(j * (_PI(2 / polySides)) + offAng) * r
35.         NEXT
36.         clr~& = midColor(_RGB(255, 255, 0), _RGB(255, 100, 0), map(r, 200, 3, 0, 1))
37.         drawPoly polys(), clr~&
38.         init = 1
39.         poly_index = poly_index + polySides
40.     ELSE
41.         r = 200 / (c ^ i)
42.         ox = p5random(r, _WIDTH - r)
43.         oy = p5random(r, _HEIGHT - r)
44.         collided = 0
45.         offAng = p5random(-_PI, _PI)
46.         FOR j = 0 TO polySides - 1
47.             tempPoly1(j).x = ox + COS(j * (_PI(2 / polySides)) + offAng) * r
48.             tempPoly1(j).y = oy + SIN(j * (_PI(2 / polySides)) + offAng) * r
49.         NEXT
50.         FOR j = 0 TO UBOUND(polys) STEP polySides
51.             FOR k = j TO j + polySides - 1
52.                 tempPoly2(k - j) = polys(k)
53.             NEXT
54.             IF polyCollide(tempPoly1(), tempPoly2()) THEN collided = -1: EXIT FOR
55.         NEXT
56.         IF NOT collided THEN
57.             ' _echo "yes"
58.             REDIM _PRESERVE polys(UBOUND(polys) + polySides) AS XY
59.             FOR j = poly_index TO poly_index + polySides - 1
60.                 polys(j) = tempPoly1(j - poly_index)
61.             NEXT
62.             clr~& = midColor(_RGB(255, 255, 0), _RGB(255, 100, 0), map(r, 200, 3, 0, 1))
63.             drawPoly tempPoly1(), clr~&
64.             poly_index = poly_index + polySides
65.         ELSE
66.             failed = failed + 1
67.             IF failed > (i * 60) THEN i = i + 1: failed = 0
68.         END IF
69.     END IF
70. LOOP UNTIL r < 3
71.  
72. FUNCTION midColor~& (clr1 AS _UNSIGNED LONG, clr2 AS _UNSIGNED LONG, v)
73.     midColor~& = _RGB(map(v, 0, 1, _RED(clr1), _RED(clr2)), map(v, 0, 1, _GREEN(clr1), _GREEN(clr2)), map(v, 0, 1, _BLUE(clr1), _BLUE(clr2)))
74. END FUNCTION
75.  
76. SUB drawPoly (vert() AS XY, clr AS _UNSIGNED LONG)
77.     n = UBOUND(vert)
78.     DIM cx, cy
79.     FOR i = 0 TO n
80.         LINE (vert(i).x, vert(i).y)-(vert((i + 1) MOD (n + 1)).x, vert((i + 1) MOD (n + 1)).y), clr
81.         cx = cx + vert(i).x: cy = cy + vert(i).y
82.     NEXT
83.     cx = cx / (n + 1): cy = cy / (n + 1)
84.     PAINT (cx, cy), clr, clr
85. END SUB
86.  
87.  
88. FUNCTION polyCollide (vert1() AS XY, vert2() AS XY)
89.     DIM n1 AS INTEGER, n2 AS INTEGER
90.     n1 = UBOUND(vert1): n2 = UBOUND(vert2)
91.     'checking if any point of polygon 1 inside polygon 2
92.     FOR i = 0 TO n1
93.         IF pointInsidePoly(vert1(i), vert2()) THEN polyCollide = -1: EXIT FUNCTION
94.     NEXT
95.     'checking if any point of polygon 2 inside polygon 1
96.     FOR i = 0 TO n2
97.         IF pointInsidePoly(vert2(i), vert1()) THEN polyCollide = -1: EXIT FUNCTION
98.     NEXT
99.     ' checking the edge intersection
100.     FOR i = 0 TO n1
101.         FOR j = 0 TO n2
102.             IF lineIntersect(vert1(i).x, vert1(i).y, vert1((i + 1) MOD (n1 + 1)).x, vert1((i + 1) MOD (n1 + 1)).y, vert2(j).x, vert2(j).y, vert2((j + 1) MOD (n2 + 1)).x, vert2((j + 1) MOD (n2 + 1)).y) THEN polyCollide = -1: EXIT FUNCTION
103.         NEXT
104.     NEXT
105. END FUNCTION
106.  
107. 'from paulbourke.net
108. FUNCTION pointInsidePoly (p AS XY, polyVert() AS XY)
109.     DIM ax1, ax2, ay1, ay2
110.     n = UBOUND(polyVert)
111.     FOR i = 0 TO n
112.         ax1 = polyVert(i).x - p.x
113.         ay1 = polyVert(i).y - p.y
114.         ax2 = polyVert((i + 1) MOD (n + 1)).x - p.x
115.         ay2 = polyVert((i + 1) MOD (n + 1)).y - p.y
116.         ang = ang + angle2D(ax1, ay1, ax2, ay2)
117.     NEXT
118.     pointInsidePoly = (ABS(ang) >= _PI)
119. END FUNCTION
120.  
121. 'from paulbourke.net
122. FUNCTION angle2D (x1, y1, x2, y2)
123.     DIM theta1, theta2, ftheta
124.     theta1 = _ATAN2(y1, x1)
125.     theta2 = _ATAN2(y2, x2)
126.     ftheta = theta1 - theta2
127.     WHILE ftheta > _PI: ftheta = ftheta - _PI(2): WEND
128.     WHILE ftheta < -_PI: ftheta = ftheta + _PI(2): WEND
129.     angle2D = ftheta
130. END FUNCTION
131.  
132. FUNCTION lineIntersect (__x1, __y1, __x2, __y2, __x3, __y3, __x4, __y4)
133.     DIM x1 AS INTEGER, y1 AS INTEGER, x2 AS INTEGER, y2 AS INTEGER, x3 AS INTEGER, y3 AS INTEGER, x4 AS INTEGER, y4 AS INTEGER
134.     DIM a1, b1, c1, a2, b2, c2
135.     DIM a1b2_minus_a2b1, b1c2_minus_b2c1, a2c1_minus_a1c2
136.     DIM inter_x AS INTEGER, inter_y AS INTEGER
137.  
138.     x1 = __x1: x2 = __x2: x3 = __x3: x4 = __x4
139.     y1 = __y1: y2 = __y2: y3 = __y3: y4 = __y4
140.    
141.     IF x1 > x2 THEN SWAP x1, x2
142.     IF x3 > x4 THEN SWAP x3, x4
143.     IF y1 > y2 THEN SWAP y1, y2
144.     IF y3 > y4 THEN SWAP y3, y4
145.    
146.     a1 = __y2 - __y1: b1 = -(__x2 - __x1): c1 = (__x2 * __y1) - (__x1 * __y2)
147.     a2 = __y4 - __y3: b2 = -(__x4 - __x3): c2 = (__x4 * __y3) - (__x3 * __y4)
148.  
149.     'check if lines are perfectly vertical or horizontal
150.     IF a1 = 0 AND a2 = 0 THEN lineIntersect = (__y1 = __y3): _DEST 0: EXIT FUNCTION
151.     IF b1 = 0 AND b2 = 0 THEN lineIntersect = (__x1 = __x3): _DEST 0: EXIT FUNCTION
152.     IF a2 = 0 OR b2 = 0 THEN GOTO skip_component_ratio
153.    
154.     'check if the whole line segments coincide with each other.
155.     IF c2 <> 0 THEN
156.         IF (a1 / a2) = (b1 / b2) AND (b1 / b2) = (c1 / c2) THEN
157.             lineIntersect = -1: EXIT FUNCTION
158.         END IF
159.     END IF
160.     skip_component_ratio:
161.     'check if the line segments have same slope.
162.     IF a1 * b2 = a2 * b1 THEN
163.         lineIntersect = (c1 = c2) 'special case, when they still coincide (as c1=c2)
164.         EXIT FUNCTION
165.     END IF
166.     'check if the line do intersect between the segments.
167.     a1b2_minus_a2b1 = (a1 * b2) - (a2 * b1): b1c2_minus_b2c1 = (b1 * c2) - (b2 * c1): a2c1_minus_a1c2 = (a2 * c1) - (a1 * c2)
168.     inter_x = b1c2_minus_b2c1 / a1b2_minus_a2b1: inter_y = a2c1_minus_a1c2 / a1b2_minus_a2b1
169.    
170.     lineIntersect = ((inter_x >= x1 AND inter_x <= x2 AND inter_y >= y1 AND inter_y <= y2)) and ((inter_x >= x3 AND inter_x <= x4 AND inter_y >= y3 AND inter_y <= y4))
171. END FUNCTION
172.  
173. 'taken from p5js.bas
174. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
175.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
176. END FUNCTION
177.  
178. FUNCTION p5random! (mn!, mx!)
179.     IF mn! > mx! THEN
180.         SWAP mn!, mx!
181.     END IF
182.     p5random! = RND * (mx! - mn!) + mn!
183. END FUNCTION
184.  

Program output for the input value of 3, i.e. for a triangle.

[Dav]

Nice one, Ashish!

- Dav

[FellippeHeitor]

Doritos!

[TerryRitchie]

Nacho cheese, please.

[bplus]

Nice one!

I remember doing circle fills with images awhile back. That was a Coding Challenge or Coding Train session with that crazy YouTube guy, Daniel Shiffman.

[TempodiBasic]

Hi Ashish
what fine colors in this geometric application!
Cool!

[Ashish]

@Dav @FellippeHeitor  @TerryRitchie @bplus @TempodiBasic
Thank you for trying this!

Ok, here is a new MOD. Now, it draws the polygon with shaded effect. To get variation, you can change value of polygonSides.

Code: QB64: [Select]

1. 'Space Filling with Polygon
2. 'By Ashish
3.  
4. RANDOMIZE TIMER
5. TYPE gl_vertex_type
6.     'position of vertex
7.     x AS SINGLE
8.     y AS SINGLE
9.     'center
10.     cx AS SINGLE
11.     cy AS SINGLE
12.     'color of the vertex to be used
13.     r AS SINGLE
14.     g AS SINGLE
15.     b AS SINGLE
16. END TYPE
17.  
18. _TITLE "Space Filling with Polygon [MOD:SHADED SHAPE]"
19. SCREEN _NEWIMAGE(800, 600, 32)
20.  
21. DIM SHARED init, polySides
22. 'warning : polySides must always be greater than 2
23. polySides = 3 'change its value to get different polygons
24. DIM tempPoly1(polySides - 1) AS gl_vertex_type, tempPoly2(polySides - 1) AS gl_vertex_type
25. REDIM SHARED polys(polySides - 1) AS gl_vertex_type
26.  
27.  
28. init = 0
29. poly_index = 0
30. i = 1
31. c = 1.05
32. failed = 0
33. CLS
34. DO
35.     IF init = 0 THEN
36.         r = p5random(150, 200)
37.         ox = p5random(r, _WIDTH - r)
38.         oy = p5random(r, _HEIGHT - r)
39.         offAng = p5random(-_PI, _PI)
40.         clr~& = midColor(_RGB(255, 255, 0), _RGB(255, 100, 0), map(r, 200, 3, 0, 1))
41.         red = map(_RED(clr~&), 0, 255, 0, 1): green = map(_GREEN(clr~&), 0, 255, 0, 1): blue = map(_BLUE(clr~&), 0, 255, 0, 1)
42.         FOR j = 0 TO polySides - 1
43.             polys(j).x = ox + COS(j * (_PI(2 / polySides)) + offAng) * r
44.             polys(j).y = oy + SIN(j * (_PI(2 / polySides)) + offAng) * r
45.             polys(j).cx = ox: polys(j).cy = oy
46.             polys(j).r = red: polys(j).g = green: polys(j).b = blue
47.         NEXT
48.         init = -1
49.         poly_index = poly_index + polySides
50.     ELSE
51.         r = 200 / (c ^ i)
52.         ox = p5random(r, _WIDTH - r)
53.         oy = p5random(r, _HEIGHT - r)
54.         collided = 0
55.         offAng = p5random(-_PI, _PI)
56.         FOR j = 0 TO polySides - 1
57.             tempPoly1(j).x = ox + COS(j * (_PI(2 / polySides)) + offAng) * r
58.             tempPoly1(j).y = oy + SIN(j * (_PI(2 / polySides)) + offAng) * r
59.         NEXT
60.         FOR j = 0 TO UBOUND(polys) STEP polySides
61.             FOR k = j TO j + polySides - 1
62.                 tempPoly2(k - j) = polys(k)
63.             NEXT
64.             IF polyCollide(tempPoly1(), tempPoly2()) THEN collided = -1: EXIT FOR
65.         NEXT
66.         IF NOT collided THEN
67.             REDIM _PRESERVE polys(UBOUND(polys) + polySides) AS gl_vertex_type
68.             clr~& = midColor(_RGB(255, 255, 0), _RGB(255, 100, 0), map(r, 200, 3, 0, 1))
69.             red = map(_RED(clr~&), 0, 255, 0, 1): green = map(_GREEN(clr~&), 0, 255, 0, 1): blue = map(_BLUE(clr~&), 0, 255, 0, 1)
70.             FOR j = poly_index TO poly_index + polySides - 1
71.                 polys(j) = tempPoly1(j - poly_index)
72.                 polys(j).cx = ox: polys(j).cy = oy
73.                 polys(j).r = red: polys(j).g = green: polys(j).b = blue
74.             NEXT
75.             poly_index = poly_index + polySides
76.         ELSE
77.             failed = failed + 1
78.             IF failed > (i * 60) THEN i = i + 1: failed = 0
79.         END IF
80.     END IF
81. LOOP UNTIL r < 3
82. SLEEP
83.  
84.  
85. SUB _GL ()
86.     IF NOT init THEN EXIT SUB
87.     _glMatrixMode _GL_MODELVIEW
88.  
89.     'set the gl screen so that it can work normal screen coordinates
90.     _glTranslatef -1, 1, 0
91.     _glScalef 1 / 400, -1 / 300, 1
92.      
93.     'to get shaded effect, we will divide polygon into smaller triangles from center of polygon in a cyclic way.
94.     FOR n = 0 TO UBOUND(polys) STEP polySides
95.         _glPushMatrix
96.         _glTranslatef polys(n).cx, polys(n).cy, 0
97.         _glBegin _GL_TRIANGLES
98.         FOR j = n TO n + polySides - 1
99.             _glColor3f 0, 0, 0
100.             _glVertex2i 0, 0
101.             _glColor3f polys(n).r, polys(n).g, polys(n).b
102.             _glVertex2i polys(j).x - polys(n).cx, polys(j).y - polys(j).cy
103.             IF (j + 1) MOD (n + polySides) = 0 THEN _glVertex2i polys(n).x - polys(n).cx, polys(n).y - polys(j).cy ELSE _glVertex2i polys(j + 1).x - polys(n).cx, polys(j + 1).y - polys(j).cy
104.         NEXT
105.         _glEnd
106.         _glPopMatrix
107.     NEXT
108. END SUB
109.  
110. FUNCTION midColor~& (clr1 AS _UNSIGNED LONG, clr2 AS _UNSIGNED LONG, v)
111.     midColor~& = _RGB(map(v, 0, 1, _RED(clr1), _RED(clr2)), map(v, 0, 1, _GREEN(clr1), _GREEN(clr2)), map(v, 0, 1, _BLUE(clr1), _BLUE(clr2)))
112. END FUNCTION
113.  
114. FUNCTION polyCollide (vert1() AS gl_vertex_type, vert2() AS gl_vertex_type)
115.     DIM n1 AS INTEGER, n2 AS INTEGER
116.     n1 = UBOUND(vert1): n2 = UBOUND(vert2)
117.     'checking if any point of polygon 1 inside polygon 2
118.     FOR i = 0 TO n1
119.         IF pointInsidePoly(vert1(i), vert2()) THEN polyCollide = -1: EXIT FUNCTION
120.     NEXT
121.     'checking if any point of polygon 2 inside polygon 1
122.     FOR i = 0 TO n2
123.         IF pointInsidePoly(vert2(i), vert1()) THEN polyCollide = -1: EXIT FUNCTION
124.     NEXT
125.     ' checking the edge intersection
126.     FOR i = 0 TO n1
127.         FOR j = 0 TO n2
128.             IF lineIntersect(vert1(i).x, vert1(i).y, vert1((i + 1) MOD (n1 + 1)).x, vert1((i + 1) MOD (n1 + 1)).y, vert2(j).x, vert2(j).y, vert2((j + 1) MOD (n2 + 1)).x, vert2((j + 1) MOD (n2 + 1)).y) THEN polyCollide = -1: EXIT FUNCTION
129.         NEXT
130.     NEXT
131. END FUNCTION
132.  
133. 'from paulbourke.net
134. FUNCTION pointInsidePoly (p AS gl_vertex_type, polyVert() AS gl_vertex_type)
135.     DIM ax1, ax2, ay1, ay2
136.     n = UBOUND(polyVert)
137.     FOR i = 0 TO n
138.         ax1 = polyVert(i).x - p.x
139.         ay1 = polyVert(i).y - p.y
140.         ax2 = polyVert((i + 1) MOD (n + 1)).x - p.x
141.         ay2 = polyVert((i + 1) MOD (n + 1)).y - p.y
142.         ang = ang + angle2D(ax1, ay1, ax2, ay2)
143.     NEXT
144.     pointInsidePoly = (ABS(ang) >= _PI)
145. END FUNCTION
146.  
147. 'from paulbourke.net
148. FUNCTION angle2D (x1, y1, x2, y2)
149.     DIM theta1, theta2, ftheta
150.     theta1 = _ATAN2(y1, x1)
151.     theta2 = _ATAN2(y2, x2)
152.     ftheta = theta1 - theta2
153.     WHILE ftheta > _PI: ftheta = ftheta - _PI(2): WEND
154.     WHILE ftheta < -_PI: ftheta = ftheta + _PI(2): WEND
155.     angle2D = ftheta
156. END FUNCTION
157.  
158. FUNCTION lineIntersect (__x1, __y1, __x2, __y2, __x3, __y3, __x4, __y4)
159.     DIM x1 AS INTEGER, y1 AS INTEGER, x2 AS INTEGER, y2 AS INTEGER, x3 AS INTEGER, y3 AS INTEGER, x4 AS INTEGER, y4 AS INTEGER
160.     DIM a1, b1, c1, a2, b2, c2
161.     DIM a1b2_minus_a2b1, b1c2_minus_b2c1, a2c1_minus_a1c2
162.     DIM inter_x AS INTEGER, inter_y AS INTEGER
163.  
164.     x1 = __x1: x2 = __x2: x3 = __x3: x4 = __x4
165.     y1 = __y1: y2 = __y2: y3 = __y3: y4 = __y4
166.    
167.     IF x1 > x2 THEN SWAP x1, x2
168.     IF x3 > x4 THEN SWAP x3, x4
169.     IF y1 > y2 THEN SWAP y1, y2
170.     IF y3 > y4 THEN SWAP y3, y4
171.    
172.     a1 = __y2 - __y1: b1 = -(__x2 - __x1): c1 = (__x2 * __y1) - (__x1 * __y2)
173.     a2 = __y4 - __y3: b2 = -(__x4 - __x3): c2 = (__x4 * __y3) - (__x3 * __y4)
174.  
175.     'check if lines are perfectly vertical or horizontal
176.     IF a1 = 0 AND a2 = 0 THEN lineIntersect = (__y1 = __y3): _DEST 0: EXIT FUNCTION
177.     IF b1 = 0 AND b2 = 0 THEN lineIntersect = (__x1 = __x3): _DEST 0: EXIT FUNCTION
178.     IF a2 = 0 OR b2 = 0 THEN GOTO skip_component_ratio
179.    
180.     'check if the whole line segments coincide with each other.
181.     IF c2 <> 0 THEN
182.         IF (a1 / a2) = (b1 / b2) AND (b1 / b2) = (c1 / c2) THEN
183.             lineIntersect = -1: EXIT FUNCTION
184.         END IF
185.     END IF
186.     skip_component_ratio:
187.     'check if the line segments have same slope.
188.     IF a1 * b2 = a2 * b1 THEN
189.         lineIntersect = (c1 = c2) 'special case, when they still coincide (as c1=c2)
190.         EXIT FUNCTION
191.     END IF
192.     'check if the line do intersect between the segments.
193.     a1b2_minus_a2b1 = (a1 * b2) - (a2 * b1): b1c2_minus_b2c1 = (b1 * c2) - (b2 * c1): a2c1_minus_a1c2 = (a2 * c1) - (a1 * c2)
194.     inter_x = b1c2_minus_b2c1 / a1b2_minus_a2b1: inter_y = a2c1_minus_a1c2 / a1b2_minus_a2b1
195.    
196.     lineIntersect = ((inter_x >= x1 AND inter_x <= x2 AND inter_y >= y1 AND inter_y <= y2)) AND ((inter_x >= x3 AND inter_x <= x4 AND inter_y >= y3 AND inter_y <= y4))
197. END FUNCTION
198.  
199. 'taken from p5js.bas
200. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
201.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
202. END FUNCTION
203.  
204. FUNCTION p5random! (mn!, mx!)
205.     IF mn! > mx! THEN
206.         SWAP mn!, mx!
207.     END IF
208.     p5random! = RND * (mx! - mn!) + mn!
209. END FUNCTION
210.  

[bplus]

Cool!

@Ashish, if you try squares maybe you could put images in them? Wouldn't that make things interesting?

[Pete]

Doritos!

@Fell: Speak English!

@ Ashish: Yep, it's all that, and a bag of chips, but I tried the latest code, and all I got was the bag of chips.. all shaded triangles, not shaded pentagons. What? Edit: Oh, I see, I found the place you mentioned to change the number of sides. Cool!

Pete

[bplus]

Hey a little mod :)

Code: QB64: [Select]

1. 'Space Filling with Polygon
2. 'By Ashish
3. 'b+ copy and mod 2020-04-29   https://www.qb64.org/forum/index.php?topic=2515.msg117572#msg117572
4. RANDOMIZE TIMER
5. TYPE XY
6.     x AS SINGLE
7.     y AS SINGLE
8. END TYPE
9.  
10. _TITLE "Space Filling with Polygon"
11. SCREEN _NEWIMAGE(800, 600, 32)
12. _DELAY .25
13. _SCREENMOVE _MIDDLE
14. 'INPUT "Enter the number of side for a polygon (must be greater than 2) : ", x%
15. 'IF x% < 3 THEN PRINT "It must be greate than 2!, taking default value of 3. Hit ENTER.": SLEEP: x% = 3
16.  
17.  
18. ' b+ loads an image and takes some measurements
19. DIM SHARED ih&
20. ih& = _LOADIMAGE("Templar.png")
21. IF ih& = -1 THEN PRINT "Sorry image did not load.": SLEEP: END
22. DIM SHARED wi, hi
23. wi = _WIDTH(ih&): hi = _HEIGHT(ih&)
24.  
25. polySides = 4
26. DIM tempPoly1(polySides - 1) AS XY, tempPoly2(polySides - 1) AS XY
27. REDIM polys(polySides - 1) AS XY
28.  
29. init = 0
30. poly_index = 0
31. i = 1
32. c = 1.1
33. failed = 0
34. CLS
35. FOR y = 0 TO 600
36.     midInk 0, 0, 255, 255, 255, 0, y / 600
37.     LINE (0, y)-(800, y)
38. NEXT
39. DO
40.     IF init = 0 THEN
41.         r = p5random(150, 200)
42.         ox = p5random(r, _WIDTH - r)
43.         oy = p5random(r, _HEIGHT - r)
44.         offAng = p5random(-_PI, _PI)
45.         FOR j = 0 TO polySides - 1
46.             polys(j).x = ox + COS(j * (_PI(2 / polySides)) + offAng) * r
47.             polys(j).y = oy + SIN(j * (_PI(2 / polySides)) + offAng) * r
48.         NEXT
49.         clr~& = midColor(_RGB(255, 255, 0), _RGB(255, 100, 0), map(r, 200, 3, 0, 1))
50.         drawPoly polys(), clr~&
51.         init = 1
52.         poly_index = poly_index + polySides
53.     ELSE
54.         r = 200 / (c ^ i)
55.         ox = p5random(r, _WIDTH - r)
56.         oy = p5random(r, _HEIGHT - r)
57.         collided = 0
58.         offAng = p5random(-_PI, _PI)
59.         FOR j = 0 TO polySides - 1
60.             tempPoly1(j).x = ox + COS(j * (_PI(2 / polySides)) + offAng) * r
61.             tempPoly1(j).y = oy + SIN(j * (_PI(2 / polySides)) + offAng) * r
62.         NEXT
63.         FOR j = 0 TO UBOUND(polys) STEP polySides
64.             FOR k = j TO j + polySides - 1
65.                 tempPoly2(k - j) = polys(k)
66.             NEXT
67.             IF polyCollide(tempPoly1(), tempPoly2()) THEN collided = -1: EXIT FOR
68.         NEXT
69.         IF NOT collided THEN
70.             ' _echo "yes"
71.             REDIM _PRESERVE polys(UBOUND(polys) + polySides) AS XY
72.             FOR j = poly_index TO poly_index + polySides - 1
73.                 polys(j) = tempPoly1(j - poly_index)
74.             NEXT
75.             clr~& = midColor(_RGB(255, 255, 0), _RGB(255, 100, 0), map(r, 200, 3, 0, 1))
76.             drawPoly tempPoly1(), clr~&
77.             poly_index = poly_index + polySides
78.         ELSE
79.             failed = failed + 1
80.             IF failed > (i * 60) THEN i = i + 1: failed = 0
81.         END IF
82.     END IF
83. LOOP UNTIL r < 1
84. SLEEP
85.  
86. FUNCTION midColor~& (clr1 AS _UNSIGNED LONG, clr2 AS _UNSIGNED LONG, v)
87.     midColor~& = _RGB(map(v, 0, 1, _RED(clr1), _RED(clr2)), map(v, 0, 1, _GREEN(clr1), _GREEN(clr2)), map(v, 0, 1, _BLUE(clr1), _BLUE(clr2)))
88. END FUNCTION
89.  
90. SUB drawPoly (vert() AS XY, clr AS _UNSIGNED LONG)
91.     'n = UBOUND(vert)
92.     'DIM cx, cy
93.     'FOR i = 0 TO n
94.     '    LINE (vert(i).x, vert(i).y)-(vert((i + 1) MOD (n + 1)).x, vert((i + 1) MOD (n + 1)).y), clr
95.     '    cx = cx + vert(i).x: cy = cy + vert(i).y
96.     'NEXT
97.     'cx = cx / (n + 1): cy = cy / (n + 1)
98.     'PAINT (cx, cy), clr, clr
99.  
100.     cx = (vert(0).x + vert(2).x) / 2 'find the center, radius and tilt
101.     cy = (vert(0).y + vert(2).y) / 2
102.     r = SQR(2) * _HYPOT(cx - vert(0).x, cy - vert(0).y) 'mult bty SQR(2) locating sq top left corner from
103.     a = _ATAN2(vert(0).y - cy, vert(0).x - cx) - _PI / 4 'subtract 45 degrees because square is off by that
104.     RotoZoom3 cx, cy, ih&, r / wi, r / hi, a
105. END SUB
106.  
107.  
108. FUNCTION polyCollide (vert1() AS XY, vert2() AS XY)
109.     DIM n1 AS INTEGER, n2 AS INTEGER
110.     n1 = UBOUND(vert1): n2 = UBOUND(vert2)
111.     'checking if any point of polygon 1 inside polygon 2
112.     FOR i = 0 TO n1
113.         IF pointInsidePoly(vert1(i), vert2()) THEN polyCollide = -1: EXIT FUNCTION
114.     NEXT
115.     'checking if any point of polygon 2 inside polygon 1
116.     FOR i = 0 TO n2
117.         IF pointInsidePoly(vert2(i), vert1()) THEN polyCollide = -1: EXIT FUNCTION
118.     NEXT
119.     ' checking the edge intersection
120.     FOR i = 0 TO n1
121.         FOR j = 0 TO n2
122.             IF lineIntersect(vert1(i).x, vert1(i).y, vert1((i + 1) MOD (n1 + 1)).x, vert1((i + 1) MOD (n1 + 1)).y, vert2(j).x, vert2(j).y, vert2((j + 1) MOD (n2 + 1)).x, vert2((j + 1) MOD (n2 + 1)).y) THEN polyCollide = -1: EXIT FUNCTION
123.         NEXT
124.     NEXT
125. END FUNCTION
126.  
127. 'from paulbourke.net
128. FUNCTION pointInsidePoly (p AS XY, polyVert() AS XY)
129.     DIM ax1, ax2, ay1, ay2
130.     n = UBOUND(polyVert)
131.     FOR i = 0 TO n
132.         ax1 = polyVert(i).x - p.x
133.         ay1 = polyVert(i).y - p.y
134.         ax2 = polyVert((i + 1) MOD (n + 1)).x - p.x
135.         ay2 = polyVert((i + 1) MOD (n + 1)).y - p.y
136.         ang = ang + angle2D(ax1, ay1, ax2, ay2)
137.     NEXT
138.     pointInsidePoly = (ABS(ang) >= _PI)
139. END FUNCTION
140.  
141. 'from paulbourke.net
142. FUNCTION angle2D (x1, y1, x2, y2)
143.     DIM theta1, theta2, ftheta
144.     theta1 = _ATAN2(y1, x1)
145.     theta2 = _ATAN2(y2, x2)
146.     ftheta = theta1 - theta2
147.     WHILE ftheta > _PI: ftheta = ftheta - _PI(2): WEND
148.     WHILE ftheta < -_PI: ftheta = ftheta + _PI(2): WEND
149.     angle2D = ftheta
150. END FUNCTION
151.  
152. FUNCTION lineIntersect (__x1, __y1, __x2, __y2, __x3, __y3, __x4, __y4)
153.     DIM x1 AS INTEGER, y1 AS INTEGER, x2 AS INTEGER, y2 AS INTEGER, x3 AS INTEGER, y3 AS INTEGER, x4 AS INTEGER, y4 AS INTEGER
154.     DIM a1, b1, c1, a2, b2, c2
155.     DIM a1b2_minus_a2b1, b1c2_minus_b2c1, a2c1_minus_a1c2
156.     DIM inter_x AS INTEGER, inter_y AS INTEGER
157.  
158.     x1 = __x1: x2 = __x2: x3 = __x3: x4 = __x4
159.     y1 = __y1: y2 = __y2: y3 = __y3: y4 = __y4
160.  
161.     IF x1 > x2 THEN SWAP x1, x2
162.     IF x3 > x4 THEN SWAP x3, x4
163.     IF y1 > y2 THEN SWAP y1, y2
164.     IF y3 > y4 THEN SWAP y3, y4
165.  
166.     a1 = __y2 - __y1: b1 = -(__x2 - __x1): c1 = (__x2 * __y1) - (__x1 * __y2)
167.     a2 = __y4 - __y3: b2 = -(__x4 - __x3): c2 = (__x4 * __y3) - (__x3 * __y4)
168.  
169.     'check if lines are perfectly vertical or horizontal
170.     IF a1 = 0 AND a2 = 0 THEN lineIntersect = (__y1 = __y3): _DEST 0: EXIT FUNCTION
171.     IF b1 = 0 AND b2 = 0 THEN lineIntersect = (__x1 = __x3): _DEST 0: EXIT FUNCTION
172.     IF a2 = 0 OR b2 = 0 THEN GOTO skip_component_ratio
173.  
174.     'check if the whole line segments coincide with each other.
175.     IF c2 <> 0 THEN
176.         IF (a1 / a2) = (b1 / b2) AND (b1 / b2) = (c1 / c2) THEN
177.             lineIntersect = -1: EXIT FUNCTION
178.         END IF
179.     END IF
180.     skip_component_ratio:
181.     'check if the line segments have same slope.
182.     IF a1 * b2 = a2 * b1 THEN
183.         lineIntersect = (c1 = c2) 'special case, when they still coincide (as c1=c2)
184.         EXIT FUNCTION
185.     END IF
186.     'check if the line do intersect between the segments.
187.     a1b2_minus_a2b1 = (a1 * b2) - (a2 * b1): b1c2_minus_b2c1 = (b1 * c2) - (b2 * c1): a2c1_minus_a1c2 = (a2 * c1) - (a1 * c2)
188.     inter_x = b1c2_minus_b2c1 / a1b2_minus_a2b1: inter_y = a2c1_minus_a1c2 / a1b2_minus_a2b1
189.  
190.     lineIntersect = ((inter_x >= x1 AND inter_x <= x2 AND inter_y >= y1 AND inter_y <= y2)) AND ((inter_x >= x3 AND inter_x <= x4 AND inter_y >= y3 AND inter_y <= y4))
191. END FUNCTION
192.  
193. 'taken from p5js.bas
194. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
195.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
196. END FUNCTION
197.  
198. FUNCTION p5random! (mn!, mx!)
199.     IF mn! > mx! THEN
200.         SWAP mn!, mx!
201.     END IF
202.     p5random! = RND * (mx! - mn!) + mn!
203. END FUNCTION
204.  
205. ' b+ added some helpers =====================================================================================
206.  
207. SUB RotoZoom3 (X AS LONG, Y AS LONG, Image AS LONG, xScale AS SINGLE, yScale AS SINGLE, radianRotation AS SINGLE) ' 0 at end means no scaling of x or y
208.     DIM px(3) AS SINGLE: DIM py(3) AS SINGLE
209.     DIM W&, H&, sinr!, cosr!, i&, x2&, y2&
210.     W& = _WIDTH(Image&): H& = _HEIGHT(Image&)
211.     px(0) = -W& / 2: py(0) = -H& / 2: px(1) = -W& / 2: py(1) = H& / 2
212.     px(2) = W& / 2: py(2) = H& / 2: px(3) = W& / 2: py(3) = -H& / 2
213.     sinr! = SIN(-radianRotation): cosr! = COS(-radianRotation)
214.     FOR i& = 0 TO 3
215.         x2& = xScale * (px(i&) * cosr! + sinr! * py(i&)) + X: y2& = yScale * (py(i&) * cosr! - px(i&) * sinr!) + Y
216.         px(i&) = x2&: py(i&) = y2&
217.     NEXT
218.     _MAPTRIANGLE _SEAMLESS(0, 0)-(0, H& - 1)-(W& - 1, H& - 1), Image TO(px(0), py(0))-(px(1), py(1))-(px(2), py(2))
219.     _MAPTRIANGLE _SEAMLESS(0, 0)-(W& - 1, 0)-(W& - 1, H& - 1), Image TO(px(0), py(0))-(px(3), py(3))-(px(2), py(2))
220. END SUB
221.  
222. SUB midInk (r1%, g1%, b1%, r2%, g2%, b2%, fr##)
223.     COLOR _RGB32(r1% + (r2% - r1%) * fr##, g1% + (g2% - g1%) * fr##, b1% + (b2% - b1%) * fr##)
224. END SUB
225.  
226.  

 

and zip with bas, exe and png

[bplus]

Here I try swapping color with the image:

Code: QB64: [Select]

1. 'Space Filling with Polygon
2. 'By Ashish
3. 'b+ copy and mod 2020-04-29   https://www.qb64.org/forum/index.php?topic=2515.msg117572#msg117572
4. 'b+ mod 2 color changing
5. RANDOMIZE TIMER
6. TYPE XY
7.     x AS SINGLE
8.     y AS SINGLE
9. END TYPE
10.  
11. _TITLE "Space Filling with Polygon"
12. SCREEN _NEWIMAGE(800, 600, 32)
13. _DELAY .25
14. _SCREENMOVE _MIDDLE
15. 'INPUT "Enter the number of side for a polygon (must be greater than 2) : ", x%
16. 'IF x% < 3 THEN PRINT "It must be greate than 2!, taking default value of 3. Hit ENTER.": SLEEP: x% = 3
17.  
18.  
19. ' b+ loads an image and takes some measurements
20. DIM SHARED ih&
21. ih& = _LOADIMAGE("Templar.png")
22. IF ih& = -1 THEN PRINT "Sorry image did not load.": SLEEP: END
23. DIM SHARED wi, hi
24. wi = _WIDTH(ih&): hi = _HEIGHT(ih&)
25. DIM SHARED rStart, origClr AS _UNSIGNED LONG
26. 'what is it's color
27.  
28. _PUTIMAGE , ih&, 0
29. origClr = POINT(10, 300)
30. PRINT origClr
31. 'END
32.  
33.  
34. polySides = 4
35. DIM tempPoly1(polySides - 1) AS XY, tempPoly2(polySides - 1) AS XY
36. REDIM polys(polySides - 1) AS XY
37.  
38. init = 0
39. poly_index = 0
40. i = 1
41. c = 1.1
42. failed = 0
43. CLS
44. FOR y = 0 TO 600
45.     LINE (0, y)-(800, y), midInk(0, 0, 255, 255, 255, 0, y / 600)
46. NEXT
47. DO
48.     IF init = 0 THEN
49.         r = p5random(150, 200)
50.         rStart = r
51.         ox = p5random(r, _WIDTH - r)
52.         oy = p5random(r, _HEIGHT - r)
53.         offAng = p5random(-_PI, _PI)
54.         FOR j = 0 TO polySides - 1
55.             polys(j).x = ox + COS(j * (_PI(2 / polySides)) + offAng) * r
56.             polys(j).y = oy + SIN(j * (_PI(2 / polySides)) + offAng) * r
57.         NEXT
58.         'clr~& = midColor(_RGB(255, 255, 0), _RGB(255, 100, 0), map(r, 200, 3, 0, 1))
59.         drawPoly polys(), midInk~&(0, 128, 0, 255, 0, 255, (rStart - r) / rStart)
60.         init = 1
61.         poly_index = poly_index + polySides
62.     ELSE
63.         r = 200 / (c ^ i)
64.         ox = p5random(r, _WIDTH - r)
65.         oy = p5random(r, _HEIGHT - r)
66.         collided = 0
67.         offAng = p5random(-_PI, _PI)
68.         FOR j = 0 TO polySides - 1
69.             tempPoly1(j).x = ox + COS(j * (_PI(2 / polySides)) + offAng) * r
70.             tempPoly1(j).y = oy + SIN(j * (_PI(2 / polySides)) + offAng) * r
71.         NEXT
72.         FOR j = 0 TO UBOUND(polys) STEP polySides
73.             FOR k = j TO j + polySides - 1
74.                 tempPoly2(k - j) = polys(k)
75.             NEXT
76.             IF polyCollide(tempPoly1(), tempPoly2()) THEN collided = -1: EXIT FOR
77.         NEXT
78.         IF NOT collided THEN
79.             ' _echo "yes"
80.             REDIM _PRESERVE polys(UBOUND(polys) + polySides) AS XY
81.             FOR j = poly_index TO poly_index + polySides - 1
82.                 polys(j) = tempPoly1(j - poly_index)
83.             NEXT
84.             clr~& = midColor(_RGB(255, 255, 0), _RGB(255, 100, 0), map(r, 200, 3, 0, 1))
85.             drawPoly tempPoly1(), midInk~&(0, 128, 0, 255, 0, 255, (rStart - r) / rStart)
86.             poly_index = poly_index + polySides
87.         ELSE
88.             failed = failed + 1
89.             IF failed > (i * 60) THEN i = i + 1: failed = 0
90.         END IF
91.     END IF
92. LOOP UNTIL r < 4
93. SLEEP
94.  
95. FUNCTION midColor~& (clr1 AS _UNSIGNED LONG, clr2 AS _UNSIGNED LONG, v)
96.     midColor~& = _RGB(map(v, 0, 1, _RED(clr1), _RED(clr2)), map(v, 0, 1, _GREEN(clr1), _GREEN(clr2)), map(v, 0, 1, _BLUE(clr1), _BLUE(clr2)))
97. END FUNCTION
98.  
99. SUB drawPoly (vert() AS XY, clr AS _UNSIGNED LONG)
100.     'n = UBOUND(vert)
101.     'DIM cx, cy
102.     'FOR i = 0 TO n
103.     '    LINE (vert(i).x, vert(i).y)-(vert((i + 1) MOD (n + 1)).x, vert((i + 1) MOD (n + 1)).y), clr
104.     '    cx = cx + vert(i).x: cy = cy + vert(i).y
105.     'NEXT
106.     'cx = cx / (n + 1): cy = cy / (n + 1)
107.     'PAINT (cx, cy), clr, clr
108.  
109.     cx = (vert(0).x + vert(2).x) / 2 'find the center, radius and tilt
110.     cy = (vert(0).y + vert(2).y) / 2
111.     r = SQR(2) * _HYPOT(cx - vert(0).x, cy - vert(0).y) 'mult bty SQR(2) locating sq top left corner from
112.     a = _ATAN2(vert(0).y - cy, vert(0).x - cx) - _PI / 4 'subtract 45 degrees because square is off by that
113.     new& = swapColor&(ih&, origClr, clr)
114.     RotoZoom3 cx, cy, new&, r / wi, r / hi, a
115.     _FREEIMAGE new&
116. END SUB
117.  
118.  
119. FUNCTION polyCollide (vert1() AS XY, vert2() AS XY)
120.     DIM n1 AS INTEGER, n2 AS INTEGER
121.     n1 = UBOUND(vert1): n2 = UBOUND(vert2)
122.     'checking if any point of polygon 1 inside polygon 2
123.     FOR i = 0 TO n1
124.         IF pointInsidePoly(vert1(i), vert2()) THEN polyCollide = -1: EXIT FUNCTION
125.     NEXT
126.     'checking if any point of polygon 2 inside polygon 1
127.     FOR i = 0 TO n2
128.         IF pointInsidePoly(vert2(i), vert1()) THEN polyCollide = -1: EXIT FUNCTION
129.     NEXT
130.     ' checking the edge intersection
131.     FOR i = 0 TO n1
132.         FOR j = 0 TO n2
133.             IF lineIntersect(vert1(i).x, vert1(i).y, vert1((i + 1) MOD (n1 + 1)).x, vert1((i + 1) MOD (n1 + 1)).y, vert2(j).x, vert2(j).y, vert2((j + 1) MOD (n2 + 1)).x, vert2((j + 1) MOD (n2 + 1)).y) THEN polyCollide = -1: EXIT FUNCTION
134.         NEXT
135.     NEXT
136. END FUNCTION
137.  
138. 'from paulbourke.net
139. FUNCTION pointInsidePoly (p AS XY, polyVert() AS XY)
140.     DIM ax1, ax2, ay1, ay2
141.     n = UBOUND(polyVert)
142.     FOR i = 0 TO n
143.         ax1 = polyVert(i).x - p.x
144.         ay1 = polyVert(i).y - p.y
145.         ax2 = polyVert((i + 1) MOD (n + 1)).x - p.x
146.         ay2 = polyVert((i + 1) MOD (n + 1)).y - p.y
147.         ang = ang + angle2D(ax1, ay1, ax2, ay2)
148.     NEXT
149.     pointInsidePoly = (ABS(ang) >= _PI)
150. END FUNCTION
151.  
152. 'from paulbourke.net
153. FUNCTION angle2D (x1, y1, x2, y2)
154.     DIM theta1, theta2, ftheta
155.     theta1 = _ATAN2(y1, x1)
156.     theta2 = _ATAN2(y2, x2)
157.     ftheta = theta1 - theta2
158.     WHILE ftheta > _PI: ftheta = ftheta - _PI(2): WEND
159.     WHILE ftheta < -_PI: ftheta = ftheta + _PI(2): WEND
160.     angle2D = ftheta
161. END FUNCTION
162.  
163. FUNCTION lineIntersect (__x1, __y1, __x2, __y2, __x3, __y3, __x4, __y4)
164.     DIM x1 AS INTEGER, y1 AS INTEGER, x2 AS INTEGER, y2 AS INTEGER, x3 AS INTEGER, y3 AS INTEGER, x4 AS INTEGER, y4 AS INTEGER
165.     DIM a1, b1, c1, a2, b2, c2
166.     DIM a1b2_minus_a2b1, b1c2_minus_b2c1, a2c1_minus_a1c2
167.     DIM inter_x AS INTEGER, inter_y AS INTEGER
168.  
169.     x1 = __x1: x2 = __x2: x3 = __x3: x4 = __x4
170.     y1 = __y1: y2 = __y2: y3 = __y3: y4 = __y4
171.  
172.     IF x1 > x2 THEN SWAP x1, x2
173.     IF x3 > x4 THEN SWAP x3, x4
174.     IF y1 > y2 THEN SWAP y1, y2
175.     IF y3 > y4 THEN SWAP y3, y4
176.  
177.     a1 = __y2 - __y1: b1 = -(__x2 - __x1): c1 = (__x2 * __y1) - (__x1 * __y2)
178.     a2 = __y4 - __y3: b2 = -(__x4 - __x3): c2 = (__x4 * __y3) - (__x3 * __y4)
179.  
180.     'check if lines are perfectly vertical or horizontal
181.     IF a1 = 0 AND a2 = 0 THEN lineIntersect = (__y1 = __y3): _DEST 0: EXIT FUNCTION
182.     IF b1 = 0 AND b2 = 0 THEN lineIntersect = (__x1 = __x3): _DEST 0: EXIT FUNCTION
183.     IF a2 = 0 OR b2 = 0 THEN GOTO skip_component_ratio
184.  
185.     'check if the whole line segments coincide with each other.
186.     IF c2 <> 0 THEN
187.         IF (a1 / a2) = (b1 / b2) AND (b1 / b2) = (c1 / c2) THEN
188.             lineIntersect = -1: EXIT FUNCTION
189.         END IF
190.     END IF
191.     skip_component_ratio:
192.     'check if the line segments have same slope.
193.     IF a1 * b2 = a2 * b1 THEN
194.         lineIntersect = (c1 = c2) 'special case, when they still coincide (as c1=c2)
195.         EXIT FUNCTION
196.     END IF
197.     'check if the line do intersect between the segments.
198.     a1b2_minus_a2b1 = (a1 * b2) - (a2 * b1): b1c2_minus_b2c1 = (b1 * c2) - (b2 * c1): a2c1_minus_a1c2 = (a2 * c1) - (a1 * c2)
199.     inter_x = b1c2_minus_b2c1 / a1b2_minus_a2b1: inter_y = a2c1_minus_a1c2 / a1b2_minus_a2b1
200.  
201.     lineIntersect = ((inter_x >= x1 AND inter_x <= x2 AND inter_y >= y1 AND inter_y <= y2)) AND ((inter_x >= x3 AND inter_x <= x4 AND inter_y >= y3 AND inter_y <= y4))
202. END FUNCTION
203.  
204. 'taken from p5js.bas
205. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
206.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
207. END FUNCTION
208.  
209. FUNCTION p5random! (mn!, mx!)
210.     IF mn! > mx! THEN
211.         SWAP mn!, mx!
212.     END IF
213.     p5random! = RND * (mx! - mn!) + mn!
214. END FUNCTION
215.  
216. ' b+ added some helpers =====================================================================================
217.  
218. SUB RotoZoom3 (X AS LONG, Y AS LONG, Image AS LONG, xScale AS SINGLE, yScale AS SINGLE, radianRotation AS SINGLE) ' 0 at end means no scaling of x or y
219.     DIM px(3) AS SINGLE: DIM py(3) AS SINGLE
220.     DIM W&, H&, sinr!, cosr!, i&, x2&, y2&
221.     W& = _WIDTH(Image&): H& = _HEIGHT(Image&)
222.     px(0) = -W& / 2: py(0) = -H& / 2: px(1) = -W& / 2: py(1) = H& / 2
223.     px(2) = W& / 2: py(2) = H& / 2: px(3) = W& / 2: py(3) = -H& / 2
224.     sinr! = SIN(-radianRotation): cosr! = COS(-radianRotation)
225.     FOR i& = 0 TO 3
226.         x2& = xScale * (px(i&) * cosr! + sinr! * py(i&)) + X: y2& = yScale * (py(i&) * cosr! - px(i&) * sinr!) + Y
227.         px(i&) = x2&: py(i&) = y2&
228.     NEXT
229.     _MAPTRIANGLE _SEAMLESS(0, 0)-(0, H& - 1)-(W& - 1, H& - 1), Image TO(px(0), py(0))-(px(1), py(1))-(px(2), py(2))
230.     _MAPTRIANGLE _SEAMLESS(0, 0)-(W& - 1, 0)-(W& - 1, H& - 1), Image TO(px(0), py(0))-(px(3), py(3))-(px(2), py(2))
231. END SUB
232.  
233. FUNCTION midInk~& (r1%, g1%, b1%, r2%, g2%, b2%, fr##)
234.     midInk~& = _RGB32(r1% + (r2% - r1%) * fr##, g1% + (g2% - g1%) * fr##, b1% + (b2% - b1%) * fr##)
235. END FUNCTION
236.  
237. ' create new Image Handle for an image copy with a color changed from original image, returns new Handle&
238. 'https://www.qb64.org/forum/index.php?topic=2451.0
239. ' from Petr to Craz1000
240. FUNCTION swapColor& (oldHandle&, oldcolor~&, newcolor~&)
241.     DIM m AS _MEM, c AS _UNSIGNED LONG
242.     swapColor& = _COPYIMAGE(oldHandle&, 32)
243.     m = _MEMIMAGE(swapColor)
244.     DO UNTIL a& = m.SIZE - 4
245.         a& = a& + 4
246.         c~& = _MEMGET(m, m.OFFSET + a&, _UNSIGNED LONG)
247.         IF c~& = oldcolor~& THEN _MEMPUT m, m.OFFSET + a&, newcolor~&
248.     LOOP
249.     _MEMFREE m
250. END FUNCTION
251.  
252.  

Same png as in zip above.

[Ashish]

@bplus
Cool! I liked your MOD!

[bplus]

@Ashish

And I like this demo because you are getting in closer with the polygons than you could with circles with the polygons drawn within. ie could almost do same thing with a circle fill and then embed any regular poly within the circles but they could not get as close as they do here, some side by side.

[Ashish]

@bplus
Yeah, thanks for giving the idea
Here we gooo...!!

Code: QB64: [Select]

1. 'Space Filling with Polygon
2. 'By Ashish
3. 'MOD : RESTRICTED AREA
4. 'circle is situated at the center of the screen
5.  
6. RANDOMIZE TIMER
7. TYPE gl_vertex_type
8.     'position of vertex
9.     x AS SINGLE
10.     y AS SINGLE
11.     'center
12.     cx AS SINGLE
13.     cy AS SINGLE
14.     'color of the vertex to be used
15.     r AS SINGLE
16.     g AS SINGLE
17.     b AS SINGLE
18. END TYPE
19.  
20. _TITLE "Space Filling with Polygon [MOD:RESTRICTED AREA]"
21. SCREEN _NEWIMAGE(800, 600, 32)
22.  
23. DIM SHARED init, polySides
24. 'warning : polySides must always be greater than 2
25. polySides = 3 'change its value to get different polygons
26. DIM tempPoly1(polySides - 1) AS gl_vertex_type, tempPoly2(polySides - 1) AS gl_vertex_type
27. REDIM SHARED polys(polySides - 1) AS gl_vertex_type
28.  
29.  
30. init = 0
31. poly_index = 0
32. i = 1
33. c = 1.05
34. failed = 0
35. CLS
36. DO
37.         search_new_place:
38.     IF init = 0 THEN
39.         r = p5random(100, 150)
40.         ox = p5random(r, _WIDTH - r)
41.         oy = p5random(r, _HEIGHT - r)
42.         offAng = p5random(-_PI, _PI)
43.         clr~& = midColor(_RGB(255, 255, 0), _RGB(255, 100, 0), map(r, 150, 3, 0, 1))
44.         red = map(_RED(clr~&), 0, 255, 0, 1): green = map(_GREEN(clr~&), 0, 255, 0, 1): blue = map(_BLUE(clr~&), 0, 255, 0, 1)
45.         FOR j = 0 TO polySides - 1
46.             polys(j).x = ox+COS(j * (_PI(2 / polySides)) + offAng) * r
47.             polys(j).y = oy+SIN(j * (_PI(2 / polySides)) + offAng) * r
48.                         if not insideCircle(polys(j),400,300,300) then  goto search_new_place
49.                        
50.             polys(j).cx = ox: polys(j).cy = oy
51.             polys(j).r = red: polys(j).g = green: polys(j).b = blue
52.         NEXT
53.         init = -1
54.         poly_index = poly_index + polySides
55.     ELSE
56.         r = 120 / (c ^ i)
57.         ox = p5random(r, _WIDTH - r)
58.         oy = p5random(r, _HEIGHT - r)
59.         collided = 0
60.         offAng = p5random(-_PI, _PI)
61.         FOR j = 0 TO polySides - 1
62.             tempPoly1(j).x = ox + COS(j * (_PI(2 / polySides)) + offAng) * r
63.             tempPoly1(j).y = oy + SIN(j * (_PI(2 / polySides)) + offAng) * r
64.                         if not insideCircle(tempPoly1(j),400,300,300) then goto search_new_place
65.         NEXT
66.         FOR j = 0 TO UBOUND(polys) STEP polySides
67.             FOR k = j TO j + polySides - 1
68.                 tempPoly2(k - j) = polys(k)
69.             NEXT
70.             IF polyCollide(tempPoly1(), tempPoly2()) THEN collided = -1: EXIT FOR
71.         NEXT
72.         IF NOT collided THEN
73.             REDIM _PRESERVE polys(UBOUND(polys) + polySides) AS gl_vertex_type
74.             clr~& = midColor(_RGB(255, 255, 0), _RGB(255, 100, 0), map(r, 120, 3, 0, 1))
75.             red = map(_RED(clr~&), 0, 255, 0, 1): green = map(_GREEN(clr~&), 0, 255, 0, 1): blue = map(_BLUE(clr~&), 0, 255, 0, 1)
76.             FOR j = poly_index TO poly_index + polySides - 1
77.                 polys(j) = tempPoly1(j - poly_index)
78.                 polys(j).cx = ox: polys(j).cy = oy
79.                 polys(j).r = red: polys(j).g = green: polys(j).b = blue
80.             NEXT
81.             poly_index = poly_index + polySides
82.         ELSE
83.             failed = failed + 1
84.             IF failed > (i * 60) THEN i = i + 1: failed = 0
85.         END IF
86.     END IF
87. LOOP UNTIL r < 3
88. SLEEP
89.  
90.  
91. SUB _GL ()
92.     IF NOT init THEN EXIT SUB
93.         _glEnable _GL_TEXTURE_2D
94.     _glMatrixMode _GL_MODELVIEW
95.  
96.     'set the gl screen so that it can work normal screen coordinates
97.     _glTranslatef -1, 1, 0
98.     _glScalef 1 / 400, -1 / 300, 1
99.      
100.     'to get shaded effect, we will divide polygon into smaller triangles from center of polygon in a cyclic way.
101.     FOR n = 0 TO UBOUND(polys) STEP polySides
102.         _glPushMatrix
103.         _glTranslatef polys(n).cx, polys(n).cy, 0
104.         _glBegin _GL_TRIANGLES
105.         FOR j = n TO n + polySides - 1
106.             _glColor3f 0, 0, 0
107.             _glVertex2i 0, 0
108.             _glColor3f polys(n).r, polys(n).g, polys(n).b
109.             _glVertex2i polys(j).x - polys(n).cx, polys(j).y - polys(j).cy
110.             IF (j + 1) MOD (n + polySides) = 0 THEN _glVertex2i polys(n).x - polys(n).cx, polys(n).y - polys(j).cy ELSE _glVertex2i polys(j + 1).x - polys(n).cx, polys(j + 1).y - polys(j).cy
111.         NEXT
112.         _glEnd
113.         _glPopMatrix
114.     NEXT
115. END SUB
116.  
117. function insideCircle (p as gl_vertex_type, cx, cy, rad)
118.     insideCircle = (sqr((cx-p.x)^2+(cy-p.y)^2)<=rad)
119. end function
120.  
121. FUNCTION midColor~& (clr1 AS _UNSIGNED LONG, clr2 AS _UNSIGNED LONG, v)
122.     midColor~& = _RGB(map(v, 0, 1, _RED(clr1), _RED(clr2)), map(v, 0, 1, _GREEN(clr1), _GREEN(clr2)), map(v, 0, 1, _BLUE(clr1), _BLUE(clr2)))
123. END FUNCTION
124.  
125. FUNCTION polyCollide (vert1() AS gl_vertex_type, vert2() AS gl_vertex_type)
126.     DIM n1 AS INTEGER, n2 AS INTEGER
127.     n1 = UBOUND(vert1): n2 = UBOUND(vert2)
128.     'checking if any point of polygon 1 inside polygon 2
129.     FOR i = 0 TO n1
130.         IF pointInsidePoly(vert1(i), vert2()) THEN polyCollide = -1: EXIT FUNCTION
131.     NEXT
132.     'checking if any point of polygon 2 inside polygon 1
133.     FOR i = 0 TO n2
134.         IF pointInsidePoly(vert2(i), vert1()) THEN polyCollide = -1: EXIT FUNCTION
135.     NEXT
136.     ' checking the edge intersection
137.     FOR i = 0 TO n1
138.         FOR j = 0 TO n2
139.             IF lineIntersect(vert1(i).x, vert1(i).y, vert1((i + 1) MOD (n1 + 1)).x, vert1((i + 1) MOD (n1 + 1)).y, vert2(j).x, vert2(j).y, vert2((j + 1) MOD (n2 + 1)).x, vert2((j + 1) MOD (n2 + 1)).y) THEN polyCollide = -1: EXIT FUNCTION
140.         NEXT
141.     NEXT
142. END FUNCTION
143.  
144. 'from paulbourke.net
145. FUNCTION pointInsidePoly (p AS gl_vertex_type, polyVert() AS gl_vertex_type)
146.     DIM ax1, ax2, ay1, ay2
147.     n = UBOUND(polyVert)
148.     FOR i = 0 TO n
149.         ax1 = polyVert(i).x - p.x
150.         ay1 = polyVert(i).y - p.y
151.         ax2 = polyVert((i + 1) MOD (n + 1)).x - p.x
152.         ay2 = polyVert((i + 1) MOD (n + 1)).y - p.y
153.         ang = ang + angle2D(ax1, ay1, ax2, ay2)
154.     NEXT
155.     pointInsidePoly = (ABS(ang) >= _PI)
156. END FUNCTION
157.  
158. 'from paulbourke.net
159. FUNCTION angle2D (x1, y1, x2, y2)
160.     DIM theta1, theta2, ftheta
161.     theta1 = _ATAN2(y1, x1)
162.     theta2 = _ATAN2(y2, x2)
163.     ftheta = theta1 - theta2
164.     WHILE ftheta > _PI: ftheta = ftheta - _PI(2): WEND
165.     WHILE ftheta < -_PI: ftheta = ftheta + _PI(2): WEND
166.     angle2D = ftheta
167. END FUNCTION
168.  
169. FUNCTION lineIntersect (__x1, __y1, __x2, __y2, __x3, __y3, __x4, __y4)
170.     DIM x1 AS INTEGER, y1 AS INTEGER, x2 AS INTEGER, y2 AS INTEGER, x3 AS INTEGER, y3 AS INTEGER, x4 AS INTEGER, y4 AS INTEGER
171.     DIM a1, b1, c1, a2, b2, c2
172.     DIM a1b2_minus_a2b1, b1c2_minus_b2c1, a2c1_minus_a1c2
173.     DIM inter_x AS INTEGER, inter_y AS INTEGER
174.  
175.     x1 = __x1: x2 = __x2: x3 = __x3: x4 = __x4
176.     y1 = __y1: y2 = __y2: y3 = __y3: y4 = __y4
177.    
178.     IF x1 > x2 THEN SWAP x1, x2
179.     IF x3 > x4 THEN SWAP x3, x4
180.     IF y1 > y2 THEN SWAP y1, y2
181.     IF y3 > y4 THEN SWAP y3, y4
182.    
183.     a1 = __y2 - __y1: b1 = -(__x2 - __x1): c1 = (__x2 * __y1) - (__x1 * __y2)
184.     a2 = __y4 - __y3: b2 = -(__x4 - __x3): c2 = (__x4 * __y3) - (__x3 * __y4)
185.  
186.     'check if lines are perfectly vertical or horizontal
187.     IF a1 = 0 AND a2 = 0 THEN lineIntersect = (__y1 = __y3): _DEST 0: EXIT FUNCTION
188.     IF b1 = 0 AND b2 = 0 THEN lineIntersect = (__x1 = __x3): _DEST 0: EXIT FUNCTION
189.     IF a2 = 0 OR b2 = 0 THEN GOTO skip_component_ratio
190.    
191.     'check if the whole line segments coincide with each other.
192.     IF c2 <> 0 THEN
193.         IF (a1 / a2) = (b1 / b2) AND (b1 / b2) = (c1 / c2) THEN
194.             lineIntersect = -1: EXIT FUNCTION
195.         END IF
196.     END IF
197.     skip_component_ratio:
198.     'check if the line segments have same slope.
199.     IF a1 * b2 = a2 * b1 THEN
200.         lineIntersect = (c1 = c2) 'special case, when they still coincide (as c1=c2)
201.         EXIT FUNCTION
202.     END IF
203.     'check if the line do intersect between the segments.
204.     a1b2_minus_a2b1 = (a1 * b2) - (a2 * b1): b1c2_minus_b2c1 = (b1 * c2) - (b2 * c1): a2c1_minus_a1c2 = (a2 * c1) - (a1 * c2)
205.     inter_x = b1c2_minus_b2c1 / a1b2_minus_a2b1: inter_y = a2c1_minus_a1c2 / a1b2_minus_a2b1
206.    
207.     lineIntersect = ((inter_x >= x1 AND inter_x <= x2 AND inter_y >= y1 AND inter_y <= y2)) AND ((inter_x >= x3 AND inter_x <= x4 AND inter_y >= y3 AND inter_y <= y4))
208. END FUNCTION
209.  
210. 'taken from p5js.bas
211. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
212.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
213. END FUNCTION
214.  
215. FUNCTION p5random! (mn!, mx!)
216.     IF mn! > mx! THEN
217.         SWAP mn!, mx!
218.     END IF
219.     p5random! = RND * (mx! - mn!) + mn!
220. END FUNCTION
221.  

 

[bplus]

@Ashish,

Cool! but can you use this very code (with slight mod) to fill a big triangle with triangles and maybe squares pentagons, hexagons.... but at least triangles?