QPixmap Class
La clase QPixmap es una representación de imagen fuera de pantalla que puede utilizarse como dispositivo de dibujo. Más información...
| Encabezado: | #include <QPixmap> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS Gui) target_link_libraries(mytarget PRIVATE Qt6::Gui) |
| qmake: | QT += gui |
| Heredado de: | QPaintDevice |
| Heredado por: |
- Lista de todos los miembros, incluidos los heredados
- QPixmap forma parte de las clases de pintura y de las clases compartidas implícitamente.
Funciones públicas
| QPixmap() | |
| QPixmap(const char *const[] xpm) | |
| QPixmap(int width, int height) | |
| QPixmap(const QString &fileName, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor) | |
| QPixmap(const QSize &size) | |
| QPixmap(const QPixmap &pixmap) | |
| QPixmap(QPixmap &&other) | |
| virtual | ~QPixmap() |
| qint64 | cacheKey() const |
| bool | convertFromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor) |
| QPixmap | copy(const QRect &rectangle = QRect()) const |
| QPixmap | copy(int x, int y, int width, int height) const |
| QBitmap | createHeuristicMask(bool clipTight = true) const |
| QBitmap | createMaskFromColor(const QColor &maskColor, Qt::MaskMode mode = Qt::MaskInColor) const |
| int | depth() const |
| void | detach() |
(since 6.2) QSizeF | deviceIndependentSize() const |
| qreal | devicePixelRatio() const |
| void | fill(const QColor &color = Qt::white) |
| bool | hasAlpha() const |
| bool | hasAlphaChannel() const |
| int | height() const |
| bool | isNull() const |
| bool | isQBitmap() const |
| bool | load(const QString &fileName, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor) |
| bool | loadFromData(const uchar *data, uint len, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor) |
| bool | loadFromData(const QByteArray &data, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor) |
| QBitmap | mask() const |
| QRect | rect() const |
| bool | save(const QString &fileName, const char *format = nullptr, int quality = -1) const |
| bool | save(QIODevice *device, const char *format = nullptr, int quality = -1) const |
| QPixmap | scaled(const QSize &size, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const |
| QPixmap | scaled(int width, int height, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const |
| QPixmap | scaledToHeight(int height, Qt::TransformationMode mode = Qt::FastTransformation) const |
| QPixmap | scaledToWidth(int width, Qt::TransformationMode mode = Qt::FastTransformation) const |
| void | scroll(int dx, int dy, const QRect &rect, QRegion *exposed = nullptr) |
| void | scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed = nullptr) |
| void | setDevicePixelRatio(qreal scaleFactor) |
| void | setMask(const QBitmap &mask) |
| QSize | size() const |
| void | swap(QPixmap &other) |
| QImage | toImage() const |
| QPixmap | transformed(const QTransform &transform, Qt::TransformationMode mode = Qt::FastTransformation) const |
| int | width() const |
| operator QVariant() const | |
| bool | operator!() const |
| QPixmap & | operator=(QPixmap &&other) |
| QPixmap & | operator=(const QPixmap &pixmap) |
Miembros públicos estáticos
| int | defaultDepth() |
| QPixmap | fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor) |
| QPixmap | fromImage(QImage &&image, Qt::ImageConversionFlags flags = Qt::AutoColor) |
| QPixmap | fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags = Qt::AutoColor) |
| QTransform | trueMatrix(const QTransform &matrix, int width, int height) |
Elementos no miembros relacionados
| QDataStream & | operator<<(QDataStream &stream, const QPixmap &pixmap) |
| QDataStream & | operator>>(QDataStream &stream, QPixmap &pixmap) |
Descripción detallada
Qt proporciona cuatro clases para gestionar datos de imagen: « QImage », «QPixmap», « QBitmap » y « QPicture ». « QImage » está diseñada y optimizada para E/S, así como para el acceso directo a píxeles y su manipulación, mientras que «QPixmap» está diseñada y optimizada para mostrar imágenes en pantalla. « QBitmap » es únicamente una clase de conveniencia que hereda de «QPixmap», garantizando una profundidad de 1. La función isQBitmap() devuelve true si un objeto QPixmap es realmente un mapa de bits; en caso contrario, devuelve false. Por último, la clase QPicture es un dispositivo de dibujo que graba y reproduce comandos de QPainter.
Un QPixmap se puede mostrar fácilmente en pantalla utilizando QLabel o una de las subclases de QAbstractButton(como QPushButton y QToolButton). QLabel tiene una propiedad «pixmap», mientras que QAbstractButton tiene una propiedad «icon».
Los objetos `QPixmap` pueden pasarse por valor, ya que la clase `QPixmap` utiliza el intercambio implícito de datos. Para obtener más información, consulta la documentación sobre el intercambio implícito de datos. Los objetos `QPixmap` también pueden transmitirse mediante un flujo.
Tenga en cuenta que los datos de píxeles de un mapa de píxeles son internos y los gestiona el sistema de ventanas subyacente. Dado que QPixmap es una subclase de ` QPaintDevice `, se puede utilizar ` QPainter ` para dibujar directamente sobre los mapas de píxeles. Solo se puede acceder a los píxeles a través de las funciones de « QPainter » o convirtiendo el QPixmap en un « QImage ». Sin embargo, la función « fill()» está disponible para inicializar todo el mapa de píxeles con un color determinado.
Existen funciones para convertir entre ` QImage ` y `QPixmap`. Normalmente, la clase ` QImage ` se utiliza para cargar un archivo de imagen, manipulando opcionalmente los datos de la imagen, antes de que el objeto ` QImage ` se convierta en un `QPixmap` para mostrarse en pantalla. Alternativamente, si no se desea realizar ninguna manipulación, el archivo de imagen se puede cargar directamente en un `QPixmap`.
QPixmap proporciona un conjunto de funciones que pueden utilizarse para obtener diversa información sobre el mapa de píxeles. Además, existen varias funciones que permiten transformar el mapa de píxeles.
Lectura y escritura de archivos de imagen
QPixmap ofrece varias formas de leer un archivo de imagen: el archivo se puede cargar al crear el objeto QPixmap o utilizando posteriormente las funciones ` load()` o ` loadFromData()`. Al cargar una imagen, el nombre del archivo puede hacer referencia a un archivo real en el disco o a uno de los recursos incrustados de la aplicación. Consulta la descripción general del sistema de recursos de Qt para obtener más detalles sobre cómo integrar imágenes y otros archivos de recursos en el ejecutable de la aplicación.
Basta con llamar a la función save() para guardar un objeto QPixmap.
La lista completa de formatos de archivo compatibles está disponible a través de las funciones QImageReader::supportedImageFormats() y QImageWriter::supportedImageFormats(). Se pueden añadir nuevos formatos de archivo como complementos. Por defecto, Qt admite los siguientes formatos:
| Formato | Descripción | Compatibilidad de Qt |
|---|---|---|
| BMP | Mapa de bits de Windows | Lectura/escritura |
| CUR | Cursor de Windows | Lectura/escritura |
| GIF | Formato de intercambio de gráficos | Lectura |
| ICO | Icono de Windows | Lectura/escritura |
| JFIF | Formato de intercambio de archivos JPEG | Lectura/escritura |
| JPEG | Grupo Conjunto de Expertos Fotográficos | Lectura/escritura |
| JPG | Grupo Conjunto de Expertos Fotográficos | Lectura/escritura |
| PBM | Mapa de bits portátil | Lectura/escritura |
| PGM | Mapa de grises portátil | Lectura/escritura |
| PNG | Gráficos de red portátiles | Lectura/escritura |
| PPM | Mapa de píxeles portátil | Lectura/escritura |
| SVG | Gráficos vectoriales escalables | Lectura |
| SVGZ | Gráficos vectoriales escalables (comprimidos) | Leer |
| XBM | Mapa de bits X11 | Lectura/escritura |
| XPM | Mapa de píxeles X11 | Lectura/escritura |
Se admiten otros formatos si está instalado el Qt Image Formats módulo está instalado.
Información sobre el mapa de píxeles
QPixmap ofrece un conjunto de funciones que se pueden utilizar para obtener diversa información sobre el mapa de píxeles:
| Funciones disponibles | |
|---|---|
| Geometría | Las funciones ` size()`, ` width()` y ` height()` proporcionan información sobre el tamaño del mapa de píxeles. La función ` rect()` devuelve el rectángulo que enmarca la imagen. |
| Componente alfa | La función hasAlphaChannel() devuelve true si el mapa de píxeles tiene un formato que respeta el canal alfa; en caso contrario, devuelve false. Las funciones hasAlpha(), setMask() y mask() son obsoletas y no deben utilizarse. Pueden resultar muy lentas.La función createHeuristicMask() crea y devuelve una máscara heurística de 1 bpp (es decir, un QBitmap) para este mapa de píxeles. Funciona seleccionando un color de una de las esquinas y, a continuación, eliminando los píxeles de ese color, comenzando por todos los bordes. La función createMaskFromColor() crea y devuelve una máscara (es decir, un QBitmap) para el mapa de píxeles basada en un color dado. |
| Información de bajo nivel | La función depth() devuelve la profundidad del mapa de píxeles. La función defaultDepth() devuelve la profundidad por defecto, es decir, la profundidad utilizada por la aplicación en la pantalla dada. La función cacheKey() devuelve un número que identifica de forma única el contenido del objeto QPixmap. |
Conversión de mapas de píxeles
Un objeto `QPixmap` se puede convertir en un ` QImage ` utilizando la función ` toImage()`. Del mismo modo, un ` QImage ` se puede convertir en un `QPixmap` utilizando la función ` fromImage()`. Si esta operación resulta demasiado costosa, puedes utilizar en su lugar ` QBitmap::fromImage()`.
Para convertir un QPixmap a HICON y viceversa, puedes utilizar las funciones QImage::toHICON() y QImage::fromHICON(), respectivamente (tras convertir el QPixmap a un QImage, tal y como se ha explicado anteriormente).
Transformaciones de mapas de píxeles
QPixmap admite varias funciones para crear un nuevo mapa de píxeles que sea una versión transformada del original:
Las funciones scaled(), scaledToWidth() y scaledToHeight() devuelven copias escaladas del mapa de píxeles, mientras que la función copy() crea un QPixmap que es una copia simple del original.
La función transformed() devuelve una copia del mapa de píxeles transformada con la matriz de transformación y el modo de transformación indicados: internamente, la matriz de transformación se ajusta para compensar cualquier traslación no deseada; es decir, transformed() devuelve el mapa de píxeles más pequeño que contiene todos los puntos transformados del mapa de píxeles original. La función estática trueMatrix() devuelve la matriz real utilizada para transformar el mapa de píxeles.
Véase también QBitmap, QImage, QImageReader y QImageWriter.
Documentación de las funciones de miembro
QPixmap::QPixmap()
Crea un mapa de píxeles nulo.
Véase también isNull().
[explicit] QPixmap::QPixmap(const char *const[] xpm)
Crea un mapa de píxeles a partir de los datos proporcionados en ` xpm `, que deben ser una imagen XPM válida.
Los errores se ignoran sin avisar.
Ten en cuenta que es posible reducir ligeramente el tamaño de la variable XPM utilizando una declaración poco habitual:
static const char * const start_xpm[] = {
"16 15 8 1",
"a c #cec6bd",
// etc.
};El « const » adicional hace que toda la definición sea de solo lectura, lo cual resulta ligeramente más eficiente (por ejemplo, cuando el código se encuentra en una biblioteca compartida) y permite su almacenamiento en ROM cuando la aplicación se va a guardar en ROM.
QPixmap::QPixmap(int width, int height)
Crea un mapa de píxeles con los valores proporcionados en ` width ` y ` height`. Si ` width ` o ` height ` es cero, se crea un mapa de píxeles nulo.
Advertencia: Esto creará un QPixmap con datos no inicializados. Llama a fill() para rellenar el mapa de píxeles con un color adecuado antes de dibujar en él con QPainter.
Véase también ` isNull()`.
QPixmap::QPixmap(const QString &fileName, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor)
Crea un mapa de píxeles a partir del archivo con el « fileName » especificado. Si el archivo no existe o tiene un formato desconocido, el mapa de píxeles se convierte en un mapa de píxeles nulo.
El cargador intenta leer el mapa de píxeles utilizando el « format » especificado. Si no se especifica el « format » (que es el valor por defecto), el cargador busca en el archivo un encabezado para deducir el formato del mismo.
El nombre del archivo puede referirse a un archivo real en el disco o a uno de los recursos incrustados en la aplicación. Consulta la descripción general del sistema de recursos para obtener más detalles sobre cómo incrustar imágenes y otros archivos de recursos en el ejecutable de la aplicación.
Si es necesario modificar la imagen para adaptarla a un resultado de menor resolución (por ejemplo, convertir de 32 bits a 8 bits), utiliza el parámetro « flags » para controlar la conversión.
Los parámetros « fileName », « format » y « flags » se pasan a la función « load()». Esto significa que los datos de « fileName » no se compilan en el binario. Si « fileName » contiene una ruta relativa (por ejemplo, solo el nombre del archivo), el archivo correspondiente debe encontrarse en relación con el directorio de trabajo en tiempo de ejecución.
Véase también Reading and Writing Image Files.
[explicit] QPixmap::QPixmap(const QSize &size)
Crea un mapa de píxeles a partir del ` size` especificado.
Advertencia: Esto creará un QPixmap con datos no inicializados. Llama a fill() para rellenar el mapa de píxeles con un color adecuado antes de dibujar sobre él con QPainter.
Esta es una función sobrecargada.
QPixmap::QPixmap(const QPixmap &pixmap)
Crea un mapa de píxeles que es una copia del archivo pixmap proporcionado.
Véase también copy().
[noexcept] QPixmap::QPixmap(QPixmap &&other)
Crea una instancia de QPixmap a partir de other.
Véase también swap() y operator=(QPixmap&&).
[virtual noexcept] QPixmap::~QPixmap()
Elimina el mapa de píxeles.
qint64 QPixmap::cacheKey() const
Devuelve un número que identifica este objeto ` QPixmap`. Los distintos objetos ` QPixmap ` solo pueden tener la misma clave de caché si hacen referencia al mismo contenido.
La clave de caché (cacheKey()) cambiará cuando se modifique el mapa de píxeles.
bool QPixmap::convertFromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor)
Sustituye los datos de este mapa de píxeles por el « image » proporcionado, utilizando el « flags » especificado para controlar la conversión. El argumento « flags » es un OR bit a bit de « Qt::ImageConversionFlags ». Si se pasa 0 como « flags », se establecen todas las opciones predeterminadas. Devuelve « true » si el resultado es que este mapa de píxeles no es nulo.
Véase también fromImage().
QPixmap QPixmap::copy(const QRect &rectangle = QRect()) const
Devuelve una copia profunda del subconjunto del mapa de píxeles especificado por el ` rectangle` proporcionado. Para obtener más información sobre las copias profundas, consulta la documentación sobre «Compartición implícita de datos ».
Si el ` rectangle ` proporcionado está vacío, se copia la imagen completa.
Véanse también operator=(), QPixmap() y Pixmap Transformations.
QPixmap QPixmap::copy(int x, int y, int width, int height) const
Devuelve una copia profunda del subconjunto del mapa de píxeles especificado por el rectángulo QRect( x, y, width, height).
Se trata de una función sobrecargada.
QBitmap QPixmap::createHeuristicMask(bool clipTight = true) const
Crea y devuelve una máscara heurística para este mapa de píxeles.
La función funciona seleccionando un color de una de las esquinas y, a continuación, eliminando píxeles de ese color, empezando por todos los bordes. Si ` clipTight ` es verdadero (el valor por defecto), la máscara tiene el tamaño justo para cubrir los píxeles; en caso contrario, la máscara es más grande que los píxeles de datos.
Es posible que la máscara no sea perfecta, pero debería ser razonable, por lo que se pueden realizar operaciones como las siguientes:
QPixmap myPixmap;
myPixmap.setMask(myPixmap.createHeuristicMask());Esta función es lenta porque implica la conversión a/desde un ` QImage`, así como cálculos no triviales.
Véanse también QImage::createHeuristicMask() y createMaskFromColor().
QBitmap QPixmap::createMaskFromColor(const QColor &maskColor, Qt::MaskMode mode = Qt::MaskInColor) const
Crea y devuelve una máscara para este mapa de píxeles basada en el valor dado maskColor. Si el valor mode es Qt::MaskInColor, todos los píxeles que coincidan con el color de la máscara serán transparentes. Si el valor mode es Qt::MaskOutColor, todos los píxeles que coincidan con el color de la máscara serán opacos.
Esta función es lenta porque implica la conversión hacia y desde un ` QImage`.
Véase también createHeuristicMask() y QImage::createMaskFromColor().
[static] int QPixmap::defaultDepth()
Devuelve la profundidad predeterminada del mapa de píxeles que utiliza la aplicación.
En todas las plataformas se devolverá la profundidad de la pantalla principal.
Nota: Se debe crear` QGuiApplication ` antes de llamar a esta función.
Véase también depth() y Pixmap Information.
int QPixmap::depth() const
Devuelve la profundidad del mapa de píxeles.
La profundidad del mapa de píxeles también se denomina «bits por píxel» (bpp) o «planos de bits» de un mapa de píxeles. Un mapa de píxeles nulo tiene una profundidad de 0.
Véase también defaultDepth() y Pixmap Information.
void QPixmap::detach()
Desvincula el mapa de píxeles de los datos compartidos del mapa de píxeles.
Qt desvincula automáticamente un mapa de píxeles cada vez que su contenido está a punto de cambiar. Esto se lleva a cabo en casi todas las funciones miembro de ` QPixmap ` que modifican el mapa de píxeles (fill(), fromImage(), load(), etc.), así como en ` QPainter::begin()` sobre un mapa de píxeles.
Hay dos excepciones en las que se debe llamar explícitamente a detach(), a saber, al llamar a la función handle() o a x11PictureHandle() (disponible únicamente en X11). En cualquier otro caso, cualquier modificación realizada mediante llamadas al sistema se llevará a cabo sobre los datos compartidos.
La función detach() devuelve el control inmediatamente si solo hay una referencia o si el mapa de píxeles aún no se ha inicializado.
[since 6.2] QSizeF QPixmap::deviceIndependentSize() const
Devuelve el tamaño del mapa de píxeles en píxeles independientes del dispositivo.
Este valor debe utilizarse cuando se emplee el tamaño del mapa de píxeles en los cálculos del tamaño de la interfaz de usuario.
El valor devuelto es equivalente a pixmap.size() / pixmap.devicePixelRatio().
Esta función se introdujo en Qt 6.2.
qreal QPixmap::devicePixelRatio() const
Devuelve la relación de píxeles del dispositivo para el mapa de píxeles. Se trata de la relación entre los píxeles del dispositivo y los píxeles independientes del dispositivo.
Utiliza esta función al calcular la geometría del diseño en función del tamaño del mapa de píxeles: ` QSize layoutSize = image.size() / image.devicePixelRatio()`
El valor predeterminado es 1,0.
Véase también setDevicePixelRatio() y QImageReader.
void QPixmap::fill(const QColor &color = Qt::white)
Rellena el mapa de píxeles con el valor dado en ` color`.
El efecto de esta función es indefinido cuando se está pintando sobre el mapa de píxeles.
Véase también Pixmap Transformations.
[static] QPixmap QPixmap::fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor)
Convierte el « image » proporcionado en un mapa de píxeles utilizando el « flags » especificado para controlar la conversión. El argumento « flags » es un OR bit a bit de « Qt::ImageConversionFlags ». Si se pasa un 0 en « flags », se establecen todas las opciones por defecto.
En el caso de imágenes monocromáticas y de 8 bits, la imagen se convierte primero a un mapa de píxeles de 32 bits y, a continuación, se rellena con los colores de la tabla de colores. Si esta operación resulta demasiado costosa, puedes utilizar en su lugar QBitmap::fromImage().
Véase también fromImageReader(), toImage() y Pixmap Conversion.
[static] QPixmap QPixmap::fromImage(QImage &&image, Qt::ImageConversionFlags flags = Qt::AutoColor)
Convierte el objeto ` image ` proporcionado en un mapa de píxeles sin copiarlo, si es posible.
Esta es una función sobrecargada.
[static] QPixmap QPixmap::fromImageReader(QImageReader *imageReader, Qt::ImageConversionFlags flags = Qt::AutoColor)
Crea un objeto ` QPixmap ` a partir de una imagen leída directamente desde un objeto ` imageReader`. El argumento ` flags ` es un OR bit a bit de ` Qt::ImageConversionFlags`. Si se pasa un 0 en ` flags `, se establecen todas las opciones predeterminadas.
En algunos sistemas, leer una imagen directamente en QPixmap puede consumir menos memoria que leer un QImage para convertirla a QPixmap.
Véase también fromImage(), toImage() y Pixmap Conversion.
bool QPixmap::hasAlpha() const
Devuelve ` true ` si este mapa de píxeles tiene un canal alfa o una máscara; en caso contrario, devuelve ` false`.
Véase también hasAlphaChannel() y mask().
bool QPixmap::hasAlphaChannel() const
Devuelve ` true ` si el mapa de píxeles tiene un formato que respeta el canal alfa; en caso contrario, devuelve ` false`.
Véase también hasAlpha().
int QPixmap::height() const
Devuelve la altura del mapa de píxeles.
Véase también size() y Pixmap Information.
bool QPixmap::isNull() const
Devuelve ` true ` si se trata de un mapa de píxeles nulo; en caso contrario, devuelve ` false`.
Un mapa de píxeles nulo tiene anchura y altura cero y carece de contenido. No se puede dibujar en un mapa de píxeles nulo.
bool QPixmap::isQBitmap() const
Devuelve « true » si se trata de un « QBitmap »; en caso contrario, devuelve « false ».
bool QPixmap::load(const QString &fileName, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor)
Carga un mapa de píxeles desde el archivo con la ruta especificada ` fileName`. Devuelve `true` si el mapa de píxeles se ha cargado correctamente; en caso contrario, invalida el mapa de píxeles y devuelve ` false`.
El cargador intenta leer el mapa de píxeles utilizando el ` format` especificado. Si no se especifica el ` format ` (que es el valor por defecto), el cargador busca en el archivo un encabezado para deducir el formato del mismo.
El nombre del archivo puede hacer referencia a un archivo real en el 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 detalles sobre cómo incrustar mapas de píxeles y otros archivos de recursos en el ejecutable de la aplicación.
Si es necesario modificar los datos para adaptarlos a un resultado de menor resolución (por ejemplo, convertir de 32 bits a 8 bits), utiliza la clase « flags » para controlar la conversión.
Tenga en cuenta que los QPixmaps se añaden automáticamente a la lista de recursos « QPixmapCache » cuando se cargan desde un archivo en el hilo principal; la clave utilizada es interna y no se puede obtener.
Véase también loadFromData() y Reading and Writing Image Files.
bool QPixmap::loadFromData(const uchar *data, uint len, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor)
Carga un mapa de píxeles a partir de los primeros bytes de la dirección len del archivo binario data. Devuelve true si el mapa de píxeles se ha cargado correctamente; en caso contrario, invalida el mapa de píxeles y devuelve false.
El cargador intenta leer el mapa de píxeles utilizando el format especificado. Si no se especifica el format (que es el valor por defecto), el cargador busca en el archivo una cabecera para adivinar el formato del mismo.
Si es necesario modificar los datos para adaptarlos a un resultado de menor resolución (por ejemplo, al convertir de 32 bits a 8 bits), utilice el parámetro « flags » para controlar la conversión.
Véanse también load() y Reading and Writing Image Files.
bool QPixmap::loadFromData(const QByteArray &data, const char *format = nullptr, Qt::ImageConversionFlags flags = Qt::AutoColor)
Carga un mapa de píxeles a partir del archivo binario data utilizando el format y el flags especificados.
Esta es una función sobrecargada.
QBitmap QPixmap::mask() const
Extrae una máscara de mapa de bits del canal alfa del mapa de píxeles.
Advertencia: Esta operación puede resultar costosa. La máscara del mapa de píxeles se extrae dinámicamente a partir de los datos de píxeles.
Véase también setMask() y Pixmap Information.
QRect QPixmap::rect() const
Devuelve el rectángulo que enmarca el mapa de píxeles.
Véase también ` Pixmap Information`.
bool QPixmap::save(const QString &fileName, const char *format = nullptr, int quality = -1) const
Guarda el mapa de píxeles en el archivo con el nombre « fileName » utilizando el nombre de archivo de imagen especificado « format » y el factor « quality ». Devuelve « true » si se realiza correctamente; en caso contrario, devuelve « false ».
El factor quality debe estar comprendido en el intervalo [0,100] o ser -1. Especifique 0 para obtener archivos comprimidos pequeños, 100 para archivos sin comprimir grandes y -1 para utilizar la configuración predeterminada.
Si format es nullptr, se elegirá un formato de imagen a partir del sufijo de fileName.
Véase también Reading and Writing Image Files.
bool QPixmap::save(QIODevice *device, const char *format = nullptr, int quality = -1) const
Esta función escribe un « QPixmap » en el « device » indicado utilizando el archivo de imagen especificado « format » y el factor « quality ». Esto se puede utilizar, por ejemplo, para guardar un «pixmap» directamente en un « QByteArray »:
QPixmap pixmap;
QByteArray bytes;
QBuffer buffer(&bytes);
buffer.open(QIODevice::WriteOnly);
pixmap.save(&buffer, "PNG"); // writes pixmap into bytes in PNG formatSe trata de una función sobrecargada.
QPixmap QPixmap::scaled(const QSize &size, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const
Escala el mapa de píxeles al tamaño especificado en size, utilizando la relación de aspecto y los modos de transformación especificados en aspectRatioMode y transformMode.

- Si aspectRatioMode es Qt::IgnoreAspectRatio, el mapa de píxeles se escala a size.
- Si aspectRatioMode es Qt::KeepAspectRatio, el mapa de píxeles se escala a un rectángulo lo más grande posible dentro de size, conservando la relación de aspecto.
- Si aspectRatioMode es Qt::KeepAspectRatioByExpanding, el mapa de píxeles se escala a un rectángulo lo más pequeño posible fuera de size, conservando la relación de aspecto.
Si el ` size ` proporcionado está vacío, esta función devuelve un mapa de píxeles nulo.
En algunos casos, puede resultar más ventajoso dibujar el mapa de píxeles en un «painter» con una escala preestablecida, en lugar de escalar el mapa de píxeles. Este es el caso, por ejemplo, cuando el «painter» se basa en OpenGL o cuando el factor de escala cambia rápidamente.
Véase también isNull() y Pixmap Transformations.
QPixmap QPixmap::scaled(int width, int height, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio, Qt::TransformationMode transformMode = Qt::FastTransformation) const
Devuelve una copia del mapa de píxeles escalada a un rectángulo con los valores de « width » y « height » especificados, de acuerdo con los valores de « aspectRatioMode » y « transformMode » indicados.
Si width o height es cero o negativo, esta función devuelve un mapa de píxeles nulo.
Esta es una función sobrecargada.
QPixmap QPixmap::scaledToHeight(int height, Qt::TransformationMode mode = Qt::FastTransformation) const
Devuelve una copia escalada de la imagen. La imagen devuelta se escala a la resolución height indicada utilizando la transformación especificada mode. El ancho del mapa de píxeles se calcula automáticamente para que se mantenga la relación de aspecto del mismo.
Si height es 0 o un valor negativo, se devuelve un mapa de píxeles nulo.
Véase también isNull() y Pixmap Transformations.
QPixmap QPixmap::scaledToWidth(int width, Qt::TransformationMode mode = Qt::FastTransformation) const
Devuelve una copia escalada de la imagen. La imagen devuelta se escala a la resolución dada ` width ` utilizando la transformación especificada ` mode`. La altura del mapa de píxeles se calcula automáticamente de modo que se conserve la relación de aspecto del mismo.
Si width es 0 o un valor negativo, se devuelve un mapa de píxeles nulo.
Véase también isNull() y Pixmap Transformations.
void QPixmap::scroll(int dx, int dy, const QRect &rect, QRegion *exposed = nullptr)
Desplaza el área rect de este mapa de píxeles en (dx, dy). La región expuesta permanece inalterada. Opcionalmente, puedes pasar un puntero a un QRegion vacío para obtener la región que queda exposed por la operación de desplazamiento.
No se puede desplazar mientras haya un pintor activo en el mapa de píxeles.
Véanse también QWidget::scroll() y QGraphicsItem::scroll().
void QPixmap::scroll(int dx, int dy, int x, int y, int width, int height, QRegion *exposed = nullptr)
Esta función de conveniencia equivale a llamar a QPixmap::scroll(dx, dy, QRect(x, y, width, height), exposed).
Véase también QWidget::scroll() y QGraphicsItem::scroll().
void QPixmap::setDevicePixelRatio(qreal scaleFactor)
Establece la relación de píxeles del dispositivo para el mapa de píxeles. Se trata de la relación entre los píxeles de la imagen y los píxeles independientes del dispositivo.
El valor predeterminado de « scaleFactor » es 1,0. Establecerlo en otro valor tiene dos efectos:
Los QPainters que se abran en el mapa de píxeles se escalarán. Por ejemplo, pintar en una imagen de 200x200 con una relación de 2,0 dará como resultado 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 del mapa de píxeles tendrán en cuenta la relación: QSize layoutSize = pixmap.size() / pixmap.devicePixelRatio() El efecto neto de esto es que el mapa de píxeles se muestra como un mapa de píxeles de alta resolución (DPI) en lugar de como un mapa de píxeles de gran tamaño (véase Drawing High Resolution Versions of Pixmaps and Images).
Véanse también devicePixelRatio() y deviceIndependentSize().
void QPixmap::setMask(const QBitmap &mask)
Establece un mapa de bits de máscara.
Esta función fusiona el mapa de píxeles « mask » con el canal alfa del mapa de píxeles. Un valor de píxel igual a 1 en la máscara significa que el píxel del mapa de píxeles no se modifica; un valor de 0 significa que el píxel es transparente. La máscara debe tener el mismo tamaño que este mapa de píxeles.
Establecer una máscara nula restablece la máscara, dejando negros los píxeles que antes eran transparentes. El efecto de esta función es indefinido cuando se está pintando sobre el mapa de píxeles.
Advertencia: Esta operación puede resultar costosa.
Véase también mask(), Pixmap Transformations y QBitmap.
QSize QPixmap::size() const
Devuelve el tamaño del mapa de píxeles.
Véase también width(), height() y Pixmap Information.
[noexcept] void QPixmap::swap(QPixmap &other)
Intercambia este mapa de píxeles por other. Esta operación es muy rápida y nunca falla.
QImage QPixmap::toImage() const
Convierte el mapa de píxeles en un objeto ` QImage`. Devuelve una imagen nula si la conversión falla.
Si el mapa de píxeles tiene una profundidad de 1 bit, la imagen devuelta también tendrá una profundidad de 1 bit. Las imágenes con más bits se devolverán en un formato que se aproxime lo más posible al del sistema subyacente. Normalmente, será un « QImage::Format_ARGB32_Premultiplied » para los mapas de píxeles con canal alfa, y « QImage::Format_RGB32 » o « QImage::Format_RGB16 » para los mapas de píxeles sin canal alfa.
Ten en cuenta que, por el momento, se ignoran las máscaras alfa en las imágenes monocromáticas.
Véanse también fromImage() y Image Formats.
QPixmap QPixmap::transformed(const QTransform &transform, Qt::TransformationMode mode = Qt::FastTransformation) const
Devuelve una copia del mapa de píxeles transformado mediante la transformación transform y la transformación mode. El mapa de píxeles original no se modifica.
La transformación transform se ajusta internamente para compensar cualquier traslación no deseada; es decir, el mapa de píxeles resultante es el más pequeño que contiene todos los puntos transformados del mapa de píxeles original. Utiliza la función trueMatrix() para obtener la matriz real utilizada para transformar el mapa de píxeles.
Esta función es lenta porque implica una transformación a un QImage, cálculos no triviales y una transformación de vuelta a un QPixmap.
Véanse también trueMatrix() y Pixmap Transformations.
[static] QTransform QPixmap::trueMatrix(const QTransform &matrix, int width, int height)
Devuelve la matriz real utilizada para transformar un mapa de píxeles con los valores especificados en ` width`, ` height ` y ` matrix`.
Al transformar un mapa de píxeles utilizando la función transformed(), la matriz de transformación se ajusta internamente para compensar cualquier traslación no deseada; es decir, transformed() devuelve el mapa de píxeles más pequeño que contiene todos los puntos transformados del mapa de píxeles original. Esta función devuelve la matriz modificada, que mapea correctamente los puntos del mapa de píxeles original al nuevo mapa de píxeles.
Véase también transformed() y Pixmap Transformations.
int QPixmap::width() const
Devuelve el ancho del mapa de píxeles.
Véase también size() y Pixmap Information.
QPixmap::operator QVariant() const
Devuelve el mapa de píxeles como un objeto ` QVariant`.
bool QPixmap::operator!() const
Devuelve ` true ` si se trata de un mapa de píxeles nulo; en caso contrario, devuelve ` false`.
Véase también isNull().
[noexcept] QPixmap &QPixmap::operator=(QPixmap &&other)
Asigna « other » a esta instancia de « QPixmap ». .
QPixmap &QPixmap::operator=(const QPixmap &pixmap)
Asigna el « pixmap » indicado a este mapa de píxeles y devuelve una referencia a dicho mapa de píxeles.
Elementos no miembros relacionados
QDataStream &operator<<(QDataStream &stream, const QPixmap &pixmap)
Escribe el objeto ` pixmap ` indicado en el archivo ` stream ` como una imagen PNG. Ten en cuenta que escribir el flujo en un archivo no generará un archivo de imagen válido.
Véase también QPixmap::save() y Serialización de tipos de datos de Qt.
QDataStream &operator>>(QDataStream &stream, QPixmap &pixmap)
Lee una imagen desde la dirección stream y la guarda en la dirección pixmap.
Véase también QPixmap::load() y Serialización de tipos 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.