Auf dieser Seite

QTransform Class

Die Klasse „QTransform“ definiert 2D-Transformationen eines Koordinatensystems. Mehr...

Header: #include <QTransform>
CMake: find_package(Qt6 REQUIRED COMPONENTS Gui)
target_link_libraries(mytarget PRIVATE Qt6::Gui)
qmake: QT += gui

Öffentliche Typen

enum TransformationType { TxNone, TxTranslate, TxScale, TxRotate, TxShear, TxProject }

Öffentliche Funktionen

QTransform()
QTransform(qreal m11, qreal m12, qreal m21, qreal m22, qreal dx, qreal dy)
QTransform(qreal m11, qreal m12, qreal m13, qreal m21, qreal m22, qreal m23, qreal m31, qreal m32, qreal m33)
QTransform(const QTransform &other)
QTransform(QTransform &&other)
qreal m11() const
qreal m12() const
qreal m13() const
qreal m21() const
qreal m22() const
qreal m23() const
qreal m31() const
qreal m32() const
qreal m33() const
QTransform adjoint() const
qreal determinant() const
qreal dx() const
qreal dy() const
QTransform inverted(bool *invertible = nullptr) const
bool isAffine() const
bool isIdentity() const
bool isInvertible() const
bool isRotating() const
bool isScaling() const
bool isTranslating() const
void map(qreal x, qreal y, qreal *tx, qreal *ty) const
QLine map(const QLine &l) const
QLineF map(const QLineF &line) const
QPainterPath map(const QPainterPath &path) const
QPoint map(const QPoint &point) const
QPointF map(const QPointF &p) const
QPolygon map(const QPolygon &polygon) const
QPolygonF map(const QPolygonF &polygon) const
QRegion map(const QRegion &region) const
void map(int x, int y, int *tx, int *ty) const
QRectF mapRect(const QRectF &rectangle) const
QRect mapRect(const QRect &rectangle) const
QPolygon mapToPolygon(const QRect &rectangle) const
void reset()
(since 6.5) QTransform &rotate(qreal a, Qt::Axis axis, qreal distanceToPlane)
QTransform &rotate(qreal a, Qt::Axis axis = Qt::ZAxis)
(since 6.5) QTransform &rotateRadians(qreal a, Qt::Axis axis, qreal distanceToPlane)
QTransform &rotateRadians(qreal a, Qt::Axis axis = Qt::ZAxis)
QTransform &scale(qreal sx, qreal sy)
void setMatrix(qreal m11, qreal m12, qreal m13, qreal m21, qreal m22, qreal m23, qreal m31, qreal m32, qreal m33)
QTransform &shear(qreal sh, qreal sv)
QTransform &translate(qreal dx, qreal dy)
QTransform transposed() const
QTransform::TransformationType type() const
operator QVariant() const
bool operator!=(const QTransform &matrix) const
QTransform operator*(const QTransform &matrix) const
QTransform &operator*=(const QTransform &matrix)
QTransform &operator*=(qreal scalar)
QTransform &operator+=(qreal scalar)
QTransform &operator-=(qreal scalar)
QTransform &operator/=(qreal scalar)
QTransform &operator=(QTransform &&other)
QTransform &operator=(const QTransform &matrix)
bool operator==(const QTransform &matrix) const

Statische öffentliche Mitglieder

QTransform fromScale(qreal sx, qreal sy)
QTransform fromTranslate(qreal dx, qreal dy)
bool quadToQuad(const QPolygonF &one, const QPolygonF &two, QTransform &trans)
bool quadToSquare(const QPolygonF &quad, QTransform &trans)
bool squareToQuad(const QPolygonF &quad, QTransform &trans)
bool qFuzzyCompare(const QTransform &t1, const QTransform &t2)
size_t qHash(const QTransform &key, size_t seed = 0)
QLine operator*(const QLine &line, const QTransform &matrix)
QLineF operator*(const QLineF &line, const QTransform &matrix)
QPainterPath operator*(const QPainterPath &path, const QTransform &matrix)
QPoint operator*(const QPoint &point, const QTransform &matrix)
QPointF operator*(const QPointF &point, const QTransform &matrix)
QPolygon operator*(const QPolygon &polygon, const QTransform &matrix)
QPolygonF operator*(const QPolygonF &polygon, const QTransform &matrix)
QRegion operator*(const QRegion &region, const QTransform &matrix)
QDataStream &operator<<(QDataStream &stream, const QTransform &matrix)
QDataStream &operator>>(QDataStream &stream, QTransform &matrix)

Ausführliche Beschreibung

Eine Transformation legt fest, wie das Koordinatensystem verschoben, skaliert, geschert, gedreht oder projiziert wird, und wird typischerweise beim Rendern von Grafiken verwendet.

