Zome: Geometrija idealna za prefabrikaciju

Zome kupole su prostorne strukture koje kombinuju principe geometrije, umetnosti i inženjerstva. One su specijalna vrsta zonohedarskih kupola — konstrukcija baziranih na pravilnim zonohedronima, što su poliedri sastavljeni od paralelograma koji su simetrično raspoređeni oko središta.

Osnovne karakteristike zome kupola

1. Geometrijska osnova
   Zome kupole su sačinjene od šipki (ili letvica) koje se spajaju u pravilnim uglovima i dužinama, formirajući višestruko ponavljajuće šablone. Najčešće su zasnovane na trima osnovnim pravcima koje zatvaraju određene uglove u prostoru, a koriste se boje (npr. plava, crvena, žuta) da označe različite dužine i orijentacije letvica.
2. Polar zonohedron
   Najčešći oblik zome kupole je tzv. polar zonohedron, koji ima kružno postavljene paralelograme, spiralno orijentisane oko vertikalne ose. Po potrebi se konstrukcija može preseći kako bi dobila kupolni (polusferni) oblik.
3. Frekvencija i nagib
   • Frekvencija određuje koliko se puta osnovni šablon ponavlja po obodu.
   • Nagib (engl. slope) određuje vertikalni rast konstrukcije i oblik kupole.
4. Primene
   • Arhitektonske i umetničke instalacije
   • Edukativni modeli za proučavanje geometrije
   • Ekološke građevine i alternativni smeštaji (slično geodetskim kupolama)
   • Konstruktivne igračke (kao Zometool)

Prednosti zome kupola

• Estetska privlačnost — Zome strukture imaju prirodnu lepotu zbog simetrije i ritma ponavljanja.
• Strukturalna stabilnost — Kombinacija šipki u zatvorenim šablonima daje veliku čvrstoću uz relativno malu težinu.
• Modularnost — Lako se konstruišu iz gotovih modula (npr. od drvenih ili plastičnih letvica).
• Matematička tačnost — Idealne su za primenu u STEM edukaciji, jer ilustruju odnose u prostornoj geometriji, zonohedrima i simetriji.

Poređenje sa geodetskim kupolama

Postoji više načina projektovanja Zome kupola (Zome Domes), u zavisnosti od:

• tipa simetrije (polarno, zonohedralno, icosahedralno…),
• načina raspoređivanja panela (projekcija sa višedimenzionalne mreže, preslikavanje iz poliedara, fraktalno…),
• ciljanog vizuelnog ili strukturalnog efekta (umetnost vs arhitektura vs inženjering).

1. Polarno (Zome kupole kao “polar zonohedra”) – kao u ovom programu

• Baza: sferna koordinatna mreža.
• Paneli formiraju paralelograme raspoređene u koncentrične slojeve.
• Parametri: frequency, layers, tilt_deg.

Prednosti: Jednostavan za generaciju, estetski prijatan, simetričan.
Ograničena forma (uvek rotaciono simetrična).

2. Zonohedralni pristup (Zome kao kombinacija zona)

• Baza: zonohedron – geometrijsko telo čije su strane paralelogrami i koje je konstruisano od više „zona“.
• Svaka zona je niz paralelograma koji dele istu orijentaciju (vektorski pravac).
• Mogu se projektovati iz višedimenzionalnih mreža (projekcija iz ℝ⁴ → ℝ³).

Prednosti: Veća kontrola nad šipkama, fleksibilnost u orijentacijama.
Složenija konstrukcija i generacija, potreban napredniji algoritam.

3. Projekcija iz Platonskih tela (najčešće icosahedron)

• Početak: npr. ikosaedar.
• Generiše se geodetska mreža razlažući trouglove u manje delove.
• Zatim se formiraju zone (serije paralelograma) duž glavnih pravaca (Zome pravci: “blue”, “red”, “yellow”).

Prednosti: Izuzetna strukturalna snaga, koristi se za građevinske zome (npr. domove).
Paneli više nisu ravni kvadrati ili jednostavni paralelogrami – postaju nepravilni.

4. Fraktalni / iterativni zome

• Korišćenje iterativnih pravila za dodavanje složenosti.
• Moguće generisati neverovatno kompleksne strukture sa zome estetikom.

Prednosti: Estetski impresivno.
Nepogodno za gradnju – komplikovani paneli, visoka računarska zahtevnost.

5. Zome kao algebraička konstrukcija (vektorski pristup)

• Svaki pravac definisan vektorom (npr. u ZomeTool sistemu: crveni, plavi, žuti).
• Paneli su spojeni kao rezultat vektorskog sabiranja i rotacija tih osnovnih pravaca.
• Zome se gradi modularno: “pravci + spojevi”.

