En esta página

QPainterPath Class

La clase QPainterPath proporciona un contenedor para operaciones de dibujo, lo que permite crear y reutilizar figuras gráficas. Más...

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

Nota: Todas las funciones de esta clase son reentrantes.

Tipos públicos

class Element
enum ElementType { MoveToElement, LineToElement, CurveToElement, CurveToDataElement }

Funciones públicas

QPainterPath()
QPainterPath(const QPointF &startPoint)
QPainterPath(const QPainterPath &path)
(since 6.10) QPainterPath(QPainterPath &&other)
~QPainterPath()
void addEllipse(const QRectF &boundingRectangle)
void addEllipse(const QPointF &center, qreal rx, qreal ry)
void addEllipse(qreal x, qreal y, qreal width, qreal height)
void addPath(const QPainterPath &path)
void addPolygon(const QPolygonF &polygon)
void addRect(const QRectF &rectangle)
void addRect(qreal x, qreal y, qreal width, qreal height)
void addRegion(const QRegion &region)
void addRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)
void addRoundedRect(qreal x, qreal y, qreal w, qreal h, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)
void addText(const QPointF &point, const QFont &font, const QString &text)
void addText(qreal x, qreal y, const QFont &font, const QString &text)
qreal angleAtPercent(qreal t) const
void arcMoveTo(const QRectF &rectangle, qreal angle)
void arcMoveTo(qreal x, qreal y, qreal width, qreal height, qreal angle)
void arcTo(const QRectF &rectangle, qreal startAngle, qreal sweepLength)
void arcTo(qreal x, qreal y, qreal width, qreal height, qreal startAngle, qreal sweepLength)
QRectF boundingRect() const
int capacity() const
void clear()
void closeSubpath()
void connectPath(const QPainterPath &path)
bool contains(const QPainterPath &p) const
bool contains(const QPointF &point) const
bool contains(const QRectF &rectangle) const
QRectF controlPointRect() const
void cubicTo(const QPointF &c1, const QPointF &c2, const QPointF &endPoint)
void cubicTo(qreal c1X, qreal c1Y, qreal c2X, qreal c2Y, qreal endPointX, qreal endPointY)
QPointF currentPosition() const
QPainterPath::Element elementAt(int index) const
int elementCount() const
Qt::FillRule fillRule() const
QPainterPath intersected(const QPainterPath &p) const
bool intersects(const QPainterPath &p) const
bool intersects(const QRectF &rectangle) const
(since 6.10) bool isCachingEnabled() const
bool isEmpty() const
qreal length() const
void lineTo(const QPointF &endPoint)
void lineTo(qreal x, qreal y)
void moveTo(const QPointF &point)
void moveTo(qreal x, qreal y)
qreal percentAtLength(qreal len) const
QPointF pointAtPercent(qreal t) const
void quadTo(const QPointF &c, const QPointF &endPoint)
void quadTo(qreal cx, qreal cy, qreal endPointX, qreal endPointY)
void reserve(int size)
(since 6.10) void setCachingEnabled(bool enabled)
void setElementPositionAt(int index, qreal x, qreal y)
void setFillRule(Qt::FillRule fillRule)
QPainterPath simplified() const
qreal slopeAtPercent(qreal t) const
QPainterPath subtracted(const QPainterPath &p) const
void swap(QPainterPath &other)
QPolygonF toFillPolygon(const QTransform &matrix = QTransform()) const
QList<QPolygonF> toFillPolygons(const QTransform &matrix = QTransform()) const
QPainterPath toReversed() const
QList<QPolygonF> toSubpathPolygons(const QTransform &matrix = QTransform()) const
void translate(qreal dx, qreal dy)
void translate(const QPointF &offset)
QPainterPath translated(qreal dx, qreal dy) const
QPainterPath translated(const QPointF &offset) const
(since 6.10) QPainterPath trimmed(qreal fromFraction, qreal toFraction, qreal offset = 0) const
QPainterPath united(const QPainterPath &p) const
bool operator!=(const QPainterPath &path) const
QPainterPath operator&(const QPainterPath &other) const
QPainterPath &operator&=(const QPainterPath &other)
QPainterPath operator+(const QPainterPath &other) const
QPainterPath &operator+=(const QPainterPath &other)
QPainterPath operator-(const QPainterPath &other) const
QPainterPath &operator-=(const QPainterPath &other)
QPainterPath &operator=(QPainterPath &&other)
QPainterPath &operator=(const QPainterPath &path)
bool operator==(const QPainterPath &path) const
QPainterPath operator|(const QPainterPath &other) const
QPainterPath &operator|=(const QPainterPath &other)
QDataStream &operator<<(QDataStream &stream, const QPainterPath &path)
QDataStream &operator>>(QDataStream &stream, QPainterPath &path)

Descripción detallada

Una ruta de pintura es un objeto compuesto por una serie de elementos gráficos básicos, como rectángulos, elipses, líneas y curvas. Estos elementos básicos pueden unirse para formar subrutas cerradas, por ejemplo, un rectángulo o una elipse. Una ruta cerrada tiene puntos de inicio y fin coincidentes. También pueden existir de forma independiente como subrutas no cerradas, como líneas y curvas.

