Code-Schnipsel

Computermuseum

Wir besuchen das Computermuseum in Kelkheim

pdp

Viele alte lauffähige Computer mit abenteuerlichen Technologien.

Das Bilderalbum. Der angemessene Soundtrack: Kraftwerk It's more fun to compute

technikum29 in Kelkheim. technikum29.de/de/

Depth of field rendering improvement in Blender

Adding realism to the render results of the cycles engine in blender.

This additional code adds realism to the render results of the blender cycles engine. It is possible to simulate some of the optical aberrations occurring when creating a picture with a real camera and camera lens.

The spherical aberration in a real lens is contributing mostly to the appereance of out-of-focus areas in an image. Rays of light entering the lens close to the center (para-axial principal rays) converge in a different focal point than rays entering in the outer areas of a lens (marginal rays). This addition to the code in kernel_camera.h creates this behaviour, it is still a technical test.

Code for altering the direction of a sample ray depending on distance to center of entrance pupil. The focal plane will be different for edge rays than for center rays:

        ...

        float3 P = make_float3(0.0f, 0.0f, 0.0f);
        float3 D = Pcamera;

        /* modify ray for depth of field */
        float aperturesize = kernel_data.cam.aperturesize;

        if(aperturesize > 0.0f) {
                /* sample point on aperture */
                float2 l_uv = camera_sample_aperture(&kernel_data.cam, lens_u, lens_v);
        float2 lensuv = l_uv * aperturesize;

                /* compute point on plane of focus */
                float ft = kernel_data.cam.focaldistance/D.z;

                /* distance from center */
+                float dis = sqrt(pow(l_uv.x,2.0) + pow(l_uv.y,2.0));
+                float3 Pfocus = make_float3(D.x, D.y, (D.z * (1.0+(1.0-dis)*0.1) )) * ft;
-               // float3 Pfocus = D*ft;

                /* update ray for effect of lens */
                P = make_float3(lensuv.x, lensuv.y, 0.0f);
                D = normalize(Pfocus - P);
        }

        ...

Scene without field of depth

scene1

Scene with field of depth, as implemented in blender 2.8

scene2

Scene with field of depth and spherical aberration. The Coma effect is also visible in asymmetrical distortion of out-of-focus areas in the image.

scene3

The next steps will be to implement some parameters for the other non-chromatic aberrations:

  • Spherical aberration
  • Coma
  • Astigmatism
  • Field curvature
  • Distortion

Some of the aberrations are depending on each other in some cases. This has to be taken into account. The artist should be able to adjust the parameters idependently.

The additional render time neccessary to achieve a similar image quality might be in a 2-digit percentage range. Some tests have to be done.

Also the displaying, manipulating and storing of parameters should follow the established GUI experience in blender.

Chromatical aberrations will require more changes to the render engine, a native approach will triple the render times at least. More research on algorithms is neccessary.

This approach tries to implement a solution close to the physical / optical realities. It is not a fast software hack. The tradeoff in longer render times might be not acceptable for some artists, desirable for ohters.

Starfield Browser

C++ Softwareprojekt für einen 3D-Betrachter der Sterne in der Umgebung der Sonne.

Stereobild

Reduzierte Listen

Funktion zu Berechnung von Josephus Zahlen.

rechner

Das Josephus Problem de.wikipedia.org/wiki/Josephus-Problem beschreibt eine Vorschrift für Streichlisten. In einer zyklischen Liste wird umlaufend jedes zweite Element entfernt. Abhängig von der Größe der Liste liefert die Funktion das letzte Element. Der Code für den HP-16C Taschenrechner: :

 001    43.22.  A       Lbl A
 002    44      0       STO 0   
 003            2       2
 004    44      1       STO 1
 005    43.22.  1       Lbl 1
 006    45      0       RCL 0
 007    45      1       RCL 1
 008            10      ./.
 009    43      40      x=0
 010    22      2       GTO 2
 011    45      1       RCL1
 012            2       2
 013            20      x
 014    44      1       STO 1
 015    22      1       GTO 1
 016    43.22.  2       Lbl 2
 017    45      1       RCL 1
 018            2       2
 019            10      ./.
 020    44      1       STO 1
 021    45      0       RCL 0
 022            34      x<>y
 023    42      9       RMD
 024            2       2
 025            20      x
 026            1       1
 027            40      +
 028    43      21      RTN

