Transformationen 09-Transformationen

Als Transformationen werden affine Transformationen im Rn betrachtet. Alle derartigen Transformationen lassen sich darstellen als: y = A x + b wobei A die quadratische Transformationsmatrix und b der Verschiebungsvektor ist. Wenn b=0 ist, so handelt es sich um eine lineare Transformation. Die Anwendung zweier affiner Transformationen ergibt: y= A2 (A1 x + b1) + b2 = A2A1 x + A2b1 + b2 = A x + b mit A = A2A1 und b = A2b1 + b2 Für lineare Transformationen entfallen die Verschiebungsanteile. Die linearen Anteile ergeben sich immer durch Multiplikation der Transformationmatrizen.  Die mehrfache Anwendung von linearen Transformationen wird durch Matrixmultiplikationen relisiert. Die mehrfache Anwendung von Verschiebungen führt auf kompliziertere Matrix-Vektor-Operationen. 09-Transformationen

Homogene Koordinaten Beispiel R1 w 1 1 R1 0.5 x 1 R1 0.5 1 0.5 R1 1 x 0.5 09-Transformationen

Kosten: Es muss mit größeren Matrizen gerechnet werden. Jeder Punkt x im Rn wir identifiziert mit der Geraden, die durch die Punkte (tx,t) im Rn+1 gebildet wird.  Jeder Punkt (x,w) mit x∈Rn und w≠0 repräsentiert genau einen Punkt aus Rn nämlich x/w. Affine Transformationen stellen sich in affinen Koordinaten folgendermaßen dar:  Alle affinen Transformationen im Rn lassen sich durch Übergang zu den homogenen Koordinaten als lineare Transformationen darstellen.  Mehrfachanwendungen von affinen Transformationen lassen sich als Matrixmultiplikationen darstellen. Kosten: Es muss mit größeren Matrizen gerechnet werden. Die letzte Zeile der Matrix ist trivial und wird deshalb nicht gespeichert. 09-Transformationen

Elementare Transformationen Alle affinen Transformationen lassen sich durch einige wenige elementare Transformationen durch Kombination erzeugen. Jede affine Transformation ist die Kombination aus einer linearen Transformation und einer Verschiebung: 09-Transformationen

Drehung Im R2 gibt es genau eine Drehung um den Koordinatenursprung mit dem Winkel α: Im R3 gibt es drei Drehungen um die Achsen mit dem Winkel α: Drehungen erhalten sowohl die Winkel, die Längen als auch die Abstände zum Koordinatenursprung. 09-Transformationen

Skalierungen Skalierungen sind Multiplikationen der einzelnen Koordinaten mit konstanten Faktoren. Es gibt im Rn genau n Skalierungen. 09-Transformationen

Scherungen Im zweidimensionalen Fall ergeben Rotation und Skalierungen genau drei Transformationen. Die lineare Transformationsmatrix enthält aber vier Parameter. Man benötigt also noch eine elementare Transformation, um alle Transformationen beschreiben zu können. Dieses kann z.B. eine Scherung sein. Im dreidimensionalen Fall ergeben drei Rotationen und drei Skalierungen sechs Transformationen. Es fehlen also noch drei Scherungen um alle Parameter festzulegen. Scherungen verändern die Längen und Winkel. Parallelität bleibt jedoch erhalten. 09-Transformationen

Die Reihenfolge der Transformationen ist wichtig! Die Hintereinanderausführung von Transformationen ist nicht kommutativ! Die Reihenfolge der Transformationen ist wichtig! Beispiel Rotation um einen gegebenen Punkt (x0,y0) um einen Winkel α. 09-Transformationen

Die Klasse AffineTransform Die Klasse AffineTransform dient der Beschreibung affiner Transformationen in java. Die Klasse ist in AWT enthalten und wird hauptsächlich in Graphics2D verwendet. java.awt.geom.AffineTransform Die Klasse ermöglicht: Die Erzeugung von affinen Transformationen Die Verkettung von affinen Transformationen Die Invertierung von affinen Transformationen Die Anwendung von affinen Transformationen auf Shape-Objekte 09-Transformationen

Konstruktoren AffineTransform() erzeugt die Identische Abbildung AffineTransform(AffineTransform Tx) erzeugt eine Kopie der affinen Transformation Tx AffineTransform(double[] flatmatrix) erzeugt aus dem Vektor flatmatrix eine affine Transformation mit der zugehörigen Matrix. flatmatrix.length<6  lineare Transformation mit der Matrix flatmatrix.length>=6  affine Transformation mit der Matrix AffineTransform(double m00, double m10, double m01, double m11, double m02, double m12) erzeugt eine affine Transformation mit der Matrix Die letzten beiden gibt es auch mit float-Variablen 09-Transformationen

Fabrikmethoden public static AffineTransform getRotateInstance (double theta) erzeugt eine Rotations-Transformation public static AffineTransform getRotateInstance (double theta, double x, double y) erzeugt eine Rotations-Transformation um den Punkt (x,y) public static AffineTransform getTranslateInstance (double tx, double ty) erzeugt eine Translations-Transformation mit der Verschiebung (tx,ty) public static AffineTransform getScaleInstance (double sx, double sy) erzeugt eine Skalierungs-Transformation mit den Faktoren (sx,sy) 09-Transformationen