Un objeto `QPainterPath` se puede utilizar para rellenar, trazar contornos y recortar. Para generar contornos rellenables a partir de una ruta de dibujo dada, utilice la clase ` QPainterPathStroker `. La principal ventaja de las rutas de dibujo frente a las operaciones de dibujo normales es que las formas complejas solo tienen que crearse una vez; después, pueden dibujarse muchas veces utilizando únicamente llamadas a la función ` QPainter::drawPath()`.

QPainterPath proporciona un conjunto de funciones que pueden utilizarse para obtener información sobre la ruta y sus elementos. Además, es posible invertir el orden de los elementos mediante la función toReversed(). También hay varias funciones para convertir este objeto de ruta de pintura en una representación poligonal.

Creación de un QPainterPath

Un objeto `QPainterPath` puede crearse como una ruta vacía, con un punto de inicio determinado, o como una copia de otro objeto `QPainterPath`. Una vez creado, se pueden añadir líneas y curvas a la ruta mediante las funciones ` lineTo()`, ` arcTo()`, ` cubicTo()` y ` quadTo()`. Las líneas y curvas se extienden desde ` currentPosition()` hasta la posición pasada como argumento.

El ` currentPosition()` del objeto `QPainterPath` es siempre la posición final de la última subtrayectoria que se ha añadido (o el punto de inicio inicial). Utilice la función ` moveTo()` para desplazar el ` currentPosition()` sin añadir ningún componente. La función ` moveTo()` inicia implícitamente una nueva subtrayectoria y cierra la anterior. Otra forma de iniciar una nueva subtrayectoria es llamar a la función closeSubpath(), que cierra la trayectoria actual añadiendo una línea desde currentPosition() de vuelta a la posición inicial de la trayectoria. Ten en cuenta que la nueva trayectoria tendrá (0, 0) como su currentPosition().

La clase `QPainterPath` también proporciona varias funciones de conveniencia para añadir subtrayectorias cerradas a una trayectoria de pintura: ` addEllipse()`, ` addPath()`, ` addRect()`, ` addRegion()` y ` addText()`. La función ` addPolygon()` añade una subtrayectoria no cerrada. De hecho, todas estas funciones son conjuntos de operaciones ` moveTo()`, ` lineTo()` y ` cubicTo()`.

Además, se puede añadir una ruta a la ruta actual mediante la función connectPath(). Pero ten en cuenta que esta función conectará el último elemento de la ruta actual con el primer elemento de la ruta dada añadiendo una línea.

A continuación se muestra un fragmento de código que ilustra cómo se puede utilizar un objeto `QPainterPath`:

Trayectoria con rectángulo y curvas de Bézier
QPainterPath path;
path.addRect(20, 20, 60, 60);

path.moveTo(0, 0);
path.cubicTo(99, 0,  50, 50,  99, 99);
path.cubicTo(0, 99,  50, 50,  0, 0);

QPainter painter(this);
painter.fillRect(0, 0, 100, 100, Qt::white);
painter.setPen(QPen(QColor(79, 106, 25), 1, Qt::SolidLine,
                    Qt::FlatCap, Qt::MiterJoin));
painter.setBrush(QColor(122, 163, 39));

painter.drawPath(path);

La ruta del pintor está inicialmente vacía al crearse. Primero añadimos un rectángulo, que es una subruta cerrada. A continuación, añadimos dos curvas de Bézier que, juntas, forman una subruta cerrada, aunque no lo sean individualmente. Por último, dibujamos la ruta completa. La ruta se rellena utilizando la regla de relleno predeterminada, ` Qt::OddEvenFill`. Qt proporciona dos métodos para rellenar rutas:

Consulte la documentación de Qt::FillRule para conocer la definición de las reglas. La regla de relleno actualmente establecida para una ruta de dibujo se puede recuperar mediante la función fillRule() y modificarse mediante la función setFillRule().

Arcos y elipses

Los argumentos de ángulo de arcTo(), arcMoveTo(), QPainter::drawArc(), QPainter::drawPie() y QPainter::drawChord() son ángulos excéntricos. Un ángulo excéntrico parametriza la elipse que cabe en el rectángulo delimitador; no mide la dirección desde el centro de dicho rectángulo hasta el punto resultante. En general, ambos coinciden solo cuando el rectángulo delimitador es un cuadrado. En un rectángulo de 400 por 100, por ejemplo, un ángulo de 45 grados da como resultado un punto que se encuentra aproximadamente 14 grados por encima de la horizontal, visto desde el centro.

Para situar un punto en una dirección determinada desde el centro, calcula tú mismo ese punto y pásalo a moveTo() o lineTo(). Como alternativa, sigue utilizando estas funciones y convierte la dirección: en un rectángulo delimitador de las coordenadas dadas width y height, la dirección theta, en radianes, se corresponde con el ángulo excéntrico qRadiansToDegrees(qAtan2(width * qSin(theta), height * qCos(theta))).

Dado que una ruta de pintor solo almacena líneas y segmentos de Bézier, Qt aproxima los arcos y las elipses con curvas de Bézier cúbicas en lugar de evaluarlos trigonométricamente. En el caso de un círculo, la aproximación sitúa los puntos a una distancia inferior al 0,1 % del radio respecto a sus posiciones reales. Por lo tanto, el código que compara un punto obtenido con ` arcMoveTo()` con otro calculado con ` qSin()` y ` qCos()` debe tener en cuenta una tolerancia en lugar de comprobar si son iguales.

Información sobre QPainterPath

