Buildingblocks für Animationen

This is an old revision of the document!

Eine Gleichmässige Bewegung (linear oder rotierend) kann durch eine lineare Funktion in der Zeit (in POV-Ray clock) beschrieben werden.

Gegeben sind zwei Punkte $A$ und $B$. Sei $\vec v = \overrightarrow{AB}$.

Die Punkte $P$ zwischen $A$ und $B$ können für Zeiten $t \in [0,1]$ wie folgt beschrieben werden: $$ \overrightarrow{OP}(t) = \overrightarrow{OA} + t \cdot \vec v = \overrightarrow{OA} + t \cdot \left(\overrightarrow{OB}-\overrightarrow{OA}\right) $$

Überprüfen Sie durch einsetzen, dass für $t=0$ und $t=1$ auch tatsächlich die gewünschten Koordinaten geliefert werden.

#declare start = <-2,-3,1.5>;
#declare ende = <1,2,0.5>;
 
// Lineare Bewegung vom Punkt 'start' zum Punkt 'ende':
// Sei 'vektor' der vektor von start zu ende, also vektor = ende-start
// Position = start + clock*vektor
 
sphere {
	start + clock*(ende-start), 0.3  // Kugel mit linearer Bewegung von start zu ende
	pigment {color rgb x+y}
}

Wenn in der Zeit $t$ von 0 bis 1 eine volle Umdrehung gemacht werden soll, muss der Drehwinkel $\alpha$ von $0^\circ$ bis $360^\circ$ variieren. Wenn dies gleichmässig erfolgen soll erhält man folgende lineare Funktion für den Winkel: $$ \alpha(t) = 360^\circ \cdot t $$

// Gleichmässige Rotation:
// Zum Zeitpunkt 0 ist der Winkel 0, zum Zeitpunkt 1, 360 also
// winkel = 360*clock
 
sphere {
	<2,0,0.5>, 0.5
	rotate 360*clock*z
	pigment {color rgb x+y}
}

Eine gleichmässig beschleunigte Bewegung wird durch eine quadratische Funktion beschrieben, mit quadratischem Koeffizienten $\frac{1}{2}a$, wobei $a$ die Beschleunigung ist.

Meistens werden aber einfach die Nullstellen der Parabel und die Höhe des Scheitels gewählt, damit die Animation passt.

#declare hoehe=2;
 
// Gleichmässig beschleunigte Bewegung vom Ursprung auf die Höhe 2 und zurück.
// Die Höhe ist eine Quadratische Funktion mit f(0)=0, f(1)=0 und f(0.5)=hoehe.
// Da die Nullstellen bekannt sind, kann die Funktion als f(x)=a*x*(1-x) mit
// noch zu bestimmenden Öffnungsfaktor a geschrieben werden. Damit ist schon einmal
// f(0)=f(1)=0 gegeben. Durch einsetzen erhält man f(0.5)=0.25*a. D.h. a muss also
// als 4*hoehe gewählt werden.
sphere {
	4*hoehe*clock*(1-clock)*z, 0.3  // Kugel mit z-Koordinate als quadratische Funktion mit Nullstellen zur Zeit 0 und 1, gegebene Scheitelhöhe.
	pigment {color rgb x+y}
	translate 0.3*z  // Damit die Kugel den Boden berührt und nicht darin versinkt.
}

Lineare Bewegung in $x/y$-Richtung, Quadratische Bewegung in $z$-Richtung:

#include "markierungen.inc"
 
#declare hoehe=2;
// Start und Ende auf selber Höhe!
#declare start=<0,-2,0>;
#declare ende=<0,2,0>;
 
// die Bewegung parallel zur x-y-Ebene erfolgt linear,
// die Bewegung in z-Richtung ist quadratisch
sphere {
	start+clock*(ende-start) + 4*hoehe*clock*(1-clock)*z, 0.3  // Kugel mit linearer Bewegung von start zu ende, plus quadratische z-Koordinate
	pigment {color rgb x+y}
	translate 0.3*z  // Damit die Kugel den Boden berührt und nicht darin versinkt.
}

#declare start = <-2,-3,1.5>;
#declare ende = <1,2,0.5>;
 
// Lineare Schwingung vom Punkt 'start' zum Punkt 'ende':
// Sei 'vektor' der vektor von start zu ende, also vektor = ende-start
//
// Wir brauchen eine Schwingung, die in der Zeit 1 eine volle Schwingung zwischen
// den Positionen 0 und 1 vollführt.
// f(t) = 0.5*sin(t*2*pi)+0.5
//
// Diese Funktion beschreibt die Position zwischen dem Start- und Endpunkt
// Position = start + f(clock)*vektor
 
sphere {
	start + (0.5*sin(clock*pi*2)+0.5)*(ende-start), 0.3  // Kugel mit linearer Bewegung von start zu ende
	pigment {color rgb x+y}
}

#declare auslenkung=20;  // Schwingung zwischen +/- auslenkung
// Wir brauchen eine Funktion, die zwischen -20 und +20 schwingt
// f(t) = sin(2*pi*t)*auslenkung
 
union { // Pendel mit Drehpunkt im Uhrsprung! Verschoben wird **nach** der Drehung
	sphere { 0, 0.1 }
	cylinder { 0, -2*z, 0.05 }
	sphere {-2*z, 0.3 }
	pigment {color rgb <1,1,0> }
	// Erst rotieren um die x-Achse:
	rotate auslenkung*sin(clock*2*pi)*x
	// Dann nach oben verschieben:
	translate 2.5*z
}

Idee: Wir teilen das Zeitintervall in Unterintervalle auf und berechnen einen neue Zeit von 0-1 in diesem Intervall:

#declare hoehe=2;
// Start und Ende auf selber Höhe!
#declare start=<0,-2,0>;
#declare ende=<0,2,0>;
 
sphere{
	<0,0,0.3>, 0.3
	pigment { color rgb <1,1,0> }
 
	// Zwei Bewegungen, je nach clock:
	#if (clock<0.5)
		#declare myclock = clock*2;  // Wieder Werte von 0 bis 1
		translate 2*y
		rotate -180*myclock*z
	#else
		#declare myclock = (clock-0.5)*2; // Wieder Werte von 0 bis 1
		translate (4*myclock-2)*y    // Linear in y-Richtung
		translate 4*3*(1-myclock)*myclock*z   // Quadratisch in z-Richtung (bis auf Höhe 2)
	#end
}