OpenSCAD: Programmieren

Akademie

OpenSCAD: Programmieren

Schleifen, Bedingungen, Operatoren, Module, Funktionen und Listen.

Kontrollfluss: for, if, let und Co.

Begriffe vorab

for: Erzeugt für jeden Wert eines Bereichs oder Vektors einen Zweig im Objektbaum.
intersection_for: Wie for, aber mit Schnittmenge statt Vereinigung.
if / else: Bedingte Ausführung eines Blocks.
Ternärer Operator: Ausdruck der Form bedingung ? a : b.
let: Legt Variablen für einen Teilbaum oder Ausdruck fest.

for() baut einen Baum

Die Doku betont: OpenSCAD ist keine iterative Sprache. for() schleift nicht im programmiersprachlichen Sinn, sondern erzeugt einen Baum von Objekten, einen Zweig pro Wert. Jeder Durchlauf hat seinen eigenen Scope; Variablen lassen sich über Durchläufe hinweg nicht verändern.

Formen

Bereich: for (a = [3 : 0.5 : 5]) liefert 3, 3.5, 4, 4.5, 5 (Standardschritt 1).
Vektor: for (a = [3, 4, 1, 5]) geht jedes Element durch.
Verschachtelt in Kurzform: for (x = r1, y = r2, z = r3).

Die Variante für Objekte (for (v = object)) nennt die Doku nur für Entwicklungs-Snapshots.

intersection_for()

Arbeitet wie for(), bildet aber die Schnittmenge aller Durchläufe statt der Vereinigung.

if / else

if (test) a oder if (test) a else b, auch verkettet mit else if. Die erste wahre Bedingung gewinnt, weitere Tests entfallen. Variablen, die du innerhalb eines Blocks zuweist, gelten nur in diesem Scope.

Ternärer Operator

wert = test ? wahr : falsch; liefert einen Wert und eignet sich für Funktionen und Rekursion.

let()

let setzt Variablen nacheinander innerhalb eines Teilbaums – spätere dürfen auf frühere zugreifen. Es ersetzt das veraltete assign().

echo() und assert()

echo() schreibt in die Console und rundet auf fünf signifikante Stellen. assert(bedingung, meldung) prüft Annahmen und stoppt bei Verletzung.

// Zahnrad-artiger Kranz aus Zylindern per for und let
for (i = [0 : 11])
    let (winkel = i * 30, abstand = 20)
        rotate([0, 0, winkel])
            translate([abstand, 0, 0])
                if (i % 2 == 0)
                    cylinder(h = 6, r = 3, $fn = 24);
                else
                    cylinder(h = 4, r = 2, $fn = 24);

// Zwei Schleifenvariablen: Raster aus Säulen
translate([50, 0, 0])
    for (x = [0 : 3], y = [0 : 2])
        translate([x * 8, y * 8, 0]) cube([5, 5, 2 + x + y]);

// Schnitt über intersection_for
translate([100, 0, 0])
    intersection_for (a = [0, 60, 120])
        rotate([0, 0, a]) cube([20, 8, 8], center = true);

Im ersten Beispiel entscheidet i % 2, ob ein hoher oder niedriger Zylinder entsteht. Im zweiten erzeugt eine Schleife mit zwei Variablen ein 4 × 3-Raster. Das dritte bildet den Durchschnitt dreier gedrehter Balken.

Wenn du „Zähler hochsetzen“ denkst, brauchst du in OpenSCAD stattdessen eine Formel in Abhängigkeit vom Schleifenwert.

Zum Selbermachen

Baue eine Wendeltreppe: für jede Stufe i drehst du um i·15° und hebst um i·3.
Nutze assert, um zu prüfen, dass eine Wandstärke positiv ist.

Quellen

OpenSCAD User Manual – Conditional and Iterator Functions (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Conditional_and_Iterator_Functions)
OpenSCAD User Manual – Other Language Features (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Other_Language_Features)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Listen, List Comprehensions und Zeichenketten

