28

2019/sketch_190227a/sketch_190227a.pyde

@@ -76,8 +76,8 @@ def keyPressed():
         make_nodes_point(desenho_atual)
     if key == 'n':
         novo_desenho(desenho_atual)
-    if key == ' ':
-        background(200)
+    if key == 'p':
+        saveFrame(SKETCH_NAME+".png")
 
 
 def novo_desenho(desenho):
@@ -125,6 +125,7 @@ def make_nodes_point(desenho):
         n0.points_to.append(n2)
 
 def desenho_plot(d):
+    noStroke()
     for node in d:
         p1, p2 = node.points_to  # se estiver apontando para alguém
         with pushMatrix():

2019/sketch_190228a/arcs.py

@@ -0,0 +1,165 @@
+# -*- coding: utf-8 -*-
+
+ROTATION = {0: 0,
+            BOTTOM: 0,
+            DOWN: 0,
+            1: HALF_PI,
+            LEFT: HALF_PI,
+            2: PI,
+            TOP: PI,
+            UP: PI,
+            3: PI + HALF_PI,
+            RIGHT: PI + HALF_PI,
+            BOTTOM + RIGHT: 0,
+            DOWN + RIGHT: 0,
+            DOWN + LEFT: HALF_PI,
+            BOTTOM + LEFT: HALF_PI,
+            TOP + LEFT: PI,
+            UP + LEFT: PI,
+            TOP + RIGHT: PI + HALF_PI,
+            UP + RIGHT: PI + HALF_PI,
+            }
+
+def quarter_circle(x, y, radius, quadrant):
+    circle_arc(x, y, radius, ROTATION[quadrant], HALF_PI)
+
+def half_circle(x, y, radius, quadrant):
+    circle_arc(x, y, radius, ROTATION[quadrant], PI)
+
+def circle_arc(x, y, radius, start_ang, sweep_ang):
+    arc(x, y, radius * 2, radius * 2, start_ang, start_ang + sweep_ang)
+
+def poly_arc(x, y, radius, start_ang, sweep_ang, num_points=2):
+    angle = sweep_ang / int(num_points)
+    a = start_ang
+    with beginShape():
+        while a <= start_ang + sweep_ang:
+            sx = x + cos(a) * radius
+            sy = y + sin(a) * radius
+            vertex(sx, sy)
+            a += angle
+
+def arc_poly(x, y, d, _, start_ang, end_ang, num_points=5):
+    sweep_ang = end_ang - start_ang
+    angle = sweep_ang / int(num_points)
+    a = start_ang
+    with beginShape():
+        while a <= end_ang:
+            sx = x + cos(a) * d / 2
+            sy = y + sin(a) * d / 2
+            vertex(sx, sy)
+            a += angle
+
+def poly_rounded2(p_list, r_list):
+    """
+    draws a 'filleted' polygon with variable radius
+    dependent on roundedCorner()
+    """
+    with pushStyle():
+        noStroke()
+        beginShape()
+        for p0, p1 in zip(p_list, [p_list[-1]] + p_list[:-1]):
+            m = (PVector(p0.x, p0.y) + PVector(p1.x, p1.y)) / 2
+            vertex(m.x, m.y)
+        endShape(CLOSE)
+    for p0, p1, p2, r in zip(p_list,
+                             [p_list[-1]] + p_list[:-1],
+                             [p_list[-2]] + [p_list[-1]] + p_list[:-2],
+                             [r_list[-1]] + r_list[:-1]
+                             ):
+        m1 = (PVector(p0.x, p0.y) + PVector(p1.x, p1.y)) / 2
+        m2 = (PVector(p2.x, p2.y) + PVector(p1.x, p1.y)) / 2
+        roundedCorner(p1, m1, m2, r)
+
+
+def roundedCorner(pc, p1, p2, r):
+    """
+    Based on Stackoverflow C# rounded corner post 
+    https://stackoverflow.com/questions/24771828/algorithm-for-creating-rounded-corners-in-a-polygon
+    """
+    # Vector 1
+    dx1 = pc.x - p1.x
+    dy1 = pc.y - p1.y
+
+    # Vector 2
+    dx2 = pc.x - p2.x
+    dy2 = pc.y - p2.y
+
+    # Angle between vector 1 and vector 2 divided by 2
+    angle = (atan2(dy1, dx1) - atan2(dy2, dx2)) / 2
+
+    # The length of segment between angular point and the
+    # points of intersection with the circle of a given radius
+    tng = abs(tan(angle))
+    segment = r / tng if tng != 0 else r
+
+    # Check the segment
+    length1 = GetLength(dx1, dy1)
+    length2 = GetLength(dx2, dy2)
+
+    min_len = min(length1, length2)
+
+    if segment > min_len:
+        segment = min_len
+        max_r = min_len * abs(tan(angle))
+    else:
+        max_r = r
+
+    # Points of intersection are calculated by the proportion between
+    # the coordinates of the vector, length of vector and the length of the
+    # segment.
+    p1Cross = GetProportionPoint(pc, segment, length1, dx1, dy1)
+    p2Cross = GetProportionPoint(pc, segment, length2, dx2, dy2)
+
+    # Calculation of the coordinates of the circle
+    # center by the addition of angular vectors.
+    dx = pc.x * 2 - p1Cross.x - p2Cross.x
+    dy = pc.y * 2 - p1Cross.y - p2Cross.y
+
+    L = GetLength(dx, dy)
+    d = GetLength(segment, max_r)
+
+    circlePoint = GetProportionPoint(pc, d, L, dx, dy)
+
+    # StartAngle and EndAngle of arc
+    startAngle = atan2(p1Cross.y - circlePoint.y, p1Cross.x - circlePoint.x)
+    endAngle = atan2(p2Cross.y - circlePoint.y, p2Cross.x - circlePoint.x)
+
+    # Sweep angle
+    sweepAngle = endAngle - startAngle
+
+    # Some additional checks
+    if sweepAngle < 0:
+        startAngle, endAngle = endAngle, startAngle
+        sweepAngle = -sweepAngle
+
+    if sweepAngle > PI:
+        startAngle, endAngle = endAngle, startAngle
+        sweepAngle = TWO_PI - sweepAngle
+
+    # Draw result using graphics
+    # noStroke()
+    with pushStyle():
+        noStroke()
+        beginShape()
+        vertex(p1.x, p1.y)
+        vertex(p1Cross.x, p1Cross.y)
+        vertex(p2Cross.x, p2Cross.y)
+        vertex(p2.x, p2.y)
+        endShape(CLOSE)
+
+    line(p1.x, p1.y, p1Cross.x, p1Cross.y)
+    line(p2.x, p2.y, p2Cross.x, p2Cross.y)
+    arc(circlePoint.x, circlePoint.y, 2 * max_r, 2 * max_r,
+        startAngle, startAngle + sweepAngle, OPEN)
+
+def GetLength(dx, dy):
+    return sqrt(dx * dx + dy * dy)
+
+def GetProportionPoint(pt, segment, L, dx, dy):
+    # factor = segment / L if L != 0 else 0
+    factor = float(segment) / L if L != 0 else segment
+    return PVector(
+        (pt.x - dx * factor),
+
+        (pt.y - dy * factor))