Kamera-Animation in Google Earth

Kameraanimationen in Google Earth mit präziserer Bewegungskontrolle.

Im Google Earth Browser lassen sich Kameraanimationen aufnehmen, speichern, importieren und als Bildfolge exportieren.

Von vielen Großstädten sind nicht nur einzelne Gebäude als 3D Modelle integriert, sondern das komplette Gelände mit Gebäuden, Bäumen, etc. ist dreidimensional verfügbar. Leider bietet die Animationssteuerung nur wenige Einstellmöglichkeiten, die Qualität der erzeugten Kamerafahrten ist bestenfalls ausreichend.

Mit Hilfe der Dokumente von Google kann man Code erzeugen, der selbst berechnete Animationen in eine syntaktisch korrekte .kml-Datei exportiert.

Die Animationssoftware im Entwicklungsstadium nimmt einzelne aus Google exportierte Kamerapositionen entgegen, berechnet Animationen in hoher zeitlicher Auflösung und erzeugt eine Animation mit Positionsdaten, die in Google als "Tour" importiert werden kann.

Der Beispielfilm basiert auf sechs Positionskeyframes für die Kamera. Die drei Animationen unterscheiden sich nur durch verschieden lange Fenster, um Parameter mit einem gleitenden Durchschnitt zu glätten.

  • Fenstergröße 0. Die einzelnen Parameter werden linear überblendet.
  • Fenstergröße 6 Sekunden.
  • Fenstergröße 22 Sekunden. Der resultierende Bewegungsablauf wird sichtbarer verändert, ist aber deutlich organischer.

Die "Tour" kann in Google Earth importiert, und dort abgespielt werden. ptour06-0300.kml. In dieser Datei sind Keyframes alle 1/50 Sekunde angelegt, entsprechend dem Fernsehstandard.

Die 3n+1 Vermutung

Berechnung der 3n+1 Folge mit dem HP-16C

rechner

Ein einfach zu beschreibendes Problem ist die 3n+1 Vermutung. de.wikipedia.org/wiki/Collatz-Problem

In der Berechnungsvorschrift ist vorgesehen:

  • Anfangswert ist eine natürlichen Zahl n > 0
  • Ist n gerade, ist das nächste n = n / 2
  • Ist n ungerade, ist das nächste n = 3 n + 1
  • Wiederholung Schritt zwei und drei.

Die Folge von Zahlen erreicht irgendwann den Wert 1. Danach ergibt sich eine zyklische Folge 1, 4, 2. Die 3n-1-Vermutung besagt, dass keine Zahl n als Startwert existiert, die nicht nach einer beliebig langen Folge den Wert 1 erreicht.

Die Berechnung der Zahlenfolgen im HP-16C ist mit diesem Programm möglich: :

 001    43.22.  A       Lbl A
 002            36      Enter   
 003            1       1
 004    44      8       STO 8
 005            33      R↓
 006    43.22.  1       Lbl 1
 007    44      9       STO 9
 008            1       1
 009    43      49      x=y
 010    22      4       GTO 4
 011    45      9       RCL 9
 012            2       2
 013    42      9       RMD
 014    43      40      x=0
 015    22      2       GTO 2
 016    45      9       RCL 9
 017            3       3
 018            20      x
 019            1       1
 020            40      +
 021    22      3       GTO 3
 022    43.22.  2       Lbl 2
 023    45      9       RCL 9
 024            2       2
 025            10      ÷
 026    43.22.  3       Lbl 3
 027    43      34      PSE
 028    45      8       RCL 8
 029            1       1
 030            40      +
 031    44      8       STO 8
 032            33      R↓
 033    22      1       GTO 1
 034    43.22.  4       Lbl 4
 035    45      8       RCL 8
 036    43      21      RTN 

Der Test auf gerade oder ungerade Zahlen wird im Integer-Modus mit der Funktion RMD (Remainder) umgesetzt. Diese Funktion gibt den Restwert bei einer Integer-Division zurück. Die Division einer Zahl durch zwei ergibt nur bei geraden Zahlen einen Restwert von Null.

.
.
.