CH NEO-ZÜRICH AUSGABE
WETTER · GRAU 12°C
BLEND DES TAGES · 07/ROGUE
EST. 2027
DIE AEC CYBER MORGENZEITUNG

PAZ Kaffi

DESIGN · ABBRUCH · KOFFEIN · DEPESCHE
AUSGABE 1117 · 17 November 2026
SENDUNG 04:42 MEZ
2'400 BOGEN GEDRUCKT
LESEZEIT · 47 MIN
Wie viele Paneltypen hat deine Fassade wirklich? Eine 47-zeilige Grasshopper-Komponente zählt sie
Akademie
FRAME · 06:55
17-11-2026

Wie viele Paneltypen hat deine Fassade wirklich? Eine 47-zeilige Grasshopper-Komponente zählt sie

Eine 47-zeilige Grasshopper-Komponente analysiert Fassaden-Paneltypen nach Eckenabständen und gruppiert sie nach Toleranz für die Fertigung.

Die erste Frage des Herstellers zu einer unregelmässigen Fassade gilt nie dem Rendering. Sie lautet: Wie viele Paneltypen? Hersteller schneiden, biegen, spannen und kisten nach Typ, nicht nach Panel. Diese eine Zahl entscheidet über die Formen, die Einrichtungen und die Etiketten auf den Paletten. Ein Atelier, das ein regelmässiges Raster gerade für eine Aussicht, eine Baumreihe oder einen Sonnenwinkel verschoben hat, kann die Antwort gewöhnlich nicht aus dem Blick geben. Zwei Panels, die 0,2 mm auseinander liegen, sehen auf dem Bildschirm gleich aus. Zwei Panels, die unterschiedlich aussehen, können das gleiche Teil sein, das umgedreht ist.

Dieses Tutorial baut die Antwort: eine Python-3-Script-Komponente in Rhino 8 Grasshopper, 47 Zeilen lang. Sie gibt jedem Panel einen Typbuchstaben (A, B, C …), zählt die Panels in jedem Typ und gibt das Zentrum jedes Panels zurück, so dass die Buchstaben auf das Modell passen. Sie ist für gewöhnliche flache Panels geschrieben. Am Ende solltest du jede Zeile lesen und bewusst ändern können.

Das Werkzeug: Die Python-3-Script-Komponente, die mit Rhino 8 von Robert McNeel & Associates mitgeliefert wird. Sie sitzt auf der Grasshopper-Leinwand (Grasshopper begann als David Ruttens Arbeit in McNeel) und gibt dir Plain Python 3 plus RhinoCommon, die Bibliothek, durch die Rhino seine Geometrie offenlegt. Wie unser PAZ-Rhino-Stück berichtete, können Atelier-Scripts jetzt direkt auf der Leinwand neben der Geometrie, die sie lesen, leben. Die Ausgabe dieses Scripts ist eine Zahl, die der Hersteller kalkuliert, was sie einen Nachmittag wert macht.

Rhino, Grasshopper, Archicad: Wer macht was

Rhino speichert die Panel-Geometrie. Grasshopper macht eine Frage über diese Geometrie zu einer wiederholbaren Regel, damit die Zahl sich bei jedem Fassadenwechsel neu berechnet. Archicad dokumentiert die vereinbarten Typen als Elemente, Verzeichnisse und Pläne. Die Typzahl gehört in die Mitte, weil sie sich mit dem Entwurf verändert.

Der Fingerabdruck

Nach dem McNeel-Forum-Thread ‘Identifying unique panels’, eröffnet am 2. Mai 2023, ist die Frage älter als dieses Tutorial, aber nicht gealtert. User2662 wollte wissen, ‘wie viele einzigartige Elemente ich auf der Fassade habe, die ich visuell mit Farbe darstelle’. magicteddy antwortete mit der ganzen Idee in einer Zeile: ‘Du musst eine Zahl ausziehen, die die gesamte Geometrie darstellt.’

Hier ist diese Zahl eine Liste. Vier Ecken geben sechs Abstände: vier Seiten und zwei Diagonalen. Sortieren. Ein 1500 × 3000 mm Rechteck gibt 1500, 1500, 3000, 3000, 3354,1, 3354,1. Verschiebe es, drehe es 90° oder wende es um, und die sortierte Liste bleibt gleich. Für gewöhnliche flache Panels bedeutet die gleiche Liste die gleiche Form.