Ein QTransform-Objekt kann mithilfe der Funktionen „ setMatrix()“, „ scale()“, „ rotate()“, „ translate()“ und „ shear()“ erstellt werden. Alternativ kann es durch Anwenden von „ basic matrix operations “ erstellt werden. Die Matrix kann auch bei der Erstellung definiert werden und mithilfe der Funktion „ reset()“ auf die Einheitsmatrix (Standard) zurückgesetzt werden.

Die Klasse `QTransform` unterstützt die Abbildung von Grafikprimitiven: Ein beliebiger Punkt, eine Linie, ein Polygon, eine Region oder ein Malerpfad kann mithilfe der Funktion ` map()` auf das durch diese Matrix definierte Koordinatensystem abgebildet werden. Im Falle eines Rechtecks können dessen Koordinaten mithilfe der Funktion ` mapRect()` transformiert werden. Ein Rechteck kann mithilfe der Funktion ` mapToPolygon()` auch in ein Polygon transformiert (auf das durch diese Matrix definierte Koordinatensystem abgebildet) werden.

QTransform stellt die Funktion ` isIdentity()` zur Verfügung, die ` true ` zurückgibt, wenn die Matrix die Einheitsmatrix ist, sowie die Funktion ` isInvertible()`, die ` true ` zurückgibt, wenn die Matrix nicht-singulär ist (d. h. `AB = BA = I`). Die Funktion „ inverted()“ gibt eine invertierte Kopie dieser Matrix zurück, sofern sie invertierbar ist (andernfalls gibt sie die Einheitsmatrix zurück), und „ adjoint()“ gibt die klassische Adjunkte der Matrix zurück. Darüber hinaus bietet QTransform die Funktion „ determinant()“, die die Determinante der Matrix zurückgibt.

Schließlich unterstützt die Klasse `QTransform` Matrixmultiplikation, Addition und Subtraktion, und Objekte dieser Klasse können sowohl gestreamt als auch verglichen werden.

Grafikdarstellung

Beim Rendern von Grafiken definiert die Matrix die Transformationen, doch die eigentliche Transformation wird von den Zeichenroutinen in ` QPainter` durchgeführt.

Standardmäßig arbeitet „ QPainter “ mit dem eigenen Koordinatensystem des zugehörigen Geräts. Der Ursprung des Standardkoordinatensystems eines „ QPaintDevice “ befindet sich in der Position oben links. Die x-Werte nehmen nach rechts hin zu; die y-Werte nehmen nach unten hin zu. Eine vollständige Beschreibung finden Sie in der Dokumentation zum Koordinatensystem.

QPainter verfügt über Funktionen zum Verschieben, Skalieren, Scheren und Drehen des Koordinatensystems ohne Verwendung eines `QTransform`. Zum Beispiel:

Text um 45 Grad gedreht
void SimpleTransformation::paintEvent(QPaintEvent *)
{
    QPainter painter(this);
    painter.setPen(QPen(Qt::blue, 1, Qt::DashLine));
    painter.drawRect(0, 0, 100, 100);

    painter.rotate(45);

    painter.setFont(QFont("Helvetica", 24));
    painter.setPen(QPen(Qt::black, 1));
    painter.drawText(20, 10, "QTransform");
}

Obwohl diese Funktionen sehr praktisch sind, kann es effizienter sein, eine QTransform zu erstellen und ` QPainter::setTransform()` aufzurufen, wenn Sie mehr als eine Transformationsoperation durchführen möchten. Zum Beispiel:

Text skaliert, gedreht und verschoben
void CombinedTransformation::paintEvent(QPaintEvent *)
{
    QPainter painter(this);
    painter.setPen(QPen(Qt::blue, 1, Qt::DashLine));
    painter.drawRect(0, 0, 100, 100);

    QTransform transform;
    transform.translate(50, 50);
    transform.rotate(45);
    transform.scale(0.5, 1.0);
    painter.setTransform(transform);

    painter.setFont(QFont("Helvetica", 24));
    painter.setPen(QPen(Qt::black, 1));
    painter.drawText(20, 10, "QTransform");
}

Grundlegende Matrixoperationen

Abbildung, die ein Objekt zeigt, das eine 3×3-Matrix enthält, wobei jede Zeile ein anderes Element darstellt

Ein QTransform-Objekt enthält eine 3 × 3-Matrix. Die Elemente ` m31 ` (dx) und ` m32 ` (dy) legen die horizontale und vertikale Verschiebung fest. Die Elemente ` m11 ` und ` m22 ` legen die horizontale und vertikale Skalierung fest. Die Elemente ` m21 ` und ` m12 ` legen die horizontale und vertikale Scherung fest. Und schließlich legen die Elemente ` m13 ` und ` m23 ` die horizontale und vertikale Projektion fest, wobei ` m33 ` als zusätzlicher Projektionsfaktor dient.

