QImage Class

Documentación de las funciones miembro

[noexcept] QImage::QImage()

Construye una imagen nula.

Véase también isNull().

[explicit] QImage::QImage(const char *const[] xpm)

Construye una imagen a partir de la imagen xpm dada.

Asegúrese de que la imagen es una imagen XPM válida. Los errores se ignoran silenciosamente.

Tenga en cuenta que es posible exprimir un poco la variable XPM utilizando una declaración inusual:

static const char * const start_xpm[] = {
    "16 15 8 1",
    "a c #cec6bd",
    // etc.
};

El extra const hace que toda la definición sea de sólo lectura, lo que es ligeramente más eficiente (por ejemplo, cuando el código está en una biblioteca compartida) y capaz de ser almacenado en ROM con la aplicación.

QImage::QImage(const QSize &size, QImage::Format format)

Construye una imagen con los datos size y format.

Se devuelve una imagen null si no se puede asignar memoria.

[explicit] QImage::QImage(const QString &fileName, const char *format = nullptr)

Construye una imagen e intenta cargarla desde el archivo con la dirección fileName.

El cargador intenta leer la imagen utilizando el format especificado. Si no se especifica format (que es el valor predeterminado), se detecta automáticamente basándose en el sufijo y la cabecera del archivo. Para más detalles, véase {QImageReader::setAutoDetectImageFormat()}{QImageReader}.

Si la carga de la imagen ha fallado, este objeto es una imagen nula.

El nombre del archivo puede referirse a un archivo real en disco o a uno de los recursos incrustados de la aplicación. Consulte la descripción general del sistema de recursos para obtener más información sobre cómo incrustar imágenes y otros archivos de recursos en el ejecutable de la aplicación.

Véase también isNull() y Reading and Writing Image Files.

QImage::QImage(int width, int height, QImage::Format format)

Construye una imagen con los datos width, height y format.

Se devolverá una imagen null si no se puede asignar memoria.

QImage::QImage(const uchar *data, int width, int height, QImage::Format format, QImageCleanupFunction cleanupFunction = nullptr, void *cleanupInfo = nullptr)

Construye una imagen con los datos width, height y format, que utiliza un búfer de memoria de sólo lectura existente, data. width y height deben especificarse en píxeles, data debe estar alineada a 32 bits, y cada línea de datos de la imagen debe estar también alineada a 32 bits.

El búfer debe permanecer válido durante toda la vida de la QImage y de todas las copias que no hayan sido modificadas o separadas del búfer original. La imagen no borra el búfer en el momento de su destrucción. Puede proporcionar un puntero de función cleanupFunction junto con un puntero extra cleanupInfo que será llamado cuando se destruya la última copia.

Si format es un formato de color indexado, la tabla de color de la imagen está inicialmente vacía y debe ser suficientemente expandida con setColorCount() o setColorTable() antes de que la imagen sea utilizada.

A diferencia del constructor similar QImage que toma un buffer de datos no-const, esta versión nunca alterará el contenido del buffer. Por ejemplo, llamar a QImage::bits() devolverá una copia profunda de la imagen, en lugar del buffer pasado al constructor. Esto permite la eficiencia de construir una QImage a partir de datos brutos, sin la posibilidad de que los datos brutos sean cambiados.

QImage::QImage(uchar *data, int width, int height, QImage::Format format, QImageCleanupFunction cleanupFunction = nullptr, void *cleanupInfo = nullptr)

Construye una imagen con los datos width, height y format, que utiliza un búfer de memoria existente, data. width y height deben especificarse en píxeles, data debe estar alineada a 32 bits, y cada línea de datos de la imagen debe estar también alineada a 32 bits.

El búfer debe permanecer válido durante toda la vida de la QImage y de todas las copias que no hayan sido modificadas o separadas del búfer original. La imagen no borra el búfer en el momento de su destrucción. Puede proporcionar un puntero de función cleanupFunction junto con un puntero extra cleanupInfo que será llamado cuando se destruya la última copia.

Si format es un formato de color indexado, la tabla de colores de la imagen está inicialmente vacía y debe ampliarse suficientemente con setColorCount() o setColorTable() antes de utilizar la imagen.

QImage::QImage(const uchar *data, int width, int height, qsizetype bytesPerLine, QImage::Format format, QImageCleanupFunction cleanupFunction = nullptr, void *cleanupInfo = nullptr)

Construye una imagen con los datos width, height y format, que utiliza un búfer de memoria existente, data. width y height deben especificarse en píxeles. bytesPerLine especifica el número de bytes por línea (stride).

El búfer debe permanecer válido durante toda la vida de la QImage y de todas las copias que no hayan sido modificadas o separadas del búfer original. La imagen no borra el búfer en el momento de su destrucción. Puede proporcionar un puntero de función cleanupFunction junto con un puntero extra cleanupInfo que será llamado cuando se destruya la última copia.

Si format es un formato de color indexado, la tabla de color de la imagen está inicialmente vacía y debe ser suficientemente expandida con setColorCount() o setColorTable() antes de que la imagen sea utilizada.

A diferencia del constructor similar QImage que toma un buffer de datos no-const, esta versión nunca alterará el contenido del buffer. Por ejemplo, llamar a QImage::bits() devolverá una copia profunda de la imagen, en lugar del buffer pasado al constructor. Esto permite la eficiencia de construir una QImage a partir de datos brutos, sin la posibilidad de que los datos brutos sean cambiados.

QImage::QImage(uchar *data, int width, int height, qsizetype bytesPerLine, QImage::Format format, QImageCleanupFunction cleanupFunction = nullptr, void *cleanupInfo = nullptr)

Construye una imagen con los datos width, height y format, que utiliza un búfer de memoria existente, data. width y height deben especificarse en píxeles. bytesPerLine especifica el número de bytes por línea (stride).

