QImage Class

Documentation des fonctions membres

[noexcept] QImage::QImage()

Crée une image nulle.

Voir aussi isNull().

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

Crée une image à partir de l'image « xpm » fournie.

Assurez-vous que l'image est une image XPM valide. Les erreurs sont ignorées sans message d'avertissement.

Notez qu’il est possible de réduire légèrement la taille de la variable XPM en utilisant une déclaration inhabituelle :

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

Le ` const ` supplémentaire rend l’ensemble de la définition en lecture seule, ce qui est légèrement plus efficace (par exemple, lorsque le code se trouve dans une bibliothèque partagée) et permet de la stocker en ROM avec l’application.

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

Crée une image à partir des paramètres size et format fournis.

Une image de type ` null ` est renvoyée si l'allocation de mémoire échoue.

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

Crée une image et tente de la charger à partir du fichier dont l'fileName est indiquée.

Le chargeur tente de lire l’image à l’aide de l’ format spécifiée. Si l’ format n’est pas spécifiée (ce qui est le cas par défaut), elle est détectée automatiquement en fonction de l’extension et de l’en-tête du fichier. Pour plus de détails, voir {QImageReader::setAutoDetectImageFormat()}{QImageReader}.

Si le chargement de l’image a échoué, cet objet est une image nulle.

Le nom de fichier peut faire référence soit à un fichier réel présent sur le disque, soit à l’une des ressources intégrées de l’application. Reportez-vous à la présentation du système de ressources pour plus de détails sur la manière d’intégrer des images et d’autres fichiers de ressources dans l’exécutable de l’application.

Voir également isNull() et Reading and Writing Image Files.

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

Crée une image à partir des paramètres suivants : width, height et format.

Une image de type ` null ` sera renvoyée si l'allocation de mémoire échoue.

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

Construit une image à partir des paramètres width, height et format fournis, en utilisant un tampon mémoire en lecture seule existant, data. Les paramètres width et height doivent être spécifiés en pixels, data doit être aligné sur 32 bits, et chaque ligne de balayage de données de l’image doit également être alignée sur 32 bits.

Le tampon doit rester valide pendant toute la durée de vie de l'objet QImage et de toutes les copies qui n'ont pas été modifiées ou détachées du tampon d'origine. L'image ne supprime pas le tampon lors de sa destruction. Vous pouvez fournir un pointeur de fonction cleanupFunction ainsi qu'un pointeur supplémentaire cleanupInfo qui sera appelé lorsque la dernière copie sera détruite.

Si format est un format de couleur indexé, la table de couleurs de l’image est initialement vide et doit être suffisamment étendue à l’aide de setColorCount() ou setColorTable() avant que l’image ne soit utilisée.

Contrairement au constructeur QImage similaire qui prend un tampon de données non-const, cette version ne modifie jamais le contenu du tampon. Par exemple, l’appel à ` QImage::bits()` renverra une copie profonde de l’image, plutôt que le tampon passé au constructeur. Cela permet de bénéficier de l’efficacité de la construction d’un QImage à partir de données brutes, sans risque que celles-ci soient modifiées.

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

Construit une image à partir des paramètres width, height et format fournis, en utilisant un tampon mémoire existant, data. Les paramètres width et height doivent être spécifiés en pixels, data doit être aligné sur 32 bits, et chaque ligne de balayage de données de l’image doit également être alignée sur 32 bits.

Le tampon doit rester valide pendant toute la durée de vie de l’objet `QImage` et de toutes les copies qui n’ont pas été modifiées ou détachées d’une autre manière du tampon d’origine. L’objet `QImage` ne supprime pas le tampon lors de sa destruction. Vous pouvez fournir un pointeur de fonction ` cleanupFunction ` ainsi qu’un pointeur supplémentaire ` cleanupInfo ` qui sera appelé lorsque la dernière copie sera détruite.

Si format est un format de couleur indexé, la table de couleurs de l’image est initialement vide et doit être suffisamment étendue à l’aide de setColorCount() ou setColorTable() avant que l’image ne soit utilisée.

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

Construit une image à partir des paramètres width, height et format, en utilisant un tampon mémoire existant, data. Les paramètres width et height doivent être spécifiés en pixels. bytesPerLine spécifie le nombre d’octets par ligne (stride).

Le tampon doit rester valide pendant toute la durée de vie de l’objet `QImage` et de toutes les copies qui n’ont pas été modifiées ou détachées d’une autre manière du tampon d’origine. L’image ne supprime pas le tampon lors de sa destruction. Vous pouvez fournir un pointeur de fonction cleanupFunction ainsi qu’un pointeur supplémentaire cleanupInfo qui sera appelé lorsque la dernière copie sera détruite.

Si format est au format de couleur indexée, la table de couleurs de l’image est initialement vide et doit être suffisamment étendue à l’aide de setColorCount() ou setColorTable() avant que l’image ne soit utilisée.

Contrairement au constructeur QImage similaire qui prend un tampon de données non-const, cette version ne modifiera jamais le contenu du tampon. Par exemple, l'appel à ` QImage::bits()` renverra une copie profonde de l'image, plutôt que le tampon passé au constructeur. Cela permet de bénéficier de l'efficacité de la construction d'un QImage à partir de données brutes, sans risque que ces données soient modifiées.

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

Construit une image à partir des paramètres width, height et format, en utilisant un tampon mémoire existant, data. Les paramètres width et height doivent être spécifiés en pixels. bytesPerLine spécifie le nombre d’octets par ligne (stride).

