Helix Zome Kupola – Matematički Model i Implementacija

Helix Zome kupola je inovativna arhitektonska i strukturna konstrukcija zasnovana na principu duplih spirala, poznatih kao double helix. Ova kupola koristi spojene spiralne šipke koje tvore stabilnu i estetski privlačnu strukturu. Njena konstrukcija se zasniva na matematičkoj geometriji i sinusoidi, što omogućava precizno definisanje položaja svih elemenata i njihovu međusobnu povezanost.

Matematički Model Helix Zome Kupole

1. Parametri kupole

• n — broj parova duplih spirala (double helix) u kupoli
• d — prečnik kupole
• h — visina kupole
• v_s — vertikalni faktor rastezanja (stretch), u opsegu [1.0, 2.0]
• α ∈ [0, π] — parametar za poziciju duž spirale
• β = (2π / n) · i, gde je i = 0, 1, …, n − 1 — fazni pomeraj spirale

2. Koordinate tačaka na spirali

Koordinate tačke na jednoj spirali definisane su formulama:

$$
\begin{aligned}
x &= \sin(\alpha + \beta) \cdot \frac{d}{4} + \sin(\beta) \cdot \frac{d}{4} \\
y &= \cos(\alpha + \beta) \cdot \frac{d}{4} + \cos(\beta) \cdot \frac{d}{4} \\
z &= \frac{\alpha}{\pi} \cdot h
\end{aligned}
$$

Gde su:

• α — ugaoni parametar spirale u opsegu [0, π]
• β — fazni pomeraj svake spirale
• d — prečnik osnove kupole
• h — visina kupole

3. Ogledalo spirala (parovi spirala)

Da bi se dobio double helix efekat, svaka spirala ima svog „partnera“ koji je njeno ogledalo. Ovo se postiže inverzijom parametra α:

• Desna spirala: koristi α kao parametar.
• Leva spirala: koristi −α, što znači da je spirala okrenuta u suprotnom smeru.

Ovo simetrično okretanje omogućava stvaranje međusobno isprepletenih duplih spirala.

4. Dužina šipke (rib)

Dužina šipke između dva uzastopna čvora spirale aproksimira se formulom:

$$
\ell_{\text{rib}} = \sqrt{ \left( \frac{d \pi}{4} \right)^2 + h^2 }
$$

Ovo se može interpretirati kao Pitagorina teorema, gde:

• dπ / 4 — predstavlja horizontalnu komponentu spirale (deo kružnog luka)
• h — vertikalna komponenta

Implementacija: Analiza datog programa

1. Generisanje spirala

Funkcija generate_spiral kreira skup tačaka za nnn spirala sa po segs+1segs + 1segs+1 tačaka:

• Za desne spirale, parametar αraste od 0 do π.
• Za leve spirale (ogledalo), α ide od 0 do −π (obrnut smer).

Ova funkcija koristi gore navedenu matematičku formulu da izračuna koordinate x,y,zx, y, zx,y,z svake tačke.

2. Konstrukcija cilindara (šipki)

Funkcija cylinder_between_points pravi geometrijski model cilindra između dve tačke p1​ i p2​:

• Izračunava se vektor, dužina i orijentacija između tačaka.
• Kreira se baza i vrh cilindra pomoću kružnice u ravni X-Y.
• Cilindar se rotira da leži između tačaka pomoću rotacione matrice rotation_matrix.
• Generišu se trouglaste površine (faces) koje povezuju bazu i vrh.

3. Spajanje spirala u kupolu

Funkcija generate_mesh pravi mesh kupole:

• Poziva generate_spiral za desne i leve spirale.
• Svaku uzastopnu par tačaka na spirali povezuje cilindrom.
• Svi cilindri se spajaju u jedan veliki mesh koji predstavlja celu kupolu.

4. Izvoz modela

Na kraju, u glavnom delu programa:

• Definišu se parametri kupole (n, segs, d, h, thickness).
• Mesh se generiše pozivom generate_mesh.
• Mesh se izvozi u PLY i STL formate, pogodnim za dalju obradu ili 3D štampu.

Program

Helix Zome kupola je matematički lepo definisana struktura koja koristi sinusne funkcije i linearne transformacije za formiranje duplih spirala kao glavnog elementa. Program implementira ovaj matematički model u Pythonu koristeći biblioteku trimesh za kreiranje geometrijskih cilindara između tačaka, što omogućava preciznu izradu 3D modela kupole. Pristup je modularan, jasan i efikasan za dalje nadogradnje poput dodavanja novih veza ili prilagođavanja parametara.

Programski kod

Naziv fajla helixzome.py:

import numpy as np
import trimesh
from math import sin, cos, pi
import ezdxf

def rotation_matrix(v1, v2):
    a = v1 / np.linalg.norm(v1)
    b = v2 / np.linalg.norm(v2)
    v = np.cross(a, b)
    dot = np.dot(a, b)
    if np.allclose(dot, 1):
        return np.eye(3)
    if np.allclose(dot, -1):
        return -np.eye(3)
    s = np.linalg.norm(v)
    km = np.array([[   0, -v[2],  v[1]],
                   [ v[2],    0, -v[0]],
                   [-v[1],  v[0],    0]])
    return np.eye(3) + km + (km @ km) * ((1 - dot) / (s*s))