El búfer debe permanecer válido durante toda la vida de la QImage y de todas las copias que no hayan sido modificadas o separadas del búfer original. La imagen no borra el búfer en el momento de su destrucción. Puede proporcionar un puntero de función cleanupFunction junto con un puntero extra cleanupInfo que será llamado cuando se destruya la última copia.

Si format es un formato de color indexado, la tabla de colores de la imagen está inicialmente vacía y debe ampliarse suficientemente con setColorCount() o setColorTable() antes de utilizar la imagen.

QImage::QImage(const QImage &image)

Crea una copia superficial de image.

Para obtener más información sobre las copias superficiales, consulte la documentación sobre la compartición implícita de datos.

Véase también copy().

[noexcept] QImage::QImage(QImage &&other)

Move-construye una instancia de QImage, haciendo que apunte al mismo objeto al que apuntaba other.

[virtual noexcept] QImage::~QImage()

Destruye la imagen y limpia.

bool QImage::allGray() const

Devuelve true si todos los colores de la imagen son tonos de gris (es decir, sus componentes rojo, verde y azul son iguales); en caso contrario, false.

Tenga en cuenta que esta función es lenta para imágenes sin tabla de colores.

Véase también isGrayscale().

void QImage::applyColorTransform(const QColorTransform &transform)

Aplica la transformación de color transform a todos los píxeles de la imagen.

[since 6.8] void QImage::applyColorTransform(const QColorTransform &transform, QImage::Format toFormat, Qt::ImageConversionFlags flags = Qt::AutoColor)

Aplica la transformación de color transform a todos los píxeles de la imagen y convierte el formato de la imagen a toFormat.

La conversión de imagen especificada flags controla cómo se manejan los datos de la imagen durante el proceso de conversión de formato.

Esta función se introdujo en Qt 6.8.

int QImage::bitPlaneCount() const

Devuelve el número de planos de bits de la imagen.

El número de planos de bits es el número de bits de información de color y transparencia de cada píxel. Es distinto (es decir, menor) que la profundidad cuando el formato de la imagen contiene bits no utilizados.

Véase también depth(), format(), y Image Formats.

uchar *QImage::bits()

Devuelve un puntero a los datos del primer píxel. Esto es equivalente a scanLine(0).

Tenga en cuenta que QImage utiliza datos compartidos implícitos. Esta función realiza una copia profunda de los datos de píxel compartidos, asegurando así que este QImage es el único que utiliza el valor de retorno actual.

Véase también scanLine(), sizeInBytes(), y constBits().

const uchar *QImage::bits() const

Tenga en cuenta que QImage utiliza datos compartidos implícitos, pero esta función no realiza una copia profunda de los datos de píxeles compartidos, porque los datos devueltos son const.

qsizetype QImage::bytesPerLine() const

Devuelve el número de bytes por línea de barrido de la imagen.

Equivale a sizeInBytes() / height() si height() es distinto de cero.

Véase también scanLine().

qint64 QImage::cacheKey() const

Devuelve un número que identifica el contenido de este objeto QImage. Objetos QImage distintos sólo pueden tener la misma clave si se refieren al mismo contenido.

La clave cambiará cuando se modifique la imagen.

QRgb QImage::color(int i) const

Devuelve el color de la tabla de colores en el índice i. El primer color está en el índice 0.

Los colores de la tabla de colores de una imagen se especifican como cuartetos ARGB (QRgb). Utilice las funciones qAlpha(), qRed(), qGreen() y qBlue() para obtener los componentes del valor del color.

Véase también setColor(), pixelIndex(), y Pixel Manipulation.

int QImage::colorCount() const

Devuelve el tamaño de la tabla de colores de la imagen.

Tenga en cuenta que colorCount() devuelve 0 para las imágenes de 32 bpp porque estas imágenes no utilizan tablas de colores, sino que codifican los valores de los píxeles como cuadrángulos ARGB.

Véase también setColorCount() y Image Information.

QColorSpace QImage::colorSpace() const

Devuelve el espacio de color de la imagen si se ha definido un espacio de color.

Véase también setColorSpace().

QList<QRgb> QImage::colorTable() const

Devuelve una lista de los colores contenidos en la tabla de colores de la imagen, o una lista vacía si la imagen no tiene tabla de colores.

Véase también setColorTable(), colorCount() y color().

[since 6.4] QImage QImage::colorTransformed(const QColorTransform &transform) const &

Devuelve el color de la imagen transformado utilizando transform en todos los píxeles de la imagen.

Esta función se introdujo en Qt 6.4.

Véase también applyColorTransform().

[since 6.8] QImage QImage::colorTransformed(const QColorTransform &transform, QImage::Format toFormat, Qt::ImageConversionFlags flags = Qt::AutoColor) const &

Devuelve el color de la imagen transformado utilizando transform en todos los píxeles de la imagen, devolviendo una imagen de formato toFormat.

La conversión de imagen especificada flags controla cómo se manejan los datos de la imagen durante el proceso de conversión de formato.

Esta función se introdujo en Qt 6.8.

Véase también applyColorTransform().

[since 6.4] QImage QImage::colorTransformed(const QColorTransform &transform) &&

Devuelve el color de la imagen transformado utilizando transform en todos los píxeles de la imagen.

Esta función se introdujo en Qt 6.4.

Véase también applyColorTransform().

[since 6.8] QImage QImage::colorTransformed(const QColorTransform &transform, QImage::Format format, Qt::ImageConversionFlags flags = Qt::AutoColor) &&

Devuelve el color de la imagen transformado utilizando transform en todos los píxeles de la imagen.

Esta función se introdujo en Qt 6.8.

Véase también applyColorTransform().

const uchar *QImage::constBits() const

Devuelve un puntero a los datos del primer píxel.

Tenga en cuenta que QImage utiliza datos compartidos implícitos, pero esta función no realiza una copia profunda de los datos de píxel compartidos, porque los datos devueltos son const.

