Wer Vorlagen für Rapid-Prototyping-Werkstücke erzeugen wollte, war bisher auf teure CAD-Programme angewiesen. Mit den hier vorgestellten Werkzeugen gibt es erstmals eine komplette Kette aus freier Software, die mit einem Povray-Modell beginnt und beim Werkstück aus Polymeren endet.

Damit ein Prototyp oder ein Kleinseriengerät Gestalt annimmt, kommen heute gern so genannte Rapid-Prototyping-Werkstücke zum Einsatz. Dem Hersteller dieser Teile wird dabei eine Datei übermittelt, die eine komplett in Dreiecksfacetten zerlegte Oberfläche des gewünschten Teils beschreibt. Der Dienstleister fertigt auf dieser Grundlage dann das gewünschte Teil mit einem dafür geeigneten Verfahren.

Am gebräuchlichsten sind derzeit Stereolithographie (das Werkstück wird aus einem Gel mittels Laserlicht selektiv ausgehärtet) und selektives Lasersintern, wobei das Teil anhand der CAD-Daten aus einem Pulver durch gezielte örtliche Wärmeeinwirkung in seiner endgültigen Form gebacken wird.

Bereits seit längerem besteht unter Linux die Möglichkeit, dreidimensionale Situationen zu modellieren und fotorealistisch darzustellen. Das Programm Povray und seine Skriptsprache bieten dazu alle notwendigen Fähigkeiten, die Bedienung kann zusätzlich noch durch die Verwendung eines geeigneten Geometrie-Editors wie KPov Modeler oder Sceda vereinfacht werden. Einen optischen Eindruck des vorerst nur virtuell vorhandenen Werkstücks kann man sich also leicht verschaffen.

Wollte man dieses vorhandene Computermodell auch tatsächlich anfertigen lassen, dann war bisher an dieser Stelle die Welt zu Ende. Das Povray-Modell ließ sich nicht weiterverwenden, kein Weg führte an der Benutzung recht kostenintensiver kommerzieller (CAD-)Modellierungssoftware vorbei.

Loch in der Werkzeugkette

Die Alternative ist das Projekt Volume3D, das derzeit vor allem aus einem in Pascal geschriebenen 3D-Kern besteht. Verschiedene mit diesem Kern arbeitende Geometriekonverter erzeugen ein für Rapid Prototyping geeignetes Datenformat aus einem Povray-Modell. Daraus kann dann direkt der Prototyp entstehen. Der 3D-Kern der Software selbst ist nicht ausschließlich auf Linux festgelegt, sondern auch unter anderen Betriebssystemen mit leichten Änderungen übersetz- und ausführbar.

Der Hersteller will für seine Planungen ein Bild von einem Gerät, das es noch gar nicht gibt? Gar kein Problem. Schnell ist ein kleines Povray-Skript geschrieben, ein fotorealistisches Bild erzeugt, etwas montiert. Sieht fast aus wie fotografiert (Abbildung 1). Jetzt müssten sich doch genau so schnell von diesem Teil zehn Stück anfertigen lassen!

Am Anfang stand das Problem

Anfragen in einigen entsprechenden Newsgroups fanden jedoch kaum ermutigende Antworten. Auch andere Quellen im Internet verbreiteten genauso wenig Optimismus. Selbst wenn das Vorhaben ziemlich kompliziert zu sein scheint: Es verheißt die Schließung der bestehenden Lücke zwischen Modellierung und fotorealistischer Darstellung auf der einen Seite und der Materialisierung einer Idee auf der anderen, also einen zu großen Nutzen, um nicht zum Weitermachen anzuspornen.

Welche Komponenten müssen ergänzt werden, um einen durchgehenden Ablauf vom Povray-Modell bis zu den Fertigungs-Grunddaten herzustellen? Ein Parser ist nötig, um die Povray-Modellbeschreibung zu lesen und ein entsprechendes Objektmodell mit triangulierter Oberfläche anzulegen. Darunter liegende Softwareschichten einer 3D-Bibliothek sind für die Erzeugung von Grundformen, Verwaltung, boolesche Operationen und Transformationen sowie den Export in verschiedene Datenformate verantwortlich. Ein Viewer dient nach der Umwandlung des Povray-Modells in eine aus Dreiecken zusammengesetzte (triangulierte) Oberfläche zur Kontrolle, ob die Konvertierung fehlerfrei abgelaufen ist. So stand der Entschluss, mal ein kleines Pascal-Programm zu schreiben, das diese Abläufe automatisiert, schnell fest.

Abbildung 1: Dieses Teil brachte den Stein ins Rollen: Intralogic- Frontblende mit Povray modelliert und visualisiert.

Abbildung 2: Die fertige Intralogic-Groupware-Appliance mit Rapid-Prototyping-Frontteil.

