Alfabetización Qt-Resumen del sistema de pintura Qt

I. Resumen

El sistema de pintura de Qt puede usar la misma API para dibujar en la pantalla y en el dispositivo de impresión y se basa principalmente en las clases QPainter, QPaintDevice y QPaintEnengine.

QPainter se utiliza para realizar operaciones de dibujo. QPaintDevice es una abstracción de un espacio bidimensional en el que se puede utilizar QPainter para dibujar. QPaintEngine proporciona una interfaz para que QPainter dibuje en diferentes tipos de dispositivos. La clase QPaintEngine es utilizada internamente por QPainter y QPaintDevice y está oculta para nosotros como programadores de aplicaciones, a menos que creemos nuestros propios tipos de dispositivos de dibujo.

El principal beneficio de este enfoque es que todos los dibujos siguen el mismo canal de dibujo, lo que facilita agregar soporte para nuevas funciones y proporcionar implementaciones predeterminadas para funciones no compatibles. En otras palabras, es muy escalable.

2. Dispositivo de dibujo y backend

La clase QPaintDevice es la clase base de objetos dibujables, es decir, QPainter puede dibujar en cualquier subclase de QPaintDevice. La función de dibujo de QPaintDevice se realiza mediante QWidget, QImage, QPixmap, QPicture, QPrinter y QOpenGLPaintDevice.

Todas las clases mencionadas a continuación heredan QPaintDevice, por lo que tienen la función de dibujar

1. Widget

La clase QWidget es la clase base para los elementos de la interfaz de usuario en el módulo Qt Widgets. Recibe el mouse, el teclado y otros eventos del sistema de ventanas y se muestra en la pantalla. Es una parte importante del sistema de ventanas.

2. Imagen

La clase QImage proporciona una representación de imagen independiente del hardware, diseñada y optimizada para E/S y acceso y manipulación directos de píxeles. QImage es compatible con una variedad de formatos de imagen, incluidas imágenes monocromáticas, de 8 bits, de 32 bits y alfa combinadas.

Hay dos ventajas de usar QImage como un dispositivo de dibujo:

1. La precisión de píxeles de cualquier operación de dibujo se puede garantizar de forma independiente de la plataforma.
2. El dibujo se puede realizar en otro subproceso que el subproceso GUI actual.

3. Mapa de píxeles

La clase QPixmap es una representación de imágenes fuera de pantalla diseñada y optimizada para mostrar imágenes en la pantalla. A diferencia de QImage, los datos de píxeles en pixmap son internos y los administra el sistema de ventanas subyacente, es decir, solo se puede acceder a los píxeles a través de las funciones de QPainter o al convertir QPixmap a QImage.

Para optimizar el dibujo con QPixmap, Qt proporciona la clase QPixmapCache, que se puede usar para almacenar mapas de píxeles temporales que son costosos de generar sin usar espacio de almacenamiento que exceda el límite de caché.

Qt también proporciona la clase de conveniencia QBitmap, que hereda de QPixmap. QBitmap garantiza un mapa de píxeles monocromático (profundidad de 1 bit), que se utiliza principalmente para crear objetos QCursor y QBrush personalizados y construir objetos QRegion.

4. Dispositivo de dibujo OpenGL

Como se mencionó anteriormente, Qt proporciona clases que facilitan el uso de OpenGL en aplicaciones Qt. Por ejemplo, QOpenGLPaintDevice habilita la API de OpenGL para la representación de QPainter.

5. Imagen

La clase QPicture es un dispositivo de dibujo que graba y reproduce comandos de QPainter. Image serializa los comandos del pintor a los dispositivos IO en un formato independiente de la plataforma. QPicture también es independiente de la resolución, es decir, un QPicture se puede mostrar en diferentes dispositivos (como svg, pdf, ps, impresora y pantalla) y tener el mismo aspecto.

Qt proporciona funciones QPicture::load() y QPicture::save() y operadores de flujo para cargar y guardar imágenes.

6. Backend de dibujo personalizado

Se puede obtener soporte para nuevos backends derivando de la clase QPaintDevice y reimplementando la función ficticia QPaintDevice::paintEngine() para decirle a QPainter qué motor de pintura debe usar para dibujar en este dispositivo en particular.

Para poder dibujar en el dispositivo, este motor de dibujo debe ser un motor de dibujo personalizado creado derivando la clase QPaintDevice.