Prednosti: Tvornički modularni sistemi, kompatibilno sa stvarnim konstrukcionim alatima (npr. ZomeTool).
Nije trivijalno za generaciju u kodu bez dobrog vektorskog sistema.

Koji je najbolji?

Zavisi od cilja:

Naziv Zome uveo je Steve Baer, tvorac ovih jedinstvenih konstrukcija, spajajući reči zonohedron (zonoedar – vrsta poliedra) i dome (kupola).

„Geometrija zonoedra može biti veoma raznolika, ali ono što danas najčešće srećemo kao Zome jeste polarni zonoedar, koji predstavlja specijalan slučaj zonoedra“, objašnjavaju arhitekte za naš portal.

Ključni parametri Zome konstrukcija

Osnovni parametri koji određuju geometriju Zomea su:

• Frekvencija – broj vektora generatora koji formiraju polarni zonoedar,
• Nagib – ugao između pojedinačnih vektora i horizontalne ravni,
• Dužina stranica – identična za sve panele u konstrukciji.

Spiralna logika i identični paneli

Model Zome 01 sastoji se od samo devet različitih panela, svi u obliku romba. Svaki panel deli makar jednu stranicu sa susednim, različitim panelom, što znači da su sve stranice jednakih dužina. Paneli su poređani od dna ka vrhu u spiralu.

Frekvencija 14 kod Zome 01 označava da 14 takvih spirala formira celu konstrukciju. Veći model, Zome 02 , ima frekvenciju 16.

Savršena za montažu

„Koliko god se ova geometrija može učiniti kompleksnom, ona je zapravo veoma pravilna i bogata ponavljanjima – što je čini idealnom za prefabrikaciju i montažu“, naglašavaju arhitekte.

Programski kod zome.py

import numpy as np
import trimesh
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d.art3d import Poly3DCollection

def spherical_to_cartesian(r, theta, phi):
    x = r * np.sin(theta) * np.cos(phi)
    y = r * np.sin(theta) * np.sin(phi)
    z = r * np.cos(theta)
    return np.array([x, y, z])

def generate_zome_polar(frequency=14, layers=6, side_length=1.0, tilt_deg=45):
    panels = []
    max_theta = np.radians(tilt_deg)
    theta_layers = np.linspace(0, max_theta, layers + 1)
    phi_steps = 2 * np.pi / frequency

    for j in range(layers):
        for i in range(frequency):
            theta0 = theta_layers[j]
            theta1 = theta_layers[j + 1]
            phi0 = i * phi_steps
            phi1 = ((i + 1) % frequency) * phi_steps
            p1 = spherical_to_cartesian(side_length, theta0, phi0)
            p2 = spherical_to_cartesian(side_length, theta0, phi1)
            p3 = spherical_to_cartesian(side_length, theta1, phi1)
            p4 = spherical_to_cartesian(side_length, theta1, phi0)
            panels.append([p1, p2, p3, p4])
    return panels

def plot_panels(panels):
    fig = plt.figure(figsize=(10, 8))
    ax = fig.add_subplot(111, projection='3d')
    for quad in panels:
        poly = Poly3DCollection([quad], facecolor='skyblue', edgecolor='k', alpha=0.8)
        ax.add_collection3d(poly)
    ax.set_box_aspect([1,1,1])
    ax.set_xlabel('X')
    ax.set_ylabel('Y')
    ax.set_zlabel('Z')
    plt.title("Polar Zonohedron (Zome kupola)")
    plt.tight_layout()
    plt.show()

def export_to_stl(panels, filename="zome_polar_kupola.stl"):
    vertices = []
    faces = []
    for quad in panels:
        idx = len(vertices)
        vertices.extend(quad)
        faces.append([idx, idx + 1, idx + 2])
        faces.append([idx, idx + 2, idx + 3])
    mesh = trimesh.Trimesh(vertices=vertices, faces=faces, process=False)
    mesh.export(filename)
    print(f"[✔] STL sačuvan kao: {filename}")

def cylinder_between_points(p1, p2, radius=0.02, sections=12):
    vec = p2 - p1
    length = np.linalg.norm(vec)
    if length == 0:
        return [], []

    axis = vec / length
    angles = np.linspace(0, 2 * np.pi, sections, endpoint=False)
    circle = np.stack([np.cos(angles)*radius, np.sin(angles)*radius, np.zeros_like(angles)], axis=1)
    base1 = circle
    base2 = circle + np.array([0,0,length])
    vertices = np.vstack([base1, base2])

    def rotation_matrix_from_vectors(vec1, vec2):
        a, b = (vec1 / np.linalg.norm(vec1)).reshape(3), (vec2 / np.linalg.norm(vec2)).reshape(3)
        v = np.cross(a, b)
        c = np.dot(a, b)
        s = np.linalg.norm(v)
        if s == 0:
            return np.eye(3)
        kmat = np.array([[0, -v[2], v[1]],
                         [v[2], 0, -v[0]],
                         [-v[1], v[0], 0]])
        return np.eye(3) + kmat + kmat @ kmat * ((1 - c) / (s ** 2))

    R = rotation_matrix_from_vectors(np.array([0,0,1]), axis)
    vertices = vertices @ R.T
    vertices += p1

    faces = []
    sections = len(angles)
    for i in range(sections):
        j = (i + 1) % sections
        faces.append([i, j, j + sections])
        faces.append([i, j + sections, i + sections])
    return vertices, faces