Als Compiler wurde der Free-Pascal-Compiler ausgewählt, der unter Linux, DOS/Windows und OS/2 einsetzbar ist. Als Alternativen wären auch der GNU-Pascal-Compiler – für fast alle Betriebssysteme und Hardware-Umgebungen, er muss aber für exotische Systeme selbst kompiliert werden – oder Borland Turbo Pascal ab Version 6 (DOS) oder Delphi/Kylix geeignet.

Von Fall zu Fall sind kleine Änderungen erforderlich. Es hätte auch C++ sein können – für nicht ganz so systemnahe Programmierung wie im vorliegenden Fall ist Pascal aber kein Nachteil. Falls nahtlose Integration mit C++-Code notwendig ist, kann das mit dem GNU-Compiler am problemlosesten und elegantesten realisiert werden.

Abbildung 3: Das rechtshändige Koordinatensystem bestimmt die Reihenfolge der Eckpunkte.

Also los! Sicherlich wäre auch die GNU Triangulated Surfaces Library eine Überlegung wert gewesen, aber schließlich siegte der Drang, selbst in die Tiefen dreidimensionaler Modellierung vorzudringen und eine schlanke 3D-Bibliothek aufzubauen. Intern liegt die hier vorgestellte Bibliothek von der Datenrepräsentation her nahe an dem für den CAM-Export wichtigen Fileformat STL (definierte Innen- beziehungsweise Außen-Orientierung der Facetten).

Der Befehlsvorrat

Povray hat als Anwender-Interface eine sehr flexible und leistungsfähige Skriptsprache, die für die Beschreibung der zu visualisierenden Situationen Anwendung findet. Povray Script bietet weitreichende Möglichkeiten, virtuelle Körper zu erzeugen, zu animieren und die Erzeugung mit Hilfe von Kontrollstrukturen und Makros zu rationalisieren.

Nicht alles, was sich am Bildschirm darstellen und betrachten lässt, ist auch körperlich herstellbar. Animationssequenzen zum Beispiel eignen sich eher weniger für die Produktion realer Werkstücke. Der Parser muss daher nicht alle Möglichkeiten der Beschreibungssprache von Povray bieten. Eine sinnvolle Teilmenge des Befehlsvorrats reicht für die Konvertierung in ein CAM-taugliches Oberflächenmodell aus; bei Bedarf lässt sie sich erweitern.

Nicht erforderlich sind verschiedene Kontrollstrukturen, Programmschleifen, Oberflächen-, Licht-, Kamera- und Animationseigenschaften. Unverzichtbar dagegen sind die Befehle für die Erzeugung elementarer Objekte, boolesche Operationen zwischen 3D-Objekten, die Vereinbarung von Variablen, Konstanten und Makros. Diese Teilmenge aus dem Povray-Befehlsumfang genügt, um die meisten möglichen Modelle problemlos in ein von der Herstellungsmaschine akzeptiertes Format umzuwandeln.

Ein Datenmodell für 3D-Objekte

Dreidimensionale Körper werden in computertauglicher Form aus triangulierten Oberflächen dargestellt. Dabei muss fast immer ein Kompromiss zwischen den beiden Hauptzielen eingegangen werden: einerseits so wenig Dreiecke wie möglich zu verwenden und andererseits die Idealoberfläche möglichst exakt nachzubilden.

Abbildung 4: Die Mutter aller 3D-Operationen: Verschneidung zweier im Raum angeordneter Dreiecke aneinander.

In der 3D-Bibliothek wird ein Dreieck (Facette) durch seine drei Eckpunkte fixiert. Die Reihenfolge der Eckpunkte bestimmt über die Rechte-Hand-Regel die Innen- und Außenseite der Facette folgendermaßen: Mit Handwurzel an P1, Fingerknöchel an P2 und Fingerspitzen in Richtung P3 zeigt der Daumen der rechten Hand aus dem Objekt heraus, Mittel-, Ring- und kleiner Finger liegen im Objektinneren.

Die Dreiecke eines 3D-Objekts werden in einem Feld gehalten, das nach Anforderung dynamisch reserviert wird. Diese Reservierung im Hauptspeicher erfolgt bei Erzeugung des Objekts. Nachträglich lässt sich die Reservierung auf die tatsächlich verwendete Facettenzahl reduzieren oder auf die maximal mögliche Facettenzahl erhöhen.

Bei der Reservierung sind eventuell notwendige Reserven zu berücksichtigen, um Körper zu vereinigen oder zu schneiden. So kann die Verschneidung zweier Quader aneinander problemlos zu 50 bis 100 Facetten pro Körper führen, auch wenn in der Ausgangssituation nur zwölf Flächen pro Objekt vorhanden waren. Ausschlaggebend für die Verwendung eines Feldes an Stelle einer (flexibler verwendbaren) Liste waren folgende Argumente: einfache Programmierung, kein Daten-Overhead und schnelle Zugriffe. Das Vergrößern und Verkleinern der 3D-Objekte läuft rechentechnisch sehr schnell ab.