Véase también bits() y constScanLine().

const uchar *QImage::constScanLine(int i) const

Devuelve un puntero a los datos de píxel en la línea de exploración con índice i. La primera línea de exploración está en el índice 0.

Los datos de la línea de exploración están alineados como mínimo a 32 bits. Para formatos de 64 bits, sigue la alineación nativa de los enteros de 64 bits (64 bits para la mayoría de las plataformas, pero especialmente 32 bits en i386).

Tenga en cuenta que QImage utiliza datos compartidos implícitos, pero esta función no realiza una copia profunda de los datos de píxel compartidos, porque los datos devueltos son const.

Véase también scanLine() y constBits().

void QImage::convertTo(QImage::Format format, Qt::ImageConversionFlags flags = Qt::AutoColor)

Convierte la imagen al format dado en su lugar, separando si es necesario.

La conversión de imagen especificada flags controla cómo se manejan los datos de la imagen durante el proceso de conversión.

Véase también convertedTo().

void QImage::convertToColorSpace(const QColorSpace &colorSpace)

Convierte la imagen a colorSpace.

Si la imagen no tiene un espacio de color válido, el método no hace nada.

Véase también convertedToColorSpace() y setColorSpace().

[since 6.8] void QImage::convertToColorSpace(const QColorSpace &colorSpace, QImage::Format format, Qt::ImageConversionFlags flags = Qt::AutoColor)

Convierte la imagen a colorSpace y format.

Si la imagen no tiene un espacio de color válido, el método no hace nada, ni tampoco si el espacio de color no es compatible con el formato.

La conversión de imagen especificada flags controla cómo se manejan los datos de la imagen durante el proceso de conversión de formato.

Esta función se introdujo en Qt 6.8.

Véase también convertedToColorSpace() y setColorSpace().

Devuelve una copia de la imagen en la dirección format.

La conversión de imagen especificada flags controla cómo se manejan los datos de la imagen durante el proceso de conversión.

Véase también convertTo() y Image Formats.

QImage QImage::convertToFormat(QImage::Format format, const QList<QRgb> &colorTable, Qt::ImageConversionFlags flags = Qt::AutoColor) const

Devuelve una copia de la imagen convertida al formato format, utilizando el formato colorTable especificado.

La conversión de formatos RGB a formatos indexados es una operación lenta y utilizará un enfoque directo del color más cercano, sin difuminado.

Devuelve una copia de la imagen en la dirección format.

La conversión de imagen especificada flags controla cómo se manejan los datos de la imagen durante el proceso de conversión.

Estas funciones se introdujeron en Qt 6.0.

Véase también convertTo() y Image Formats.

QImage QImage::convertedToColorSpace(const QColorSpace &colorSpace) const

Devuelve la imagen convertida a colorSpace.

Si la imagen no tiene un espacio de color válido, se devuelve un QImage nulo.

Véase también convertToColorSpace() y colorTransformed().

Devuelve la imagen convertida a colorSpace y format.

Si la imagen no tiene un espacio de color válido, se devuelve un QImage nulo.

La conversión de imagen especificada flags controla cómo se manejan los datos de la imagen durante el proceso de conversión de formato.

Estas funciones se introdujeron en Qt 6.8.

Véase también colorTransformed().

QImage QImage::copy(const QRect &rectangle = QRect()) const

Devuelve una sub-área de la imagen como una nueva imagen.

La imagen devuelta se copia desde la posición (rectangle.x(), rectangle.y()) en esta imagen, y siempre tendrá el tamaño de la rectangle dada.

En áreas más allá de esta imagen, los píxeles se ponen a 0. Para imágenes RGB de 32 bits, esto significa negro; para imágenes ARGB de 32 bits, esto significa negro transparente; para imágenes de 8 bits, esto significa el color con índice 0 en la tabla de colores que puede ser cualquier cosa; para imágenes de 1 bit, esto significa Qt::color0.

Si rectangle es un rectángulo nulo, se copia toda la imagen.

Véase también QImage().

QImage QImage::copy(int x, int y, int width, int height) const

La imagen devuelta se copia desde la posición (x, y) en esta imagen, y siempre tendrá los width y height dados. En áreas más allá de esta imagen, los píxeles se ponen a 0.

QImage QImage::createAlphaMask(Qt::ImageConversionFlags flags = Qt::AutoColor) const

Construye y devuelve una máscara de 1-bpp del buffer alfa de esta imagen. Devuelve una imagen nula si el formato de la imagen es QImage::Format_RGB32.

El argumento flags es un bitwise-OR de Qt::ImageConversionFlags, y controla el proceso de conversión. Si se pasa 0 para flags, se activan todas las opciones por defecto.

La imagen devuelta tiene un orden de bits little-endian (es decir, el formato de la imagen es QImage::Format_MonoLSB), que puede convertir a big-endian (QImage::Format_Mono) utilizando la función convertToFormat().

Véase también createHeuristicMask() y Image Transformations.

QImage QImage::createHeuristicMask(bool clipTight = true) const

Crea y devuelve una máscara heurística de 1 bpp para esta imagen.

La función funciona seleccionando un color de una de las esquinas y eliminando píxeles de ese color empezando por todos los bordes. Las cuatro esquinas votan qué color se va a eliminar. En caso de empate (lo que generalmente significa que esta función no es aplicable a la imagen), el resultado es arbitrario.

La imagen devuelta tiene un orden de bits little-endian (es decir, el formato de la imagen es QImage::Format_MonoLSB), que puede convertir a big-endian (QImage::Format_Mono) utilizando la función convertToFormat().

Si clipTight es verdadero (por defecto) la máscara es lo suficientemente grande como para cubrir los píxeles; en caso contrario, la máscara es más grande que los píxeles de datos.

Tenga en cuenta que esta función no tiene en cuenta el búfer alfa.

Véase también createAlphaMask() y Image Transformations.

