__main__.py

"""2026-03-02
Recursive Division 03
Desenho de subdivisões recursivas a partir de um quadrilátero
ericof.com|https://openprocessing.org/sketch/1307209
png
Sketch,py5,CreativeCoding
"""

from dataclasses import dataclass
from sketches.utils.draw import canvas
from sketches.utils.draw import vetores as vh
from sketches.utils.draw.cores.paletas import gera_paleta
from sketches.utils.helpers import sketches as helpers

import numpy as np
import py5


sketch = helpers.info_for_sketch(__file__, __doc__)


@dataclass
class Limites:
    """Limites do quadrilátero."""

    v1: np.ndarray
    v2: np.ndarray
    v3: np.ndarray
    v4: np.ndarray


cor_fundo_base = py5.color(0)
# Variáveis globais
limites: Limites | None = None
paleta = gera_paleta("Navy-Orange")
largura_canvas, altura_canvas = helpers.DIMENSOES.internal
lado_menor = min(largura_canvas, altura_canvas)
largura_fundo = lado_menor
largura_minima = largura_fundo * 0.95
meia_largura_minima = largura_minima / 2
raio2_minimo = meia_largura_minima * meia_largura_minima

cor_fundo = None


class CelulaRecursiva:
    """Objeto recursivo que subdivide quadrilátero e desenha contornos arredondados."""

    contador: int
    numero_divisoes_atual: int
    limite_divisoes: int
    divisoes: int
    razao_folga: float
    subobjetos: list["CelulaRecursiva"]
    amplitude_deslocamento: float
    cor: int
    limite: Limites
    direcao_divisao: str
    semente_ruido: float
    velocidade_ruido: float
    frequencia: float
    min_ruido: float
    max_ruido: float
    intervalo_ruido: float
    exibir_sub: list[bool]
    obj_id: str

    def __init__(
        self,
        numero_divisoes_atual: int,
        limite: Limites,
        obj_id: str,
        divisoes: int = 20,
        limite_divisoes: int = 15,
        razao_folga: float = 0.75,
        amplitude_divisor: float = 800,
    ):
        """Cria uma instância e possivelmente a subdivide em dois subobjetos."""
        self.obj_id = obj_id
        self.contador = 0
        self.numero_divisoes_atual = numero_divisoes_atual
        self.limite_divisoes = limite_divisoes
        self.razao_folga = razao_folga
        self.divisoes = divisoes
        self.subobjetos: list[CelulaRecursiva] = []

        self.amplitude_deslocamento = largura_minima / amplitude_divisor
        self.cor = py5.color(py5.random_choice(paleta))

        probabilidade_divisao = 1.0
        e_primeiro = self.numero_divisoes_atual == 1
        pode_dividir = self.numero_divisoes_atual < self.limite_divisoes
        sorteou = py5.random(1) < probabilidade_divisao

        self.limite = limite

        if (pode_dividir and sorteou) or e_primeiro:
            self.dividir_objeto()

    def dividir_objeto(self) -> None:
        """Define direção e parâmetros de ruído e cria dois subobjetos."""
        self.direcao_divisao = "vertical" if py5.random(1) < 0.5 else "horizontal"

        self.semente_ruido = float(py5.random(1000))
        self.velocidade_ruido = 0.0015
        self.frequencia = 6
        self.min_ruido = 0.2
        self.max_ruido = 0.8
        self.intervalo_ruido = self.max_ruido - self.min_ruido
        self.contador = 0

        proximo = self.numero_divisoes_atual + 1
        self.subobjetos = [
            CelulaRecursiva(proximo, limite=self.limite, obj_id=f"{self.obj_id}/0"),
            CelulaRecursiva(proximo, limite=self.limite, obj_id=f"{self.obj_id}/1"),
        ]

    def atualizar(
        self,
        limite: Limites,
    ) -> None:
        """Atualiza cantos e repassa para subobjetos (se existirem)."""
        self.limite = limite

        self.exibir_sub = [True, True]

        if self.subobjetos:
            passo = self.velocidade_ruido * self.contador
            ruido_base = py5.noise(self.semente_ruido + passo)
            ang = py5.TAU * self.frequencia * ruido_base
            seno = py5.sin(ang)
            metade_intervalo = self.intervalo_ruido / 2
            valor_ruido = float((seno + 1) * metade_intervalo + self.min_ruido)
            func = (
                self._atualizar_vertical
                if self.direcao_divisao == "vertical"
                else self._atualizar_horizontal
            )
            func(self.limite, valor_ruido)

        self.contador += 1

    def _atualizar_vertical(
        self,
        limite_base: Limites,
        valor_ruido: float,
    ) -> None:
        """Atualiza subdivisão vertical."""
        limite = Limites(
            limite_base.v1,
            vh.interpolar_vetor(limite_base.v1, limite_base.v2, valor_ruido),
            vh.interpolar_vetor(limite_base.v4, limite_base.v3, valor_ruido),
            limite_base.v4,
        )

        r1 = self.redimensionar_objeto_deslocamento_fixo(
            limite, self.amplitude_deslocamento
        )
        self.exibir_sub[0] = r1[1]
        if self.exibir_sub[0]:
            self.subobjetos[0].atualizar(limite)

        limite2 = Limites(
            limite.v2,
            limite_base.v2,
            limite_base.v3,
            limite.v3,
        )

        r2 = self.redimensionar_objeto_deslocamento_fixo(
            limite2, self.amplitude_deslocamento
        )
        self.exibir_sub[1] = r2[1]
        if self.exibir_sub[1]:
            self.subobjetos[1].atualizar(limite2)

    def _atualizar_horizontal(
        self,
        limite_base: Limites,
        valor_ruido: float,
    ) -> None:
        """Atualiza subdivisão horizontal."""
        limite = Limites(
            limite_base.v1,
            limite_base.v2,
            vh.interpolar_vetor(limite_base.v2, limite_base.v3, valor_ruido),
            vh.interpolar_vetor(limite_base.v1, limite_base.v4, valor_ruido),
        )

        r1 = self.redimensionar_objeto_deslocamento_fixo(
            limite, self.amplitude_deslocamento
        )
        self.exibir_sub[0] = r1[1]
        if self.exibir_sub[0]:
            self.subobjetos[0].atualizar(limite)

        limite2 = Limites(
            limite.v4,
            limite.v3,
            limite_base.v3,
            limite_base.v4,
        )

        r2 = self.redimensionar_objeto_deslocamento_fixo(
            limite2, self.amplitude_deslocamento
        )
        self.exibir_sub[1] = r2[1]
        if self.exibir_sub[1]:
            self.subobjetos[1].atualizar(limite2)

    def desenhar(self) -> None:
        """Desenha o objeto e recursivamente os subobjetos visíveis."""
        py5.fill(self.cor)
        print(f"- Desenhando {self.obj_id} e {self.numero_divisoes_atual}")
        if self.verificar_desenho():
            self.desenhar_linha_externa()

        if self.subobjetos:
            if self.exibir_sub[0]:
                self.subobjetos[0].desenhar()
            if self.exibir_sub[1]:
                self.subobjetos[1].desenhar()

    def verificar_desenho(self) -> bool:
        """True se os 4 cantos estiverem dentro do círculo (usa dist²)."""
        v1x, v1y = self.limite.v1
        v2x, v2y = self.limite.v2
        v3x, v3y = self.limite.v3
        v4x, v4y = self.limite.v4

        d1 = v1x * v1x + v1y * v1y
        d2 = v2x * v2x + v2y * v2y
        d3 = v3x * v3x + v3y * v3y
        d4 = v4x * v4x + v4y * v4y

        return (
            d1 < raio2_minimo
            and d2 < raio2_minimo
            and d3 < raio2_minimo
            and d4 < raio2_minimo
        )

    def redimensionar_objeto_deslocamento_fixo(
        self,
        limite_base: Limites,
        amplitude: float,
    ) -> tuple[Limites, bool]:
        """Desloca arestas e retorna [v1s, v2s, v3s, v4s, exibir]."""
        exibir = True

        v1: np.ndarray = limite_base.v1
        v2: np.ndarray = limite_base.v2
        v3: np.ndarray = limite_base.v3
        v4: np.ndarray = limite_base.v4

        n12 = vh.ajustar_magnitude(vh.normal_90(v2 - v1), amplitude)
        n23 = vh.ajustar_magnitude(vh.normal_90(v3 - v2), amplitude)
        n34 = vh.ajustar_magnitude(vh.normal_90(v4 - v3), amplitude)
        n41 = vh.ajustar_magnitude(vh.normal_90(v1 - v4), amplitude)

        v1_12 = v1 + n12
        v2_12 = v2 + n12

        v2_23 = v2 + n23
        v3_23 = v3 + n23

        v3_34 = v3 + n34
        v4_34 = v4 + n34

        v4_41 = v4 + n41
        v1_41 = v1 + n41

        limite = Limites(
            vh.calcular_cruzamento(v4_41, v1_41, v1_12, v2_12),
            vh.calcular_cruzamento(v1_12, v2_12, v2_23, v3_23),
            vh.calcular_cruzamento(v2_23, v3_23, v3_34, v4_34),
            vh.calcular_cruzamento(v3_34, v4_34, v4_41, v1_41),
        )

        if limite.v1[0] >= limite.v2[0] or limite.v1[1] >= limite.v4[1]:
            exibir = False
        return limite, exibir

    def desenhar_linha_externa(self) -> None:
        """Desenha o contorno externo arredondado."""
        v1, v2, v3, v4 = self.limite.v1, self.limite.v2, self.limite.v3, self.limite.v4
        parametros = (
            (v4, v1, v2),
            (v1, v2, v3),
            (v2, v3, v4),
            (v3, v4, v1),
        )
        z = py5.random_int(-20, 20)
        with py5.begin_shape():
            for v in parametros:
                pontos = self.calcular_canto_externo(*v)
                for x, y in pontos:
                    py5.vertex(float(x), float(y), z)

    def calcular_canto_externo(
        self,
        v1: np.ndarray,
        v2: np.ndarray,
        v3: np.ndarray,
    ) -> np.ndarray:
        """Gera pontos do arco externo no canto v2 (v1-v2-v3)."""
        deslocamento = self.amplitude_deslocamento * self.razao_folga

        centro21 = vh.ajustar_magnitude(vh.normal_90(v1 - v2), deslocamento)
        centro23 = vh.ajustar_magnitude(vh.normal_90(v2 - v3), deslocamento)

        # Ângulo entre vetores
        a = centro21
        b = centro23
        dot = float(a[0] * b[0] + a[1] * b[1])
        na = float(np.hypot(a[0], a[1]))
        nb = float(np.hypot(b[0], b[1]))
        cosang = dot / (na * nb)
        cosang = float(np.clip(cosang, -1.0, 1.0))
        ang_externo = float(np.arccos(cosang))

        divisoes = self.divisoes
        passo = ang_externo / divisoes

        # Rotações incrementais com matriz 2x2 (NumPy)
        c = float(np.cos(passo))
        s = float(np.sin(passo))
        rot = np.array([[c, -s], [s, c]], dtype=np.float64)

        pontos = np.empty((divisoes + 1, 2), dtype=np.float64)
        atual = centro21.copy()

        for i in range(divisoes + 1):
            pontos[i] = v2 + atual
            atual = rot @ atual

        return pontos