tri[1]:=triangle(0,0,0,0,10,5,10,10,5,'Dreieck_1',100);
tri[2]:=triangle(1,2,0,8,10,6,1,10,10,'Dreieck_2',100);
if shape_shape(tri[1],tri[2]) then begin
  tri[1]^.include_triangles(tri[2]);
  export_gts(tri[1],'Tri_Tri.gts');
end;

01 var
02   Dreieck,Quader,Kegelstumpf,Zylinder,Prisma,Ikosaeder,Kugel:pshape_3d;
03   Polygon:ppoly;
04 begin
05   Dreieck:=triangle(0,0,0,10,0,0,10,10,0,'Dreieck',100);
06 
07   Quader:=box(0,0,0,10,2,6,'Quader',1000);
08 
09   Kegelstumpf:=cone(5,10,10,'Kegel',2000);
10 
11   Zylinder:=cylinder(5,10,'Zylinder',2000);
12 
13   Polygon:=create_poly(5);
14   Polygon^[0]:=point(0,0,0);
15   Polygon^[1]:=point(10,0,0);
16   Polygon^[2]:=point(5,10,0);
17   Polygon^[3]:=point(0,10,0);
18   Polygon^[4]:=point(0,0,0);
19   Prisma:=prism(0,10,5,poly,'Prisma',100);
20   Polygon:=free_poly(5);
21 
22   Ikosaeder:=icosaeder(5,'Ikosaeder',1000);
23 
24   Kugel:=sphere(5,'Kugel',10000);
25 
26 { Nutzfunktionen }
27 
28   dispose(Kugel,done);
29   dispose(Ikosaeder,done);
30   dispose(Prisma,done);
31   dispose(Zylinder,done);
32   dispose(Kegelstumpf,done);
33   dispose(Quader,done);
34   dispose(Dreieck,done);
35 end.

Boolesche Logik und etwas Vektorrechnung

In der Praxis gilt: Einen 3D-Körper anfangs immer großzügig erzeugen und nach dem Erzeugen auf seine tatsächliche Größe reduzieren. Bei Operationen wie Verschneiden, Addieren, Subtrahieren sind wieder Reserven notwendig, um die zusätzlich entstehenden Dreiecke aufzunehmen. Also alle beteiligten Objekte vor booleschen Operationen vergrößern, danach wieder reduzieren. Transformationen wie Verschieben und Drehen verändern die Anzahl der benötigten Dreiecksfacetten nicht.

Mit dieser Strategie gehen nur die jeweils gerade aktiven Elemente verschwenderisch mit dem Speicherplatz um, alle anderen Objekte sind auf ihr Mindestmaß beschränkt. Alle Basistypen sowohl für einfache geometrische Objekte als auch komplette dreidimensionale Oberflächenformen sind im Modul »triangle3d.pp« deklariert.

»triangle3d.pp« stellt ebenfalls die elementaren Rechenoperationen bereit, die im dreidimensionalen Raum am häufigsten Verwendung finden. Die Grundrechenarten für Vektoren sind Addition, Subtraktion sowie Punktprodukt und Vektorprodukt mit jeweils zwei Argumenten, Skalierung und Normalisierung mit nur einem Vektorargument. Der Betrag eines Vektors gibt den Abstand zwischen dem Anfangs- und dem Endpunkt des Vektors an.

Darauf aufbauend ermitteln weitere Funktionen eine Ebene aus drei gegebenen Punkten, das Lot eines Punktes auf eine Strecke, den Abstand eines Punktes von einer Strecke oder Ebene, Schnittpunkte von Strecke und Ebene sowie Strecke und Strecke. Die höchsten Level bilden Funktionen, die die Schnittstrecke zweier Dreiecke ermitteln oder feststellen, ob zwei Dreiecke einander Vorder- oder Rückseite zuwenden oder nichts miteinander zu tun haben.

Interessierte können den kompletten mathematischen Hintergrund beispielsweise in[3] nachlesen. Die Vektor-Elementarfunktionen sind hauptsächlich gefragt, wenn es gilt, dreidimensionale Objekte aneinander zu schneiden und vereinigte Objekte zu erzeugen. Natürlich kann auch die Erzeugung eines 3D-Körpers nicht ohne sie erfolgen.

Die Bausteine – elementare Objekte

So wie die Burg aus Holzbausteinen aus vielen einfachsten Objekten besteht, so werden auch komplizierte dreidimensionale Gebilde beim Entwurf aus einfachen Grundkörpern zusammengesetzt. Zur Verfügung stehen einzelne Dreiecke, Quader, Kegel, Zylinder, Prismen, Ikosaeder und Kugeln (Abbildung 5). Die Erzeugungsfunktionen der geometrischen Grundbausteine sind in der Unit »form .pp« zusammengefasst, weitere Objekte lassen sich einfach hinzufügen.