Die Diagonalen machen echte Arbeit. Ein Parallelogramm mit 1500 und 3000 mm Seiten hat genau die gleichen vier Seitenlängen des Rechtecks; nur seine Diagonalen unterscheiden sich. Ein Fingerabdruck, der nur aus Seiten gebaut wird, würde sie als einen Typ nennen, und die Werkstatt würde den Unterschied an der Jigge finden. Die Jigge ist ein sehr ehrlicher Reviewer.

Toleranz, richtig gemacht

Kein Paar Panels in einem echten Modell passt auf die letzte Dezimalstelle, also braucht der Vergleich eine Toleranz. Im gleichen Thread gruppierte Toni_Osterlund Panels nach einem Code von drei gerundeten Winkeln und notierte, dass ‘das Runden Toleranz im Gruppieren erlaubt’. Toni_Osterlund berichtet die Ergebnisse offen: ‘Mit Rundung auf 1 Dezimalstelle bekommen wir 16 unterschiedliche … Mit vielleicht zu viel Variation innerhalb einer Gruppe.’ Und: ‘Mit Rundung auf 2 Dezimalstellen geht es besser, aber ergibt 116 unterschiedliche.’ Von 16 zu 116 Typen mit einer Dezimalstelle: dieses Zahlenpaar ist das Nützlichste im Thread, weil es zeigt, wie stark die Zahl von der Toleranz abhängt, die du wählst.

Runden hat eine Eigenschaft, die es zu wissen lohnt. Snap jeden Wert auf ein 5-mm-Raster, und zwei Breiten 0,2 mm auseinander, 1502,4 und 1502,6 mm, landen auf 1500 und 1505. Zwei Typen, aus einem Unterschied, den niemand vor Ort messen könnte.

So vergleicht die Komponente statt zu runden. Jedes neue Panel wird gegen das erste Panel jedes bisher gefundenen Typs überprüft. Wenn jeder Abstand innerhalb T dieses Referenzmitglieds liegt, wird es dem Typ beigeordnet; wenn nicht, beginnt es einen neuen. Im Test unten gaben sieben Panels 3 Typen im Vergleich und 4 im Runden auf 5 mm, und das Paar 1502,4 / 1502,6 ist der ganze Unterschied. Die Kosten sind klar: Ein Typ ist ein Radius um sein erstes Mitglied, also können zwei Panels in einem Typ um bis zu 2 × T unterscheiden, und die Eingabereihenfolge entscheidet, welches Panel die Referenz wird.

←HEUTE: Rhino 8 stellt Python 3 auf die Grasshopper-Leinwand, und die Typenzahl des Herstellers liegt 47 Zeilen entfernt.
→3012: Fassaden werden Panel für Panel repariert, und der Typbuchstabe ist, wie ein 25-Jähriger das richtige Ersatzteil bestellt.
Drehpunkt: Ein Buchstabe ist heute eine Fertigungstatsache und seit Jahrzehnten ein Wartungsdatensatz.

Einrichtung: Öffne Rhino 8 und starte Grasshopper. Nach McNeels Scripting-Guide du ‘zum Maths-Tab gehst und Script-Panel und eine Python-3-Script-Komponente auf die Leinwand wirfst.’ Sie beginnt mit Eingaben x und y und Ausgaben out und a. Die erste Zeile, #! python 3, ist das, was der Guide ‘language specifier directive’ nennt. Doppelklick auf die Komponente, füge dies ein und führe es aus:

#! python 3
import math
a = math.dist((0, 0, 0), (1500, 3000, 0))
print(a)   # etwa 3354,1: die Diagonale eines 1500 x 3000 Panels

math.dist braucht Python 3.8 oder später. Wenn diese Zeile läuft, wird auch das Hauptscript laufen.

Erste Schritte:

  1. Benenne x zu P um (überprüfe, wo dein Rhino-Build die Rename-Option platziert). Klicke rechts darauf und stelle Parameter Access auf List Access ein, damit, in den Worten des Guides, ‘alle Datenzweige zur gleichen Zeit behandelt werden’. Im Type Hints Untermenü wähle Brep.
  2. Benenne y zu T um, Typ Hinweis float, und stöpsel einen Number Slider bei 5,0 ein. In einem Millimeter-Modell bedeutet das 5 mm.
  3. Zoom auf die Komponente, um Ausgaben L, C, K und N zu addieren; behalte a. Ausgaben sind nur Variablennamen, die das Script zuweist.
  4. Füge das vollständige Skript ein, verbinde deine Panel-Oberflächen zu P, und lies a: eine Zeile wie ‘7 Panels, 3 Typen bei Toleranz 5,0’.

