ZenCad 3D-Skriptsimulationssystem

Die Arbeit, auf die ich Sie aufmerksam machen möchte, ist der Versuch, noch einmal ein skriptbasiertes 3D-Modellierungssystem zu schreiben. Schreiben Sie, wie ich sie sehen möchte.

Das Rezept für das ZenCad-System ist recht einfach. Das Konzept der Skripterstellung 3D-Modellierung von OpenScad, dem geometrischen Kern von OpenCascade, Python3 als Kleber, dem Lazal Computation Library Evalcache für aggressives Caching von Berechnungen. Fügen Sie Gewürze aus ein paar anderen Werkzeugen hinzu, würzen Sie die Gui mit PyQt-Sauce und servieren Sie sie unter Rühren, aber ohne zu schütteln.

Skript-CAD-Systeme

CAD oder gemäß unserem CAD ist ein computergestütztes Konstruktionssystem. Im Gegensatz zu interaktiven 3D-Editoren interpretieren geskriptete CAD-Systeme das Wort "automatisiert" in dem Sinne, wie es die Entwickler normalerweise verstehen. Das heißt, nicht als eine Reihe von Computerwerkzeugen, sondern als kristallklarer Algorithmus, der nur zum Zeitpunkt seiner Erstellung menschliches Eingreifen erfordert.

Bei der Arbeit mit CAD-Skripten zeichnen wir das Modell nicht direkt auf dem Bildschirm, sondern erstellen das Programm, nach dem das Modell generiert wird. Für Personen, die nur mit interaktivem CAD vertraut sind, kann dieser Ansatz als absolute parametrische Modellierung beschrieben werden. Genau genommen werden Skripte häufig verwendet, um eine interaktive Umgebung zu ergänzen und zusätzliche Tools zu schreiben. Die Arbeit in einem paradigmatisch sauberen Skript-CAD erfordert jedoch eine andere Organisation des Workflows, eine andere Denkweise und ist für einen etwas anderen Aufgabenbereich konzipiert.

Das derzeit bekannteste und reinste Skript-CAD ist OpenScad.

Am Anfang war OpenScad

Es gibt einen bestimmten Personenkreis, der den praktischen Kompass, SolidWorks, FreeCad, das weltliche und unprätentiöse OpenScad bevorzugt. Es ist nicht einfach, die Frage zu beantworten, was das Geheimnis seines Erfolgs ist, aber man kann definitiv sagen, dass es leicht, flexibel genug zu bedienen und mit einem Minimum an Einstellungen ausgestattet ist. Teile der darauf geschriebenen Modelle sind leicht wiederzuverwenden.

OpenScad weist jedoch einige lästige Mängel auf:

• openscad funktioniert nur mit Mesh-Netzwerken.
• openscad hat eine relativ niedrige Skalierbarkeitsgrenze, es beginnt bei großen Modellen stark zu verzögern.
• openscad lässt sich nur schwer in andere Systeme integrieren, weshalb die Verwendung einer eigenen Sprache der Grund dafür ist.

Leider ist es bei aller Leistungsfähigkeit des Scripting-Ansatzes ziemlich problematisch, über den Rahmen des nützlichen Flashing-Schreibens einfacher Modelle mit OpenScad hinauszugehen.

Sprache und alles in allem

Das erste, was ich hier beheben möchte, ist, eine Allzwecksprache als Kampfwerkzeug zu verwenden. Durch die Verwendung einer Allzwecksprache können Sie die Vollständigkeit ihrer syntaktischen Funktionen und die Gesamtheit der zuvor geschriebenen Bibliotheken zur Lösung von 3D-Modellierungsproblemen nutzen.

Die Verwendung von Python vereinfacht den OpenScad-Code, indem der Modellcode im Vergleich zu OpenScad transparenter wird.

