Class ColorPaletteHelper

Class ColorPaletteHelper

Namn på plats: Aspose.Imaging Församling: Aspose.Imaging.dll (25.4.0)

Hjälpklassen för färgpalett manipulation.

public static class ColorPaletteHelper

Inheritance

object ColorPaletteHelper

Arvsmedlemmar

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

Methods

Create4Bit()

Skapar 4 bit färgpaletten.

public static IColorPalette Create4Bit()

Returns

IColorPalette

4 bit färgpalett.

Create4BitGrayscale(Bool)

Skapar den 4 bit gråskaliga paletten.

public static IColorPalette Create4BitGrayscale(bool minIsWhite)

Parameters

minIsWhite bool

Om du ställer in “true” börjar paletten med vit färg, annars börjar det med svart färg.

Returns

IColorPalette

Den 4 bit greyscale paletten.

Create8Bit()

Skapar den 8 bit färgpaletten.

public static IColorPalette Create8Bit()

Returns

IColorPalette

8 bit färgpalett.

Create8BitGrayscale(Bool)

Skapar den 8 bit gråskala paletten.

public static IColorPalette Create8BitGrayscale(bool minIsWhite)

Parameters

minIsWhite bool

Om du ställer in “true” börjar paletten med vit färg, annars börjar det med svart färg.

Returns

IColorPalette

Den 8 bit greyscale paletten.

Examples

Följande exempel skapar en palettierad grayscale BMP-bild och sparar sedan den till en fil.

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

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

                                                                                                      // Save to a file
                                                                                                      createOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(dir + "output.palette8bit.bmp", false);

                                                                                                      // Use 8 bits per pixel to reduce the size of the output image.
                                                                                                      createOptions.BitsPerPixel = 8;

                                                                                                      // Set the standard 8-bit grayscale color palette which covers all grayscale colors.
                                                                                                      // If the processed image contains only grayscale colors, then its palettized version
                                                                                                      // is visually indistinguishable from a non-palletized one.
                                                                                                      createOptions.Palette = Aspose.Imaging.ColorPaletteHelper.Create8BitGrayscale(false);

                                                                                                      // Save without compression.
                                                                                                      // You can also use RLE-8 compression to reduce the size of the output image.
                                                                                                      createOptions.Compression = Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb;

                                                                                                      // Set the horizontal and vertical resolution to 96 dpi.
                                                                                                      createOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

                                                                                                      // Create a BMP image of 100 x 100 px and save it to a file.
                                                                                                      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);

                                                                                                          // Fill the image with a grayscale gradient
                                                                                                          graphics.FillRectangle(gradientBrush, image.Bounds);

                                                                                                          image.Save();
                                                                                                      }

CreateGrayscale(int)

Få den grayscale paletten av angiven bit räkning. Tillåtna bitvärden är 1, 2, 4, 8.

public static IColorPalette CreateGrayscale(int bits)

Parameters

bits int

Den lilla räkningen.

Returns

IColorPalette

Grayscale palett.

Exceptions

ArgumentOutOfRangeException

bits'

CreateMonochrome()

Skapar en monokrom färgpalett som endast innehåller 2 färger.

public static IColorPalette CreateMonochrome()

Returns

IColorPalette

Färgpalett för monochroma bilder.

GetCloseImagePalette(RasterImage, int)

Få färgpalett från rasterbilden (palletizes bild) om bilden inte har en. I fall palett existerar det kommer att användas istället för att utföra beräkningar.

public static IColorPalette GetCloseImagePalette(RasterImage image, int entriesCount)

Parameters

image RasterImage

och rasterbilden.

entriesCount int

De önskade entréerna räknas.

Returns

IColorPalette

Färgpaletten som börjar med de vanligaste färgerna från image’ och innehåller entriesCount’ entries.

Examples