QImage QImage::createMaskFromColor(QRgb color, Qt::MaskMode mode = Qt::MaskInColor) const

Crea y devuelve una máscara para esta imagen basada en el valor color dado. Si mode es MaskInColor (el valor por defecto), todos los píxeles que coincidan con color serán píxeles opacos en la máscara. Si mode es MaskOutColor, todos los píxeles que coincidan con el color dado serán transparentes.

Véase también createAlphaMask() y createHeuristicMask().

int QImage::depth() const

Devuelve la profundidad de la imagen.

La profundidad de la imagen es el número de bits utilizados para almacenar un único píxel, también llamados bits por píxel (bpp).

Las profundidades soportadas son 1, 8, 16, 24, 32 y 64.

Véase también bitPlaneCount(), convertToFormat(), Image Formats, y Image Information.

[since 6.2] QSizeF QImage::deviceIndependentSize() const

Devuelve el tamaño de la imagen en píxeles independientes del dispositivo.

Este valor debe utilizarse cuando se utiliza el tamaño de la imagen en los cálculos de tamaño de la interfaz de usuario.

El valor devuelto es equivalente a image.size() / image.devicePixelRatio().

Esta función se introdujo en Qt 6.2.

qreal QImage::devicePixelRatio() const

Devuelve la proporción de píxeles del dispositivo para la imagen. Es la relación entre los píxeles del dispositivo y los píxeles independientes del dispositivo.

Utilice esta función cuando calcule la geometría del diseño basándose en el tamaño de la imagen: QSize layoutSize = image.size() / image.devicePixelRatio()

El valor por defecto es 1.0.

Véase también setDevicePixelRatio() y QImageReader.

int QImage::dotsPerMeterX() const

Devuelve el número de píxeles que caben horizontalmente en un metro físico. Junto con dotsPerMeterY(), este número define la escala prevista y la relación de aspecto de la imagen.

Véase también setDotsPerMeterX() y Image Information.

int QImage::dotsPerMeterY() const

Devuelve el número de píxeles que caben verticalmente en un metro físico. Junto con dotsPerMeterX(), este número define la escala prevista y la relación de aspecto de la imagen.

Véase también setDotsPerMeterY() y Image Information.

void QImage::fill(uint pixelValue)

Rellena toda la imagen con la dirección pixelValue.

Si la profundidad de esta imagen es 1, sólo se utiliza el bit más bajo. Si dices fill(0), fill(2), etc., la imagen se rellena con 0s. Si dice fill(1), fill(3), etc., la imagen se rellena con 1s. Si la profundidad es 8, se utilizan los 8 bits más bajos y si la profundidad es 16 se utilizan los 16 bits más bajos.

Si la profundidad de la imagen es superior a 32 bits el resultado es indefinido.

Véase también depth() y Image Transformations.

void QImage::fill(Qt::GlobalColor color)

Rellena la imagen con el color dado, descrito como un color global estándar.

void QImage::fill(const QColor &color)

Rellena toda la imagen con el valor color.

Si la profundidad de la imagen es 1, la imagen se rellenará con 1 si color es igual a Qt::color1; en caso contrario se rellenará con 0.

Si la profundidad de la imagen es 8, la imagen se rellenará con el índice correspondiente a color en la tabla de colores si está presente; en caso contrario, se rellenará con 0.

[since 6.9] void QImage::flip(Qt::Orientations orient = Qt::Vertical)

Voltea o refleja la imagen en la dirección horizontal y/o vertical dependiendo de orient.

Esta función se introdujo en Qt 6.9.

Véase también flipped(Qt::Orientations) y Image Transformations.

Devuelve una versión invertida o reflejada de la imagen, reflejada en la dirección horizontal y/o vertical dependiendo de orient.

Tenga en cuenta que la imagen original no se modifica.

Estas funciones se introdujeron en Qt 6.9.

Véase también flip(Qt::Orientations) y Image Transformations.

QImage::Format QImage::format() const

Devuelve el formato de la imagen.

Véase también Image Formats.

[static, since 6.2] QImage QImage::fromData(QByteArrayView data, const char *format = nullptr)

Construye una imagen a partir de la dirección QByteArrayView data . El cargador intenta leer la imagen utilizando el format especificado. Si no se especifica format (que es el valor predeterminado), el cargador sondea los datos en busca de una cabecera para adivinar el formato del archivo.

Si se especifica format, debe ser uno de los valores devueltos por QImageReader::supportedImageFormats().

Si la carga de la imagen falla, la imagen devuelta será una imagen nula.

Esta función se introdujo en Qt 6.2.

Véase también load(), save(), y Reading and Writing Image Files.

[static] QImage QImage::fromData(const QByteArray &data, const char *format = nullptr)

Construye un QImage a partir del QByteArray dado data.

[static] QImage QImage::fromData(const uchar *data, int size, const char *format = nullptr)

Construye un QImage a partir de los primeros size bytes del binario data.

[static, since 6.0] QImage QImage::fromHBITMAP(HBITMAP hbitmap)

Devuelve un QImage equivalente al hbitmap dado.

HBITMAP no almacena información sobre el canal alfa.

En el caso estándar, el canal alfa se ignora y se crea una imagen totalmente opaca (normalmente con el formato QImage::Format_RGB32).

Sin embargo, hay casos en los que se utiliza el canal alfa, por ejemplo para iconos de aplicaciones o de la bandeja del sistema. En ese caso, se debe llamar a reinterpretAsFormat(QImage::Format_ARGB32) en la imagen devuelta para asegurarse de que el formato es correcto.

Esta función se introdujo en Qt 6.0.

Véase también toHBITMAP() y reinterpretAsFormat().

[static, since 6.0] QImage QImage::fromHICON(HICON icon)

Devuelve un QImage que es equivalente al icon dado.

Esta función se introdujo en Qt 6.0.

Véase también toHICON().