Le tampon doit rester valide pendant toute la durée de vie de l’objet QImage et de toutes les copies qui n’ont pas été modifiées ou détachées d’une autre manière du tampon d’origine. L’image ne supprime pas le tampon lors de sa destruction. Vous pouvez fournir un pointeur de fonction cleanupFunction ainsi qu’un pointeur supplémentaire cleanupInfo qui sera appelé lorsque la dernière copie sera détruite.

Si format est un format de couleur indexé, la table de couleurs de l’image est initialement vide et doit être suffisamment étendue à l’aide de setColorCount() ou setColorTable() avant que l’image ne soit utilisée.

QImage::QImage(const QImage &image)

Crée une copie superficielle de l'image on fournie.

Pour plus d’informations sur les copies superficielles, consultez la documentation relative au partage implicite des données.

Voir également copy().

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

Cette méthode crée une instance de `QImage` et la fait pointer vers le même objet que celui vers lequel pointait ` other `.

[virtual noexcept] QImage::~QImage()

Détruit l'image et nettoie tout.

bool QImage::allGray() const

Renvoie « true » si toutes les couleurs de l'image sont des nuances de gris (c'est-à-dire si leurs composantes rouge, verte et bleue sont égales) ; sinon, renvoie « false ».

Notez que cette fonction est lente pour les images sans table de couleurs.

Voir également isGrayscale().

void QImage::applyColorTransform(const QColorTransform &transform)

Applique la transformation de couleur « transform » à tous les pixels de l'image.

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

Applique la transformation de couleur transform à tous les pixels de l'image et convertit le format de l'image au format toFormat.

Les flags de conversion d’image spécifiées déterminent la manière dont les données d’image sont traitées pendant le processus de conversion de format.

Cette fonction a été introduite dans Qt 6.8.

int QImage::bitPlaneCount() const

Renvoie le nombre de plans de bits de l'image.

Le nombre de plans de bits correspond au nombre de bits d'informations de couleur et de transparence pour chaque pixel. Ce nombre est différent (c'est-à-dire inférieur) de la profondeur lorsque le format d'image contient des bits inutilisés.

Voir également depth(), format() et Image Formats.

uchar *QImage::bits()

Renvoie un pointeur vers les données du premier pixel. Cela équivaut à ` scanLine(0)`.

Notez que la fonction ` QImage ` utilise le partage implicite des données. Cette fonction effectue une copie profonde des données de pixels partagées, garantissant ainsi que l'QImage ion en cours est la seule à utiliser la valeur de retour actuelle.

Voir également scanLine(), sizeInBytes() et constBits().

const uchar *QImage::bits() const

Notez que la fonction ` QImage ` utilise le partage implicite des données, mais qu'elle n' effectue pas de copie profonde des données de pixels partagées, car les données renvoyées sont de type `const`.

qsizetype QImage::bytesPerLine() const

Renvoie le nombre d'octets par ligne de balayage de l'image.

Cela équivaut à sizeInBytes() / height() si height() est différent de zéro.

Voir aussi scanLine().

qint64 QImage::cacheKey() const

Renvoie un nombre qui identifie le contenu de cet objet ` QImage `. Deux objets ` QImage ` distincts ne peuvent avoir la même clé que s'ils font référence au même contenu.

La clé change lorsque l'image est modifiée.

QRgb QImage::color(int i) const

Renvoie la couleur de la table de couleurs à l'index i. La première couleur se trouve à l'index 0.

Les couleurs de la table de couleurs d’une image sont spécifiées sous forme de quadruplets ARGB (QRgb). Utilisez les fonctions qAlpha(), qRed(), qGreen() et qBlue() pour obtenir les composantes de la valeur de couleur.

Voir également setColor(), pixelIndex() et Pixel Manipulation.

int QImage::colorCount() const

Renvoie la taille de la table de couleurs de l'image.

Notez que la fonction colorCount() renvoie 0 pour les images 32 bpp, car celles-ci n'utilisent pas de tables de couleurs, mais codent plutôt les valeurs des pixels sous forme de quadruplets ARGB.

Voir également setColorCount() et Image Information.

QColorSpace QImage::colorSpace() const

Renvoie l'espace colorimétrique de l'image si celui-ci est défini.

Voir également setColorSpace().

QList<QRgb> QImage::colorTable() const

Renvoie une liste des couleurs contenues dans la table de couleurs de l'image, ou une liste vide si l'image ne dispose pas de table de couleurs

Voir également setColorTable(), colorCount() et color().

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

Renvoie la couleur de l'image transformée à l'aide de la fonction « transform » appliquée à tous les pixels de l'image.

Cette fonction a été introduite dans Qt 6.4.

Voir également applyColorTransform().

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

Renvoie l'image dont les couleurs ont été transformées à l'aide de la fonction ` transform ` sur tous les pixels de l'image, en renvoyant une image au format ` toFormat`.

Les paramètres de conversion d’image spécifiés ( flags ) déterminent la manière dont les données d’image sont traitées au cours du processus de conversion de format.

Cette fonction a été introduite dans Qt 6.8.

Voir également applyColorTransform().

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

Renvoie la couleur de l'image obtenue après application de la fonction « transform » à tous les pixels de l'image.

Cette fonction a été introduite dans Qt 6.4.

Voir aussi ` applyColorTransform()`.

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

Renvoie la couleur de l'image obtenue après application de la fonction « transform » à tous les pixels de l'image.

Cette fonction a été introduite dans Qt 6.8.

Voir également ` applyColorTransform()`.

const uchar *QImage::constBits() const

Renvoie un pointeur vers les données du premier pixel.

Notez que la fonction ` QImage ` utilise le partage implicite des données, mais que cette fonction n' effectue pas de copie profonde des données de pixels partagées, car les données renvoyées sont de type `const`.

