En esta página

QImageReader Class

La clase QImageReader ofrece una interfaz independiente del formato para leer imágenes desde archivos u otros dispositivos. Más información...

Encabezado: #include <QImageReader>
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

enum ImageReaderError { FileNotFoundError, DeviceError, UnsupportedFormatError, InvalidDataError, UnknownError }

Funciones públicas

QImageReader()
QImageReader(QIODevice *device, const QByteArray &format = QByteArray())
QImageReader(const QString &fileName, const QByteArray &format = QByteArray())
~QImageReader()
bool autoDetectImageFormat() const
bool autoTransform() const
QColor backgroundColor() const
bool canRead() const
QRect clipRect() const
int currentImageNumber() const
QRect currentImageRect() const
bool decideFormatFromContent() const
QIODevice *device() const
(since 6.12) QSize effectiveSize() const
QImageReader::ImageReaderError error() const
QString errorString() const
QString fileName() const
QByteArray format() const
int imageCount() const
QImage::Format imageFormat() const
bool jumpToImage(int imageNumber)
bool jumpToNextImage()
int loopCount() const
int nextImageDelay() const
int quality() const
QImage read()
bool read(QImage *image)
QRect scaledClipRect() const
QSize scaledSize() const
void setAutoDetectImageFormat(bool enabled)
void setAutoTransform(bool enabled)
void setBackgroundColor(const QColor &color)
void setClipRect(const QRect &rect)
void setDecideFormatFromContent(bool ignored)
void setDevice(QIODevice *device)
void setFileName(const QString &fileName)
void setFormat(const QByteArray &format)
void setQuality(int quality)
void setScaledClipRect(const QRect &rect)
void setScaledSize(const QSize &size)
QSize size() const
QByteArray subType() const
QList<QByteArray> supportedSubTypes() const
bool supportsAnimation() const
bool supportsOption(QImageIOHandler::ImageOption option) const
QString text(const QString &key) const
QStringList textKeys() const
QImageIOHandler::Transformations transformation() const

Miembros públicos estáticos

(since 6.0) int allocationLimit()
QByteArray imageFormat(QIODevice *device)
QByteArray imageFormat(const QString &fileName)
QList<QByteArray> imageFormatsForMimeType(const QByteArray &mimeType)
(since 6.0) void setAllocationLimit(int mbLimit)
QList<QByteArray> supportedImageFormats()
QList<QByteArray> supportedMimeTypes()

Descripción detallada

La forma más habitual de leer imágenes es mediante los constructores de ` QImage ` y ` QPixmap`, o bien llamando a ` QImage::load()` y ` QPixmap::load()`. `QImageReader` es una clase especializada que te ofrece un mayor control a la hora de leer imágenes. Por ejemplo, puedes leer una imagen con un tamaño específico llamando a ` setScaledSize()` y puedes seleccionar un rectángulo de recorte, cargando así solo partes de la imagen, llamando a ` setClipRect()`. Dependiendo de la compatibilidad subyacente del formato de imagen, esto puede ahorrar memoria y acelerar la carga de las imágenes.

Para leer una imagen, hay que empezar por crear un objeto `QImageReader`. Pasa al constructor de `QImageReader` un nombre de archivo o un puntero de dispositivo, junto con el formato de imagen. A continuación, puede establecer varias opciones, como el rectángulo de recorte (mediante la llamada a ` setClipRect()`) y el tamaño escalado (mediante la llamada a ` setScaledSize()`). ` canRead()` devuelve la imagen si `QImageReader` puede leerla (es decir, si el formato de imagen es compatible y el dispositivo está abierto para la lectura). Llame a ` read()` para leer la imagen.

Si se produce algún error al leer la imagen, read() devolverá un QImage nulo. A continuación, puede llamar a error() para averiguar el tipo de error que se ha producido, o a errorString() para obtener una descripción legible por el usuario de lo que ha fallado.

Nota: QImageReader asume el control exclusivo sobre el archivo o dispositivo que se le haya asignado. Cualquier intento de modificar el archivo o dispositivo asignado mientras el objeto QImageReader esté activo dará lugar a resultados indefinidos.

Formatos