QTransform transformiert einen Punkt in der Ebene anhand der folgenden Formeln in einen anderen Punkt:

x' = m11*x + m21*y + dx
y' = m22*y + m12*x + dy
if (!isAffine()) {
    w' = m13*x + m23*y + m33
    x' /= w'
    y' /= w'
}

Der Punkt (x, y) ist der ursprüngliche Punkt, und (x', y') ist der transformierte Punkt. (x', y') kann durch Ausführen derselben Operation auf die Matrix „ inverted()“ wieder in (x, y) zurücktransformiert werden.

Die verschiedenen Matrixelemente können beim Erstellen der Matrix oder später mithilfe der Funktion „ setMatrix()“ festgelegt werden. Sie können auch mithilfe der Hilfsfunktionen „ translate()“, „ rotate()“, „ scale()“ und „ shear()“ bearbeitet werden. Die aktuell eingestellten Werte können mithilfe der Funktionen „ m11()“, „ m12()“, „ m13()“, „ m21()“, „ m22()“, „ m23()“, „ m31()“, „ m32()“, „ m33()“, „ dx()“ und „ dy()“ abgerufen werden.

Die Translation ist die einfachste Transformation. Durch die Einstellung von „ dx “ und „ dy “ wird das Koordinatensystem um „ dx “ Einheiten entlang der X-Achse und um „ dy “ Einheiten entlang der Y-Achse verschoben. Eine Skalierung kann durch die Einstellung von „ m11 “ und „ m22 “ vorgenommen werden. Wenn Sie beispielsweise „ m11 “ auf 2 und „ m22 “ auf 1,5 setzen, wird die Höhe verdoppelt und die Breite um 50 % vergrößert. Die Identitätsmatrix hat die Werte m11, m22 und m33 auf 1 gesetzt (alle anderen sind auf 0 gesetzt) und bildet einen Punkt auf sich selbst ab. Die Scherung wird durch m12 und m21 gesteuert. Werden diese Elemente auf Werte ungleich Null gesetzt, wird das Koordinatensystem verdreht. Eine Drehung wird durch die Einstellung sowohl der Scherungsfaktoren als auch der Skalierungsfaktoren erreicht. Eine perspektivische Transformation wird durch die Einstellung sowohl der Projektionsfaktoren als auch der Skalierungsfaktoren erreicht.

Kombination von Transformationen

Hier ist ein Beispiel für kombinierte Transformationen unter Verwendung grundlegender Matrixoperationen:

Text mit kombinierter Matrixtransformation
void BasicOperations::paintEvent(QPaintEvent *)
{
    const double a = qDegreesToRadians(45.0);
    double sina = sin(a);
    double cosa = cos(a);

    QTransform scale(0.5, 0, 0, 1.0, 0, 0);
    QTransform rotate(cosa, sina, -sina, cosa, 0, 0);
    QTransform translate(1, 0, 0, 1, 50.0, 50.0);

    QTransform transform = scale * rotate * translate;

    QPainter painter(this);
    painter.setPen(QPen(Qt::blue, 1, Qt::DashLine));
    painter.drawRect(0, 0, 100, 100);

    painter.setTransform(transform);

    painter.setFont(QFont("Helvetica", 24));
    painter.setPen(QPen(Qt::black, 1));
    painter.drawText(20, 10, "QTransform");
}

Die kombinierte Transformation skaliert zunächst jeden Operanden, dreht ihn dann und verschiebt ihn schließlich – genau in der Reihenfolge, in der das Produkt seiner Faktoren geschrieben wird. Das bedeutet, dass der Punkt, auf den die Transformationen angewendet werden, implizit von links mit der rechts davon stehenden Transformation multipliziert wird.

Bezug zur Matrixnotation

Die Matrixnotation in QTransform ist die Transponierte einer allgemein gelehrten Konvention, die Transformationen und Punkte als Matrizen und Vektoren darstellt. Bei dieser Konvention wird die Matrix links und der Spaltenvektor rechts multipliziert. Mit anderen Worten: Wenn mehrere Transformationen auf einen Punkt angewendet werden, wirkt die Matrix ganz rechts zuerst direkt auf den Vektor ein. Dann wirkt die nächste Matrix von links auf das Ergebnis der ersten Operation ein – und so weiter. Infolgedessen multipliziert diese Konvention die Matrizen, aus denen sich eine zusammengesetzte Transformation zusammensetzt, in umgekehrter Reihenfolge zu QTransform, wie Sie unter Combining Transforms sehen können. Durch Transponieren der Matrizen und deren Kombination rechts neben einem Zeilenvektor, der den Punkt darstellt, erscheinen die Matrizen der Transformationen in ihrem Produkt in der Reihenfolge, in der wir uns die Anwendung der Transformationen auf den Punkt vorstellen.