La clase QPainterPath proporciona un conjunto de funciones que devuelven información sobre la ruta y sus elementos.

La función currentPosition() devuelve el punto final de la última subtrayectoria añadida (o el punto inicial). La función elementAt() se puede utilizar para recuperar los distintos elementos de la subtrayectoria; el número de elementos se puede obtener mediante la función elementCount(), y la función isEmpty() indica si este objeto QPainterPath contiene algún elemento.

La función controlPointRect() devuelve el rectángulo que contiene todos los puntos y puntos de control de esta ruta. Esta función es considerablemente más rápida de calcular que la función exacta boundingRect(), que devuelve el rectángulo delimitador de esta ruta de dibujo con precisión de punto flotante.

Por último, QPainterPath proporciona la función ` contains()` —que puede utilizarse para determinar si un punto o un rectángulo dado se encuentra dentro de la ruta— y la función ` intersects()` —que determina si alguno de los puntos situados dentro de un rectángulo dado también se encuentra dentro de esta ruta—.

Conversión de QPainterPath

Por motivos de compatibilidad, puede ser necesario simplificar la representación de una ruta de dibujo: QPainterPath proporciona las funciones toFillPolygon(), toFillPolygons() y toSubpathPolygons(), que convierten la ruta de dibujo en un polígono. La función toFillPolygon() devuelve la ruta de dibujo como un único polígono, mientras que las dos funciones restantes devuelven una lista de polígonos.

Las funciones toFillPolygons() y toSubpathPolygons() se proporcionan porque suele ser más rápido dibujar varios polígonos pequeños que dibujar un polígono grande, aunque el número total de puntos dibujados sea el mismo. La diferencia entre ambas radica en el número de polígonos que devuelven: la función ` toSubpathPolygons()` crea un polígono para cada subtrayecto, independientemente de que estos se crucen (es decir, de que sus rectángulos delimitadores se superpongan), mientras que la función ` toFillPolygons()` crea solo un polígono para los subtrayectos que se superponen.

Las funciones toFillPolygon() y toFillPolygons() convierten primero todos los subtrazados en polígonos y, a continuación, utilizan una técnica de rebobinado para garantizar que los subtrazados superpuestos se puedan rellenar siguiendo la regla de relleno correcta. Ten en cuenta que el rebobinado inserta líneas adicionales en el polígono, por lo que el contorno del polígono de relleno no coincide con el contorno del trazado.

Ejemplos

Qt proporciona el ejemplo «Painter Paths» y el ejemplo «Vector Deformation», que se encuentran en el directorio de ejemplos de Qt.

El ejemplo «Painter Paths» muestra cómo se pueden utilizar las rutas de pintura para crear formas complejas para su representación y permite al usuario experimentar con el relleno y el trazo. El ejemplo «Vector Deformation» muestra cómo utilizar QPainterPath para dibujar texto.

Véase también « QPainterPathStroker» , « QPainter », « QRegion » y «Ejemplo de trazos de pintor».

Documentación sobre tipos de miembros

enum QPainterPath::ElementType

Esta enumeración describe los tipos de elementos que se utilizan para conectar vértices en subtrayectos.

Ten en cuenta que los elementos añadidos como subtrayectos cerrados mediante las funciones de conveniencia addEllipse(), addPath(), addPolygon(), addRect(), addRegion() y addText(), se añaden en realidad a la trayectoria como una colección de elementos separados mediante las funciones moveTo(), lineTo() y cubicTo().

ConstanteValorDescripción
QPainterPath::MoveToElement0Una nueva subruta. Véase también ` moveTo()`.
QPainterPath::LineToElement1Una línea. Véase también lineTo().
QPainterPath::CurveToElement2Una curva. Véase también cubicTo() y quadTo().
QPainterPath::CurveToDataElement3Los datos adicionales necesarios para describir una curva en un elemento CurveToElement.

Véase también elementAt() y elementCount().

Documentación de las funciones de miembro

[noexcept] QPainterPath::QPainterPath()

Crea un objeto QPainterPath vacío.

[explicit] QPainterPath::QPainterPath(const QPointF &startPoint)

Crea un objeto `QPainterPath` con el ` startPoint ` indicado como su posición actual.

QPainterPath::QPainterPath(const QPainterPath &path)

Crea un objeto `QPainterPath` que es una copia del ` path` especificado.

Véase también operator=().

[noexcept, since 6.10] QPainterPath::QPainterPath(QPainterPath &&other)

Crea un nuevo objeto «painter path» a partir de other.

El objeto del que se ha realizado el traslado, ` other `, se coloca en el estado de construcción por defecto.

Esta función se introdujo en Qt 6.10.

[noexcept] QPainterPath::~QPainterPath()

Elimina este objeto « QPainterPath ».

void QPainterPath::addEllipse(const QRectF &boundingRectangle)

Crea una elipse dentro del « boundingRectangle » especificado y la añade a la ruta del pintor como una subruta cerrada.

La elipse está compuesta por una curva en sentido horario, que comienza y termina en cero grados (la posición de las 3 en punto). La curva es una aproximación cúbica de Bézier de la elipse, no una representación exacta de la misma, tal y como se describe en Arcs and Ellipses.

Elipse con rectángulo delimitador
QLinearGradient myGradient;
QPen myPen;
QRectF boundingRectangle;

QPainterPath myPath;
myPath.addEllipse(boundingRectangle);