public static AffineTransform getShearInstance (double shx, double shy) erzeugt eine Scherungs-Transformation mit den Faktoren (shx,shy) 09-Transformationen

Abfragemethoden public int getType() bestimmt den Typ der Transformation: TYPE_IDENTITY : Identische Transformation TYPE_GENERAL_TRANSFORM : allgemeine Transformation TYPE_TRANSLATION : enthält Translationsanteil (m02≠0 oder m12≠0) TYPE_UNIFORM_SCALE : gleichmäßig Skalierung (m00==m11≠1) TYPE_GENERAL_SCALE : ungleichmäßige Skalierung (m00≠1, m11≠1, m00≠m11) TYPE_QUADRANT_ROTATION : Rotation um Vielfache von 90° TYPE_GENERAL_ROTATION : allgemeine Rotation mehrfache Typen werden durch oder - Operation gebildet public double getDeterminant() berechnet die Determinante der Transformationsmatrix = m00*m11-m01*m10 09-Transformationen

public double getScaleX() liefert m00 public void getMatrix(double[] flatmatrix) bestimmt die Transformationsmatrix: flatmatrix.length<6 flatmatrix={m00, m10, m01, m11} flatmatrix.length>=6 flatmatrix={m00, m10, m01, m11, m02, m12} public double getScaleX() liefert m00 public double getScaleY() liefert m11 public double getShareX() liefert m01 public double getShareY() liefert m10 public double getTranslateX() liefert m02 public double getTranslateY() liefert m12 09-Transformationen

Verkettung von Transformationen public void concatenate(AffineTransform Tx) verkettet die aktuelle Transformation mit Tx [this] = [this] * [Tx] public void preConcatenate(AffineTransform Tx) verkettet die aktuelle Transformation mit Tx [this] = [Tx] * [this] public void translate(double tx, double ty) entspricht concatenate(AffineTransform.getTranslateInstance(tx,ty)) public void rotate(double theta) entspricht concatenate(AffineTransform.getRotateInstance(theta)) public void rotate(double theta, double x, double y) entspricht concatenate(AffineTransform.getRotateInstance (theta, x, y)) 09-Transformationen

public void scale(double sx, double sy) entspricht concatenate(AffineTransform.getScaleInstance (sx, sy)) public void share(double shx, double shy) entspricht concatenate(AffineTransform.getShareInstance (shx, shy)) 09-Transformationen

Überschreiben der Transformation public void setToIdentity() ersetzt die Transformation durch die Identität public void setToTranslation(double tx, double ty) ersetzt die Transformation durch die Translation AffineTransform.getTranslateInstance(tx,ty) public void setToRotation(double theta) ersetzt die Transformation durch die Rotation AffineTransform.getRotateInstance(theta) public void setToRotation(double theta, double x, double y) ersetzt die Transformation durch die Rotation AffineTransform.getRotateInstance(theta, x, y) public void setToScale(double sx, double sy) ersetzt die Transformation durch die Rotation AffineTransform.getScaleInstance(sx, sy) public void setToShear(double shx, double shy) ersetzt die Transformation durch die Rotation AffineTransform.getScaleInstance(sx, sy) 09-Transformationen

public AffineTransform createInverse() throws NoninvertibleTransformException berechnet die inverse Transformation 09-Transformationen

Transformation von Objekten public Point2D transform(Point2D ptSrc, Point2D ptDst) Transformiert den Punkt ptSrc mit der aktuellen Transformation. Das Ergebnis wird auf das Objekt ptDst gespeichert und als Wert der Methode zurückgegeben. Ist ptDst==null wird ein neues Objekt erzeugt. public void transform(Point2D[] ptSrc, int srcOff, Point2D[] ptDst, int dstOff, int numPts) Transformiert einen Vektor ptSrc von Punkten und speichert die Resultate im Vektor ptDst. public void transform(float[] srcPts, int srcOff, float[] dstPts, int dstOff, int numPts) Die zu transformierenden Punkte werden in dem Vektor srcPtr = {x0, y0, x1, y0, …} gespeichert. Analog die Resultate in dstPts. Analoge Methoden für double[]double[], float[]double[] und double[]float[]. 09-Transformationen

public Point2D inverseTransform(Point2D ptSrc, Point2D ptDst) throws NoninvertibleTransformException berechnet den invers transformierten Punkt public void inverseTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts) throws NoninvertibleTransformException berechnet die invers transformierten Punkte public Point2D deltaTransform(Point2D ptSrc, Point2D ptDst) berechnet die Transformation des Punktes ptSrc, wobei die Translationskomponente nicht berücksichtigt wird. public void deltaTransform(double[] srcPts, int srcOff, double[] dstPts, int dstOff, int numPts) berechnet die Transformation eines Vektors von Punkten ohne Berücksichtigung der Translationskomponente 09-Transformationen

public Shape createTransformedShape(Shape pSrc) Berechnet ein Shape-Objekt als Transformation des Shape-Objektes pSrc. Shape-Objekte sind allgemeine 2D-Objekte in Graphics2D. 09-Transformationen