Class ColorPaletteHelper

Class ColorPaletteHelper

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

Clase auxiliar para la manipulación de paletas de colores.

public static class ColorPaletteHelper

Herencia

objectColorPaletteHelper

Miembros heredados

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

Métodos

Create4Bit()

Crea la paleta de colores de 4 bits.

public static IColorPalette Create4Bit()

Retorna

IColorPalette

La paleta de colores de 4 bits.

Create4BitGrayscale(bool)

Crea la paleta de escala de grises de 4 bits.

public static IColorPalette Create4BitGrayscale(bool minIsWhite)

Parámetros

minIsWhite bool

si se establece en ```cstrue la paleta comienza con color blanco, de lo contrario comienza con color negro.

Retorna

IColorPalette

La paleta de escala de grises de 4 bits.

Create8Bit()

Crea la paleta de colores de 8 bits.

public static IColorPalette Create8Bit()

Retorna

IColorPalette

La paleta de colores de 8 bits.

Create8BitGrayscale(bool)

Crea la paleta de escala de grises de 8 bits.

public static IColorPalette Create8BitGrayscale(bool minIsWhite)

Parámetros

minIsWhite bool

si se establece en ```cstrue la paleta comienza con color blanco, de lo contrario comienza con color negro.

Retorna

IColorPalette

La paleta de escala de grises de 8 bits.

Ejemplos

El siguiente ejemplo crea una imagen BMP en escala de grises con paleta y luego la guarda en un archivo.```csharp [C#]

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

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

                                                                                                  // Guardar en un archivo
                                                                                                  createOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(dir + "output.palette8bit.bmp", false);

                                                                                                  // Usar 8 bits por píxel para reducir el tamaño de la imagen de salida.
                                                                                                  createOptions.BitsPerPixel = 8;

                                                                                                  // Establecer la paleta de colores en escala de grises de 8 bits estándar que cubre todos los colores en escala de grises.
                                                                                                  // Si la imagen procesada contiene solo colores en escala de grises, entonces su versión con paleta
                                                                                                  // es visualmente indistinguible de una versión sin paleta.
                                                                                                  createOptions.Palette = Aspose.Imaging.ColorPaletteHelper.Create8BitGrayscale(false);

                                                                                                  // Guardar sin compresión.
                                                                                                  // También puede usar compresión RLE-8 para reducir el tamaño de la imagen de salida.
                                                                                                  createOptions.Compression = Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb;

                                                                                                  // Establecer la resolución horizontal y vertical a 96 dpi.
                                                                                                  createOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

                                                                                                  // Crear una imagen BMP de 100 x 100 px y guardarla en un archivo.
                                                                                                  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);

                                                                                                      // Rellenar la imagen con un degradado en escala de grises
                                                                                                      graphics.FillRectangle(gradientBrush, image.Bounds);

                                                                                                      image.Save();
                                                                                                  }

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

Obtiene la paleta de escala de grises de un número de bits especificado. Los valores de bits permitidos son 1, 2, 4, 8.

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

Parámetros

bits int

El número de bits.

Retorna

IColorPalette

Paleta en escala de grises.

Excepciones

ArgumentOutOfRangeException

bits

CreateMonochrome()

Crea una paleta de colores monocromática que contiene solo 2 colores.

public static IColorPalette CreateMonochrome()

Retorna

IColorPalette

Paleta de colores para imágenes monocromáticas.

GetCloseImagePalette(RasterImage, int)

Obtiene la paleta de colores de una imagen rasterizada (paletiza la imagen) en caso de que la imagen no tenga una. En caso de que exista una paleta, se utilizará en lugar de realizar cálculos.

public static IColorPalette GetCloseImagePalette(RasterImage image, int entriesCount)

Parámetros

image RasterImage

La imagen rasterizada.

entriesCount int

El número deseado de entradas.

Retorna

IColorPalette

La paleta de colores que comienza con los colores más frecuentes de la imagen y contiene entriesCount entradas.

Ejemplos

El siguiente ejemplo carga una imagen BMP y la guarda de nuevo en BMP usando varias opciones de guardado.```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;

                                                                                                       // Crear BmpOptions
                                                                                                       Aspose.Imaging.ImageOptions.BmpOptions saveOptions = new Aspose.Imaging.ImageOptions.BmpOptions();

                                                                                                       // Usar 8 bits por píxel para reducir el tamaño de la imagen de salida.
                                                                                                       saveOptions.BitsPerPixel = 8;

                                                                                                       // Establecer la paleta de color de 8 bits más cercana que cubre el número máximo de píxeles de la imagen, de modo que una imagen paletizada
                                                                                                       // sea casi visualmente indistinguible de una sin paletizar.
                                                                                                       saveOptions.Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette(rasterImage, 256);

                                                                                                       // Guardar sin compresión.
                                                                                                       // También puede usar compresión RLE-8 para reducir el tamaño de la imagen de salida.
                                                                                                       saveOptions.Compression = Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb;

                                                                                                       // Establecer la resolución horizontal y vertical a 96 dpi.
                                                                                                       saveOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

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