QPainter painter(this);
painter.setBrush(myGradient);
painter.setPen(myPen);
painter.drawPath(myPath);

Véase también arcTo(), QPainter::drawEllipse() y Composing a QPainterPath.

void QPainterPath::addEllipse(const QPointF &center, qreal rx, qreal ry)

Crea una elipse situada en center con radios rx y ry, y la añade a la ruta del pintor como una subruta cerrada.

Esta es una función sobrecargada.

void QPainterPath::addEllipse(qreal x, qreal y, qreal width, qreal height)

Crea una elipse dentro del rectángulo delimitador definido por su esquina superior izquierda en (x, y), width y height, y la añade a la ruta del pintor como una subruta cerrada.

Esta es una función sobrecargada.

void QPainterPath::addPath(const QPainterPath &path)

Añade la ruta path indicada a esta ruta como una subruta cerrada.

Véase también connectPath() y Composing a QPainterPath.

void QPainterPath::addPolygon(const QPolygonF &polygon)

Añade el « polygon » indicado a la ruta como una subruta (sin cerrar).

Ten en cuenta que, una vez añadido el polígono, la posición actual es el último punto de polygon. Para trazar una línea de vuelta al primer punto, utiliza la función closeSubpath().

Polígono con coordenadas de puntos etiquetadas
QLinearGradient myGradient;
QPen myPen;
QPolygonF myPolygon;

QPainterPath myPath;
myPath.addPolygon(myPolygon);

QPainter painter(this);
painter.setBrush(myGradient);
painter.setPen(myPen);
painter.drawPath(myPath);

Véanse también lineTo() y Composing a QPainterPath.

void QPainterPath::addRect(const QRectF &rectangle)

Añade el « rectangle » indicado a esta ruta como una subruta cerrada.

El « rectangle » se añade como un conjunto de líneas en el sentido de las agujas del reloj. La posición actual de la ruta de dibujo tras añadir el « rectangle » se encuentra en la esquina superior izquierda del rectángulo.

Rectángulo con marcador de posición actual
QLinearGradient myGradient;
QPen myPen;
QRectF myRectangle;

QPainterPath myPath;
myPath.addRect(myRectangle);

QPainter painter(this);
painter.setBrush(myGradient);
painter.setPen(myPen);
painter.drawPath(myPath);

Véase también addRegion(), lineTo() y Composing a QPainterPath.

void QPainterPath::addRect(qreal x, qreal y, qreal width, qreal height)

Añade un rectángulo en la posición (x, y), con los valores indicados width y height, como un subtrayecto cerrado.

Se trata de una función sobrecargada.

void QPainterPath::addRegion(const QRegion &region)

Añade la región « region » especificada a la ruta, incorporando cada rectángulo de la región como una subruta cerrada independiente.

Véase también addRect() y Composing a QPainterPath.

void QPainterPath::addRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)

Añade al trazado el rectángulo dado rect con las esquinas redondeadas.

Los argumentos xRadius y yRadius especifican los radios de las elipses que definen las esquinas del rectángulo redondeado. Cuando mode es Qt::RelativeSize, xRadius y yRadius se especifican en porcentaje de la mitad del ancho y la altura del rectángulo, respectivamente, y deben estar comprendidos entre 0,0 y 100,0.

Véase también addRect().

void QPainterPath::addRoundedRect(qreal x, qreal y, qreal w, qreal h, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)

Añade al trazado el rectángulo especificado x, y, w, h con las esquinas redondeadas.

Se trata de una función sobrecargada.

void QPainterPath::addText(const QPointF &point, const QFont &font, const QString &text)

Añade el « text » indicado a esta ruta como un conjunto de subrutas cerradas creadas a partir del « font » proporcionado. Las subrutas se colocan de tal forma que el extremo izquierdo de la línea de base del texto quede situado en el « point » especificado.

Algunas fuentes pueden generar subtrayectorias superpuestas y requerirán la regla de relleno Qt::WindingFill para una representación correcta.

Texto Qt con posición de la línea de base
QLinearGradient myGradient;
QPen myPen;
QFont myFont;
QPointF baseline(x, y);

QPainterPath myPath;
myPath.addText(baseline, myFont, tr("Qt"));

QPainter painter(this);
painter.setBrush(myGradient);
painter.setPen(myPen);
painter.drawPath(myPath);

Véanse también QPainter::drawText(), Composing a QPainterPath y setFillRule().

void QPainterPath::addText(qreal x, qreal y, const QFont &font, const QString &text)

Añade el « text » indicado a esta ruta como un conjunto de subrutas cerradas creadas a partir del « font » proporcionado. Las subrutas se colocan de tal forma que el extremo izquierdo de la línea de base del texto quede en el punto especificado por (x, y).

Esta es una función sobrecargada.

qreal QPainterPath::angleAtPercent(qreal t) const

Devuelve el ángulo de la tangente a la ruta en el porcentaje t. El argumento t debe estar comprendido entre 0 y 1.

Los valores positivos del ángulo indican un sentido antihorario, mientras que los valores negativos indican un sentido horario. Cero grados corresponde a la posición de las 3 en punto.

Ten en cuenta que, al igual que con los demás métodos de porcentaje, la medida porcentual no es lineal con respecto a la longitud si hay curvas en la trayectoria. Cuando hay curvas, el argumento de porcentaje se asigna al parámetro t de las ecuaciones de Bézier.