Llama a supportedImageFormats() para obtener una lista de los formatos que QImageReader puede leer. QImageReader admite todos los formatos de imagen integrados, además de cualquier complemento de formato de imagen que permita la lectura. Llama a supportedMimeTypes() para obtener una lista de los tipos MIME admitidos, que, por ejemplo, se pueden pasar a QFileDialog::setMimeTypeFilters().

QImageReader detecta automáticamente el formato de imagen de forma predeterminada, analizando la cadena de formato proporcionada (opcional), la extensión del nombre de archivo y el contenido del flujo de datos. Puedes activar o desactivar esta función llamando a setAutoDetectImageFormat().

Versiones de alta resolución de las imágenes

Es posible proporcionar versiones de alta resolución de las imágenes en caso de que se aplique una escala entre píxeles del dispositivo y píxeles independientes del dispositivo.

La versión de alta resolución se identifica mediante el sufijo @2x en el nombre base. La imagen leída tendrá la relación de píxeles del dispositivo establecida en un valor de 2.

Esto se puede desactivar configurando la variable de entorno QT_HIGHDPI_DISABLE_2X_IMAGE_LOADING.

Véase también QImageWriter, QImageIOHandler, QImageIOPlugin, QMimeDatabase, QColorSpace, QImage::devicePixelRatio(), QPixmap::devicePixelRatio(), QIcon, QPainter::drawPixmap() y QPainter::drawImage().

Documentación sobre los tipos de miembros

enum QImageReader::ImageReaderError

Esta enumeración describe los diferentes tipos de errores que pueden producirse al leer imágenes con QImageReader.

ConstanteValorDescripción
QImageReader::FileNotFoundError1QImageReader Se utilizó «file» con un nombre de archivo, pero no se encontró ningún archivo con ese nombre. Esto también puede ocurrir si el nombre del archivo no contenía ninguna extensión y Qt no admite el archivo con la extensión correcta.
QImageReader::DeviceError2QImageReader Se ha producido un error del dispositivo al leer la imagen. Consulta las especificaciones de tu dispositivo para obtener más detalles sobre el problema.
QImageReader::UnsupportedFormatError3Qt no admite el formato de imagen solicitado.
QImageReader::InvalidDataError4Los datos de la imagen no eran válidos y QImageReader no pudo leer la imagen a partir de ellos. Esto puede ocurrir si el archivo de imagen está dañado.
QImageReader::UnknownError0Se ha producido un error desconocido. Si obtienes este valor tras llamar a read(), lo más probable es que se deba a un error en QImageReader.

Documentación de la función miembro

QImageReader::QImageReader()

Crea un objeto QImageReader vacío. Antes de leer una imagen, llama a ` setDevice()` o a ` setFileName()`.

[explicit] QImageReader::QImageReader(QIODevice *device, const QByteArray &format = QByteArray())

Crea un objeto QImageReader con el dispositivo device y el formato de imagen format.

[explicit] QImageReader::QImageReader(const QString &fileName, const QByteArray &format = QByteArray())

Crea un objeto QImageReader con el nombre de archivo « fileName » y el formato de imagen « format ».

Véase también setFileName().

[noexcept] QImageReader::~QImageReader()

Destruye el objeto ` QImageReader `.

[static, since 6.0] int QImageReader::allocationLimit()

Devuelve el límite de asignación actual, en megabytes.

Esta función se introdujo en Qt 6.0.

Véase también setAllocationLimit().

bool QImageReader::autoDetectImageFormat() const

Devuelve ` true ` si la detección automática del formato de imagen está activada en este lector de imágenes; en caso contrario, devuelve ` false`. Por defecto, la detección automática está activada.

Véase también setAutoDetectImageFormat().

bool QImageReader::autoTransform() const

Devuelve ` true ` si el gestor de imágenes aplicará metadatos de transformación en ` read()` y ` effectiveSize()`.

Véase también setAutoTransform(), transformation(), read() y effectiveSize().

QColor QImageReader::backgroundColor() const

Devuelve el color de fondo que se utiliza al leer una imagen. Si el formato de la imagen no admite la configuración del color de fondo, se devuelve un color no válido.

Véase también setBackgroundColor() y read().

bool QImageReader::canRead() const