3. Dibujo y relleno

1. Dibujo

QPainter proporciona funciones altamente optimizadas para hacer el dibujo requerido por la mayoría de los programas GUI. Puede dibujar cualquier cosa, desde primitivos de gráficos simples (representados por las clases QPoint, QLine, QRect, QRegion y QPolygon) hasta formas complejas como rutas vectoriales. En Qt, las rutas vectoriales están representadas por la clase QPainterPath. QPainterPath proporciona un contenedor para operaciones de dibujo, lo que permite construir y reutilizar formas gráficas.

1. QPainterPath
QPainterPath es un objeto compuesto de líneas y curvas. Por ejemplo, los rectángulos están hechos de líneas rectas y las elipses están hechas de líneas curvas.

La principal ventaja de las rutas de pintor sobre las operaciones normales de dibujo es que las formas complejas solo necesitan crearse una vez; luego se pueden dibujar varias veces simplemente llamando a la función QPainter::drawPath().

Los objetos QPainterPath se pueden usar para rellenar, delinear y recortar. Para generar un contorno rellenable para una ruta de pintor dada, use la clase QPainterPathStroker.

Las líneas y los contornos se dibujan utilizando la clase QPen. Un bolígrafo se define por su estilo (es decir, su tipo de línea), ancho, pincel, cómo se dibujan las mayúsculas (estilo de mayúscula) y cómo se conectan dos líneas conectadas (estilo de unión). El pincel de la pluma es un objeto QBrush, que se utiliza para rellenar los trazos generados por la pluma, es decir, la clase QBrush define el modo de relleno.

QPainter también puede dibujar texto alineado y mapas de píxeles.

Al dibujar texto, la fuente se especifica utilizando la clase QFont. Qt usará la fuente con las propiedades especificadas, si no existe una fuente coincidente, Qt usará la fuente instalada más cercana. Las propiedades de fuente reales utilizadas se pueden obtener mediante la clase QFontInfo. Además, la clase QFontMetrics proporciona métricas de fuentes y la clase QFontDatabase proporciona información sobre las fuentes disponibles en el sistema de ventanas subyacente.

Normalmente, QPainter dibuja en un sistema de coordenadas "natural", pero puede usar la clase QTransform para realizar transformaciones entre la vista y los sistemas de coordenadas mundiales. Para obtener más información, consulte Sistemas de coordenadas, que también describe el proceso de renderizado, la relación entre las representaciones lógicas y los píxeles renderizados, y las ventajas del dibujo suavizado.

2. Dibujo suavizado
Al dibujar, la representación de píxeles se controla mediante la sugerencia de representación QPainter::Antialiasing. La enumeración QPainter::RenderHint se utiliza para especificar banderas para QPainter que pueden o no ser utilizadas por cualquier motor dado.

El valor de QPainter::Antialiasing indica que el motor debe eliminar los bordes de la primitiva si es posible, es decir, suavizar los bordes usando diferentes intensidades de color.

2. Relleno

Rellene la forma usando la clase QBrush. Un pincel se define por su color y estilo (es decir, su modo de relleno).

Cualquier color en Qt está representado por la clase QColor, que admite modelos de color RGB, HSV y CMYK. QColor también admite contornos y rellenos combinados alfa (para especificar efectos de transparencia), y la clase es independiente de la plataforma y el dispositivo (use la clase QColormap para asignar colores al hardware).

Los patrones de relleno disponibles se describen mediante la enumeración Qt::BrushStyle. Estos incluyen patrones básicos que van desde colores uniformes hasta patrones muy dispersos, varias combinaciones de líneas, rellenos degradados y texturas. Qt proporciona la clase QGradient para definir un relleno degradado personalizado y usa la clase QPixmap para especificar el modo de textura.

1. QGradient
La clase QGradient se usa junto con la clase QBrush para especificar el relleno de degradado.

Actualmente, Qt admite tres tipos de rellenos degradados: los degradados lineales interpolan el color entre los puntos inicial y final, los degradados radiales interpolan el color entre el punto focal y el punto final en la circunferencia y los degradados cónicos interpolan el color alrededor del punto central.

4. Sistema de coordenadas