#!/usr/bin/env python #coding: utf-8 from zencad import * lazy.diag = True c1 = 100 c2 = 130 c3 = c2/2 + 20 base = box(c1,c1,c1,center=True) f1 = ngon(r = 35, n = 3) f2 = ngon(r = 35, n = 5) f3 = circle(35) s1 = linear_extrude(f1, c2, center=True) s2 = linear_extrude(f2, c2, center=True).rotateY(deg(90)) s3 = linear_extrude(f3, c2, center=True).rotateX(deg(90)) #          3 . m1 = base - s1 - s2 - s3 m2 = base ^ s1 ^ s2 ^ s3 m3 = s1 + s2 + s3 ystep = 240 xstep = 240 fontpath = os.path.join(zencad.moduledir, "examples/fonts/testfont.ttf") #    .      . t1 = textshape("difference", fontpath, 40) t1c = t1.center() t1=t1.translate(-t1c.x, -t1c.y, 0).rotateZ(deg(45)) t2 = textshape("intersect", fontpath, 40) t2c = t2.center() t2=t2.translate(-t2c.x, -t2c.y, 0).rotateZ(deg(45)) t3 = textshape("union", fontpath, 40) t3c = t3.center() t3=t3.translate(-t3c.x, -t3c.y, 0).rotateZ(deg(45)) #  ,  . disp(base.forw(ystep)) disp(s1) disp(s2.left(xstep)) disp(s3.right(xstep)) disp(m1.back(ystep)) disp(m2.left(xstep).back(ystep)) disp(m3.right(xstep).back(ystep)) disp(t1.back(ystep).up(c3), Color(1,1,0)) disp(t2.left(xstep).back(ystep).up(c3), Color(1,1,0)) disp(t3.right(xstep).back(ystep).up(c3), Color(1,1,0)) disp(s1.left(xstep).back(ystep), Color(0.5,0,0,0.95)) disp(s2.left(xstep).back(ystep), Color(0.5,0,0,0.95)) disp(s3.left(xstep).back(ystep), Color(0.5,0,0,0.95)) disp(s1.back(ystep), Color(0.5,0,0,0.95)) disp(s2.back(ystep), Color(0.5,0,0,0.95)) disp(s3.back(ystep), Color(0.5,0,0,0.95)) show() 

Es ist beispielsweise sehr praktisch, eine Punktwolke mithilfe der Syntax von Generatoren zu filtern.

 #!/usr/bin/env python3 from zencad import * #  . ng = ngon(r = 10, n = 6) #      . vertices = ng.vertices() filtered_vertices = [v for v in vertices if vx < 0] #      . m = ng.fillet(4, filtered_vertices) disp(m) show() 

Dank Python, das inoffiziell den Titel des King of Glue im modernen Software-Ökosystem einnimmt, lässt sich zencad problemlos in andere Bibliotheken und Softwaresysteme integrieren. Wir können Sympy in einem Skript verwenden, um eine analytische Oberfläche zu generieren, Numpy, um eine auf dieser Oberfläche erzeugte Punktwolke zu verarbeiten, und natürlich Zencad zum Erstellen, Visualisieren und Nachbearbeiten.

 from zencad import * import numpy xcoords = numpy.linspace(-10,10,50) ycoords = numpy.linspace(-10,15,50) lines = [ interpolate([point(x, y, 0.01*(x**2 + y**3)) for x in xcoords]) for y in ycoords ] wires = [] for l in lines: trans = translate(0,0,-30) sf = l.endpoints() w=sew([l, segment(sf[0], trans(sf[0])), trans(l), segment(sf[1], trans(sf[1]))]) wires.append(w) for l in lines: disp(l.left(30)) disp(loft(wires) - halfspace().down(10)) show() 

Das solide Fundament von OpenCascade

Die Mathematik von polygonalen Netzen ist viel einfacher als die Mathematik der Grenzdarstellung, aber die Grenzdarstellung ist viel praktischer. Insbesondere Polygonnetze haben ein kombinatorisches Explosionsproblem, das sich insbesondere dann manifestiert, wenn es darum geht, ein Modell zu rendern. In OpenScad ist es häufig erforderlich, ein Produkt mit einer Auflösung zu entwickeln, die viel niedriger ist als die Auflösung eines realen Modells, was die Reinheit des Paradigmas verletzt.