bool QImage::hasAlphaChannel() const

Devuelve true si la imagen tiene un formato que respeta el canal alfa, en caso contrario devuelve false.

Véase también Image Information.

int QImage::height() const

Devuelve la altura de la imagen.

Véase también Image Information.

void QImage::invertPixels(QImage::InvertMode mode = InvertRgb)

Invierte todos los valores de píxel de la imagen.

La inversión dada mode sólo tiene sentido cuando la profundidad de la imagen es 32. El valor por defecto mode es InvertRgb, que deja el canal alfa sin cambios. Si mode es InvertRgba, los bits alfa también se invierten.

Invertir una imagen de 8 bits significa sustituir todos los píxeles que utilizan el índice de color i por un píxel que utiliza el índice de color 255 menos i. Lo mismo ocurre con una imagen de 1 bit. Tenga en cuenta que la tabla de colores no se modifica.

Si la imagen tiene un canal alfa premultiplicado, la imagen se convierte primero a un formato de imagen no premultiplicado para ser invertida y luego se vuelve a convertir.

Véase también Image Transformations.

bool QImage::isGrayscale() const

Para imágenes de 32 bits, esta función es equivalente a allGray().

Para imágenes indexadas por colores, esta función devuelve true si color(i) es QRgb(i, i, i) para todos los índices de la tabla de colores; en caso contrario devuelve false.

Véase también allGray() y Image Formats.

bool QImage::isNull() const

Devuelve true si es una imagen nula, en caso contrario devuelve false.

Una imagen nula tiene todos los parámetros a cero y no tiene datos asignados.

bool QImage::load(const QString &fileName, const char *format = nullptr)

Carga una imagen desde el archivo con la dirección fileName. Devuelve true si la imagen se ha cargado correctamente; en caso contrario, invalida la imagen y devuelve false.

El cargador intenta leer la imagen utilizando el format especificado, por ejemplo, PNG o JPG. Si no se especifica format (que es el valor predeterminado), se detecta automáticamente basándose en el sufijo y la cabecera del archivo. Para más detalles, véase QImageReader::setAutoDetectImageFormat().

El nombre del archivo puede referirse a un archivo real en disco o a uno de los recursos incrustados de la aplicación. Consulta la descripción general del sistema de recursos para saber cómo incrustar imágenes y otros archivos de recursos en el ejecutable de la aplicación.

Véase también Reading and Writing Image Files.

bool QImage::load(QIODevice *device, const char *format)

Esta función lee un QImage del device dado. Puede utilizarse, por ejemplo, para cargar una imagen directamente en QByteArray.

[since 6.2] bool QImage::loadFromData(QByteArrayView data, const char *format = nullptr)

Carga una imagen desde la dirección QByteArrayView data . Devuelve true si la imagen se ha cargado correctamente; en caso contrario, invalida la imagen y devuelve false.

El cargador intenta leer la imagen utilizando el format especificado, por ejemplo, PNG o JPG. Si no se especifica format (que es el valor predeterminado), el cargador sondea el archivo en busca de una cabecera para adivinar el formato del archivo.

Esta función se introdujo en Qt 6.2.

Véase también Reading and Writing Image Files.

bool QImage::loadFromData(const QByteArray &data, const char *format = nullptr)

Carga una imagen desde la dirección QByteArray data .

bool QImage::loadFromData(const uchar *data, int len, const char *format = nullptr)

Carga una imagen a partir de los primeros len bytes del binario dado data.

[since 6.0, until 6.13] void QImage::mirror(bool horizontal = false, bool vertical = true)

Esta función dejará de utilizarse en la versión 6.13.

Utilice flip(Qt::Orientations) en su lugar.

Refleja la imagen en la dirección horizontal y/o vertical dependiendo de si horizontal y vertical están establecidos en true o false.

Esta función se introdujo en Qt 6.0.

Véase también mirrored() y Image Transformations.

Esta función dejará de utilizarse en la versión 6.13.

Utilice flipped(Qt::Orientations) en su lugar.

Devuelve un espejo de la imagen, reflejada en la dirección horizontal y/o vertical dependiendo de si horizontal y vertical están en true o false.

Tenga en cuenta que la imagen original no se modifica.

Véase también mirror() y Image Transformations.

QPoint QImage::offset() const

Devuelve el número de píxeles por los que se pretende desplazar la imagen al posicionarla con respecto a otras imágenes.

Véase también setOffset() y Image Information.

QRgb QImage::pixel(const QPoint &position) const

Devuelve el color del píxel en la dirección position.

Si position no es válido, el resultado es indefinido.

Ver también setPixel(), valid(), constBits(), constScanLine(), y Pixel Manipulation.

QRgb QImage::pixel(int x, int y) const

Devuelve el color del píxel en las coordenadas (x, y).

QColor QImage::pixelColor(const QPoint &position) const

Devuelve el color del píxel en el position dado como QColor.

Si position no es válido, se devuelve un QColor no válido.

Ver también setPixelColor(), setPixel(), valid(), constBits(), constScanLine(), y Pixel Manipulation.

QColor QImage::pixelColor(int x, int y) const

Devuelve el color del píxel en las coordenadas (x, y) como QColor.

[noexcept] QPixelFormat QImage::pixelFormat() const

Devuelve la dirección QImage::Format como QPixelFormat

int QImage::pixelIndex(const QPoint &position) const

Devuelve el índice de píxel en el position dado.

Si position no es válido, o si la imagen no es una imagen con paleta (depth() > 8), los resultados son indefinidos.

Véase también valid(), depth(), y Pixel Manipulation.

int QImage::pixelIndex(int x, int y) const

Devuelve el índice de píxel en (x, y).

QRect QImage::rect() const

Devuelve el rectángulo envolvente (0, 0, width(), height()) de la imagen.

Véase también Image Information.

bool QImage::reinterpretAsFormat(QImage::Format format)