Siehe auch QPainter, „Koordinatensystem“, „Beispiel für affine Transformationen“ und „Beispiel für Transformationen“.

Dokumentation zum Mitgliedstyp

enum QTransform::TransformationType

KonstanteWert
QTransform::TxNone0x00
QTransform::TxTranslate0x01
QTransform::TxScale0x02
QTransform::TxRotate0x04
QTransform::TxShear0x08
QTransform::TxProject0x10

Dokumentation zu Member-Funktionen

QTransform::QTransform()

Erstellt eine Identitätsmatrix.

Alle Elemente werden auf Null gesetzt, mit Ausnahme von m11 und m22 (die den Maßstab festlegen) sowie m33, die auf 1 gesetzt werden.

Siehe auch reset().

QTransform::QTransform(qreal m11, qreal m12, qreal m21, qreal m22, qreal dx, qreal dy)

Erstellt eine Matrix mit den Elementen m11, m12, m21, m22, dx und dy.

Siehe auch setMatrix().

QTransform::QTransform(qreal m11, qreal m12, qreal m13, qreal m21, qreal m22, qreal m23, qreal m31, qreal m32, qreal m33)

Erstellt eine Matrix mit den Elementen m11, m12, m13, m21, m22, m23, m31, m32, m33.

Siehe auch setMatrix().

[constexpr noexcept default] QTransform::QTransform(const QTransform &other)

Erstellt eine Instanz von „ QTransform “ durch Kopieren.

[constexpr noexcept default] QTransform::QTransform(QTransform &&other)

Erstellt eine Instanz von „ QTransform “ mithilfe von „Move“.

qreal QTransform::m11() const

Gibt den horizontalen Skalierungsfaktor zurück.

Siehe auch scale() und Basic Matrix Operations.

qreal QTransform::m12() const

Gibt den vertikalen Scherfaktor zurück.

Siehe auch shear() und Basic Matrix Operations.

qreal QTransform::m13() const

Gibt den horizontalen Projektionsfaktor zurück.

Siehe auch translate() und Basic Matrix Operations.

qreal QTransform::m21() const

Gibt den horizontalen Scherfaktor zurück.

Siehe auch shear() und Basic Matrix Operations.

qreal QTransform::m22() const

Gibt den vertikalen Skalierungsfaktor zurück.

Siehe auch scale() und Basic Matrix Operations.

qreal QTransform::m23() const

Gibt den vertikalen Projektionsfaktor zurück.

Siehe auch translate() und Basic Matrix Operations.

qreal QTransform::m31() const

Gibt den Faktor für die horizontale Verschiebung zurück.

Siehe auch dx(), translate() und Basic Matrix Operations.

qreal QTransform::m32() const

Gibt den vertikalen Verschiebungsfaktor zurück.

Siehe auch dy(), translate() und Basic Matrix Operations.

qreal QTransform::m33() const

Gibt den Divisionsfaktor zurück.

Siehe auch translate() und Basic Matrix Operations.

QTransform QTransform::adjoint() const

Gibt den Adjunkten dieser Matrix zurück.

qreal QTransform::determinant() const

Gibt die Determinante der Matrix zurück.

qreal QTransform::dx() const

Gibt den Faktor für die horizontale Verschiebung zurück.

Siehe auch m31(), translate() und Basic Matrix Operations.

qreal QTransform::dy() const

Gibt den vertikalen Verschiebungsfaktor zurück.

Siehe auch translate() und Basic Matrix Operations.

[static] QTransform QTransform::fromScale(qreal sx, qreal sy)

Erzeugt eine Matrix, die einer Skalierung von sx in horizontaler Richtung und sy in vertikaler Richtung entspricht. Dies entspricht der Funktion QTransform().scale(sx, sy), ist jedoch etwas schneller.

[static] QTransform QTransform::fromTranslate(qreal dx, qreal dy)

Erzeugt eine Matrix, die einer Verschiebung von dx entlang der x-Achse und dy entlang der y-Achse entspricht. Dies entspricht der Funktion QTransform().translate(dx, dy), ist jedoch etwas schneller.

QTransform QTransform::inverted(bool *invertible = nullptr) const

Gibt eine invertierte Kopie dieser Matrix zurück.

Ist die Matrix singulär (nicht invertierbar), ist die zurückgegebene Matrix die Einheitsmatrix. Ist ` invertible ` gültig (d. h. ungleich 0), wird sein Wert auf `true` gesetzt, wenn die Matrix invertierbar ist, andernfalls auf `false`.

Siehe auch ` isInvertible()`.

bool QTransform::isAffine() const