Följande exempel laddar upp en BMP-bild och sparar den tillbaka till BMP med hjälp av olika sparalternativ.

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

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

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

                                                                                                           // Use 8 bits per pixel to reduce the size of the output image.
                                                                                                           saveOptions.BitsPerPixel = 8;

                                                                                                           // Set the closest 8-bit color palette which covers the maximal number of image pixels, so that a palettized image
                                                                                                           // is almost visually indistinguishable from a non-palletized one.
                                                                                                           saveOptions.Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette(rasterImage, 256);

                                                                                                           // Save without compression.
                                                                                                           // You can also use RLE-8 compression to reduce the size of the output image.
                                                                                                           saveOptions.Compression = Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb;

                                                                                                           // Set the horizontal and vertical resolution to 96 dpi.
                                                                                                           saveOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

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

Följande exempel visar hur man palletiserar en BMP-bild för att minska dess utkomststorlek.

// Create a BMP image 100 x 100 px.
                                                                                              using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100))
                                                                                              {
                                                                                                  // The linear gradient from the left-top to the right-bottom corner of the 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);

                                                                                                  // Fill the entire image with the linear gradient brush.
                                                                                                  Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);
                                                                                                  gr.FillRectangle(brush, bmpImage.Bounds);

                                                                                                  // Get the closest 8-bit color palette which covers as many pixels as possible, so that a palettized image
                                                                                                  // is almost visually indistinguishable from a non-palletized one.
                                                                                                  Aspose.Imaging.IColorPalette palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette(bmpImage, 256);

                                                                                                  // 8-bit palette contains at most 256 colors.
                                                                                                  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("The palettized image size is {0} bytes.", stream.Length);
                                                                                                  }

                                                                                                  using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                  {
                                                                                                      bmpImage.Save(stream);
                                                                                                      System.Console.WriteLine("The non-palettized image size is {0} bytes.", stream.Length);
                                                                                                  }
                                                                                              }

                                                                                              // The output looks like this:
                                                                                              // The palettized image size is 11078 bytes.
                                                                                              // The non-palettized image size is 40054 bytes.

GetCloseImagePalette(RasterImage, int, PaletteMiningMethod)

Får färgpalett från rasterbilden (palletizes bild) om bilden inte har en. Paletten kommer att optimeras för bättre indexerad bildkvalitet eller tas “AS IS” när PaletteMiningMethod.UseCurrentPalette används.

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

Parameters

image RasterImage

och rasterbilden.

entriesCount int

De önskade entréerna räknas.

paletteMiningMethod PaletteMiningMethod

Metoden för palettmining.

Returns

IColorPalette

Färgpaletten som börjar med de vanligaste färgerna från image’ och innehåller entriesCount’ entries.

Examples

Följande exempel visar hur man komprimerar en PNG-bild, med hjälp av indexerad färg med bästa fit palett

// Loads png image        
                                                                                                                 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,
                                                                                                                          // Use indexed color type
                                                                                                                      ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.IndexedColor,
                                                                                                                          // Use maximal compression
                                                                                                                      CompressionLevel = 9,
                                                                                                                   // Get the closest 8-bit color palette which covers as many pixels as possible, so that a palettized image
                                                                                                                      // is almost visually indistinguishable from a non-palletized one.
                                                                                                                      Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette((Aspose.Imaging.RasterImage)image, 256, Aspose.Imaging.PaletteMiningMethod.Histogram)
                                                                                                                 });
                                                                                                             }
                                                                                                                 // The output file size should be significantly reduced

GetCloseImagePalette(RasterImage, Rectangle, int)

Få färgpalett från rasterbilden (palletizes bild) om bilden inte har en. I fall palett existerar det kommer att användas istället för att utföra beräkningar.

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

Parameters

image RasterImage

och rasterbilden.

destBounds Rectangle

Destinationsbilden är begränsad.

entriesCount int

De önskade entréerna räknas.

Returns

IColorPalette