Voir également ` bits()` et ` constScanLine()`.

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

Renvoie un pointeur vers les données de pixel de la ligne de balayage dont l'index est i. La première ligne de balayage correspond à l'index 0.

Les données de ligne de balayage sont alignées au minimum sur 32 bits. Pour les formats 64 bits, elles suivent l’alignement natif des entiers 64 bits (64 bits pour la plupart des plateformes, mais notamment 32 bits sur i386).

Notez que ` QImage ` utilise le partage implicite des données, mais cette fonction n'effectue pas de copie profonde des données de pixels partagées, car les données renvoyées sont de type `const`.

Voir également scanLine() et constBits().

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

Convertit l'image selon l'format spécifiée sur place, en la détachant si nécessaire.

Les flags s de conversion d'image spécifiées déterminent la manière dont les données d'image sont traitées pendant le processus de conversion.

Voir également convertedTo().

void QImage::convertToColorSpace(const QColorSpace &colorSpace)

Convertit l'image au format « colorSpace ».

Si l'image ne dispose pas d'un espace colorimétrique valide, la méthode ne fait rien.

Voir également convertedToColorSpace() et setColorSpace().

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

Convertit l'image aux formats colorSpace et format.

Si l'image ne dispose pas d'un espace colorimétrique valide, la méthode ne fait rien ; il en va de même si l'espace colorimétrique n'est pas compatible avec le format.

Les paramètres de conversion d’image spécifiés ( flags ) déterminent la manière dont les données d’image sont gérées pendant le processus de conversion de format.

Cette fonction a été introduite dans Qt 6.8.

Voir également convertedToColorSpace() et setColorSpace().

Renvoie une copie de l'image selon l'format spécifiée.

Les flags de conversion d'image spécifiées déterminent la manière dont les données d'image sont traitées pendant le processus de conversion.

Voir également convertTo() et Image Formats.

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

Renvoie une copie de l'image convertie au format « format » spécifié, en utilisant la valeur « colorTable » indiquée.

La conversion des formats RVB vers des formats indexés est une opération lente qui utilise une approche simple par couleur la plus proche, sans tramage.

Renvoie une copie de l'image selon l'format s spécifiées.

Les flags s de conversion d'image spécifiées déterminent la manière dont les données d'image sont traitées pendant le processus de conversion.

Ces fonctions ont été introduites dans Qt 6.0.

Voir également convertTo() et Image Formats.

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

Renvoie l'image convertie au format « colorSpace ».

Si l'image ne dispose pas d'un espace colorimétrique valide, une valeur nulle est renvoyée pour « QImage ».

Voir également ` convertToColorSpace()` et ` colorTransformed()`.

Renvoie l'image convertie aux formats colorSpace et format.

Si l'image ne dispose pas d'un espace colorimétrique valide, un objet ` QImage ` nul est renvoyé.

Les flags de conversion d'image spécifiées déterminent la manière dont les données d'image sont traitées pendant le processus de conversion de format.

Ces fonctions ont été introduites dans Qt 6.8.

Voir également colorTransformed().

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

Renvoie une partie de l'image sous forme d'une nouvelle image.

L'image renvoyée est copiée à partir de la position (rectangle.x(), rectangle.y()) dans cette image, et aura toujours la taille de l'rectangle.

Dans les zones situées au-delà de cette image, les pixels sont définis à 0. Pour les images RVB 32 bits, cela correspond au noir ; pour les images ARGB 32 bits, cela correspond au noir transparent ; pour les images 8 bits, cela correspond à la couleur dont l’index est 0 dans la table de couleurs, qui peut être n’importe quelle couleur ; pour les images 1 bit, cela correspond à Qt::color0.

Si l'rectangle fournie est un rectangle nul, l'image entière est copiée.

Voir également QImage().

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

L'image renvoyée est copiée à partir de la position (x, y) dans cette image, et aura toujours les coordonnées width et height. Dans les zones situées au-delà de cette image, les pixels sont mis à 0.

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

Crée et renvoie un masque de 1 bpp à partir du tampon alpha de cette image. Renvoie une image nulle si le format de l’image est « QImage::Format_RGB32 ».

L'argument ` flags ` est un OU binaire de ` Qt::ImageConversionFlags` et contrôle le processus de conversion. En passant 0 pour les indicateurs, toutes les options par défaut sont activées.

L’image renvoyée a un ordre des bits « little-endian » (c’est-à-dire que le format de l’image est QImage::Format_MonoLSB), que vous pouvez convertir en « big-endian » (QImage::Format_Mono) à l’aide de la fonction convertToFormat().

Voir également createHeuristicMask() et Image Transformations.

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

Crée et renvoie un masque heuristique de 1 bpp pour cette image.

La fonction fonctionne en sélectionnant une couleur dans l’un des coins, puis en supprimant les pixels de cette couleur en commençant par tous les bords. Les quatre coins déterminent quelle couleur doit être masquée. En cas d’égalité (ce qui signifie généralement que cette fonction n’est pas applicable à l’image), le résultat est arbitraire.

L’image renvoyée a un ordre des bits « little-endian » (c’est-à-dire que le format de l’image est QImage::Format_MonoLSB), que vous pouvez convertir en « big-endian » (QImage::Format_Mono) à l’aide de la fonction convertToFormat().

Si clipTight est vrai (valeur par défaut), le masque est juste assez grand pour recouvrir les pixels ; sinon, le masque est plus grand que les pixels de données.

Notez que cette fonction ne tient pas compte du tampon alpha.

Voir également createAlphaMask() et Image Transformations.

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