Gibt „ true “ zurück, wenn die Matrix eine affine Transformation darstellt; andernfalls wird „ false “ zurückgegeben.

bool QTransform::isIdentity() const

Gibt „ true “ zurück, wenn es sich bei der Matrix um die Einheitsmatrix handelt, andernfalls „ false “.

Siehe auch reset().

bool QTransform::isInvertible() const

Gibt „ true “ zurück, wenn die Matrix invertierbar ist, andernfalls „ false “.

Siehe auch inverted().

bool QTransform::isRotating() const

Gibt „ true “ zurück, wenn die Matrix eine Rotationstransformation darstellt, andernfalls „ false “.

Hinweis: Eine Rotationstransformation von 180 Grad und/oder 360 Grad wird als Skalierungstransformation behandelt.

Siehe auch reset().

bool QTransform::isScaling() const

Gibt „ true “ zurück, wenn die Matrix eine Skalierungstransformation darstellt, andernfalls „ false “.

Siehe auch reset().

bool QTransform::isTranslating() const

Gibt „ true “ zurück, wenn die Matrix eine Translationstransformation darstellt, andernfalls „ false “.

Siehe auch reset().

void QTransform::map(qreal x, qreal y, qreal *tx, qreal *ty) const

Ordnet die angegebenen Koordinaten x und y dem durch diese Matrix definierten Koordinatensystem zu. Die resultierenden Werte werden jeweils in *tx und *ty gespeichert.

Die Koordinaten werden anhand der folgenden Formeln transformiert:

x' = m11*x + m21*y + dx
y' = m22*y + m12*x + dy
if (!isAffine()) {
    w' = m13*x + m23*y + m33
    x' /= w'
    y' /= w'
}

Der Punkt (x, y) ist der ursprüngliche Punkt, und (x', y') ist der transformierte Punkt.

Siehe auch Basic Matrix Operations.

QLine QTransform::map(const QLine &l) const

Erzeugt und gibt ein „ QLineF “-Objekt zurück, das eine Kopie der angegebenen Linie „ l “ darstellt, die in das durch diese Matrix definierte Koordinatensystem abgebildet wurde.

Dies ist eine überladene Funktion.

QLineF QTransform::map(const QLineF &line) const

Erzeugt und gibt ein ` QLine `-Objekt zurück, das eine Kopie des angegebenen ` line` darstellt, abgebildet auf das durch diese Matrix definierte Koordinatensystem. Beachten Sie, dass die transformierten Koordinaten auf die nächste ganze Zahl gerundet werden.

Dies ist eine überladene Funktion.

QPainterPath QTransform::map(const QPainterPath &path) const

Erzeugt und gibt ein „ QPainterPath “-Objekt zurück, das eine Kopie des angegebenen „ path “ darstellt und in das durch diese Matrix definierte Koordinatensystem abgebildet ist.

Dies ist eine überladene Funktion.

QPoint QTransform::map(const QPoint &point) const

Erzeugt und gibt ein ` QPoint `-Objekt zurück, das eine Kopie des angegebenen ` point` darstellt, abgebildet auf das durch diese Matrix definierte Koordinatensystem. Beachten Sie, dass die transformierten Koordinaten auf die nächste ganze Zahl gerundet werden.

Dies ist eine überladene Funktion.

QPointF QTransform::map(const QPointF &p) const

Erzeugt und gibt ein ` QPointF `-Objekt zurück, das eine Kopie des angegebenen Punktes ` p` darstellt, der in das durch diese Matrix definierte Koordinatensystem abgebildet wurde.

Dies ist eine überladene Funktion.

QPolygon QTransform::map(const QPolygon &polygon) const

Erzeugt und gibt ein ` QPolygon `-Objekt zurück, das eine Kopie des angegebenen ` polygon` darstellt, abgebildet auf das durch diese Matrix definierte Koordinatensystem. Beachten Sie, dass die transformierten Koordinaten auf die nächste ganze Zahl gerundet werden.

Dies ist eine überladene Funktion.

QPolygonF QTransform::map(const QPolygonF &polygon) const

Erzeugt und gibt ein ` QPolygonF `-Objekt zurück, das eine Kopie des angegebenen ` polygon` darstellt, abgebildet auf das durch diese Matrix definierte Koordinatensystem.

Dies ist eine überladene Funktion.

QRegion QTransform::map(const QRegion &region) const

Erstellt und gibt ein „ QRegion “-Objekt zurück, das eine Kopie des angegebenen „ region “ darstellt, abgebildet auf das durch diese Matrix definierte Koordinatensystem.

Der Aufruf dieser Methode kann bei Verwendung von Rotationen oder Scherungen relativ rechenintensiv sein.

Dies ist eine überladene Funktion.

void QTransform::map(int x, int y, int *tx, int *ty) const