Der zweite Implementierungspunkt ist daher die Verwendung eines vollwertigen geometrischen Kerns, der anstelle des Netzmodells die Grenzdarstellung verwendet. ZenCad basiert auf dem geometrischen Kern des Hackers von OpenCascade und zielt natürlich nicht darauf ab, die volle Leistungsfähigkeit in der Python-Umgebung bereitzustellen. Der Versuch, OpenCascade vollständig zu vermitteln, würde dazu führen, dass ein zweites PythonOCC geschrieben wird. ZenCad nimmt die Spitze ein und versucht, ein Gleichgewicht zwischen Funktionalität und Ergonomie aufrechtzuerhalten.

 #!/usr/bin/env python3 #coding: utf-8 from zencad import * import zencad.surface as surface import zencad.curve2 as curve2 lazy.diag=True height = 70 width = 50 thickness = 30 # BASE pnt1 = point(-width/2,0,0); pnt2 = point(-width/2,-thickness/4,0); pnt3 = point(0,-thickness/2,0); pnt4 = point(width/2,-thickness/4,0); pnt5 = point(width/2,0,0); edge1 = segment(pnt1, pnt2) edge2 = circle_arc(pnt2, pnt3, pnt4) edge3 = segment(pnt4, pnt5) wire = sew([edge1, edge2, edge3]) profile = sew([wire, wire.mirrorX()]) body = profile.fill().extrude(height) body = fillet(body, thickness/12) hl(body.forw(140)) # NECK neck_radius = thickness/4.; neck_height = height/10; neck = cylinder(r=neck_radius, h=neck_height).up(height) body = body + neck hl(body.forw(100)) # THICK body = thicksolid(body, -thickness / 50, [point(0,0,height+height/10)]) hl(body.forw(60)) # THREAD ( 2       .) cylsurf1 = surface.cylinder(neck_radius * 0.99) cylsurf2 = surface.cylinder(neck_radius * 1.05) major = 2 * math.pi; minor = neck_height / 10; angle = math.atan2(neck_height / 4, 2 * math.pi) ellipse1 = curve2.ellipse(major, minor).rotate(angle) arc1 = cylsurf1.map(curve2.trimmed_curve2(ellipse1, 0, math.pi)) segment1 = cylsurf1.map(curve2.segment(ellipse1.value(0), ellipse1.value(math.pi))) ellipse2 = curve2.ellipse(major, minor/4).rotate(angle) arc2 = cylsurf2.map(curve2.trimmed_curve2(ellipse2, 0, math.pi)) segment2 = cylsurf2.map(curve2.segment(ellipse2.value(0), ellipse2.value(math.pi))) m1 = sew([arc1, segment1]) m2 = sew([arc2, segment2]) thread = loft([m1, m2]).up(height + neck_height / 2) hl(m1.up(height + neck_height / 2).right(80)) hl(m2.up(height + neck_height / 2).right(60)) hl(thread.right(40)) # FINAL m = thread + body display(m) show() 

Kontinuität der Tradition. Der Ursprung als Quelle von allem

Die Zencad-Syntaxlösungen, die dem Beispiel seines älteren Bruders und OpenScad-Lehrers folgen, minimieren die Anzahl der Entitäten in der Bibliothek. Wie OpenScad ist ZenCad grundsätzlich nicht in der Lage, an dem Punkt (x, y, z) ein Grundelement zu erstellen, obwohl OpenCascade dies zulässt. ZenCad erstellt zuerst ein Grundelement am Ursprung und legt dann mithilfe von Transformationen die benötigte Position fest. Transformationen in ZenCad existieren sowohl als separate Objekte als auch als Methoden von Körpern.

 #  . cube(40, center=True).rotateX(deg(45)).rotateZ(deg(45)).right(20) #  . (right(20) * rotateZ(deg(45)) * rotateX(deg(45)))(cube(40, center=True)) #  . trans = right(20) * rotateZ(deg(45)) * rotateX(deg(45)) cube(40, center=True).transform(trans) 

