Class ColorPaletteHelper

Class ColorPaletteHelper

Namespace: Aspose.Imaging
Assembly: Aspose.Imaging.dll (25.2.0)

Classe d’assistance pour la manipulation des palettes de couleurs.

public static class ColorPaletteHelper

Héritage

objectColorPaletteHelper

Membres hérités

object.GetType(), object.MemberwiseClone(), object.ToString(), object.Equals(object?), object.Equals(object?, object?), object.ReferenceEquals(object?, object?), object.GetHashCode()

Méthodes

Create4Bit()

Crée la palette de couleurs 4 bits.

public static IColorPalette Create4Bit()

Retourne

IColorPalette

La palette de couleurs 4 bits.

Create4BitGrayscale(bool)

Crée la palette de niveaux de gris 4 bits.

public static IColorPalette Create4BitGrayscale(bool minIsWhite)

Paramètres

minIsWhite bool

s’il est défini sur ```cstrue, la palette commence avec la couleur blanche, sinon elle commence avec la couleur noire.

Retourne

IColorPalette

La palette de niveaux de gris 4 bits.

Create8Bit()

Crée la palette de couleurs 8 bits.

public static IColorPalette Create8Bit()

Retourne

IColorPalette

La palette de couleurs 8 bits.

Create8BitGrayscale(bool)

Crée la palette de niveaux de gris 8 bits.

public static IColorPalette Create8BitGrayscale(bool minIsWhite)

Paramètres

minIsWhite bool

s’il est défini sur ```cstrue, la palette commence avec la couleur blanche, sinon elle commence avec la couleur noire.

Retourne

IColorPalette

La palette de niveaux de gris 8 bits.

Exemples

L’exemple suivant crée une image BMP en niveaux de gris palettisée et l’enregistre ensuite dans un fichier.```csharp [C#]

                                                                                                  string dir = "c:\\temp\\";

                                                                                                  Aspose.Imaging.ImageOptions.BmpOptions createOptions = new Aspose.Imaging.ImageOptions.BmpOptions();

                                                                                                  // Enregistrer dans un fichier
                                                                                                  createOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(dir + "output.palette8bit.bmp", false);

                                                                                                  // Utiliser 8 bits par pixel pour réduire la taille de l'image de sortie.
                                                                                                  createOptions.BitsPerPixel = 8;

                                                                                                  // Définir la palette de couleurs en niveaux de gris standard 8 bits qui couvre toutes les couleurs en niveaux de gris.
                                                                                                  // Si l'image traitée ne contient que des couleurs en niveaux de gris, alors sa version palettisée
                                                                                                  // est visuellement indistinguable d'une version non palettisée.
                                                                                                  createOptions.Palette = Aspose.Imaging.ColorPaletteHelper.Create8BitGrayscale(false);

                                                                                                  // Enregistrer sans compression.
                                                                                                  // Vous pouvez également utiliser la compression RLE-8 pour réduire la taille de l'image de sortie.
                                                                                                  createOptions.Compression = Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb;

                                                                                                  // Définir la résolution horizontale et verticale à 96 dpi.
                                                                                                  createOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

                                                                                                  // Créer une image BMP de 100 x 100 px et l'enregistrer dans un fichier.
                                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(createOptions, 100, 100))
                                                                                                  {
                                                                                                      Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(image);

                                                                                                      Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                          new Aspose.Imaging.Point(0, 0),
                                                                                                          new Aspose.Imaging.Point(image.Width, image.Height),
                                                                                                          Aspose.Imaging.Color.Black,
                                                                                                          Aspose.Imaging.Color.White);

                                                                                                      // Remplir l'image avec un dégradé en niveaux de gris
                                                                                                      graphics.FillRectangle(gradientBrush, image.Bounds);

                                                                                                      image.Save();
                                                                                                  }

### <a id="Aspose_Imaging_ColorPaletteHelper_CreateGrayscale_System_Int32_"></a> CreateGrayscale\(int\)

Obtient la palette de niveaux de gris d'un nombre de bits spécifié. Les valeurs de bits autorisées sont 1, 2, 4, 8.

```csharp
public static IColorPalette CreateGrayscale(int bits)

