Suche
MenüSchließen
OpenSCAD für Anfänger · Teil 4TutorialEinsteiger

OpenSCAD

OpenSCAD für Anfänger – Teil 4: Objekte verschieben und drehen

Positioniere und drehe Grundkörper mit translate() und rotate() und lerne, warum die Reihenfolge der Transformationen wichtig ist.

Veröffentlicht am · Aktualisiert am

5 Minuten Lesezeit · 1 PDF-Download

Voraussetzungen

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

In den bisherigen Teilen haben wir grundlegende OpenSCAD-Syntax, Variablen und die wichtigsten 3D-Grundkörper kennengelernt.

Bisher wurden unsere Körper allerdings immer am Ursprung des Koordinatensystems erzeugt.

Für echte Konstruktionen reicht das natürlich nicht aus.

Wir müssen einzelne Elemente gezielt positionieren und drehen können.

Dafür stellt OpenSCAD zwei besonders wichtige Transformationen bereit:

translate();
rotate();

Lernziel: Nach dieser Lektion kannst du Objekte entlang der X-, Y- und Z-Achse verschieben, um diese Achsen drehen und mehrere Grundkörper gezielt zu einem ersten Bauteil anordnen.

Warum müssen Objekte verschoben werden?

Erzeugen wir mehrere Grundkörper ohne weitere Angaben:

cube([40, 30, 10]);

cylinder(h=20, d=15, $fn=64);

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

werden alle am Ursprung erzeugt.

Dadurch können sich die Körper gegenseitig überlagern.

Damit wir diese Körper gezielt anordnen können, verwenden wir translate().

Objekte mit translate() verschieben

Die allgemeine Schreibweise lautet:

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

Die drei Werte stehen für die Verschiebung entlang der drei Raumachsen.

Beispiel:

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

Der Quader wird um 30 mm in positive X-Richtung verschoben.

Verschieben in X-Richtung

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

Bedeutung:

Achse Verschiebung
X 30 mm
Y 0 mm
Z 0 mm

Verschieben in Y-Richtung

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

Der Körper wird um 30 mm entlang der Y-Achse verschoben.

Verschieben in Z-Richtung

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

Der Körper wird um 20 mm nach oben verschoben.

Negative Werte

Auch negative Koordinaten sind möglich.

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

Dadurch bewegt sich der Körper in negative X-Richtung.

Dasselbe gilt für Y und Z.

Mehrere Grundkörper anordnen

Jetzt können wir die in Teil 3 kennengelernten Grundkörper gezielt verteilen:

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

translate([0, 0, 0])
    cylinder(h=20, d=15, $fn=64);

translate([30, 0, 10])
    sphere(d=20, $fn=64);

Damit können wir erstmals mehrere Geometrien unabhängig voneinander positionieren.

OpenSCAD-Editor mit translate-Aufrufen und räumlich getrennten Grundkörpern: Kugel, Zylinder und Quader.
translate() verteilt die drei Grundkörper auf getrennte Positionen im Koordinatensystem.

Positionen parametrisch definieren

Auch Positionen müssen nicht als feste Zahlen angegeben werden.

Beispiel:

abstand = 30;

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

translate([abstand, 0, 10])
    sphere(d=20, $fn=64);

Ändern wir:

abstand = 50;

werden beide Körper automatisch weiter auseinander positioniert.

So bleiben auch Positionsangaben parametrisch.

Objekte mit rotate() drehen

Mit rotate() können Körper um die drei Raumachsen gedreht werden.

Die allgemeine Schreibweise lautet:

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

Die Werte werden in Grad angegeben.

Beispiel:

rotate([0, 0, 45])
    cube([40, 10, 5]);

Der Quader wird um 45 Grad um die Z-Achse gedreht.

Drehung um die X-Achse

Ein Zylinder wird standardmäßig entlang der Z-Achse erzeugt.

cylinder(h=30, d=10, $fn=64);

Mit:

rotate([90, 0, 0])
    cylinder(h=30, d=10, $fn=64);

wird der Zylinder um 90 Grad um die X-Achse gedreht.

Drehung um die Y-Achse

rotate([0, 90, 0])
    cylinder(h=30, d=10, $fn=64);

Auch damit lässt sich ein Zylinder horizontal ausrichten, allerdings in einer anderen Richtung.

Drehung um die Z-Achse

rotate([0, 0, 45])
    cube([40, 10, 5]);

Diese Drehung erfolgt innerhalb der XY-Ebene.

Gerade bei Platten, Armen oder diagonalen Verstrebungen wird das später häufig benötigt.

Die Reihenfolge ist wichtig

Transformationen können ineinander verschachtelt werden.

Beispiel:

translate([30, 0, 0])
    rotate([0, 0, 45])
        cube([40, 10, 5]);

OpenSCAD wertet diesen Aufbau von innen nach außen aus.

Das bedeutet:

  1. Quader erzeugen

  2. Quader drehen

  3. gedrehten Quader verschieben

Man kann sich den Aufbau also so vorstellen:

translate
└── rotate
    └── cube