void QPainterPath::arcMoveTo(const QRectF &rectangle, qreal angle)

Crea una jugada que se sitúa en el arco que ocupa la posición « rectangle » en « angle ».

Los ángulos se especifican en grados. Los arcos en sentido horario pueden especificarse utilizando ángulos negativos. Si rectangle no es un cuadrado, angle es un ángulo excéntrico y no mide la dirección desde el centro del rectángulo, tal y como se describe en Arcs and Ellipses.

Véase también moveTo(), arcTo() y Arcs and Ellipses.

void QPainterPath::arcMoveTo(qreal x, qreal y, qreal width, qreal height, qreal angle)

Crea una jugada situada en el arco que abarca las posiciones QRectF(x, y, width, height) en angle.

Esta es una función sobrecargada.

void QPainterPath::arcTo(const QRectF &rectangle, qreal startAngle, qreal sweepLength)

Crea un arco que ocupa el rectangle indicado, comenzando en el startAngle especificado y extendiéndose sweepLength grados en sentido antihorario.

Los ángulos se especifican en grados. Los arcos en sentido horario pueden especificarse utilizando ángulos negativos. Si rectangle no es un cuadrado, los ángulos son ángulos excéntricos y no miden la dirección desde el centro del rectángulo, tal y como se describe en Arcs and Ellipses.

Ten en cuenta que esta función conecta el punto inicial del arco con la posición actual si aún no están conectados. Una vez añadido el arco, la posición actual es el último punto del arco. Para trazar una línea de vuelta al primer punto, utiliza la función closeSubpath().

Trayectoria de arco con rectángulo delimitador y ángulo inicial
QPainterPath myPath;
myPath.moveTo(center);
myPath.arcTo(boundingRect, startAngle,
             sweepLength);

QPainter painter(this);
painter.setBrush(myGradient);
painter.setPen(myPen);
painter.drawPath(myPath);

Véase también arcMoveTo(), addEllipse(), QPainter::drawArc(), QPainter::drawPie() y Composing a QPainterPath.

void QPainterPath::arcTo(qreal x, qreal y, qreal width, qreal height, qreal startAngle, qreal sweepLength)

Crea un arco que ocupa el rectángulo QRectF(x, y, width, height), que comienza en el punto especificado startAngle y se extiende sweepLength grados en sentido antihorario.

Se trata de una función sobrecargada.

QRectF QPainterPath::boundingRect() const

Devuelve el rectángulo delimitador de esta ruta de dibujo como un rectángulo con precisión de punto flotante.

Véase también controlPointRect().

int QPainterPath::capacity() const

Devuelve el número de elementos asignados por la función QPainterPath.

Véase también ` clear()` y ` reserve()`.

void QPainterPath::clear()

Borra los elementos de la ruta almacenados.

Esto permite que la ruta reutilice las asignaciones de memoria anteriores.

Véase también reserve() y capacity().

void QPainterPath::closeSubpath()

Cierra la subruta actual trazando una línea hasta el inicio de la misma, con lo que se inicia automáticamente una nueva ruta. El punto actual de la nueva ruta es (0, 0).

Si el subtrayecto no contiene ningún elemento, esta función no realiza ninguna acción.

Véase también moveTo() y Composing a QPainterPath.

void QPainterPath::connectPath(const QPainterPath &path)

Conecta la ruta « path » especificada con esta ruta añadiendo una línea desde el último elemento de esta ruta hasta el primer elemento de la ruta especificada.

Véase también addPath() y Composing a QPainterPath.

bool QPainterPath::contains(const QPainterPath &p) const

Devuelve « true » si la ruta dada « p » está contenida dentro de la ruta actual. Devuelve « false » si alguna arista de la ruta actual y « p » se cruzan.

Las operaciones de conjunto sobre rutas tratarán las rutas como áreas. Las rutas no cerradas se tratarán como si estuvieran implícitamente cerradas.

Véase también intersects().

bool QPainterPath::contains(const QPointF &point) const

Devuelve « true » si el elemento « point » dado se encuentra dentro de la ruta; en caso contrario, devuelve « false ».

Véase también intersects().

bool QPainterPath::contains(const QRectF &rectangle) const

Devuelve « true » si la dirección rectangle se encuentra dentro de la ruta; en caso contrario, devuelve « false ».

QRectF QPainterPath::controlPointRect() const

Devuelve el rectángulo que contiene todos los puntos y puntos de control de esta ruta.

Esta función es considerablemente más rápida de calcular que la función exacta ` boundingRect()`, y el rectángulo devuelto es siempre un superconjunto del rectángulo devuelto por ` boundingRect()`.

Véase también boundingRect().

void QPainterPath::cubicTo(const QPointF &c1, const QPointF &c2, const QPointF &endPoint)

Añade una curva Bézier cúbica entre la posición actual y el punto dado endPoint utilizando los puntos de control especificados por c1 y c2.

Una vez añadida la curva, la posición actual se actualiza para situarse en el punto final de la curva.

Curva de Bézier cúbica con los puntos de control c1 y c2
QLinearGradient myGradient;
QPen myPen;

QPainterPath myPath;
myPath.cubicTo(c1, c2, endPoint);

QPainter painter(this);
painter.setBrush(myGradient);
painter.setPen(myPen);
painter.drawPath(myPath);