Ordnet die angegebenen Koordinaten x und y dem durch diese Matrix definierten Koordinatensystem zu. Die resultierenden Werte werden jeweils in *tx und *ty gespeichert. Beachten Sie, dass die transformierten Koordinaten auf die nächste ganze Zahl gerundet werden.

Dies ist eine überladene Funktion.

QRectF QTransform::mapRect(const QRectF &rectangle) const

Erzeugt und gibt ein „ QRectF “-Objekt zurück, das eine Kopie des angegebenen „ rectangle “ darstellt und in das durch diese Matrix definierte Koordinatensystem abgebildet wird.

Die Koordinaten des Rechtecks werden anhand der folgenden Formeln transformiert:

x' = m11*x + m21*y + dx
y' = m22*y + m12*x + dy
if (!isAffine()) {
    w' = m13*x + m23*y + m33
    x' /= w'
    y' /= w'
}

Wenn eine Drehung oder Scherung angegeben wurde, gibt diese Funktion das umschließende Rechteck zurück. Um den genauen Bereich abzurufen, auf den das angegebene ` rectangle ` abgebildet wird, verwenden Sie stattdessen die Funktion ` mapToPolygon()`.

Siehe auch „ mapToPolygon()“ und „ Basic Matrix Operations “.

QRect QTransform::mapRect(const QRect &rectangle) const

Erzeugt und gibt ein ` QRect `-Objekt zurück, das eine Kopie des angegebenen ` rectangle` darstellt und in das durch diese Matrix definierte Koordinatensystem abgebildet wird. Beachten Sie, dass die transformierten Koordinaten auf die nächste ganze Zahl gerundet werden.

Dies ist eine überladene Funktion.

QPolygon QTransform::mapToPolygon(const QRect &rectangle) const

Erzeugt und gibt eine Darstellung „ QPolygon “ des angegebenen „ rectangle “ zurück, das in das durch diese Matrix definierte Koordinatensystem abgebildet wird.

Die Koordinaten des Rechtecks werden anhand der folgenden Formeln transformiert:

x' = m11*x + m21*y + dx
y' = m22*y + m12*x + dy
if (!isAffine()) {
    w' = m13*x + m23*y + m33
    x' /= w'
    y' /= w'
}

Polygone und Rechtecke verhalten sich bei der Transformation (aufgrund der Rundung auf ganze Zahlen) etwas unterschiedlich, sodass ` matrix.map(QPolygon(rectangle)) ` nicht immer mit ` matrix.mapToPolygon(rectangle)` übereinstimmt.

Siehe auch ` mapRect()` und ` Basic Matrix Operations`.

[static] bool QTransform::quadToQuad(const QPolygonF &one, const QPolygonF &two, QTransform &trans)

Erstellt eine Transformationsmatrix, trans, die ein vierseitiges Polygon, one, auf ein anderes vierseitiges Polygon, two, abbildet. Gibt „ true “ zurück, wenn die Transformation möglich ist; andernfalls wird „false“ zurückgegeben.

Dies ist eine Komfortmethode, die die Methoden „ quadToSquare()“ und „ squareToQuad()“ kombiniert. Sie ermöglicht es, das eingegebene Viereck in ein beliebiges anderes Viereck zu transformieren.

Siehe auch squareToQuad() und quadToSquare().

[static] bool QTransform::quadToSquare(const QPolygonF &quad, QTransform &trans)

Erstellt eine Transformationsmatrix, trans, die ein vierseitiges Polygon, quad, auf ein Einheitsquadrat abbildet. Gibt true zurück, wenn die Transformation konstruiert wurde, oder „false“, wenn eine solche Transformation nicht existiert.

Siehe auch squareToQuad() und quadToQuad().

void QTransform::reset()

Setzt die Matrix auf eine Einheitsmatrix zurück, d. h., alle Elemente werden auf Null gesetzt, mit Ausnahme von m11 und m22 (die den Skalierungsfaktor angeben) sowie m33, die auf 1 gesetzt werden.

Siehe auch QTransform(), isIdentity() und Basic Matrix Operations.

[since 6.5] QTransform &QTransform::rotate(qreal a, Qt::Axis axis, qreal distanceToPlane)

Dreht das Koordinatensystem um den angegebenen Winkel „ a “ gegen den Uhrzeigersinn um den angegebenen Punkt „ axis “ im Abstand „ distanceToPlane “ vom Bildschirm und gibt einen Verweis auf die Matrix zurück.

Beachten Sie: Wenn Sie eine Drehung ` QTransform ` auf einen in Widget-Koordinaten definierten Punkt anwenden, erfolgt die Drehung im Uhrzeigersinn, da die y-Achse nach unten zeigt.

Der Winkel wird in Grad angegeben.