Eine Reihe von Transformationen ist Standard und umfasst Translation, Rotation, Reflektion und Zoom.

Faulheit

Um die Rechenzeit zu minimieren, wird die Mathematik in ZenCad verkürzt und alle Berechnungen werden aggressiv zwischengespeichert. Die [del] blockchain [/ del] evalcache-Bibliothek, über die ich vor einiger Zeit auf den Seiten von Habrahabr gesprochen habe, kümmert sich um die Verwaltung von Lenifizierungsalgorithmen: das Zwischenspeichern von Datenträgern von Lazy-Computing-Bäumen . Zencad speichert die Berechnungsergebnisse in einem gemeinsamen Cache, dessen Status über die Visualizer-Oberfläche überwacht werden kann. Der sha512-Hash-Algorithmus, der mit ausgeprägter Redundanz verwendet wird, eliminiert die Möglichkeit von Kollisionen von Hash-Schlüsseln für faule Objekte (der Hash-Raum beträgt das 10 ^ 74-fache der Anzahl der Atome im Universum).

Beim Erstellen dieses Modells werden vier Megabyte Geometrie generiert, und im ersten Durchgang kann es für eine ziemlich lange Zeit berechnet werden:

Die Arbeit mit Gewindeflächen ist rechenintensiv:

Das Problem der Reflexionstopologie. Nahpunktmethode

OpenScad hat keine Anfas- oder Rundungsvorgänge. OpenCascade bietet sie. Dies sind sehr wichtige Vorgänge, und es wäre eine Schande, sie nicht für ZenCad in Betrieb zu nehmen. Es gibt andere Vorgänge, bei denen ein topologisches Objekt angegeben werden muss, z. B. die Verwendung eines dünnwandigen Modells im OpenCascade-Flaschenbeispiel. In einem grafischen CAD-System geben wir mit der Maus ein topologisches Objekt (Kante, Fläche, Scheitelpunkt) an. Wenn wir ein Skript schreiben, haben wir keine solche Gelegenheit. Native OpenCascade löst das Problem mit der Reflexion und verwendet es für die Arbeit mit grafischem CAD. Obwohl ZenCad die Modellreflexion unterstützt, weist die Verwendung als primäres Werkzeug eine Reihe erheblicher Nachteile auf. Erstens steigt der Wissensstand, der für die Verwendung dieser Tools erforderlich ist, stark an, da Sie zumindest das interne topologische Konzept verstehen müssen. Zweitens bricht die Harmonie fauler Algorithmen sofort, sobald sie im Skript erscheint, und der Modellcode ist auch ziemlich kompliziert. Während langwieriger Reflexionen und Experimente entschied ich mich für die Nahpunktmethode. Kurz gesagt, wenn topologisch abhängige Operationen ausgeführt werden, umgeht das Programm das Objekt und findet das topologische Objekt, das dem gegebenen Punkt am nächsten liegt, unter denjenigen, die in den Körper eintreten. Dieser Artikel gilt als ausgewählt. Eine solche Lösung ist rechenintensiver, funktioniert jedoch aufgrund des Caching gut. Dieser Ansatz wird für alle Operationen verwendet, die von Topologieelementen abhängen.

Wie oben erwähnt, bleibt auch die Möglichkeit erhalten, das Modell mit gesundem Menschenverstand wiederzugeben, wie im obigen Beispiel gezeigt (Beispiel: Filtern eines Array von Punkten).

Marker Q und Marker W.

Die Abmessungen des Modells können aufgrund der Nicht-Offensichtlichkeit der Skala schwierig vom Bildschirm abzulesen sein. Zum Teil können Marker dieses Problem lösen. Mit einer intuitiven Oberfläche (nirgends intuitiver) signalisieren Markierungen die Koordinaten und zeigen den Abstand an, was die Analyse der Geometrie und die Auswahl von Punkten für Operationen wie Fasen / Runden vereinfacht.

