XProfan

Kompilieren Markieren Separieren

- Seite 24 -

HofK

Nun habe ich kompliziertere Flächen in Arbeit,
z.B. die Fläche vom Geschlecht 3, siehe [...]

Seite 56.
und WIKIPEDIA [...]

Für die Eingabe benötigt man die implizite Funktion und die partiellen Ableitungen. Diese sind schon recht aufwändig.

// Example: implicit surface of genus 3
const rx2 = 36;
const ry2 = 12.25;
const rz2 = 16;
const r2 = 1.44;
const x0 = 3.9;
const f0 = ( x, y, z ) => ( rz2 * rz2 * z * z );
const f1 = ( x, y, z ) => ( 1 - x * x / rx2 - y * y / ry2 );
const f2 = ( x, y, z ) => ( ( x - x0 ) * ( x - x0 ) + y * y - r2 );
const f3 = ( x, y, z ) => ( x * x + y * y - r2 );
const f4 = ( x, y, z ) => ( ( x + x0  )* ( x + x0 ) + y * y - r2 );
const dxf1 = ( x, y, z ) => ( -2 * x / rx2 );
const dxf2 = ( x, y, z ) => ( 2 * ( x - x0 ) );
const dxf3 = ( x, y, z ) => ( 2 * x );
const dxf4 = ( x, y, z ) => ( 2 * ( x + x0 ) );
const dyf1 = ( x, y, z ) => ( -2 * y / ry2 );
const dyf2 = ( x, y, z ) => ( 2 * y );
const dyf3 = ( x, y, z ) => ( 2 * y );
const dyf4 = ( x, y, z ) => ( 2 * y );
const isf = ( x, y, z ) => ( f0( x, y, z ) - f1( x, y, z ) * f2( x, y, z ) * f3( x, y, z ) * f4( x, y, z ) );// IMPLICIT SURFACE Function
const dx = ( x, y, z ) => ( -( dxf1( x, y, z ) * f2( x, y, z ) * f3( x, y, z ) * f4( x, y, z ) + f1( x, y, z ) * dxf2( x, y, z ) * f3( x, y, z ) * f4( x, y, z ) + f1( x, y, z ) * f2( x, y, z ) * dxf3( x, y, z ) * f4( x, y, z ) + f1( x, y, z ) * f2( x, y, z ) * f3( x, y, z ) * dxf4( x, y, z ) ) );// PARTIAL DERIVATE to x
const dy = ( x, y, z ) => ( -( dyf1( x, y, z ) * f2( x, y, z ) * f3( x, y, z ) * f4( x, y, z ) + f1( x, y, z ) * dyf2( x, y, z ) * f3( x, y, z ) * f4( x, y, z ) + f1( x, y, z ) * f2( x, y, z ) * dyf3( x, y, z ) * f4( x, y, z ) + f1( x, y, z ) * f2( x, y, z ) * f3( x, y, z ) * dyf4( x, y, z ) ) );// PARTIAL DERIVATE to y
const dz = ( x, y, z ) => ( rz2 * rz2 * 2 * z );// PARTIAL DERIVATE to z
const xs = 0;// x START POINT
const ys = 3;// y START POINT
const zs = 0;// z START POINT
//const e = 0.001; // epsilon
//const d  = 0.128; // rough edge length of triangles
const e = 0.001;// epsilon
const d  = 0.13;// rough edge length of triangles
//const e = 0.001; // epsilon
//const d  = 0.2; // rough edge length of triangles

Da ich den Algorithmus noch immer nicht bis ins letzte Detail umgesetzt habe, funktioniert es nicht mit allen Kombinationen aus e und d. Ich bleibe dran!

Keine Aussage zu Fehlern, nur soviel

....

13.07.2019 ▲

HofK

Bei relativ großer ungefährer Seitenlänge der Dreiecke kommt es bei komplizierten Flächen mit sehr unterschiedlichen Krümmungen zu Darstellungsfehlern. Auch ist das ein Grund, dass manche Kombinationen aus e und d nicht funktionieren, da das Newton-Verfahren nicht zur korrekten Nullstelle konvergiert, z.B. geht bei festem d mal sogar e=0.001, 0.0001 geht nicht, aber 0.00001 geht wieder.

Die Idee war nun, die Seitenlänge d abhängig von der Krümmung zu machen.
Geht man das theoretisch an, benötigt man Dinge wie die Hesse-Matrix [...]

[...]

Dann wird der Aufwand für die Eingabe sehr hoch und auch die Berechnungen sind recht umfangreich.

Deshalb habe ich einen einfachen Näherungsansatz gewählt.