Begriffe vorab

List Comprehension: Ausdruck, der eine Liste aus einer Schleife erzeugt.
each: Entpackt eine Liste in die umgebende Liste.
search(): Sucht Werte in Listen oder Zeichenketten.
Typtest: Funktion, die den Typ eines Wertes prüft, z. B. is_list.
str(): Wandelt Argumente in Text um und verkettet sie.

List Comprehensions

Mit [ for (i = bereich) ausdruck ] erzeugst du Listen. Erweiterungen:

Filter: [ for (x = liste) if (bedingung) x ].
if/else innerhalb der Liste (laut Doku ab 2019.05).
let für Zwischenwerte.
each (ab 2019.05) entpackt eine Liste, z. B. zum Flachklopfen.
C-artiges for for (init; bedingung; schritt) für rekursive Berechnungen (ab 2019.05).

Kerngedanke: Du beschreibst die Liste, statt sie schrittweise zu füllen. Das passt zur unveränderlichen Natur von OpenSCAD-Variablen. Typisch: Punktlisten für polygon mit Winkelfunktionen.

Zeichenketten

str(…) wandelt alle Argumente in Text um und verkettet sie.
chr(…) (ab 2015.03) wandelt Unicode-Codepunkte in Zeichen (chr(65) = „A“).
ord("a") (ab 2019.05) liefert den Codepunkt (97).
len("Hello world") liefert 11 – auch für Listen.
search() findet Werte in Listen und Text.

Typtests (ab 2019.05)

is_undef, is_bool, is_num, is_string, is_list und – ab 2021.01 – is_function. Besonderheiten: is_undef(a) prüft ohne Warnung bei unbekannter Variable; is_num gilt auch für Unendlich, aber nicht für nan.

// Ellipse aus einer List Comprehension
punkte = [ for (a = [0 : 10 : 359]) [ 20 * cos(a), 10 * sin(a) ] ];
linear_extrude(4) polygon(punkte);

// Filter und Transformation
zahlen = [1, 2, 3, 4, 5, 6];
gerade = [ for (z = zahlen) if (z % 2 == 0) z * z ];
echo(gerade);                                    // [4, 16, 36]

// Flachklopfen mit each
flach = [ each [1, 2], each [3, 4] ];
echo(flach);                                     // [1, 2, 3, 4]

// Text und Typen
beschriftung = str("Maß: ", 12, " mm");
echo(beschriftung, len(beschriftung), is_string(beschriftung), is_list(zahlen));
echo(chr(65), ord("a"));

Die erste Liste erzeugt 36 Punkte einer Ellipse mit Halbachsen 20 und 10 und gibt sie an polygon. Die zweite filtert gerade Zahlen und quadriert sie.

Statt eine Liste in einer Schleife „aufzufüllen“, beschreibst du sie mit einer List Comprehension.

Zum Selbermachen

Erzeuge die Eckpunkte eines Sterns mit abwechselnd zwei Radien.
Filtere aus einer Liste von Maßen alle über 10 und gib sie aus.

Quellen

OpenSCAD User Manual – List Comprehensions (en.wikibooks.org/wiki/OpenSCAD_User_Manual/List_Comprehensions)
OpenSCAD User Manual – String Functions (en.wikibooks.org/wiki/OpenSCAD_User_Manual/String_Functions)
OpenSCAD User Manual – Type Test Functions (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Type_Test_Functions)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Module und Funktionen: eigene Bausteine

Begriffe vorab

Modul: Wiederverwendbarer Baustein, der Geometrie erzeugt.
Funktion: Berechnet und liefert einen Wert, erzeugt aber keine Geometrie.
children(): Die Kind-Objekte, die einem Modul übergeben werden.
Standardwert: Wert, der gilt, wenn kein Argument übergeben wird.
Rekursion: Eine Funktion oder ein Modul ruft sich selbst auf.