Verfolgen Sie Quellaktualisierungen

Wie der große Bruder (OpenScad) kann ZenCad das generierte Modell beim Ändern der Quelldatei aktualisieren. In Kombination mit dem Caching-System können Sie so das Skript ganz bequem ändern, wobei Sie den sich ändernden Status des Produkts fast in Echtzeit vor Augen haben.

Animation

Die Vorzüge von Zencad enden hier nicht.

ZenCad (dank der schnellen Opencascade) kann die Szene in Echtzeit neu zeichnen, sodass Sie ein 3D-Modell animieren können. Die Animation wird durch eine gewöhnliche Python-Funktion implementiert und ermöglicht es Ihnen, sich ganz frei zu behandeln. Da wir uns in einer Python-Umgebung befinden, kann zencad Daten aus externen Quellen als Modellbewegungen visualisieren (z. B. mithilfe von Multithreading + tcpsocket). So kann Zencad beispielsweise zum naturnahen Testen von Roboterprodukten verwendet werden. Oh hallo Pavillon !!! Hallo ROS !!! Es ist schön, dich auch im Publikum zu sehen. Eine Kinematikbibliothek, die übrigens den Aufbau kinematischer Ketten von Robotermanipulatoren erheblich vereinfachen würde, befindet sich in der Entwicklung.

Die Animation befindet sich derzeit noch in einer semi-experimentellen Version (insbesondere in Bezug auf die Kamerasteuerung), daher werde ich nicht näher darauf eingehen.

Exportieren - Importieren

Derzeit werden Export und Import im Brep-Format unterstützt, was die Integration mit Freecad und den Export im STL-Format ermöglicht, wodurch Modelle für den 3D-Druck generiert werden können. Die Generierung von Screenshots wird ebenfalls unterstützt. Einschließlich automatisch. Insbesondere Screenshots im Online-Handbuch werden von ZenCad automatisch generiert.

Aktueller Status

Derzeit ist ZenCad noch weit von der Fertigstellung entfernt und dennoch in dem Teil, in dem es bereit ist, voll funktionsfähig.

Die Bibliothek ist in Pipy für Debian-kompatible Achsen mit Versionen von Python3.5, Python3.6, Python3.7 verfügbar

(Möglicherweise müssen Sie qt5-default installieren, da einige Probleme mit den Plugins in PyQt5 auftreten.)

 python3 -m pip install zencad apt install qt5-default 

GUI über die Befehlszeile ausführen:

 python3 -m zencad 

Ausführen von GUI aus einem Python-Skript:

 #!/usr/bin/env python3 import zencad m = zencad.cube(20) zencad.disp(m) zencad.show() 

Leider geht der Fortschritt des Systems nicht so schnell voran, wie wir es uns wünschen. Die meisten APIs für zweidimensionale Geometrie und APIs für das Arbeiten mit Oberflächen wurden noch nicht implementiert, die Unterstützung für den Export und Import von Standardformaten, die Fehlerbehandlung ist nicht immer transparent, automatische Tests wurden nicht ausgearbeitet, Bibliotheken für die Konstruktion von Gewindeverbindungen und Zahnradprodukten wurden konzipiert und noch nicht implementiert. Als externer Editor, der völlig abnormal ist, ist plötzlich Hardcore !!! Erhabener Text ... Ich möchte das System auch wirklich verfeinern, damit es unter Windows ausgeführt werden kann (dies erfordert ziemlich viel Expertenarbeit).

Mit zencad können Sie jetzt jedoch recht komplexe 3D-Modelle entwerfen, Modelle für den 3D-Druck erstellen und sogar die Kinematik von Mechanismen visualisieren.

Projektverknüpfungen

Github: https://github.com/mirmik/zencad , https://github.com/mirmik/servoce

pypi: https://pypi.org/project/zencad/ , https://pypi.org/project/pyservoce/

Handbuch

Vielen Dank für Ihre Aufmerksamkeit.