Class ColorPaletteHelper

Class ColorPaletteHelper

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

Classe auxiliar para manipulação de paletas de cores.

public static class ColorPaletteHelper

Herança

objectColorPaletteHelper

Membros Herdados

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

Métodos

Create4Bit()

Cria a paleta de cores de 4 bits.

public static IColorPalette Create4Bit()

Retorna

IColorPalette

A paleta de cores de 4 bits.

Create4BitGrayscale(bool)

Cria a paleta de tons de cinza de 4 bits.

public static IColorPalette Create4BitGrayscale(bool minIsWhite)

Parâmetros

minIsWhite bool

Se definido como ```cstrue, a paleta começa com a cor branca; caso contrário, começa com a cor preta.

Retorna

IColorPalette

A paleta de tons de cinza de 4 bits.

Create8Bit()

Cria a paleta de cores de 8 bits.

public static IColorPalette Create8Bit()

Retorna

IColorPalette

A paleta de cores de 8 bits.

Create8BitGrayscale(bool)

Cria a paleta de tons de cinza de 8 bits.

public static IColorPalette Create8BitGrayscale(bool minIsWhite)

Parâmetros

minIsWhite bool

Se definido como ```cstrue, a paleta começa com a cor branca; caso contrário, começa com a cor preta.

Retorna

IColorPalette

A paleta de tons de cinza de 8 bits.

Exemplos

O exemplo a seguir cria uma imagem BMP em tons de cinza com paleta e a salva em um arquivo.```csharp [C#]

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

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

                                                                                                  // Salvar em um arquivo
                                                                                                  createOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(dir + "output.palette8bit.bmp", false);

                                                                                                  // Usar 8 bits por pixel para reduzir o tamanho da imagem de saída.
                                                                                                  createOptions.BitsPerPixel = 8;

                                                                                                  // Definir a paleta de cores em tons de cinza de 8 bits padrão que cobre todas as cores em tons de cinza.
                                                                                                  // Se a imagem processada contém apenas cores em tons de cinza, então sua versão com paleta
                                                                                                  // é visualmente indistinguível de uma versão sem paleta.
                                                                                                  createOptions.Palette = Aspose.Imaging.ColorPaletteHelper.Create8BitGrayscale(false);

                                                                                                  // Salvar sem compressão.
                                                                                                  // Você também pode usar compressão RLE-8 para reduzir o tamanho da imagem de saída.
                                                                                                  createOptions.Compression = Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb;

                                                                                                  // Definir a resolução horizontal e vertical para 96 dpi.
                                                                                                  createOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

                                                                                                  // Criar uma imagem BMP de 100 x 100 px e salvá-la em um arquivo.
                                                                                                  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);

                                                                                                      // Preencher a imagem com um gradiente em tons de cinza
                                                                                                      graphics.FillRectangle(gradientBrush, image.Bounds);

                                                                                                      image.Save();
                                                                                                  }

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

Obtém a paleta de tons de cinza de contagem de bits especificada. Os valores de bits permitidos são 1, 2, 4, 8.

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

Parâmetros

bits int

A contagem de bits.

Retorna

IColorPalette

Paleta em tons de cinza.

Exceções

ArgumentOutOfRangeException

bits

CreateMonochrome()

Cria uma paleta de cores monocromática contendo apenas 2 cores.

public static IColorPalette CreateMonochrome()

Retorna

IColorPalette

Paleta de cores para imagens monocromáticas.

GetCloseImagePalette(RasterImage, int)

Obtém a paleta de cores de uma imagem raster (paletiza a imagem) caso a imagem não tenha uma. Caso a paleta exista, ela será utilizada em vez de realizar cálculos.

public static IColorPalette GetCloseImagePalette(RasterImage image, int entriesCount)

Parâmetros

image RasterImage

A imagem raster.

entriesCount int

A contagem de entradas desejada.

Retorna

IColorPalette

A paleta de cores que começa com as cores mais frequentes da image e contém entriesCount entradas.

Exemplos

O exemplo a seguir carrega uma imagem BMP e a salva de volta em BMP usando várias opções de salvamento.```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;

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

                                                                                                       // Usar 8 bits por pixel para reduzir o tamanho da imagem de saída.
                                                                                                       saveOptions.BitsPerPixel = 8;

                                                                                                       // Definir a paleta de cores de 8 bits mais próxima que cobre o maior número de pixels da imagem, de modo que uma imagem paletizada
                                                                                                       // seja quase visualmente indistinguível de uma não paletizada.
                                                                                                       saveOptions.Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette(rasterImage, 256);

                                                                                                       // Salvar sem compressão.
                                                                                                       // Você também pode usar compressão RLE-8 para reduzir o tamanho da imagem de saída.
                                                                                                       saveOptions.Compression = Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb;

                                                                                                       // Definir a resolução horizontal e vertical para 96 dpi.
                                                                                                       saveOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

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

