Class RasterImage
Der Name: Aspose.Imaging Versammlung: Aspose.Imaging.dll (25.4.0)
Es repräsentiert ein Raster-Bild, das Raster-Grafiken unterstützt.
public abstract class RasterImage : Image, IDisposable, IObjectWithBounds, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, IHasXmpData, IHasMetadataInheritance
object ← DisposableObject ← DataStreamSupporter ← Image ← RasterImage
Derived
Implements
IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata
Vererbte Mitglieder
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
Dieses Beispiel zeigt, wie Sie Pixel-Informationen in einer Array von Typfarbe laden, die Array manipulieren und wieder auf das Bild setzen.Um diese Operationen durchzuführen, erstellt dieses Beispiel eine neue Bilddatei (in GIF-Format) uisng MemoryStream Objekt.
//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()
Initialisiert eine neue Instanz der Aspose.Imaging.RasterImage Klasse.
[JsonConstructor]
protected RasterImage()RasterImage(ICOLORPALETTE)
Initialisiert eine neue Instanz der Aspose.Imaging.RasterImage Klasse.
protected RasterImage(IColorPalette colorPalette)Parameters
colorPalette IColorPalette
Die Farbe Palette.
Fields
xmpDaten
Die XMP Metadaten
[JsonProperty]
protected XmpPacketWrapper xmpDataFeldwert
Properties
DataLoader
Erhalten oder setzen Sie den Datenlader.
[JsonProperty]
protected IRasterImageArgb32PixelLoader DataLoader { get; set; }Eigentumswert
HasAlpha
Er erhält einen Wert, der darauf hindeutet, ob diese Instanz Alpha hat.
public virtual bool HasAlpha { get; }Eigentumswert
Examples
Das folgende Beispiel laden raster Bilder auf und drucken Informationen über Rohdatenformat und alpha-Kanal.
// 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=TrueDas folgende Beispiel zeigt, wie man Informationen über Rohdatenformat und Alpha-Kanal aus einem BMP-Bild extrahiert.
// 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
Er erhält einen Wert, der angibt, ob das Bild transparente Farbe hat.
public virtual bool HasTransparentColor { get; set; }Eigentumswert
HorizontalResolution
Erhalten oder setzen die horizontale Auflösung, in Pixeln pro Zoll, dieses Aspose.Imaging.RasterImage.
public virtual double HorizontalResolution { get; set; }Eigentumswert
Examples
Das folgende Beispiel zeigt, wie man eine horizontale/vertikale Auflösung eines Rasterbildes festlegt.
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
Bitte beachten Sie, dass diese Wert immer 96 ist, da verschiedene Plattformen die Bildschirmresolution nicht zurückgeben können. Sie können die SetResolution-Methode verwenden, um beide Resolutionwerte in einem einzigen Anruf zu aktualisieren.
ImageOpacity
Er bekommt die Opacität dieses Bildes.
public virtual float ImageOpacity { get; }Eigentumswert
IsRawDataAvailable
Er erhält einen Wert, der angibt, ob die Rohdatenlastung verfügbar ist.
public bool IsRawDataAvailable { get; }Eigentumswert
PremultiplyComponents
Er erhält oder stellt einen Wert an, der darauf hindeutet, ob die Bildkomponenten vorausgeführt werden müssen.
public virtual bool PremultiplyComponents { get; set; }Eigentumswert
Examples
Das folgende Beispiel erzeugt ein neues Rasterbild, speichert die angegebenen halb transparenten Pixel, ladet dann diese Pixel hoch und erhält endgültige Farben in der vorverfolgten Form.
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
Erhalten oder setzen Sie den benutzerdefinierten Farbkonverter
public IColorConverter RawCustomColorConverter { get; set; }Eigentumswert
RawDataFormat
Erhalten Sie das Rohdatenformat.
public virtual PixelDataFormat RawDataFormat { get; }Eigentumswert
Examples
Das folgende Beispiel laden raster Bilder auf und drucken Informationen über Rohdatenformat und alpha-Kanal.
// 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=TrueDieses Beispiel zeigt, wie man ein DJVU-Bild aus einem Datei-Stream laden und Informationen über die Seiten drucken kann.
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
Erhalten Sie die aktuellen Rohdaten-Einstellungen. Bitte beachten Sie, wenn Sie diese Einstellungen verwenden, werden die Daten ohne Konvertierung geladen.
[JsonIgnore]
public RawDataSettings RawDataSettings { get; }Eigentumswert
RawFallbackIndex
Erhalten oder setzen Sie den Fallback-Index zu verwenden, wenn der Palette-Index außerhalb der Grenzen ist
public int RawFallbackIndex { get; set; }Eigentumswert
RawIndexedColorConverter
Erhalten oder setzen den indexierten Farbkonverter
public IIndexedColorConverter RawIndexedColorConverter { get; set; }Eigentumswert
RawLineSize
Erhalten Sie die Rohlinie Größe in Byten.
public virtual int RawLineSize { get; }Eigentumswert
TransparentColor
Er bekommt das Bild transparente Farbe.
public virtual Color TransparentColor { get; set; }Eigentumswert
UpdateXmpData
Er erhält oder setzt einen Wert, der darauf hindeutet, ob die XMP-Metadaten aktualisiert werden sollen.
public virtual bool UpdateXmpData { get; set; }Eigentumswert
UsePalette
Er erhält einen Wert, der angibt, ob die Bildpalette verwendet wird.
public override bool UsePalette { get; }Eigentumswert
UseRawData
Er erhält oder stellt einen Wert an, der angibt, ob die Rohdatenladung verwendet werden soll, wenn die Rohdatenladung verfügbar ist.
public virtual bool UseRawData { get; set; }Eigentumswert
VerticalResolution
Erhalten oder setzen die vertikale Auflösung, in Pixeln pro Zoll, dieses Aspose.Imaging.RasterImage.
public virtual double VerticalResolution { get; set; }Eigentumswert
Examples
Das folgende Beispiel zeigt, wie man eine horizontale/vertikale Auflösung eines Rasterbildes festlegt.
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
Bitte beachten Sie, dass diese Wert immer 96 ist, da verschiedene Plattformen die Bildschirmresolution nicht zurückgeben können. Sie können die SetResolution-Methode verwenden, um beide Resolutionwerte in einem einzigen Anruf zu aktualisieren.
XmpData
Erhalten oder setzen die XMP-Metadaten.
public virtual XmpPacketWrapper XmpData { get; set; }Eigentumswert
Methods
AdjustBrightness(Int)
Anpassung einer Beleuchtung für Bild.
public virtual void AdjustBrightness(int brightness)Parameters
brightness int
Brightness Wert ist.
Examples
Im folgenden Beispiel wird die Glanzkorrektur eines Bildes durchgeführt.
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(Flotte)
Bildkontrast
public virtual void AdjustContrast(float contrast)Parameters
contrast float
Kontrastwert (in Range [-100; 100])
Examples
Das folgende Beispiel führt zur Kontrastkorrektur eines Bildes durch.
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(Flotte, Flotte und Flotte)
Gamma Korrektur eines Bildes.
public virtual void AdjustGamma(float gammaRed, float gammaGreen, float gammaBlue)Parameters
gammaRed float
Gamma für den roten Kanalkoeffizient
gammaGreen float
Gamma für Grünkanalkoeffizient
gammaBlue float
Gamma für Blue Channel Coefficient
Examples
Das folgende Beispiel führt eine Gamma Korrektur eines Bildes durch, das verschiedene Koeffizienten für Farbkomponenten anwendet.
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(Flotte)
Gamma Korrektur eines Bildes.
public virtual void AdjustGamma(float gamma)Parameters
gamma float
Gamma für rote, grüne und blaue Kanäle Coefficient
Examples
Das folgende Beispiel führt zu einer Gamma Korrektur eines Bildes.
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(doppelt)
Binarisierung eines Bildes mit Bradley’s adaptive Frontierungsalgorithmus mit der integrierten Bildfrontierung
public virtual void BinarizeBradley(double brightnessDifference)Parameters
brightnessDifference double
Der Lichtunterschied zwischen dem Pixel und dem Durchschnitt eines s x s Fensters von Pixeln, die um diesen Pixel zentriert sind.
BinarizeBradley(Doppelt, Int)
Binarisierung eines Bildes mit Bradley’s adaptive Frontierungsalgorithmus mit der integrierten Bildfrontierung
public virtual void BinarizeBradley(double brightnessDifference, int windowSize)Parameters
brightnessDifference double
Der Lichtunterschied zwischen dem Pixel und dem Durchschnitt eines s x s Fensters von Pixeln, die um diesen Pixel zentriert sind.
windowSize int
Die Größe des s x s Fensters von Pixeln, die um diesen Pixel zentriert sind
Examples
Das folgende Beispiel binarisiert ein Rasterbild mit Bradley’s adaptive Frontierungsalgorithmus mit der angegebenen Fenstergröße.
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)
Binarisierung eines Bildes mit vordefinierter Grenze
public virtual void BinarizeFixed(byte threshold)Parameters
threshold byte
Wenn der entsprechende graue Wert eines Pixels größer ist als der Grenzwert, wird ihm ein Wert von 255 zugeordnet, 0 sonst.
Examples
Das folgende Beispiel binarisiert ein Rasterbild mit der vordefinierten Grenze. Binarisierte Bilder enthalten nur 2 Farben - schwarz und wei.
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()
Binarisierung eines Bildes mit Otsu-Grenze
public virtual void BinarizeOtsu()Examples
Das folgende Beispiel binarisiert ein Rasterbild mit Otsu-Grenze. binarisierte Bilder enthalten nur 2 Farben - schwarz und wei.
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)
Mischen Sie diese Bildinstanz mit dem overlay’ Bild.
public virtual void Blend(Point origin, RasterImage overlay, Rectangle overlayArea, byte overlayAlpha = 255)Parameters
origin Point
Das Hintergrundbild blendender Herkunft.
overlay RasterImage
Das überladende Bild.
overlayArea Rectangle
Das Overlay-Gebiet.
overlayAlpha byte
Die Überschwemmung der Alpha.
Blend(Punkt, RasterImage, Byte)
Mischen Sie diese Bildinstanz mit dem overlay’ Bild.
public void Blend(Point origin, RasterImage overlay, byte overlayAlpha = 255)Parameters
origin Point
Das Hintergrundbild blendender Herkunft.
overlay RasterImage
Das überladende Bild.
overlayAlpha byte
Die Überschwemmung der Alpha.
Dither(Die Methode, int)
Ausführungen, die sich auf das aktuelle Bild auswirken.
public void Dither(DitheringMethod ditheringMethod, int bitsCount)Parameters
ditheringMethod DitheringMethod
Die Dithering Methode.
bitsCount int
Die letzten Bits zählen für Dithering.
Examples
Das folgende Beispiel laden ein Rasterbild auf und erledigt die Grenze und fließt mit unterschiedlicher Paletttiefe.
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(DitheringMethod, int, IColorPalette)
Ausführungen, die sich auf das aktuelle Bild auswirken.
public abstract void Dither(DitheringMethod ditheringMethod, int bitsCount, IColorPalette customPalette)Parameters
ditheringMethod DitheringMethod
Die Dithering Methode.
bitsCount int
Die letzten Bits zählen für Dithering.
customPalette IColorPalette
Die gewöhnliche Palette für Dithering.
Filter(Rectangle, FilterOptionsBase)
Filtert den angegebenen Rechteck.
public virtual void Filter(Rectangle rectangle, FilterOptionsBase options)Parameters
rectangle Rectangle
Die rechte Ecke.
options FilterOptionsBase
Die Optionen.
Examples
Das folgende Beispiel gilt für verschiedene Arten von Filtern für ein Rasterbild.
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(und int, int)
Erhält ein Bild mit einem 32-Bit-ARGB-Pixel.
public int GetArgb32Pixel(int x, int y)Parameters
x int
Der Pixel x Standort.
y int
Pixel und Standort.
Returns
Das 32-Bit-ARGB-Pixel für die angegebenen Lage.
Examples
Das folgende Beispiel laden ein Rasterbild auf und erhält die Farbe eines willkürlichen Pixels, das als 32-Bit-Total-Wert dargestellt wird.
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);
}Das folgende Beispiel zeigt, wie Bildcaching die Leistung beeinflusst. im Allgemeinen wird das Lesen von cached-Daten schneller durchgeführt als das Lesen von nicht cached-Daten.
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)
Erhalten Sie die standardmäßige 32-Bit-ARGB-Pixel-Array.
public int[] GetDefaultArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Die rechte Ecke, um Pixel zu bekommen.
Returns
int [][]
Die Standard-Pixels werden ausgeführt.
GetDefaultPixels(Rectangle, IPartialArgb32PixelLoader)
Erhalten Sie die standardmäßigen Pixel mit partiellen Pixel-Ladern.
public void GetDefaultPixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Die rechte Ecke, um Pixel zu bekommen.
partialPixelLoader IPartialArgb32PixelLoader
Die partielle Pixel Loader.
GetDefaultRawData(Rectangle, IPartialRawDataLoader, RawDataSettings)
Erhalten Sie die standardmäßige Rohdatenregelung mit partiellen Pixel-Ladern.
public void GetDefaultRawData(Rectangle rectangle, IPartialRawDataLoader partialRawDataLoader, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Die rechte Ecke, um Pixel zu bekommen.
partialRawDataLoader IPartialRawDataLoader
Der partielle Rohdatenloader.
rawDataSettings RawDataSettings
Die Rohdateninstellungen.
GetDefaultRawData(Rectangle und RawDataSettings)
Erhalten Sie die default raw data array.
public byte[] GetDefaultRawData(Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Die rechte Ecke, um Rohdaten zu erhalten.
rawDataSettings RawDataSettings
Die Rohdateninstellungen.
Returns
byte [][]
Die default raw data array.
GetModifyDate(Bool)
Gibt das Datum und die Zeit, an dem das Ressourcenbild zuletzt geändert wurde.
public virtual DateTime GetModifyDate(bool useDefault)Parameters
useDefault bool
Wenn Sie auf ’true’ eingestellt sind, verwenden Sie die Informationen aus FileInfo als Standardwert.
Returns
Das Datum und die Uhrzeit des Ressourcenbildes wurde zuletzt geändert.
GetPixel(und int, int)
Sie erhalten ein Bildpixel.
public Color GetPixel(int x, int y)Parameters
x int
Der Pixel x Standort.
y int
Pixel und Standort.
Returns
Die Pixelfarbe für die angegebenen Lage.
Examples
Das folgende Beispiel laden ein Rasterbild auf und erhält die Farbe eines arbiträren Pixels.
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()
Fangen Sie den Schießang.Diese Methode gilt für gescannte Textdokumente, um den Schießang zu bestimmen beim Scan.
public float GetSkewAngle()Returns
Der Skigengang, in Grad.
Grayscale()
Umwandlung eines Bildes in seine grayscale Darstellung
public virtual void Grayscale()Examples
Das folgende Beispiel verwandelt ein farbiges Rasterbild in seine grayscale Darstellung. Grayscale Bilder bestehen ausschließlich aus Schatten des Grays und tragen nur Intensitätsinformationen.
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)
Laden Sie 32-Bit ARGB-Pixel.
public int[] LoadArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Der Rechtangel, um Pixel von zu laden.
Returns
int [][]
Die 32-Bit-ARGB-Pixel-Array wird geladen.
Examples
Das folgende Beispiel zeigt, wie Pixel eines Rasterbildes geladen und verarbeitet werden können.Die Pixel werden als 32-Bit-Total-Werte dargestellt. Zum Beispiel berücksichtigen Sie ein Problem der Berechnung voll transparenter Pixel eines Bildes.
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)
Laden Sie 64-Bit ARGB-Pixel.
public long[] LoadArgb64Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Der Rechtangel, um Pixel von zu laden.
Returns
long [][]
Die hochgeladenen 64-Bit-ARGB-Pixel-Array.
Examples
Das folgende Beispiel zeigt, wie Pixel eines Rasterbildes geladen und verarbeitet werden können.Die Pixel werden als 64-Bit-Total-Werte dargestellt. Zum Beispiel berücksichtigen Sie ein Problem der Berechnung voll transparenter Pixel eines Bildes.
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)
Pixel im CMYK-Format laden.
public int[] LoadCmyk32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Der Rechtangel, um Pixel von zu laden.
Returns
int [][]
Die hochgeladenen CMYK-Pixel präsentieren sich als 32-Bit-Inateger-Werte.
LoadCmykPixels(Rectangle)
Pixel im CMYK-Format laden.Bitte verwenden Sie die Aspose.Imaging.RasterImage.LoadCmyk32Pixels(Aspose.Imaging.Rectangle) Methode effektiver.
[Obsolete("Method is obsolete")]
public CmykColor[] LoadCmykPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Der Rechtangel, um Pixel von zu laden.
Returns
CmykColor [][]
Die hochgeladenen CMYK Pixel Array.
LoadPartialArgb32Pixels(Rectangle, IPartialArgb32PixelLoader)
Laden 32-Bit-ARGB-Pixels teilweise durch Pakete.
public void LoadPartialArgb32Pixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Der gewünschte Rechteck.
partialPixelLoader IPartialArgb32PixelLoader
Der 32-Bit ARGB Pixel-Ladegerät.
Examples
Das folgende Beispiel zeigt, wie Sie Pixel eines Rasterbildes mit Ihrem eigenen Teilprozessor laden und verarbeiten können. Zum Beispiel berücksichtigen Sie ein Problem mit der Berechnung voll transparenter Pixel eines Bildes. Um transparente Pixel mit Teilladenmechanismus zu berechnen, wird eine separate Klasse TransparentArgb32PixelCounter mit der Implementierung von Aspose.Imaging.IPartialArgb32PixelLoader eingeführt.
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)
Laden 64-Bit-ARGB-Pixels teilweise durch Pakete.
public void LoadPartialArgb64Pixels(Rectangle rectangle, IPartialArgb64PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Der gewünschte Rechteck.
partialPixelLoader IPartialArgb64PixelLoader
Der 64-Bit ARGB Pixel Loader.
LoadPartialPixels(Rectangle, IPartialPixelLoader)
Laden Sie Pixel teilweise durch Pakete.
public void LoadPartialPixels(Rectangle desiredRectangle, IPartialPixelLoader pixelLoader)Parameters
desiredRectangle Rectangle
Der gewünschte Rechteck.
pixelLoader IPartialPixelLoader
Der Pixel Loader.
Examples
Das folgende Beispiel zeigt, wie man Pixel eines Rasterbildes mit Ihrem eigenen Teilprozessor laden und verarbeiten kann. Zum Beispiel berücksichtigen Sie ein Problem mit der Berechnung voll transparenter Pixel eines Bildes. Um Transparent mit Teilladenmechanismus zu berechnen, wird eine separate Klasse TransparentPixelCounter eingeführt, die Aspose.Imaging.IPartialPixelLoader implementiert.
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)
Laden Sie Pixel.
public Color[] LoadPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Der Rechtangel, um Pixel von zu laden.
Returns
Color [][]
Die hochgeladenen Pixel sind aufgeladen.
Examples
Das folgende Beispiel zeigt, wie man Pixel eines Rasterbildes laden und verarbeiten kann. Beispielsweise berücksichtigen Sie ein Problem mit der Berechnung voll transparenter Pixel eines Bildes.
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);
}Dieses Beispiel zeigt, wie Sie Pixel-Informationen in einer Array von Typfarbe laden, die Array manipulieren und wieder auf das Bild setzen.Um diese Operationen durchzuführen, erstellt dieses Beispiel eine neue Bilddatei (in GIF-Format) uisng MemoryStream Objekt.
//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)
Laden Sie Rohdaten.
public void LoadRawData(Rectangle rectangle, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Der Rechtangel, um Rohdaten von.
rawDataSettings RawDataSettings
Die Rohdateninstellungen, die für geladene Daten verwendet werden. Bitte beachten Sie, wenn die Daten nicht im angegebenen Format sind, dann wird die Datenkonvertierung durchgeführt.
rawDataLoader IPartialRawDataLoader
Der Rohdatenloader.
Examples
Das folgende Beispiel zeigt, wie Sie Pixel aus den Rohbilddaten mit RawDataSettings extrahieren können. zum Beispiel, denken Sie an ein Problem der Berechnung voll transparenter Pixel eines Bildes.
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)
Laden Sie Rohdaten.
public void LoadRawData(Rectangle rectangle, Rectangle destImageBounds, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Der Rechtangel, um Rohdaten von.
destImageBounds Rectangle
Das Bild begrenzt.
rawDataSettings RawDataSettings
Die Rohdateninstellungen, die für geladene Daten verwendet werden. Bitte beachten Sie, wenn die Daten nicht im angegebenen Format sind, dann wird die Datenkonvertierung durchgeführt.
rawDataLoader IPartialRawDataLoader
Der Rohdatenloader.
NormalizeAngle()
Normalisieren Sie den Winkel.Diese Methode gilt für gescannte Textdokumente, um sich von der gescannten Scan loszuwerden.Diese Methode verwendet Aspose.Imaging.RasterImage.GetSkewAngle und Aspose.Imaging.RasterImage.Rotate(System.Single) Methoden.
public void NormalizeAngle()NormalizeAngle(Bool, Farbe)
Normalisieren Sie den Winkel.Diese Methode gilt für gescannte Textdokumente, um sich von der gescannten Scan loszuwerden.Diese Methode verwendet Aspose.Imaging.RasterImage.GetSkewAngle und Aspose.Imaging.RasterImage.Rotate(System.Single,System.Boolean,Aspose.Imaging.Color) Methoden.
public virtual void NormalizeAngle(bool resizeProportionally, Color backgroundColor)Parameters
resizeProportionally bool
Wenn Sie auf “richtig” festgelegt sind, werden Sie Ihre Bildgröße gemäß rotierten Rechtangeln (Kornpunkte) Prognosen geändert haben, in anderen Fällen, die Dimensionen unberührt lassen und nur interne Bildgehalte rotierten.
backgroundColor Color
Farbe des Hintergrunds.
Examples
Skew ist ein Artefakte, das während des Dokumentscan-Prozesses erscheinen kann, wenn die Texte / Bilder des Dokuments in einem leichten Winkel rotiert werden. Es kann verschiedene Ursachen haben, aber am häufigsten ist, dass das Papier während einer Scan falsch gelegt wird. Daher, deskew ist der Prozess der Entdeckung und Fixierung dieses Problems auf scannen Dateien (d.h. Bitmap) so deskewed Dokumente haben die Texte / Bilder korrekt und horizontalerweise angepasst.
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()
Normalisieren Sie das Bildhistogram – passen Sie die Pixelwerte an, um alle verfügbaren Bereiche zu verwenden.
public virtual void NormalizeHistogram()ReadArgb32ScanLine(Int)
Lesen Sie die gesamte Scan-Linie durch den angegebenen Scan-Linie-Index.
public int[] ReadArgb32ScanLine(int scanLineIndex)Parameters
scanLineIndex int
Zero-basierter Index der Scan-Linie.
Returns
int [][]
Die Scannenlinie 32-Bit ARGB Farbwerte sortiert.
ReadScanLine(Int)
Lesen Sie die gesamte Scan-Linie durch den angegebenen Scan-Linie-Index.
public Color[] ReadScanLine(int scanLineIndex)Parameters
scanLineIndex int
Zero-basierter Index der Scan-Linie.
Returns
Color [][]
Die Scan-Linie Pixel Farbwerte sorgen.
ReleaseManagedResources()
Stellen Sie sicher, dass hier keine nicht verwalteten Ressourcen veröffentlicht werden, da sie möglicherweise bereits veröffentlicht wurden.
protected override void ReleaseManagedResources()RemoveMetadata()
Entfernen Sie diese Bildinstanzmetadaten, indem Sie diesen Aspose.Imaging.Xmp.IHasXMPData.xmpVertrag festlegen Null.
public override void RemoveMetadata()ReplaceColor(Farbe, Byte und Farbe)
Es ersetzt eine Farbe für eine andere mit der zulässigen Differenz und bewahrt den ursprünglichen Alpha-Wert, um glänzende Rände zu speichern.
public void ReplaceColor(Color oldColor, byte oldColorDiff, Color newColor)Parameters
oldColor Color
Die alte Farbe wird ersetzt.
oldColorDiff byte
Der Unterschied in der alten Farbe erlaubt, um den ersetzten Farbton zu erweitern.
newColor Color
Neue Farbe ersetzt die alte Farbe.
ReplaceColor(Int, Byte und Int)
Es ersetzt eine Farbe für eine andere mit der zulässigen Differenz und bewahrt den ursprünglichen Alpha-Wert, um glänzende Rände zu speichern.
public virtual void ReplaceColor(int oldColorArgb, byte oldColorDiff, int newColorArgb)Parameters
oldColorArgb int
Die alte Farbe ARGB wird ersetzt.
oldColorDiff byte
Der Unterschied in der alten Farbe erlaubt, um den ersetzten Farbton zu erweitern.
newColorArgb int
Neue Farbwerte ARGB ersetzen alte Farbwerte mit.
ReplaceNonTransparentColors(Color)
Er ersetzt alle nicht transparenten Farben mit einer neuen Farbe und bewahrt den ursprünglichen Alpha-Wert, um schmutzige Rände zu speichern.Hinweis: Wenn Sie es auf Bildern ohne Transparenz verwenden, werden alle Farben mit einem einzigen ersetzt.
public void ReplaceNonTransparentColors(Color newColor)Parameters
newColor Color
Neue Farben ersetzen nicht transparente Farben.
ReplaceNonTransparentColors(Int)
Er ersetzt alle nicht transparenten Farben mit einer neuen Farbe und bewahrt den ursprünglichen Alpha-Wert, um schmutzige Rände zu speichern.Hinweis: Wenn Sie es auf Bildern ohne Transparenz verwenden, werden alle Farben mit einem einzigen ersetzt.
public virtual void ReplaceNonTransparentColors(int newColorArgb)Parameters
newColorArgb int
Neue Farbwerte ARGB ersetzen nicht transparente Farben mit.
Resize(int, int, ImageResizeSettings)
Wiederherstellen des Bildes mit erweiterten Optionen.
public override void Resize(int newWidth, int newHeight, ImageResizeSettings settings)Parameters
newWidth int
Die neue Breite.
newHeight int
Die neue Höhe.
settings ImageResizeSettings
Die Resize Einstellungen.
Examples
Dieses Beispiel laden ein Raster-Bild auf und resiziert es mit verschiedenen Resizing-Einstellungen.
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, Farbe)
Drehen Sie das Bild um das Zentrum.
public virtual void Rotate(float angle, bool resizeProportionally, Color backgroundColor)Parameters
angle float
Der Rotationswinkel in Grad. Positive Werte werden die Uhr drehen.
resizeProportionally bool
Wenn Sie auf “richtig” festgelegt sind, werden Sie Ihre Bildgröße gemäß rotierten Rechtangeln (Kornpunkte) Prognosen geändert haben, in anderen Fällen, die Dimensionen unberührt lassen und nur interne Bildgehalte rotierten.
backgroundColor Color
Farbe des Hintergrunds.
Exceptions
Nicht implementierte Ausnahmen
Rotate(Flotte)
Drehen Sie das Bild um das Zentrum.
public override void Rotate(float angle)Parameters
angle float
Der Rotationswinkel in Grad. Positive Werte werden die Uhr drehen.
Save(Stream, ImageOptionsBase, Rectangle)
Speichert die Daten des Bildes in den angegebenen Stream im angegebenen Dateiformat nach Speicheroptionen.
public override void Save(Stream stream, ImageOptionsBase optionsBase, Rectangle boundsRectangle)Parameters
stream Stream
Der Stream, um die Daten des Bildes zu speichern.
optionsBase ImageOptionsBase
Die sparen Optionen.
boundsRectangle Rectangle
Das Zielbild begrenzt rektangle. Set die leere rektangle für die Verwendung von Quellgrenzen.
SaveArgb32Pixels(Rektangel, Int[])
Speichern Sie die 32-Bit-ARGB-Pixel.
public void SaveArgb32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Die rechte Ecke, um Pixel zu speichern.
pixels int
[][]
Die 32-Bit-ARGB-Pixel werden aufgeführt.
Examples
Das folgende Beispiel füllt das zentrale Gebiet eines Rasterbildes mit schwarzen Pixeln mit der Aspose.Imaging.RasterImage.SaveArgb32Pixels-Methode.
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(Rektangel, Int[])
Sparen Sie die Pixel.
public void SaveCmyk32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Die rechte Ecke, um Pixel zu speichern.
pixels int
[][]
Die CMYK-Pixel wurden als 32-Bit-Einheitwerte dargestellt.
Examples
Das folgende Beispiel füllt das zentrale Gebiet eines Rasterbildes mit schwarzen Pixeln mit der Aspose.Imaging.RasterImage.SaveCmyk32Pixels-Methode.
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(Rectangle und CmykColor[])
Sparen Sie die Pixel.Bitte verwenden Sie die Aspose.Imaging.RasterImage.SaveCmyk32Pixels(Aspose.Imaging.Rectangle,System.Int32[]) Methode effektiver.
[Obsolete("Method is obsolete")]
public void SaveCmykPixels(Rectangle rectangle, CmykColor[] pixels)Parameters
rectangle Rectangle
Die rechte Ecke, um Pixel zu speichern.
pixels CmykColor
[][]
Die CMYK-Pixel werden aufgeführt.
SavePixels(Rectangle, Farbe[])
Sparen Sie die Pixel.
public void SavePixels(Rectangle rectangle, Color[] pixels)Parameters
rectangle Rectangle
Die rechte Ecke, um Pixel zu speichern.
pixels Color
[][]
Die Pixel sind aufgeregt.
Examples
Das folgende Beispiel füllt das zentrale Gebiet eines Rasterbildes mit schwarzen Pixeln mit der Methode 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");
}Dieses Beispiel zeigt, wie Sie Pixel-Informationen in einer Array von Typfarbe laden, die Array manipulieren und wieder auf das Bild setzen.Um diese Operationen durchzuführen, erstellt dieses Beispiel eine neue Bilddatei (in GIF-Format) uisng MemoryStream Objekt.
//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, Rectangle, RawDataSettings)
Er spart die Rohdaten.
public void SaveRawData(byte[] data, int dataOffset, Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
data byte
[][]
und die Rohdaten.
dataOffset int
Die anfänglichen Rohdaten entschädigen.
rectangle Rectangle
Die Rohdaten rectangle.
rawDataSettings RawDataSettings
Die Rohdaten setzen die Daten in.
SetArgb32Pixel(und int, int, int)
Setzen Sie ein 32-Bit-ARGB-Pixel für die angegebenen Position.
public void SetArgb32Pixel(int x, int y, int argb32Color)Parameters
x int
Der Pixel x Standort.
y int
Pixel und Standort.
argb32Color int
Das 32-Bit-ARGB-Pixel für die angegebenen Position.
Examples
Das folgende Beispiel laden ein Rasterbild auf und legt die Farbe eines arbiträren Pixels fest.
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(IColorPalette und Bool)
Setzen Sie die Bildpalette.
public override void SetPalette(IColorPalette palette, bool updateColors)Parameters
palette IColorPalette
Die Palette zu setzen.
updateColors bool
wenn auf “richtige” Farben festgelegt wird, wird gemäß der neuen Palette aktualisiert; sonst bleiben die Farb-Indizes unverändert. Bitte beachten Sie, dass unveränderte Indizes das Bild auf der Ladung verschwinden können, wenn einige Indizes keine entsprechenden Palette-Einnahmen haben.
SetPixel(int, int, Farbe)
Setzen Sie ein Bildpixel für die angegebenen Position.
public void SetPixel(int x, int y, Color color)Parameters
x int
Der Pixel x Standort.
y int
Pixel und Standort.
color Color
Die Pixelfarbe für die angegebenen Position.
Examples
Das folgende Beispiel laden ein Rasterbild auf und legt die Farbe eines arbiträren Pixels fest.
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(Doppel, Doppel)
Setzt die Auflösung für diese Aspose.Imaging.RasterImage.
public virtual void SetResolution(double dpiX, double dpiY)Parameters
dpiX double
Die horizontale Auflösung, in Punkten pro Zoll, des Aspose.Imaging.RasterImage.
dpiY double
Die vertikale Auflösung, in Punkten pro Zoll, des Aspose.Imaging.RasterImage.
Examples
Das folgende Beispiel zeigt, wie man eine horizontale/vertikale Auflösung eines Rasterbildes festlegt.
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()
Umwandeln Sie das Raster-Bild in die Bitmap.Diese Methode wird nicht in Versionen von .Net7.0 oder höher unterstützt.
public virtual Bitmap ToBitmap()Returns
Die Bitmap
UpdateDimensions(und int, int)
Aktualisieren Sie die Bilddimensionen.
protected abstract void UpdateDimensions(int newWidth, int newHeight)Parameters
newWidth int
Die neue Bildweite.
newHeight int
Die neue Bildhöhe.
UpdateMetadata()
Aktualisieren Sie die Bildmetadata.
protected virtual void UpdateMetadata()WriteArgb32ScanLine(und int, int[])
Schreiben Sie die gesamte Scan-Linie zum angegebenen Scan-Linie-Index.
public void WriteArgb32ScanLine(int scanLineIndex, int[] argb32Pixels)Parameters
scanLineIndex int
Zero-basierter Index der Scan-Linie.
argb32Pixels int
[][]
Die 32-Bit-ARGB-Farben können geschrieben werden.
WriteScanLine(Int, Farbe[])
Schreiben Sie die gesamte Scan-Linie zum angegebenen Scan-Linie-Index.
public void WriteScanLine(int scanLineIndex, Color[] pixels)Parameters
scanLineIndex int
Zero-basierter Index der Scan-Linie.
pixels Color
[][]
Die Pixelfarben lassen sich schreiben.