Véanse también quadTo() y Composing a QPainterPath.

void QPainterPath::cubicTo(qreal c1X, qreal c1Y, qreal c2X, qreal c2Y, qreal endPointX, qreal endPointY)

Añade una curva de Bézier cúbica entre la posición actual y el punto final (endPointX, endPointY) con los puntos de control especificados por (c1X, c1Y) y (c2X, c2Y).

Esta es una función sobrecargada.

QPointF QPainterPath::currentPosition() const

Devuelve la posición actual de la ruta.

QPainterPath::Element QPainterPath::elementAt(int index) const

Devuelve el elemento situado en la posición index especificada en la ruta del pintor.

Véase también ElementType, elementCount() y isEmpty().

int QPainterPath::elementCount() const

Devuelve el número de elementos que componen la ruta del pintor.

Véase también ElementType, elementAt() y isEmpty().

Qt::FillRule QPainterPath::fillRule() const

Devuelve la regla de relleno actualmente establecida para la ruta del pintor.

Véase también setFillRule().

QPainterPath QPainterPath::intersected(const QPainterPath &p) const

Devuelve una ruta que es la intersección entre el área de relleno de esta ruta y el área de relleno de p. Las curvas Bézier pueden simplificarse a segmentos de recta debido a la inestabilidad numérica que conlleva el cálculo de intersecciones de curvas Bézier.

bool QPainterPath::intersects(const QPainterPath &p) const

Devuelve « true » si la ruta actual se cruza en algún punto con la ruta dada « p ». También devuelve « true » si la ruta actual contiene o está contenida en alguna parte de « p ».

Las operaciones de unión sobre trazados tratarán a los trazados como áreas. Los trazados no cerrados se tratarán como si estuvieran implícitamente cerrados.

Véase también contains().

bool QPainterPath::intersects(const QRectF &rectangle) const

Devuelve « true » si algún punto del rectángulo dado « rectangle » se cruza con la ruta; en caso contrario, devuelve « false ».

Se produce una intersección si cualquiera de las líneas que forman el rectángulo cruza una parte de la ruta o si cualquier parte del rectángulo se superpone con cualquier área delimitada por la ruta. Esta función tiene en cuenta el valor actual de ` fillRule ` para determinar qué se considera dentro de la ruta.

Véase también contains().

[since 6.10] bool QPainterPath::isCachingEnabled() const

Devuelve «true» si el almacenamiento en caché está activado; en caso contrario, devuelve «false».

Esta función se introdujo en Qt 6.10.

Véase también ` setCachingEnabled()`.

bool QPainterPath::isEmpty() const

Devuelve « true » si no hay elementos en esta ruta o si el único elemento es un « MoveToElement »; en caso contrario, devuelve « false ».

Véase también elementCount().

qreal QPainterPath::length() const

Devuelve la longitud de la ruta actual.

void QPainterPath::lineTo(const QPointF &endPoint)

Añade una línea recta desde la posición actual hasta el punto dado endPoint. Una vez trazada la línea, la posición actual se actualiza para situarse en el punto final de la línea.

Véase también addPolygon(), addRect() y Composing a QPainterPath.

void QPainterPath::lineTo(qreal x, qreal y)

Traza una línea desde la posición actual hasta el punto (x, y).

Esta es una función sobrecargada.

void QPainterPath::moveTo(const QPointF &point)

Mueve el punto actual a la posición indicada point, iniciando implícitamente un nuevo subtrayecto y cerrando el anterior.

Véase también closeSubpath() y Composing a QPainterPath.

void QPainterPath::moveTo(qreal x, qreal y)

Mueve la posición actual a (x, y) e inicia una nueva subruta, cerrando implícitamente la ruta anterior.

Se trata de una función sobrecargada.

qreal QPainterPath::percentAtLength(qreal len) const

Devuelve el porcentaje de la trayectoria completa correspondiente a la longitud especificada len.

Ten en cuenta que, al igual que en otros métodos de porcentaje, la medida del porcentaje no es lineal con respecto a la longitud si hay curvas en la ruta. Cuando hay curvas, el argumento de porcentaje se asigna al parámetro t de las ecuaciones de Bézier.

QPointF QPainterPath::pointAtPercent(qreal t) const

Devuelve el punto situado en el porcentaje t de la ruta actual. El argumento t debe estar comprendido entre 0 y 1.

Ten en cuenta que, al igual que en otros métodos de porcentaje, la medición porcentual no es lineal con respecto a la longitud si la ruta contiene curvas. Cuando hay curvas, el argumento de porcentaje se asigna al parámetro t de las ecuaciones de Bézier.

void QPainterPath::quadTo(const QPointF &c, const QPointF &endPoint)

Añade una curva de Bézier cuadrática entre la posición actual y el punto dado endPoint, con el punto de control especificado por c.

Una vez añadida la curva, el punto actual se actualiza para situarse en el punto final de la curva.

Véase también cubicTo() y Composing a QPainterPath.

void QPainterPath::quadTo(qreal cx, qreal cy, qreal endPointX, qreal endPointY)

Añade una curva de Bézier cuadrática entre el punto actual y el punto final (endPointX, endPointY) con el punto de control especificado por (cx, cy).

Se trata de una función sobrecargada.

void QPainterPath::reserve(int size)

Reserva una cantidad determinada de elementos en la memoria interna de QPainterPath.

Intenta asignar memoria para al menos size elementos.