Crée et renvoie un masque pour cette image en fonction de la valeur color fournie. Si mode est défini sur MaskInColor (valeur par défaut), tous les pixels correspondant à color seront des pixels opaques dans le masque. Si mode est défini sur MaskOutColor, tous les pixels correspondant à la couleur indiquée seront transparents.

Voir également createAlphaMask() et createHeuristicMask().

int QImage::depth() const

Renvoie la profondeur de l'image.

La profondeur de l'image correspond au nombre de bits utilisés pour stocker un seul pixel, également appelé « bits par pixel » (bpp).

Les profondeurs prises en charge sont 1, 8, 16, 24, 32 et 64.

Voir également bitPlaneCount(), convertToFormat(), Image Formats et Image Information.

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

Renvoie la taille de l'image en pixels indépendants du périphérique.

Cette valeur doit être utilisée lorsque la taille de l’image est prise en compte dans les calculs de taille de l’interface utilisateur.

La valeur renvoyée est équivalente à image.size() / image.devicePixelRatio().

Cette fonction a été introduite dans Qt 6.2.

qreal QImage::devicePixelRatio() const

Renvoie le rapport de pixels de l'appareil pour l'image. Il s'agit du rapport entre les pixels de l'appareil et les pixels indépendants de l'appareil.

Utilisez cette fonction pour calculer la géométrie de la mise en page en fonction de la taille de l'image : ` QSize layoutSize = image.size() / image.devicePixelRatio()`

La valeur par défaut est 1,0.

Voir également setDevicePixelRatio() et QImageReader.

int QImage::dotsPerMeterX() const

Renvoie le nombre de pixels pouvant tenir horizontalement sur un mètre physique. Associé à la fonction dotsPerMeterY(), ce nombre définit l'échelle et le format prévus pour l'image.

Voir également setDotsPerMeterX() et Image Information.

int QImage::dotsPerMeterY() const

Renvoie le nombre de pixels pouvant tenir verticalement sur un mètre physique. Associé à la fonction dotsPerMeterX(), ce nombre définit l'échelle et le format prévus pour l'image.

Voir également setDotsPerMeterY() et Image Information.

void QImage::fill(uint pixelValue)

Remplit l'intégralité de l'image avec l'pixelValue on fournie.

Si la profondeur de cette image est égale à 1, seul le bit de poids faible est utilisé. Si vous indiquez fill(0), fill(2), etc., l'image est remplie de 0. Si vous utilisez fill(1), fill(3), etc., l'image est remplie de 1. Si la profondeur est de 8, les 8 bits les plus significatifs sont utilisés et si la profondeur est de 16, les 16 bits les plus significatifs sont utilisés.

Si la profondeur de l'image est supérieure à 32 bits, le résultat n'est pas défini.

Voir également depth() et Image Transformations.

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

Remplit l'image avec l'color on fournie, décrite comme une couleur globale standard.

void QImage::fill(const QColor &color)

Remplit l'intégralité de l'image avec l'color spécifiée.

Si la profondeur de l'image est égale à 1, l'image sera remplie avec la valeur 1 si l'color est égale à Qt::color1; dans le cas contraire, elle sera remplie avec la valeur 0.

Si la profondeur de l'image est de 8, l'image sera remplie avec l'indice correspondant à color dans la table de couleurs s'il existe ; sinon, elle sera remplie avec 0.

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

Inverse ou reflète l'image dans le sens horizontal et/ou vertical, selon la valeur de ` orient`.

Cette fonction a été introduite dans Qt 6.9.

Voir également flipped(Qt::Orientations) et Image Transformations.

Renvoie une version inversée ou en miroir de l'image, reflétée horizontalement et/ou verticalement selon la valeur de ` orient`.

Notez que l'image d'origine n'est pas modifiée.

Ces fonctions ont été introduites dans Qt 6.9.

Voir également flip(Qt::Orientations) et Image Transformations.

QImage::Format QImage::format() const

Renvoie le format de l'image.

Voir aussi Image Formats.

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

Crée une image à partir de l'QByteArrayView data fournie. Le chargeur tente de lire l'image à l'aide de l'format spécifiée. Si format n'est pas spécifié (ce qui est le cas par défaut), le chargeur analyse les données à la recherche d'un en-tête afin de deviner le format du fichier.

Si format est spécifié, il doit s’agir de l’une des valeurs renvoyées par la fonction QImageReader::supportedImageFormats().

Si le chargement de l'image échoue, l'image renvoyée sera une image nulle.

Cette fonction a été introduite dans Qt 6.2.

Voir également load(), save() et Reading and Writing Image Files.

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

Crée un objet ` QImage ` à partir des données fournies ` QByteArray ` et ` data`.

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

Construit un objet ` QImage ` à partir des ` size ` premiers octets du fichier binaire ` data` fourni.

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

Renvoie un objet ` QImage ` équivalent à l'objet ` hbitmap` fourni.

HBITMAP ne stocke pas d’informations concernant le canal alpha.

Dans le cas standard, le canal alpha est ignoré et une image entièrement opaque est créée (généralement au format QImage::Format_RGB32).

Il existe toutefois des cas où le canal alpha est utilisé, par exemple pour les icônes d'application ou les icônes de la barre d'état système. Dans ce cas, il convient d'appeler la fonction ` reinterpretAsFormat(QImage::Format_ARGB32) ` sur l'image renvoyée afin de s'assurer que le format est correct.

Cette fonction a été introduite dans Qt 6.0.

Voir également ` toHBITMAP()` et ` reinterpretAsFormat()`.

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

Renvoie un objet ` QImage ` équivalent à l'objet ` icon` fourni.