El siguiente ejemplo muestra cómo paletizar una imagen BMP para reducir su tamaño de salida.```csharp
[C#]

                                                                                              // Crear una imagen BMP de 100 x 100 px.
                                                                                              using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100))
                                                                                              {
                                                                                                  // El degradado lineal desde la esquina superior izquierda hasta la esquina inferior derecha de la imagen.
                                                                                                  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);

                                                                                                  // Rellenar toda la imagen con el pincel de degradado lineal.
                                                                                                  Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);
                                                                                                  gr.FillRectangle(brush, bmpImage.Bounds);

                                                                                                  // Obtener la paleta de color de 8 bits más cercana que cubre la mayor cantidad posible de píxeles, de modo que una imagen paletizada
                                                                                                  // sea casi visualmente indistinguible de una no paletizada.
                                                                                                  Aspose.Imaging.IColorPalette palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette(bmpImage, 256);

                                                                                                  // La paleta de 8 bits contiene como máximo 256 colores.
                                                                                                  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("El tamaño de la imagen paletizada es {0} bytes.", stream.Length);
                                                                                                  }

                                                                                                  using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                  {
                                                                                                      bmpImage.Save(stream);
                                                                                                      System.Console.WriteLine("El tamaño de la imagen sin paletizar es {0} bytes.", stream.Length);
                                                                                                  }
                                                                                              }

                                                                                              // La salida se ve así:
                                                                                              // El tamaño de la imagen paletizada es 11078 bytes.
                                                                                              // El tamaño de la imagen sin paletizar es 40054 bytes.

GetCloseImagePalette(RasterImage, int, PaletteMiningMethod)

Obtiene la paleta de colores de una imagen rasterizada (paletiza la imagen) en caso de que la imagen no tenga una. La paleta está destinada a ser optimizada para una mejor calidad de imagen indexada o tomada “AS IS” cuando se usa PaletteMiningMethod.UseCurrentPalette.

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

Parámetros

image RasterImage

La imagen rasterizada.

entriesCount int

El número deseado de entradas.

paletteMiningMethod PaletteMiningMethod

El método de minería de paletas.

Retorna

IColorPalette

La paleta de colores que comienza con los colores más frecuentes de la imagen y contiene entriesCount entradas.

Ejemplos

El siguiente ejemplo muestra cómo comprimir una imagen PNG, usando color indexado con la mejor paleta ajustada```csharp [C#]

                                                                                                         // Carga la imagen 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,
                                                                                                                      // Usar tipo de color indexado
                                                                                                                  ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.IndexedColor,
                                                                                                                      // Usar compresión máxima
                                                                                                                  CompressionLevel = 9,
                                                                                                               // Obtener la paleta de color de 8 bits más cercana que cubre la mayor cantidad posible de píxeles, de modo que una imagen paletizada
                                                                                                                  // sea casi visualmente indistinguible de una no paletizada.
                                                                                                                  Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette((Aspose.Imaging.RasterImage)image, 256, Aspose.Imaging.PaletteMiningMethod.Histogram)
                                                                                                             });
                                                                                                         }
                                                                                                             // El tamaño del archivo de salida debería reducirse significativamente

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

Obtiene la paleta de colores de una imagen rasterizada (paletiza la imagen) en caso de que la imagen no tenga una. En caso de que exista una paleta, se utilizará en lugar de realizar cálculos.

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