Der Code, erklärt:

#! python 3
"""Panel types - Grasshopper (Rhino 8) Python 3 script component.
Inputs : P  panels (Brep, List Access)    T  tolerance, model units (float)
Outputs: L  type per panel   C  panel centres   K  type names
         N  panels per type  a  summary"""
import math
from itertools import combinations
import Rhino.Geometry as rg

def signature(pts):
    """Corner points -> sorted list of all corner-to-corner distances."""
    return sorted(math.dist(p, q) for p, q in combinations(pts, 2))

def same(s1, s2, tol):
    return len(s1) == len(s2) and all(abs(x - y) <= tol for x, y in zip(s1, s2))

def name(i):
    """0 -> A ... 25 -> Z, 26 -> AA"""
    s, i = "", i + 1
    while i:
        i, r = divmod(i - 1, 26)
        s = chr(65 + r) + s
    return s

tol = T if T else 5.0
refs, counts, L, C = [], [], [], []
for brep in P:
    if brep is None:
        L.append("-")
        C.append(None)
        continue
    pts = [(v.X, v.Y, v.Z) for v in brep.DuplicateVertices()]
    C.append(rg.Point3d(*[sum(c) / len(pts) for c in zip(*pts)]))
    sig = signature(pts)
    for i, ref in enumerate(refs):
        if same(sig, ref, tol):
            break
    else:
        refs.append(sig)
        counts.append(0)
        i = len(refs) - 1
    counts[i] += 1
    L.append(name(i))

K = [name(i) for i in range(len(refs))]
N = counts
a = "{} panels, {} types at tolerance {}".format(sum(counts), len(refs), tol)

Zeilen 1–8 — der Vertrag: Die Direktive wählt Python 3. Der Docstring (der Text in Tripletts) listet alle Eingaben und Ausgaben auf, damit ein Kollege, der die Komponente sechs Monate später öffnet, weiss, was er erwartet. combinations gibt jedes Paar genau einmal aus.

Zeilen 10–12 — der Fingerabdruck: Eine Funktion ist ein benannter, wiederverwendbarer Codeblock. signature() misst jedes Eckenpaar mit math.dist (sechs Paare für vier Ecken) und sortiert das Ergebnis. Die Sortierung macht die Liste unabhängig davon, in welcher Reihenfolge Rhino die Ecken auflistet, daher passen rotierte Kopien zusammen.

Zeilen 14–15 — der Vergleich: same() überprüft zuerst, dass beide Listen die gleiche Länge haben, so dass ein Dreieck nie mit einem Quad übereinstimmt, dann dass jedes Wertepaar innerhalb tol liegt. all() stoppt beim ersten Fehler.

Zeilen 17–23 — die Namen: name() zählt wie Spreadsheet-Spalten, so dass der 27. Typ AA ist. Der Test druckte Z AA AB für 25, 26 und 27.

Zeilen 25–43 — die Schleife: Eine Schleife wiederholt ihren Block einmal pro Element, hier einmal pro Panel. Eine leere Eingabe erhält ‘-‘ und kein Zentrum, daher bleibt jede Ausgabe mit der Eingabe ausgerichtet. McNeels RhinoCommon-Referenz dokumentiert DuplicateVertices() als Rückgabe Point3d[]; die Ecken werden zu Plain-Tupeln, damit die gleichen Funktionen ausserhalb von Rhino für Tests laufen. Das Zentrum ist der Durchschnitt der Ecken. Dann Pythons for … else: die else läuft nur, wenn die Schleife ohne break beendet wurde, was bedeutet, dass kein vorhandener Typ passte. Der Anfängerfehler ist, diese else unter die if einzurücken. Die Komponente stoppt dann beim allerersten Panel mit einem NameError: Mit noch keinen gefundenen Typen läuft die innere Schleife nie, daher wird i nie gesetzt.

Zeilen 45–47 — die Ausgaben: K enthält die Typnamen, N die Zählung pro Typ, a den Satz, den du in eine E-Mail klebst.