Man berechnet bereits zu einem Punkt die auf einem Umkreis mit Radius d in der Tangentialebene liegenden Punkte. Dann werden diese Punkte per Newton-Verfahren auf die Fläche gebracht. Merkt man sich nun für die Punkte den Abstand Punkt-Tangentialebene und bildet Maximum oder Mittelwert, hat man ein ungefähres Maß der Krümmung. Damit kann man nun d verändern.

Nachteil: Man muss die komplette Rechnung mit dem neuen d noch einmal machen, der Gesamtrechenaufwand verdoppelt sich also nahezu. Im Programm sind es nur wenige Zeilen mehr.

Bei dieser bereits sehr feinen Auflösung bringt es nicht viel, im Gegenteil, die Gleichmäßigkeit der Triangulierung ist gestört.

Aber wie sieht es bei großem d aus?

Auf den ersten Blick ganz ordentlich,

aber das Problem der nicht exakten Konvergenz wird nicht gelöst.

Es ist also sinnvoller lieber die Dreiecke insgesamt klein bezüglich der stärksten Krümmung zu halten.

Deshalb verfolge ich diesen Ansatz nicht weiter. War aber interessant.

16.07.2019 ▲

HofK

Im Algorithmus [...]

Seite 52 werden "Schlechte" Nahepunkte beschrieben. Die hatte ich erstmal ausgeklammert. Trotzdem funktionierte es bei den Beispielen. Also geschaut, wann diese Punktepaare auftreten.

So entstehen sie:

Die aktive Front kommt sich selbst nahe:

Sie wird getrennt:

In diesem Beispiel entsteht bei der Füllung mit Dreiecken ein kleines, fast rechtwinkliges Dreieck. Die Länge der einen Seite ist der Abstand zwischen den getrennten Fronten und hier dann etwas kleiner als die ungefähre Seitenlänge d.

Warum hat es aber auch bei diesem Beispiel funktioniert? Warum werden die Fronten nicht gleich wieder vereinigt und es gibt eine Endlosschleife?

Die Antwort liegt in meiner speziellen Art der Umsetzung des Algorithmus. Diese weicht an einigen Stellen von der Pascal-Vorgabe ab.

Nach Trennung der aktiven Front bestimme ich erst für den kleineren, dann für den verbleibenden (manchmal zwischenzeitlich veränderten) Winkel neue Dreiecke (ohne nachfolgende Abstandsprüfung). Das ist der Stand im zweiten Bild.

Die obere Front im Bild ist nun die aktive Front. Bei der Abstandsprüfung gehe ich davon aus, dass bis auf die neu erzeugte Punkte um den aktuellen Punkt (kleinster Winkel der Front) alle anderen Punkte unverändert sind. Damit prüfe ich nur für die neuen Punkten ( meist 1 oder 2, seltener 3 oder gar 4) den Abstand zu den anderen Punkten.

Sollte mal einer der gerade ohne Prüfung erzeugten Punkte den kleinsten Winkel haben, so sind die nun dort erzeugten Punkte auf jeden Fall weiter als die ungefähre Seitenlänge d von der unteren Front entfernt.

Die schlechten Nahepunkte werden also "umgangen" und ich erspare mir die Prüfung.

20.07.2019 ▲

Kompilieren Markieren Separieren

HofK

Noch ein nettes Beispiel. Drei verschmelzende Kugeln. Im Gegensatz zu einfachen Kugeln die man so anordnet, ist der Übergang gerundet und innen sind die Kugeln nicht getrennt.

// Example: implicit surface, three balls
const f0 = (x,y,z) => ( x*x + y*y + z*z - 4 );
const f1 = (x,y,z) => ( (x+3)*(x+3) + y*y + z*z - 3 );
const f2 = (x,y,z) => ( x*x + (y-2)*(y-2) + (z-2)*(z-2) - 1.8 );
const isf = (x,y,z) => ( f0(x,y,z)*f1(x,y,z)*f2(x,y,z ) - 0.4 );// IMPLICIT SURFACE Function
const dx = (x,y,z) => ( 2*x*f1(x,y,z)*f2(x,y,z) + 2*(x+3)*f0(x,y,z)*f2(x,y,z) + 2*x*f0(x,y,z)*f1(x,y,z) );// PARTIAL DERIVATE to x
const dy = (x,y,z) => ( 2*y*f1(x,y,z)*f2(x,y,z) + 2*y*f0(x,y,z)*f2(x,y,z) + 2*(y-2)*f0(x,y,z)*f1(x,y,z) );// PARTIAL DERIVATE to y
const dz = (x,y,z) => ( 2*z*f1(x,y,z)*f2(x,y,z) + 2*z*f0(x,y,z)*f2(x,y,z) + 2*(z-2)*f0(x,y,z)*f1(x,y,z) );// PARTIAL DERIVATE to z
const progressFactor = 3;// for slider
const xs = 0;// x START POINT
const ys = 4 ;// y START POINT
const zs = 0;// z START POINT
const e = 0.001;// epsilon
const d = 0.1;// rough edge length of triangles

