Text Only | Text with Attachments

QB64.org Forum

Active Forums => Programs => Topic started by: Ashish on April 28, 2020, 07:42:44 am

Title: Space Filling with Polygons
Post by: Ashish on April 28, 2020, 07:42:44 am
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.  
  5. TYPE XY
  6.     x AS SINGLE
  7.     y AS SINGLE
  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
  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)))
  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
  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
  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)
  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
  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))
  172.  
  173. 'taken from p5js.bas
  174. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
  175.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
  177.  
  178. FUNCTION p5random! (mn!, mx!)
  179.     IF mn! > mx! THEN
  180.         SWAP mn!, mx!
  181.     END IF
  182.     p5random! = RND * (mx! - mn!) + mn!
  184.  

 [ This attachment cannot be displayed inline in 'Print Page' view ]  
Program output for the input value of 3, i.e. for a triangle.
Title: Re: Space Filling with Polygons
Post by: Dav on April 28, 2020, 09:11:42 am
Nice one, Ashish!

- Dav
Title: Re: Space Filling with Polygons
Post by: FellippeHeitor on April 28, 2020, 09:18:35 am
Doritos!
Title: Re: Space Filling with Polygons
Post by: TerryRitchie on April 28, 2020, 11:19:32 am
Nacho cheese, please.
Title: Re: Space Filling with Polygons
Post by: bplus on April 28, 2020, 12:22:06 pm
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.
Title: Re: Space Filling with Polygons
Post by: TempodiBasic on April 28, 2020, 07:33:03 pm
Hi Ashish
what fine colors in this geometric application!
Cool!  [ This attachment cannot be displayed inline in 'Print Page' view ]  
Title: Re: Space Filling with Polygons
Post by: Ashish on April 28, 2020, 11:24:04 pm
@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.  
  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
  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
  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
  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
  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)))
  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
  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)
  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
  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))
  198.  
  199. 'taken from p5js.bas
  200. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
  201.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
  203.  
  204. FUNCTION p5random! (mn!, mx!)
  205.     IF mn! > mx! THEN
  206.         SWAP mn!, mx!
  207.     END IF
  208.     p5random! = RND * (mx! - mn!) + mn!
  210.  

 [ This attachment cannot be displayed inline in 'Print Page' view ]  
Title: Re: Space Filling with Polygons
Post by: bplus on April 29, 2020, 11:43:03 am
Cool!

@Ashish, if you try squares maybe you could put images in them? Wouldn't that make things interesting?
Title: Re: Space Filling with Polygons
Post by: Pete on April 29, 2020, 04:48:29 pm
Quote from: FellippeHeitor on April 28, 2020, 09:18:35 am
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
Title: Re: Space Filling with Polygons
Post by: bplus on April 29, 2020, 08:50:54 pm
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
  5. TYPE XY
  6.     x AS SINGLE
  7.     y AS SINGLE
  9.  
  10. _TITLE "Space Filling with Polygon"
  11. SCREEN _NEWIMAGE(800, 600, 32)
  12. _DELAY .25
  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
  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
  35. FOR y = 0 TO 600
  36.     midInk 0, 0, 255, 255, 255, 0, y / 600
  37.     LINE (0, y)-(800, y)
  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
  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)))
  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
  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
  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)
  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
  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))
  192.  
  193. 'taken from p5js.bas
  194. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
  195.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
  197.  
  198. FUNCTION p5random! (mn!, mx!)
  199.     IF mn! > mx! THEN
  200.         SWAP mn!, mx!
  201.     END IF
  202.     p5random! = RND * (mx! - mn!) + mn!
  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))
  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##)
  225.  
  226.  

 


and zip with bas, exe and png
Title: Re: Space Filling with Polygons
Post by: bplus on April 29, 2020, 09:55:32 pm
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
  6. TYPE XY
  7.     x AS SINGLE
  8.     y AS SINGLE
  10.  
  11. _TITLE "Space Filling with Polygon"
  12. SCREEN _NEWIMAGE(800, 600, 32)
  13. _DELAY .25
  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
  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
  44. FOR y = 0 TO 600
  45.     LINE (0, y)-(800, y), midInk(0, 0, 255, 255, 255, 0, y / 600)
  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
  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)))
  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&
  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
  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)
  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
  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))
  203.  
  204. 'taken from p5js.bas
  205. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
  206.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
  208.  
  209. FUNCTION p5random! (mn!, mx!)
  210.     IF mn! > mx! THEN
  211.         SWAP mn!, mx!
  212.     END IF
  213.     p5random! = RND * (mx! - mn!) + mn!
  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))
  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##)
  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
  251.  
  252.  

Same png as in zip above.
Title: Re: Space Filling with Polygons
Post by: Ashish on April 30, 2020, 08:41:14 am
@bplus
Cool! I liked your MOD!
Title: Re: Space Filling with Polygons
Post by: bplus on April 30, 2020, 11:40:56 am
@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.
Title: Re: Space Filling with Polygons
Post by: Ashish on April 30, 2020, 12:14:43 pm
@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.  
  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
  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
  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
  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
  116.  
  117. function insideCircle (p as gl_vertex_type, cx, cy, rad)
  118.     insideCircle = (sqr((cx-p.x)^2+(cy-p.y)^2)<=rad)
  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)))
  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
  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)
  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
  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))
  209.  
  210. 'taken from p5js.bas
  211. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
  212.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
  214.  
  215. FUNCTION p5random! (mn!, mx!)
  216.     IF mn! > mx! THEN
  217.         SWAP mn!, mx!
  218.     END IF
  219.     p5random! = RND * (mx! - mn!) + mn!
  221.  


  [ This attachment cannot be displayed inline in 'Print Page' view ]  