Wie sich alle Basisformen erzeugen lassen, zeigt Listing 2. Jedes 3D-Objekt bekommt zusätzlich zu den formbestimmenden Parametern noch einen Namen und eine Facetten-Maximalanzahl als Parameter (der am weitesten rechts stehende Parameter). Die Facetten-Maximalanzahl gibt an, wie weit ein dreidimensionales Objekt wachsen kann.

Das Wachsen geschieht durch Verschneiden von Objekten aneinander und durch Import von zusätzlichen Facetten in ein Geometriemodell. Die Bedeutung der sonstigen Parameter ist größtenteils selbsterklärend. Runde Formen werden von der Konstante »facet_precision« beeinflusst, die den Winkel zwischen benachbarten Facetten begrenzt. Voreingestellt sind 5¡, das ist aber jederzeit zu ändern. Vorsicht ist bei sehr klein gewählten Winkeln zwischen benachbarten Facetten geboten, weil dann die Zahl der Dreiecksfacetten explodiert.

Abbildung 5: Auch komplizierte dreidimensionale Objekte setzen sich aus diesen einfachen Grundkörpern zusammen: Dreieck, Quader, Kegel oder Kegelstumpf, Zylinder, Prisma, Ikosaeder (wird hier als Basiskörper für die Kugel eingesetzt) und Kugel.

Boolesche Operationen – 3D-Grundrechenarten

Im Gegensatz zum Holzbaukasten, der es nur erlaubt, elementare Körper zu addieren und so zu einem Gesamtkunstwerk zu fügen, bietet das Computermodell mehr Möglichkeiten. Zwei Körper lassen sich addieren oder subtrahieren oder zu einer Gemeinsamkeitsform vereinigen (Abbildung 6).

Diese Grundrechenarten für 3D-Körper sind das Herz aller 3D-Konstruktionen, aus denen später real existierende Teile entstehen sollen. Auch komplizierte Körper mit unregelmäßigen Formen und vielen Facetten lassen sich damit bei geringem Aufwand erzeugen. Die drei Funktionen »add_shape«, »sub_shape« und »inter_shape«, die eine körperliche Addition, Subtraktion sowie die Erzeugung der Gemeinsamkeitsform durchführen, sind in der Unit »shape3d.pp« beheimatet. Diese Funktionen liefern einen Zeiger auf ein vollständig neues 3D-Objekt als Ergebnis.

Die als Argumente in die Operation eingespeisten Zeiger auf die Ausgangsobjekte sind nach der Durchführung ungültig und dürfen für weitere Operationen nicht mehr verwendet werden. Bei der Operation Subtraktion entscheidet die jeweilige Reihenfolge der Argumente darüber, welcher Körper von welchem subtrahiert wird.

Komplikationen und Transformationen

Solange die betroffenen Körper einander sauber schneiden, funktionieren die Algorithmen der 3D-Grundrechenarten problemlos. Sobald allerdings Partien der Oberfläche beider betrachteter Körper identisch sind (also in der gleichen Ebene liegen), sind zusätzliche Feinheiten zu beachten. Für die Behandlung identischer und anti-identischer Oberflächenpartien sind daher gesonderte Prüfungen in den Funktionen »add_shape«, »sub_shape« und »inter_shape« vorgesehen, die diese Oberflächenpartien entfernen oder solche zweilagigen Partien auf eine Lage reduzieren.

Die Transformations-Operationen Verschiebung, Drehung und Streckung schaffen die Voraussetzungen dafür, einmal konstruierte Objekte an unterschiedlichen Positionen und in verschiedenen Lagen und Größen zu verwenden. Die Transformationsfunktionen sind in der Unit »trans3d.pp« zusammengefasst.

Daten doppelt exportieren – GTS und STL

Import- und Exportfunktionen stehen in der Unit »export3d.pp«. Zusätzlich zum STL-Format für die Fertigung des Objekts ist auch ein Export in das Format GTS vorgesehen, es schafft die Verbindung zur Open-GL-Visualisierung mit dem Mesh Viewer. Sie dient vor allem der Kontrolle erzeugter Objekte auf korrekte Modellierung. Das exportierte GTS-File enthält nahezu die gleichen Informationen wie das STL-File, das für die CAM-Anbindung Verwendung findet. Detailunterschiede beider Fileformate bestehen darin, dass GTS 3D-Primitive 1., 2. und 3. Ordnung (Punkte, Linien und Dreiecke) abspeichert – allerdings geht durch das Umsortieren von Punkten und Kanten die klare Festlegung über Innen- und Außenseite der enthaltenen Facetten verloren.

Abbildung 6: Ein Beispiel für die 3D-Grundrechenarten: Aus einem Ikosaeder (a) und einem Quader (b) enstehen folgende Formen: ein Ikosaeder (c) und ein Quader (d), wobei die Oberfläche entlang der Schnittkanten beider Körper geschnitten wird, addierte Körper (e), vom Ikosaeder subtrahierter Quader (f), vom Quader subtrahierter Ikosaeder (g) und die Gemeinschaftsform beider Körper (h).

