Ejemplo de transformaciones
El ejemplo de transformaciones muestra cómo las transformaciones influyen en la forma en que QPainter representa las primitivas gráficas.

La aplicación permite al usuario manipular el renderizado de una forma cambiando la traslación, la rotación y la escala del sistema de coordenadas de « QPainter ».
El ejemplo consta de dos clases y una enumeración global:
- La clase «
RenderArea» controla el renderizado de una forma determinada. - La clase `
Window` es la ventana principal de la aplicación. - La enumeración `
Operation` describe las distintas operaciones de transformación disponibles en la aplicación.
En primer lugar, echaremos un vistazo rápido a la enumeración ` Operation `; a continuación, revisaremos la clase ` RenderArea ` para ver cómo se representa una forma. Por último, analizaremos las funciones de la aplicación «Transformaciones» implementadas en la clase ` Window `.
Operaciones de transformación
Normalmente, el dispositivo de dibujo ( QPainter ) opera en el propio sistema de coordenadas del dispositivo asociado, pero también ofrece un buen soporte para las transformaciones de coordenadas.
El sistema de coordenadas predeterminado de un dispositivo de dibujo tiene su origen en la esquina superior izquierda. Los valores x aumentan hacia la derecha y los valores y aumentan hacia abajo. Puedes escalar el sistema de coordenadas mediante un desplazamiento determinado utilizando la función ` QPainter::scale()`, puedes girarlo en el sentido de las agujas del reloj utilizando la función ` QPainter::rotate()` y puedes trasladarlo (es decir, añadir un desplazamiento determinado a los puntos) utilizando la función ` QPainter::translate()`. También puedes deformar el sistema de coordenadas alrededor del origen (lo que se denomina «cizallamiento») utilizando la función ` QPainter::shear()`.
Todas las operaciones de transformación se aplican a la matriz de transformación de QPainter, a la que se puede acceder mediante la función QPainter::worldTransform(). Una matriz transforma un punto del plano en otro punto. Para obtener más información sobre la matriz de transformación, consulta la documentación sobre el sistema de coordenadas y QTransform.
enum Operation { NoTransformation, Translate, Rotate, Scale };La enumeración global Operation se declara en el archivo renderarea.h y describe las distintas operaciones de transformación disponibles en la aplicación Transformations.
Definición de la clase `RenderArea`
La clase ` RenderArea ` hereda de ` QWidget` y controla la representación de una forma determinada.
class RenderArea : public QWidget
{
Q_OBJECT
public:
RenderArea(QWidget *parent = nullptr);
void setOperations(const QList<Operation> &operations);
void setShape(const QPainterPath &shape);
QSize minimumSizeHint() const override;
QSize sizeHint() const override;
protected:
void paintEvent(QPaintEvent *event) override;Declaramos dos funciones públicas, ` setOperations() ` y ` setShape()`, para poder especificar la forma del widget ` RenderArea ` y transformar el sistema de coordenadas en el que se representa la forma.
Reimplementamos las funciones minimumSizeHint() y sizeHint() de QWidget para dotar al widget RenderArea de un tamaño razonable dentro de nuestra aplicación, y reimplementamos el controlador de eventos QWidget::paintEvent() para dibujar la forma del área de renderizado aplicando las opciones de transformación elegidas por el usuario.
private:
void drawCoordinates(QPainter &painter);
void drawOutline(QPainter &painter);
void drawShape(QPainter &painter);
void transformPainter(QPainter &painter);
QList<Operation> operations;
QPainterPath shape;
QRect xBoundingRect;
QRect yBoundingRect;
};También declaramos varias funciones de conveniencia para dibujar la forma, el contorno del sistema de coordenadas y las coordenadas, así como para transformar el pintor de acuerdo con las transformaciones elegidas.
Además, el widget ` RenderArea ` mantiene una lista de las operaciones de transformación aplicadas actualmente, una referencia a su forma y un par de variables de conveniencia que utilizaremos al renderizar las coordenadas.
Implementación de la clase `RenderArea`
El widget ` RenderArea ` controla la representación de una forma determinada, incluidas las transformaciones del sistema de coordenadas, mediante la reimplementación del controlador de eventos ` QWidget::paintEvent()`. Pero primero echaremos un vistazo rápido al constructor y a las funciones que permiten acceder al widget ` RenderArea `:
RenderArea::RenderArea(QWidget *parent)
: QWidget(parent)
{
QFont newFont = font();
newFont.setPixelSize(12);
setFont(newFont);
QFontMetrics fontMetrics(newFont);
xBoundingRect = fontMetrics.boundingRect(tr("x"));
yBoundingRect = fontMetrics.boundingRect(tr("y"));
}En el constructor, pasamos el parámetro «parent» a la clase base y personalizamos la fuente que utilizaremos para representar las coordenadas. La función QWidget::font() devuelve la fuente establecida actualmente para el widget. Siempre que no se haya establecido ninguna fuente especial, o tras llamar a QWidget::setFont(), se trata bien de una fuente especial para la clase del widget, bien de la fuente del padre o (si este widget es un widget de nivel superior) de la fuente predeterminada de la aplicación.
Tras asegurarnos de que el tamaño de la fuente es de 12 puntos, extraemos los rectángulos que enmarcan las letras de las coordenadas, «x» e «y», utilizando la clase ` QFontMetrics `.
QFontMetrics proporciona funciones para acceder a las métricas individuales de la fuente, a sus caracteres y a las cadenas representadas con dicha fuente. La función ` QFontMetrics::boundingRect()` devuelve el rectángulo delimitador del carácter dado con respecto al punto más a la izquierda de la línea base.
void RenderArea::setOperations(const QList<Operation> &operations)
{
this->operations = operations;
update();
}
void RenderArea::setShape(const QPainterPath &shape)
{
this->shape = shape;
update();
}En las funciones ` setShape() ` y ` setOperations() `, actualizamos el widget ` RenderArea ` almacenando el nuevo valor o valores, seguido de una llamada a la ranura ` QWidget::update()`, que programa un evento de dibujo para su procesamiento cuando Qt vuelva al bucle de eventos principal.
QSize RenderArea::minimumSizeHint() const
{
return QSize(182, 182);
}
QSize RenderArea::sizeHint() const
{
return QSize(232, 232);
}Reimplementamos las funciones ` minimumSizeHint()` y ` sizeHint()` de ` QWidget` para dotar al widget ` RenderArea ` de un tamaño razonable dentro de nuestra aplicación. Las implementaciones predeterminadas de estas funciones devuelven un tamaño no válido si no existe ningún diseño para este widget y, en caso contrario, devuelven el tamaño mínimo o el tamaño preferido del diseño, respectivamente.
void RenderArea::paintEvent(QPaintEvent *event)
{
QPainter painter(this);
painter.setRenderHint(QPainter::Antialiasing);
painter.fillRect(event->rect(), QBrush(Qt::white));
painter.translate(66, 66);El controlador de eventos paintEvent() recibe los eventos de pintura del widget RenderArea. Un evento de pintura es una solicitud para volver a pintar todo o parte del widget. Puede producirse como resultado de QWidget::repaint() o QWidget::update(), o porque el widget estaba oculto y ahora se ha revelado, o por muchas otras razones.
En primer lugar, creamos un objeto ` QPainter ` para el widget ` RenderArea `. La indicación de renderizado ` QPainter::Antialiasing ` indica que el motor debe aplicar suavizado a los bordes de las primitivas si es posible. A continuación, borramos el área que hay que volver a dibujar utilizando la función ` QPainter::fillRect()`.
También traslamos el sistema de coordenadas con un desplazamiento constante para garantizar que la forma original se represente con un margen adecuado.
{
QPainterStateGuard guard(&painter);
transformPainter(painter);
drawShape(painter);
}Antes de empezar a renderizar la forma, instanciamos un ` QPainterStateGuard ` para guardar el estado actual del pintor (es decir, insertamos el estado en una pila), incluyendo el sistema de coordenadas actual mientras se encuentra en el ámbito. La razón para guardar el estado del «painter» es que la siguiente llamada a la función transformPainter() transformará el sistema de coordenadas en función de las operaciones de transformación seleccionadas en ese momento, y necesitamos una forma de volver al estado original para dibujar el contorno.
Tras transformar el sistema de coordenadas, dibujamos la forma de RenderArea y, a continuación, restauramos el estado del pintor mediante la función QPainter::restore() (es decir, sacamos el estado guardado de la pila).
drawOutline(painter);A continuación, dibujamos el contorno del cuadrado.
transformPainter(painter);
drawCoordinates(painter);
}Dado que queremos que las coordenadas se correspondan con el sistema de coordenadas en el que se representa la forma, debemos realizar otra llamada a la función ` transformPainter() `.
El orden de las operaciones de dibujo es fundamental en lo que respecta a los píxeles compartidos. La razón por la que no dibujamos las coordenadas cuando el sistema de coordenadas ya se ha transformado para renderizar la forma, sino que aplazamos su dibujo hasta el final, es que queremos que las coordenadas aparezcan sobre la forma y su contorno.
En esta ocasión no es necesario guardar el estado de ` QPainter `, ya que el dibujo de las coordenadas es la última operación de dibujo.
void RenderArea::drawCoordinates(QPainter &painter)
{
painter.setPen(Qt::red);
painter.drawLine(0, 0, 50, 0);
painter.drawLine(48, -2, 50, 0);
painter.drawLine(48, 2, 50, 0);
painter.drawText(60 - xBoundingRect.width() / 2,
0 + xBoundingRect.height() / 2, tr("x"));
painter.drawLine(0, 0, 0, 50);
painter.drawLine(-2, 48, 0, 50);
painter.drawLine(2, 48, 0, 50);
painter.drawText(0 - yBoundingRect.width() / 2,
60 + yBoundingRect.height() / 2, tr("y"));
}
void RenderArea::drawOutline(QPainter &painter)
{
painter.setPen(Qt::darkGreen);
painter.setPen(Qt::DashLine);
painter.setBrush(Qt::NoBrush);
painter.drawRect(0, 0, 100, 100);
}
void RenderArea::drawShape(QPainter &painter)
{
painter.fillPath(shape, Qt::blue);
}Las funciones drawCoordinates(), drawOutline() y drawShape() son funciones de conveniencia que se invocan desde el controlador de eventos paintEvent(). Para obtener más información sobre las operaciones básicas de dibujo de QPainter y sobre cómo mostrar primitivas gráficas básicas, consulta el ejemplo «Dibujo básico ».
void RenderArea::transformPainter(QPainter &painter)
{
for (int i = 0; i < operations.size(); ++i) {
switch (operations[i]) {
case Translate:
painter.translate(50, 50);
break;
case Scale:
painter.scale(0.75, 0.75);
break;
case Rotate:
painter.rotate(60);
break;
case NoTransformation:
default:
;
}
}
}La función de conveniencia transformPainter() también se invoca desde el controlador de eventos paintEvent() y transforma el sistema de coordenadas de la QPainter especificada según las opciones de transformación del usuario.
Definición de la clase Window
La clase ` Window ` es la ventana principal de la aplicación «Transformations».
La aplicación muestra cuatro widgets « RenderArea ». El widget situado más a la izquierda representa la forma en el sistema de coordenadas predeterminado de « QPainter »; los demás representan la forma con la transformación elegida, además de todas las transformaciones aplicadas a los widgets « RenderArea » situados a su izquierda.
class Window : public QWidget
{
Q_OBJECT
public:
Window();
public slots:
void operationChanged();
void shapeSelected(int index);Declaramos dos ranuras públicas para que la aplicación pueda responder a la interacción del usuario, actualizando los widgets « RenderArea » mostrados según las opciones de transformación del usuario.
La ranura « operationChanged() » actualiza cada uno de los widgets « RenderArea » aplicando las operaciones de transformación seleccionadas en ese momento, y se invoca cada vez que el usuario cambia las operaciones seleccionadas. La ranura « shapeSelected() » actualiza las formas de los widgets « RenderArea » cada vez que el usuario cambia la forma preferida.
private:
void setupShapes();
enum { NumTransformedAreas = 3 };
RenderArea *originalRenderArea;
RenderArea *transformedRenderAreas[NumTransformedAreas];
QComboBox *shapeComboBox;
QComboBox *operationComboBoxes[NumTransformedAreas];
QList<QPainterPath> shapes;
};También declaramos una función privada de conveniencia, setupShapes(), que se utiliza al construir el widget Window, y declaramos punteros a los distintos componentes del widget. Optamos por mantener las formas disponibles en una QList de QPainterPaths. Además, declaramos una enumeración privada que cuenta el número de widgets RenderArea mostrados, excepto el widget que representa la forma en el sistema de coordenadas predeterminado de QPainter.
Implementación de la clase Window
En el constructor creamos e inicializamos los componentes de la aplicación:
Window::Window()
{
originalRenderArea = new RenderArea;
shapeComboBox = new QComboBox;
shapeComboBox->addItem(tr("Clock"));
shapeComboBox->addItem(tr("House"));
shapeComboBox->addItem(tr("Text"));
shapeComboBox->addItem(tr("Truck"));
QGridLayout *layout = new QGridLayout;
layout->addWidget(originalRenderArea, 0, 0);
layout->addWidget(shapeComboBox, 1, 0);En primer lugar, creamos el widget RenderArea que representará la forma en el sistema de coordenadas predeterminado. También creamos el QComboBox asociado, que permite al usuario elegir entre cuatro formas diferentes: un reloj, una casa, un texto y un camión. Las formas en sí se crean al final del constructor, utilizando la función de conveniencia setupShapes().
for (int i = 0; i < NumTransformedAreas; ++i) {
transformedRenderAreas[i] = new RenderArea;
operationComboBoxes[i] = new QComboBox;
operationComboBoxes[i]->addItem(tr("No transformation"));
operationComboBoxes[i]->addItem(tr("Rotate by 60\xC2\xB0"));
operationComboBoxes[i]->addItem(tr("Scale to 75%"));
operationComboBoxes[i]->addItem(tr("Translate by (50, 50)"));
connect(operationComboBoxes[i], &QComboBox::activated,
this, &Window::operationChanged);
layout->addWidget(transformedRenderAreas[i], 0, i + 1);
layout->addWidget(operationComboBoxes[i], 1, i + 1);
}A continuación, creamos los widgets RenderArea que representarán sus formas mediante transformaciones de coordenadas. Por defecto, la operación aplicada es No Transformation, es decir, las formas se representan dentro del sistema de coordenadas predeterminado. Creamos e inicializamos los QComboBoxasociados con elementos correspondientes a las distintas operaciones de transformación descritas por la enumeración global Operation.
También conectamos la señal « activated()» de los « QComboBox» a la ranura « operationChanged() » para actualizar la aplicación cada vez que el usuario cambie las operaciones de transformación seleccionadas.
setLayout(layout);
setupShapes();
shapeSelected(0);
setWindowTitle(tr("Transformations"));
}Por último, configuramos el diseño de la ventana de la aplicación mediante la función ` QWidget::setLayout()`, creamos las formas disponibles utilizando la función de conveniencia privada ` setupShapes() ` y hacemos que la aplicación muestre la forma del reloj al iniciarse mediante la ranura pública ` shapeSelected() ` antes de establecer el título de la ventana.
void Window::setupShapes()
{
QPainterPath truck;
QPainterPath clock;
QPainterPath house;
QPainterPath text;
...
shapes.append(clock);
shapes.append(house);
shapes.append(text);
shapes.append(truck);
connect(shapeComboBox, &QComboBox::activated,
this, &Window::shapeSelected);
}La función ` setupShapes() ` se invoca desde el constructor y crea los objetos ` QPainterPath ` que representan las formas utilizadas en la aplicación. Para obtener más detalles sobre la construcción, consulte el archivo de ejemplo ` painting/transformations/window.cpp `. Las formas se almacenan en una lista ` QList`. La función ` QList::append()` inserta la forma indicada al final de la lista.
También conectamos la señal activated() de los QComboBox asociados a la ranura shapeSelected() para actualizar la aplicación cuando el usuario cambia la forma preferida.
void Window::operationChanged()
{
static const Operation operationTable[] = {
NoTransformation, Rotate, Scale, Translate
};
QList<Operation> operations;
for (int i = 0; i < NumTransformedAreas; ++i) {
int index = operationComboBoxes[i]->currentIndex();
operations.append(operationTable[index]);
transformedRenderAreas[i]->setOperations(operations);
}
}La ranura pública operationChanged() se activa cada vez que el usuario cambia las operaciones seleccionadas.
Recuperamos la operación de transformación elegida para cada uno de los widgets « RenderArea » transformados consultando el « QComboBoxes » asociado. Se supone que los widgets « RenderArea » transformados deben representar la forma con la transformación especificada por su cuadro combinado asociado , además de todas las transformaciones aplicadas a los widgets « RenderArea » situados a su izquierda. Por ese motivo, para cada widget que consultamos, añadimos la operación asociada a un QList de transformaciones que aplicamos al widget antes de pasar al siguiente.
void Window::shapeSelected(int index)
{
QPainterPath shape = shapes[index];
originalRenderArea->setShape(shape);
for (int i = 0; i < NumTransformedAreas; ++i)
transformedRenderAreas[i]->setShape(shape);
}La ranura « shapeSelected() » se invoca cada vez que el usuario cambia la forma preferida, actualizando los widgets « RenderArea » mediante su función pública « setShape() ».
Resumen
El ejemplo «Transformaciones» muestra cómo las transformaciones influyen en la forma en que QPainter representa las primitivas gráficas. Normalmente, QPainter opera en el propio sistema de coordenadas del dispositivo, pero también ofrece un buen soporte para las transformaciones de coordenadas. Con la aplicación «Transformaciones» puedes escalar, rotar y trasladar el sistema de coordenadas de QPainter. El orden en el que se aplican estas transformaciones es esencial para el resultado.
Todas las operaciones de transformación se realizan sobre la matriz de transformación de QPainter. Para obtener más información sobre la matriz de transformación, consulta la documentación sobre el sistema de coordenadas y el « QTransform ».
La documentación de referencia de Qt ofrece varios ejemplos de dibujo. Entre ellos se encuentra el ejemplo «Transformaciones afines», que muestra la capacidad de Qt para realizar transformaciones en operaciones de dibujo. El ejemplo también permite al usuario experimentar con las distintas operaciones de transformación.
© 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.