Ein ehrlicher Vorbehalt: diese Ergebnisse kommen aus Plain Python 3.10 mit einem Stand-In für Rhino.Geometry, nicht aus Rhino, also führe einen Lauf auf deiner eigenen Leinwand aus, bevor du ihm vertraust. Die sieben Panels waren ein 1500 × 3000 Rechteck, eine verschobene Kopie, eine Kopie im 90°-Winkel gedreht, Panels 1502,4 und 1502,6 breit, ein 1200 × 3000 Panel und ein 1500 mm breites Parallelogramm geschert 300 mm über eine 3000 mm Höhe, plus eine leere Eingabe.

greedy, tol 5 mm : ['A', 'A', 'A', 'A', 'A', 'B', 'C'] -> 3 types
round to 5 mm    : ['A', 'A', 'A', 'A', 'B', 'C', 'D'] -> 4 types
1502.4 vs 1502.6 rounded widths: 1500 1505
name(25), name(26), name(27): Z AA AB

T = 5.0 | L = ['A', 'A', 'A', 'A', 'A', 'B', 'C', '-']
   K = ['A', 'B', 'C'] N = [5, 1, 1]
   7 panels, 3 types at tolerance 5.0
C = [(750,1500,0), (2750,1500,0), (1500,750,0), (751,1500,0),
     (751,1500,0), (600,1500,0), (900,1500,0), None]

Das Parallelogramm ist Typ C. In diesem Test dehnt seine Scherung auch die langen Seiten auf etwa 3015 mm; umgebaut mit Seiten von genau 1500 und 3000 mm, landet es immer noch in Typ C auf seinen Diagonalen allein.

Was es nicht sieht

Es misst nur Ecken, so dass gekrümmte oder gefaltete Panels mit den gleichen Ecken identisch aussehen. Spiegelbilder zählen als ein Typ; wenn das Panel ein Vordergesicht hat (eine Beschichtung, Befestigungen auf einer Seite), teile sie von Hand. Mitglieder eines Typs können um bis zu 2 × T unterscheiden, und die Eingabereihenfolge wählt die Referenz. T ist in Modelleinheiten: T = 5 bedeutet nur 5 mm in einem Millimeter-Modell.

Atelier: Für ein 12-köpfiges Studio in Zürich kommt die Typenzahl meist als Überraschung vom Hersteller an, nachdem die Fassade aus guten Gründen gelockert wurde. Teams, die Geometriework an Scripts und AI-Assistenten geben, brauchen die gegenteilige Gewohnheit: das Atelier nennt die Zahl und besitzt die Toleranz dahinter. Montagszug: Addiere diese Komponente zur Fassadendefinition und mache ‘Typen bei Toleranz T’ eine feste Zeile in jedem Panel-Export zum Hersteller.

Hack: Verschärfe die Toleranz, bis die nahezu identischen Breiten trennen, und prognostiziere die Buchstaben, bevor du schaust. Verschiebe den Schieber in T von 5,0 bis 0,1. Die Panels 1502,4 und 1502,6 sollten Type A verlassen und ihre eigenen Buchstaben erhalten, während die verschobene und gedrehte Kopie A bleibt. Der Test druckte:

# T slider: 5.0 -> 0.1
T = 0.1 | L = ['A', 'A', 'A', 'B', 'C', 'D', 'E', '-']
   K = ['A', 'B', 'C', 'D', 'E'] N = [3, 1, 1, 1, 1]
   7 panels, 5 types at tolerance 0.1

Die gedrehte Kopie passt bei 0,1 mm: der Fingerabdruck, nicht die Toleranz, fängt Rotation ab. Um Buchstaben auf dem Modell zu sehen, verbinde C und L zu einer nativen Text-Tag-Display-Komponente; verbinde K und N zu einem Panel, um das Verzeichnis zu lesen.

Lerne es:

Führe es auf der Fassade auf deinem Bildschirm heute aus, und schreibe die Toleranz neben die Zahl, bevor jemand anderes danach fragt.

GEMELDET AUS
MIT-UNTERZEICHNER
PAZ Academy
VERTRAUEN
HIGH
NACHDRUCKE
© PAZ - PARAMETRIC ACADEMY ZURICH · ALLE RECHTE VORBEHALTEN

PAZ Kaffi · interdisziplinäre Redaktionsarbeit, geleitet von der PAZ Academy

⚑ FEHLER MELDEN · KORREKTUR EINSENDEN
◂ ZURÜCK ZUR TITELSEITE · PAZ KAFFI

© 2026 PAZ Academy.