Devuelve ` true ` si se puede leer una imagen en el dispositivo (es decir, si el formato de la imagen es compatible y el dispositivo parece contener datos válidos); en caso contrario, devuelve ` false`.

canRead() es una función ligera que solo realiza una comprobación rápida para ver si los datos de la imagen son válidos. read() puede seguir devolviendo false incluso después de que canRead() haya devuelto true, si los datos de la imagen están dañados.

Nota: Normalmente,una consulta de ` QMimeDatabase ` es un método más adecuado que esta función para identificar archivos o datos que podrían no ser imágenes.

En el caso de las imágenes que admiten animación, canRead() devuelve false cuando se han leído todos los fotogramas.

Véase también read(), supportedImageFormats() y QMimeDatabase.

QRect QImageReader::clipRect() const

Devuelve el rectángulo de recorte (también conocido como ROI, o «región de interés») de la imagen. Si no se ha establecido ningún rectángulo de recorte, se devuelve un objeto « QRect » no válido.

Véase también setClipRect().

int QImageReader::currentImageNumber() const

En el caso de los formatos de imagen que admiten animación, esta función devuelve el número de secuencia del fotograma actual. Si el formato de imagen no admite animación, se devuelve 0.

Esta función devuelve -1 si se produce un error.

Véanse también supportsAnimation(), QImageIOHandler::currentImageNumber() y canRead().

QRect QImageReader::currentImageRect() const

En el caso de los formatos de imagen que admiten animación, esta función devuelve el rectángulo correspondiente al fotograma actual. En caso contrario, se devuelve un rectángulo nulo.

Véase también supportsAnimation() y QImageIOHandler::currentImageRect().

bool QImageReader::decideFormatFromContent() const

Devuelve si el lector de imágenes debe decidir qué complemento utilizar basándose únicamente en el contenido del flujo de datos, en lugar de en la extensión del archivo.

Véase también setDecideFormatFromContent().

QIODevice *QImageReader::device() const

Devuelve el dispositivo asignado actualmente a QImageReader, o nullptr si no se ha asignado ningún dispositivo.

Véase también setDevice().

[since 6.12] QSize QImageReader::effectiveSize() const

Devuelve el tamaño efectivo de la imagen teniendo en cuenta la transformación, sin leer realmente el contenido de la imagen.

Si el formato de imagen no admite esta característica, esta función devuelve un tamaño no válido. Todos los gestores de imágenes integrados en Qt admiten esta característica, pero los complementos de formatos de imagen personalizados no están obligados a hacerlo.

Esta función se introdujo en Qt 6.12.

Véase también setAutoTransform(), size(), QImageIOHandler::ImageOption, QImageIOHandler::option() y QImageIOHandler::supportsOption().

QImageReader::ImageReaderError QImageReader::error() const

Devuelve el tipo de error que se ha producido en último lugar.

Véase también ImageReaderError y errorString().

QString QImageReader::errorString() const

Devuelve una descripción comprensible para el usuario del último error que se ha producido.

Véase también error().

QString QImageReader::fileName() const

Si el dispositivo asignado actualmente es un ` QFile`, o si se ha llamado a ` setFileName()`, esta función devuelve el nombre del archivo desde el que lee ` QImageReader `. En caso contrario (es decir, si no se ha asignado ningún dispositivo o si el dispositivo no es un ` QFile`), se devuelve un ` QString ` vacío.

Véase también setFileName() y setDevice().

QByteArray QImageReader::format() const

Devuelve el formato que utiliza « QImageReader » para leer imágenes.

Puedes llamar a esta función después de asignar un dispositivo al lector para determinar el formato del dispositivo. Por ejemplo:

QImageReader reader("image.png");
// reader.format() == "png"

Si el lector no puede leer ninguna imagen del dispositivo (por ejemplo, porque no hay ninguna imagen o porque ya se ha leído), o si el formato no es compatible, esta función devuelve un QByteArray() vacío.

Véase también setFormat() y supportedImageFormats().

int QImageReader::imageCount() const

Para los formatos de imagen que admiten animación, esta función devuelve el número total de imágenes de la animación. Si el formato no admite animación, se devuelve 0.