Der innere Aufbau eines GTS-File ist simpel. Die erste Zeile mit drei ganzzahligen Werten gibt Auskunft darüber, wie viele Geometrieelemente welcher Art (Punkte, Kanten, Flächen) zum repräsentierten Modell gehören. Die folgenden Datenblöcke enthalten (in dieser Reihenfolge) in jeweils einer Zeile die Koordinaten eines Punktes, die Endpunkte einer Kante und die Indizes der zu einer Dreiecks-Oberflächenfacette gehörenden Kanten. Punktkoordinaten werden durch drei Gleitkommazahlen dargestellt. Zeilen mit zwei Ganzzahlen enthalten die Indizes der Endpunkte einer Kante, Zeilen mit drei Ganzzahlen die Indizes der Kanten einer Dreiecksfacette. Die Anzahl der Zeilen in jedem Datenblock stimmt mit der Anzahl der Elemente der jeweiligen Art überein.

tri[1]:=triangle(0,0,0,0,10,5,10,10,5,'Dreieck_1',100);
tri[2]:=triangle(0,0,0,0,10,5,10,10,5,'Dreieck_2',100);
translate(12,0,0,tri[2]);
tri[1]^.include_triangles(tri[2]);
export_gts(tri[1],'Translat.gts');

tri[1]:=triangle(0,0,0,0,10,5,10,10,5,'Dreieck_1',100);
tri[2]:=triangle(0,0,0,0,10,5,10,10,5,'Dreieck_2',100);
rotate(0,0,0,0,0,1,PI/3,tri[2]);
tri[1]^.include_triangles(tri[2]);
export_gts(tri[1],'Rotat.gts');

tri[1]:=triangle(0,0,0,0,10,5,10,10,5,'Dreieck_1',100);
tri[2]:=triangle(0,0,0,0,10,5,10,10,5,'Dreieck_2',100);
rotate(0,0,2.5,2,tri[2]);
tri[1]^.include_triangles(tri[2]);
export_gts(tri[1],'Scale.gts');

01 6 6 2
02  0.000000000000000E+000  0.000000000000000E+000 -2.500000000000000E+000
03  0.000000000000000E+000  0.000000000000000E+000  0.000000000000000E+000
04  0.000000000000000E+000  1.000000000000000E+001  5.000000000000000E+000
05  0.000000000000000E+000  2.000000000000000E+001  7.500000000000000E+000
06  1.000000000000000E+001  1.000000000000000E+001  5.000000000000000E+000
07  2.000000000000000E+001  2.000000000000000E+001  7.500000000000000E+000
08 1 4
09 1 6
10 2 3
11 2 5
12 3 5
13 4 6
14 1 2 6
15 3 4 5

STL-Fileformat – Standard für die Fertigung

Das STL-Fileformat ist das für die Fertigung von 3D-Körpern übliche Fileformat. Die Bezeichnung rührt vom Stereolithographie-Verfahren (STL) her, in dem das Werkstück mit Laserlicht aus einem Materialgel gezielt ausgehärtet wird. Eingebettet zwischen die Start- und Stoppmarken »solid« und »endsolid« steht für jede Oberflächenfacette ein siebenzeiliger Eintrag der im Beispiel zu sehenden Form (»facet…endfacet«).

In der Regel können die Produktionsanlagen die Facettennormale aus den gegebenen Punkten selbst errechnen. Falls dies geschehen soll, ist die Normalenrichtung mit »0 0 0« anzugeben. Andernfalls wird an dieser Stelle ein Vektor der Länge »1« erwartet, der senkrecht auf der Dreiecksfläche steht und nach außen zeigt. Die Vertex-Werte stellen die Koordinaten der Eckpunkte der Dreiecksfacette dar. Die neben dem Ascii-STL-Format ebenfalls existierende binäre Darstellung unterstützt die Volume3D-Bibliothek derzeit nicht.

Die visuelle Abschlusskontrolle eines fertig konstruierten Bauteils vor der Weitergabe in die Fertigung ist eine obligatorische Sicherheitsmaßnahme, die viel Zeit, Geld und Ärger erspart. Gut geeignet für diesen Zweck ist der QT-Mesh-Viewer[2], mit dem auch die in diesem Artikel gezeigten Screenshots entstanden.

Das als GTS-File exportierte 3D-Modell kann mit diesem Werkzeug nicht nur von allen Seiten betrachtet, sondern auch in Schichten aufgeschnitten werden, was eine Tiefenkontrolle des erzeugten Modells möglich macht. Nach erfolgreicher visueller Kontrolle des modellierten Teils steht einer Übertragung des Modells zur Produktionsanlage nichts mehr im Wege.

Hat’s gestimmt? Ergebnisse im Viewer

Nachdem die (Pascal-)programmierte Erzeugung von triangulierten Oberflächen passabel funktioniert, stellt sich als nächste Herausforderung die Schließung der Lücke, die zwischen dem Povray-Modell und der aus Dreiecksfacetten aufgebauten Oberfläche klafft. Traditionell bemüht die Unix/Linux-Welt die Gespanne »lex«/»yacc« beziehungsweise »flex«/»bison«, um Quelltextfiles in die Bestandteile zu zerlegen und Interpreter für verschiedene Anwendungsfälle automatisiert zu erzeugen.