Paramètres

bits int

Le nombre de bits.

Retourne

IColorPalette

Palette de niveaux de gris.

Exceptions

ArgumentOutOfRangeException

bits

CreateMonochrome()

Crée une palette de couleurs monochrome contenant uniquement 2 couleurs.

public static IColorPalette CreateMonochrome()

Retourne

IColorPalette

Palette de couleurs pour les images monochromes.

GetCloseImagePalette(RasterImage, int)

Obtient la palette de couleurs d’une image raster (palettise l’image) dans le cas où l’image n’en a pas. Si une palette existe, elle sera utilisée au lieu d’effectuer des calculs.

public static IColorPalette GetCloseImagePalette(RasterImage image, int entriesCount)

Paramètres

image RasterImage

L’image raster.

entriesCount int

Le nombre d’entrées souhaité.

Retourne

IColorPalette

La palette de couleurs qui commence par les couleurs les plus fréquentes de l’image et contient entriesCount entrées.

Exemples

L’exemple suivant charge une image BMP et l’enregistre à nouveau au format BMP en utilisant diverses options d’enregistrement.```csharp [C#]

                                                                                                   string dir = "c:\\temp\\";

                                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                   {
                                                                                                       Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;

                                                                                                       // Créer BmpOptions
                                                                                                       Aspose.Imaging.ImageOptions.BmpOptions saveOptions = new Aspose.Imaging.ImageOptions.BmpOptions();

                                                                                                       // Utiliser 8 bits par pixel pour réduire la taille de l'image de sortie.
                                                                                                       saveOptions.BitsPerPixel = 8;

                                                                                                       // Définir la palette de couleurs 8 bits la plus proche qui couvre le maximum de pixels de l'image, de sorte qu'une image palettisée
                                                                                                       // soit presque visuellement indistinguable d'une image non palettisée.
                                                                                                       saveOptions.Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette(rasterImage, 256);

                                                                                                       // Enregistrer sans compression.
                                                                                                       // Vous pouvez également utiliser la compression RLE-8 pour réduire la taille de l'image de sortie.
                                                                                                       saveOptions.Compression = Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb;

                                                                                                       // Définir la résolution horizontale et verticale à 96 dpi.
                                                                                                       saveOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

                                                                                                       image.Save(dir + "sample.bmpoptions.bmp", saveOptions);
                                                                                                   }

L'exemple suivant montre comment palettiser une image BMP pour réduire sa taille de sortie.```csharp
[C#]

                                                                                              // Créer une image BMP de 100 x 100 px.
                                                                                              using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100))
                                                                                              {
                                                                                                  // Le dégradé linéaire du coin supérieur gauche au coin inférieur droit de l'image.
                                                                                                  Aspose.Imaging.Brushes.LinearGradientBrush brush =
                                                                                                      new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                          new Aspose.Imaging.Point(0, 0),
                                                                                                          new Aspose.Imaging.Point(bmpImage.Width, bmpImage.Height),
                                                                                                          Aspose.Imaging.Color.Red,
                                                                                                          Aspose.Imaging.Color.Green);

                                                                                                  // Remplir toute l'image avec le pinceau dégradé linéaire.
                                                                                                  Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);
                                                                                                  gr.FillRectangle(brush, bmpImage.Bounds);

                                                                                                  // Obtenir la palette de couleurs 8 bits la plus proche qui couvre autant de pixels que possible, de sorte qu'une image palettisée
                                                                                                  // soit presque visuellement indistinguable d'une image non palettisée.
                                                                                                  Aspose.Imaging.IColorPalette palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette(bmpImage, 256);

                                                                                                  // La palette 8 bits contient au maximum 256 couleurs.
                                                                                                  Aspose.Imaging.ImageOptions.BmpOptions saveOptions = new Aspose.Imaging.ImageOptions.BmpOptions();
                                                                                                  saveOptions.Palette = palette;
                                                                                                  saveOptions.BitsPerPixel = 8;

                                                                                                  using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                  {
                                                                                                      bmpImage.Save(stream, saveOptions);
                                                                                                      System.Console.WriteLine("La taille de l'image palettisée est de {0} octets.", stream.Length);
                                                                                                  }

                                                                                                  using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                  {
                                                                                                      bmpImage.Save(stream);
                                                                                                      System.Console.WriteLine("La taille de l'image non palettisée est de {0} octets.", stream.Length);
                                                                                                  }
                                                                                              }

                                                                                              // La sortie ressemble à ceci :
                                                                                              // La taille de l'image palettisée est de 11078 octets.
                                                                                              // La taille de l'image non palettisée est de 40054 octets.