Cette fonction a été introduite dans Qt 6.0.

Voir également toHICON().

bool QImage::hasAlphaChannel() const

Renvoie « true » si le format de l'image prend en charge le canal alpha ; sinon, renvoie « false ».

Voir également Image Information.

int QImage::height() const

Renvoie la hauteur de l'image.

Voir aussi Image Information.

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

Inverse toutes les valeurs de pixels de l'image.

L'mode d'inversion indiquée n'a de sens que lorsque la profondeur de l'image est de 32. L'mode par défaut est InvertRgb, ce qui laisse le canal alpha inchangé. Si l'mode est InvertRgba, les bits alpha sont également inversés.

Inverser une image de 8 bits revient à remplacer tous les pixels utilisant l’indice de couleur i par un pixel utilisant l’indice de couleur 255 moins i. Il en va de même pour une image de 1 bit. Notez que la table des couleurs n’ est pas modifiée.

Si l’image possède un canal alpha pré-multiplié, elle est d’abord convertie au format d’image non pré-multiplié pour être inversée, puis reconvertie.

Voir également Image Transformations.

bool QImage::isGrayscale() const

Pour les images 32 bits, cette fonction équivaut à ` allGray()`.

Pour les images à index de couleur, cette fonction renvoie true si color(i) est égal à QRgb(i, i, i) pour tous les indices de la table de couleurs ; sinon, elle renvoie false.

Voir également allGray() et Image Formats.

bool QImage::isNull() const

Renvoie « true » s'il s'agit d'une image nulle, sinon renvoie « false ».

Une image nulle a tous ses paramètres définis à zéro et aucune donnée allouée.

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

Charge une image à partir du fichier dont l'fileName est spécifiée. Renvoie « true » si l'image a été chargée avec succès ; sinon, invalide l'image et renvoie « false ».

Le chargeur tente de lire l’image en utilisant l’ format spécifié, par exemple PNG ou JPG. Si l’ format n’est pas spécifié (ce qui est le cas par défaut), il est détecté automatiquement en fonction de l’extension et de l’en-tête du fichier. Pour plus de détails, voir QImageReader::setAutoDetectImageFormat().

Le nom de fichier peut faire référence soit à un fichier réel présent sur le disque, soit à l’une des ressources intégrées de l’application. Consultez la présentation du système de ressources pour plus de détails sur la manière d’intégrer des images et d’autres fichiers de ressources dans l’exécutable de l’application.

Voir également Reading and Writing Image Files.

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

Cette fonction lit une image « QImage » à partir de l'device indiquée. Elle peut, par exemple, être utilisée pour charger une image directement dans un « QByteArray ».

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

Charge une image à partir de l'QByteArrayView indiquée data. Renvoie true si l'image a été chargée avec succès ; sinon, invalide l'image et renvoie false.

Le chargeur tente de lire l’image en utilisant le format spécifié format, par exemple PNG ou JPG. Si format n’est pas spécifié (ce qui est le cas par défaut), le chargeur analyse le fichier à la recherche d’un en-tête afin de deviner le format du fichier.

Cette fonction a été introduite dans Qt 6.2.

Voir également Reading and Writing Image Files.

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

Charge une image à partir de l'QByteArray n indiquée : data.

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

Charge une image à partir des premiers len octets du fichier binaire data.

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

Cette fonction sera obsolète à partir de la version 6.13.

Utilisez plutôt flip(Qt::Orientations).

Inverse l'image horizontalement et/ou verticalement selon que horizontal et vertical sont définis sur true ou false.

Cette fonction a été introduite dans Qt 6.0.

Voir également mirrored() et Image Transformations.

Cette fonction est prévue pour être obsolète à partir de la version 6.13.

Utilisez plutôt flipped(Qt::Orientations).

Renvoie une image inversée, reflétée horizontalement et/ou verticalement selon que horizontal et vertical sont définis sur true ou false.

Notez que l'image d'origine n'est pas modifiée.

Voir également mirror() et Image Transformations.

QPoint QImage::offset() const

Renvoie le nombre de pixels dont l'image doit être décalée lors de son positionnement par rapport à d'autres images.

Voir également setOffset() et Image Information.

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

Renvoie la couleur du pixel situé à l'position indiquée.

Si l'position n'est pas valide, le résultat est indéfini.

Voir également setPixel(), valid(), constBits(), constScanLine() et Pixel Manipulation.

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

Renvoie la couleur du pixel situé aux coordonnées (x, y).

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

Renvoie la couleur du pixel situé à l'position indiquée sous la forme d'un objet ` QColor`.

Si l'position n'est pas valide, une valeur « invalid QColor » est renvoyée.

Voir également setPixelColor(), setPixel(), valid(), constBits(), constScanLine() et Pixel Manipulation.

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

Renvoie la couleur du pixel situé aux coordonnées (x, y) sous la forme d'un objet de type ` QColor`.

[noexcept] QPixelFormat QImage::pixelFormat() const

Renvoie l'QImage::Format sous la forme d'un QPixelFormat

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

Renvoie l'index du pixel correspondant à l'adresse « position » indiquée.

Si ` position ` n'est pas valide, ou si l'image n'est pas une image à palette (depth() > 8), le comportement est indéfini.

Voir également valid(), depth() et Pixel Manipulation.

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

Renvoie l'index du pixel situé à l'adresse (x, y).

QRect QImage::rect() const

Renvoie le rectangle englobant (0, 0, width(), height()) de l'image.

Voir aussi Image Information.

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

Modifie le format de l'image en format sans modifier les données. Ne fonctionne qu'entre des formats de même profondeur.