Parámetros

image RasterImage

La imagen rasterizada.

destBounds Rectangle

Los límites de la imagen de destino.

entriesCount int

El número deseado de entradas.

Retorna

IColorPalette

La paleta de colores que comienza con los colores más frecuentes de la imagen y contiene entriesCount entradas.

GetCloseImagePalette(RasterImage, Rectangle, int, bool)

Obtiene la paleta de colores de una imagen rasterizada (paletiza la imagen) en caso de que la imagen no tenga una. En caso de que exista una paleta, se utilizará en lugar de realizar cálculos.

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

Parámetros

image RasterImage

La imagen rasterizada.

destBounds Rectangle

Los límites de la imagen de destino.

entriesCount int

El número deseado de entradas.

useImagePalette bool

Si se establece, utilizará su propia paleta de imagen si está disponible.

Retorna

IColorPalette

La paleta de colores que comienza con los colores más frecuentes de la imagen y contiene entriesCount entradas.

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

Obtiene la paleta de colores de una imagen rasterizada (paletiza la imagen) en caso de que la imagen no tenga una. En caso de que exista una paleta, se utilizará en lugar de realizar cálculos.

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

Parámetros

image RasterImage

La imagen rasterizada.

destBounds Rectangle

Los límites de la imagen de destino.

entriesCount int

El número deseado de entradas.

useImagePalette bool

Si se establece, utilizará su propia paleta de imagen si está disponible.

alphaBlendInColor Color

El color que debe usarse como color de fondo para el reemplazo de alfa semi-transparente.

Retorna

IColorPalette

La paleta de colores que comienza con los colores más frecuentes de la imagen y contiene entriesCount entradas.

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

Obtiene la paleta de colores de una imagen rasterizada (paletiza la imagen) en caso de que la imagen no tenga una. En caso de que exista una paleta, se utilizará en lugar de realizar cálculos.

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

Parámetros

image RasterImage

La imagen rasterizada.

destBounds Rectangle

Los límites de la imagen de destino.

entriesCount int

El número deseado de entradas.

useImagePalette bool

Si se establece, utilizará su propia paleta de imagen si está disponible.

alphaBlendInColor Color

El color que debe usarse como color de fondo para el reemplazo de alfa semi-transparente.

keepTransparency bool

Si se establece, considerará los bits del canal alfa de los colores de la imagen.

Retorna

IColorPalette

La paleta de colores que comienza con los colores más frecuentes de la imagen y contiene entriesCount entradas.

GetCloseTransparentImagePalette(RasterImage, int)

Obtiene la paleta de colores de una imagen rasterizada (paletiza la imagen) en caso de que la imagen no tenga una. En caso de que exista una paleta, se utilizará en lugar de realizar cálculos.

public static IColorPalette GetCloseTransparentImagePalette(RasterImage image, int entriesCount)

Parámetros

image RasterImage

La imagen rasterizada.

entriesCount int

El número deseado de entradas.

Retorna

IColorPalette

La paleta de colores que comienza con los colores más frecuentes de la imagen y contiene entriesCount entradas.

GetDownscalePalette(RasterImage)

Obtiene una paleta de 256 colores, compuesta de los bits superiores de los valores de color de la imagen inicial.

public static ColorPalette GetDownscalePalette(RasterImage image)

Parámetros

image RasterImage

La imagen.

Retorna

ColorPalette

La Aspose.Imaging.ColorPalette.

GetUniformColorPalette(RasterImage)

Obtiene una paleta uniforme de 256 colores.

public static ColorPalette GetUniformColorPalette(RasterImage image)

Parámetros

image RasterImage

La imagen.

Retorna

ColorPalette

La Aspose.Imaging.ColorPalette.

HasTransparentColors(IColorPalette)

Determina si la paleta especificada tiene colores transparentes.

public static bool HasTransparentColors(IColorPalette palette)

Parámetros

palette IColorPalette

La paleta.

Retorna

bool

cstrue</code> si la paleta especificada tiene colores transparentes; de lo contrario, csfalse.

Excepciones

ArgumentNullException

palette es nulo.

 Español