GetCloseImagePalette(RasterImage, int, PaletteMiningMethod)

Obtient la palette de couleurs d’une image raster (palettise l’image) dans le cas où l’image n’en a pas. La palette est sur le point d’être optimisée pour une meilleure qualité d’image indexée ou prise “EN L’ÉTAT” lorsque PaletteMiningMethod.UseCurrentPalette est utilisé.

public static IColorPalette GetCloseImagePalette(RasterImage image, int entriesCount, PaletteMiningMethod paletteMiningMethod)

Paramètres

image RasterImage

L’image raster.

entriesCount int

Le nombre d’entrées souhaité.

paletteMiningMethod PaletteMiningMethod

La méthode d’extraction de palette.

Retourne

IColorPalette

La palette de couleurs qui commence par les couleurs les plus fréquentes de l’image et contient entriesCount entrées.

Exemples

L’exemple suivant montre comment compresser une image PNG, en utilisant une couleur indexée avec une palette de meilleur ajustement```csharp [C#]

                                                                                                         // Charge l'image png        
                                                                                                             string  sourceFilePath="OriginalRings.png";
                                                                                                             string  outputFilePath="OriginalRingsOutput.png";
                                                                                                             using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(sourceFilePath))
                                                                                                         {
                                                                                                             image.Save(outputFilePath, new Aspose.Imaging.ImageOptions.PngOptions()
                                                                                                             {
                                                                                                                  Progressive = true,
                                                                                                                      // Utiliser le type de couleur indexée
                                                                                                                  ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.IndexedColor,
                                                                                                                      // Utiliser la compression maximale
                                                                                                                  CompressionLevel = 9,
                                                                                                               // Obtenir la palette de couleurs 8 bits la plus proche qui couvre autant de pixels que possible, de sorte qu'une image palettisée
                                                                                                                  // soit presque visuellement indistinguable d'une image non palettisée.
                                                                                                                  Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette((Aspose.Imaging.RasterImage)image, 256, Aspose.Imaging.PaletteMiningMethod.Histogram)
                                                                                                             });
                                                                                                         }
                                                                                                             // La taille du fichier de sortie devrait être considérablement réduite

### <a id="Aspose_Imaging_ColorPaletteHelper_GetCloseImagePalette_Aspose_Imaging_RasterImage_Aspose_Imaging_Rectangle_System_Int32_"></a> GetCloseImagePalette\(RasterImage, Rectangle, int\)

Obtient la palette de couleurs d'une image raster (palettise l'image) dans le cas où l'image n'en a pas. Si une palette existe, elle sera utilisée au lieu d'effectuer des calculs.

```csharp
public static IColorPalette GetCloseImagePalette(RasterImage image, Rectangle destBounds, int entriesCount)

Paramètres

image RasterImage

L’image raster.

destBounds Rectangle

Les limites de l’image de destination.

entriesCount int

Le nombre d’entrées souhaité.

Retourne

IColorPalette

La palette de couleurs qui commence par les couleurs les plus fréquentes de l’image et contient entriesCount entrées.

GetCloseImagePalette(RasterImage, Rectangle, int, bool)

Obtient la palette de couleurs d’une image raster (palettise l’image) dans le cas où l’image n’en a pas. Si une palette existe, elle sera utilisée au lieu d’effectuer des calculs.

public static IColorPalette GetCloseImagePalette(RasterImage image, Rectangle destBounds, int entriesCount, bool useImagePalette)

