Class ColorPaletteHelper

Class ColorPaletteHelper

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

מחלקת עזר למניפולציה של פלטות צבעים.

public static class ColorPaletteHelper

ירושה

objectColorPaletteHelper

חברים ירושים

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

שיטות

Create4Bit()

יוצר את פלטת הצבעים בגודל 4 ביט.

public static IColorPalette Create4Bit()

מחזיר

IColorPalette

פלטת הצבעים בגודל 4 ביט.

Create4BitGrayscale(bool)

יוצר את פלטת הגרסקייל בגודל 4 ביט.

public static IColorPalette Create4BitGrayscale(bool minIsWhite)

פרמטרים

minIsWhite bool

אם מוגדר ל-```cstrue הפלטה מתחילה בצבע לבן, אחרת היא מתחילה בצבע שחור.

מחזיר

IColorPalette

פלטת הגרסקייל בגודל 4 ביט.

Create8Bit()

יוצר את פלטת הצבעים בגודל 8 ביט.

public static IColorPalette Create8Bit()

מחזיר

IColorPalette

פלטת הצבעים בגודל 8 ביט.

Create8BitGrayscale(bool)

יוצר את פלטת הגרסקייל בגודל 8 ביט.

public static IColorPalette Create8BitGrayscale(bool minIsWhite)

פרמטרים

minIsWhite bool

אם מוגדר ל-```cstrue הפלטה מתחילה בצבע לבן, אחרת היא מתחילה בצבע שחור.

מחזיר

IColorPalette

פלטת הגרסקייל בגודל 8 ביט.

דוגמאות

הדוגמה הבאה יוצרת תמונת BMP בגווני אפור עם פלטה ואז שומרת אותה לקובץ.```csharp [C#]

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

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

                                                                                                  // שמירה לקובץ
                                                                                                  createOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(dir + "output.palette8bit.bmp", false);

                                                                                                  // השתמש ב-8 ביטים לכל פיקסל כדי לצמצם את גודל התמונה המוצאת.
                                                                                                  createOptions.BitsPerPixel = 8;

                                                                                                  // הגדר את פלטת הצבעים בגווני אפור בגודל 8 ביט המכסה את כל צבעי הגרסקייל.
                                                                                                  // אם התמונה המעובדת מכילה רק צבעים בגווני אפור, אז הגרסה עם הפלטה שלה
                                                                                                  // לא ניתנת להבחנה ויזואלית מגרסה ללא פלטה.
                                                                                                  createOptions.Palette = Aspose.Imaging.ColorPaletteHelper.Create8BitGrayscale(false);

                                                                                                  // שמירה ללא דחיסה.
                                                                                                  // ניתן גם להשתמש בדחיסת RLE-8 כדי לצמצם את גודל התמונה המוצאת.
                                                                                                  createOptions.Compression = Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb;

                                                                                                  // הגדר את הרזולוציה האופקית והאנכית ל-96 dpi.
                                                                                                  createOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

                                                                                                  // צור תמונת BMP בגודל 100 x 100 פיקסלים ושמור אותה לקובץ.
                                                                                                  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);

                                                                                                      // מלא את התמונה עם גרדיאנט בגווני אפור
                                                                                                      graphics.FillRectangle(gradientBrush, image.Bounds);

                                                                                                      image.Save();
                                                                                                  }

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

מקבל את פלטת הגרסקייל של מספר הביטים שצוין. ערכי הביטים המורשים הם 1, 2, 4, 8.

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

פרמטרים

bits int

מספר הביטים.

מחזיר

IColorPalette

פלטת גרסקייל.

חריגות

ArgumentOutOfRangeException

bits

CreateMonochrome()

יוצר פלטת צבעים מונוכרומית המכילה 2 צבעים בלבד.

public static IColorPalette CreateMonochrome()

מחזיר

IColorPalette

פלטת צבעים לתמונות מונוכרומיות.

GetCloseImagePalette(RasterImage, int)

מקבל פלטת צבעים מתמונה רסטרית (ממלא את התמונה בפלטה) במקרה שהתמונה לא מכילה אחת. במקרה שהפלטה קיימת היא תישתמש במקום לבצע חישובים.

public static IColorPalette GetCloseImagePalette(RasterImage image, int entriesCount)

פרמטרים

image RasterImage

התמונה הרסטרית.

entriesCount int

מספר הכניסות הרצוי.

מחזיר

IColorPalette

פלטת הצבעים המתחילה עם הצבעים הנפוצים ביותר מה-image ומכילה entriesCount כניסות.

דוגמאות

הדוגמה הבאה טוענת תמונת BMP ושומרת אותה חזרה ל-BMP באמצעות אפשרויות שמירה שונות.```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;

                                                                                                       // צור את BmpOptions
                                                                                                       Aspose.Imaging.ImageOptions.BmpOptions saveOptions = new Aspose.Imaging.ImageOptions.BmpOptions();

                                                                                                       // השתמש ב-8 ביטים לכל פיקסל כדי לצמצם את גודל התמונה המוצאת.
                                                                                                       saveOptions.BitsPerPixel = 8;

                                                                                                       // הגדר את פלטת הצבעים הקרובה בגודל 8 ביט המכסה את המספר המרבי של פיקסלי התמונה, כך שהתמונה עם הפלטה
                                                                                                       // כמעט לא ניתנת להבחנה מגרסה ללא פלטה.
                                                                                                       saveOptions.Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette(rasterImage, 256);

                                                                                                       // שמירה ללא דחיסה.
                                                                                                       // ניתן גם להשתמש בדחיסת RLE-8 כדי לצמצם את גודל התמונה המוצאת.
                                                                                                       saveOptions.Compression = Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb;

                                                                                                       // הגדר את הרזולוציה האופקית והאנכית ל-96 dpi.
                                                                                                       saveOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);

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