Esta función devuelve -1 si se produce un error.

Véanse también supportsAnimation(), QImageIOHandler::imageCount() y canRead().

QImage::Format QImageReader::imageFormat() const

Devuelve el formato de la imagen, sin leer realmente su contenido. El formato describe el formato de imagen que devuelve QImageReader::read(), no el formato de la imagen real.

Si el formato de la imagen no admite esta característica, esta función devuelve un formato no válido.

Véanse también QImageIOHandler::ImageOption, QImageIOHandler::option() y QImageIOHandler::supportsOption().

[static] QByteArray QImageReader::imageFormat(QIODevice *device)

Si el dispositivo lo admite, esta función devuelve el formato de imagen del dispositivo device. En caso contrario, se devuelve una cadena vacía.

Véase también QImageReader::autoDetectImageFormat().

[static] QByteArray QImageReader::imageFormat(const QString &fileName)

Si es compatible, esta función devuelve el formato de imagen del archivo fileName. En caso contrario, devuelve una cadena vacía.

[static] QList<QByteArray> QImageReader::imageFormatsForMimeType(const QByteArray &mimeType)

Devuelve la lista de formatos de imagen correspondientes a mimeType.

Ten en cuenta que la instancia de QGuiApplication debe crearse antes de llamar a esta función.

Véanse también supportedImageFormats() y supportedMimeTypes().

bool QImageReader::jumpToImage(int imageNumber)

En el caso de los formatos de imagen que admiten animación, esta función salta a la imagen cuyo número de secuencia es imageNumber, devolviendo «true» si la operación se realiza con éxito o «false» si no se encuentra la imagen correspondiente.

La siguiente llamada a ` read()` intentará leer esta imagen.

Véanse también jumpToNextImage() y QImageIOHandler::jumpToImage().

bool QImageReader::jumpToNextImage()

En el caso de los formatos de imagen que admiten animación, esta función avanza un paso en la imagen actual y devuelve «true» si la operación se realiza correctamente, o «false» si no hay ninguna imagen siguiente en la animación.

La implementación por defecto llama a ` read()`, y a continuación descarta la imagen resultante, pero el gestor de imágenes puede tener una forma más eficiente de implementar esta operación.

Véanse también ` jumpToImage()` y ` QImageIOHandler::jumpToNextImage()`.

int QImageReader::loopCount() const

En el caso de los formatos de imagen que admiten animación, esta función devuelve el número de veces que debe repetirse la animación. Si esta función devuelve -1, puede significar que la animación debe repetirse indefinidamente o que se ha producido un error. Si se ha producido un error, canRead() devolverá «false».

Véanse también supportsAnimation(), QImageIOHandler::loopCount() y canRead().

int QImageReader::nextImageDelay() const

En el caso de los formatos de imagen que admiten animación, esta función devuelve el número de milisegundos que hay que esperar hasta mostrar el siguiente fotograma de la animación. Si el formato de imagen no admite animación, se devuelve 0.

Esta función devuelve -1 si se produce un error.

Véase también supportsAnimation(), QImageIOHandler::nextImageDelay() y canRead().

int QImageReader::quality() const

Devuelve la configuración de calidad del formato de imagen.

Véase también setQuality().

QImage QImageReader::read()

Lee una imagen del dispositivo. Si la operación se realiza correctamente, se devuelve la imagen leída; en caso contrario, se devuelve un objeto ` QImage ` nulo. A continuación, puedes llamar a ` error()` para averiguar el tipo de error que se ha producido, o a ` errorString()` para obtener una descripción del error en lenguaje natural.

En el caso de los formatos de imagen que admiten animación, al llamar a read() repetidamente se devolverá el siguiente fotograma. Cuando se hayan leído todos los fotogramas, se devolverá una imagen nula.

Véase también canRead(), supportedImageFormats(), supportsAnimation() y QMovie.

bool QImageReader::read(QImage *image)

Lee una imagen del dispositivo y la almacena en ` image`, que debe apuntar a un ` QImage`. Devuelve ` true ` si la operación se realiza correctamente; en caso contrario, devuelve ` false`.