Title: Re: Space Filling with Polygons
Post by: bplus on April 30, 2020, 12:34:20 pm
@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?
Title: Re: Space Filling with Polygons
Post by: Ashish on May 01, 2020, 12:23:26 am
Quote from: bplus on April 30, 2020, 12:34:20 pm
@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?
Oh.. So this is what you mean @bplus . Ok
Here new MOD. Now, you need to specify the shape in which you are going to do space filling and then you have to specify the shape
which is to be used for filling the area.
That is, you can now have triangles inside Pentagon, or Squares in inside triangles, etc.

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


 [ This attachment cannot be displayed inline in 'Print Page' view ]  

Squares inside pentagon


  [ This attachment cannot be displayed inline in 'Print Page' view ]  

Pentagons inside triangle
Title: Re: Space Filling with Polygons
Post by: bplus on May 01, 2020, 02:48:24 am
@Ashish,

Nailed it! :)
Title: Re: Space Filling with Polygons
Post by: _vince on May 01, 2020, 06:35:48 am
Nice pattern guys ;-) ;-)

Here is my experiment
Code: [Select]
defdbl a-z
const sw = 1024
const sh = 768
pi = 4*atn(1)

screen _newimage(sw, sh, 32)
line (0,0)-(sw,sh),_rgb(0,0,0),bf

a = sh
bplus sw/2, sh/2, a, 0, _rgb(50,0,0), _rgb(0,0,0)
c = 1.5
n = 7
for i=2 to n
        a = sh/(i^(c*c))
        for j=0 to 2000
                x = sw/2 - a*(i^(c*c))/2 + a*(i^(c*c))*rnd
                y = sh/2 - a*(i^(c*c))/2 + a*(i^(c*c))*rnd
                rot = 2*pi*rnd'*(i - 1)
                bplus x, y, a, rot, _rgb(50 + (i-1)*205/n,0,0), _rgb(50,0,0)
        next
next

sleep
system

sub bplus (x0, y0, a, rot, cc as _integer64, cp as _integer64)
        p = 50/400
        q = 20/400

        dim img as long
        img = _newimage(a, a, 32)

        _dest img
        line (0,0)-(a,a),cp,bf
        for y=0 to a - 1
        for x=0 to a - 1
                if (((x + p*a)^2 + (y - a/2)^2) > a*a*(q + 0.5)^2) and (((x - a - p*a)^2 + (y - a/2)^2) > a*a*(q + 0.5)^2) or (((y + p*a)^2 + (x - a/2)^2) > a*a*(q + 0.5)^2) and (((y - a - p*a)^2 + (x - a/2)^2) > a*a*(q + 0.5)^2) then pset (x, y), cc
        next
        next

        dim tl as long, tr as long, bl as long, br as long
        dim r as integer, g as integer, b as integer

        yes = 1
        a2 = a*(sqr(2) - 0.5)
        _dest 0
        for y=-a2 to a + a2
        for x=-a2 to a + a2
                xx = (x - a/2)*cos(rot) - (y - a/2)*sin(rot) + a/2
                yy = (x - a/2)*sin(rot) + (y - a/2)*cos(rot) + a/2

                if (xx >= 0 and xx < a-1 and yy >= 0 and yy < a-1) then
                        _source img
                        if point (xx, yy) <> cp then
                                _source 0
                                if point(x0 - a/2 + x, y0 - a/2 + y) <> cp then yes = 0
                        end if
                end if
        next
        next

        if yes then
                _dest 0
                for y=-a2 to a + a2
                for x=-a2 to a + a2
                        xx = (x - a/2)*cos(rot) - (y - a/2)*sin(rot) + a/2
                        yy = (x - a/2)*sin(rot) + (y - a/2)*cos(rot) + a/2

                        if (xx >= 0 and xx < a-1 and yy >= 0 and yy < a-1) then
                                _source img
                                if int(xx) > a-1 or int(yy) > a-1 then tl = cp else tl = point(int(xx), int(yy))
                                if int(xx) > a-1 or int(yy) > a-1 or int(xx)+1 > a-1 then tr = cp else tr = point(int(xx) + 1, int(yy))
                                if int(xx) > a-1 or int(yy) > a-1 or int(yy)+1 > a-1 then bl = cp else bl = point(int(xx), int(yy) + 1)
                                if int(xx) > a-1 or int(yy) > a-1 or int(xx)+1 > a-1 or int(yy)+1 > a-1 then br = cp else br = point(int(xx) + 1, int(yy) + 1)

                                dx = xx - int(xx)
                                dy = yy - int(yy)

                                r = _round((1 - dy)*((1 - dx)*  _red(tl) + dx*  _red(tr)) + dy*((1 - dx)*  _red(bl) + dx*  _red(br)))
                                g = _round((1 - dy)*((1 - dx)*_green(tl) + dx*_green(tr)) + dy*((1 - dx)*_green(bl) + dx*_green(br)))
                                b = _round((1 - dy)*((1 - dx)* _blue(tl) + dx* _blue(tr)) + dy*((1 - dx)* _blue(bl) + dx* _blue(br)))

                                if point (xx, yy) <> cp then pset (x0 - a/2 + x, y0 - a/2 + y), _rgb(r,g,b)
                        end if
                next
                next
        end if

        _freeimage img
end sub
Title: Re: Space Filling with Polygons
Post by: Ashish on May 01, 2020, 08:52:12 am
Hi _vince, that screenshots is awesome! :D
But, your program is running slowly. Is this my PC fault or your program do lot of calculations?
Title: Re: Space Filling with Polygons
Post by: _vince on May 01, 2020, 09:09:00 am
It's not really optimized, it does pixel by pixel overlap detection.  I let it run and came back an hour later for a slightly bigger picture but not as pretty as I was hoping

Text Only | Text with Attachments