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

OpenSCAD

OpenSCAD für Anfänger – Teil 17: Qualität und Rundungen mit $fn, $fa und $fs

Steuere die Rundungsqualität in OpenSCAD mit $fn, $fa und $fs. Vergleiche Vorschau und Rendering und optimiere einen parametrischen Drehknopf.

Veröffentlicht am

7 Minuten Lesezeit

Steuere die Rundungsqualität in OpenSCAD mit $fn, $fa und $fs. Vergleiche Vorschau und Rendering und optimiere einen parametrischen Drehknopf.

Voraussetzungen

Du brauchst OpenSCAD und die Grundlagen aus Teil 16. Die Beispiele verwenden die klassische OpenSCAD-Syntax; eine Ausführung mit einer konkreten Softwareversion wurde hier nicht geprüft. Wir behandeln eine Modelleinheit als einen Millimeter.

Kapitel 4 – Von 2D zu 3D

Runde Geometrien wie Kreise, Zylinder oder Kugeln sehen auf dem Bildschirm zwar rund aus, bestehen intern aber aus vielen geraden Segmenten.

Wie fein diese Segmente sind, beeinflusst sowohl:

  • die sichtbare Qualität

  • die Renderzeit

  • die Komplexität des Modells

  • die Größe exportierter Mesh-Dateien

OpenSCAD stellt dafür insbesondere drei spezielle Variablen bereit:

$fn
$fa
$fs

Lernziel:
Nach dieser Lektion kannst du die Auflösung runder Geometrien kontrollieren und zwischen Vorschauqualität und finaler Modellqualität unterscheiden.

Warum sind Rundungen polygonal?

Ein Kreis wird intern nicht als mathematisch unendlich glatte Kontur dargestellt.

Stattdessen wird er durch viele kurze Geraden angenähert.

Ein Zylinder mit:

$fn=8

besitzt daher nur acht Seiten.

Beispiel:

cylinder(
    h=20,
    d=30,
    $fn=8
);

Qualität mit $fn beeinflussen

Erhöhen wir den Wert:

cylinder(
    h=20,
    d=30,
    $fn=32
);

wird der Körper deutlich runder.

Mit:

cylinder(
    h=20,
    d=30,
    $fn=96
);

ist die Rundung sehr fein.

Was bedeutet $fn?

$fn definiert die Anzahl der Fragmente einer Rundung.

Vereinfacht:

$fn Wirkung
8 sehr grob
16 grob
32 mittel
64 fein
96+ sehr fein

Die tatsächlich sinnvolle Zahl hängt immer von Größe und Einsatzzweck des Modells ab.

$fn global setzen

Statt $fn an jedem Körper anzugeben, kann ein globaler Wert definiert werden:

$fn = 64;

cylinder(
    h=20,
    d=30
);

sphere(
    d=30
);

Damit verwenden beide Geometrien denselben Wert.

Lokale Werte überschreiben

Ein einzelner Körper kann trotzdem einen anderen Wert verwenden:

$fn = 32;

cylinder(
    h=20,
    d=30
);

translate([
    50,
    0,
    0
])
    cylinder(
        h=20,
        d=30,
        $fn=96
    );

Warum ein fixer $fn-Wert nicht immer ideal ist

Ein sehr kleiner Kreis benötigt normalerweise weniger Segmente als ein großer Kreis.

Werden beide mit:

$fn=64

erzeugt, kann der kleine unnötig komplex und der große möglicherweise noch sichtbar kantig sein.

Für solche Situationen stehen:

$fa
$fs

zur Verfügung.

$fa – Winkelauflösung

$fa definiert den Mindestwinkel für die automatische Segmentberechnung.

Beispiel:

$fa = 30;

circle(
    d=40
);

erzeugt eine relativ grobe Kontur.

Mit:

$fa = 5;

circle(
    d=40
);

wird die Kontur feiner.

Ein kleinerer $fa-Wert führt im Allgemeinen zu mehr Segmenten.

$fs – Segmentgröße

$fs beeinflusst die Mindestgröße der Segmente für die automatische Auflösung.

Beispiel:

$fs = 2;

Bei größeren Rundungen werden dadurch automatisch mehr Segmente verwendet als bei kleinen.

Das macht $fs besonders interessant für Modelle mit sehr unterschiedlich großen Kreisen und Radien.

Zusammenspiel von $fa und $fs

Wenn $fn nicht ausdrücklich vorgegeben ist, kann OpenSCAD die Anzahl der Segmente aus $fa und $fs bestimmen.

Damit passt sich die Auflösung stärker an die jeweilige Geometrie an.

Für parametrische Modelle kann das sinnvoller sein als ein starrer $fn-Wert.

Höhere Qualität bedeutet mehr Geometrie

Eine feinere Rundung erzeugt mehr Polygone.

Das kann bedeuten:

  • längere Vorschauzeit

  • längere Renderzeit

  • größere STL-Dateien

  • mehr Speicherbedarf

  • langsamere boolesche Operationen

Besonders bei:

  • vielen Bohrungen

  • Kugeln

  • komplexen Rotationskörpern

  • großen Schleifen

kann sich das deutlich bemerkbar machen.

