OpenSCAD für Anfänger – Teil 5: Skalieren und Spiegeln

Voraussetzungen

Du brauchst OpenSCAD und die Grundlagen aus Teil 4 des Kurses.

In Teil 4 haben wir gelernt, wie Objekte mit translate() verschoben und mit rotate() gedreht werden.

Damit können wir Grundkörper bereits gezielt im Raum anordnen.

In dieser Lektion kommen zwei weitere wichtige Transformationen hinzu:

scale();
mirror();

Mit scale() verändern wir die Größe eines Objekts.

Mit mirror() erzeugen wir eine gespiegelte Geometrie.

Gerade bei symmetrischen Konstruktionen kann mirror() viel Arbeit sparen.

Lernziel: Nach dieser Lektion kannst du Objekte gleichmäßig oder achsabhängig skalieren und symmetrische Konstruktionen durch Spiegeln erzeugen.

Objekte mit scale() skalieren

Die allgemeine Schreibweise lautet:

scale([X, Y, Z])
    objekt();

Die drei Werte sind Skalierungsfaktoren.

Dabei gilt:

Gleichmäßig skalieren

Ausgangspunkt:

cube([20, 20, 10]);

Mit:

scale([2, 2, 2])
    cube([20, 20, 10]);

wird der Körper in allen drei Richtungen verdoppelt.

Aus:

20 × 20 × 10 mm

werden:

40 × 40 × 20 mm

Nur eine Richtung verändern

Wir müssen nicht alle Achsen gleich skalieren.

Beispiel:

scale([2, 1, 1])
    cube([20, 20, 10]);

Damit wird nur die X-Richtung verändert.

Das Ergebnis besitzt:

• X = 40 mm

• Y = 20 mm

• Z = 10 mm

Unterschiedliche Faktoren verwenden

Auch unterschiedliche Skalierungsfaktoren sind möglich:

scale([1, 1.5, 0.5])
    cube([20, 20, 10]);

Das bedeutet:

Skalierungsfaktoren als Variablen

Wie andere Werte können auch Skalierungsfaktoren parametrisch definiert werden:

scale_x = 1.5;
scale_y = 1;
scale_z = 0.8;

scale([scale_x, scale_y, scale_z])
    cube([20, 20, 10]);

Aus einer Kugel wird eine elliptische Form

Ein besonders anschauliches Beispiel ist eine Kugel.

Aus:

sphere(d=20, $fn=64);

wird mit:

scale([2, 1, 1])
    sphere(d=20, $fn=64);

eine längliche Form.

Damit lassen sich mit sehr wenig Code neue Formen erzeugen.

scale() bei technischen Bauteilen

Bei technischen Konstruktionen sollte scale() mit Bedacht verwendet werden.

Wird ein komplettes Modell skaliert, verändern sich automatisch auch:

• Bohrungsdurchmesser

• Wandstärken

• Abstände

• Ausschnitte

• Materialstärken

Beispielsweise wird eine 5-mm-Bohrung bei einer Skalierung um Faktor 2 ebenfalls zu einer 10-mm-Bohrung.

Für präzise technische Modelle ist es deshalb häufig besser, die eigentlichen Parameter zu verändern.

scale() eignet sich besonders gut, wenn eine Geometrie bewusst proportional gestreckt oder gestaucht werden soll.

Objekte mit mirror() spiegeln

Die allgemeine Schreibweise lautet:

mirror([X, Y, Z])
    objekt();

Die Werte definieren die Ausrichtung der Spiegelebene.

Für den Einstieg sind drei Fälle besonders wichtig.

Spiegeln entlang der X-Richtung

Beispiel:

translate([20, 0, 0])
    cube([10, 20, 10]);

Der Körper befindet sich auf der positiven X-Seite.

Mit:

mirror([1, 0, 0])
    translate([20, 0, 0])
        cube([10, 20, 10]);

wird er auf die gegenüberliegende Seite gespiegelt.

Die wichtigsten Spiegelrichtungen

Für den Einstieg kann man sich folgende Zuordnung merken:

Original und Spiegelung gleichzeitig anzeigen

mirror() ersetzt das Original nicht automatisch.

Wenn beide Varianten benötigt werden, erzeugen wir das Objekt einmal normal und einmal gespiegelt:

translate([20, 0, 0])
    cube([10, 20, 10]);

mirror([1, 0, 0])
    translate([20, 0, 0])
        cube([10, 20, 10]);

Dieses Prinzip ist besonders nützlich für symmetrische Bauteile.

Symmetrische Konstruktionen

Nehmen wir an, wir möchten eine Halterung mit zwei identischen Stegen konstruieren.

Natürlich könnten wir beide Stege einzeln positionieren.

Besser ist häufig:

1. einen Steg konstruieren

2. diesen spiegeln

Dadurch müssen wir Maße und Position nur einmal definieren.

Warum center=true beim Spiegeln hilfreich ist

Symmetrische Konstruktionen lassen sich besonders einfach aufbauen, wenn ihr Mittelpunkt im Ursprung liegt.