Funktionen und Module

Die Doku trennt klar: Funktionen liefern Werte, Module führen Aktionen aus, geben aber keine Werte zurück. Es gibt keinen Mechanismus, mit dem ein Modul einen Wert nach außen reicht. Namen dürfen nur a–z, A–Z, 0–9 und Unterstrich enthalten und unterscheiden Groß- und Kleinschreibung.

Funktionen

function name(parameter) = ausdruck; – ein Ausdruck, kein Block. Parameter dürfen Standardwerte haben: function f(x = 3) = 2*x + 1;. Innerhalb von Funktionen setzt let Hilfsvariablen. Funktionsliterale (f = function (x) x * x;) sind ab Version 2021.01 möglich und erfassen Variablen lexikalisch (Closures).

Module

module name(parameter) { … }. Fast jede Anweisung darf im Modul stehen, auch Definitionen weiterer Module und Funktionen (dann nur lokal sichtbar). Variablen im Modul gelten nur innerhalb des jeweiligen Aufrufs.

children()

Ein Modul kann Kind-Objekte übernehmen und sie transformieren – so entstehen eigene „Operatoren“. children() meint alle Kinder, children(index) ein einzelnes, children([start:schritt:ende]) einen Bereich und children([v1, v2]) mehrere. $children enthält die Anzahl der Kinder. Zusammen in einen Block gefasste Objekte zählen als ein Kind.

Rekursion

Mit Endrekursion kann OpenSCAD die Rekursion intern in eine Schleife umwandeln: Das erlaubt bis zu etwa 1.000.000 Aufrufe, normale Rekursion nur einige Tausend. Module haben diese Optimierung nicht. Bei verzweigender Rekursion warnt die Doku: Die Rekursionstiefe unter 7 halten, weil Zahl der Primitive und Vorschauzeit exponentiell wachsen.

// Funktion mit Standardwert und let
function flaeche(b, h = 10) = let (a = b * h) a;
echo(flaeche(4), flaeche(4, 3));            // 40 und 12

// Funktionsliteral (ab 2021.01) und Endrekursion
quadrat = function (x) x * x;
function summe(n, s = 0) = n == 0 ? s : summe(n - 1, s + n);
echo(quadrat(5), summe(100));               // 25 und 5050

// Modul mit Standardwerten
module saeule(h = 10, r = 3) {
    cylinder(h = h, r = r, $fn = 32);
    translate([0, 0, h]) sphere(r = r + 1, $fn = 32);
}

// Eigener Operator mit children(): Objekt n-mal im Kreis anordnen
module im_kreis(n, radius) {
    for (i = [0 : n - 1])
        rotate([0, 0, i * 360 / n])
            translate([radius, 0, 0]) children();
}

im_kreis(6, 25) saeule(h = 8, r = 2);
saeule();

Das Modul im_kreis weiß nichts über das, was es verteilt: Es bekommt ein Kind-Objekt und wiederholt es. So entsteht aus drei Zeilen ein wiederverwendbarer Baustein.

Modularisiere früh: Jedes Bauteil, das du zweimal brauchst, gehört in ein Modul mit Parametern.

Zum Selbermachen

Schreibe ein Modul „loch_platte(b, t, h, lochdurchmesser)“.
Baue einen Operator „spiegel_paar“, der sein Kind einmal normal und einmal gespiegelt zeichnet.

Quellen

OpenSCAD User Manual – User-Defined Functions and Modules (en.wikibooks.org/wiki/OpenSCAD_User_Manual/User-Defined_Functions_and_Modules)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

Operatoren und mathematische Funktionen

Begriffe vorab

Operator: Zeichen für eine Rechen- oder Vergleichsoperation.
Modulo: Rest einer Division (%).
Skalarprodukt: Ergebnis der Multiplikation zweier Vektoren.
Grad: Winkeleinheit, die OpenSCAD in trigonometrischen Funktionen nutzt.
Norm: Länge eines Vektors.