def export_edges_to_ply_with_thickness(panels, filename="zome_polar_kupola_edges_thick.ply", thickness=0.02):
    points = []
    point_indices = dict()
    edges = set()

    def add_point(pt):
        key = tuple(np.round(pt, decimals=8))
        if key not in point_indices:
            point_indices[key] = len(points)
            points.append(pt)
        return point_indices[key]

    for quad in panels:
        idxs = [add_point(pt) for pt in quad]
        edge_pairs = [(idxs[0], idxs[1]), (idxs[1], idxs[2]),
                      (idxs[2], idxs[3]), (idxs[3], idxs[0])]
        #diag_pairs = [(idxs[0], idxs[2]), (idxs[1], idxs[3])]
        diag_pairs = [(idxs[0], idxs[2])]

        for e in edge_pairs + diag_pairs:
            e_sorted = tuple(sorted(e))
            edges.add(e_sorted)

    vertices_np = np.array(points)

    all_vertices = []
    all_faces = []
    vert_offset = 0

    for e in edges:
        v1 = vertices_np[e[0]]
        v2 = vertices_np[e[1]]
        cyl_verts, cyl_faces = cylinder_between_points(v1, v2, radius=thickness, sections=12)
        if len(cyl_verts) == 0:
            continue
        all_vertices.append(cyl_verts)
        all_faces.append(np.array(cyl_faces) + vert_offset)
        vert_offset += len(cyl_verts)

    if len(all_vertices) == 0:
        print("Nema šipki za eksport!")
        return

    all_vertices = np.vstack(all_vertices)
    all_faces = np.vstack(all_faces)
    mesh = trimesh.Trimesh(vertices=all_vertices, faces=all_faces, process=False)
    mesh.export(filename)
    print(f"[✔] PLY šipke sa debljinom sačuvane kao: {filename}")

if __name__ == "__main__":
    frequency = 14
    layers = 6
    side_length = 1.0
    tilt_deg = 60
    thickness = 0.005  # Debljina šipki

    panels = generate_zome_polar(frequency, layers, side_length, tilt_deg)
    plot_panels(panels)
    export_to_stl(panels, "zome_polar_kupola.stl")
    export_edges_to_ply_with_thickness(panels, "zome_polar_kupola_edges_thick.ply", thickness=thickness)

Ovaj program generiše 3D model polarne zome kupole, prikazuje ga, i izvozi u dva formata:

• STL – površinski model panela (kvadrati/paralelogrami),
• PLY – model šipki sa debljinom (cilindri između čvorova).

MODULI KOJI SE UVOZE

import numpy as np                # Rad sa nizovima i matematikom
import trimesh                   # 3D mesh strukture i eksport
import matplotlib.pyplot as plt  # Prikaz panela
from mpl_toolkits.mplot3d.art3d import Poly3DCollection  # 3D prikaz panela

Funkcija spherical_to_cartesian

def spherical_to_cartesian(r, theta, phi):
    ...

• Pretvara sferne koordinate(r, θ, φ) u kartezijanske(x, y, z):
  • r – dužina stranice
  • theta – ugao od “nord pola” (nagnutost)
  • phi – azimutalni ugao (rotacija oko vertikalne ose)

Funkcija generate_zome_polar

def generate_zome_polar(frequency=14, layers=6, side_length=1.0, tilt_deg=45):

• Generiše panele zome kupole u obliku kvadrata/paralelograma.
• Parametri:
  • frequency – broj panela po horizontali (krug)
  • layers – broj slojeva po visini
  • side_length – radijus kupole (dužina od centra do panela)
  • tilt_deg – ukupna visina kupole u stepenima (rotacija od vrha)
• Vraća listu panela: svaki panel je lista 4 tačke u prostoru [p1, p2, p3, p4].

Funkcija plot_panels

def plot_panels(panels):

• Vizuelno prikazuje panele koristeći matplotlib u 3D prostoru.
• Svaki panel se prikazuje kao poligon sa plavom bojom i crnom ivicom.

Funkcija export_to_stl