Eine Grundplatte können wir beispielsweise so zentrieren:

cube([80, 50, 5], center=true);

Der Mittelpunkt des Quaders befindet sich dadurch bei:

X = 0
Y = 0
Z = 0

Praxisprojekt: symmetrische Halterung

Wir erstellen eine kleine Halterung mit:

• einer Grundplatte

• einem rechten Steg

• einem gespiegelten linken Steg

Parameter

platte_b = 80;
platte_t = 50;
platte_h = 5;

steg_b = 10;
steg_t = 50;
steg_h = 30;

steg_x = 25;

Grundplatte

cube(
    [platte_b, platte_t, platte_h],
    center=true
);

Ersten Steg positionieren

Da die Grundplatte um den Ursprung zentriert ist, setzen wir den ersten Steg auf die positive X-Seite:

translate([
    steg_x,
    0,
    platte_h / 2 + steg_h / 2
])
    cube(
        [steg_b, steg_t, steg_h],
        center=true
    );

Die Z-Position berechnen wir aus:

platte_h / 2 + steg_h / 2

Dadurch steht der Steg genau auf der Oberseite der Grundplatte.

Zweiten Steg spiegeln

Den zweiten Steg müssen wir nicht erneut positionieren.

Wir spiegeln einfach den ersten:

mirror([1, 0, 0])
    translate([
        steg_x,
        0,
        platte_h / 2 + steg_h / 2
    ])
        cube(
            [steg_b, steg_t, steg_h],
            center=true
        );

Vollständiger Code

// -------------------------
// Parameter
// -------------------------

platte_b = 80;
platte_t = 50;
platte_h = 5;

steg_b = 10;
steg_t = 50;
steg_h = 30;

steg_x = 25;

// -------------------------
// Modell
// -------------------------

cube(
    [platte_b, platte_t, platte_h],
    center=true
);

// rechter Steg

translate([
    steg_x,
    0,
    platte_h / 2 + steg_h / 2
])
    cube(
        [steg_b, steg_t, steg_h],
        center=true
    );

// linker Steg

mirror([1, 0, 0])
    translate([
        steg_x,
        0,
        platte_h / 2 + steg_h / 2
    ])
        cube(
            [steg_b, steg_t, steg_h],
            center=true
        );

Vorteil der Spiegelung

Ändern wir beispielsweise:

steg_x = 30;

bewegen sich beide Stege automatisch symmetrisch nach außen.

Auch Änderungen an:

steg_b
steg_t
steg_h

wirken automatisch auf beide Seiten.

Das reduziert:

• doppelte Parameter

• doppelte Berechnungen

• mögliche Fehler

• unnötigen Code

Mitmach-Aufgabe

Erstelle eine symmetrische Halterung.

Grundplatte

Stege

Verwende:

center=true
translate()
mirror()

Erzeuge nur einen Steg direkt und erzeuge die zweite Seite durch Spiegelung.

Musterlösung

// -------------------------
// Parameter
// -------------------------

platte_b = 100;
platte_t = 60;
platte_h = 5;

steg_b = 12;
steg_t = 60;
steg_h = 35;

steg_x = 35;

// -------------------------
// Modell
// -------------------------

cube(
    [platte_b, platte_t, platte_h],
    center=true
);

translate([
    steg_x,
    0,
    platte_h / 2 + steg_h / 2
])
    cube(
        [steg_b, steg_t, steg_h],
        center=true
    );

mirror([1, 0, 0])
    translate([
        steg_x,
        0,
        platte_h / 2 + steg_h / 2
    ])
        cube(
            [steg_b, steg_t, steg_h],
            center=true
        );

Was haben wir gelernt?

Nach dieser Lektion kennst du zwei weitere wichtige Transformationen:

scale();
mirror();

Du weißt:

• Skalierungswerte sind Faktoren

• 1 bedeutet unverändert

• 2 bedeutet doppelte Größe

• 0.5 bedeutet halbe Größe

• einzelne Achsen können unterschiedlich skaliert werden

• mirror() erzeugt eine gespiegelte Geometrie

• symmetrische Bauteile müssen dadurch nur auf einer Seite konstruiert werden

• center=true kann symmetrische Konstruktionen deutlich vereinfachen

Damit verfügen wir bereits über die wichtigsten Transformationen in OpenSCAD:

translate();
rotate();
scale();
mirror();

Im nächsten Teil

Im nächsten Teil beginnen wir damit, aus mehreren einzelnen Grundkörpern ein gemeinsames Bauteil zu erzeugen.

Dazu lernen wir:

union();

Mit union() können mehrere Geometrien logisch zu einer gemeinsamen Form zusammengefasst werden.

Wir verwenden dafür unsere Halterung aus dieser Lektion und bauen sie Schritt für Schritt weiter aus.

Passendes Cheatsheet

Im Cheatsheet „Transformationen und Koordinaten“ findest du die Befehle dieser Lektion kompakt zum Nachschlagen. Du kannst das Cheatsheet auch direkt als PDF herunterladen.