20.07.2019 ▲

p.specht

Erinnert ein wenig an die Ergebnisse von "Blender" ...

XProfan 11
Computer: Gerät, daß es in Mikrosekunden erlaubt, 50.000 Fehler zu machen, zB 'daß' statt 'das'...

22.07.2019 ▲

HofK

p.specht (22.07.2019)

Erinnert ein wenig an die Ergebnisse von "Blender" ...

Da sind mit Sicherheit sehr viele Algorithmen implementiert. Habe mich damit aber nicht beschäftigt.

----------------------------

Auf Seite 54 von [...]

sind zwei Möglichkeiten der Begrenzung eines Zylinders dargestellt. Die implizite Funktion des Zylinders ergibt ohne Begrenzung eine unendlich große Fläche, da in der Funktion
const isf = (x,y,z) => ( x*x + y*y - 1 ); // IMPLICIT SURFACE Function die Variable z nicht auftaucht.

Also habe ich eine Boundingbox hinzuprogrammiert.

const e = 0.01; // epsilon
const d = 0.1; // rough edge length of triangles
const b = [ 10, -10, 0.6, -10, 2, -1.3 ]; // bounds xMax, xMin, yMax, yMin, zMax, zMin

Das macht im Algorithmus an mehreren Stellen Abänderungen/Ergänzungen nötig.

Man erkennt das Problem. In Richtung der z-Achse funktioniert es prima, da man die Koordinate einfach auf die Grenze zurücksetzen kann. Sie kommt in der Funktion nicht vor und hat keinen Einfluss auf das Newton Verfahren.

Macht man das wie im Bild dargestellt mit einer der anderen Achsen, so bleibt der Rand ausgefranst und die fransigen Ecken liegen nicht exakt auf dem Zylinder. Hier tiefer bei 0,6.

Da die Prüfungen bezüglich der Boundingbox doch einigen Aufwand verursachen, werde ich diese Programmvariante nur für Zylinder und ähnliche Dinge nutzen. Die allgemeinere Form ist dann die Begrenzung durch weitere Frontpolygone, wie ich es bei der Kugel mit den beliebigen Öffnungen gemacht habe. Hier ist der Aufwand lediglich die Erstellung dieser passenden Frontpolygone. Das Programm selbst braucht keine Ergänzung.

Nach meiner Kenntnis gibt es keine Möglichkeit (oder keine hier praktikable) bei der Impliziten Funktion mit dem Newton Verfahren die Punkte "glatt " auf die Grenze zu bringen, wenn die Variable in der Funktion und ihren partiellen Ableitungen auftaucht.

Nun muss noch etwas aufgeräumt und optimiert werden, ehe der Code vorzeigbar ist.

----------

Ein weiteres Beispiel ist die Fläche vom Geschlecht 2 [...]

22.07.2019 ▲

Kompilieren Markieren Separieren

HofK

Noch ein Versuch mit Begrenzung. Zwei sich schneidende Zylinder.

// Example: implicit surface, two cylinder
const f1 = (x,y,z) => ( x*x + y*y - 1 );
const f2 = (x,y,z) => ( y*y + z*z - 1 );
//const isf = (x,y,z) => ( f1(x,y,z)*f2(x,y,z) - 0.5 ); // IMPLICIT SURFACE Function
const isf = (x,y,z) => ( f1(x,y,z)*f2(x,y,z) - 0.25 );// IMPLICIT SURFACE Function
const dx = (x,y,z) => ( 2*x*f2(x,y,z) );// PARTIAL DERIVATE to x
const dy = (x,y,z) => ( 2*y*( f1(x,y,z) + f2(x,y,z) ) );// PARTIAL DERIVATE to y
const dz = (x,y,z) => ( 2*z*f2(x,y,z) );// PARTIAL DERIVATE to z
const progressFactor = 5;// for slider
const xs = 0.2;// x START POINT
const ys = 1.1;// y START POINT
const zs = 0.1;// z START POINT
const e = 0.001;// epsilon
const d = 0.05;// rough edge length of triangles
const b = [ 1.4, -1.4, 10, -10, 1.4, -1.4 ];// bounds xMax, xMin, yMax, yMin, zMax, zMin

