Class RasterImage
De naam: Aspose.Imaging Verzameling: Aspose.Imaging.dll (25.4.0)
Het vertegenwoordigt een raster beeld dat raster graphics-operaties ondersteunt.
public abstract class RasterImage : Image, IDisposable, IObjectWithBounds, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, IHasXmpData, IHasMetadataInheritance
object ← DisposableObject ← DataStreamSupporter ← Image ← RasterImage
Derived
Implements
IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata
Geëerbiede leden
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
Dit voorbeeld laat zien hoe u Pixel-informatie in een Array van Type Color laden, de array manipuleren en terug instellen naar de afbeelding. Om deze operaties uit te voeren creëert dit voorwerp een nieuwe Image-bestand (in GIF-formaat) uisng MemoryStream-object.
//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()
Initialiseert een nieuwe instantie van de Aspose.Imaging.RasterImage-klasse.
[JsonConstructor]
protected RasterImage()RasterImage(ICOLORPALET)
Initialiseert een nieuwe instantie van de Aspose.Imaging.RasterImage-klasse.
protected RasterImage(IColorPalette colorPalette)Parameters
colorPalette IColorPalette
De kleurpalet.
Fields
xmpdaten
De XMP metadata
[JsonProperty]
protected XmpPacketWrapper xmpDataveldwaarde
Properties
DataLoader
Geeft of zet de data loader.
[JsonProperty]
protected IRasterImageArgb32PixelLoader DataLoader { get; set; }Eigendomswaarde
HasAlpha
Geeft een waarde die aangeeft of deze instantie alpha heeft.
public virtual bool HasAlpha { get; }Eigendomswaarde
Examples
Het volgende voorbeeld laden rasterbeelden en drukken informatie over het grondgegevensformaat en de alfa-kanaal.
// 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=TrueHet volgende voorbeeld toont hoe u informatie over het grondgegevensformaat en de alfa-kanaal uit een BMP-afbeelding kunt extraheren.
// 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
Geeft een waarde die aangeeft of de afbeelding transparante kleur heeft.
public virtual bool HasTransparentColor { get; set; }Eigendomswaarde
HorizontalResolution
Geeft of stelt de horizontale resolutie, in pixels per inch, van dit Aspose.Imaging.RasterImage.
public virtual double HorizontalResolution { get; set; }Eigendomswaarde
Examples
Het volgende voorbeeld toont hoe je een horisontale/verticale resolutie van een raster beeld kunt instellen.
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
Opmerking per standaard deze waarde is altijd 96 omdat verschillende platforms de resolutie van het scherm niet kunnen retourneren. u kunt overwegen om de SetResolution-methode te gebruiken om beide resolutiewaarden in één oproep te updaten.
ImageOpacity
De opaciteit van deze afbeelding.
public virtual float ImageOpacity { get; }Eigendomswaarde
IsRawDataAvailable
Geeft een waarde die aangeeft of de grondgegevensloading beschikbaar is.
public bool IsRawDataAvailable { get; }Eigendomswaarde
PremultiplyComponents
Geeft of stelt een waarde die aangeeft of de afbeeldingcomponenten moeten worden vooraf vermenigvuldigd.
public virtual bool PremultiplyComponents { get; set; }Eigendomswaarde
Examples
Het volgende voorbeeld creëert een nieuw rasterbeeld, bespaart de aangegeven semi-transparante pixels, loopt dan die pixelen en krijgt uiteindelijke kleuren in de vooraf vermenigvuldigde vorm.
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
Geeft of instelt de aangepaste kleurconverter
public IColorConverter RawCustomColorConverter { get; set; }Eigendomswaarde
RawDataFormat
Geeft het grondgegevensformaat.
public virtual PixelDataFormat RawDataFormat { get; }Eigendomswaarde
Examples
Het volgende voorbeeld laden rasterbeelden en drukken informatie over het grondgegevensformaat en de alfa-kanaal.
// 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=TrueDit voorbeeld toont hoe je een DJVU-afbeelding uit een bestandstromen kunt laden en informatie over de pagina’s kunt afdrukken.
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
Krijg de huidige grondgegevensinstellingen.Noteer bij het gebruik van deze instellingen de gegevens opladen zonder conversie.
[JsonIgnore]
public RawDataSettings RawDataSettings { get; }Eigendomswaarde
RawFallbackIndex
Geeft of zet de fallback index om te gebruiken wanneer de paletindex buiten de grenzen is
public int RawFallbackIndex { get; set; }Eigendomswaarde
RawIndexedColorConverter
Geeft of zet de geïndexeerde kleurconverter
public IIndexedColorConverter RawIndexedColorConverter { get; set; }Eigendomswaarde
RawLineSize
Geeft de grootte van de grondlijn in byten.
public virtual int RawLineSize { get; }Eigendomswaarde
TransparentColor
Geeft de afbeelding transparante kleur.
public virtual Color TransparentColor { get; set; }Eigendomswaarde
UpdateXmpData
Geeft of stelt een waarde die aangeeft of u de XMP metadata moet bijwerken.
public virtual bool UpdateXmpData { get; set; }Eigendomswaarde
UsePalette
Geeft een waarde die aangeeft of de beeldpalet wordt gebruikt.
public override bool UsePalette { get; }Eigendomswaarde
UseRawData
Geeft of stelt een waarde die aangeeft of het gebruik van grondgegevensloading wanneer de grondgegevensloading beschikbaar is.
public virtual bool UseRawData { get; set; }Eigendomswaarde
VerticalResolution
Geeft of stelt de verticale resolutie, in pixels per inch, van dit Aspose.Imaging.RasterImage.
public virtual double VerticalResolution { get; set; }Eigendomswaarde
Examples
Het volgende voorbeeld toont hoe je een horisontale/verticale resolutie van een raster beeld kunt instellen.
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
Opmerking per standaard deze waarde is altijd 96 omdat verschillende platforms de resolutie van het scherm niet kunnen retourneren. u kunt overwegen om de SetResolution-methode te gebruiken om beide resolutiewaarden in één oproep te updaten.
XmpData
Geeft of instelt de XMP metadata.
public virtual XmpPacketWrapper XmpData { get; set; }Eigendomswaarde
Methods
AdjustBrightness(Int)
Aanpassing van een helderheid voor het beeld.
public virtual void AdjustBrightness(int brightness)Parameters
brightness int
De briljante waarde.
Examples
Het volgende voorbeeld uitvoert een helderheidcorrectie van een afbeelding.
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(Vloot)
Image Contrast
public virtual void AdjustContrast(float contrast)Parameters
contrast float
Contrastwaarde (in bereik [-100; 100])
Examples
Het volgende voorbeeld uitvoert een contrastcorrectie van een afbeelding.
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(De vloot, de vloot, de vloot)
Gamma-correctie van een beeld.
public virtual void AdjustGamma(float gammaRed, float gammaGreen, float gammaBlue)Parameters
gammaRed float
Gamma voor de rode kanaal coefficiënt
gammaGreen float
Gamma voor groene kanaal coëfficiënt
gammaBlue float
Gamma voor blauw kanaal coefficiënt
Examples
Het volgende voorbeeld uitvoert een gamma-correctie van een afbeelding die verschillende coëfficiënten toepast op kleurcomponenten.
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(Vloot)
Gamma-correctie van een beeld.
public virtual void AdjustGamma(float gamma)Parameters
gamma float
Gamma voor rode, groene en blauwe kanalen coëfficiënt
Examples
Het volgende voorbeeld uitvoert een gamma-correctie van een afbeelding.
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(dubbele)
Binarisatie van een afbeelding met behulp van Bradley’s adaptieve thresholding algoritme met behulp van de integrale beeld thresholding
public virtual void BinarizeBradley(double brightnessDifference)Parameters
brightnessDifference double
Het lichtverschil tussen de pixel en het gemiddelde van een s x s venster van pixels centraal rond deze pixel.
BinarizeBradley(Twee keer, int)
Binarisatie van een afbeelding met behulp van Bradley’s adaptieve thresholding algoritme met behulp van de integrale beeld thresholding
public virtual void BinarizeBradley(double brightnessDifference, int windowSize)Parameters
brightnessDifference double
Het lichtverschil tussen de pixel en het gemiddelde van een s x s venster van pixels centraal rond deze pixel.
windowSize int
De grootte van de s x s venster van pixels centraal rond deze pixel
Examples
Het volgende voorbeeld binarisert een raster beeld met Bradley’s adaptieve grensoverschrijdende algoritme met de aangegeven venstergrootte.
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)
Binarisatie van een afbeelding met een vooraf gedefinieerde drempel
public virtual void BinarizeFixed(byte threshold)Parameters
threshold byte
Als de overeenkomstige grijze waarde van een pixel groter is dan de grens, wordt er een waarde van 255 aan toegewezen, 0 anders.
Examples
Het volgende voorbeeld binarisert een raster-afbeelding met de vooraf gedefinieerde drempel. Binariseerde afbeeldingen bevatten slechts 2 kleuren - zwart en wit.
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()
Binarisatie van een beeld met Otsu thresholding
public virtual void BinarizeOtsu()Examples
Het volgende voorbeeld binariseren een raster beeld met Otsu thresholding. Binariseerde beelden bevatten slechts 2 kleuren - zwart en wit.
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(Point, RasterImage, Rectangle, byte)
Verzamel deze afbeelding met het overlay’ beeld.
public virtual void Blend(Point origin, RasterImage overlay, Rectangle overlayArea, byte overlayAlpha = 255)Parameters
origin Point
De achtergrond afbeelding blendend oorsprong.
overlay RasterImage
Het overlijden beeld.
overlayArea Rectangle
Het overlijden gebied.
overlayAlpha byte
De overlijden alfa.
Blend(punt, RasterImage, byte)
Verzamel deze afbeelding met het overlay’ beeld.
public void Blend(Point origin, RasterImage overlay, byte overlayAlpha = 255)Parameters
origin Point
De achtergrond afbeelding blendend oorsprong.
overlay RasterImage
Het overlijden beeld.
overlayAlpha byte
De overlijden alfa.
Dither(De methode, int)
Het speelt zich af op het huidige beeld.
public void Dither(DitheringMethod ditheringMethod, int bitsCount)Parameters
ditheringMethod DitheringMethod
De Dithering Methode.
bitsCount int
De laatste bits tellen voor dithering.
Examples
Het volgende voorbeeld loopt een raster-afbeelding en uitvoert grenzen en vloeibare dithering met behulp van verschillende paletdichtheid.
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)
Het speelt zich af op het huidige beeld.
public abstract void Dither(DitheringMethod ditheringMethod, int bitsCount, IColorPalette customPalette)Parameters
ditheringMethod DitheringMethod
De Dithering Methode.
bitsCount int
De laatste bits tellen voor dithering.
customPalette IColorPalette
De gewone palet voor dithering.
Filter(Rectangle, FilterOptionsBase)
Filter de aangegeven rectangle.
public virtual void Filter(Rectangle rectangle, FilterOptionsBase options)Parameters
rectangle Rectangle
De rechthoek.
options FilterOptionsBase
De opties .
Examples
Het volgende voorbeeld geldt voor verschillende soorten filters voor een raster beeld.
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(int, int)
Geeft een afbeelding van een 32-bit ARGB-pixel.
public int GetArgb32Pixel(int x, int y)Parameters
x int
De locatie van de pixel x.
y int
Pixel en locatie.
Returns
De 32-bit ARGB-pixel voor de aangegeven locatie.
Examples
Het volgende voorbeeld loopt een raster-afbeelding en krijgt de kleur van een willekeurige pixel die wordt weergegeven als een 32-bit volledige waarde.
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);
}Het volgende voorbeeld laat zien hoe beeldcaching de prestaties beïnvloedt. in het algemeen wordt het lezen van cached data sneller uitgevoerd dan het leren van niet-cached gegevens.
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)
Geeft de standaard 32-bit ARGB pixels array.
public int[] GetDefaultArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
De rectangle om pixels voor te krijgen.
Returns
int []
De standaard pixels array.
GetDefaultPixels(Rectangle, IPartialArgb32PixelLoader)
Krijg de standaard pixels met behulp van een gedeeltelijke pixelloader.
public void GetDefaultPixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
De rectangle om pixels voor te krijgen.
partialPixelLoader IPartialArgb32PixelLoader
Het gedeeltelijke pixelloader.
GetDefaultRawData(Rectangle, IPartialRawDataLoader, RawDataSettings)
Krijg de standaard gronddata array met behulp van een gedeeltelijke pixelloader.
public void GetDefaultRawData(Rectangle rectangle, IPartialRawDataLoader partialRawDataLoader, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
De rectangle om pixels voor te krijgen.
partialRawDataLoader IPartialRawDataLoader
De partiële grondgegevensloader.
rawDataSettings RawDataSettings
De grondgegevens instellingen.
GetDefaultRawData(Rectangle en RawDataSettings)
Geeft de standaard raw data array.
public byte[] GetDefaultRawData(Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
De rectangle om grondgegevens voor te krijgen.
rawDataSettings RawDataSettings
De grondgegevens instellingen.
Returns
byte []
De standaard raw data array.
GetModifyDate(Bool)
Geeft de datum en tijd dat de resource-afbeelding voor het laatst is gewijzigd.
public virtual DateTime GetModifyDate(bool useDefault)Parameters
useDefault bool
als u op ’true’ hebt ingesteld, gebruikt u de informatie van FileInfo als standaardwaarde.
Returns
De datum en tijd dat de resource-afbeelding voor het laatst is gewijzigd.
GetPixel(int, int)
Geeft een beeld pixels.
public Color GetPixel(int x, int y)Parameters
x int
De locatie van de pixel x.
y int
Pixel en locatie.
Returns
De kleur van de pixel voor de aangegeven locatie.
Examples
Het volgende voorbeeld loopt een raster beeld en krijgt de kleur van een willekeurige pixel.
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()
Geeft de skijngang.Deze methode is van toepassing op gescannelde tekstdocumenten, om de schijfhoek bij het scannen te bepalen.
public float GetSkewAngle()Returns
De schuimengang, in graden.
Grayscale()
Transformatie van een afbeelding naar zijn grayscale vertegenwoordiging
public virtual void Grayscale()Examples
Het volgende voorbeeld transformeert een gekleurde rasterbeeld naar zijn grayscale vertegenwoordiging.Grayescale beelden bestaan uitsluitend uit schaduwen van grijze en dragen alleen intensiteitsinformatie.
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)
32-bit ARGB pixels opladen.
public int[] LoadArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
De rectangle om pixels uit te laden.
Returns
int []
De opgeladen 32-bit ARGB pixels array.
Examples
Het volgende voorbeeld laat zien hoe je pixels van een raster-afbeelding kunt laden en verwerken.De pixelen worden vertegenwoordigd als 32-bit-integrale waarden.
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)
64-bit ARGB pixels opladen.
public long[] LoadArgb64Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
De rectangle om pixels uit te laden.
Returns
long []
De laadde 64-bit ARGB pixels array.
Examples
Het volgende voorbeeld laat zien hoe je pixels van een raster-afbeelding kunt laden en verwerken.De pixelen worden vertegenwoordigd als 64-bit-integrale waarden.
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)
Pixels in CMYK-formaat opladen.
public int[] LoadCmyk32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
De rectangle om pixels uit te laden.
Returns
int []
De geladen CMYK pixels presenteren als 32-bit inateger waarden.
LoadCmykPixels(Rectangle)
Pixels in CMYK-formaat opladen.Gebruik deze methode effectiever de Aspose.Imaging.RasterImage.LoadCmyk32Pixels(W L 17 .Rectangle) method.
[Obsolete("Method is obsolete")]
public CmykColor[] LoadCmykPixels(Rectangle rectangle)Parameters
rectangle Rectangle
De rectangle om pixels uit te laden.
Returns
CmykColor []
De geladen CMYK pixels array.
LoadPartialArgb32Pixels(Rectangle, IPartialArgb32PixelLoader)
Laden 32-bit ARGB pixels gedeeltelijk door pakketten.
public void LoadPartialArgb32Pixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
De gewenste rectangle.
partialPixelLoader IPartialArgb32PixelLoader
De 32-bit ARGB pixelloader.
Examples
Het volgende voorbeeld laat zien hoe je pixels van een raster-afbeelding kunt laden en verwerken met behulp van je eigen gedeeltelijke processor. Bijvoorbeeld, overwegen een probleem van het tellen van volledig transparante pixelen van één beeld. Om doorzichtige pixeles te berekenen door middel van gedeelde ladingmechanisme, wordt een afzonderlijke klasse geïntroduceerd TransparentArgb32PixelCounter implementeren Aspose.Imaging.IPartialArGB32PixelLoader wordt ingevoerd.
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)
Het laden van 64-bit ARGB pixels gedeeltelijk door pakketten.
public void LoadPartialArgb64Pixels(Rectangle rectangle, IPartialArgb64PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
De gewenste rectangle.
partialPixelLoader IPartialArgb64PixelLoader
De 64-bit ARGB pixelloader.
LoadPartialPixels(Rectangle, IPartialPixelLoader)
De pixels worden gedeeltelijk door pakketten opgeladen.
public void LoadPartialPixels(Rectangle desiredRectangle, IPartialPixelLoader pixelLoader)Parameters
desiredRectangle Rectangle
De gewenste rectangle.
pixelLoader IPartialPixelLoader
De Pixel Loader.
Examples
Het volgende voorbeeld laat zien hoe je pixels van een raster-afbeelding kunt laden en verwerken met behulp van je eigen gedeeltelijke processor. Bijvoorbeeld, overwegen een probleem van het tellen van volledig transparante pixelen van één beeld. Om transparant te berekenen door middel van deelloading mechanisme, wordt een afzonderlijke klasse TransparentPixelCounter geïmplementeerd Aspose.Imaging.
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)
Het laden van pixels.
public Color[] LoadPixels(Rectangle rectangle)Parameters
rectangle Rectangle
De rectangle om pixels uit te laden.
Returns
Color []
De opgeladen pixels array.
Examples
Het volgende voorbeeld laat zien hoe je pixels van een raster-afbeelding kunt laden en verwerken.Bijvoorbeeld, overwegen we een probleem met het tellen van volledig transparante pixelen van één beeld.
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);
}Dit voorbeeld laat zien hoe u Pixel-informatie in een Array van Type Color laden, de array manipuleren en terug instellen naar de afbeelding. Om deze operaties uit te voeren creëert dit voorwerp een nieuwe Image-bestand (in GIF-formaat) uisng MemoryStream-object.
//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)
Het laden van grondgegevens.
public void LoadRawData(Rectangle rectangle, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
De rectangle om grondgegevens uit te laden.
rawDataSettings RawDataSettings
De grondgegevensinstellingen om te gebruiken voor geladen gegevens. opmerking als de gegevens niet in het aangegeven formaat zijn dan gegevensconversie zal worden uitgevoerd.
rawDataLoader IPartialRawDataLoader
De rauwe data loader.
Examples
Het volgende voorbeeld laat zien hoe je pixels uit de grond beeldgegevens kunt extraheren met behulp van RawDataSettings.
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)
Het laden van grondgegevens.
public void LoadRawData(Rectangle rectangle, Rectangle destImageBounds, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
De rectangle om grondgegevens uit te laden.
destImageBounds Rectangle
De nette afbeelding grenst.
rawDataSettings RawDataSettings
De grondgegevensinstellingen om te gebruiken voor geladen gegevens. opmerking als de gegevens niet in het aangegeven formaat zijn dan gegevensconversie zal worden uitgevoerd.
rawDataLoader IPartialRawDataLoader
De rauwe data loader.
NormalizeAngle()
Normaliseren van de hoek.Deze methode is van toepassing op gescande tekstdocumenten om zich te ontdoen van de gescande scan.Deze methode maakt gebruik van de Aspose.Imaging.RasterImage.GetSkewAngle- en de W L17. Raster Image .Rotate(System.Single) methoden.
public void NormalizeAngle()NormalizeAngle(Bool, kleur)
Normaliseren van de hoek.Deze methode is van toepassing op gescande tekstdocumenten om zich te ontdoen van de gescande scan.Deze methode maakt gebruik van de Aspose.Imaging.RasterImage.GetSkewAngle en de W L 17. RasterIme.Roate(System.Single,Systems.Boolean,__W WL 17 _.Color) methoden.
public virtual void NormalizeAngle(bool resizeProportionally, Color backgroundColor)Parameters
resizeProportionally bool
als je ’true’ hebt ingesteld, zal je afbeeldingsgrootte worden gewijzigd in overeenstemming met rotatie rectangle (kornpunten) projecties in het andere geval dat de afmetingen niet aanraakt en alleen de interne afbeeldingsinhoud wordt rotatieerd.
backgroundColor Color
De kleur van de achtergrond.
Examples
Skew is een artefact dat kan verschijnen tijdens het scannen van documenten wanneer de tekst / afbeeldingen van het document worden rotatieerd op een lichte hoek. Het kan verschillende oorzaken hebben, maar het meest voorkomende is dat het papier wordt misplaatst tijdens een scan. Daarom, deskev is het proces van detecteren en fixeren van dit probleem op gescannuleerde bestanden (d.w.z. bitmap) zodat de discreet document zal de text / beelden correct en horizontaal aangepast hebben.
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()
Normaliseren van het beeldhistogram - aanpassen van de pixels om alle beschikbare randen te gebruiken.
public virtual void NormalizeHistogram()ReadArgb32ScanLine(Int)
Lees de hele scanlijn door de gespecificeerde scanlijnindex.
public int[] ReadArgb32ScanLine(int scanLineIndex)Parameters
scanLineIndex int
Zero gebaseerde index van de scanlijn.
Returns
int []
De scanlijn 32-bit ARGB kleurwaarden array.
ReadScanLine(Int)
Lees de hele scanlijn door de gespecificeerde scanlijnindex.
public Color[] ReadScanLine(int scanLineIndex)Parameters
scanLineIndex int
Zero gebaseerde index van de scanlijn.
Returns
Color []
De scanlijn pixels kleur waarden array.
ReleaseManagedResources()
Verwijder de beheerde middelen. zorg ervoor dat geen beheerde middelen hier worden vrijgegeven, omdat ze misschien al zijn vrijgegeven.
protected override void ReleaseManagedResources()RemoveMetadata()
Verwijder deze afbeeldingsinstantie metadata door deze Aspose.Imaging.Xmp.IHasXMPData.xmpValuatie te instellen Null.
public override void RemoveMetadata()ReplaceColor(Kleur, byte en kleur)
Vervangt de ene kleur naar de andere met een toegestane verschil en behoudt de oorspronkelijke alfa-waarde om gladde randen te redden.
public void ReplaceColor(Color oldColor, byte oldColorDiff, Color newColor)Parameters
oldColor Color
De oude kleur moet vervangen worden.
oldColorDiff byte
Geleverd verschil in oude kleur om de vervangde kleur ton te kunnen verbreden.
newColor Color
Nieuwe kleur om oude kleur te vervangen.
ReplaceColor(int, byte, int)
Vervangt de ene kleur naar de andere met een toegestane verschil en behoudt de oorspronkelijke alfa-waarde om gladde randen te redden.
public virtual void ReplaceColor(int oldColorArgb, byte oldColorDiff, int newColorArgb)Parameters
oldColorArgb int
De oude kleur ARGB waarde moet worden vervangen.
oldColorDiff byte
Geleverd verschil in oude kleur om de vervangde kleur ton te kunnen verbreden.
newColorArgb int
Nieuwe kleur ARGB waarde om oude kleur te vervangen met.
ReplaceNonTransparentColors(Color)
Het vervangt alle niet-transparente kleuren met nieuwe kleuren en behoudt de oorspronkelijke alfa-waarde om gladde randen te redden.Opmerking: als u het gebruikt op beelden zonder transparantie, worden alle kleuren vervangen door een enkele.
public void ReplaceNonTransparentColors(Color newColor)Parameters
newColor Color
Nieuwe kleuren om niet transparante kleuren te vervangen.
ReplaceNonTransparentColors(Int)
Het vervangt alle niet-transparente kleuren met nieuwe kleuren en behoudt de oorspronkelijke alfa-waarde om gladde randen te redden.Opmerking: als u het gebruikt op beelden zonder transparantie, worden alle kleuren vervangen door een enkele.
public virtual void ReplaceNonTransparentColors(int newColorArgb)Parameters
newColorArgb int
Nieuwe kleur ARGB waarde om niet transparante kleuren te vervangen.
Resize(int, int, ImageResizeSettings)
Verwijder het beeld met uitgebreide opties.
public override void Resize(int newWidth, int newHeight, ImageResizeSettings settings)Parameters
newWidth int
De nieuwe breedte.
newHeight int
De nieuwe hoogte.
settings ImageResizeSettings
De resize instellingen.
Examples
Dit voorbeeld loopt een raster-afbeelding en resecteert het met behulp van verschillende resizing-instellingen.
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, kleur)
Ronde afbeelding rond het centrum.
public virtual void Rotate(float angle, bool resizeProportionally, Color backgroundColor)Parameters
angle float
De rotatie van de hoek in graden. positieve waarden zullen rotatie horloge.
resizeProportionally bool
als je ’true’ hebt ingesteld, zal je afbeeldingsgrootte worden gewijzigd in overeenstemming met rotatie rectangle (kornpunten) projecties in het andere geval dat de afmetingen niet aanraakt en alleen de interne afbeeldingsinhoud wordt rotatieerd.
backgroundColor Color
De kleur van de achtergrond.
Exceptions
Niet geïmplementeerde uitzondering
Rotate(Vloot)
Ronde afbeelding rond het centrum.
public override void Rotate(float angle)Parameters
angle float
De rotatie van de hoek in graden. positieve waarden zullen rotatie horloge.
Save(Stream, ImageOptionsBase, Rectangle)
Speel de gegevens van de afbeelding naar de aangegeven stroom in het aangegeven bestandformaat volgens de opties voor het opslaan.
public override void Save(Stream stream, ImageOptionsBase optionsBase, Rectangle boundsRectangle)Parameters
stream Stream
De stroom om de gegevens van de afbeelding op te slaan.
optionsBase ImageOptionsBase
De opties voor besparing.
boundsRectangle Rectangle
De bestemming beeld grenzen rectangle. Set de lege rectangle voor het gebruik van bron grenzen.
SaveArgb32Pixels(De rectangle, int[])
Speelt de 32-bit ARGB pixels.
public void SaveArgb32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
De rectangle om pixels op te slaan.
pixels int
[]
De 32-bit ARGB pixels array.
Examples
Het volgende voorbeeld vult het centrale gebied van een raster beeld met zwarte pixels met behulp van de 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(De rectangle, int[])
Bespaar de pixels.
public void SaveCmyk32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
De rectangle om pixels op te slaan.
pixels int
[]
De CMYK pixels worden gepresenteerd als de 32-bit-integrale waarden.
Examples
Het volgende voorbeeld vult het centrale gebied van een raster beeld met zwarte pixels met behulp van de 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, CmykColor[])
Bespaar de pixels.Gebruik de Aspose.Imaging.RasterImage.SaveCmyk32Pixels(W L 17 .Rectangle,System.Int32[]) methode effectiever.
[Obsolete("Method is obsolete")]
public void SaveCmykPixels(Rectangle rectangle, CmykColor[] pixels)Parameters
rectangle Rectangle
De rectangle om pixels op te slaan.
pixels CmykColor
[]
De CMYK pixels array.
SavePixels(Rectangle, kleur[])
Bespaar de pixels.
public void SavePixels(Rectangle rectangle, Color[] pixels)Parameters
rectangle Rectangle
De rectangle om pixels op te slaan.
pixels Color
[]
De pixels worden gehaald.
Examples
Het volgende voorbeeld vult het centrale gebied van een raster beeld met zwarte pixels met behulp van de Aspose.Imaging.RasterImage.SavePixels-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
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");
}Dit voorbeeld laat zien hoe u Pixel-informatie in een Array van Type Color laden, de array manipuleren en terug instellen naar de afbeelding. Om deze operaties uit te voeren creëert dit voorwerp een nieuwe Image-bestand (in GIF-formaat) uisng MemoryStream-object.
//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)
Het bespaart de grondgegevens.
public void SaveRawData(byte[] data, int dataOffset, Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
data byte
[]
De rauwe gegevens.
dataOffset int
De start van de grondgegevens wordt terugbetaald.
rectangle Rectangle
De grondgegevens rectangle.
rawDataSettings RawDataSettings
De grondgegevens stellen de gegevens in.
SetArgb32Pixel(int, int, int)
Stel een afbeelding van een 32-bit ARGB-pixel voor de aangegeven positie.
public void SetArgb32Pixel(int x, int y, int argb32Color)Parameters
x int
De locatie van de pixel x.
y int
Pixel en locatie.
argb32Color int
De 32-bit ARGB-pixel voor de aangegeven positie.
Examples
Het volgende voorbeeld loopt een raster beeld en stelt de kleur van een willekeurige pixel vast.
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, Bool)
Stel de beeldpalet in.
public override void SetPalette(IColorPalette palette, bool updateColors)Parameters
palette IColorPalette
De palet om te zetten.
updateColors bool
als de ‘waar’ kleuren worden ingesteld zal worden bijgewerkt volgens de nieuwe palet; anders blijven de kleurindices onveranderd.
SetPixel(int, int, kleur)
Stel een beeldpixel voor de aangegeven positie.
public void SetPixel(int x, int y, Color color)Parameters
x int
De locatie van de pixel x.
y int
Pixel en locatie.
color Color
De kleur van de pixel voor de aangegeven positie.
Examples
Het volgende voorbeeld loopt een raster beeld en stelt de kleur van een willekeurige pixel vast.
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(dubbele, dubbele)
Set de resolutie voor dit Aspose.Imaging.RasterImage.
public virtual void SetResolution(double dpiX, double dpiY)Parameters
dpiX double
De horizontale resolutie, in punten per inch, van de Aspose.Imaging.RasterImage.
dpiY double
De verticale resolutie, in punten per inch, van de Aspose.Imaging.RasterImage.
Examples
Het volgende voorbeeld toont hoe je een horisontale/verticale resolutie van een raster beeld kunt instellen.
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()
Convert raster beeld naar de bitmap.Deze methode wordt niet ondersteund in versies van .Net7.0 of hoger
public virtual Bitmap ToBitmap()Returns
De bitmap
UpdateDimensions(int, int)
Update de afbeeldingsdimensies.
protected abstract void UpdateDimensions(int newWidth, int newHeight)Parameters
newWidth int
De nieuwe beeldbreedte.
newHeight int
De nieuwe beeldhoogte.
UpdateMetadata()
Update de metadata van de afbeelding.
protected virtual void UpdateMetadata()WriteArgb32ScanLine(int, int[])
Schrijf de gehele scanlijn op de aangegeven scanlijnindex.
public void WriteArgb32ScanLine(int scanLineIndex, int[] argb32Pixels)Parameters
scanLineIndex int
Zero gebaseerde index van de scanlijn.
argb32Pixels int
[]
De 32-bits ARGB-kleuren zijn klaar om te schrijven.
WriteScanLine(int, kleur[])
Schrijf de gehele scanlijn op de aangegeven scanlijnindex.
public void WriteScanLine(int scanLineIndex, Color[] pixels)Parameters
scanLineIndex int
Zero gebaseerde index van de scanlijn.
pixels Color
[]
De pixel kleuren komen om te schrijven.