Rechenoperatoren

+ - * / % ^: Addition, Subtraktion, Multiplikation, Division, Modulo und Potenz. Der Potenzoperator ^ erfordert laut Doku Version 2021.01 oder neuer. Das Minuszeichen funktioniert auch als Vorzeichen. Modulo ist praktisch für Muster: Eine Zahl modulo 2 ist 0 bei geraden und 1 bei ungeraden Zahlen. Bitoperationen (| & << >> ~) nennt die Doku nur für Entwicklungs-Snapshots.

Vergleich und Logik

< <= == != >= > sowie && || !. Nicht-Boolesche Werte werden vor der Auswertung in Boolesche umgewandelt. Einzelheiten laut Doku: Zeichenketten werden alphabetisch verglichen, true > false, Vektoren sind nur bei vollständiger Gleichheit gleich, verschiedene Typen sind ungleich ([1] != 1), undef ist nur sich selbst gleich, und nan ist nichts gleich.

Vektoren und Matrizen

Vektor mit Zahl: jedes Element wird multipliziert oder geteilt.
Vektor mit Vektor: Addition und Subtraktion elementweise.
Zwei einfache Vektoren multipliziert ergeben das Skalarprodukt.
Matrizenmultiplikation folgt der linearen Algebra und ist nicht kommutativ.

Mathematische Funktionen

Winkelfunktionen in Grad: sin, cos, tan, asin, acos, atan; atan2(y, x) liefert Winkel im Bereich −180 < Winkel ≤ 180.
Grundfunktionen: abs, sign, sqrt, pow, exp, floor, ceil, round (rundet „weg von null“: round(5.5) ergibt 6, round(-5.5) ergibt −6), ln (natürlich), log (Basis 10).
Mehrere Werte: min und max mit mehreren Argumenten oder einem Vektor, norm (Euklidische Länge), len (Anzahl der Elemente), cross (Kreuzprodukt), concat (Vektoren aneinanderhängen).
Weitere: lookup (Tabelle mit linearer Interpolation), rands (Zufallszahlen).

// Punkte auf einem Kreis mit Winkelfunktionen (Winkel in Grad!)
r = 20;
for (i = [0 : 7]) {
    w = i * 45;
    translate([r * cos(w), r * sin(w), 0]) sphere(r = 2, $fn = 16);
}

// Abstand zweier Punkte mit norm() und Hilfsausgabe
a = [0, 0, 0];
b = [3, 4, 12];
echo(laenge = norm(b - a));            // 13
echo(gerundet = round(5.5), runter = floor(-2.5), rest = 17 % 5);

// Linie zwischen a und b als dünner Zylinder (Länge per norm)
// Ausrichtung per Winkel aus atan2
translate(a)
rotate([0, 0, atan2(b.y - a.y, b.x - a.x)])
rotate([0, 90 - asin(b.z / norm(b - a)), 0])
    cylinder(h = norm(b - a), r = 0.5, $fn = 12);

Die Kreispunkte entstehen mit cos und sin – beide erwarten Grad, nicht Bogenmaß. Das Beispiel ergibt echo-Ausgaben mit 13, 6, −3 und 2.

Alle Winkel in OpenSCAD sind Grad. Wer Bogenmaß-Formeln übernimmt, muss umrechnen.

Zum Selbermachen

Verteile zwölf Kugeln gleichmäßig auf einem Kreis.
Berechne mit norm() die Diagonale eines Quaders und gib sie per echo aus.

Quellen

OpenSCAD User Manual – Mathematical Operators (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Mathematical_Operators)
OpenSCAD User Manual – Mathematical Functions (en.wikibooks.org/wiki/OpenSCAD_User_Manual/Mathematical_Functions)
OpenSCAD Cheat Sheet (openscad.org/cheatsheet, bezieht sich auf Version 2021.01)

OpenSCAD: Programmieren