def criar_objeto_principal() -> CelulaRecursiva:
    """Cria o objeto principal."""
    global cor_fundo, limites

    limites = Limites(
        vh.criar_vetor(-meia_largura_minima, -meia_largura_minima),
        vh.criar_vetor(+meia_largura_minima, -meia_largura_minima),
        vh.criar_vetor(+meia_largura_minima, +meia_largura_minima),
        vh.criar_vetor(-meia_largura_minima, +meia_largura_minima),
    )

    paleta.append("#FFF4EC")
    cor_fundo = py5.color(py5.random_choice(paleta))
    objeto = CelulaRecursiva(numero_divisoes_atual=1, limite=limites, obj_id="0")
    objeto.atualizar(limites)
    return objeto


def setup():
    py5.size(*helpers.DIMENSOES.external, py5.P3D)
    py5.color_mode(py5.HSB, 360, 100, 100)
    py5.background(cor_fundo_base)
    principal = criar_objeto_principal()

    with py5.push():
        py5.translate(*helpers.DIMENSOES.centro)
        py5.stroke(cor_fundo_base)
        py5.stroke_weight(1)
        principal.desenhar()

    # Credits and go
    canvas.sketch_frame(
        sketch,
        cor_fundo_base,
        "large_transparent_white",
        "transparent_white",
        version=2,
    )


def key_pressed():
    key = py5.key
    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()