def export_to_stl(panels, filename="zome_polar_kupola.stl"):

• Pretvara panele u triangularni mesh (jer STL ne podržava kvadrate).
• Svaki panel deli na 2 trougla:
  • trougao (0,1,2) i (0,2,3)
• Izvezi u STL fajl preko trimesh.

Funkcija cylinder_between_points

def cylinder_between_points(p1, p2, radius=0.02, sections=12):

• Generiše cilindar između tačaka p1 i p2.
• Cilindar se pravi:
  • kao 2 kruga (base1, base2) sa sections tačaka
  • i bočne strane (trouglovi)
• Koristi rotaciju da usmeri cilindar duž p2 - p1 vektora:
  • pravi rotacionu matricu koja rotira os Z → vektor p2-p1.

Funkcija export_edges_to_ply_with_thickness

def export_edges_to_ply_with_thickness(...):

• Dodaje cilindrične šipke umesto linija za svaki ivicu panela.
• Koraci:
  1. Skuplja sve tačke iz panela (za identifikaciju jedinstvenih čvorova).
  2. Formira sve ivice panela, uključujući i dijagonalu (opciono).
  3. Za svaku ivicu poziva cylinder_between_points i prikuplja vertikse i face-ove.
  4. Sastavlja ih u jedan 3D mesh (trimesh.Trimesh) i eksportuje u .ply.

Glavni program (if __name__ == "__main__":)

frequency = 14
layers = 6
side_length = 1.0
tilt_deg = 60
thickness = 0.005

Značenje:
frequency = 14

Broj panela po horizontali, tj. koliko "ćelija" (paralelograma) ima u jednom prstenu oko kupole.

Efekat:
Viši broj → finija i glađa kupola.

Niži broj → vidljivo manje segmenata, više "uglata".

Vizuelna analogija:
Zamišljaj kao da deliš krug na 14 jednakih delova. Svaki deo je početna tačka za jedan vertikalni segment zome kupole.

layers = 6
Značenje:
Broj horizontalnih slojeva (prstenova) između vrha i donje ivice kupole.

Efekat:
Povećanjem layers → kupola postaje viša i složenija, ima više redova panela.

Smanjenjem layers → jednostavnija i niža kupola.

Važno:
Ukupno se pravi layers + 1 horizontalna visinska tačka (theta_layers), pa je broj kvadratnih panela po visini baš layers.

side_length = 1.0
Značenje:
Radijalna dužina vektora od centra do svake tačke na kupoli — odnosno "radijus sfere" po kojoj su tačke raspoređene.

Efekat:
Utiče na apsolutnu veličinu kupole.

Sve tačke (paneli) su projektovane na sferu poluprečnika side_length.

Napomena:
Ova vrednost se ne odnosi direktno na stvarne dužine šipki (koje zavise od geometrije panela), ali postavlja referentnu veličinu sfere.

tilt_deg = 60
Značenje:
Ukupni nagib kupole, izražen u stepenima – meri se od vrha prema dnu (θ ugao u sfernim koordinatama).

Efekat:
tilt_deg = 90 → polovina sfere (hemisfera).

tilt_deg < 90 → manje od polulopte, sečena kupola.

tilt_deg > 90 → uključuje i deo ispod horizontale (ređe se koristi).

Vizuelno:
Zome kupola pod tilt_deg = 60 izgleda kao elegantna polukupola, sa otvorom od oko 2/3 polulopte (jer θ = 60°).

thickness = 0.005
Značenje:
Debljina šipki koje spajaju čvorove panela prilikom izvoza u .ply fajl. Koristi se za pravljenje cilindara koji vizuelno predstavljaju šipke.

Efekat:
Veća vrednost → deblje šipke.

Manja vrednost → tanji izgled, pogodniji za precizne modele.

Praktično:
Ova vrednost je često relativna u odnosu na side_length. Ako je side_length = 1.0, onda je thickness = 0.005 jednako 0.5% glavne dimenzije.

Celokupno značenje ovih parametara:
Parametar	Efekat na model
frequency	Širina i detaljnost u horizontalnom pravcu
layers	Visina i složenost po vertikali
side_length	Skala modela (veličina)
tilt_deg	Visina kupole (koliko dela sfere obuhvata)
thickness	Debljina šipki kod PLY izvoza

Ukratko – šta program radi?

• Modelira zome kupolu kao slojeve paralelograma po sferi.
• Vizualizuje je u 3D prostoru.
• Eksportuje:
  • STL – površina panela
  • PLY – šipke kao cilindri, spremno za 3D štampu ili analizu

Linkovi:

https://www.gradnja.rs/ove-montazne-modularne-kupole-po-projektu-domacih-arhitekata-izvodice-se-u-sad