05

2019/sketch_190603a/b_polys.py

@@ -143,18 +143,18 @@ def b_roundedCorner(pc, p2, p1, r):
         A = True
         startAngle, endAngle = endAngle, startAngle
         sweepAngle = -sweepAngle
-        # ellipse(pc[0], pc[1], 15, 15)
+        ellipse(pc[0], pc[1], 15, 15)
 
     if sweepAngle > PI:
         B = True
         startAngle, endAngle = endAngle, startAngle
         sweepAngle = TWO_PI - sweepAngle
-        # ellipse(pc[0], pc[1], 25, 25)
+        ellipse(pc[0], pc[1], 25, 25)
 
     if (A and not B) or (B and not A):
         startAngle, endAngle = endAngle, startAngle
         sweepAngle = -sweepAngle
-        # ellipse(pc[0], pc[1], 5, 5)
+        ellipse(pc[0], pc[1], 5, 5)
 
     b_arc(circlePoint[0], circlePoint[1], 2 * max_r, 2 * max_r,
           startAngle, startAngle + sweepAngle, arc_type=2)

2019/sketch_190603a/sketch_190603a.pyde

@@ -18,9 +18,9 @@ def draw():
     stroke(0, 0, 0)
     noFill()
     if not keyPressed:
-        fill(0, 200, 0, 100) 
+        # fill(0, 200, 0, 100) 
         b_poly_arc_augmented(p_list, rad_list)
-        fill(0, 0, 200, 100)
+        # fill(0, 0, 200, 100)
         b_poly_filleted(p_list, rad_list)
     elif key == " ":
         poly_arc_augmented(p_list, rad_list)

2019/sketch_190605a/sketch_190605a.pyde

@@ -0,0 +1,87 @@
+# Alexandre B A Villares - https://abav.lugaralgum.com/sketch-a-day
+# More explorations of lines in grids
+
+from random import shuffle
+from itertools import product, combinations, permutations, combinations_with_replacement
+from var_bar import var_bar
+
+space, border = 40, 0
+position = 0  # initial position
+
+
+def setup():
+    global line_combos, W, H, position, num
+    size(820, 460)
+    frameRate(1)
+    rectMode(CENTER)
+    strokeWeight(2)
+    grid = product(range(-1, 1), repeat=2)  # 2X2
+    # all line combinations on a grid
+    lines = permutations(grid, 2)
+    # allow only some lines
+    possible_lines = []
+    for l in lines:
+        (x0, y0), (x1, y1) = l[0], l[1]
+        if dist(x0, y0, x1, y1) < 2:  # rule defined here...
+            possible_lines.append(l)
+    num_possible_lines = len(possible_lines)
+    println("Number of possible lines: {}".format(num_possible_lines))
+    # main stuff
+    line_combos = list(combinations(possible_lines, 3))
+    # shuffle(line_combos) # ucomment to shuffle!
+    num = len(line_combos)
+    println("Number of permutations: {}".format(num))
+    W = (width - border * 2) // space
+    H = (height - border * 2) // space
+    println("Cols: {} Rows: {} Visible grid: {}".format(W, H, W * H))
+
+
+def draw():
+    global position
+    background(240)
+    i = position
+    for y in range(H):
+        for x in range(W):
+            if i < len(line_combos):
+                pushMatrix()
+                # B option
+                # translate(border / 2 + space + space * x,
+                #           border / 2 + space + space * y)
+                translate(border + space + space * x,
+                          border + space + space * y)
+                draw_combo(i)
+                popMatrix()
+                i += 1
+    if i < len(line_combos):
+        # gif_export(GifMaker, SKETCH_NAME)
+        # gif_export(GifMaker, SKETCH_NAME[:-1] + "b") # B option
+        position += H * W
+
+def draw_combo(n):
+    colorMode(RGB)
+    blendMode(MULTIPLY)
+    siz = space / 2. # B option
+    for i, sl in enumerate(line_combos[n]):
+        colorMode(HSB)
+        fill(i * 64, 128, 128)
+        (x0, y0), (x1, y1) = sl[0], sl[1]
+        noStroke()
+        var_bar(x0 * siz, y0 * siz, x1 * siz, y1 * siz, siz / 8, siz / 4)
+
+def keyPressed():
+    global W, H
+    if key == "s":
+        saveFrame("####.png")
+
+def settings():
+    from os import path
+    global SKETCH_NAME
+    SKETCH_NAME = path.basename(sketchPath())
+    OUTPUT = ".png"
+    println(
+        """
+![{0}]({2}/{0}/{0}{1})
+
+[{0}](https://github.com/villares/sketch-a-day/tree/master/{2}/{0}) [[Py.Processing](https://villares.github.io/como-instalar-o-processing-modo-python/index-EN)]
+""".format(SKETCH_NAME, OUTPUT, year())
+    )

2019/sketch_190605a/var_bar.py