Si image tiene el mismo formato y tamaño que los datos de la imagen que se va a leer, es posible que esta función no necesite asignar una nueva imagen antes de la lectura. Por este motivo, puede resultar más rápida que la otra sobrecarga de read(), que siempre crea una nueva imagen; especialmente al leer varias imágenes con el mismo formato y tamaño.

QImage icon(64, 64, QImage::Format_RGB32);
QImageReader reader("icon_64x64.bmp");
if (reader.read(&icon)) {
    // Display icon
}

En el caso de los formatos de imagen que admiten animación, al llamar a read() repetidamente se devolverá el siguiente fotograma. Cuando se hayan leído todos los fotogramas, se devolverá una imagen nula.

Esta es una función sobrecargada.

Véase también canRead(), supportedImageFormats(), supportsAnimation() y QMovie.

QRect QImageReader::scaledClipRect() const

Devuelve el rectángulo de recorte escalado de la imagen.

Véase también setScaledClipRect().

QSize QImageReader::scaledSize() const

Devuelve el tamaño escalado de la imagen.

Véase también setScaledSize().

[static, since 6.0] void QImageReader::setAllocationLimit(int mbLimit)

Establece el límite de asignación en mbLimit megabytes. Se rechazarán las imágenes que requieran una asignación de memoria QImage superior a este límite. Si mbLimit es 0, se desactivará la comprobación del tamaño de asignación.

Este límite ayuda a las aplicaciones a evitar un consumo de memoria inesperadamente elevado al cargar archivos de imagen dañados. Normalmente no es necesario modificarlo. El límite predeterminado es lo suficientemente amplio para todos los tamaños de imagen más habituales.

En tiempo de ejecución, este valor puede ser sobrescrito por la variable de entorno QT_IMAGEIO_MAXALLOC.

Nota: Los requisitos de memoria se calculan para un mínimo de 32 bits por píxel, ya que Qt suele convertir una imagen a esa profundidad cuando se utiliza en Qt GUI. Esto significa que el límite de asignación efectivo es significativamente menor que mbLimit al leer imágenes de 1 bpp y 8 bpp.

Esta función se introdujo en Qt 6.0.

Véase también allocationLimit().

void QImageReader::setAutoDetectImageFormat(bool enabled)

Si enabled es «true», la detección automática del formato de imagen está activada; en caso contrario, está desactivada. Por defecto, la detección automática está activada.

QImageReader Utiliza un método exhaustivo para detectar el formato de imagen; en primer lugar, si se pasa un nombre de archivo a ` QImageReader`, intentará detectar la extensión del archivo si el nombre de archivo proporcionado no apunta a un archivo existente, añadiendo una a una las extensiones predeterminadas compatibles al nombre de archivo proporcionado. A continuación, utiliza el siguiente método para detectar el formato de imagen:

  • En primer lugar, se consultan los complementos de imagen, basándose bien en la cadena de formato opcional, bien en el sufijo del nombre de archivo (si el dispositivo de origen es un archivo). En esta fase no se realiza ninguna detección de contenido. QImageReader elegirá el primer complemento que admita la lectura de este formato.
  • Si ningún complemento admite el formato de imagen, se comprueban los gestores integrados de Qt basándose bien en la cadena de formato opcional, bien en el sufijo del nombre de archivo.
  • Si no se encuentran complementos compatibles ni controladores integrados, se comprueba cada complemento analizando el contenido del flujo de datos.
  • Si ningún complemento puede detectar el formato de la imagen basándose en el contenido de los datos, se comprueba cada controlador de imagen integrado inspeccionando el contenido.
  • Por último, si todos los métodos anteriores fallan, « QImageReader » informará de un error al intentar leer la imagen.

Al desactivar la detección automática del formato de imagen, QImageReader solo consultará los complementos y los controladores integrados basándose en la cadena de formato (es decir, no se comprueban las extensiones de los nombres de archivo).

Véanse también autoDetectImageFormat(), QImageIOHandler::canRead() y QImageIOPlugin::capabilities().

void QImageReader::setAutoTransform(bool enabled)

Establece que a las imágenes devueltas por read() y a los tamaños devueltos por effectiveSize() se les deben aplicar automáticamente los metadatos de transformación si enabled es true.

