sketch-a-day/sketches/daily/y2026_m03/d21/__main__.py at 2026 · ericof/sketch-a-day · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
"""2026-03-21
Esfera de Retalhos 02
Esfera formada por folhas orgânicas de cores diversas
ericof.com
png
Sketch,py5,CreativeCoding
"""

from collections import deque
from dataclasses import dataclass
from sketches.utils.draw import canvas
from sketches.utils.draw.cores.paletas import gera_paleta
from sketches.utils.draw.cores.paletas import lista_paletas
from sketches.utils.draw.esfera import pontos_esfera
from sketches.utils.helpers import sketches as helpers

import numpy as np
import py5


sketch = helpers.info_for_sketch(__file__, __doc__)

cor_fundo = py5.color(0)

z_factor = 0.02

paletas = [
    gera_paleta(name, True) for name in lista_paletas() if name.startswith("op-")
]


@dataclass
class EsferaRotacao:
    x: float = -15
    y: float = 45
    z: float = 0
    dist_z: float = -2000


rotacao = EsferaRotacao()


def calcula_coordenadas(xb: float, yb: float, zb: float) -> tuple[float, float, float]:
    mult = py5.random(1 - z_factor, 1 + z_factor)
    return xb, yb, zb * mult


def calcula_vetores_largura(pontos: np.ndarray) -> np.ndarray:
    """Calcula vetores perpendiculares à espinha de cada folha e à superfície da esfera.

    O vetor resultante aponta "para o lado" de cada ponto, garantindo espessura
    3D independente da posição na esfera (equador, polo, etc).
    """
    total = len(pontos)
    vetores = np.empty_like(pontos)
    for i in range(total):
        # espinha local: direção ao longo da sequência de pontos
        espinha = pontos[(i + 1) % total] - pontos[(i - 1) % total]
        # produto vetorial com o vetor radial (normal à superfície da esfera)
        w = np.cross(espinha, pontos[i])
        norm = np.linalg.norm(w)
        vetores[i] = w / norm if norm > 1e-6 else np.array([0.0, 0.0, 1.0])
    return vetores


def criar_forma(pontos, local_paletas, largura: float = 10) -> py5.Py5Shape:
    """Cria a forma composta por folhas orgânicas sobre a esfera."""
    pts = np.array(pontos)
    # vetores de largura pré-calculados por ponto — garante conexão
    # entre folhas adjacentes
    vetores = calcula_vetores_largura(pts) * largura
    forma = py5.create_shape(py5.GROUP)
    total = len(pts)
    for idx in range(0, total, 2):
        i1, im, i2 = idx % total, (idx + 1) % total, (idx + 2) % total
        p1, wv1 = pts[i1], vetores[i1]
        pm, wvm = pts[im], vetores[im]
        p2, wv2 = pts[i2], vetores[i2]

        paleta = local_paletas[0]
        cor_borda = paleta[0]
        paleta.rotate()
        cor_preench = paleta[0]

        folha = py5.create_shape()
        with folha.begin_closed_shape():
            # borda frontal: p1 → p2 curvando por pm (offset positivo)
            folha.vertex(*(p1 + wv1))
            folha.quadratic_vertex(*(pm + wvm), *(p2 + wv2))
            # borda traseira: p2 → p1 curvando por pm (offset negativo)
            folha.vertex(*(p2 - wv2))
            folha.quadratic_vertex(*(pm - wvm), *(p1 - wv1))
        folha.set_stroke(cor_borda)
        folha.set_fill(cor_preench)
        forma.add_child(folha)
        local_paletas.rotate()
    return forma


def setup():
    global forma
    py5.size(*helpers.DIMENSOES.external, py5.P3D)
    pontos = pontos_esfera(800, 200)
    local_paletas = deque(paletas[:])
    forma = criar_forma(pontos, local_paletas, largura=50)


def draw():
    py5.background(cor_fundo)
    with py5.push():
        py5.translate(*helpers.DIMENSOES.centro, rotacao.dist_z)
        py5.rotate_y(py5.radians(rotacao.y))
        py5.rotate_x(py5.radians(rotacao.x))
        py5.rotate_z(py5.radians(rotacao.z))
        py5.shape(forma)

    # Créditos e encerramento
    canvas.sketch_frame(
        sketch,
        cor_fundo,
        "large_transparent_white",
        "transparent_white",
        version=2,
    )


def key_pressed():
    key = py5.key
    match py5.key:
        case " ":
            save_and_close()
        case "+":
            rotacao.dist_z += 50
        case "-":
            rotacao.dist_z -= 50
    match py5.key_code:
        case py5.UP:
            rotacao.x += 3
        case py5.DOWN:
            rotacao.x -= 3
        case py5.LEFT:
            rotacao.y += 3
        case py5.RIGHT:
            rotacao.y -= 3
    if key == " ":
        save_and_close()


def save_and_close():
    py5.no_loop()
    canvas.save_sketch_image(sketch)
    py5.exit_sketch()


if __name__ == "__main__":
    py5.run_sketch()