Färgpaletten som börjar med de vanligaste färgerna från image’ och innehåller entriesCount’ entries.

GetCloseImagePalette(RasterImage, Rectangle, int, bool)

Få färgpalett från rasterbilden (palletizes bild) om bilden inte har en. I fall palett existerar det kommer att användas istället för att utföra beräkningar.

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

Parameters

image RasterImage

och rasterbilden.

destBounds Rectangle

Destinationsbilden är begränsad.

entriesCount int

De önskade entréerna räknas.

useImagePalette bool

Om den är inställd, kommer den att använda sin egen bildpalett om tillgänglig

Returns

IColorPalette

Färgpaletten som börjar med de vanligaste färgerna från image’ och innehåller entriesCount’ entries.

GetCloseImagePalette(RasterImage, Rectangle, int, bool, Färg)

Få färgpalett från rasterbilden (palletizes bild) om bilden inte har en. I fall palett existerar det kommer att användas istället för att utföra beräkningar.

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

Parameters

image RasterImage

och rasterbilden.

destBounds Rectangle

Destinationsbilden är begränsad.

entriesCount int

De önskade entréerna räknas.

useImagePalette bool

Om den är inställd, kommer den att använda sin egen bildpalett om tillgänglig

alphaBlendInColor Color

Färgen som ska användas som en bakgrundsfärg för semi-transparent alfa ersättning.

Returns

IColorPalette

Färgpaletten som börjar med de vanligaste färgerna från image’ och innehåller entriesCount’ entries.

GetCloseImagePalette(RasterImage, Rectangle, int, bool, Färg, bool)

Få färgpalett från rasterbilden (palletizes bild) om bilden inte har en. I fall palett existerar det kommer att användas istället för att utföra beräkningar.

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

Parameters

image RasterImage

och rasterbilden.

destBounds Rectangle

Destinationsbilden är begränsad.

entriesCount int

De önskade entréerna räknas.

useImagePalette bool

Om den är inställd, kommer den att använda sin egen bildpalett om tillgänglig

alphaBlendInColor Color

Färgen som ska användas som en bakgrundsfärg för semi-transparent alfa ersättning.

keepTransparency bool

Om du ställer in, kommer det att överväga alfa-kanalbiter av bildfärgerna.

Returns

IColorPalette

Färgpaletten som börjar med de vanligaste färgerna från image’ och innehåller entriesCount’ entries.

GetCloseTransparentImagePalette(RasterImage, int)

Få färgpalett från rasterbilden (palletizes bild) om bilden inte har en. I fall palett existerar det kommer att användas istället för att utföra beräkningar.

public static IColorPalette GetCloseTransparentImagePalette(RasterImage image, int entriesCount)

Parameters

image RasterImage

och rasterbilden.

entriesCount int

De önskade entréerna räknas.

Returns

IColorPalette

Färgpaletten som börjar med de vanligaste färgerna från image’ och innehåller entriesCount’ entries.

GetDownscalePalette(RasterImage)

Få 256 färgpalett, bestående av övre bitar av ursprungliga bildfärgvärden.

public static ColorPalette GetDownscalePalette(RasterImage image)

Parameters

image RasterImage

och bilden.

Returns

ColorPalette

Den Aspose.Imaging.ColorPalette.

GetUniformColorPalette(RasterImage)

Få en enhetlig 256 färgpalett.

public static ColorPalette GetUniformColorPalette(RasterImage image)

Parameters

image RasterImage

och bilden.

Returns

ColorPalette

Den Aspose.Imaging.ColorPalette.

HasTransparentColors(Färgpalett)

Bestäm om den angivna paletten har transparenta färger.

public static bool HasTransparentColors(IColorPalette palette)

Parameters

palette IColorPalette

och paletten.

Returns

bool

’true’ om den angivna paletten har transparenta färger; annars, ‘falsk’.

Exceptions

ArgumentNullException

palette’ is null.

 Svenska