הדוגמה הבאה מראה כיצד למלא פלטת צבעים לתמונה BMP כדי לצמצם את גודל הפלט שלה.```csharp
[C#]

                                                                                              // צור תמונת BMP בגודל 100 x 100 פיקסלים.
                                                                                              using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100))
                                                                                              {
                                                                                                  // הגרדיאנט הליניארי מהפינה השמאלית-עליון לפינה הימנית-תחתון של התמונה.
                                                                                                  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);

                                                                                                  // מלא את כל התמונה עם מברשת הגרדיאנט הליניארי.
                                                                                                  Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);
                                                                                                  gr.FillRectangle(brush, bmpImage.Bounds);

                                                                                                  // קבל את פלטת הצבעים הקרובה בגודל 8 ביט המכסה כמה שיותר פיקסלים, כך שהתמונה עם הפלטה
                                                                                                  // כמעט לא ניתנת להבחנה מגרסה ללא פלטה.
                                                                                                  Aspose.Imaging.IColorPalette palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette(bmpImage, 256);

                                                                                                  // פלטת 8 ביט מכילה לכל היותר 256 צבעים.
                                                                                                  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("גודל התמונה עם הפלטה הוא {0} בייטים.", stream.Length);
                                                                                                  }

                                                                                                  using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                  {
                                                                                                      bmpImage.Save(stream);
                                                                                                      System.Console.WriteLine("גודל התמונה ללא הפלטה הוא {0} בייטים.", stream.Length);
                                                                                                  }
                                                                                              }

                                                                                              // הפלט נראה כך:
                                                                                              // גודל התמונה עם הפלטה הוא 11078 בייטים.
                                                                                              // גודל התמונה ללא הפלטה הוא 40054 בייטים.

GetCloseImagePalette(RasterImage, int, PaletteMiningMethod)

מקבל פלטת צבעים מתמונה רסטרית (ממלא את התמונה בפלטה) במקרה שהתמונה לא מכילה אחת. הפלטה עומדת להיות אופטימלית לאיכות התמונה הממוסדת או נלקחת “כפי שהיא” כאשר PaletteMiningMethod.UseCurrentPalette משומשת.

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

פרמטרים

image RasterImage

התמונה הרסטרית.

entriesCount int

מספר הכניסות הרצוי.

paletteMiningMethod PaletteMiningMethod

שיטת חפירת הפלטה.

מחזיר

IColorPalette

פלטת הצבעים המתחילה עם הצבעים הנפוצים ביותר מה-image ומכילה entriesCount כניסות.

דוגמאות

הדוגמה הבאה מראה כיצד לדחוס תמונת PNG, באמצעות צבע ממוסד עם פלטת צבעים הטובה ביותר.```csharp [C#]

                                                                                                         // טוען תמונת 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,
                                                                                                                      // השתמש בסוג צבע ממוסד
                                                                                                                  ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.IndexedColor,
                                                                                                                      // השתמש בדחיסה מקסימלית
                                                                                                                  CompressionLevel = 9,
                                                                                                               // קבל את פלטת הצבעים הקרובה בגודל 8 ביט המכסה כמה שיותר פיקסלים, כך שהתמונה עם הפלטה
                                                                                                                  // כמעט לא ניתנת להבחנה מגרסה ללא פלטה.
                                                                                                                  Palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette((Aspose.Imaging.RasterImage)image, 256, Aspose.Imaging.PaletteMiningMethod.Histogram)
                                                                                                             });
                                                                                                         }
                                                                                                             // גודל הקובץ המוצא צריך להיות מצומצם באופן משמעותי

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

מקבל פלטת צבעים מתמונה רסטרית (ממלא את התמונה בפלטה) במקרה שהתמונה לא מכילה אחת. במקרה שהפלטה קיימת היא תישתמש במקום לבצע חישובים.

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