Véase también clear(), capacity() y QList::reserve().

[since 6.10] void QPainterPath::setCachingEnabled(bool enabled)

Activa o desactiva el almacenamiento en caché de la longitud según el valor de ` enabled`.

Al habilitar el almacenamiento en caché se aceleran las llamadas repetidas a las funciones miembro que implican valores de longitud de ruta y porcentajes, como length(), percentAtLength(), pointAtPercent() etc., a costa de un mayor consumo de memoria para almacenar los cálculos intermedios. Por defecto, está deshabilitado.

Al desactivar el almacenamiento en caché se liberará toda la memoria de caché asignada.

Esta función se introdujo en Qt 6.10.

Véanse también isCachingEnabled(), length(), percentAtLength(), pointAtPercent() y trimmed().

void QPainterPath::setElementPositionAt(int index, qreal x, qreal y)

Establece las coordenadas x e y del elemento con índice index en x y y.

void QPainterPath::setFillRule(Qt::FillRule fillRule)

Establece la regla de relleno de la ruta del pincel según el valor dado fillRule. Qt ofrece dos métodos para rellenar rutas:

Véase también fillRule().

QPainterPath QPainterPath::simplified() const

Devuelve una versión simplificada de esta ruta. Esto implica fusionar todas las subrutas que se cruzan y devolver una ruta que no contenga aristas que se crucen. Las líneas paralelas consecutivas también se fusionarán. La ruta simplificada utilizará siempre la regla de relleno predeterminada: « Qt::OddEvenFill ». Las curvas de Bézier pueden simplificarse a segmentos de línea debido a la inestabilidad numérica que supone calcular las intersecciones de curvas de Bézier.

qreal QPainterPath::slopeAtPercent(qreal t) const

Devuelve la pendiente de la trayectoria en el porcentaje t. El argumento t debe estar comprendido entre 0 y 1.

Ten en cuenta que, al igual que en otros métodos de porcentaje, la medida porcentual no es lineal con respecto a la longitud si la ruta contiene curvas. Cuando hay curvas, el argumento de porcentaje se asigna al parámetro t de las ecuaciones de Bézier.

QPainterPath QPainterPath::subtracted(const QPainterPath &p) const

Devuelve una ruta que corresponde al área de relleno de p restada del área de relleno de esta ruta.

Las operaciones de unión sobre trazados tratarán los trazados como áreas. Los trazados no cerrados se tratarán como si estuvieran implícitamente cerrados. Las curvas de Bézier pueden simplificarse a segmentos de línea debido a la inestabilidad numérica que supone realizar intersecciones de curvas de Bézier.

[noexcept] void QPainterPath::swap(QPainterPath &other)

Cambia esta ruta de pintor por other. Esta operación es muy rápida y nunca falla.

QPolygonF QPainterPath::toFillPolygon(const QTransform &matrix = QTransform()) const

Convierte la ruta en un polígono utilizando la función « QTransform » matrix y devuelve el polígono.

El polígono se crea convirtiendo primero todas las subtrayectorias en polígonos y, a continuación, utilizando una técnica de rebobinado para garantizar que las subtrayectorias superpuestas se puedan rellenar siguiendo la regla de relleno correcta.

Ten en cuenta que el rebobinado inserta líneas adicionales en el polígono, por lo que el contorno del polígono de relleno no coincide con el contorno de la ruta.

Véase también toSubpathPolygons(), toFillPolygons() y QPainterPath Conversion.

QList<QPolygonF> QPainterPath::toFillPolygons(const QTransform &matrix = QTransform()) const

Convierte la ruta en una lista de polígonos utilizando la función ` QTransform ` matrix y devuelve dicha lista.

Esta función se diferencia de la función toFillPolygon() en que crea varios polígonos. Se ofrece porque, por lo general, es más rápido dibujar varios polígonos pequeños que uno grande, aunque el número total de puntos dibujados sea el mismo.

La función `toFillPolygons()` se diferencia de la función ` toSubpathPolygons()` en que crea un único polígono para los subtrayectos cuyos rectángulos delimitadores se solapan.

Al igual que la función ` toFillPolygon()`, esta función utiliza una técnica de rebobinado para garantizar que las subtrazas superpuestas se puedan rellenar utilizando la regla de relleno correcta. Ten en cuenta que el rebobinado inserta líneas adicionales en los polígonos, por lo que el contorno del polígono de relleno no coincide con el contorno de la traza.

Véanse también toSubpathPolygons(), toFillPolygon() y QPainterPath Conversion.

QPainterPath QPainterPath::toReversed() const

Crea y devuelve una copia invertida de la ruta.

Lo que se invierte es el orden de los elementos: si un « QPainterPath » se compone llamando a las funciones « moveTo()», « lineTo()» y « cubicTo()» en el orden especificado, la copia invertida se compone llamando a « cubicTo()», « lineTo()» y « moveTo()».

QList<QPolygonF> QPainterPath::toSubpathPolygons(const QTransform &matrix = QTransform()) const

Convierte la ruta en una lista de polígonos utilizando la función « QTransform » matrix y devuelve dicha lista.

Esta función crea un polígono para cada subtrayectoria, independientemente de que las subtrayectorias se crucen (es decir, de que los rectángulos delimitadores se superpongan). Para garantizar que dichas subtrayectorias superpuestas se rellenen correctamente, utiliza en su lugar la función toFillPolygons().