Véase también autoTransform(), transformation(), read() y effectiveSize().

void QImageReader::setBackgroundColor(const QColor &color)

Establece el color de fondo en color. Se espera que los formatos de imagen que admiten esta operación inicialicen el fondo en color antes de leer una imagen.

Véase también backgroundColor() y read().

void QImageReader::setClipRect(const QRect &rect)

Establece el rectángulo de recorte de la imagen (también conocido como ROI, o «región de interés») en rect. Las coordenadas de rect son relativas al tamaño de la imagen sin transformar, tal y como lo devuelve la función size().

Véanse también clipRect(), setScaledSize() y setScaledClipRect().

void QImageReader::setDecideFormatFromContent(bool ignored)

Si ignored se establece en «true», el lector de imágenes ignorará los formatos o extensiones de archivo especificados y decidirá qué complemento utilizar basándose únicamente en el contenido del flujo de datos.

Al activar esta opción, se cargan todos los complementos de imagen. Cada complemento leerá los primeros bytes de los datos de la imagen y determinará si es compatible o no.

Esto también desactiva la detección automática del formato de imagen.

Véase también decideFormatFromContent().

void QImageReader::setDevice(QIODevice *device)

Establece el dispositivo de QImageReader como device. Si ya se ha establecido un dispositivo, el dispositivo anterior se elimina de QImageReader y, por lo demás, no se modifica.

Si el dispositivo aún no está abierto, QImageReader intentará abrirlo en modo ReadOnly llamando a open(). Ten en cuenta que esto no funciona con determinados dispositivos, como QProcess, QTcpSocket y QUdpSocket, en los que se requiere una lógica más compleja para abrir el dispositivo.

Véase también device() y setFileName().

void QImageReader::setFileName(const QString &fileName)

Establece el nombre de archivo de QImageReader en fileName. Internamente, QImageReader creará un objeto QFile, lo abrirá en modo ReadOnly y lo utilizará al leer imágenes.

Si fileName no incluye una extensión de archivo (por ejemplo, .png o .bmp), QImageReader recorrerá todas las extensiones compatibles hasta encontrar un archivo que coincida.

Véase también fileName(), setDevice() y supportedImageFormats().

void QImageReader::setFormat(const QByteArray &format)

Establece el formato que utilizará QImageReader al leer imágenes en format. format es una cadena de texto que no distingue entre mayúsculas y minúsculas. Ejemplo:

QImageReader reader;
reader.setFormat("png"); // same as reader.setFormat("PNG");

Puedes llamar a ` supportedImageFormats()` para obtener la lista completa de formatos que admite ` QImageReader `.

Véase también format().

void QImageReader::setQuality(int quality)

Establece la configuración de calidad del formato de imagen en « quality ».

Algunos formatos de imagen, en particular los que sufren pérdida de información, implican un equilibrio entre: a) la calidad visual de la imagen resultante, y b) el tiempo de ejecución de la decodificación. Esta función establece el nivel de dicho equilibrio para los formatos de imagen que lo admiten.

En el caso de la lectura de imágenes escaladas, el ajuste de calidad también puede influir en el nivel de equilibrio entre la calidad visual y la velocidad de ejecución del algoritmo de escalado.

El rango de valores de ` quality ` depende del formato de imagen. Por ejemplo, el formato «jpeg» admite un rango de calidad de 0 (baja calidad visual) a 100 (alta calidad visual).

Véanse también quality() y setScaledSize().

void QImageReader::setScaledClipRect(const QRect &rect)

Establece el rectángulo de recorte escalado en rect. El rectángulo de recorte escalado es el rectángulo de recorte (también conocido como ROI, o «región de interés») que se aplica una vez que se ha escalado la imagen.

Véase también scaledClipRect() y setScaledSize().

void QImageReader::setScaledSize(const QSize &size)

Establece el tamaño escalado de la imagen en size. El escalado se realiza después del rectángulo de recorte inicial, pero antes de que se aplique el rectángulo de recorte escalado. El algoritmo utilizado para el escalado depende del formato de la imagen. Por defecto (es decir, si el formato de la imagen no admite el escalado), ` QImageReader ` utilizará `QImage::scale()` con `Qt::SmoothScaling`.