Cambia el formato de la imagen a format sin cambiar los datos. Sólo funciona entre formatos de la misma profundidad.

Devuelve true si tiene éxito.

Esta función puede utilizarse para cambiar imágenes con canales alfa a sus correspondientes formatos opacos si se sabe que los datos son sólo opacos, o para cambiar el formato de un búfer de imagen dado antes de sobrescribirlo con nuevos datos.

Véase también hasAlphaChannel() y convertToFormat().

[since 6.0] void QImage::rgbSwap()

Intercambia los valores de los componentes rojo y azul de todos los píxeles, convirtiendo efectivamente una imagen RGB en una imagen BGR.

Esta función se introdujo en Qt 6.0.

Véase también rgbSwapped() y Image Transformations.

Devuelve un QImage en el que se han intercambiado los valores de los componentes rojo y azul de todos los píxeles, convirtiendo así una imagen RGB en una imagen BGR.

El QImage original no se modifica.

Véase también rgbSwap() y Image Transformations.

bool QImage::save(const QString &fileName, const char *format = nullptr, int quality = -1) const

Guarda la imagen en el archivo con el factor fileName dado, utilizando el archivo de imagen format y quality dados. Si format es nullptr, QImage intentará adivinar el formato mirando el sufijo de fileName.

El factor quality debe estar en el rango de 0 a 100 o -1. Especifique 0 para obtener archivos comprimidos pequeños, 100 para archivos grandes sin comprimir y -1 (el valor predeterminado) para utilizar la configuración predeterminada.

Devuelve true si la imagen se ha guardado correctamente; en caso contrario, devuelve false.

Véase también Reading and Writing Image Files.

bool QImage::save(QIODevice *device, const char *format = nullptr, int quality = -1) const

Esta función escribe un QImage en el device dado.

Puede utilizarse, por ejemplo, para guardar una imagen directamente en QByteArray:

QImage image;
QByteArray ba;
QBuffer buffer(&ba);
buffer.open(QIODevice::WriteOnly);
image.save(&buffer, "PNG"); // writes image into ba in PNG format