Ist „ distanceToPlane “ gleich Null, wird der Wert ignoriert. Dies eignet sich zur Implementierung orthogonaler Projektionen, bei denen die z-Koordinate verworfen statt projiziert werden soll.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch setMatrix().

QTransform &QTransform::rotate(qreal a, Qt::Axis axis = Qt::ZAxis)

Dreht das Koordinatensystem um den angegebenen Winkel „ a “ gegen den Uhrzeigersinn um den angegebenen Punkt „ axis “ im Abstand von 1024,0 vom Bildschirm und gibt einen Verweis auf die Matrix zurück.

Beachten Sie: Wenn Sie eine Drehung ( QTransform ) auf einen in Widget-Koordinaten definierten Punkt anwenden, erfolgt die Drehung im Uhrzeigersinn, da die y-Achse nach unten zeigt.

Der Winkel wird in Grad angegeben.

Dies ist eine überladene Funktion.

Siehe auch „ setMatrix “.

[since 6.5] QTransform &QTransform::rotateRadians(qreal a, Qt::Axis axis, qreal distanceToPlane)

Dreht das Koordinatensystem um den angegebenen Winkel „ a “ gegen den Uhrzeigersinn um den angegebenen Punkt „ axis “ im Abstand „ distanceToPlane “ vom Bildschirm und gibt einen Verweis auf die Matrix zurück.

Beachten Sie: Wenn Sie eine Drehung ` QTransform ` auf einen in Widget-Koordinaten definierten Punkt anwenden, erfolgt die Drehung im Uhrzeigersinn, da die y-Achse nach unten zeigt.

Der Winkel wird in Radianten angegeben.

Ist „ distanceToPlane “ gleich Null, wird der Wert ignoriert. Dies eignet sich zur Implementierung orthogonaler Projektionen, bei denen die z-Koordinate verworfen statt projiziert werden soll.

Diese Funktion wurde in Qt 6.5 eingeführt.

Siehe auch ` setMatrix()`.

QTransform &QTransform::rotateRadians(qreal a, Qt::Axis axis = Qt::ZAxis)

Dreht das Koordinatensystem um den angegebenen Winkel „ a “ gegen den Uhrzeigersinn um den angegebenen Punkt „ axis “ im Abstand von 1024,0 zum Bildschirm und gibt einen Verweis auf die Matrix zurück.

Beachten Sie: Wenn Sie eine QTransform auf einen in Widget-Koordinaten definierten Punkt anwenden, erfolgt die Drehung im Uhrzeigersinn, da die y-Achse nach unten zeigt.

Der Winkel wird in Radianten angegeben.

Dies ist eine überladene Funktion.

Siehe auch setMatrix().

QTransform &QTransform::scale(qreal sx, qreal sy)

Skaliert das Koordinatensystem horizontal um sx und vertikal um sy und gibt einen Verweis auf die Matrix zurück.

Siehe auch setMatrix().

void QTransform::setMatrix(qreal m11, qreal m12, qreal m13, qreal m21, qreal m22, qreal m23, qreal m31, qreal m32, qreal m33)

Setzt die Matrixelemente auf die angegebenen Werte: m11, m12, m13, m21, m22, m23, m31, m32 und m33. Beachten Sie, dass diese Funktion die bisherigen Werte überschreibt. QTransform stellt die Hilfsfunktionen translate(), rotate(), scale() und shear() zur Verfügung, um die verschiedenen Matrixelemente basierend auf dem aktuell definierten Koordinatensystem zu bearbeiten.

Siehe auch QTransform().

QTransform &QTransform::shear(qreal sh, qreal sv)

Verschiebt das Koordinatensystem horizontal um sh und vertikal um sv und gibt einen Verweis auf die Matrix zurück.

Siehe auch setMatrix().

[static] bool QTransform::squareToQuad(const QPolygonF &quad, QTransform &trans)

Erstellt eine Transformationsmatrix, trans, die ein Einheitsquadrat auf ein vierseitiges Polygon abbildet, quad. Gibt true zurück, wenn die Transformation konstruiert wurde, oder „false“, wenn eine solche Transformation nicht existiert.

Siehe auch quadToSquare() und quadToQuad().

QTransform &QTransform::translate(qreal dx, qreal dy)

Verschiebt das Koordinatensystem um dx entlang der x-Achse und um dy entlang der y-Achse und gibt einen Verweis auf die Matrix zurück.

Siehe auch setMatrix().

QTransform QTransform::transposed() const

Gibt die Transponierte dieser Matrix zurück.

QTransform::TransformationType QTransform::type() const

Gibt den Transformationstyp dieser Matrix zurück.

Der Transformationstyp ist der höchste Enumerationswert, der alle Transformationen der Matrix umfasst. Wenn die Matrix beispielsweise sowohl skaliert als auch verschiebt, wäre der Typ „ TxShear “, da „ TxShear “ einen höheren Enumerationswert hat als „ TxScale “.