Yaccs, Bisons und andere Rinder und Büffel sind dafür bekannt, etwas störrisch zu sein. Deshalb wurde für die Interpretation der Povray-Skripte nur der Flex-Scanner benutzt, um den Povray-Quelltext in Einzelelemente zu zerlegen und jedem einzeln eine Bedeutung zuzuordnen.

Parser büffelt Povray

Der zugehörige Parser (»povparse«) entstand wieder im Eigenbau in Pascal. Er übernimmt anhand von »flex« übergebener Einzelteile des Quellcodes alle weiteren zur Generierung einer triangulierten Oberfläche notwendigen Schritte und die Aufrufe der Volume3D-Bibliothek. Der Perl-Wrapper »pov2tri« sorgt für die Ausführung beider Programme unter einem Dach. »pov2tri« liest die Povray-Skripte ein und erzeugt daraus 3D-Objekte mit triangulierten Oberflächen, und zwar wahlweise im GTS- oder STL-Fileformat. Zusätzlich kann auch die Präzision vorgegeben werden, mit der gebogene Oberflächenpartien modelliert werden sollen.

Wie eingangs erwähnt verfügt Povray über eine sehr leistungsfähige, flexible und mächtige Skriptsprache. Der hier vorgestellte Parser deckt davon nur einen kleinen Anteil ab. Alle anderen Befehle ignoriert er, gibt jedoch eine Liste der ignorierten Befehle aus. Der Anwender kann dann selbst entscheiden, ob diese Liste seinen Vorstellungen entspricht und alle für ein vollständiges 3D-Teil maßgeblichen Anweisungen umgesetzt wurden.

Die Beschränkung auf einen kleinen Teil der Möglichkeiten eines Povray-Skripts ist nicht nur Parser- sondern auch fertigungsbedingt. In klassischen 3D-Szenen übliche Dinge wie Lichtquellen, unbegrenzte Flächen, Oberflächenfinish, Farben und Texturen haben in der Fertigung keinen Sinn. Bei der Auswahl der zu implementierenden Funktionen sollten also möglichst nur jene vorhanden sein, die für die effiziente Konstruktion von 3D-Teilen von Bedeutung sind.

Gezielte Auswahl von Funktionen

Daher verfügt der Parser unter anderem über die Möglichkeiten, mit Zahlen und Vektoren im Quelltext zu rechnen (vorerst aber nur Grundrechenarten) sowie Makros zu definieren und zu verwenden. Die direkt zu erzeugenden (so genannten primitiven) 3D-Körper sind Quader (»box«), Kugel (»sphere«), Zylinder (»cylinder«), Kegel (»cone«) und Prisma (»prism«). Die Körper lassen sich verschieben (»translate«), rotieren (»rotate«), vereinigen (»union«, »merge«), subtrahieren (»subtract«) und auf den gemeinsamen Rauminhalt reduzieren (»intersection«).

Am Ende des Generierungslaufs werden alle erzeugten 3D-Objekte zusammengefasst und wahlweise als GTS- und/oder STL-File exportiert. Die Möglichkeiten, die sich bereits aus diesen wenigen implementierten Funktionen ergeben, sind in den meisten Fällen völlig ausreichend, um ein für die Fertigung vorgesehenes Teil als räumliches Gebilde zu erzeugen. Listing 6 zeigt die einzelnen Schritte für das simultane Erzeugen eines fotorealistischen Bildes mit Povray und einer triangulierten dreidimensionalen Oberfläche für die gleiche Situation. Aus dem gleichen Quelltextfile »test .pov« generiert Povray ein Bitmap-Bild und »pov2tri« ein GTS-File.

01 solid
02 facet normal  0.000000000000000E+000  4.472135954999580E-001 -8.944271909999160E-001
03   outer loop
04     vertex  0.000000000000000E+000  0.000000000000000E+000  0.000000000000000E+000
05     vertex  0.000000000000000E+000  1.000000000000000E+001  5.000000000000000E+000
06     vertex  1.000000000000000E+001  1.000000000000000E+001  5.000000000000000E+000
07   endloop
08 endfacet
09 facet normal  0.000000000000000E+000  4.472135954999580E-001 -8.944271909999160E-001
10   outer loop
11     vertex  0.000000000000000E+000  0.000000000000000E+000 -2.500000000000000E+000
12     vertex  0.000000000000000E+000  2.000000000000000E+001  7.500000000000000E+000
13     vertex  2.000000000000000E+001  2.000000000000000E+001  7.500000000000000E+000
14   endloop
15 endfacet
16 endsolid