QImage QImage::scaled(const QSize &size, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const

Devuelve una copia de la imagen escalada a un rectángulo definido por el size dado según los aspectRatioMode y transformMode dados .

• Si aspectRatioMode es Qt::IgnoreAspectRatio, la imagen se escala a size.
• Si aspectRatioMode es Qt::KeepAspectRatio, la imagen se escala a un rectángulo lo más grande posible dentro de size, preservando la relación de aspecto.
• Si aspectRatioMode es Qt::KeepAspectRatioByExpanding, la imagen se escala a un rectángulo lo más pequeño posible fuera de size, preservando la relación de aspecto.

Si size está vacío, esta función devuelve una imagen nula.

Véase también isNull() y Image Transformations.

QImage QImage::scaled(int width, int height, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const

Devuelve una copia de la imagen escalada a un rectángulo con los valores dados width y height según los valores dados aspectRatioMode y transformMode.

Si width o height son cero o negativos, esta función devuelve una imagen nula.

QImage QImage::scaledToHeight(int height, Qt::TransformationMode mode = Qt::FastTransformation) const

Devuelve una copia escalada de la imagen. La imagen devuelta se escala al height dado utilizando la transformación especificada mode.

Esta función calcula automáticamente la anchura de la imagen para que se mantenga la proporción de la imagen.

Si height es 0 o negativo, se devuelve una imagen nula.

Véase también Image Transformations.

QImage QImage::scaledToWidth(int width, Qt::TransformationMode mode = Qt::FastTransformation) const

Devuelve una copia escalada de la imagen. La imagen devuelta se escala al width dado utilizando la transformación especificada mode.

Esta función calcula automáticamente la altura de la imagen para mantener su relación de aspecto.

Si width es 0 o negativo, se devuelve una imagen nula.

Véase también Image Transformations.

uchar *QImage::scanLine(int i)

Devuelve un puntero a los datos de píxel en la línea de exploración con índice i. La primera línea de exploración está en el índice 0.

Los datos de la línea de exploración están alineados como mínimo a 32 bits. Para formatos de 64 bits, sigue la alineación nativa de los enteros de 64 bits (64 bits para la mayoría de las plataformas, pero especialmente 32 bits en i386).

Por ejemplo, para eliminar el componente verde de cada píxel de una imagen:

for (int y = 0; y < image.height(); ++y) {
    QRgb *line = reinterpret_cast<QRgb*>(image.scanLine(y));
    for (int x = 0; x < image.width(); ++x) {
        QRgb &rgb = line[x];
        rgb = qRgba(qRed(rgb), qGreen(0), qBlue(rgb), qAlpha(rgb));
    }
}

Véase también bytesPerLine(), bits(), Pixel Manipulation, y constScanLine().

const uchar *QImage::scanLine(int i) const

void QImage::setAlphaChannel(const QImage &alphaChannel)

Establece el canal alfa de esta imagen en alphaChannel.

Si alphaChannel es una imagen alfa de 8 bits, los valores alfa se utilizan directamente. En caso contrario, alphaChannel se convierte a escala de grises de 8 bits y se utiliza la intensidad de los valores de los píxeles.

Si la imagen ya tiene un canal alfa, el canal alfa existente se multiplica por el nuevo. Si la imagen no tiene canal alfa, se convertirá a un formato que sí lo tenga.

La operación es similar a pintar alphaChannel como una imagen alfa sobre esta imagen usando QPainter::CompositionMode_DestinationIn.

Véase también hasAlphaChannel(), Image Transformations, y Image Formats.

void QImage::setColor(int index, QRgb colorValue)

Establece el color en el index dado en la tabla de colores, al dado a colorValue. El valor del color es un cuadruplo ARGB.

Si index está fuera del tamaño actual de la tabla de colores, se expande con setColorCount().

Véase también color(), colorCount(), setColorTable(), y Pixel Manipulation.

void QImage::setColorCount(int colorCount)

Redimensiona la tabla de colores para que contenga colorCount entradas.

Si se amplía la tabla de colores, todos los colores adicionales se establecerán como transparentes (es decir, qRgba(0, 0, 0, 0)).

Cuando se utiliza la imagen, la tabla de colores debe ser lo suficientemente grande como para tener entradas para todos los valores de píxel/índice presentes en la imagen, de lo contrario los resultados son indefinidos.

Véase también colorCount(), colorTable(), setColor(), y Image Transformations.

void QImage::setColorSpace(const QColorSpace &colorSpace)

Establece el espacio de color de la imagen en colorSpace sin realizar ninguna conversión en los datos de la imagen.

Véase también colorSpace().

void QImage::setColorTable(const QList<QRgb> &colors)

Establece la tabla de colores utilizada para traducir los índices de color a valores QRgb, en la dirección colors especificada.

Cuando se utiliza la imagen, la tabla de colores debe ser lo suficientemente grande como para tener entradas para todos los valores de píxel/índice presentes en la imagen, de lo contrario los resultados son indefinidos.

Véase también colorTable(), setColor(), y Image Transformations.

void QImage::setDevicePixelRatio(qreal scaleFactor)

Establece la proporción de píxeles del dispositivo para la imagen. Es la relación entre los píxeles de la imagen y los píxeles independientes del dispositivo.

Por defecto, scaleFactor es 1.0. Establecerlo a otro valor tiene dos efectos:

Los QPainters que se abran sobre la imagen serán escalados. Por ejemplo, pintar en una imagen de 200x200 con un ratio de 2.0 resultará en unos límites de pintura efectivos (independientes del dispositivo) de 100x100.

Las rutas de código en Qt que calculan la geometría del diseño basándose en el tamaño de la imagen tendrán en cuenta el ratio: QSize layoutSize = image.size() / image.devicePixelRatio() El efecto neto de esto es que la imagen se muestra como una imagen de alto-DPI en lugar de una imagen grande (ver Drawing High Resolution Versions of Pixmaps and Images).

Véase también devicePixelRatio() y deviceIndependentSize().

void QImage::setDotsPerMeterX(int x)

Establece el número de píxeles que caben horizontalmente en un metro físico, en x.

Junto con dotsPerMeterY(), este número define la escala prevista y la relación de aspecto de la imagen, y determina la escala a la que QPainter dibujará los gráficos en la imagen. No cambia la escala ni la relación de aspecto de la imagen cuando se renderiza en otros dispositivos de pintura.

Véase también dotsPerMeterX() y Image Information.

void QImage::setDotsPerMeterY(int y)

Establece el número de píxeles que caben verticalmente en un metro físico, en y.

Junto con dotsPerMeterX(), este número define la escala prevista y la relación de aspecto de la imagen, y determina la escala a la que QPainter dibujará los gráficos en la imagen. No cambia la escala ni la relación de aspecto de la imagen cuando se renderiza en otros dispositivos de pintura.

Véase también dotsPerMeterY() y Image Information.

void QImage::setOffset(const QPoint &offset)

Establece el número de píxeles en los que la imagen debe desplazarse al posicionarse con respecto a otras imágenes, en offset.

Véase también offset() y Image Information.

void QImage::setPixel(const QPoint &position, uint index_or_rgb)

Establece el índice del píxel o el color en el position dado a index_or_rgb.

Si el formato de la imagen es monocromo o con paletas, el valor index_or_rgb dado debe ser un índice de la tabla de colores de la imagen; en caso contrario, el parámetro debe ser un valor QRgb.

Si position no es un par de coordenadas válido en la imagen, o si index_or_rgb >= colorCount() en el caso de imágenes monocromas y con paleta, el resultado es indefinido.

Véase también pixel() y Pixel Manipulation.

void QImage::setPixel(int x, int y, uint index_or_rgb)

Establece el índice de píxel o color en (x, y) a index_or_rgb.

void QImage::setPixelColor(const QPoint &position, const QColor &color)

Establece el color en el position dado a color.

Si position no es un par de coordenadas válido en la imagen, o el formato de la imagen es monocromo o paleta, el resultado es indefinido.

Véase también pixelColor(), pixel(), bits(), scanLine(), y Pixel Manipulation.

void QImage::setPixelColor(int x, int y, const QColor &color)

Establece el color del píxel en (x, y) a color.

void QImage::setText(const QString &key, const QString &text)

Establece el texto de la imagen en la dirección text y lo asocia a la dirección key.

Si sólo quieres almacenar un bloque de texto (por ejemplo, un "comentario" o sólo una descripción), puedes pasar una clave vacía o utilizar una clave genérica como "Descripción".

El texto de la imagen se incrusta en los datos de la imagen cuando se llama a save() o QImageWriter::write().

No todos los formatos de imagen admiten texto incrustado. Puede averiguar si una imagen o formato específico admite texto incrustado utilizando QImageWriter::supportsOption(). Damos un ejemplo:

    QImageWriter writer; writer.setFormat("png"); if (writer.supportsOption(QImageIOHandler::Descripción))        qDebug() << "Png supports embedded text";

Puede utilizar QImageWriter::supportedImageFormats() para averiguar qué formatos de imagen están a su disposición.

Véase también text() y textKeys().

QSize QImage::size() const

Devuelve el tamaño de la imagen, es decir, sus width() y height().

Véase también Image Information y deviceIndependentSize().

qsizetype QImage::sizeInBytes() const

Devuelve el tamaño de los datos de la imagen en bytes.

Véase también bytesPerLine(), bits() y Image Information.

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

Intercambia esta imagen con other. Esta operación es muy rápida y nunca falla.

QString QImage::text(const QString &key = QString()) const

Devuelve el texto de la imagen asociado a la dirección key. Si el key especificado es una cadena vacía, se devuelve todo el texto de la imagen, con cada par clave-texto separado por una nueva línea.

Véase también setText() y textKeys().

QStringList QImage::textKeys() const

Devuelve las claves de texto de esta imagen.

Puede utilizar estas claves con text() para listar el texto de la imagen para una clave determinada.

Véase también text().

CGImageRef QImage::toCGImage() const

Crea un CGImage equivalente a este QImage, y devuelve un CGImageRef handle.

El CGImageRef devuelto participa en la compartición implícita de QImage y contiene una referencia a los datos de QImage. CGImage es inmutable y nunca desprenderá el QImage. La escritura en el QImage desprenderá como de costumbre.

Esta función es rápida y no copia ni convierte datos de imagen.

Si el formato de la imagen no se puede convertir, se devolverá un CGImageRef nulo. Los usuarios de esta función pueden convertir primero QImage a un formato compatible, por ejemplo Format_ARGB32_Premultiplied.

Si la imagen no tiene un espacio de color establecido, el espacio de color resultante de CGImageRef se establece en el espacio de color sRGB.

[since 6.0] HBITMAP QImage::toHBITMAP() const

Crea un HBITMAP equivalente al QImage.

Devuelve el "handle" de HBITMAP.

Es responsabilidad de quien llama liberar los datos de HBITMAP después de su uso.

Para su uso con llamadas GDI estándar, como BitBlt(), la imagen debe tener el formato QImage::Format_RGB32.

Al utilizar el HBITMAP resultante para la función GDI AlphaBlend(), la imagen debe tener el formato QImage::Format_ARGB32_Premultiplied (utilice convertToFormat()).

Cuando se utiliza el HBITMAP resultante como icono de aplicación o icono de bandeja del sistema, la imagen debe tener el formato QImage::Format_ARGB32.

Esta función se introdujo en Qt 6.0.

Véase también fromHBITMAP() y convertToFormat().

[since 6.0] HICON QImage::toHICON(const QImage &mask = {}) const

Crea un HICON equivalente al QPixmap, aplicando la máscara mask.

Si mask no es nulo, debe tener el formato QImage::Format_Mono. Devuelve el manejador HICON.

Es responsabilidad de quien llama liberar los datos de HICON después de su uso.

Esta función se introdujo en Qt 6.0.

Véase también fromHICON().

[static noexcept] QImage::Format QImage::toImageFormat(QPixelFormat format)

Convierte format en un QImage::Format

[static noexcept] QPixelFormat QImage::toPixelFormat(QImage::Format format)

Convierte format en un QPixelFormat

QImage QImage::transformed(const QTransform &matrix, Qt::TransformationMode mode = Qt::FastTransformation) const

Devuelve una copia de la imagen transformada utilizando la transformación matrix y la transformación mode dadas.

La imagen devuelta tendrá normalmente el mismo {Image Formats}{formato} que la imagen original. Sin embargo, una transformación compleja puede dar como resultado una imagen en la que no todos los píxeles estén cubiertos por los píxeles transformados de la imagen original. En tales casos, a esos píxeles de fondo se les asignará un valor de color transparente, y a la imagen transformada se le dará un formato con un canal alfa, aunque la imagen original no lo tuviera.

La transformación matrix se ajusta internamente para compensar la traslación no deseada; es decir, la imagen producida es la imagen más pequeña que contiene todos los puntos transformados de la imagen original. Utilice la función trueMatrix() para recuperar la matriz real utilizada para transformar una imagen.

A diferencia de la otra sobrecarga, esta función puede utilizarse para realizar transformaciones de perspectiva en imágenes.

Véase también trueMatrix() y Image Transformations.

[static] QTransform QImage::trueMatrix(const QTransform &matrix, int width, int height)

Devuelve la matriz real utilizada para transformar una imagen con los valores dados width, height y matrix.

Cuando se transforma una imagen utilizando la función transformed(), la matriz de transformación se ajusta internamente para compensar la traslación no deseada, es decir, transformed() devuelve la imagen más pequeña que contiene todos los puntos transformados de la imagen original. Esta función devuelve la matriz modificada, que mapea correctamente los puntos de la imagen original en la nueva imagen.

A diferencia de la otra sobrecarga, esta función crea matrices de transformación que pueden utilizarse para realizar transformaciones de perspectiva en las imágenes.

Véase también transformed() y Image Transformations.

bool QImage::valid(const QPoint &pos) const

Devuelve true si pos es un par de coordenadas válido dentro de la imagen; en caso contrario devuelve false.

Véase también rect() y QRect::contains().

bool QImage::valid(int x, int y) const

Devuelve true si QPoint(x, y) es un par de coordenadas válido dentro de la imagen; en caso contrario devuelve false.

int QImage::width() const

Devuelve la anchura de la imagen.

Véase también Image Information.

QImage::operator QVariant() const

Devuelve la imagen como QVariant.

bool QImage::operator!=(const QImage &image) const

Devuelve true si esta imagen y la dada image tienen contenidos diferentes; en caso contrario devuelve false.

La comparación puede ser lenta, a menos que haya alguna diferencia obvia, como anchuras diferentes, en cuyo caso la función devolverá rápidamente.

Véase también operator=().

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

Mover-asigna other a esta instancia QImage.

QImage &QImage::operator=(const QImage &image)

Asigna una copia superficial de image a esta imagen y devuelve una referencia a la misma.

Para obtener más información sobre las copias superficiales, consulte la documentación Implicit Data Sharing.

Véase también copy() y QImage().

bool QImage::operator==(const QImage &image) const

Devuelve true si esta imagen y la dada image tienen el mismo contenido; en caso contrario devuelve false.

La comparación puede ser lenta, a menos que haya alguna diferencia obvia (por ejemplo, diferente tamaño o formato), en cuyo caso la función devolverá rápidamente.

Véase también operator=().