O exemplo a seguir mostra como paletizar uma imagem BMP para reduzir seu tamanho de saída.```csharp
[C#]

                                                                                              // Criar uma imagem BMP de 100 x 100 px.
                                                                                              using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100))
                                                                                              {
                                                                                                  // O gradiente linear do canto superior esquerdo para o canto inferior direito da imagem.
                                                                                                  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);

                                                                                                  // Preencher toda a imagem com o pincel de gradiente linear.
                                                                                                  Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);
                                                                                                  gr.FillRectangle(brush, bmpImage.Bounds);

                                                                                                  // Obter a paleta de cores de 8 bits mais próxima que cobre o maior número de pixels possível, de modo que uma imagem paletizada
                                                                                                  // seja quase visualmente indistinguível de uma não paletizada.
                                                                                                  Aspose.Imaging.IColorPalette palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette(bmpImage, 256);

                                                                                                  // A paleta de 8 bits contém no máximo 256 cores.
                                                                                                  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("O tamanho da imagem paletizada é {0} bytes.", stream.Length);
                                                                                                  }

                                                                                                  using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                  {
                                                                                                      bmpImage.Save(stream);
                                                                                                      System.Console.WriteLine("O tamanho da imagem não paletizada é {0} bytes.", stream.Length);
                                                                                                  }
                                                                                              }

                                                                                              // A saída se parece com isto:
                                                                                              // O tamanho da imagem paletizada é 11078 bytes.
                                                                                              // O tamanho da imagem não paletizada é 40054 bytes.

GetCloseImagePalette(RasterImage, int, PaletteMiningMethod)

Obtém a paleta de cores de uma imagem raster (paletiza a imagem) caso a imagem não tenha uma. A paleta está prestes a ser otimizada para melhor qualidade de imagem indexada ou tomada “COMO ESTÁ” quando PaletteMiningMethod.UseCurrentPalette é usado.

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

Parâmetros

image RasterImage

A imagem raster.

entriesCount int

A contagem de entradas desejada.

paletteMiningMethod PaletteMiningMethod

O método de mineração de paleta.

Retorna

IColorPalette

A paleta de cores que começa com as cores mais frequentes da image e contém entriesCount entradas.

Exemplos

O exemplo a seguir mostra como comprimir uma imagem PNG, usando cor indexada com paleta de melhor ajuste.```csharp [C#]

                                                                                                         // Carrega imagem 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 cor indexada
                                                                                                                  ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.IndexedColor,
                                                                                                                      // Usar compressão máxima
                                                                                                                  CompressionLevel = 9,
                                                                                                               // Obter a paleta de cores de 8 bits mais próxima que cobre o maior número de pixels possível, de modo que uma imagem paletizada
                                                                                                                  // seja quase visualmente indistinguível de uma não paletizada.
                                                                                                                  Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette((Aspose.Imaging.RasterImage)image, 256, Aspose.Imaging.PaletteMiningMethod.Histogram)
                                                                                                             });
                                                                                                         }
                                                                                                             // O tamanho do arquivo de saída deve ser significativamente reduzido

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