2019/sketch_190228a/gif_exporter.py

@@ -0,0 +1,40 @@
+"""
+Alexandre B A Villares http://abav.lugaralgum.com - GPL v3 
+
+A helper for the Processing gifAnimation library https://github.com/extrapixel/gif-animation/tree/3.0
+Download from https://github.com/villares/processing-play/blob/master/export_GIF/unzip_and_move_to_libraries_GifAnimation.zip
+This helper was inspired by an example by Art Simon https://github.com/APCSPrinciples/AnimatedGIF/
+
+# add at the start of your sketch:
+  add_library('gifAnimation')
+  from gif_exporter import gif_export
+# add at the end of draw():
+  gif_export(GifMaker)
+"""
+
+def gif_export(GifMaker,             # gets a reference to the library
+               filename="exported",  # .gif will be added
+               repeat=0,             # 0 makes it an "endless" animation
+               quality=255,          # quality range 0 - 255
+               delay=1200,            # this is quick
+               frames=0,             # 0 will stop on keyPressed or frameCount >= 100000
+               finish=False):        # force stop
+    global gifExporter
+    try:
+        gifExporter
+    except NameError:
+        gifExporter = GifMaker(this, filename + ".gif")
+        gifExporter.setRepeat(repeat)
+        gifExporter.setQuality(quality)
+        gifExporter.setDelay(delay)
+        
+    gifExporter.addFrame()
+
+    if frames == 0:
+       if keyPressed and key == "e":
+           finish = True
+                
+    if finish:
+        gifExporter.finish()
+        print("gif saved")
+        exit()