01 // test.pov: Test- und Demoscript fuer die
02 // Erzeugung triangulierter Oberflaechen aus Povray-Quellen
03 
04 #include "colors.inc"
05 #include "textures.inc"
06 
07 
08 // Variablendeklarationen (geometrische Abmessungen)
09 #declare Breite = 5;
10 #declare Hoehe = 3;
11 #declare Laenge = 10;
12 #declare D_Breite = 4;
13 #declare D_Hoehe = 2;
14 #declare D_Laenge = 7;
15 #declare Radius = 3;
16 
17 camera {
18     location <-20*Laenge, 100*Hoehe, Laenge>
19     look_at 

20     angle 5
21 }
22 
23 light_source { <-500, 500, -500> White }
24 light_source { <-300, 1500, 500> White }
25 
26 plane { y, -.1
27         texture {
28         pigment { White }
29                 finish { ambient 1 }
30         }
31 }
32 
33 
34 // Makrodeklaration fuer Quader
35 #declare Quader = box {
36     <0, 0, 0> 

37 }
38 
39 // Makrodeklaration fuer Zylinder
40 #declare Zylinder = cylinder {
41     <0,-Hoehe,0> <0,2*Hoehe+D_Hoehe,0> Radius
42 }
43 
44 // Addierte Quader mit ausgeschnittenem Zylinderstueck
45 difference {
46   union {
47     object { Quader pigment { Red } }
48     object { Quader translate <D_Breite,D_Hoehe,D_Laenge> pigment { Blue } }
49   }
50 
51   object { Zylinder translate <0,0,0> }
52 }
53 
54 // Freistehender Zylinder
55 object { Zylinder translate <2*Breite+D_Breite,0,0> pigment { Gray } }

Entgegen allen in Natur- und Ingenieurwissenschaften üblichen Gepflogenheiten setzt Povray ein linkshändiges Koordinatensystem ein. »pov2tri« rechnet daher die Koordinatenwerte beim Import in die Volume3D-Bibliothek auf ein rechtshändiges System um, wie es auch in den Exportfiles Verwendung findet. Dazu genügt die Vorzeichenumkehr aller z-Koordinatenwerte.

Ergänzt wird »pov2tri« durch die beiden Utilities »stl2gts« und »gts2stl«, die eine Umwandlung zwischen den beiden Fileformaten STL und GTS hin und her bewerkstelligen (etwa um STL-Modelle Viewer-fähig zu machen). Die Gesamtstruktur aller bis jetzt realisierten Programmmodule und Bibliotheken ist in dem Übersichtsschema in Abbildung 9 dargestellt.

Reale Virtualität dank Rapid Prototyping

Nachdem alle Konstruktions-, Modellierungs-, Visualisierungs- und Prüfschritte erfolgreich abgeschlossen sind, kommt endlich der Schritt an die Reihe, der den eigentlichen Nutzen aller Vorarbeiten ausmacht: die reale Herstellung des modellierten Objekts mit einem Rapid-Prototyping-Verfahren (RP). Um unnötige Kosten und Ärger zu vermeiden, ist aber zuvor noch eine genaue Prüfung der gesamten Objektoberfläche im 3D- Viewer bis ins Detail unerlässlich, ebenso wie eine Fahrt in die Tiefe (siehe Abbildung 7). Erst wenn mit dieser Endkontrolle alle Zweifel an der korrekten Modellierung ausgeräumt sind, sollte die Fertigung beauftragt werden.

Fertigungstechnisch besteht die Wahl zwischen dem Stereolithographie-Verfahren (STL) und dem selektiven Lasersintern (SLS). Beim STL-Verfahren kommt ein Gel zum Einsatz, das am Schnittpunkt zweier Laserstrahlen aushärtet. SLS-Teile werden – ebenfalls per Laser – schichtweise aus einem Pulver hergestellt, wobei die zum Werkstück gehörigen Partien vom Laser erwärmt und so lokal miteinander und mit dem bereits vorhandenen Werkstückstumpf verschmelzen.

Im STL-Verfahren hergestellte Werkstücke weisen eine gute Oberflächenqualität und detaillierte Strukturen auf, sind aber mechanisch wenig belastbar. Sie dienen hauptsächlich dazu, eine Gussform zur Fertigung von Kleinserien herzustellen.

Herstellung aus Polymer-Gel oder Pulver

SLS-Werkstücke kommen in ihren mechanischen Eigenschaften den im Spritzgussverfahren hergestellten Werkstücken nahe. Durch die Herstellung aus einem körnigen Pulver ist allerdings auch die Oberfläche rauh. In die exakte Ausformung sehr feiner Oberflächenstrukturen unter einem halben Millimeter darf man beim SLS-Verfahren keine übertriebenen Erwartungen setzen.