Obtém a paleta de cores de uma imagem raster (paletiza a imagem) caso a imagem não tenha uma. Caso a paleta exista, ela será utilizada em vez de realizar cálculos.

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

Parâmetros

image RasterImage

A imagem raster.

destBounds Rectangle

Os limites da imagem de destino.

entriesCount int

A contagem de entradas desejada.

Retorna

IColorPalette

A paleta de cores que começa com as cores mais frequentes da image e contém entriesCount entradas.

GetCloseImagePalette(RasterImage, Rectangle, int, bool)

Obtém a paleta de cores de uma imagem raster (paletiza a imagem) caso a imagem não tenha uma. Caso a paleta exista, ela será utilizada em vez de realizar cálculos.

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

Parâmetros

image RasterImage

A imagem raster.

destBounds Rectangle

Os limites da imagem de destino.

entriesCount int

A contagem de entradas desejada.

useImagePalette bool

Se definido, usará sua própria paleta de imagem se disponível.

Retorna

IColorPalette

A paleta de cores que começa com as cores mais frequentes da image e contém entriesCount entradas.

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

Obtém a paleta de cores de uma imagem raster (paletiza a imagem) caso a imagem não tenha uma. Caso a paleta exista, ela será utilizada em vez de realizar cálculos.

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

Parâmetros

image RasterImage

A imagem raster.

destBounds Rectangle

Os limites da imagem de destino.

entriesCount int

A contagem de entradas desejada.

useImagePalette bool

Se definido, usará sua própria paleta de imagem se disponível.

alphaBlendInColor Color

A cor que deve ser usada como cor de fundo para substituição alfa semitransparente.

Retorna

IColorPalette

A paleta de cores que começa com as cores mais frequentes da image e contém entriesCount entradas.

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

Obtém a paleta de cores de uma imagem raster (paletiza a imagem) caso a imagem não tenha uma. Caso a paleta exista, ela será utilizada em vez de realizar cálculos.

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

Parâmetros

image RasterImage

A imagem raster.

destBounds Rectangle

Os limites da imagem de destino.

entriesCount int

A contagem de entradas desejada.

useImagePalette bool

Se definido, usará sua própria paleta de imagem se disponível.

alphaBlendInColor Color

A cor que deve ser usada como cor de fundo para substituição alfa semitransparente.

keepTransparency bool

Se definido, considerará os bits do canal alfa das cores da imagem.

Retorna

IColorPalette

A paleta de cores que começa com as cores mais frequentes da image e contém entriesCount entradas.

GetCloseTransparentImagePalette(RasterImage, int)

Obtém a paleta de cores de uma imagem raster (paletiza a imagem) caso a imagem não tenha uma. Caso a paleta exista, ela será utilizada em vez de realizar cálculos.

public static IColorPalette GetCloseTransparentImagePalette(RasterImage image, int entriesCount)

Parâmetros

image RasterImage

A imagem raster.

entriesCount int

A contagem de entradas desejada.

Retorna

IColorPalette

A paleta de cores que começa com as cores mais frequentes da image e contém entriesCount entradas.

GetDownscalePalette(RasterImage)

Obtém uma paleta de 256 cores, composta dos bits superiores dos valores de cor da imagem inicial.

public static ColorPalette GetDownscalePalette(RasterImage image)

Parâmetros

image RasterImage

A imagem.

Retorna

ColorPalette

A Aspose.Imaging.ColorPalette.

GetUniformColorPalette(RasterImage)

Obtém uma paleta uniforme de 256 cores.

public static ColorPalette GetUniformColorPalette(RasterImage image)

Parâmetros

image RasterImage

A imagem.

Retorna

ColorPalette

A Aspose.Imaging.ColorPalette.

HasTransparentColors(IColorPalette)

Determina se a paleta especificada possui cores transparentes.

public static bool HasTransparentColors(IColorPalette palette)

Parâmetros

palette IColorPalette

A paleta.

Retorna

bool

cstrue</code> se a paleta especificada possui cores transparentes; caso contrário, csfalse.

Exceções

ArgumentNullException

palette é nulo.

 Português