OpenSCAD für Anfänger – Teil 6: Körper verbinden mit union()

Voraussetzungen

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

Kapitel 2 – Richtig konstruieren

Mit Teil 6 beginnt das zweite Kapitel unseres OpenSCAD-Einsteigerkurses.

In den ersten fünf Teilen haben wir die wichtigsten Grundlagen kennengelernt:

• OpenSCAD-Syntax

• Variablen und Berechnungen

• Grundkörper

• translate()

• rotate()

• scale()

• mirror()

Jetzt beginnen wir damit, diese Werkzeuge zu echten Konstruktionen zu kombinieren.

Der erste neue Befehl dafür lautet:

union();

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

Lernziel: Nach dieser Lektion kannst du mehrere Grundkörper mit union() zu einer gemeinsamen Konstruktion zusammenfassen und komplexere Codebereiche mit geschweiften Klammern sauber strukturieren.

Mehrere Körper in einem Modell

Betrachten wir zunächst zwei einfache Körper:

cube([40, 30, 10]);

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

In der 3D-Ansicht sieht diese Kombination bereits wie ein gemeinsames Bauteil aus.

Im Quelltext sind es jedoch zunächst zwei getrennte Geometrien.

Körper mit union() zusammenfassen

Der grundsätzliche Aufbau lautet:

union() {

    objekt1();

    objekt2();
}

Für unser Beispiel:

union() {

    cube([40, 30, 10]);

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

Alle Objekte innerhalb der geschweiften Klammern gehören jetzt zur gleichen union()-Operation.

Was bedeutet union()?

Das englische Wort union bedeutet in diesem Zusammenhang Vereinigung.

Mehrere geometrische Objekte werden gemeinsam betrachtet.

Beispielsweise:

Quader
+
Steg
+
weiterer Steg
=
gemeinsame Geometrie

union() ist eine der grundlegenden booleschen Operationen in OpenSCAD.

Weitere lernen wir in den nächsten Lektionen kennen.

Geschweifte Klammern

Mit union() begegnen uns geschweifte Klammern besonders deutlich:

union() {

    ...

}

Alles zwischen:

{

und:

}

gehört zu diesem Block.

Innerhalb eines solchen Blocks können beliebig viele Geometrien stehen.

Mehrere Körper verbinden

Beispiel:

union() {

    cube([60, 40, 5]);

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

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

Damit entsteht eine einfache U-förmige Halterung.

Warum union() verwenden?

Bei einfachen Modellen sieht das Ergebnis teilweise auch ohne union() korrekt aus.

Trotzdem hat die explizite Vereinigung mehrere Vorteile.

Bessere Struktur

Es wird sofort klar:

Diese Geometrien gehören zusammen.

Vorbereitung auf weitere Operationen

Später können wir eine komplette vereinigte Geometrie beispielsweise in:

difference()

verwenden.

Bessere Lesbarkeit

Komplexere Modelle können in logische Baugruppen unterteilt werden.

Code sauber einrücken

Mit zunehmender Verschachtelung wird eine saubere Einrückung immer wichtiger.

Beispiel:

union() {

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

}

Die Einrückung ist vor allem für uns Menschen wichtig.

Sie zeigt auf einen Blick:

union
└── translate
    └── cube

Parametrische U-Halterung

Wir greifen die symmetrische Konstruktion aus Teil 5 wieder auf.

Parameter

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

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

steg_abstand = 25;

Grundplatte

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

Rechter Steg

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

Linker Steg

Den zweiten Steg erzeugen wir durch Spiegelung:

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

Alles gemeinsam mit union()

Jetzt kommen alle drei Geometrien in einen gemeinsamen Block:

union() {

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

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

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

Müssen sich die Körper berühren?

Ein wichtiger Punkt:

union() kann auch räumlich getrennte Körper enthalten.

Beispielsweise:

union() {