Véase también toFillPolygons(), toFillPolygon() y QPainterPath Conversion.

void QPainterPath::translate(qreal dx, qreal dy)

Traslada todos los elementos de la ruta según (dx, dy).

Véase también translated().

void QPainterPath::translate(const QPointF &offset)

Traslada todos los elementos de la ruta según la « offset » indicada.

Esta es una función sobrecargada.

Véase también translated().

QPainterPath QPainterPath::translated(qreal dx, qreal dy) const

Devuelve una copia de la ruta traducida mediante (dx, dy).

Véase también translate().

QPainterPath QPainterPath::translated(const QPointF &offset) const

Devuelve una copia de la ruta traducida mediante el método ` offset` indicado.

Esta es una función sobrecargada.

Véase también translate().

[since 6.10] QPainterPath QPainterPath::trimmed(qreal fromFraction, qreal toFraction, qreal offset = 0) const

Devuelve el tramo de la ruta comprendido entre las fracciones de longitud fromFraction y toFraction. El rango efectivo de las fracciones va desde 0 —que indica el punto inicial de la ruta— hasta 1, que indica su punto final. Las fracciones son lineales con respecto a la longitud de la ruta, a diferencia de los valores porcentuales t.

El valor de offset se sumará a los valores de las fracciones. Si ello provoca un desbordamiento por exceso o por defecto del intervalo [0, 1], los valores se repetirán, al igual que la ruta resultante. El rango efectivo del desplazamiento está comprendido entre -1 y 1.

Las llamadas repetidas a esta función pueden optimizarse {activando el almacenamiento en caché}{setCachingEnabled()}.

Esta función se introdujo en Qt 6.10.

Véase también length(), percentAtLength() y setCachingEnabled().

QPainterPath QPainterPath::united(const QPainterPath &p) const

Devuelve una ruta que es la unión del área de relleno de esta ruta y del área de relleno de p.

Las operaciones de unión sobre trazados tratarán los trazados como áreas. Los trazados no cerrados se tratarán como si estuvieran implícitamente cerrados. Las curvas Bézier pueden simplificarse a segmentos de línea debido a la inestabilidad numérica que supone calcular intersecciones de curvas Bézier.

Véanse también intersected() y subtracted().

bool QPainterPath::operator!=(const QPainterPath &path) const

Devuelve « true » si esta ruta del pintor difiere de la especificada en « path ».

Ten en cuenta que la comparación de rutas puede implicar una comparación elemento por elemento, lo que puede resultar lento en el caso de rutas complejas.

Véase también operator==().

QPainterPath QPainterPath::operator&(const QPainterPath &other) const

Devuelve la intersección de esta ruta con la ruta other.

Véase también intersected(), operator&=(), united() y operator|().

QPainterPath &QPainterPath::operator&=(const QPainterPath &other)

Intersecta esta ruta con other y devuelve una referencia a esta ruta.

Véase también intersected(), operator&() y operator|=().

QPainterPath QPainterPath::operator+(const QPainterPath &other) const

Devuelve la unión de esta ruta y la ruta other. Esta función es equivalente al operador |().

Véase también united(), operator+=() y operator-().

QPainterPath &QPainterPath::operator+=(const QPainterPath &other)

Une esta ruta con other y devuelve una referencia a dicha ruta. Esto equivale al operador |=().

Véase también « united()», « operator+()» y « operator-=()».

QPainterPath QPainterPath::operator-(const QPainterPath &other) const

Resta la ruta other de una copia de esta ruta y devuelve la copia.

Véase también subtracted(), operator-=() y operator+().

QPainterPath &QPainterPath::operator-=(const QPainterPath &other)

Resta « other » de esta ruta y devuelve una referencia a dicha ruta.

Véase también « subtracted()», « operator-()» y « operator+=()».

[noexcept] QPainterPath &QPainterPath::operator=(QPainterPath &&other)

Asigna « other » a esta instancia de « QPainterPath ». ».

QPainterPath &QPainterPath::operator=(const QPainterPath &path)

Asigna el objeto « path » indicado a esta ruta de pintor.

Véase también QPainterPath().

bool QPainterPath::operator==(const QPainterPath &path) const

Devuelve ` true ` si esta ruta de pintura es igual a la especificada en ` path`.

Ten en cuenta que la comparación de rutas puede implicar una comparación elemento por elemento, lo que puede resultar lento en el caso de rutas complejas.

Véase también operator!=().

QPainterPath QPainterPath::operator|(const QPainterPath &other) const

Devuelve la unión de esta ruta y la ruta other.

Véase también united(), operator|=(), intersected() y operator&().

QPainterPath &QPainterPath::operator|=(const QPainterPath &other)

Une esta ruta con other y devuelve una referencia a dicha ruta.

Véase también united(), operator|() y operator&=().

Elementos relacionados no miembros

QDataStream &operator<<(QDataStream &stream, const QPainterPath &path)

Escribe el pintor especificado path en el stream indicado, y devuelve una referencia al stream.

Véase también Serialización detipos de datos de Qt.

QDataStream &operator>>(QDataStream &stream, QPainterPath &path)

Lee una ruta de pintura desde la fuente « stream » especificada y la coloca en el destino « path » indicado, y devuelve una referencia a « stream ».

Véase también «Serialización detipos de datos de Qt».

© 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.