פרמטרים

image RasterImage

התמונה הרסטרית.

destBounds Rectangle

גבולות התמונה המיועדת.

entriesCount int

מספר הכניסות הרצוי.

מחזיר

IColorPalette

פלטת הצבעים המתחילה עם הצבעים הנפוצים ביותר מה-image ומכילה entriesCount כניסות.

GetCloseImagePalette(RasterImage, Rectangle, int, bool)

מקבל פלטת צבעים מתמונה רסטרית (ממלא את התמונה בפלטה) במקרה שהתמונה לא מכילה אחת. במקרה שהפלטה קיימת היא תישתמש במקום לבצע חישובים.

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

פרמטרים

image RasterImage

התמונה הרסטרית.

destBounds Rectangle

גבולות התמונה המיועדת.

entriesCount int

מספר הכניסות הרצוי.

useImagePalette bool

אם מוגדר, הוא ישתמש בפלטת התמונה שלו אם זמינה.

מחזיר

IColorPalette

פלטת הצבעים המתחילה עם הצבעים הנפוצים ביותר מה-image ומכילה entriesCount כניסות.

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

מקבל פלטת צבעים מתמונה רסטרית (ממלא את התמונה בפלטה) במקרה שהתמונה לא מכילה אחת. במקרה שהפלטה קיימת היא תישתמש במקום לבצע חישובים.

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

פרמטרים

image RasterImage

התמונה הרסטרית.

destBounds Rectangle

גבולות התמונה המיועדת.

entriesCount int

מספר הכניסות הרצוי.

useImagePalette bool

אם מוגדר, הוא ישתמש בפלטת התמונה שלו אם זמינה.

alphaBlendInColor Color

הצבע שישמש כצבע רקע להחלפת אלפא חצי שקוף.

מחזיר

IColorPalette

פלטת הצבעים המתחילה עם הצבעים הנפוצים ביותר מה-image ומכילה entriesCount כניסות.

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

מקבל פלטת צבעים מתמונה רסטרית (ממלא את התמונה בפלטה) במקרה שהתמונה לא מכילה אחת. במקרה שהפלטה קיימת היא תישתמש במקום לבצע חישובים.

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

פרמטרים

image RasterImage

התמונה הרסטרית.

destBounds Rectangle

גבולות התמונה המיועדת.

entriesCount int

מספר הכניסות הרצוי.

useImagePalette bool

אם מוגדר, הוא ישתמש בפלטת התמונה שלו אם זמינה.

alphaBlendInColor Color

הצבע שישמש כצבע רקע להחלפת אלפא חצי שקוף.

keepTransparency bool

אם מוגדר, הוא יתחשב בביטוי הערוץ האלפא של צבעי התמונה.

מחזיר

IColorPalette

פלטת הצבעים המתחילה עם הצבעים הנפוצים ביותר מה-image ומכילה entriesCount כניסות.

GetCloseTransparentImagePalette(RasterImage, int)

מקבל פלטת צבעים מתמונה רסטרית (ממלא את התמונה בפלטה) במקרה שהתמונה לא מכילה אחת. במקרה שהפלטה קיימת היא תישתמש במקום לבצע חישובים.

public static IColorPalette GetCloseTransparentImagePalette(RasterImage image, int entriesCount)

פרמטרים

image RasterImage

התמונה הרסטרית.

entriesCount int

מספר הכניסות הרצוי.

מחזיר

IColorPalette

פלטת הצבעים המתחילה עם הצבעים הנפוצים ביותר מה-image ומכילה entriesCount כניסות.

GetDownscalePalette(RasterImage)

מקבל פלטת צבעים בגודל 256, המורכבת מביטוי עליון של ערכי צבעים בתמונה המקורית.

public static ColorPalette GetDownscalePalette(RasterImage image)

פרמטרים

image RasterImage

התמונה.

מחזיר

ColorPalette

הפלטה של Aspose.Imaging.ColorPalette.

GetUniformColorPalette(RasterImage)

מקבל פלטת צבעים אחידה בגודל 256.

public static ColorPalette GetUniformColorPalette(RasterImage image)

פרמטרים

image RasterImage

התמונה.

מחזיר

ColorPalette

הפלטה של Aspose.Imaging.ColorPalette.

HasTransparentColors(IColorPalette)

קובע אם הפלטה שצוינה מכילה צבעים שקופים.

public static bool HasTransparentColors(IColorPalette palette)

פרמטרים

palette IColorPalette

הפלטה.

מחזיר

bool

cstrue</code> אם הפלטה שצוינה מכילה צבעים שקופים; אחרת, csfalse.

חריגות

ArgumentNullException

palette הוא null.

 Ελληνικά