def cylinder_between_points(p1, p2, radius=0.01, sections=4):
    vec = p2 - p1
    length = np.linalg.norm(vec)
    if length < 1e-6:
        return np.array([]), np.array([])
    dir = vec / length
    angles = np.linspace(0, 2*pi, sections, endpoint=False)
    circle = np.stack([np.cos(angles)*radius, np.sin(angles)*radius, np.zeros_like(angles)], axis=1)
    base = circle
    top = circle + np.array([0, 0, length])
    verts = np.vstack([base, top])
    R = rotation_matrix(np.array([0,0,1]), dir)
    verts = verts @ R.T + p1
    faces = []
    n = sections
    for i in range(n):
        j = (i+1) % n
        faces += [[i, j, j+n], [i, j+n, i+n]]
    return verts, np.array(faces)

def generate_spiral(n, segs, d, h, direction):
    spirals = []
    for i in range(n):
        beta = 2 * pi * i / n
        spiral = []
        for j in range(segs + 1):
            alpha = pi * j / segs
            theta = alpha if direction == 1 else -alpha
            x = sin(theta + beta) * d/4 + sin(beta)*d/4
            y = cos(theta + beta) * d/4 + cos(beta)*d/4
            z = (alpha/pi) * h
            spiral.append([x, y, z])
        spirals.append(np.array(spiral))
    return spirals

def generate_mesh(n, segs, d, h, thickness):
    verts_list, faces_list = [], []
    offset = 0

    spirals_right = generate_spiral(n, segs, d, h, direction=1)
    spirals_left = generate_spiral(n, segs, d, h, direction=-1)

    for spiral in spirals_right:
        for j in range(segs):
            p1, p2 = spiral[j], spiral[j+1]
            v, f = cylinder_between_points(p1, p2, thickness)
            if len(v):
                verts_list.append(v)
                faces_list.append(f + offset)
                offset += len(v)

    for spiral in spirals_left:
        for j in range(segs):
            p1, p2 = spiral[j], spiral[j+1]
            v, f = cylinder_between_points(p1, p2, thickness)
            if len(v):
                verts_list.append(v)
                faces_list.append(f + offset)
                offset += len(v)

    return np.vstack(verts_list), np.vstack(faces_list), spirals_right, spirals_left

def export_wireframe_dxf(mesh, filename):
    doc = ezdxf.new(dxfversion="R2010")
    msp = doc.modelspace()
    for edge in mesh.edges_unique:
        p1 = mesh.vertices[edge[0]]
        p2 = mesh.vertices[edge[1]]
        msp.add_line(p1, p2)
    doc.saveas(filename)

def export_axis_lines_dxf(spirals_right, spirals_left, filename):
    doc = ezdxf.new(dxfversion="R2010")
    msp = doc.modelspace()

    # Desne spirale - plavo (ACI color 5)
    for spiral in spirals_right:
        for i in range(len(spiral) - 1):
            p1 = spiral[i]
            p2 = spiral[i + 1]
            msp.add_line(p1, p2, dxfattribs={"color": 5})

    # Leve spirale - crveno (ACI color 1)
    for spiral in spirals_left:
        for i in range(len(spiral) - 1):
            p1 = spiral[i]
            p2 = spiral[i + 1]
            msp.add_line(p1, p2, dxfattribs={"color": 1})

    doc.saveas(filename)

if __name__ == "__main__":
    n = 24         # broj spirala po smeru
    segs = 24      # broj segmenata po spirali
    d = 4.0        # prečnik kupole
    h = 2.0        # visina kupole
    thickness = 0.01

    verts, faces, spirals_right, spirals_left = generate_mesh(n, segs, d, h, thickness)
    mesh = trimesh.Trimesh(vertices=verts, faces=faces, process=False)

    mesh.export("helix_zome_ogledalo.ply")
    mesh.export("helix_zome_ogledalo.stl")
    mesh.export("helix_zome_ogledalo.obj")
    export_wireframe_dxf(mesh, "helix_zome_ogledalo_wireframe.dxf")
    export_axis_lines_dxf(spirals_right, spirals_left, "helix_zome_ogledalo_axis_lines.dxf")

    print("✅ Izvezeni fajlovi: .ply, .stl, .obj, .dxf (wireframe i ose)")

Reference:

Matematički modeli i teorija

1. „The Mathematics of Zome“ – Tom Davis
   Izuzetno detaljan papir (PDF) koji prikazuje kako izračunati dužine šipki u Zome sistemu i kako se čvorišta međusobno povezuju
   https://www.yumpu.com/en/document/view/25868597/zome-patterns-home-page-tom-davis
2. „Spinning Circles and Parametric Approach“ – SimplyDifferently.org
   Web članak objašnjava dve metode generisanja helix Zome geometrije: korišćenjem uvijenih kružnica i parametrskog pristupa
   https://www.simplydifferently.org/Helix_Zome
3. Zometool Manual 2.3 Detaljni PDF vodič sa uvodom u strukturu boja i simetrije Zome sistema (2-, 3‑ i 5‑fold modeli), te primene u geometriji i edukaciji: https://www.researchgate.net/publication/344594402_From_Zoom_Organization_to_Zome_Configuration_and_Dynamics_Integrating_the_doughnut_helix_and_pineapple_models_towards_global_strategic_coherence

Kontekst i primena

4. https://www.gradnja.rs/ove-montazne-modularne-kupole-po-projektu-domacih-arhitekata-izvodice-se-u-sad
5. Laetus in Praesens – o “Zonoedrima i Zome konstrukcijama”
   Analiza spirala i helix formi unutar Zome struktura, spominje zlati rez i geometriju zamishljenog sustava: https://www.laetusinpraesens.org/pdfs/2020s/zoomzome_2020.pdf