Si solo se establece una dimensión en ` size`, la otra se calculará a partir de la ` natural size ` de la imagen para mantener la relación de aspecto.

Véase también scaledSize(), setClipRect() y setScaledClipRect().

QSize QImageReader::size() const

Devuelve el tamaño de la imagen sin leer realmente su contenido.

Si el formato de imagen no admite esta característica, esta función devuelve un tamaño no válido. Todos los gestores de imágenes integrados en Qt admiten esta característica, pero los complementos de formatos de imagen personalizados no están obligados a hacerlo.

Véase también effectiveSize(), QImageIOHandler::ImageOption, QImageIOHandler::option() y QImageIOHandler::supportsOption().

QByteArray QImageReader::subType() const

Devuelve el subtipo de la imagen.

[static] QList<QByteArray> QImageReader::supportedImageFormats()

Devuelve la lista de formatos de imagen compatibles con QImageReader.

Por defecto, Qt puede leer los siguientes formatos:

FormatoTipo MIMEDescripción
BMPimage/bmpMapa de bits de Windows
GIFimage/gifFormato de intercambio de gráficos (opcional)
JPGimage/jpegGrupo Conjunto de Expertos Fotográficos
PNGimage/pngGráficos de red portátiles
PBMimage/x-portable-bitmapMapa de bits portátil
PGMimage/x-portable-graymapMapa de grises portátil
PPMimage/x-portable-pixmapMapa de píxeles portátil
XBMimage/x-xbitmapMapa de píxeles X11
XPMimagen/x-xpixmapMapa de píxeles X11
SVGimage/svg+xmlGráficos vectoriales escalables

La lectura y escritura de archivos SVG se admite a través del Qt SVG módulo. El Qt Image Formats módulo ofrece compatibilidad con formatos de imagen adicionales.

Ten en cuenta que la instancia de ` QCoreApplication ` debe crearse antes de llamar a esta función.

Véase también setFormat(), QImageWriter::supportedImageFormats() y QImageIOPlugin.

[static] QList<QByteArray> QImageReader::supportedMimeTypes()

Devuelve la lista de tipos MIME compatibles con QImageReader.

Ten en cuenta que la instancia de QApplication debe crearse antes de llamar a esta función.

Véanse también supportedImageFormats() y QImageWriter::supportedMimeTypes().

QList<QByteArray> QImageReader::supportedSubTypes() const

Devuelve la lista de subtipos compatibles con una imagen.

bool QImageReader::supportsAnimation() const

Devuelve « true » si el formato de imagen admite animación; en caso contrario, devuelve «false».

Véase también QMovie::supportedFormats().

bool QImageReader::supportsOption(QImageIOHandler::ImageOption option) const

Devuelve « true » si el lector admite « option »; en caso contrario, devuelve «false».

Los distintos formatos de imagen admiten diferentes opciones. Llama a esta función para determinar si el formato actual admite una opción concreta. Por ejemplo, el formato PNG permite incrustar texto en los metadatos de la imagen (véase text()), y el formato BMP permite determinar el tamaño de la imagen sin cargarla por completo en la memoria (véase size()).

QImageReader reader(":/image.png");
if (reader.supportsOption(QImageIOHandler::Size))
    qDebug() << "Size:" << reader.size();

Véase también QImageWriter::supportsOption().

QString QImageReader::text(const QString &key) const

Devuelve el texto de la imagen asociado a « key ».

La compatibilidad con esta opción se implementa a través de ` QImageIOHandler::Description`.

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

QStringList QImageReader::textKeys() const

Devuelve las claves de texto de esta imagen. Puedes utilizar estas claves con text() para mostrar el texto de la imagen correspondiente a una clave determinada.

La compatibilidad con esta opción se implementa mediante QImageIOHandler::Description.

Véase también text(), QImageWriter::setText() y QImage::textKeys().

QImageIOHandler::Transformations QImageReader::transformation() const

Devuelve los metadatos de transformación de la imagen, incluida la orientación de la misma. Si el formato no admite metadatos de transformación, se devuelve el valor « QImageIOHandler::TransformationNone ».

Véase también setAutoTransform() y autoTransform().

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