2019/sketch_190228a/sketch_190228a.pyde

@@ -0,0 +1,152 @@
+# Alexandre B A Villares - https://abav.lugaralgum.com/sketch-a-day
+SKETCH_NAME, OUTPUT = "sketch_190228a", ".gif"
+"""
+Fixed the transition thing
+"""
+from collections import namedtuple
+import random as rnd
+import copy as cp
+from gif_exporter import gif_export
+from arcs import poly_rounded2
+add_library('peasycam')
+add_library('GifAnimation')
+
+X_LIST, Y_LIST = [], []  # listas de posições para elementos
+desenho_atual, outro_desenho, desenho_inter, desenho_inicial = [], [], [], []
+
+SPACING, MARGIN = 100, 0
+MAX_S = 2 
+LEVELS = 5
+NUM_NODES = 20  # número de elementos do desenho / number of nodes
+Node = namedtuple('Node', 'x y radius_size points_to')
+radius_modifier = 10
+end_mode = False
+
+def setup():
+    smooth(16)
+    size(600, 600, P3D)
+    hint(DISABLE_DEPTH_TEST)
+    #blendMode(MULTIPLY)
+    colorMode(HSB)
+    cam = PeasyCam(this, 660)
+    X_LIST[:] = [x for x in range(MARGIN, 1 + width - MARGIN, SPACING)]
+    Y_LIST[:] = [y for y in range(MARGIN, 1 + height - MARGIN, SPACING)]
+    novo_desenho(desenho_atual)
+    desenho_inicial[:] = cp.deepcopy(desenho_atual)
+
+def draw():
+    global radius_modifier, desenho_atual, outro_desenho, end_mode
+    #ortho()
+    #rotateX(HALF_PI / 2)
+    translate(-width / 2, -height / 2, - 120) # + 150)
+    background(200)
+    fc = frameCount % 100 - 50
+    if fc < 0:
+        desenho = desenho_atual
+    elif 0 <= fc < 49:
+        make_inter_nodes(map(fc, 0, 50, 0, 1))
+        desenho = desenho_inter
+    elif fc == 49:
+        desenho_atual, outro_desenho = outro_desenho, desenho_atual
+        desenho = desenho_atual
+        if end_mode: exit()
+        if not mousePressed:
+            make_nodes_point(outro_desenho)
+        else:
+            print("will reset")
+            end_mode = True
+            outro_desenho[:] = cp.deepcopy(desenho_inicial)
+
+    desenho_plot(desenho)
+    # if frameCount % 4 == 0:
+    #      gif_export(GifMaker, filename=SKETCH_NAME, delay=200)
+    
+def desenho_plot(d):
+    #noStroke()
+    for node in d:
+        p1, p2 = node.points_to  # se estiver apontando para alguém
+        with pushMatrix():
+            for i in range(LEVELS):
+                fill(128 + i * 16, 255, 255, 64) #164 + i * 8,, 255, 255, 64)
+                translate(0, 0, 48)
+                rs = [(node.radius_size + i * radius_modifier),
+                      (p1.radius_size + i * radius_modifier),
+                      (p2.radius_size + i * radius_modifier), ]
+                poly_rounded2([node, p1, p2], rs)
+
+def keyPressed():
+    if key == 'g':
+        gif_export(GifMaker, filename=SKETCH_NAME)
+    if key == 'r':
+        make_nodes_point(desenho_atual)
+    if key == 'n':
+        novo_desenho(desenho_atual)
+    if key == 'p':
+        saveFrame(SKETCH_NAME+".png")
+
+def novo_desenho(desenho):
+    """
+    Esvazia a lista elementos do desenho anterior e cria um novo
+    """
+    desenho[:] = []
+    for X in X_LIST:
+        for Y in Y_LIST:
+            desenho.append(Node(X, Y, rnd.choice([2, 4, 6]), []))
+    make_nodes_point(desenho)
+    outro_desenho[:] = cp.deepcopy(desenho)
+    make_nodes_point(outro_desenho)
+
+
+def new_node(base=None):
+    if not base:
+        return Node(                   # elemento/"nó" uma namedtuple com:
+            rnd.choice(X_LIST),        # x
+            rnd.choice(Y_LIST),        # y
+            10,
+            #rnd.choice([0, 0, 0, 0, 100]),     # radius_size
+            []  # points_to... (lista com ref. a outro elem.))
+        )
+    else:
+        n =  new_node()
+        while dist(n.x, n.y, base.x, base.y) > MAX_S * SPACING:
+            n =  new_node()
+        return n
+
+def make_nodes_point(desenho):
+    # AREA = (x1y2 + x2y3 + x3y1 – x1y3 – x2y1 – x3y2)/2.
+    # x₁ (y₂ - y₃) + x₂ (y₃ - y₁) + x₃ (y₁ - y₂) == 0
+    for n0 in desenho:  # para cada elemento do desenho
+        n1, n2 = new_node(n0), new_node(n0)
+        while (n1.x * (n2.y - n0.y) +
+               n2.x * (n0.y - n1.y) +
+               n0.x * (n1.y - n2.y) == 0):
+            # if the points are colinear, choose new nodes
+            n1, n2 = new_node(n0), new_node(n0)
+        n0.points_to[:] = []
+        n0.points_to.append(n1)
+        n0.points_to.append(n2)
+
+
+def make_inter_nodes(amt):
+    desenho_inter[:] = []
+    for n1, n2 in zip(desenho_atual, outro_desenho):
+        desenho_inter.append(Node(                   # elemento/"nó" uma namedtuple com:
+            n1.x,        # x
+            n1.y,        # y
+            n1.radius_size,   # radius_size
+            # cp.deepcopy(n1.points_to)
+            [Node(lerp(p1.x, p2.x, amt),
+                  lerp(p1.y, p2.y, amt),
+                  lerp(p1.radius_size, p2.radius_size, amt), [])
+             for p1, p2 in zip(n1.points_to, n2.points_to)]
+        ))
+
+# print text to add to the project's README.md
+def settings():
+    println(
+        """
+![{0}](2019/{0}/{0}{1})
+
+[{0}](https://github.com/villares/sketch-a-day/tree/master/2019/{0}) [[Py.Processing](https://villares.github.io/como-instalar-o-processing-modo-python/index-EN)]
+""".format(SKETCH_NAME, OUTPUT)
+    )

README.md

@@ -22,6 +22,11 @@ Get updates from my sort-of-weekly newsletter: [[sketch-mail](https://tinyletter
 
 ## 2019
 
+---
+
+![sketch_190228a](2019/sketch_190228a/sketch_190228a.gif)
+
+[sketch_190228a](https://github.com/villares/sketch-a-day/tree/master/2019/sketch_190228a) [[Py.Processing](https://villares.github.io/como-instalar-o-processing-modo-python/index-EN)]
 
 ---