Renvoie « true » en cas de succès.

Cette fonction peut être utilisée pour convertir des images comportant des canaux alpha vers leurs formats opaques correspondants si l’on sait que les données sont exclusivement opaques, ou pour modifier le format d’un tampon d’image donné avant de le remplacer par de nouvelles données.

Voir également ` hasAlphaChannel()` et ` convertToFormat()`.

[since 6.0] void QImage::rgbSwap()

Permet d'inverser les valeurs des composantes rouge et bleue de tous les pixels, ce qui revient à convertir une image RVB en image BGR.

Cette fonction a été introduite dans Qt 6.0.

Voir également rgbSwapped() et Image Transformations.

Renvoie un objet ` QImage ` dans lequel les valeurs des composantes rouge et bleue de tous les pixels ont été inversées, ce qui revient à convertir une image RVB en image BGR.

L'QImage d'origine n'est pas modifiée.

Voir également ` rgbSwap()` et ` Image Transformations`.

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

Enregistre l’image dans un fichier avec le facteur d’ fileName, en utilisant le fichier image spécifié format et le facteur d’ quality. Si format est nullptr, QImage tentera de deviner le format en examinant le suffixe de fileName.

Le facteur quality doit être compris entre 0 et 100 ou égal à -1. Indiquez 0 pour obtenir de petits fichiers compressés, 100 pour de grands fichiers non compressés et -1 (valeur par défaut) pour utiliser les paramètres par défaut.

Renvoie « true » si l’image a été enregistrée avec succès ; sinon, renvoie « false ».

Voir également Reading and Writing Image Files.

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

Cette fonction enregistre une image au format « QImage » à l'adresse indiquée device.

Cela peut, par exemple, être utilisé pour enregistrer une image directement dans un fichier « 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

Renvoie une copie de l'image redimensionnée en un rectangle défini par l'size fournie, conformément aux paramètres aspectRatioMode et transformMode fournis.

• Si aspectRatioMode est Qt::IgnoreAspectRatio, l'image est redimensionnée selon size.
• Si aspectRatioMode est Qt::KeepAspectRatio, l'image est redimensionnée en un rectangle aussi grand que possible à l'intérieur de size, en conservant le rapport hauteur/largeur.
• Si aspectRatioMode est Qt::KeepAspectRatioByExpanding, l'image est redimensionnée en un rectangle aussi petit que possible à l'extérieur de size, tout en conservant le rapport d'aspect.

Si l’ size fournie est vide, cette fonction renvoie une image nulle.

Voir également isNull() et Image Transformations.

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

Renvoie une copie de l'image redimensionnée en un rectangle dont les dimensions sont définies par les paramètres « width » et « height », selon les paramètres « aspectRatioMode » et « transformMode ».

Si la largeur ( width ) ou la hauteur ( height ) est égale à zéro ou négative, cette fonction renvoie une image nulle.

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

Renvoie une copie redimensionnée de l'image. L'image renvoyée est redimensionnée aux dimensions indiquées ( height ) à l'aide de la transformation spécifiée mode.

Cette fonction calcule automatiquement la largeur de l'image de manière à préserver le rapport d'aspect de celle-ci.

Si l'height donnée est égale à 0 ou négative, une image vide est renvoyée.

Voir également Image Transformations.

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

Renvoie une copie redimensionnée de l'image. L'image renvoyée est redimensionnée à l'width e indiquée à l'aide de la transformation spécifiée mode.

Cette fonction calcule automatiquement la hauteur de l’image de manière à préserver son rapport d’aspect.

Si l'width fournie est égale à 0 ou négative, une image vide est renvoyée.

Voir également Image Transformations.

uchar *QImage::scanLine(int i)

Renvoie un pointeur vers les données de pixel de la ligne de balayage dont l'index est i. La première ligne de balayage correspond à l'index 0.

Les données de la ligne de balayage sont alignées au minimum sur 32 bits. Pour les formats 64 bits, elles suivent l’alignement natif des entiers 64 bits (64 bits pour la plupart des plateformes, mais notamment 32 bits sur i386).

Par exemple, pour supprimer la composante verte de chaque pixel d’une image :

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));
    }
}

Voir également bytesPerLine(), bits(), Pixel Manipulation et constScanLine().

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

void QImage::setAlphaChannel(const QImage &alphaChannel)

Définit le canal alpha de cette image sur la valeur indiquée dans ` alphaChannel`.

Si alphaChannel est une image alpha de 8 bits, les valeurs alpha sont utilisées directement. Sinon, alphaChannel est converti en niveaux de gris 8 bits et l’intensité des valeurs de pixels est utilisée.

Si l’image possède déjà un canal alpha, le canal alpha existant est multiplié par le nouveau. Si l’image ne possède pas de canal alpha, elle sera convertie dans un format qui en comporte un.

Cette opération revient à superposer l’image alphaChannel en tant qu’image alpha sur cette image à l’aide de QPainter::CompositionMode_DestinationIn.

Voir également hasAlphaChannel(), Image Transformations et Image Formats.

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

Définit la couleur à l'index indiquée dans la table des couleurs, en lui attribuant la valeur spécifiée à l'colorValue. La valeur de couleur est un quadruplet ARGB.

Si index dépasse la taille actuelle de la table de couleurs, celle-ci est agrandie à l’aide de setColorCount().

Voir également color(), colorCount(), setColorTable() et Pixel Manipulation.

void QImage::setColorCount(int colorCount)

Redimensionne la table de couleurs pour qu’elle contienne colorCount entrées.