Bei beiden Verfahren ist man an die jeweils geeigneten Werkstoffe gebunden. SLS-Werkstücke sind üblicherweise weiß, STL-Teile durchscheinend. Wer zum Beispiel Farbigkeit beziehungsweise andere Materialeigenschaften wie größere Härte oder Dichte braucht, muss Abgüssen herstellen. Alternativ kann man das Werkstück auch mit Farbe beschichten, was aber immer Nachteile gegenüber durchgefärbten Werkstücken hat. Die erzeugten Teile können direkt dazu dienen, die Konstruktion oder die Funktion im montierten Zustand zu testen (beim STL-Verfahren wegen der geringen mechanischen Festigkeit jedoch nur eingeschränkt).

Für Kleinserien des RP-Teils lässt sich vom Urmodell eine Silikonform herstellen, die für das Abgießen von bis zu 30 Kopien benutzbar ist. Anschließend ist die Form verschlissen. Selbstverständlich sind auch mehrere Formen vom Urmodell herstellbar. SLS-Werkstücke werden üblicherweise vor der Abformung einer abschließenden glättenden Oberflächenbearbeitung (Finish) unterzogen. Das Abgießen erfolgt unter Vakuum, um Lufteinschlüsse zu verhindern.

Know-how beim Gießen

Mit den beschriebenen RP-Verfahren sind der Phantasie des Konstrukteurs kaum Grenzen gesetzt. Aber Achtung: Auch wenn Abgüsse von einem futuristisch gestalteten Werkstück angefertigt werden sollen, muss man sich schnell auf die konservativen Prinzipien Guss-gerechter Konstruktion besinnen. Hier nur die wichtigsten:

• Hinterschneidungen vermeiden
• Durchgehend ausreichende Wandstärken verwenden
• Luftsäcke vermeiden (das Risiko wird zwar durch das Vakuum reduziert, verschwindet aber trotzdem nicht gänzlich).

Die Berücksichtigung dieser Konstruktionsprinzipien senkt die Wahrscheinlichkeit eines Misserfolgs ganz erheblich. Eventuell ist auch eine nachträgliche mechanische Bearbeitung (Drehen, Bohren, Fräsen) des Werkstücks unausweichlich oder dessen Teilung ist in Betracht zu ziehen. Die Herstellung von RP-Teilen wird von einer Reihe von Dienstleistern angeboten. Die Kosten sind abhängig von der Größe des herzustellenden Teils, vom ausgewählten Verfahren und von eventuell herzustellenden Abgüssen.

Einzelstücke im SLS-Verfahren lassen sich bereits für unter 300 Euro herstellen. Kleinserien mit Abgüssen des Urmodells beginnen bei etwa 800 Euro. Diese Werte sind jedoch stark von der Geometrie des zu fertigenden Objekts abhängig und werden von dem Dienstleister im Einzelfall kalkuliert. In den Infos ist als Beispiel ein Unternehmen aufgeführt, das die beschriebenen RP-Dienstleistungen anbietet.

Abbildung 7: Zur Endkontrolle wird das Objekt im Viewer noch einmal geprüft.

File per Mail versenden und auf Postboten warten

Also STL-File eingezippt und hingemailt und freudig auf den Postboten mit dem fertigen Werkstück gewartet. An dieser Stelle nochmals der Hinweis: Es gibt keine Garantie, dass alle 3D-Operationen vollständig (beschränkter Befehlssatz) und fehlerfrei ablaufen. Die abschließende Qualitätskontrolle des fertigen 3D-Modells im Viewer ist daher Pflicht, um kostspielige Enttäuschungen in Form verschossener Teile zu vermeiden.

Abbildung 8: Mit Pov2tri erzeugtes GTS-File im Viewer (oben) und das Povray-Bild der Szene (unten).

Entwicklungsziele Stabilität und mehr Funktionen

Die Bibliothek Volume3D und die beschriebenen Kommandozeilentools sind kompakt und leichtgewichtig nach tatsächlichen Fertigungserfordernissen entwickelt worden. Sie bilden zwar nur einen kleinen, aber leistungsfähigen und vielseitig nutzbaren Ausschnitt der Möglichkeiten von Povray ab. Allerdings befindet sich die Software nach wie vor in der Entwicklung. Derzeit gehen die Anstrengung vor allem dahin, alle Programmbestandteile ausgiebig zu testen, um einen stabilen, produktionsreifen Stand zu erreichen.

Zusätzliche Funktionalität soll nach Bedarf hinzukommen. Ganz oben auf der Liste der geplanten Erweiterungen stehen berechnete, automatisch vernetzte Flächen (zum Beispiel für Turbinenschaufeln), das Erzeugen und Importieren von Povray-3D-Meshes sowie das Abrunden von Kanten.

Abbildung 9: Übersicht und Funktionsumfang der Volume3D/Pov2tri-Software. Die orange dargestellten Module sind Bestandteile des vorgestellten Projekts.

Die Software steht unter einer dualen Lizenz: Für freie Projekte unterliegt sie der GPL, eine ebenfalls angebotene kommerzielle Lizenz benötigt, wer sie in proprietäre Programme einbinden will oder Delphi/Kylix statt Free Pascal oder GNU Pascal nutzt. (uwo)