Class RasterImage
Nazwa przestrzeń: Aspose.Imaging Zgromadzenie: Aspose.Imaging.dll (25.4.0)
Przedstawia obraz raster obsługujący operacje grafiki raster.
public abstract class RasterImage : Image, IDisposable, IObjectWithBounds, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, IHasXmpData, IHasMetadataInheritance
object ← DisposableObject ← DataStreamSupporter ← Image ← RasterImage
Derived
Implements
IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata
Dziedziczeni członkowie
Image.CanLoad(string) , Image.CanLoad(string, LoadOptions) , Image.CanLoad(Stream) , Image.CanLoad(Stream, LoadOptions) , Image.Create(ImageOptionsBase, int, int) , Image.Create(Image[]) , Image.Create(MultipageCreateOptions) , Image.Create(string[], bool) , Image.Create(string[]) , Image.Create(Image[], bool) , Image.GetFileFormat(string) , Image.GetFileFormat(Stream) , Image.GetFittingRectangle(Rectangle, int, int) , Image.GetFittingRectangle(Rectangle, int[], int, int) , Image.Load(string, LoadOptions) , Image.Load(string) , Image.Load(Stream, LoadOptions) , Image.Load(Stream) , Image.GetProportionalWidth(int, int, int) , Image.GetProportionalHeight(int, int, int) , Image.RemoveMetadata() , Image.CanSave(ImageOptionsBase) , Image.Resize(int, int) , Image.Resize(int, int, ResizeType) , Image.Resize(int, int, ImageResizeSettings) , Image.GetDefaultOptions(object[]) , Image.GetOriginalOptions() , Image.ResizeWidthProportionally(int) , Image.ResizeHeightProportionally(int) , Image.ResizeWidthProportionally(int, ResizeType) , Image.ResizeHeightProportionally(int, ResizeType) , Image.ResizeWidthProportionally(int, ImageResizeSettings) , Image.ResizeHeightProportionally(int, ImageResizeSettings) , Image.RotateFlip(RotateFlipType) , Image.Rotate(float) , Image.Crop(Rectangle) , Image.Crop(int, int, int, int) , Image.Save() , Image.Save(string) , Image.Save(string, ImageOptionsBase) , Image.Save(string, ImageOptionsBase, Rectangle) , Image.Save(Stream, ImageOptionsBase) , Image.Save(Stream, ImageOptionsBase, Rectangle) , Image.GetSerializedStream(ImageOptionsBase, Rectangle, out int) , Image.SetPalette(IColorPalette, bool) , Image.UpdateContainer(Image) , Image.GetCanNotSaveMessage(ImageOptionsBase) , Image.GetFitRectangle(Rectangle) , Image.GetImage2Export(ImageOptionsBase, Rectangle, IImageExporter) , Image.GetFitRectangle(Rectangle, int[]) , Image.OnPaletteChanged(IColorPalette, IColorPalette) , Image.OnPaletteChanging(IColorPalette, IColorPalette) , Image.ReleaseManagedResources() , Image.BitsPerPixel , Image.Bounds , Image.Container , Image.Height , Image.Palette , Image.UsePalette , Image.Size , Image.Width , Image.InterruptMonitor , Image.BufferSizeHint , Image.AutoAdjustPalette , Image.HasBackgroundColor , Image.FileFormat , Image.BackgroundColor , DataStreamSupporter.timeout , DataStreamSupporter.CacheData() , DataStreamSupporter.Save() , DataStreamSupporter.Save(Stream) , DataStreamSupporter.Save(string) , DataStreamSupporter.Save(string, bool) , DataStreamSupporter.SaveData(Stream) , DataStreamSupporter.ReleaseManagedResources() , DataStreamSupporter.OnDataStreamContainerChanging(StreamContainer) , DataStreamSupporter.DataStreamContainer , DataStreamSupporter.IsCached , DisposableObject.Dispose() , DisposableObject.ReleaseManagedResources() , DisposableObject.ReleaseUnmanagedResources() , DisposableObject.VerifyNotDisposed() , DisposableObject.Disposed , object.GetType() , object.MemberwiseClone() , object.ToString() , object.Equals(object?) , object.Equals(object?, object?) , object.ReferenceEquals(object?, object?) , object.GetHashCode()
Examples
Ten przykład pokazuje, jak pobierać informacje o pikselach w Array typu Koloru, manipulować array i ustawić je z powrotem na obraz. Aby wykonać te czynności, ten przykład tworzy nowy plik obrazu (w formacie GIF) uisng Obiekt MemoryStream.
//Create an instance of MemoryStream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
//Create an instance of GifOptions and set its various properties including the Source property
Aspose.Imaging.ImageOptions.GifOptions gifOptions = new Aspose.Imaging.ImageOptions.GifOptions();
gifOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);
//Create an instance of Image
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Create(gifOptions, 500, 500))
{
//Get the pixels of image by specifying the area as image boundary
Aspose.Imaging.Color[] pixels = image.LoadPixels(image.Bounds);
//Loop over the Array and sets color of alrenative indexed pixel
for (int index = 0; index < pixels.Length; index++)
{
if (index % 2 == 0)
{
//Set the indexed pixel color to yellow
pixels[index] = Aspose.Imaging.Color.Yellow;
}
else
{
//Set the indexed pixel color to blue
pixels[index] = Aspose.Imaging.Color.Blue;
}
}
//Apply the pixel changes to the image
image.SavePixels(image.Bounds, pixels);
// save all changes.
image.Save();
}
// Write MemoryStream to File
using (System.IO.FileStream fileStream = new System.IO.FileStream(@"C:\temp\output.gif", System.IO.FileMode.Create))
{
stream.WriteTo(fileStream);
}
}Constructors
RasterImage()
Inicjalizuje nową instancję klasy Aspose.Imaging.RasterImage.
[JsonConstructor]
protected RasterImage()RasterImage(Kolorowe palety)
Inicjalizuje nową instancję klasy Aspose.Imaging.RasterImage.
protected RasterImage(IColorPalette colorPalette)Parameters
colorPalette IColorPalette
Kolorowe palety .
Fields
xmpData
Metody XMP
[JsonProperty]
protected XmpPacketWrapper xmpDataWartość pola
Properties
DataLoader
Pobierz lub ustawić ładowarkę danych.
[JsonProperty]
protected IRasterImageArgb32PixelLoader DataLoader { get; set; }Wartość nieruchomości
HasAlpha
Otrzymuje wartość wskazującą, czy ta instancja ma alfa.
public virtual bool HasAlpha { get; }Wartość nieruchomości
Examples
Poniższy przykład ładuje obrazy rasterowe i drukuje informacje na temat formatu surowych danych i kanału alfa.
// The image files to load.
string[] fileNames = new string[]
{
@"c:\temp\sample.bmp",
@"c:\temp\alpha.png",
};
foreach (string fileName in fileNames)
{
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(fileName))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
System.Console.WriteLine("ImageFile={0}, FileFormat={1}, HasAlpha={2}", fileName, rasterImage.RawDataFormat, rasterImage.HasAlpha);
}
}
// The output may look like this:
// ImageFile=c:\temp\sample.bmp, FileFormat=Rgb24Bpp, used channels: 8,8,8, HasAlpha=False
// ImageFile=c:\temp\alpha.png, FileFormat=RGBA32Bpp, used channels: 8,8,8,8, HasAlpha=TruePoniższy przykład pokazuje, jak wyciągnąć informacje o surowym formacie danych i kanał alfa z obrazu BMP.
// Create a 32-bpp BMP image of 100 x 100 px.
using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 32, null))
{
System.Console.WriteLine("FileFormat={0}, RawDataFormat={1}, HasAlpha={2}", bmpImage.FileFormat, bmpImage.RawDataFormat, bmpImage.HasAlpha);
};
// Create a 24-bpp BMP image of 100 x 100 px.
using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 24, null))
{
System.Console.WriteLine("FileFormat={0}, RawDataFormat={1}, HasAlpha={2}", bmpImage.FileFormat, bmpImage.RawDataFormat, bmpImage.HasAlpha);
};
// Generally, BMP doesn't support alpha channel so the output will look like this:
// FileFormat = Bmp, RawDataFormat = Rgb32Bpp, used channels: 8,8,8,8, HasAlpha = False
// FileFormat = Bmp, RawDataFormat = Rgb24Bpp, used channels: 8,8,8, HasAlpha = FalseHasTransparentColor
Otrzymuje wartość wskazującą, czy obraz ma przejrzysty kolor.
public virtual bool HasTransparentColor { get; set; }Wartość nieruchomości
HorizontalResolution
Otrzymuje lub ustawia rozdzielczość horyzontalną, w pikselach na cala, tego Aspose.Imaging.RasterImage.
public virtual double HorizontalResolution { get; set; }Wartość nieruchomości
Examples
Poniższy przykład pokazuje, jak ustawić rozdzielczość horyzontalną / pionową obrazu rasterowego.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.jpg"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Get horizontal and vertical resolution of the image
double horizontalResolution = rasterImage.HorizontalResolution;
double verticalResolution = rasterImage.VerticalResolution;
System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", horizontalResolution);
System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", verticalResolution);
if (horizontalResolution != 96.0 || verticalResolution != 96.0)
{
// Use the SetResolution method for updating both resolution values in a single call.
System.Console.WriteLine("Set resolution values to 96 dpi");
rasterImage.SetResolution(96.0, 96.0);
System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", rasterImage.HorizontalResolution);
System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", rasterImage.VerticalResolution);
}
// The output may look like this:
// The horizontal resolution, in pixels per inch: 300
// The vertical resolution, in pixels per inch: 300
// Set resolution values to 96 dpi
// The horizontal resolution, in pixels per inch: 96
// The vertical resolution, in pixels per inch: 96
}Remarks
Zazwyczaj wartość ta wynosi zawsze 96 ponieważ różne platformy nie mogą zwrócić rozdzielczości ekranu. Możesz rozważyć użycie metody SetResolution, aby zaktualizować oba wartości rozdzielczości w jednym wezwaniu.
ImageOpacity
Zyskuje opację tego obrazu.
public virtual float ImageOpacity { get; }Wartość nieruchomości
IsRawDataAvailable
Otrzymuje wartość wskazującą, czy ładowanie surowych danych jest dostępne.
public bool IsRawDataAvailable { get; }Wartość nieruchomości
PremultiplyComponents
Otrzymuje lub ustawia wartość wskazującą, czy elementy obrazu muszą być przedwzroczone.
public virtual bool PremultiplyComponents { get; set; }Wartość nieruchomości
Examples
Poniższy przykład tworzy nowy obraz raster, przechowuje określone półprzejrzałe piksele, a następnie ładuje te piksely i otrzymuje ostateczne kolory w uprzedniej formie.
int imageWidth = 3;
int imageHeight = 2;
Aspose.Imaging.Color[] colors = new Aspose.Imaging.Color[]
{
Aspose.Imaging.Color.FromArgb(127, 255, 0, 0),
Aspose.Imaging.Color.FromArgb(127, 0, 255, 0),
Aspose.Imaging.Color.FromArgb(127, 0, 0, 255),
Aspose.Imaging.Color.FromArgb(127, 255, 255, 0),
Aspose.Imaging.Color.FromArgb(127, 255, 0, 255),
Aspose.Imaging.Color.FromArgb(127, 0, 255, 255),
};
Aspose.Imaging.ImageOptions.PngOptions createOptions = new Aspose.Imaging.ImageOptions.PngOptions();
createOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream(), true);
createOptions.ColorType = Aspose.Imaging.FileFormats.Png.PngColorType.TruecolorWithAlpha;
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Create(createOptions, imageWidth, imageHeight))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Save pixels for the whole image.
rasterImage.SavePixels(rasterImage.Bounds, colors);
// The pixels are stored in the original image in the non-premultiplied form.
// Need to specify the corresponding option explicitly to obtain premultiplied color components.
// The premultiplied color components are calculated by the formulas:
// red = original_red * alpha / 255;
// green = original_green * alpha / 255;
// blue = original_blue * alpha / 255;
rasterImage.PremultiplyComponents = true;
Aspose.Imaging.Color[] premultipliedColors = rasterImage.LoadPixels(rasterImage.Bounds);
for (int i = 0; i < colors.Length; i++)
{
System.Console.WriteLine("Original color: {0}", colors[i].ToString());
System.Console.WriteLine("Premultiplied color: {0}", premultipliedColors[i].ToString());
}
}RawCustomColorConverter
otrzymuje lub ustawia konwerter kolorów
public IColorConverter RawCustomColorConverter { get; set; }Wartość nieruchomości
RawDataFormat
Dostęp do formatu surowych danych.
public virtual PixelDataFormat RawDataFormat { get; }Wartość nieruchomości
Examples
Poniższy przykład ładuje obrazy rasterowe i drukuje informacje na temat formatu surowych danych i kanału alfa.
// The image files to load.
string[] fileNames = new string[]
{
@"c:\temp\sample.bmp",
@"c:\temp\alpha.png",
};
foreach (string fileName in fileNames)
{
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(fileName))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
System.Console.WriteLine("ImageFile={0}, FileFormat={1}, HasAlpha={2}", fileName, rasterImage.RawDataFormat, rasterImage.HasAlpha);
}
}
// The output may look like this:
// ImageFile=c:\temp\sample.bmp, FileFormat=Rgb24Bpp, used channels: 8,8,8, HasAlpha=False
// ImageFile=c:\temp\alpha.png, FileFormat=RGBA32Bpp, used channels: 8,8,8,8, HasAlpha=TrueTen przykład pokazuje, jak pobrać obraz DJVU z przepływu plików i wydrukować informacje o stronach.
string dir = "c:\\temp\\";
// Load a DJVU image from a file stream.
using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.djvu"))
{
using (Aspose.Imaging.FileFormats.Djvu.DjvuImage djvuImage = new Aspose.Imaging.FileFormats.Djvu.DjvuImage(stream))
{
System.Console.WriteLine("The total number of pages: {0}", djvuImage.Pages.Length);
System.Console.WriteLine("The active page number: {0}", djvuImage.ActivePage.PageNumber);
System.Console.WriteLine("The first page number: {0}", djvuImage.FirstPage.PageNumber);
System.Console.WriteLine("The last page number: {0}", djvuImage.LastPage.PageNumber);
foreach (Aspose.Imaging.FileFormats.Djvu.DjvuPage djvuPage in djvuImage.Pages)
{
System.Console.WriteLine("--------------------------------------------------");
System.Console.WriteLine("Page number: {0}", djvuPage.PageNumber);
System.Console.WriteLine("Page size: {0}", djvuPage.Size);
System.Console.WriteLine("Page raw format: {0}", djvuPage.RawDataFormat);
}
}
}
//The output may look like this:
//The total number of pages: 2
//The active page number: 1
//The first page number: 1
//The last page number: 2
//--------------------------------------------------
//Page number: 1
//Page size: { Width = 2481, Height = 3508}
//Page raw format: RgbIndexed1Bpp, used channels: 1
//--------------------------------------------------
//Page number: 2
//Page size: { Width = 2481, Height = 3508}
//Page raw format: RgbIndexed1Bpp, used channels: 1RawDataSettings
Należy pamiętać, że przy użyciu tych ustawień dane są ładowane bez konwersji.
[JsonIgnore]
public RawDataSettings RawDataSettings { get; }Wartość nieruchomości
RawFallbackIndex
Uzyskuje lub ustawia indeks spadku do użycia, gdy indeks palety jest poza granicami
public int RawFallbackIndex { get; set; }Wartość nieruchomości
RawIndexedColorConverter
otrzymuje lub ustawia indeksowany konwerter kolorów
public IIndexedColorConverter RawIndexedColorConverter { get; set; }Wartość nieruchomości
RawLineSize
Otrzymuje rozmiar linii surowej w bajtach.
public virtual int RawLineSize { get; }Wartość nieruchomości
TransparentColor
Zdjęcie otrzymuje kolor przejrzysty.
public virtual Color TransparentColor { get; set; }Wartość nieruchomości
UpdateXmpData
otrzymuje lub ustawia wartość wskazującą, czy należy zaktualizować metadane XMP.
public virtual bool UpdateXmpData { get; set; }Wartość nieruchomości
UsePalette
Otrzymuje wartość wskazującą, czy paleta obrazu jest używana.
public override bool UsePalette { get; }Wartość nieruchomości
UseRawData
Otrzymuje lub ustawia wartość wskazującą, czy należy używać ładowania surowych danych, gdy ładowanie surowych danych jest dostępne.
public virtual bool UseRawData { get; set; }Wartość nieruchomości
VerticalResolution
Otrzymuje lub ustawia rozdzielczość pionową, w pikselach na cala, tego Aspose.Imaging.RasterImage.
public virtual double VerticalResolution { get; set; }Wartość nieruchomości
Examples
Poniższy przykład pokazuje, jak ustawić rozdzielczość horyzontalną / pionową obrazu rasterowego.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.jpg"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Get horizontal and vertical resolution of the image
double horizontalResolution = rasterImage.HorizontalResolution;
double verticalResolution = rasterImage.VerticalResolution;
System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", horizontalResolution);
System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", verticalResolution);
if (horizontalResolution != 96.0 || verticalResolution != 96.0)
{
// Use the SetResolution method for updating both resolution values in a single call.
System.Console.WriteLine("Set resolution values to 96 dpi");
rasterImage.SetResolution(96.0, 96.0);
System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", rasterImage.HorizontalResolution);
System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", rasterImage.VerticalResolution);
}
// The output may look like this:
// The horizontal resolution, in pixels per inch: 300
// The vertical resolution, in pixels per inch: 300
// Set resolution values to 96 dpi
// The horizontal resolution, in pixels per inch: 96
// The vertical resolution, in pixels per inch: 96
}Remarks
Zazwyczaj wartość ta wynosi zawsze 96 ponieważ różne platformy nie mogą zwrócić rozdzielczości ekranu. Możesz rozważyć użycie metody SetResolution, aby zaktualizować oba wartości rozdzielczości w jednym wezwaniu.
XmpData
Pobierz lub ustawić metadane XMP.
public virtual XmpPacketWrapper XmpData { get; set; }Wartość nieruchomości
Methods
AdjustBrightness(Int)
Dostosowanie jasności do obrazu.
public virtual void AdjustBrightness(int brightness)Parameters
brightness int
Wartość jasności .
Examples
Poniższy przykład wykonuje poprawę jasności obrazu.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Set the brightness value. The accepted values of brightness are in the range [-255, 255].
rasterImage.AdjustBrightness(50);
rasterImage.Save(dir + "sample.AdjustBrightness.png");
}AdjustContrast(Floty)
kontrast obrazu
public virtual void AdjustContrast(float contrast)Parameters
contrast float
Wartość kontrastu (w zakresie [-100; 100])
Examples
Poniższy przykład wykonuje kontrast korekty obrazu.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Set the contrast value. The accepted values of contrast are in the range [-100f, 100f].
rasterImage.AdjustContrast(50);
rasterImage.Save(dir + "sample.AdjustContrast.png");
}AdjustGamma(float, float i float)
Gamma korekcja obrazu.
public virtual void AdjustGamma(float gammaRed, float gammaGreen, float gammaBlue)Parameters
gammaRed float
Gamma dla współczynnika czerwonego kanału
gammaGreen float
Gamma dla współczynnika zielonego kanału
gammaBlue float
Gamma dla współczynnika niebieskiego kanału
Examples
Poniższy przykład wykonuje korektę gamma obrazu, stosując różne współczynniki dla komponentów kolorowych.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Set individual gamma coefficients for red, green and blue channels.
rasterImage.AdjustGamma(1.5f, 2.5f, 3.5f);
rasterImage.Save(dir + "sample.AdjustGamma.png");
}AdjustGamma(Floty)
Gamma korekcja obrazu.
public virtual void AdjustGamma(float gamma)Parameters
gamma float
Gamma dla współczynnika czerwonych, zielonych i niebieskich kanałów
Examples
Poniższy przykład wykonuje korektę gamma obrazu.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Set gamma coefficient for red, green and blue channels.
rasterImage.AdjustGamma(2.5f);
rasterImage.Save(dir + "sample.AdjustGamma.png");
}BinarizeBradley(Podwójne)
Binaryzacja obrazu za pomocą adaptowego algorytmu granicznego Bradleya za pomocą integralnego granicznego obrazu
public virtual void BinarizeBradley(double brightnessDifference)Parameters
brightnessDifference double
Różnica jasności pomiędzy pikselem a średnią s x s okna pikseli skoncentrowane wokół tego piksela.
BinarizeBradley(podwójne, int)
Binaryzacja obrazu za pomocą adaptowego algorytmu granicznego Bradleya za pomocą integralnego granicznego obrazu
public virtual void BinarizeBradley(double brightnessDifference, int windowSize)Parameters
brightnessDifference double
Różnica jasności pomiędzy pikselem a średnią s x s okna pikseli skoncentrowane wokół tego piksela.
windowSize int
Rozmiar okna s x s pikseli skoncentrowane wokół tego piksela
Examples
Poniższy przykład binaryzuje obraz raster z adaptowym algorytmem granicy Bradleya z określonymi rozmiarami okna.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Binarize the image with a brightness difference of 5. The brightness is a difference between a pixel and the average of an 10 x 10 window of pixels centered around this pixel.
rasterImage.BinarizeBradley(5, 10);
rasterImage.Save(dir + "sample.BinarizeBradley5_10x10.png");
}BinarizeFixed(byte)
Binaryzacja obrazu z uprzednio zdefiniowaną granicą
public virtual void BinarizeFixed(byte threshold)Parameters
threshold byte
Jeśli odpowiednia szara wartość piksela jest większa niż granica, wartość 255 zostanie przypisana do niego, 0 inaczej.
Examples
Poniższy przykład binaryzuje obraz raster z uprzednio zdefiniowaną granicą. obrazy binarizowane zawierają tylko 2 kolory - czarny i biały.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Binarize the image with a threshold value of 127.
// If a corresponding gray value of a pixel is greater than 127, a value of 255 will be assigned to it, 0 otherwise.
rasterImage.BinarizeFixed(127);
rasterImage.Save(dir + "sample.BinarizeFixed.png");
}BinarizeOtsu()
Binaryzacja obrazu z granicą Otsu
public virtual void BinarizeOtsu()Examples
Poniższy przykład binaryzuje obraz raster z granicą Otsu.Binaryzowane obrazy zawierają tylko 2 kolory - czarny i biały.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Binarize the image with Otsu thresholding.
rasterImage.BinarizeOtsu();
rasterImage.Save(dir + "sample.BinarizeOtsu.png");
}Blend(Punkt, RasterImage, Rectangle, Byte)
Wymieszaj ten przykład obrazu z obrazem overlay".
public virtual void Blend(Point origin, RasterImage overlay, Rectangle overlayArea, byte overlayAlpha = 255)Parameters
origin Point
Zdjęcie blendujące pochodzenie.
overlay RasterImage
Zdjęcie nadwyższone.
overlayArea Rectangle
Obszar przepływu.
overlayAlpha byte
Przełomowy alfa.
Blend(Pozycja, RasterImage, byte)
Wymieszaj ten przykład obrazu z obrazem overlay".
public void Blend(Point origin, RasterImage overlay, byte overlayAlpha = 255)Parameters
origin Point
Zdjęcie blendujące pochodzenie.
overlay RasterImage
Zdjęcie nadwyższone.
overlayAlpha byte
Przełomowy alfa.
Dither(Metoda rozmieszczania, int)
Występuje w obecnym obrazie.
public void Dither(DitheringMethod ditheringMethod, int bitsCount)Parameters
ditheringMethod DitheringMethod
Metoda dystrybucji .
bitsCount int
Ostatnie bity liczą na dystrybucję.
Examples
Poniższy przykład ładuje obraz raster i wykonuje granicę i przepływ dystrybucji za pomocą różnych głębokości palety.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Perform threshold dithering using 4-bit color palette which contains 16 colors.
// The more bits specified the higher quality and the bigger size of the output image.
// Note that only 1-bit, 4-bit and 8-bit palettes are supported at the moment.
rasterImage.Dither(Aspose.Imaging.DitheringMethod.ThresholdDithering, 4);
rasterImage.Save(dir + "sample.ThresholdDithering4.png");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Perform floyd dithering using 1-bit color palette which contains only 2 colors - black and white.
// The more bits specified the higher quality and the bigger size of the output image.
// Note that only 1-bit, 4-bit and 8-bit palettes are supported at the moment.
rasterImage.Dither(Aspose.Imaging.DitheringMethod.FloydSteinbergDithering, 1);
rasterImage.Save(dir + "sample.FloydSteinbergDithering1.png");
}Dither(DitheringMetoda, int, IColorPalette)
Występuje w obecnym obrazie.
public abstract void Dither(DitheringMethod ditheringMethod, int bitsCount, IColorPalette customPalette)Parameters
ditheringMethod DitheringMethod
Metoda dystrybucji .
bitsCount int
Ostatnie bity liczą na dystrybucję.
customPalette IColorPalette
Przygotowuje się paletę do Dithering.
Filter(Rectangle, FilterOptionsBase)
Filtruje określony rektangul.
public virtual void Filter(Rectangle rectangle, FilterOptionsBase options)Parameters
rectangle Rectangle
z rektangulą .
options FilterOptionsBase
i opcji .
Examples
Poniższy przykład stosuje różne rodzaje filtrów do obrazu rasterowego.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Apply a median filter with a rectangle size of 5 to the entire image.
rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MedianFilterOptions(5));
rasterImage.Save(dir + "sample.MedianFilter.png");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Apply a bilateral smoothing filter with a kernel size of 5 to the entire image.
rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.BilateralSmoothingFilterOptions(5));
rasterImage.Save(dir + "sample.BilateralSmoothingFilter.png");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Apply a Gaussian blur filter with a radius of 5 and a sigma value of 4.0 to the entire image.
rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.GaussianBlurFilterOptions(5, 4.0));
rasterImage.Save(dir + "sample.GaussianBlurFilter.png");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Apply a Gauss-Wiener filter with a radius of 5 and a smooth value of 4.0 to the entire image.
rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.GaussWienerFilterOptions(5, 4.0));
rasterImage.Save(dir + "sample.GaussWienerFilter.png");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Apply a motion wiener filter with a length of 5, a smooth value of 4.0 and an angle of 90.0 degrees to the entire image.
rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MotionWienerFilterOptions(10, 1.0, 90.0));
rasterImage.Save(dir + "sample.MotionWienerFilter.png");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Apply a sharpen filter with a kernel size of 5 and a sigma value of 4.0 to the entire image.
rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.SharpenFilterOptions(5, 4.0));
rasterImage.Save(dir + "sample.SharpenFilter.png");
}GetArgb32Pixel(i int, int)
Otrzymuje obraz 32-bitowy piksel ARGB.
public int GetArgb32Pixel(int x, int y)Parameters
x int
Położenie piksela x.
y int
Pixel i lokalizacja.
Returns
32-bitowy piksel ARGB dla określonej lokalizacji.
Examples
Poniższy przykład ładuje obraz raster i otrzymuje kolor arbitralnego piksela reprezentowanego jako wartość 32-bitową.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Get an integer representation of the color of the top-left pixel of the image.
int color = rasterImage.GetArgb32Pixel(0, 0);
// To obtain the values of the individual color components, shift the color value by a corresponding number of bits
int alpha = (color >> 24) & 0xff;
int red = (color >> 16) & 0xff;
int green = (color >> 8) & 0xff;
int blue = (color >> 0) & 0xff;
System.Console.WriteLine("The color of the pixel(0,0) is A={0},R={1},G={2},B={3}", alpha, red, green, blue);
}Poniższy przykład pokazuje, jak caching obrazu wpływa na wydajność.W ogóle, czytanie danych cache jest wykonywane szybciej niż odczytywanie nie-cache danych.
string dir = "c:\\temp\\";
// Load an image from a PNG file.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
// Cache all pixel data so that no additional data loading will be performed from the underlying data stream
image.CacheData();
System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Start();
// Reading all pixels is pretty fast.
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
for (int y = 0; y < image.Height; y++)
{
for (int x = 0; x < image.Width; x++)
{
int color = rasterImage.GetArgb32Pixel(x, y);
}
}
stopwatch.Stop();
System.Console.WriteLine("Reading all cached pixels took {0} ms.", stopwatch.ElapsedMilliseconds);
}
// Load an image from a PNG file
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
System.Diagnostics.Stopwatch stopwatch = new System.Diagnostics.Stopwatch();
stopwatch.Start();
// Reading all pixels is not as fast as when caching
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
for (int y = 0; y < image.Height; y++)
{
for (int x = 0; x < image.Width; x++)
{
int color = rasterImage.GetArgb32Pixel(x, y);
}
}
stopwatch.Stop();
System.Console.WriteLine("Reading all pixels without preliminary caching took {0} ms.", stopwatch.ElapsedMilliseconds);
}
// The output may look like this:
// Reading all cached pixels took 1500 ms.
// Reading all pixels without preliminary caching took 150000 ms.GetDefaultArgb32Pixels(Rectangle)
Otrzymuje domyślny 32-bitowy rozkład pikseli ARGB.
public int[] GetDefaultArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Płytki do uzyskania pikseli.
Returns
int [ ]
Podstawowe piksele są rozmieszczone.
GetDefaultPixels(Rectangle, IPartialArgb32PixelLoader)
Dostęp do standardowych pikseli za pomocą częściowego ładowarki pikseli.
public void GetDefaultPixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Płytki do uzyskania pikseli.
partialPixelLoader IPartialArgb32PixelLoader
Częściowy piksel ładowarki.
GetDefaultRawData(Rectangle, IPartialRawDataLoader, ustawienia RawData)
Dostęp do domyślnego zestawu surowych danych za pomocą częściowego ładowarki pikseli.
public void GetDefaultRawData(Rectangle rectangle, IPartialRawDataLoader partialRawDataLoader, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Płytki do uzyskania pikseli.
partialRawDataLoader IPartialRawDataLoader
Częściowy ładowarka surowych danych.
rawDataSettings RawDataSettings
Ustawienia surowych danych.
GetDefaultRawData(Rectangle i RawDataSettings)
Otrzymuje domyślny array surowych danych.
public byte[] GetDefaultRawData(Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Rękawiczki do uzyskania surowych danych.
rawDataSettings RawDataSettings
Ustawienia surowych danych.
Returns
byte [ ]
Podstawowe dane surowe.
GetModifyDate(Bool)
Otrzymuje datę i czas, w którym obraz zasobowy został ostatnio zmodyfikowany.
public virtual DateTime GetModifyDate(bool useDefault)Parameters
useDefault bool
Jeśli ustawione na “prawdziwe”, użyj informacji z FileInfo jako wartości domyślnej.
Returns
Data i czas ostatniej modyfikacji obrazu zasobów.
GetPixel(i int, int)
Otrzymuje pixel obrazu.
public Color GetPixel(int x, int y)Parameters
x int
Położenie piksela x.
y int
Pixel i lokalizacja.
Returns
Kolor pixelowy dla określonej lokalizacji.
Examples
Poniższy przykład ładuje obraz raster i otrzymuje kolor arbitralnego piksela.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Get the color of the top-left pixel of the image.
Color color = rasterImage.GetPixel(0, 0);
// Obtain the values of the individual color components
byte alpha = color.A;
byte red = color.R;
int green = color.G;
int blue = color.B;
System.Console.WriteLine("The color of the pixel(0,0) is A={0},R={1},G={2},B={3}", alpha, red, green, blue);
}GetSkewAngle()
Znajduje się pod kątem skrzydła.Metoda ta jest stosowana do skanowanych dokumentów tekstowych, aby określić kąt skierowania podczas skanowania.
public float GetSkewAngle()Returns
Węgiel szkieletowy, w stopniach.
Grayscale()
Przekształcenie obrazu w jego grayscale
public virtual void Grayscale()Examples
Poniższy przykład przekształca kolorowy obraz rastera w jego reprezentację grayscale. obrazy Grayscal składają się wyłącznie z odcieni szary i przynoszą tylko informacje o intensywności.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
rasterImage.Grayscale();
rasterImage.Save(dir + "sample.Grayscale.png");
}LoadArgb32Pixels(Rectangle)
Ładuje 32-bitowe piksele ARGB.
public int[] LoadArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rękawiczki do ładowania pikseli.
Returns
int [ ]
32-bitowe piksele ARGB.
Examples
Poniższy przykład pokazuje, jak pobierać i przetwarzać piksele obrazu rasterowego.Pixele są reprezentowane jako 32-bitowe wartości całościowe.Na przykład, rozważ problem liczenia całkowicie przejrzystych pikselów obrazów.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\alpha.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Load pixels for the whole image. Any rectangular part of the image can be specified as a parameter of the Aspose.Imaging.RasterImage.LoadArgb32Pixels method.
int[] pixels = rasterImage.LoadArgb32Pixels(rasterImage.Bounds);
int count = 0;
foreach (int pixel in pixels)
{
int alpha = (pixel >> 24) & 0xff;
if (alpha == 0)
{
count++;
}
}
System.Console.WriteLine("The number of fully transparent pixels is {0}", count);
System.Console.WriteLine("The total number of pixels is {0}", image.Width * image.Height);
}LoadArgb64Pixels(Rectangle)
Ładuje 64-bitowe piksele ARGB.
public long[] LoadArgb64Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rękawiczki do ładowania pikseli.
Returns
long [ ]
Zestaw 64-bitowych pikseli ARGB.
Examples
Poniższy przykład pokazuje, jak pobierać i przetwarzać piksele obrazu rasterowego.Pixele są reprezentowane jako 64-bitowe wartości całościowe.Na przykład, rozważ problem liczenia całkowicie przejrzystych pikselów obrazy.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\16rgba.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Load pixels for the whole image. Any rectangular part of the image can be specified as a parameter of the Aspose.Imaging.RasterImage.LoadArgb64Pixels method.
// Note that the image itself must have 16 bits per sample, because Aspose.Imaging.RasterImage.LoadArgb64Pixels doesn't work with 8 bit per sample.
// In order to work with 8 bits per sample please use the good old Aspose.Imaging.RasterImage.LoadArgb32Pixels method.
long[] pixels = rasterImage.LoadArgb64Pixels(rasterImage.Bounds);
int count = 0;
foreach (int pixel in pixels)
{
// Note that all color components including alpha are represented by 16-bit values, so their allowed values are in the range [0, 63535].
int alpha = (pixel >> 48) & 0xffff;
if (alpha == 0)
{
count++;
}
}
System.Console.WriteLine("The number of fully transparent pixels is {0}", count);
System.Console.WriteLine("The total number of pixels is {0}", image.Width * image.Height);
}LoadCmyk32Pixels(Rectangle)
Wykonuje piksele w formacie CMYK.
public int[] LoadCmyk32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rękawiczki do ładowania pikseli.
Returns
int [ ]
Obciążone piksele CMYK są prezentowane jako wartości 32-bitowe.
LoadCmykPixels(Rectangle)
Wykonuje piksele w formacie CMYK.Proszę użyć bardziej efektywnej metody Aspose.Imaging.RasterImage.LoadCmyk32Pixels(__W L17_Rectangle).
[Obsolete("Method is obsolete")]
public CmykColor[] LoadCmykPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rękawiczki do ładowania pikseli.
Returns
CmykColor [ ]
Przesyłane piksele CMYK.
LoadPartialArgb32Pixels(Rectangle, IPartialArgb32PixelLoader)
Ładuje 32-bitowe piksele ARGB częściowo przez pakiety.
public void LoadPartialArgb32Pixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Pożądany rektangul.
partialPixelLoader IPartialArgb32PixelLoader
32-bitowy ładowarka pixelowa ARGB.
Examples
Poniższy przykład pokazuje, jak pobierać i przetwarzać piksele obrazu rasterowego za pomocą własnego częściowego procesora. Na przykład, rozważ problem liczenia całkowicie przejrzystych pixelów obrazy. Aby liczyć przejrzyste piksely przy użyciu mechanizmu ładowania częściowej, wprowadzono oddzielną klasę TransparentArgb32PixelCounter wdrażanie Aspose.Imaging.IPartialArGB32PixelLoader.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\alpha.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Create an instance of the Aspose.Imaging.IPartialArgb32PixelLoader and pass it to the Aspose.Imaging.RasterImage.LoadPartialArgb32Pixels
TransparentArgb32PixelCounter counter = new TransparentArgb32PixelCounter();
// Load pixels for the whole image. Any rectangular part of the image can be specified as the first parameter of the Aspose.Imaging.RasterImage.LoadPartialArgb32Pixels method.
rasterImage.LoadPartialArgb32Pixels(rasterImage.Bounds, counter);
System.Console.WriteLine("The number of fully transparent pixels is {0}", counter.Count);
System.Console.WriteLine("The total number of pixels is {0}", image.Width * image.Height);
}
// The counter may look like this:
/// <summary>
/// Counts the number of fully transparent pixels with alpha channel value of 0.
/// </summary>
private class TransparentArgb32PixelCounter : IPartialArgb32PixelLoader
{
/// <summary>
/// The number of fully transparent pixels.
/// </summary>
private int count;
/// <summary>
/// Gets the number of fully transparent pixels.
/// </summary>
public int Count
{
get { return this.count; }
}
/// <summary>
/// Processes the loaded pixels. This method is called back every time when a new portion of pixels is loaded.
/// </summary>
/// <param name="pixelsRectangle"/>The pixels rectangle.
/// <param name="pixels"/>The 32-bit ARGB pixels.
/// <param name="start"/>The start pixels point.
/// <param name="end"/>The end pixels point.
public void Process(Aspose.Imaging.Rectangle pixelsRectangle, int[] pixels, Aspose.Imaging.Point start, Aspose.Imaging.Point end)
{
foreach (int pixel in pixels)
{
int alpha = (pixel >> 24) & 0xff;
if (alpha == 0)
{
this.count++;
}
}
}
}LoadPartialArgb64Pixels(Rectangle, IPartialArgb64PixelLoader)
64-bitowe piksele ARGB są częściowo ładowane przez pakiety.
public void LoadPartialArgb64Pixels(Rectangle rectangle, IPartialArgb64PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Pożądany rektangul.
partialPixelLoader IPartialArgb64PixelLoader
64-bitowy ładowarka pikseli ARGB.
LoadPartialPixels(Rectangle i IPartialPixelLoader)
Częściowo ładuje piksele pakietami.
public void LoadPartialPixels(Rectangle desiredRectangle, IPartialPixelLoader pixelLoader)Parameters
desiredRectangle Rectangle
Pożądany rektangul.
pixelLoader IPartialPixelLoader
To pixelowy ładowarka.
Examples
Poniższy przykład pokazuje, jak pobierać i przetwarzać piksele obrazu rasterowego za pomocą własnego częściowego procesora. Na przykład, rozważ problem liczenia całkowicie przejrzystych pixelów obrazy. Aby liczyć przejrzyste za pośrednictwem mechanizmu ładowania partialnego, wprowadza się oddzielna klasa TransparentPixelCounter wdrażania Aspose.Imaging.IPartialPixelLoader.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\alpha.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Create an instance of the Aspose.Imaging.IPartialPixelLoader and pass it to the Aspose.Imaging.RasterImage.LoadPartialPixels
TransparentPixelCounter counter = new TransparentPixelCounter();
// Load pixels for the whole image. Any rectangular part of the image can be specified as the first parameter of the Aspose.Imaging.RasterImage.LoadPartialPixels method.
rasterImage.LoadPartialPixels(rasterImage.Bounds, counter);
System.Console.WriteLine("The number of fully transparent pixels is {0}", counter.Count);
System.Console.WriteLine("The total number of pixels is {0}", image.Width * image.Height);
}
// The counter may look like this:
/// <summary>
/// Counts the number of fully transparent pixels with alpha channel value of 0.
/// </summary>
private class TransparentPixelCounter : IPartialPixelLoader
{
/// <summary>
/// The number of fully transparent pixels.
/// </summary>
private int count;
/// <summary>
/// Gets the number of fully transparent pixels.
/// </summary>
public int Count
{
get { return this.count; }
}
/// <summary>
/// Processes the loaded pixels. This method is called back every time when a new portion of pixels is loaded.
/// </summary>
/// <param name="pixelsRectangle"/>The pixels rectangle.
/// <param name="pixels"/>The 32-bit ARGB pixels.
/// <param name="start"/>The start pixels point.
/// <param name="end"/>The end pixels point.
public void Process(Aspose.Imaging.Rectangle pixelsRectangle, Aspose.Imaging.Color[] pixels, Aspose.Imaging.Point start, Aspose.Imaging.Point end)
{
foreach (Color pixel in pixels)
{
if (pixel.A == 0)
{
this.count++;
}
}
}
}LoadPixels(Rectangle)
Wypełniamy piksele.
public Color[] LoadPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rękawiczki do ładowania pikseli.
Returns
Color [ ]
Przesyłane piksele rozciągają się.
Examples
Poniższy przykład pokazuje, jak pobierać i przetwarzać piksele obrazu rasterowego. na przykład, rozważ problem liczenia pełno przejrzystych pixelów obrazów.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\alpha.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Load pixels for the whole image. Any rectangular part of the image can be specified as a parameter of the Aspose.Imaging.RasterImage.LoadPixels method.
Color[] pixels = rasterImage.LoadPixels(rasterImage.Bounds);
int count = 0;
foreach (Color pixel in pixels)
{
if (pixel.A == 0)
{
count++;
}
}
System.Console.WriteLine("The number of fully transparent pixels is {0}", count);
System.Console.WriteLine("The total number of pixels is {0}", image.Width * image.Height);
}Ten przykład pokazuje, jak pobierać informacje o pikselach w Array typu Koloru, manipulować array i ustawić je z powrotem na obraz. Aby wykonać te czynności, ten przykład tworzy nowy plik obrazu (w formacie GIF) uisng Obiekt MemoryStream.
//Create an instance of MemoryStream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
//Create an instance of GifOptions and set its various properties including the Source property
Aspose.Imaging.ImageOptions.GifOptions gifOptions = new Aspose.Imaging.ImageOptions.GifOptions();
gifOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);
//Create an instance of Image
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Create(gifOptions, 500, 500))
{
//Get the pixels of image by specifying the area as image boundary
Aspose.Imaging.Color[] pixels = image.LoadPixels(image.Bounds);
//Loop over the Array and sets color of alrenative indexed pixel
for (int index = 0; index < pixels.Length; index++)
{
if (index % 2 == 0)
{
//Set the indexed pixel color to yellow
pixels[index] = Aspose.Imaging.Color.Yellow;
}
else
{
//Set the indexed pixel color to blue
pixels[index] = Aspose.Imaging.Color.Blue;
}
}
//Apply the pixel changes to the image
image.SavePixels(image.Bounds, pixels);
// save all changes.
image.Save();
}
// Write MemoryStream to File
using (System.IO.FileStream fileStream = new System.IO.FileStream(@"C:\temp\output.gif", System.IO.FileMode.Create))
{
stream.WriteTo(fileStream);
}
}LoadRawData(Rectangle, RawDataSettings, IPartialRawDataLoader)
Ładuje surowe dane.
public void LoadRawData(Rectangle rectangle, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Rękawiczki do ładowania surowych danych.
rawDataSettings RawDataSettings
Uwaga: jeśli dane nie są w określonym formacie, to zostanie przeprowadzona konwersja danych.
rawDataLoader IPartialRawDataLoader
Czarny ładowarka danych.
Examples
Poniższy przykład pokazuje, jak wyciągać piksele z danych surowego obrazu za pomocą RawDataSettings. na przykład, rozważ problem liczenia całkowicie przejrzystych pikselów obrazy.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\GrayscaleWithAlpha.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
Aspose.Imaging.RawDataSettings settings = rasterImage.RawDataSettings;
TransparentPixelRawDataCounter rawDataLoader = new TransparentPixelRawDataCounter(settings);
// Load pixels for the whole image. Any rectangular part of the image can be specified as a parameter of the Aspose.Imaging.RasterImage.LoadRawData method.
rasterImage.LoadRawData(rasterImage.Bounds, settings, rawDataLoader);
System.Console.WriteLine("The number of fully transparent pixels is {0}", rawDataLoader.Count);
System.Console.WriteLine("The total number of pixels is {0}", image.Width * image.Height);
}
// In case of raw data, the counter may look like this:
/// <summary>
/// Counts the number of fully transparent pixels with alpha channel value of 0.
/// </summary>
private class TransparentPixelRawDataCounter : IPartialRawDataLoader
{
/// <summary>
/// The number of fully transparent pixels.
/// </summary>
private int count;
/// <summary>
/// The raw data settings of the loaded image.
/// </summary>
private Aspose.Imaging.RawDataSettings rawDataSettings;
/// <summary>
/// Gets the number of fully transparent pixels.
/// </summary>
public int Count
{
get { return this.count; }
}
/// <summary>
/// Initializes a new instance of the <see transparentpixelrawdatacounter=""></see> class.
/// </summary>
/// <param name="settings"/>The raw data settings allow to extract color components from raw data.
public TransparentPixelRawDataCounter(Aspose.Imaging.RawDataSettings settings)
{
this.rawDataSettings = settings;
this.count = 0;
}
/// <summary>
/// Processes the loaded raw data. This method is called back every time when a new portion of raw data is loaded.
/// </summary>
/// <param name="dataRectangle"/>The raw data rectangle.
/// <param name="data"/>The raw data.
/// <param name="start"/>The start data point.
/// <param name="end"/>The end data point.
public void Process(Aspose.Imaging.Rectangle dataRectangle, byte[] data, Aspose.Imaging.Point start, Aspose.Imaging.Point end)
{
int[] channelBits = this.rawDataSettings.PixelDataFormat.ChannelBits;
// Only simple formats are consdired here to simplify the code.
// Let's consider only images with 8 bits per sample.
for (int i = 0; i < channelBits.Length; i++)
{
if (channelBits[i] != 8)
{
throw new System.NotSupportedException();
}
}
switch (this.rawDataSettings.PixelDataFormat.PixelFormat)
{
case PixelFormat.Rgb:
case PixelFormat.Bgr:
{
if (channelBits.Length == 4)
{
// ARGB
for (int i = 0; i < data.Length; i += 4)
{
// The alpha channel is stored last, after the color components.
if (data[i + 3] == 0)
{
this.count++;
}
}
}
}
break;
case PixelFormat.Grayscale:
{
if (channelBits.Length == 2)
{
// Grayscale Alpha
for (int i = 0; i < data.Length; i += 2)
{
// The alpha channel is stored last, after the color components.
if (data[i + 1] == 0)
{
this.count++;
}
}
}
}
break;
default:
throw new System.ArgumentOutOfRangeException("PixelFormat");
}
}
/// <summary>
/// Processes the loaded raw data. This method is called back every time when a new portion of raw data is loaded.
/// </summary>
/// <param name="dataRectangle"/>The raw data rectangle.
/// <param name="data"/>The raw data.
/// <param name="start"/>The start data point.
/// <param name="end"/>The end data point.
/// <param name="loadOptions"/>The load options.
public void Process(Aspose.Imaging.Rectangle dataRectangle, byte[] data, Aspose.Imaging.Point start, Aspose.Imaging.Point end, Aspose.Imaging.LoadOptions loadOptions)
{
this.Process(dataRectangle, data, start, end);
}
}LoadRawData(Rectangle, Rectangle, RawDataSettings, IPartialRawDataLoader)
Ładuje surowe dane.
public void LoadRawData(Rectangle rectangle, Rectangle destImageBounds, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Rękawiczki do ładowania surowych danych.
destImageBounds Rectangle
Wizerunek jest ograniczony.
rawDataSettings RawDataSettings
Uwaga: jeśli dane nie są w określonym formacie, to zostanie przeprowadzona konwersja danych.
rawDataLoader IPartialRawDataLoader
Czarny ładowarka danych.
NormalizeAngle()
Normalizacja kąta.Ta metoda jest stosowana do skanowanych dokumentów tekstowych, aby pozbyć się skanowanego skanowania.Metoda ta wykorzystuje metody Aspose.Imaging.RasterImage.GetSkewAngle i W L17.
public void NormalizeAngle()NormalizeAngle(Bool, Kolor)
Normalizacja kąta.Ta metoda jest stosowana do skanowanych dokumentów tekstowych, aby pozbyć się skanowanego skanowania.Metoda ta wykorzystuje metody Aspose.Imaging.RasterImage.GetSkewAngle i Wl17. RasterImage.Roate(System.Single, System.Boolean,__W L17 _.Color).
public virtual void NormalizeAngle(bool resizeProportionally, Color backgroundColor)Parameters
resizeProportionally bool
Jeśli ustawione na “prawdziwe”, zmieni się rozmiar obrazu w zależności od obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu.
backgroundColor Color
Kolor z tła.
Examples
Skew jest artefaktem, który może pojawić się podczas procesu skanowania dokumentów, gdy tekst / obrazy dokumentu są obrotowane w lekkim kącie. Może to mieć różne przyczyny, ale najczęstsze jest to, że papier jest niewłaściwie umieszczony podczas skanu. Dlatego, deskev jest procesem wykrywania i naprawy tego problemu na skanej plikach (tj. bitmap), więc deskowane dokumenty będą miały poprawnie i horyzontalnie dostosowane teksty / zdjęcia.
string dir = "c:\\aspose.imaging\\issues\\net\\3567\\";
string inputFilePath = dir + "skewed.png";
string outputFilePath = dir + "skewed.out.png";
// Get rid of the skewed scan with default parameters
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Load(inputFilePath))
{
// Deskew
image.NormalizeAngle(false /*do not resize*/, Aspose.Imaging.Color.LightGray /*background color*/);
image.Save(outputFilePath);
}NormalizeHistogram()
Normalizuje histogram obrazu – dostosowuje wartości pikseli do wykorzystania wszystkich dostępnych zakresów.
public virtual void NormalizeHistogram()ReadArgb32ScanLine(Int)
Przeczyta całą linię skanowania przez określony indeks linii skanowania.
public int[] ReadArgb32ScanLine(int scanLineIndex)Parameters
scanLineIndex int
Wskaźnik oparty na zero linii skanowania.
Returns
int [ ]
Linia skanowania 32-bitowe wartości kolorów ARGB.
ReadScanLine(Int)
Przeczyta całą linię skanowania przez określony indeks linii skanowania.
public Color[] ReadScanLine(int scanLineIndex)Parameters
scanLineIndex int
Wskaźnik oparty na zero linii skanowania.
Returns
Color [ ]
Linia skanowania pixel kolor wartości array.
ReleaseManagedResources()
Upewnij się, że nie zarządzane zasoby nie są tutaj uwalniane, ponieważ mogą być już uwalniane.
protected override void ReleaseManagedResources()RemoveMetadata()
Usuń te metadane przykładu obrazu, ustawiając tę wartość Aspose.Imaging.Xmp.IHasxmpData. zero.
public override void RemoveMetadata()ReplaceColor(Kolor, byta i kolor)
Zastępuje jeden kolor na inny z dopuszczalną różnicą i zachowuje oryginalną wartość alfa, aby zaoszczędzić gładkie krawędzie.
public void ReplaceColor(Color oldColor, byte oldColorDiff, Color newColor)Parameters
oldColor Color
Stary kolor należy zastąpić.
oldColorDiff byte
Pozwolone różnice w starym kolorze, aby móc rozszerzyć zastąpiony ton koloru.
newColor Color
Nowy kolor zastępuje stary kolor.
ReplaceColor(Int , byte , int)
Zastępuje jeden kolor na inny z dopuszczalną różnicą i zachowuje oryginalną wartość alfa, aby zaoszczędzić gładkie krawędzie.
public virtual void ReplaceColor(int oldColorArgb, byte oldColorDiff, int newColorArgb)Parameters
oldColorArgb int
Stary kolor ARGB wartość do zastąpienia.
oldColorDiff byte
Pozwolone różnice w starym kolorze, aby móc rozszerzyć zastąpiony ton koloru.
newColorArgb int
Nowy kolor wartość ARGB do zastąpienia starego koloru.
ReplaceNonTransparentColors(Color)
Zastępuje wszystkie nieprzezroczyste kolory nowym kolorem i zachowuje oryginalną wartość alfa, aby zaoszczędzić gładkie krawędzie.Uwaga: jeśli używasz go na obrazach bez przejrzystości, wszystkie kolory zostaną zastąpione jednym.
public void ReplaceNonTransparentColors(Color newColor)Parameters
newColor Color
Nowy kolor zastępuje nieprzejrzałe kolory.
ReplaceNonTransparentColors(Int)
Zastępuje wszystkie nieprzezroczyste kolory nowym kolorem i zachowuje oryginalną wartość alfa, aby zaoszczędzić gładkie krawędzie.Uwaga: jeśli używasz go na obrazach bez przejrzystości, wszystkie kolory zostaną zastąpione jednym.
public virtual void ReplaceNonTransparentColors(int newColorArgb)Parameters
newColorArgb int
Nowy kolor wartość ARGB zastąpić nieprzezroczyste kolory.
Resize(int, int, ImageResizeSettings)
Odtwarza obraz z rozszerzonymi opcjami.
public override void Resize(int newWidth, int newHeight, ImageResizeSettings settings)Parameters
newWidth int
Nowa szerokość .
newHeight int
Nowa wysokość .
settings ImageResizeSettings
Zmiany w ustawieniach.
Examples
Ten przykład ładuje obraz raster i odtwarza go za pomocą różnych ustawień odświeżania.
string dir = "c:\\temp\\";
Aspose.Imaging.ImageResizeSettings resizeSettings = new Aspose.Imaging.ImageResizeSettings();
// The adaptive algorithm based on weighted and blended rational function and lanczos3 interpolation.
resizeSettings.Mode = Aspose.Imaging.ResizeType.AdaptiveResample;
// The small rectangular filter
resizeSettings.FilterType = Aspose.Imaging.ImageFilterType.SmallRectangular;
// The number of colors in the palette.
resizeSettings.EntriesCount = 256;
// The color quantization is not used
resizeSettings.ColorQuantizationMethod = ColorQuantizationMethod.None;
// The euclidian method
resizeSettings.ColorCompareMethod = ColorCompareMethod.Euclidian;
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale down by 2 times using adaptive resampling.
image.Resize(image.Width / 2, image.Height / 2, resizeSettings);
image.Save(dir + "downsample.adaptive.gif");
}Rotate(Float, Bool, Kolor)
Rotacja obrazu wokół centrum.
public virtual void Rotate(float angle, bool resizeProportionally, Color backgroundColor)Parameters
angle float
Kąt obrotowy w stopniach. wartości pozytywne będą obrotować zegarem.
resizeProportionally bool
Jeśli ustawione na “prawdziwe”, zmieni się rozmiar obrazu w zależności od obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu.
backgroundColor Color
Kolor z tła.
Exceptions
Niewykonane wyjątki
Rotate(Floty)
Rotacja obrazu wokół centrum.
public override void Rotate(float angle)Parameters
angle float
Kąt obrotowy w stopniach. wartości pozytywne będą obrotować zegarem.
Save(Strumień, ImageOptionsBase, Rectangle)
Przechowuje dane obrazu do określonego strumienia w określonym formacie pliku według opcji przechowywania.
public override void Save(Stream stream, ImageOptionsBase optionsBase, Rectangle boundsRectangle)Parameters
stream Stream
Strumień do przechowywania danych obrazu do.
optionsBase ImageOptionsBase
Opcje oszczędnościowe.
boundsRectangle Rectangle
Zdjęcie docelowe ogranicza rektangle. ustawić pusty rektangle do wykorzystania granic źródłowych.
SaveArgb32Pixels(Rzeczypospolita, int[])
Oszczędność 32-bitowych pikseli ARGB.
public void SaveArgb32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Rękawiczki do przechowywania pikseli.
pixels int
[ ]
32-bitowe piksele ARGB.
Examples
Poniższy przykład wypełnia obszar centralny obrazu rastera czarnymi pikseli za pomocą metody Aspose.Imaging.RasterImage.SaveArgb32Pixels.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// The black square
int[] pixels = new int[(rasterImage.Width / 2) * (rasterImage.Height / 2)];
for (int i = 0; i < pixels.Length; i++)
{
pixels[i] = Color.Black.ToArgb();
}
// Draw the black square at the center of the image.
Aspose.Imaging.Rectangle area = new Aspose.Imaging.Rectangle(rasterImage.Width / 4, rasterImage.Height / 4, rasterImage.Width / 2, rasterImage.Height / 2);
rasterImage.SaveArgb32Pixels(area, pixels);
rasterImage.Save(dir + "sample.SaveArgb32Pixels.png");
}SaveCmyk32Pixels(Rzeczypospolita, int[])
Oszczędź piksele.
public void SaveCmyk32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Rękawiczki do przechowywania pikseli.
pixels int
[ ]
Piksele CMYK prezentowane są jako 32-bitowe wartości integralne.
Examples
Poniższy przykład wypełnia obszar centralny obrazu rastera czarnymi pikseli za pomocą metody Aspose.Imaging.RasterImage.SaveCmyk32Pixels.
string dir = @"c:\temp\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Get an integer representation of black in the CMYK color space.
int blackCmyk = Aspose.Imaging.CmykColorHelper.ToCmyk(Color.Black);
// The black square.
int[] pixels = new int[(rasterImage.Width / 2) * (rasterImage.Height / 2)];
for (int i = 0; i < pixels.Length; i++)
{
pixels[i] = blackCmyk;
}
// Draw the black square at the center of the image.
Aspose.Imaging.Rectangle area = new Aspose.Imaging.Rectangle(rasterImage.Width / 4, rasterImage.Height / 4, rasterImage.Width / 2, rasterImage.Height / 2);
rasterImage.SaveCmyk32Pixels(area, pixels);
rasterImage.Save(dir + "sample.SaveCmyk32Pixels.png");
}SaveCmykPixels(Rektangle, CmykColor[])
Oszczędź piksele.Proszę użyć bardziej efektywnej metody Aspose.Imaging.RasterImage.SaveCmyk32Pixels(W L 17 .Rectangle,System.Int32[]).
[Obsolete("Method is obsolete")]
public void SaveCmykPixels(Rectangle rectangle, CmykColor[] pixels)Parameters
rectangle Rectangle
Rękawiczki do przechowywania pikseli.
pixels CmykColor
[ ]
Piksele CMYK rozciągają się.
SavePixels(Kolorowy, kolorowy[])
Oszczędź piksele.
public void SavePixels(Rectangle rectangle, Color[] pixels)Parameters
rectangle Rectangle
Rękawiczki do przechowywania pikseli.
pixels Color
[ ]
Piksele są w porządku.
Examples
Poniższy przykład wypełnia obszar centralny obrazu rastera czarnymi pikseli za pomocą metody Aspose.Imaging.RasterImage.SavePixels.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// The black square
Color[] pixels = new Color[(rasterImage.Width / 2) * (rasterImage.Height / 2)];
for (int i = 0; i < pixels.Length; i++)
{
pixels[i] = Color.Black;
}
// Draw the black square at the center of the image.
Aspose.Imaging.Rectangle area = new Aspose.Imaging.Rectangle(rasterImage.Width / 4, rasterImage.Height / 4, rasterImage.Width / 2, rasterImage.Height / 2);
rasterImage.SavePixels(area, pixels);
rasterImage.Save(dir + "sample.SavePixels.png");
}Ten przykład pokazuje, jak pobierać informacje o pikselach w Array typu Koloru, manipulować array i ustawić je z powrotem na obraz. Aby wykonać te czynności, ten przykład tworzy nowy plik obrazu (w formacie GIF) uisng Obiekt MemoryStream.
//Create an instance of MemoryStream
using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
{
//Create an instance of GifOptions and set its various properties including the Source property
Aspose.Imaging.ImageOptions.GifOptions gifOptions = new Aspose.Imaging.ImageOptions.GifOptions();
gifOptions.Source = new Aspose.Imaging.Sources.StreamSource(stream);
//Create an instance of Image
using (Aspose.Imaging.RasterImage image = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Create(gifOptions, 500, 500))
{
//Get the pixels of image by specifying the area as image boundary
Aspose.Imaging.Color[] pixels = image.LoadPixels(image.Bounds);
//Loop over the Array and sets color of alrenative indexed pixel
for (int index = 0; index < pixels.Length; index++)
{
if (index % 2 == 0)
{
//Set the indexed pixel color to yellow
pixels[index] = Aspose.Imaging.Color.Yellow;
}
else
{
//Set the indexed pixel color to blue
pixels[index] = Aspose.Imaging.Color.Blue;
}
}
//Apply the pixel changes to the image
image.SavePixels(image.Bounds, pixels);
// save all changes.
image.Save();
}
// Write MemoryStream to File
using (System.IO.FileStream fileStream = new System.IO.FileStream(@"C:\temp\output.gif", System.IO.FileMode.Create))
{
stream.WriteTo(fileStream);
}
}SaveRawData(byte[ ], int, rektangle, RawDataSettings)
Oszczędność surowych danych.
public void SaveRawData(byte[] data, int dataOffset, Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
data byte
[ ]
i surowych danych.
dataOffset int
Początkowe dane surowe są zwrotne.
rectangle Rectangle
Dane surowe są rektangulowane.
rawDataSettings RawDataSettings
Dane surowe są ustawione, w których są dane.
SetArgb32Pixel(Int , int , int , int)
Ustaw obraz 32-bitowy piksel ARGB dla określonej pozycji.
public void SetArgb32Pixel(int x, int y, int argb32Color)Parameters
x int
Położenie piksela x.
y int
Pixel i lokalizacja.
argb32Color int
32-bitowy piksel ARGB dla określonej pozycji.
Examples
Poniższy przykład ładuje obraz raster, a następnie określa kolor arbitralnego piksela.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Sets the color of the top-left pixel.
rasterImage.SetArgb32Pixel(0, 0, Aspose.Imaging.Color.Aqua.ToArgb());
// Another way is to pass an instance of the Aspose.Imaging.Color directly
rasterImage.SetPixel(0, 0, Aspose.Imaging.Color.Aqua);
}SetPalette(IkolorPalette, Bool)
Ustaw paletę obrazu.
public override void SetPalette(IColorPalette palette, bool updateColors)Parameters
palette IColorPalette
Płytka do ustawienia.
updateColors bool
Jeśli ustawione na “prawdziwe” kolory zostaną zaktualizowane zgodnie z nową paletą; w przeciwnym razie indeksy kolorów pozostają niezmienione. zauważ, że niezmienione indeksy mogą zepsuć obraz na ładowaniu, jeśli niektóre indeksy nie mają odpowiednich wpisów palet.
SetPixel(int, int, kolor)
Ustaw piksel obrazu dla określonej pozycji.
public void SetPixel(int x, int y, Color color)Parameters
x int
Położenie piksela x.
y int
Pixel i lokalizacja.
color Color
Kolor pixelowy dla określonej pozycji.
Examples
Poniższy przykład ładuje obraz raster, a następnie określa kolor arbitralnego piksela.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Sets the color of the top-left pixel.
rasterImage.SetArgb32Pixel(0, 0, Aspose.Imaging.Color.Aqua.ToArgb());
// Another way is to pass an instance of the Aspose.Imaging.Color directly
rasterImage.SetPixel(0, 0, Aspose.Imaging.Color.Aqua);
}SetResolution(podwójne, podwójne)
Ustaw rozdzielczość dla tego Aspose.Imaging.RasterImage.
public virtual void SetResolution(double dpiX, double dpiY)Parameters
dpiX double
Rozdzielczość horyzontalna, w punktach na cala, Aspose.Imaging.RasterImage.
dpiY double
Rozdzielczość pionowa, w punktach na cala, Aspose.Imaging.RasterImage.
Examples
Poniższy przykład pokazuje, jak ustawić rozdzielczość horyzontalną / pionową obrazu rasterowego.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.jpg"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Get horizontal and vertical resolution of the image
double horizontalResolution = rasterImage.HorizontalResolution;
double verticalResolution = rasterImage.VerticalResolution;
System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", horizontalResolution);
System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", verticalResolution);
if (horizontalResolution != 96.0 || verticalResolution != 96.0)
{
// Use the SetResolution method for updating both resolution values in a single call.
System.Console.WriteLine("Set resolution values to 96 dpi");
rasterImage.SetResolution(96.0, 96.0);
System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", rasterImage.HorizontalResolution);
System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", rasterImage.VerticalResolution);
}
// The output may look like this:
// The horizontal resolution, in pixels per inch: 300
// The vertical resolution, in pixels per inch: 300
// Set resolution values to 96 dpi
// The horizontal resolution, in pixels per inch: 96
// The vertical resolution, in pixels per inch: 96
}ToBitmap()
Konwertuj obraz raster na bitmap.Metoda ta nie jest obsługiwana w wersjach .Net7.0 i wyższych.
public virtual Bitmap ToBitmap()Returns
Bitmap
UpdateDimensions(i int, int)
Aktualizacja wymiarów obrazu.
protected abstract void UpdateDimensions(int newWidth, int newHeight)Parameters
newWidth int
Nowy widok obrazu.
newHeight int
Nowa wysokość obrazu.
UpdateMetadata()
Aktualizacja metadatu obrazu.
protected virtual void UpdateMetadata()WriteArgb32ScanLine(i int, int[])
Wpisz całą linię skanowania do określonego indeksu linii skanowania.
public void WriteArgb32ScanLine(int scanLineIndex, int[] argb32Pixels)Parameters
scanLineIndex int
Wskaźnik oparty na zero linii skanowania.
argb32Pixels int
[ ]
32-bitowe kolory ARGB pozwalają na pisanie.
WriteScanLine(w kolorze, kolor[])
Wpisz całą linię skanowania do określonego indeksu linii skanowania.
public void WriteScanLine(int scanLineIndex, Color[] pixels)Parameters
scanLineIndex int
Wskaźnik oparty na zero linii skanowania.
pixels Color
[ ]
Kolory pikseli są do pisania.