Si la table de couleurs est agrandie, toutes les couleurs supplémentaires seront définies comme transparentes (c'est-à-dire qRgba(0, 0, 0, 0)).

Lorsque l’image est utilisée, la table de couleurs doit être suffisamment grande pour contenir des entrées correspondant à toutes les valeurs de pixels/index présentes dans l’image, sinon les résultats sont indéfinis.

Voir également colorCount(), colorTable(), setColor() et Image Transformations.

void QImage::setColorSpace(const QColorSpace &colorSpace)

Définit l'espace colorimétrique de l'image sur « colorSpace » sans effectuer de conversion sur les données de l'image.

Voir également colorSpace().

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

Définit la table de couleurs utilisée pour convertir les indices de couleur en valeurs d'QRgb, en indiquant l'colors spécifiée.

Lorsque l’image est utilisée, la table de couleurs doit être suffisamment grande pour contenir des entrées correspondant à toutes les valeurs de pixels/index présentes dans l’image, faute de quoi les résultats sont indéfinis.

Voir également colorTable(), setColor() et Image Transformations.

void QImage::setDevicePixelRatio(qreal scaleFactor)

Définit le rapport de pixels de l'appareil pour l'image. Il s'agit du rapport entre les pixels de l'image et les pixels indépendants de l'appareil.

La valeur par défaut scaleFactor est 1,0. La modification de cette valeur a deux conséquences :

Les QPainters ouverts sur l’image seront mis à l’échelle. Par exemple, dessiner sur une image de 200x200 avec un rapport de 2,0 donnera des limites de dessin effectives (indépendantes du périphérique) de 100x100.

Les chemins de code dans Qt qui calculent la géométrie de mise en page en fonction de la taille de l’image tiendront compte de ce rapport : QSize layoutSize = image.size() / image.devicePixelRatio() L’effet net est que l’image s’affiche comme une image haute résolution (DPI) plutôt que comme une image de grande taille (voir Drawing High Resolution Versions of Pixmaps and Images).

Voir également devicePixelRatio() et deviceIndependentSize().

void QImage::setDotsPerMeterX(int x)

Définit le nombre de pixels pouvant tenir horizontalement dans un mètre physique, à x.

Associé à la fonction ` dotsPerMeterY()` (), ce nombre définit l’échelle et le rapport d’aspect souhaités pour l’image, et détermine l’échelle à laquelle la fonction ` QPainter ` dessinera les graphiques sur l’image. Il ne modifie pas l’échelle ni le rapport d’aspect de l’image lorsqu’elle est affichée sur d’autres périphériques de dessin.

Voir également dotsPerMeterX() et Image Information.

void QImage::setDotsPerMeterY(int y)

Définit le nombre de pixels pouvant tenir verticalement sur un mètre physique, à y.

Associé à la fonction ` dotsPerMeterX()`, ce nombre définit l'échelle et le rapport d'aspect souhaités de l'image, et détermine l'échelle à laquelle la fonction ` QPainter ` dessinera les graphiques sur l'image. Il ne modifie pas l'échelle ni le rapport d'aspect de l'image lorsqu'elle est affichée sur d'autres périphériques de dessin.

Voir également ` dotsPerMeterY()` et ` Image Information`.

void QImage::setOffset(const QPoint &offset)

Définit le nombre de pixels de décalage prévu pour l'image lors de son positionnement par rapport à d'autres images, sur offset.

Voir également offset() et Image Information.

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

Définit l'index du pixel ou la couleur à l'position indiquée sur index_or_rgb.

Si le format de l'image est monochrome ou à palette, la valeur index_or_rgb fournie doit être un index dans la table de couleurs de l'image ; sinon, le paramètre doit être une valeur QRgb.

Si position ne constitue pas une paire de coordonnées valide dans l’image, ou si index_or_rgb >= colorCount() dans le cas d’images monochromes et à palette, le résultat est indéfini.

Voir également pixel() et Pixel Manipulation.

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

Définit l'index de pixel ou la couleur à l'adresse (x, y) sur index_or_rgb.

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

Définit la couleur à l'position indiquée sur color.

Si position ne correspond pas à une paire de coordonnées valide dans l'image, ou si le format de l'image est monochrome ou à palette, le résultat est indéfini.

Voir également pixelColor(), pixel(), bits(), scanLine() et Pixel Manipulation.

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

Définit la couleur du pixel situé à l'adresse (x, y) sur color.

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

Définit le texte de l'image sur l'text indiquée et l'associe à l'key indiquée.

Si vous souhaitez simplement stocker un seul bloc de texte (par exemple, un « commentaire » ou simplement une description), vous pouvez soit passer une clé vide, soit utiliser une clé générique telle que « Description ».

Le texte de l'image est intégré aux données de l'image lorsque vous appelez save() ou QImageWriter::write().

Tous les formats d'image ne prennent pas en charge l'intégration de texte. Vous pouvez vérifier si une image ou un format spécifique prend en charge l'intégration de texte à l'aide de la fonction QImageWriter::supportsOption(). Voici un exemple :

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

Vous pouvez utiliser QImageWriter::supportedImageFormats() pour connaître les formats d'image disponibles.

Voir également text() et textKeys().

QSize QImage::size() const

Renvoie la taille de l'image, c'est-à-dire ses propriétés width() et height().

Voir également Image Information et deviceIndependentSize().

qsizetype QImage::sizeInBytes() const

Renvoie la taille des données d'image en octets.

Voir également bytesPerLine(), bits() et Image Information.

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

Remplace cette image par celle-ci : other. Cette opération est très rapide et ne pose jamais de problème.

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

Renvoie le texte de l'image associé à l'key donné. Si l'key spécifié est une chaîne vide, l'intégralité du texte de l'image est renvoyée, chaque paire clé-texte étant séparée par un saut de ligne.

Voir également setText() et textKeys().

QStringList QImage::textKeys() const

Renvoie les clés de texte associées à cette image.

Vous pouvez utiliser ces clés avec la fonction text() pour afficher le texte de l'image correspondant à une clé donnée.

Voir également text().

CGImageRef QImage::toCGImage() const

Crée un objet « CGImage » équivalent à celui-ci : QImage, et renvoie un descripteur « CGImageRef ».

Le CGImageRef renvoyé participe au partage implicite de QImage et contient une référence aux données de QImage. CGImage est immuable et ne détachera jamais le QImage. Toute écriture sur le QImage entraînera son détachement, comme d’habitude.

Cette fonction est rapide et ne copie ni ne convertit les données d’image.

Si le format de l’image ne peut pas être converti, un CGImageRef nul sera renvoyé. Les utilisateurs de cette fonction peuvent alors convertir au préalable l’ QImage en un format pris en charge, par exemple Format_ARGB32_Premultiplied.

Si l’image ne dispose pas d’un espace colorimétrique défini, l’espace colorimétrique du CGImageRef résultant est défini sur l’espace colorimétrique sRGB.

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

Crée un équivalent HBITMAP de la méthode QImage.

Renvoie le descripteur de la HBITMAP.

Il incombe à l'appelant de libérer les données de l'HBITMAP après utilisation.

Pour une utilisation avec des appels GDI standard, tels que ` BitBlt()`, l'image doit avoir le format ` QImage::Format_RGB32`.

Lors de l’utilisation de l’objet HBITMAP obtenu pour la fonction GDI AlphaBlend(), l’image doit être au format QImage::Format_ARGB32_Premultiplied (utilisez convertToFormat()).

Lorsque vous utilisez le HBITMAP ainsi obtenu comme icône d'application ou icône de la barre d'état système, l'image doit être au format QImage::Format_ARGB32.

Cette fonction a été introduite dans Qt 6.0.

Voir également fromHBITMAP() et convertToFormat().

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

Crée un équivalent « HICON » de la balise « QPixmap », en appliquant le masque « mask ».

Si mask n'est pas nul, il doit être au format QImage::Format_Mono. Renvoie le descripteur HICON.

Il incombe à l’appelant de libérer les données de ` HICON ` après utilisation.

Cette fonction a été introduite dans Qt 6.0.

Voir aussi fromHICON().

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

Convertit format en un QImage::Format

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

Convertit format en un QPixelFormat

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

Renvoie une copie de l'image transformée à l'aide de l'matrix de transformation et de l'mode de transformation indiqués.

L'image renvoyée aura normalement le même {Formats d'image}{format} que l'image d'origine. Cependant, une transformation complexe peut aboutir à une image dans laquelle tous les pixels ne sont pas recouverts par les pixels transformés de l’image d’origine. Dans ce cas, ces pixels d’arrière-plan se verront attribuer une valeur de couleur transparente, et l’image transformée se verra attribuer un format comportant un canal alpha, même si l’image d’origine n’en disposait pas.