Mehr Polygone bedeuten nicht automatisch besseren 3D-Druck

Die tatsächliche Druckqualität hängt auch vom Druckverfahren ab.

Beim FDM-Druck beispielsweise von:

  • Düsendurchmesser

  • Layerhöhe

  • Druckgeschwindigkeit

  • Maschinenmechanik

  • Slicer-Einstellungen

Eine extrem hoch aufgelöste STL-Datei kann daher deutlich komplexer sein, ohne dass der Ausdruck sichtbar besser wird.

Sinnvolle Qualität wählen

Ein universeller Wert existiert nicht.

Für viele kleine bis mittelgroße technische Bauteile kann beispielsweise:

$fn=48

oder:

$fn=64

bereits gut funktionieren.

Bei größeren sichtbaren Rundungen können höhere Werte sinnvoll sein.

Bei internen oder kaum sichtbaren Geometrien häufig niedrigere.

Qualität parametrisch machen

Eine einfache Strategie:

qualitaet = 64;

Danach:

cylinder(
    h=20,
    d=30,
    $fn=qualitaet
);

Damit wird die Auflösung zentral steuerbar.

Vorschau und Rendering unterscheiden

Während der Konstruktion benötigt man häufig keine extrem hohe Qualität.

OpenSCAD stellt dafür:

$preview

zur Verfügung.

Damit kann beispielsweise geschrieben werden:

qualitaet =
    $preview
        ? 24
        : 96;

Das bedeutet:

Vorschau → 24 Segmente
Finales Rendering → 96 Segmente

Praxisprojekt: Drehknopf optimieren

Wir verwenden den Drehknopf aus Teil 15.

Qualitätsparameter

qualitaet_vorschau = 24;
qualitaet_final = 96;

qualitaet =
    $preview
        ? qualitaet_vorschau
        : qualitaet_final;

Geometrie

radius_unten = 15;
radius_oben = 13;
hoehe = 12;

achsen_d = 6;
ueberstand = 1;

profil = [
    [0, 0],
    [radius_unten, 0],
    [radius_oben, hoehe],
    [0, hoehe]
];

difference() {

    rotate_extrude(
        $fn=qualitaet
    )
        polygon(profil);

    translate([
        0,
        0,
        -ueberstand
    ])
        cylinder(
            h=hoehe + 2 * ueberstand,
            d=achsen_d,
            $fn=qualitaet
        );
}

Globale Alternative mit $fa und $fs

Statt $fn fest vorzugeben, kann beispielsweise mit:

$fa = 5;
$fs = 1;

gearbeitet werden.

Dadurch kann OpenSCAD die benötigte Segmentzahl abhängig von der jeweiligen Geometrie bestimmen.

Welche Variante besser ist, hängt vom Modell und vom gewünschten Workflow ab.

Mitmach-Aufgabe

Erstelle einen Zylinder mit:

Parameter Wert
Durchmesser 50 mm
Höhe 20 mm
Vorschauqualität 16
finale Qualität 96

Verwende:

$preview

um automatisch zwischen beiden Qualitätsstufen umzuschalten.

Musterlösung

durchmesser = 50;
hoehe = 20;

qualitaet =
    $preview
        ? 16
        : 96;

cylinder(
    h=hoehe,
    d=durchmesser,
    $fn=qualitaet
);

Was haben wir gelernt?

Die wichtigsten Qualitätsparameter für Rundungen sind:

$fn
$fa
$fs

Dabei gilt:

  • $fn definiert direkt die Segmentanzahl

  • $fa begrenzt den Winkel eines Segments

  • $fs beeinflusst die Segmentgröße

  • hohe Werte beziehungsweise feine Einstellungen erhöhen die Modellkomplexität

  • eine hohe Polygonzahl bedeutet nicht automatisch bessere Druckqualität

  • mit $preview können unterschiedliche Einstellungen für Konstruktion und finales Rendering verwendet werden

Damit können wir Qualität und Performance unserer OpenSCAD-Modelle deutlich bewusster steuern.

Im nächsten Teil

Im nächsten Teil geht es um die Organisation größerer OpenSCAD-Projekte.

Wir lernen:

include
use

Damit können wir:

  • Funktionen auslagern

  • Module in eigene Dateien verschieben

  • wiederverwendbare Bibliotheken aufbauen

  • den Hauptcode deutlich übersichtlicher gestalten

Das ist ein wichtiger Schritt vom einzelnen OpenSCAD-Modell hin zu größeren, strukturierten Projekten.

Wie arbeiten $fa und $fs zusammen?

Bei $fn=0 verwendet OpenSCAD für einen Kreis näherungsweise ceil(max(min(360/$fa, 2*PI*r/$fs), 5)) Segmente. Die kleinere der beiden Auflösungen begrenzt also die Segmentzahl; mindestens fünf Segmente bleiben erhalten. Eine positive Vorgabe für $fn hat Vorrang. Deshalb reicht es nicht immer, nur einen der beiden Werte zu verkleinern.

Weiterlernen

Referenz

Die OpenSCAD-Sprachreferenz verlinkt die Dokumentation der verwendeten Befehle.