El sistema de coordenadas está controlado por la clase QPainter. Junto con las clases QPaintDevice y QPaintEngine, QPainter forma la base del sistema de pintura de Qt. QPainter se utiliza para realizar operaciones de dibujo. QPaintDevice es una abstracción de un espacio bidimensional en el que se puede utilizar QPainter para dibujar. QPaintEngine proporciona una interfaz para que QPainter dibuje en diferentes tipos de dispositivos.

La clase QPaintDevice es la clase base para objetos dibujables: su funcionalidad de dibujo es heredada por las clases QWidget, QImage, QPixmap, QPicture y QOpenGLPaintDevice. El sistema de coordenadas predeterminado para los dispositivos de dibujo se origina en la esquina superior izquierda. los valores de x aumentan hacia la derecha y los valores de y aumentan hacia abajo. La unidad predeterminada es un píxel en dispositivos basados ​​en píxeles y un punto (1/72 de pulgada) en impresoras.

El mapeo de las coordenadas lógicas de QPainter a las coordenadas físicas de QPaintDevice es manejado por la matriz de transformación, la ventana gráfica y la "ventana" de QPainter. El sistema de coordenadas lógicas y el sistema de coordenadas físicas coinciden por defecto. QPainter también admite transformaciones de coordenadas (como rotación y escalado).

1. Representación

1. Representación lógica
El tamaño (ancho y alto) de una primitiva gráfica siempre corresponde a su modelo matemático, independientemente del ancho de la pluma utilizada para la representación:

2. Pintura sin suavizado
Al dibujar, la representación de píxeles se controla mediante el parámetro de representación QPainter::Antialiasing.

La enumeración RenderHint se utiliza para especificar banderas para QPainter que pueden o no ser utilizadas por un motor determinado. El valor de QPainter::Antialiasing indica que el motor debe eliminar los bordes de la primitiva si es posible, es decir, suavizar los bordes usando diferentes intensidades de color.

Pero, de forma predeterminada, el pintor se renderiza con alias y se aplican otras reglas: cuando se renderiza con un lápiz de un píxel de ancho, los píxeles se renderizarán a la derecha y debajo de un punto definido matemáticamente. Por ejemplo:

Al renderizar con un lápiz con píxeles pares, los píxeles se renderizarán simétricamente alrededor de un punto definido matemáticamente, mientras que con un lápiz con píxeles impares, los píxeles libres se renderizarán a la derecha y debajo del punto matemático, como un mismo píxel. situación. Para ver un ejemplo específico, consulte el diagrama QRectF a continuación.

Tenga en cuenta que, por razones históricas, los valores de retorno de las funciones QRect::right() y QRect::bottom() se desvían de la verdadera esquina inferior derecha del rectángulo.

La función right() de QRect devuelve left() + width() - 1, mientras que la función bottom() devuelve top() + height() - 1. Los puntos verdes en la imagen de arriba muestran las coordenadas de retorno de estas funciones.

Le recomendamos que use QRectF directamente: la clase QRectF usa coordenadas de punto flotante para definir un rectángulo en el plano para garantizar la precisión (QRect usa coordenadas enteras), mientras que las funciones QRectF::right() y QRectF::bottom() regresan la verdadera esquina inferior derecha.

Alternativamente, usando un QRect, aplique x() + ancho() e y() + alto() para encontrar la esquina inferior derecha, evitando las funciones derecha() e inferior().

3. Pintura suavizada
Si configura la sugerencia de renderizado suavizado de QPainter, los píxeles se renderizarán simétricamente en ambos lados del punto definido matemáticamente:

4. Transformación

De forma predeterminada, QPainter opera en el propio sistema de coordenadas del dispositivo asociado, pero también es totalmente compatible con las transformaciones de coordenadas afines.

Podemos escalar el sistema de coordenadas por un desplazamiento dado usando la función QPainter::scale(), podemos rotarlo en el sentido de las agujas del reloj usando la función QPainter::rotate(), y podemos traducirlo usando la función QPainter::translate() ( es decir, añade el desplazamiento dado al punto).

También puede rotar el sistema de coordenadas alrededor del origen usando la función QPainter::shear(). Todas las operaciones de transformación se realizan en la matriz de transformación de QPainter, que puede obtener utilizando la función QPainter::worldTransform(). Una matriz transforma un punto de un plano en otro.