Hier führten nur wenige Parameterkonstellationen zu einem Ergebnis. Teilweise überlaufen sich Teile der Front oder die Rechnung landet in einer Endlosschleife, oder der Rand ist nicht glatt, da alle Variablen vorkommen.

Für dieses Beispiel also besser auch Randpolygone als Front definieren.

23.07.2019 ▲

p.specht

Demnach hätten mathematisch Männer und Frauen das gleiche Geschlecht, oder?

XProfan 11
Computer: Gerät, daß es in Mikrosekunden erlaubt, 50.000 Fehler zu machen, zB 'daß' statt 'das'...

25.07.2019 ▲

HofK

p.specht (25.07.2019)

Demnach hätten mathematisch Männer und Frauen das gleiche Geschlecht, oder?

Keine Ahnung, in der Mathematik ist es immer eine Frage der Definition.

Ich erinnere mich noch gut der manchmal etwas ermüdenden Abfolge
"Definition-Satz-Beweis" die zu absolvieren war.

Und es ist eine Frage des herangehens. Da fällt mir etwas uraltes ein:

Der Mathematik Professor schließt den Hörsaal auf, ein sehr pünktlicher Student geht hinein, der Professor bleibt vor der Tür und wartet. Als das akademische Viertel verstrichen ist und das Interesse an seiner Vorlesung gelinde gesagt seeeehr gering ist, ruft er in den Hörsaal. Fällt aus - ich schließe ab! Es kommen zwei Studenten heraus! Was denkt sich der Mathematik Professor? Ganz logisch, jetzt ist noch genau bzw. eineindeutig -1 Student im Saal. Bleibt die Frage wie er es mit dem abschließen hält. Keine Ahnung.

26.07.2019 ▲

HofK

Die Triangulation der impliziten Flächen ist in einem Stadium, wo man sie veröffentlichen kann.

Dort zu finden:

GitHub [...]

meine Seite [...]

letzter Abschnitt bzw. direkt [...]

discourse [...]

Einige noch offene Dinge werden später ergänzt.

26.07.2019 ▲

HofK

Anstatt etwas Sinnvolles zu machen, werde ich seit Stunden durch die "KleinWeich" Chaoten aufgehalten. Nach dem Update von Windoofs 10 laufen so einige Dinge nicht mehr ordentlich. Mein externer Monitor blieb dunkel. Obwohl das Update fast eine Stunde gewerkelt hat und davor schon telemetry die CPU mit fast 100% auslastete ( habe ich jetzt abgeklemmt) wurden die Treiber nicht erneuert. Ich musste selbst erst darauf kommen im Netz nach Treibern suchen zu lassen. Die wurden dann anstandslos installiert - gehts noch?! Otto Normalverbraucher schafft das Gerät zur Reparatur - Arbeitsbeschaffung für das Handwerk. Nicht das es jetzt wirklich funktioniert. Nach Standby bleibt der Monitor dann wieder dunkel. Neustart oder USB Stecker ziehen (externe Grafik über USB 3.0, da meine interne externe Grafik im Laptop vor geraumer Zeit den "Geist" aufgegeben hat).

Die Grafiken in den vorherigen Beiträgen wurden mit dem Lineal von IF [...]

aufgenommen. Sehr praktikabel.
Funktioniert nicht mehr. Nun übe ich mit Firefox "Bildschirmfoto".

zwei Zylinder mit Kugel
(Variante mit Begrenzung ist noch nicht ganz fertig)

Auch classic shell wird ausgebremst. Es kommt eine tiefrote Warnung. Funktioniert aber noch irgendwie, darf sich nur nicht anpassen. Nervt, wenn bei jedem Start die Warnung kommt und was genau nicht geht merke ich eventuell irgendwann. Der Trick mit der totalen Herabsetzung der Sicherheit in der Benutzerkontensteuerung hilft diesmal hier nicht.

Meine RAM Disk funktioniert noch. Glück gehabt, mal sehen, bis zu welchem Zwangsupdate. Was noch zerstört wurde wird sich zeigen. Aber keine Alternative dank Quasimonopol. In den (sauren) Apfel möchte man auch nicht unbedingt beißen und (J)..ux ist in der Anwendung doch zu eingeschränkt.

---
Nachtrag:
Das im Netz beschriebene abklemmen von telemetry mit einem Eintrag in der Registrierung wird bei Neustart in Update 1903 wohl einfach ignoriert. Mein Laptop wird zum 100% Ofen. Im Task Manager den Prozess beenden bringt aber vorläufige Abkühlung.

30.07.2019 ▲