Warum ist die Reihenfolge wichtig?

Vergleichen wir:

translate([30, 0, 0])
    rotate([0, 0, 45])
        cube([40, 10, 5]);

mit:

rotate([0, 0, 45])
    translate([30, 0, 0])
        cube([40, 10, 5]);

Obwohl dieselben Werte verwendet werden, kann das Ergebnis unterschiedlich sein.

Im zweiten Beispiel wird zunächst der Quader verschoben und anschließend diese komplette Position um den Ursprung gedreht.

Praxisprojekt: einfache Halterung

Jetzt verwenden wir translate(), um eine erste einfache Halterung aufzubauen.

Sie besteht aus:

  • einer Grundplatte

  • einem senkrechten Steg

Die Grundplatte erhält:

Parameter Wert
Breite 60 mm
Tiefe 40 mm
Höhe 5 mm

Der Steg erhält:

Parameter Wert
Breite 10 mm
Tiefe 40 mm
Höhe 30 mm

Grundplatte

platte_b = 60;
platte_t = 40;
platte_h = 5;

cube([platte_b, platte_t, platte_h]);

Steg positionieren

Der Steg soll auf der Oberseite der Grundplatte stehen.

steg_b = 10;
steg_t = 40;
steg_h = 30;

translate([25, 0, platte_h])
    cube([steg_b, steg_t, steg_h]);

Für die Z-Position verwenden wir direkt:

platte_h

Damit steht der Steg immer auf der Oberseite der Grundplatte – auch wenn deren Dicke später verändert wird.

Den Steg automatisch zentrieren

Statt die X-Position fest mit 25 anzugeben, können wir sie berechnen:

steg_x = (platte_b - steg_b) / 2;

Dann verwenden wir:

translate([steg_x, 0, platte_h])
    cube([steg_b, steg_t, steg_h]);

Der vollständige Code lautet:

// -------------------------
// Grundplatte
// -------------------------

platte_b = 60;
platte_t = 40;
platte_h = 5;

// -------------------------
// Steg
// -------------------------

steg_b = 10;
steg_t = 40;
steg_h = 30;

// Position berechnen

steg_x = (platte_b - steg_b) / 2;

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

cube([platte_b, platte_t, platte_h]);

translate([steg_x, 0, platte_h])
    cube([steg_b, steg_t, steg_h]);

Jetzt bleibt der Steg automatisch mittig positioniert.

Warum ist diese Berechnung sinnvoll?

Angenommen, wir ändern:

platte_b = 100;

Dann wird die Position des Stegs automatisch neu berechnet.

Wir müssen keine Position von Hand verändern.

Das ist eines der grundlegenden Prinzipien parametrischer Konstruktion:

Ein Wert sollte möglichst aus bereits vorhandenen Parametern berechnet werden, wenn zwischen diesen Werten eine logische Beziehung besteht.

Mitmach-Aufgabe

Erstelle eine einfache parametrische Halterung.

Grundplatte

Parameter Wert
Breite 80 mm
Tiefe 50 mm
Höhe 5 mm

Steg

Parameter Wert
Breite 10 mm
Tiefe 50 mm
Höhe 35 mm

Der Steg soll:

  • auf der Oberseite der Grundplatte stehen

  • in X-Richtung automatisch mittig positioniert werden

Versuche die Position aus den vorhandenen Parametern zu berechnen.

Musterlösung

// -------------------------
// Grundplatte
// -------------------------

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

// -------------------------
// Steg
// -------------------------

steg_b = 10;
steg_t = 50;
steg_h = 35;

// -------------------------
// Berechnungen
// -------------------------

steg_x = (platte_b - steg_b) / 2;

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

cube([platte_b, platte_t, platte_h]);

translate([steg_x, 0, platte_h])
    cube([steg_b, steg_t, steg_h]);

Teste anschließend beispielsweise:

platte_b = 100;

Der Steg sollte weiterhin automatisch mittig auf der Grundplatte stehen.

Was haben wir gelernt?

Nach dieser Lektion kannst du Objekte gezielt im dreidimensionalen Raum anordnen.

Du kennst:

translate();
rotate();

und weißt:

  • translate([X,Y,Z]) verschiebt einen Körper

  • positive und negative Werte sind möglich

  • rotate([X,Y,Z]) dreht einen Körper

  • Drehwinkel werden in Grad angegeben

  • Transformationen lassen sich verschachteln

  • OpenSCAD wertet verschachtelte Transformationen von innen nach außen aus

  • Positionen können aus Parametern berechnet werden

  • Bauteile können dadurch automatisch korrekt ausgerichtet bleiben

Damit können wir erstmals mehrere Grundkörper sinnvoll zu einer Konstruktion anordnen.

Im nächsten Teil

Im fünften Teil lernen wir zwei weitere Transformationen kennen:

scale();
mirror();

Mit scale() können wir Modelle vergrößern, verkleinern oder gezielt in einzelnen Richtungen strecken.

Mit mirror() können wir Geometrien spiegeln.

Das ist besonders praktisch für symmetrische Bauteile.

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.