Si necesita usar la misma transformación repetidamente, también puede usar el objeto QTransform y las funciones QPainter::worldTransform() y QPainter::setWorldTransform(). Puede guardar la matriz de transformación de QPainter en cualquier momento llamando a la función QPainter::save(), que guarda la matriz en la pila interna. La función QPainter::restore() lo abre.

Las matrices de transformación a menudo se requieren cuando se reutiliza el mismo código de dibujo en varios dispositivos de dibujo. Sin transformaciones, el resultado estará estrechamente ligado a la resolución del dispositivo de dibujo. Las impresoras tienen resoluciones altas, como 600 puntos por pulgada, mientras que las pantallas suelen tener entre 72 y 100 puntos por pulgada.

El ejemplo de Reloj analógico muestra cómo usar la matriz de transformación de QPainter para pintar el contenido de un control personalizado.
Recomendamos compilar y ejecutar este ejemplo antes de seguir leyendo. En particular, intente cambiar el tamaño de la ventana a un tamaño diferente.

  void AnalogClockWindow::render(QPainter *p)
  {
    
    
      static const QPoint hourHand[3] = {
    
    
          QPoint(7, 8),
          QPoint(-7, 8),
          QPoint(0, -40)
      };
      static const QPoint minuteHand[3] = {
    
    
          QPoint(7, 8),
          QPoint(-7, 8),
          QPoint(0, -70)
      };

      QColor hourColor(127, 0, 127);
      QColor minuteColor(0, 127, 127, 191);

      p->setRenderHint(QPainter::Antialiasing);
      p->translate(width() / 2, height() / 2);

      int side = qMin(width(), height());
      p->scale(side / 200.0, side / 200.0);

Transformamos el sistema de coordenadas para que el punto (0,0) esté en el centro del control, en lugar de en la esquina superior izquierda. También escalamos el sistema por lado/100, donde lado es el ancho o alto del control, el que sea más corto. Queremos que el reloj sea cuadrado, aunque el dispositivo no lo sea.

Esto nos dará un área cuadrada de 200 x 200 con el origen (0,0) en el centro, en la que podemos dibujar. Lo que dibujemos aparecerá en el cuadrado más grande posible que quepa en el control.

Consulte también la sección de conversión de ventana a ventana gráfica.

      QTime time = QTime::currentTime();

      p->save();
      p->rotate(30.0 * ((time.hour() + time.minute() / 60.0)));
      p->drawConvexPolygon(hourHand, 3);
      p->restore();

Dibujamos la manecilla de la hora del reloj girando el sistema de coordenadas y llamando a QPainter::drawConvexPolygon(). Debido a la rotación, se dibuja en la orientación correcta.
El polígono se especifica como una matriz de valores x, y alternos, almacenados en la variable estática hourHand (definida al principio de la función), que corresponde a los cuatro puntos (2,0), (0,2), (- 2,0 ) y (0, -25).

Las llamadas a QPainter::save() y QPainter::restore() alrededor del código aseguran que el código subyacente no interfiera con las transformaciones que usamos.

      p->save();
      p->rotate(6.0 * (time.minute() + time.second() / 60.0));
      p->drawConvexPolygon(minuteHand, 3);
      p->restore();

Hacemos lo mismo para el minutero del reloj, que está definido por los cuatro puntos (1,0), (0,1), (-1,0) y (0,-40). Estas coordenadas especifican un puntero que es más delgado y más largo que una aguja.

      p->setPen(minuteColor);

      for (int j = 0; j < 60; ++j) {
    
    
          if ((j % 5) != 0)
              p->drawLine(92, 0, 96, 0);
          p->rotate(6.0);
      }

Finalmente, dibujamos la esfera del reloj, que consta de 12 líneas cortas separadas 30 grados.

Conversión ventana-ventana

Al dibujar con QPainter, especificamos puntos usando coordenadas lógicas, que luego se convierten en las coordenadas físicas del dispositivo de dibujo.

El mapeo de coordenadas lógicas a coordenadas físicas es manejado por la transformación mundial de QPainter worldTransform() (descrita en la sección Transformación) y viewport() y window() de QPainter. La ventana gráfica representa coordenadas físicas que especifican un rectángulo arbitrario. Una "ventana" describe el mismo rectángulo en coordenadas lógicas. Por defecto, los sistemas de coordenadas lógicas y físicas son coincidentes, equivalentes al rectángulo de dibujo del dispositivo.

Usando la transformación ventana-ventana, podemos hacer que el sistema de coordenadas lógicas coincida con nuestras preferencias. También se puede usar para hacer que el código de dibujo sea independiente del QPaintDevice. Por ejemplo, puede extender las coordenadas lógicas de (-50,-50) a (50,50), con (0,0) en el medio, llamando a la función QPainter::setwinwindow():

  QPainter painter(this);
  painter.setWindow(QRect(-50, -50, 100, 100));

Ahora las coordenadas lógicas (-50,-50) corresponden a las coordenadas físicas (0,0) del dispositivo de dibujo. Independientemente del dispositivo de dibujo, nuestro código de dibujo siempre operará en coordenadas lógicas específicas. Es equivalente a que podamos configurar manualmente esta relación de coordenadas. Una relación conveniente para definir tales coordenadas usted mismo.

Al configurar la "ventana" o el rectángulo de la ventana gráfica, se puede realizar una transformación lineal de coordenadas. Tenga en cuenta que cada esquina de la "ventana" se asigna a una esquina correspondiente de la ventana gráfica y viceversa. Por esta razón, suele ser una buena idea mantener la ventana gráfica y la "ventana" en la misma relación de aspecto para evitar distorsiones:

  int side = qMin(width(), height())
  int x = (width() - side / 2);
  int y = (height() - side / 2);

  painter.setViewport(x, y, side, side);

Si configuramos el sistema de coordenadas lógicas para que sea cuadrado, también debemos configurar la ventana gráfica para que sea cuadrada usando la función QPainter::setViewport(). En el ejemplo anterior, lo configuramos en el cuadrado más grande que cabe en el rectángulo de dibujo del dispositivo. Puede mantener su código de dibujo independiente del dispositivo de dibujo teniendo en cuenta el tamaño del dispositivo de dibujo al configurar la ventana o la ventana gráfica.

Tenga en cuenta que la transformación de ventana a ventana gráfica es solo una transformación lineal, es decir, no realiza recorte. Esto significa que si dibuja fuera de la "ventana" configurada actualmente, su dibujo aún se convertirá a la ventana gráfica utilizando el mismo método de álgebra lineal.

Las matrices de visualización, "ventana" y transformación determinan cómo las coordenadas lógicas de QPainter se asignan a las coordenadas físicas del dispositivo de dibujo. De forma predeterminada, la matriz de transformación del mundo es la matriz de identidad, y la configuración de la "ventana" y la ventana gráfica son equivalentes a las del dispositivo de dibujo, es decir, los sistemas de coordenadas del mundo, la "ventana" y el dispositivo son equivalentes, pero como hemos visto , el sistema puede manipular mediante operaciones de transformación y transformaciones de ventana-ventana.

5. Leer y escribir archivos de imagen

La forma más común de leer una imagen es a través de los constructores QImage y QPixmap, o llamando a las funciones QImage::load() y QPixmap::load(). Además, Qt proporciona la clase QImageReader, que brinda más control sobre el proceso. Según el soporte subyacente del formato de imagen, la clase proporciona funciones que ahorran memoria y aceleran la carga de imágenes.

Asimismo, Qt proporciona la clase QImageWriter, que admite la configuración de opciones específicas del formato, como gamma, nivel de compresión y calidad antes de almacenar la imagen. Si no necesitamos estas opciones, podemos usar QImage::save() o QPixmap::save() en su lugar.

1. QPelícula

QMovie es una clase de conveniencia para mostrar animaciones, utilizando internamente la clase QImageReader. Una vez creada, la clase QMovie proporciona varias funciones para ejecutar y controlar una animación determinada.

Las clases QImageReader y QImageWriter dependen de la clase QImageIOHandler. La clase QImageIOHandler es una interfaz de E/S de imagen general para todos los formatos de imagen en Qt. QImageReader y QImageWriter usan internamente el objeto QImageIOHandler para agregar soporte para diferentes formatos de imagen para Qt.
Las funciones QImageReader::supportedImageFormats() y QImageWriter::supportedImageFormats() proporcionan una lista de formatos de archivo admitidos. Qt admite varios formatos de archivo de forma predeterminada, además, se pueden agregar nuevos formatos a través de complementos. Los formatos admitidos actualmente se enumeran en la documentación de la clase QImageReader y QImageWriter.
El mecanismo de complemento de Qt también se puede usar para escribir controladores de formato de imagen personalizados. Esto se hace derivando de la clase QImageIOHandler y creando un objeto QImageIOPlugin, que es una fábrica para crear objetos QImageIOHandler. Cuando se instala el complemento, QImageReader y QImageWriter cargarán automáticamente el complemento y comenzarán a usarlo.

6. Equipo relacionado con el dibujo

Pintura relacionada	Función
QBitmap	Mapa de píxeles monocromático (profundidad de 1 bit)
QBrush	Define el modo de relleno para formas dibujadas por QPainter
QColor	Colores basados ​​en valores RGB, HSV o CMYK
QColorSpace	abstracción del espacio de color
QColorTransform	Conversión entre espacios de color
QMapa de colores	Asigna QColors independientes del dispositivo a valores de píxeles dependientes del dispositivo
QConicalGradient	Se usa en combinación con QBrush para especificar un pincel de degradado cónico
QFuente	Especifica consultas de fuentes para dibujar texto
QFontMetrics	información de métricas de fuente
QFontMetricsF	información de métricas de fuente
QGenericMatrix	Una clase de plantilla que representa una matriz de transformación NxM con N columnas y M filas
Gradiente Q	Se usa en combinación con QBrush para especificar rellenos degradados
QIcono	Iconos escalables en diferentes modos y estados
QIconEngine	Clase base abstracta para renderizadores QIcon
QImagen	Una representación de imagen independiente del hardware que permite el acceso directo a los datos de píxeles y se puede utilizar como dispositivo de dibujo
QImageReader	Formato de interfaz independiente para leer imágenes de archivos u otros dispositivos
QImageWriter	Formato de interfaz independiente para escribir imágenes en archivos u otros dispositivos
Línea Q	Vector 2-D usando precisión entera
QLineF	Los vectores 2D usan precisión de punto flotante
QLinearGradient	Se usa en combinación con QBrush para especificar un pincel de degradado lineal
QMárgenes	Definir los cuatro márgenes del rectángulo.
QMárgenesF	Definir los cuatro márgenes del rectángulo.
QPagedPaintDevice	Indica un dispositivo de dibujo que admite varias páginas.
QPaintDevice	Clase base para objetos que se pueden dibujar con QPainter
QPaintEngine	Una definición abstracta de cómo QPainter dibuja en un dispositivo determinado en una plataforma determinada
QPintor	Realice dibujos de bajo nivel en widgets y otros dispositivos de dibujo
QPainterPath	Un contenedor para operaciones de dibujo, que permite construir y reutilizar gráficos
QPainterPathStroker	Se utiliza para generar un contorno rellenable para una ruta de dibujo determinada
QPdfWriter	clase para generar archivos PDF que se pueden usar como dispositivos de trazado
QPen	Define cómo un QPainter debe dibujar los contornos de líneas y formas
QPixmap	Una representación de imagen fuera de la pantalla que se puede utilizar como dispositivo de dibujo.
QPunto	definir un punto en el plano usando precisión entera
QPuntoF	definir un punto en el plano usando precisión de coma flotante
QPolígono	Vector de punto usando precisión entera
QPolígonoF	Vector de punto usando precisión de punto flotante
QRadialGradient	Especificación de un pincel de degradado radial mediante combinación con QBrush
QRecto	definir un rectángulo en el plano usando precisión entera
QRectF	define un rectángulo en el plano usando precisión de coma flotante
Región QR	Especifica la región de recorte para el paintr
QRgba64	Estructura que contiene colores RGB de 64 bits
QTamaño	Defina el tamaño de un objeto 2D usando precisión de punto entero
QTamañoF	Definir el tamaño de un objeto 2D usando precisión de punto flotante
QStylePainter	Clase de conveniencia para dibujar elementos QStyle en widgets
QSistemas de escritura compatibles	Al registrar fuentes con el uso interno de la base de datos de fuentes Qt
QSvgGenerator	Un dispositivo de dibujo para crear dibujos SVG
QSvgRenderer	Se utiliza para dibujar el contenido de un archivo SVG en un dispositivo de dibujo
QSvg Widget	Un control para mostrar el contenido de un archivo de gráficos vectoriales escalables (SVG)
QTransformar	Transformación 2D del sistema de coordenadas especificado
QVector2D	representar vectores o vértices en un espacio bidimensional