L’ matrix e de transformation est ajustée en interne pour compenser toute translation indésirable ; c’est-à-dire que l’image produite est la plus petite image contenant tous les points transformés de l’image d’origine. Utilisez la fonction trueMatrix() pour récupérer la matrice réelle utilisée pour transformer une image.

Contrairement à l’autre surcharge, cette fonction peut être utilisée pour effectuer des transformations de perspective sur des images.

Voir également trueMatrix() et Image Transformations.

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

Renvoie la matrice effectivement utilisée pour transformer une image à l'aide des paramètres ` width`, ` height ` et ` matrix` fournis.

Lors de la transformation d’une image à l’aide de la fonction transformed(), la matrice de transformation est ajustée en interne pour compenser toute translation indésirable ; en d’autres termes, transformed() renvoie la plus petite image contenant tous les points transformés de l’image d’origine. Cette fonction renvoie la matrice modifiée, qui mappe correctement les points de l’image d’origine vers la nouvelle image.

Contrairement à l’autre surcharge, cette fonction crée des matrices de transformation pouvant être utilisées pour effectuer des transformations en perspective sur des images.

Voir également transformed() et Image Transformations.

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

Renvoie true si pos est une paire de coordonnées valide dans l'image ; sinon, renvoie false.

Voir également rect() et QRect::contains().

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

Renvoie « true » si « QPoint » ( «x », « y ») est une paire de coordonnées valide dans l'image ; sinon, renvoie « false ».

int QImage::width() const

Renvoie la largeur de l'image.

Voir aussi Image Information.

QImage::operator QVariant() const

Renvoie l'image sous la forme d'un objet ` QVariant`.

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

Renvoie « true » si cette image et l'image fournie ont des contenus différents ; sinon, renvoie « false ».

La comparaison peut être lente, sauf s’il existe une différence évidente, telle qu’une largeur différente, auquel cas la fonction renverra rapidement un résultat.

Voir également operator=().

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

Cette opération attribue l'other à cette instance QImage.

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

Attribue une copie superficielle de l'image on fournie à cette image et renvoie une référence à cette image.

Pour plus d’informations sur les copies superficielles, consultez la documentation relative au partage implicite des données.

Voir également ` copy()` et ` QImage()`.

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

Renvoie « true » si cette image et l'image fournie ont le même contenu ; sinon, renvoie « false ».

La comparaison peut être lente, sauf s’il existe une différence évidente (par exemple, une taille ou un format différent), auquel cas la fonction renverra rapidement un résultat.

Voir également operator=().