Die Kenntnis des Transformationstyps einer Matrix ist für die Optimierung nützlich: Oft lassen sich bestimmte Typen optimaler behandeln als der allgemeine Fall.

QTransform::operator QVariant() const

Gibt die Transformation als ` QVariant` zurück.

bool QTransform::operator!=(const QTransform &matrix) const

Gibt „ true “ zurück, wenn diese Matrix nicht mit der angegebenen „ matrix “ übereinstimmt; andernfalls wird „ false “ zurückgegeben.

QTransform QTransform::operator*(const QTransform &matrix) const

Gibt das Ergebnis der Multiplikation dieser Matrix mit dem angegebenen matrix zurück.

Beachten Sie, dass die Matrixmultiplikation nicht kommutativ ist, d. h. a*b ≠ b*a.

QTransform &QTransform::operator*=(const QTransform &matrix)

Gibt das Ergebnis der Multiplikation dieser Matrix mit dem angegebenen „ matrix “ zurück.

Dies ist eine überladene Funktion.

QTransform &QTransform::operator*=(qreal scalar)

Gibt das Ergebnis einer elementweisen Multiplikation dieser Matrix mit dem angegebenen ` scalar` zurück.

Dies ist eine überladene Funktion.

QTransform &QTransform::operator+=(qreal scalar)

Gibt die Matrix zurück, die entsteht, wenn zu jedem Element dieser Matrix der angegebene Wert ` scalar ` addiert wird.

QTransform &QTransform::operator-=(qreal scalar)

Gibt die Matrix zurück, die entsteht, wenn von jedem Element dieser Matrix der angegebene Wert ` scalar ` abgezogen wird.

QTransform &QTransform::operator/=(qreal scalar)

Gibt das Ergebnis einer elementweisen Division dieser Matrix durch die angegebene Matrix ` scalar` zurück.

[noexcept default] QTransform &QTransform::operator=(QTransform &&other)

Weist „ other “ dieser „ QTransform “-Instanz zu.

[noexcept default] QTransform &QTransform::operator=(const QTransform &matrix)

Weist dieser Matrix die Werte der angegebenen „ matrix “ zu.

bool QTransform::operator==(const QTransform &matrix) const

Gibt „ true “ zurück, wenn diese Matrix mit der angegebenen „ matrix “ übereinstimmt, andernfalls „ false “.

Verwandte Nicht-Mitglieder

[noexcept] bool qFuzzyCompare(const QTransform &t1, const QTransform &t2)

Gibt „ true “ zurück, wenn „ t1 “ und „ t2 “ gleich sind, wobei bei Gleitkomma-Vergleichen ein geringer Ungenauigkeitsfaktor berücksichtigt wird; andernfalls „false“.

[noexcept] size_t qHash(const QTransform &key, size_t seed = 0)

Gibt den Hashwert für key zurück, wobei seed als Startwert für die Berechnung verwendet wird.

QLine operator*(const QLine &line, const QTransform &matrix)

Dies entspricht matrix.map(line).

Siehe auch QTransform::map().

QLineF operator*(const QLineF &line, const QTransform &matrix)

Dies entspricht matrix.map(line).

Siehe auch QTransform::map().

QPainterPath operator*(const QPainterPath &path, const QTransform &matrix)

Dies entspricht matrix.map(path).

Siehe auch QTransform::map().

QPoint operator*(const QPoint &point, const QTransform &matrix)

Dies entspricht matrix.map(point).

Siehe auch QTransform::map().

QPointF operator*(const QPointF &point, const QTransform &matrix)

Entspricht matrix.map(point).

Siehe auch QTransform::map().

QPolygon operator*(const QPolygon &polygon, const QTransform &matrix)

Dies entspricht matrix.map(polygon).

Siehe auch QTransform::map().

QPolygonF operator*(const QPolygonF &polygon, const QTransform &matrix)

Dies entspricht matrix.map(polygon).

Siehe auch QTransform::map().

QRegion operator*(const QRegion &region, const QTransform &matrix)

Dies entspricht matrix.map(region).

Siehe auch QTransform::map().

QDataStream &operator<<(QDataStream &stream, const QTransform &matrix)

Schreibt den angegebenen „ matrix “ in den angegebenen „ stream “ und gibt eine Referenz auf den Stream zurück.

Siehe auch „Serialisierung vonQt-Datentypen“.

QDataStream &operator>>(QDataStream &stream, QTransform &matrix)

Liest den angegebenen „ matrix “ aus dem angegebenen „ stream “ und gibt eine Referenz auf den Stream zurück.

Siehe auch „Serialisierung vonQt-Datentypen“.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.