    cube([20, 20, 10]);

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

Die beiden Quader gehören zwar zur gleichen union()-Operation, sie sind aber räumlich nicht miteinander verbunden.

Für ein zusammenhängendes 3D-Druckteil sollten sich die einzelnen Körper daher berühren oder überlappen.

Geometrien leicht überlappen lassen

In einigen Situationen ist es sinnvoll, zwei Körper minimal überlappen zu lassen.

Beispiel:

ueberlappung = 0.1;

Die Position eines Stegs könnte dann leicht verändert werden.

Der Vorteil:

Zwei Körper liegen nicht nur exakt Fläche auf Fläche, sondern besitzen tatsächlich ein kleines gemeinsames Volumen.

Für den Einstieg ist das noch kein zwingendes Thema, bei komplexeren Konstruktionen kann es jedoch hilfreich sein.

Praxisprojekt: einfacher Winkelhalter

Als zweites Beispiel erstellen wir einen parametrischen Winkelhalter.

Er besteht aus:

• einer Grundplatte

• einer senkrechten Rückwand

Parameter

breite = 60;
tiefe = 30;
hoehe = 40;
wand = 5;

Grundplatte

cube([
    breite,
    tiefe,
    wand
]);

Rückwand

translate([
    0,
    0,
    wand
])
    cube([
        breite,
        wand,
        hoehe - wand
    ]);

Beide Körper vereinigen

union() {

    cube([
        breite,
        tiefe,
        wand
    ]);

    translate([
        0,
        0,
        wand
    ])
        cube([
            breite,
            wand,
            hoehe - wand
        ]);
}

Vollständiger parametrischer Winkelhalter

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

breite = 60;
tiefe = 30;
hoehe = 40;
wand = 5;

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

union() {

    // Grundplatte
    cube([
        breite,
        tiefe,
        wand
    ]);

    // Rückwand
    translate([
        0,
        0,
        wand
    ])
        cube([
            breite,
            wand,
            hoehe - wand
        ]);
}

Damit haben wir ein kleines, aber bereits vollständig parametrisches Bauteil.

Mitmach-Aufgabe

Erstelle einen parametrischen Winkelhalter.

Abmessungen

Verwende:

cube()
translate()
union()

Grundplatte und Rückwand sollen über gemeinsame Parameter gesteuert werden.

Musterlösung

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

breite = 80;
tiefe = 40;
hoehe = 50;
wand = 6;

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

union() {

    // Grundplatte
    cube([
        breite,
        tiefe,
        wand
    ]);

    // Rückwand
    translate([
        0,
        0,
        wand
    ])
        cube([
            breite,
            wand,
            hoehe - wand
        ]);
}

Teste anschließend beispielsweise:

wand = 8;

oder:

hoehe = 70;

Die Konstruktion sollte sich automatisch anpassen.

Was haben wir gelernt?

Nach dieser Lektion kennst du die erste wichtige boolesche Operation in OpenSCAD:

union();

Du weißt:

• mehrere Geometrien können in einem union()-Block zusammengefasst werden

• geschweifte Klammern bilden einen gemeinsamen Codeblock

• beliebig viele Objekte können innerhalb einer Vereinigung stehen

• saubere Einrückung verbessert die Lesbarkeit

• zusammengehörige Geometrien sollten bei einem echten Bauteil räumlich verbunden sein

• union() bildet eine wichtige Grundlage für komplexere boolesche Konstruktionen

Im nächsten Teil

Im nächsten Teil lernen wir wahrscheinlich eine der wichtigsten Funktionen für technische OpenSCAD-Modelle kennen:

difference();

Mit difference() können wir Geometrie entfernen.

Damit erzeugen wir beispielsweise:

• Bohrungen

• Ausschnitte

• Taschen

• Durchbrüche

• Hohlräume

Unser Winkelhalter bekommt damit im nächsten Schritt seine ersten Befestigungsbohrungen.

Passendes Cheatsheet

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

Weiter geht es mit Teil 7: Löcher und Ausschnitte mit difference().