Paramètres

image RasterImage

L’image raster.

destBounds Rectangle

Les limites de l’image de destination.

entriesCount int

Le nombre d’entrées souhaité.

useImagePalette bool

S’il est défini, il utilisera sa propre palette d’image si disponible.

Retourne

IColorPalette

La palette de couleurs qui commence par les couleurs les plus fréquentes de l’image et contient entriesCount entrées.

GetCloseImagePalette(RasterImage, Rectangle, int, bool, Color)

Obtient la palette de couleurs d’une image raster (palettise l’image) dans le cas où l’image n’en a pas. Si une palette existe, elle sera utilisée au lieu d’effectuer des calculs.

public static IColorPalette GetCloseImagePalette(RasterImage image, Rectangle destBounds, int entriesCount, bool useImagePalette, Color alphaBlendInColor)

Paramètres

image RasterImage

L’image raster.

destBounds Rectangle

Les limites de l’image de destination.

entriesCount int

Le nombre d’entrées souhaité.

useImagePalette bool

S’il est défini, il utilisera sa propre palette d’image si disponible.

alphaBlendInColor Color

La couleur qui doit être utilisée comme couleur de fond pour le remplacement alpha semi-transparent.

Retourne

IColorPalette

La palette de couleurs qui commence par les couleurs les plus fréquentes de l’image et contient entriesCount entrées.

GetCloseImagePalette(RasterImage, Rectangle, int, bool, Color, bool)

Obtient la palette de couleurs d’une image raster (palettise l’image) dans le cas où l’image n’en a pas. Si une palette existe, elle sera utilisée au lieu d’effectuer des calculs.

public static IColorPalette GetCloseImagePalette(RasterImage image, Rectangle destBounds, int entriesCount, bool useImagePalette, Color alphaBlendInColor, bool keepTransparency)

Paramètres

image RasterImage

L’image raster.

destBounds Rectangle

Les limites de l’image de destination.

entriesCount int

Le nombre d’entrées souhaité.

useImagePalette bool

S’il est défini, il utilisera sa propre palette d’image si disponible.

alphaBlendInColor Color

La couleur qui doit être utilisée comme couleur de fond pour le remplacement alpha semi-transparent.

keepTransparency bool

S’il est défini, il considérera les bits du canal alpha des couleurs de l’image.

Retourne

IColorPalette

La palette de couleurs qui commence par les couleurs les plus fréquentes de l’image et contient entriesCount entrées.

GetCloseTransparentImagePalette(RasterImage, int)

Obtient la palette de couleurs d’une image raster (palettise l’image) dans le cas où l’image n’en a pas. Si une palette existe, elle sera utilisée au lieu d’effectuer des calculs.

public static IColorPalette GetCloseTransparentImagePalette(RasterImage image, int entriesCount)

Paramètres

image RasterImage

L’image raster.

entriesCount int

Le nombre d’entrées souhaité.

Retourne

IColorPalette

La palette de couleurs qui commence par les couleurs les plus fréquentes de l’image et contient entriesCount entrées.

GetDownscalePalette(RasterImage)

Obtenir une palette de 256 couleurs, composée des bits supérieurs des valeurs de couleur de l’image initiale.

public static ColorPalette GetDownscalePalette(RasterImage image)

Paramètres

image RasterImage

L’image.

Retourne

ColorPalette

La Aspose.Imaging.ColorPalette.

GetUniformColorPalette(RasterImage)

Obtenir une palette uniforme de 256 couleurs.

public static ColorPalette GetUniformColorPalette(RasterImage image)

Paramètres

image RasterImage

L’image.

Retourne

ColorPalette

La Aspose.Imaging.ColorPalette.

HasTransparentColors(IColorPalette)

Détermine si la palette spécifiée a des couleurs transparentes.

public static bool HasTransparentColors(IColorPalette palette)

Paramètres

palette IColorPalette

La palette.

Retourne

bool

cstrue</code> si la palette spécifiée a des couleurs transparentes ; sinon, csfalse.

Exceptions

ArgumentNullException

palette est null.

 Français