@@ -0,0 +1,100 @@
+def var_bar(p1x, p1y, p2x, p2y, r1, r2=None):
+    """
+    Tangent/tangent shape on 2 circles of arbitrary radius
+    """
+    if r2 is None:
+        r2 = r1
+    #line(p1x, p1y, p2x, p2y)
+    d = dist(p1x, p1y, p2x, p2y)
+    ri = r1 - r2
+    if d > abs(ri):
+        rid = (r1 - r2) / d
+        if rid > 1:
+            rid = 1
+        if rid < -1:
+            rid = -1
+        beta = asin(rid) + HALF_PI
+        with pushMatrix():
+            translate(p1x, p1y)
+            angle = atan2(p1x - p2x, p2y - p1y)
+            rotate(angle + HALF_PI)
+            x1 = cos(beta) * r1
+            y1 = sin(beta) * r1
+            x2 = cos(beta) * r2
+            y2 = sin(beta) * r2
+            #print((d, beta, ri, x1, y1, x2, y2))
+            beginShape()  
+            b_arc(0, 0, r1 * 2, r1 * 2,
+                -beta - PI, beta - PI, mode=2)
+            b_arc(d, 0, r2 * 2, r2 * 2,
+                beta - PI, PI - beta, mode=2)
+            endShape(CLOSE)
+
+    else:
+        ellipse(p1x, p1y, r1 * 2, r1 * 2)
+        ellipse(p2x, p2y, r2 * 2, r2 * 2)
+        
+def b_arc(cx, cy, w, h, start_angle, end_angle, mode=0):
+    """
+    A bezier approximation of an arc
+    using the same signature as the original Processing arc()
+    mode: 0 "normal" arc, using beginShape() and endShape()
+              1 "middle" used in recursive call of smaller arcs
+              2 "naked" like normal, but without beginShape() and endShape()
+                 for use inside a larger PShape
+    """
+    theta = end_angle - start_angle
+    # Compute raw Bezier coordinates.
+    if mode != 1 or theta < HALF_PI:
+        x0 = cos(theta / 2.0)
+        y0 = sin(theta / 2.0)
+        x3 = x0
+        y3 = 0 - y0
+        x1 = (4.0 - x0) / 3.0
+        if y0 != 0:
+            y1 = ((1.0 - x0) * (3.0 - x0)) / (3.0 * y0)  # y0 != 0...
+        else:
+            y1 = 0
+        x2 = x1
+        y2 = 0 - y1
+        # Compute rotationally-offset Bezier coordinates, using:
+        # x' = cos(angle) * x - sin(angle) * y
+        # y' = sin(angle) * x + cos(angle) * y
+        bezAng = start_angle + theta / 2.0
+        cBezAng = cos(bezAng)
+        sBezAng = sin(bezAng)
+        rx0 = cBezAng * x0 - sBezAng * y0
+        ry0 = sBezAng * x0 + cBezAng * y0
+        rx1 = cBezAng * x1 - sBezAng * y1
+        ry1 = sBezAng * x1 + cBezAng * y1
+        rx2 = cBezAng * x2 - sBezAng * y2
+        ry2 = sBezAng * x2 + cBezAng * y2
+        rx3 = cBezAng * x3 - sBezAng * y3
+        ry3 = sBezAng * x3 + cBezAng * y3
+        # Compute scaled and translated Bezier coordinates.
+        rx, ry = w / 2.0, h / 2.0
+        px0 = cx + rx * rx0
+        py0 = cy + ry * ry0
+        px1 = cx + rx * rx1
+        py1 = cy + ry * ry1
+        px2 = cx + rx * rx2
+        py2 = cy + ry * ry2
+        px3 = cx + rx * rx3
+        py3 = cy + ry * ry3
+        # Debug points... comment this out!
+        # stroke(0)
+        # ellipse(px3, py3, 15, 15)
+        # ellipse(px0, py0, 5, 5)
+    # Drawing
+    if mode == 0: # 'normal' arc (not 'middle' nor 'naked')
+        beginShape()
+    if mode != 1: # if not 'middle'
+        vertex(px3, py3)
+    if theta < HALF_PI:
+        bezierVertex(px2, py2, px1, py1, px0, py0)
+    else:
+        # to avoid distortion, break into 2 smaller arcs
+        b_arc(cx, cy, w, h, start_angle, end_angle - theta / 2.0, mode=1)
+        b_arc(cx, cy, w, h, start_angle + theta / 2.0, end_angle, mode=1)
+    if mode == 0: # end of a 'normal' arc
+        endShape()

README.md

@@ -24,10 +24,22 @@ Get updates from my sort-of-weekly newsletter: [[sketch-mail](https://villares.o
 
 ---
 
+![sketch_190605a](2019/sketch_190605a/sketch_190605a.png)
+
+[sketch_190605a](https://github.com/villares/sketch-a-day/tree/master/2019/sketch_190605a) [[Py.Processing](https://villares.github.io/como-instalar-o-processing-modo-python/index-EN)]
+
+Using new bars, with much better fill, thanks to my Bezier arc-aproximation.
+- Number of possible lines: 12
+- Number of combinations: 220
+
+---
+
 ![sketch_190604a](2019/sketch_190604a/sketch_190604a.png)
 
 [sketch_190604a](https://github.com/villares/sketch-a-day/tree/master/2019/sketch_190604a) [[Py.Processing](https://villares.github.io/como-instalar-o-processing-modo-python/index-EN)]
+4a.png)
 
+[sketch_190604a](https://github.com/villares/sketch-a-day/tree/master/2019/sketch_190604a) [[Py.Processing](https://villares.github.io/como-instalar-o-
 Did some cleanup of yesterday's code and updated my polygon aproximation of an arc, to use it with the filleted and arc-augmented polylines.
 
 ---