Class RasterImage
Navne til: Aspose.Imaging Sammensætning: Aspose.Imaging.dll (25.4.0)
Det repræsenterer et rasterbillede, der understøtter rastergrafikoperationer.
public abstract class RasterImage : Image, IDisposable, IObjectWithBounds, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, IHasXmpData, IHasMetadataInheritance
object ← DisposableObject ← DataStreamSupporter ← Image ← RasterImage
Derived
Implements
IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata
De arvede medlemmer
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
Dette eksempel viser, hvordan du lader Pixel-oplysninger i en Array af Type Color, manipulerer array og sætter det tilbage til billedet. For at udføre disse operationer skaber dette eksempel en ny Image-fil (i 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()
Initialiserer en ny instans af Aspose.Imaging.RasterImage klasse.
[JsonConstructor]
protected RasterImage()RasterImage(ICOLORPalette)
Initialiserer en ny instans af Aspose.Imaging.RasterImage klasse.
protected RasterImage(IColorPalette colorPalette)Parameters
colorPalette IColorPalette
Den farve palette.
Fields
xmpData
XMP metadata
[JsonProperty]
protected XmpPacketWrapper xmpDataFællesværdi
Properties
DataLoader
Få eller indsætte data loader.
[JsonProperty]
protected IRasterImageArgb32PixelLoader DataLoader { get; set; }Ejendomsværdi
HasAlpha
Giver en værdi, der angiver, om denne instans har alfa.
public virtual bool HasAlpha { get; }Ejendomsværdi
Examples
Følgende eksempel lader rasterbilleder og trykker oplysninger om rådataformat og alfa-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=TrueFølgende eksempel viser, hvordan man ekstraherer oplysninger om rådataformat og alfa-kanal fra et BMP-billede.
// 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
Giver en værdi, der angiver, om billedet har en gennemsigtig farve.
public virtual bool HasTransparentColor { get; set; }Ejendomsværdi
HorizontalResolution
Få eller indstille den horisontale opløsning, i piksler pr. centimeter, af denne Aspose.Imaging.RasterImage.
public virtual double HorizontalResolution { get; set; }Ejendomsværdi
Examples
Følgende eksempel viser, hvordan man indstiller en horisontal/vertikal opløsning af et rasterbillede.
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
Note by default denne værdi er altid 96 da forskellige platforme ikke kan returnere skærmresolution. Du kan overveje at bruge SetResolution-metoden til at opdatere begge resolutionsværdier i en enkelt opkald.
ImageOpacity
Gør opaciteten af dette billede.
public virtual float ImageOpacity { get; }Ejendomsværdi
IsRawDataAvailable
Giver en værdi, der angiver, om rå data opladning er tilgængelig.
public bool IsRawDataAvailable { get; }Ejendomsværdi
PremultiplyComponents
Giver eller indsætter en værdi, der angiver, om billedkomponenterne skal forlænges.
public virtual bool PremultiplyComponents { get; set; }Ejendomsværdi
Examples
Følgende eksempel skaber et nyt rasterbillede, sparer de angivne halvt gennemsigtige pixels, lader derefter disse pixler og får endelige farver i den forlængede 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
Få eller indstille den tilpassede farvekonverter
public IColorConverter RawCustomColorConverter { get; set; }Ejendomsværdi
RawDataFormat
Få den rå data format.
public virtual PixelDataFormat RawDataFormat { get; }Ejendomsværdi
Examples
Følgende eksempel lader rasterbilleder og trykker oplysninger om rådataformat og alfa-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=TrueDette eksempel viser, hvordan man lader et DJVU-billede fra en filstrøm og trykker oplysninger om siderne.
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
Bemærk, når du bruger disse indstillinger, oplader dataene uden konvertering.
[JsonIgnore]
public RawDataSettings RawDataSettings { get; }Ejendomsværdi
RawFallbackIndex
Få eller indsætte fallback-indekset til brug, når paletteindekset er uden for grænser
public int RawFallbackIndex { get; set; }Ejendomsværdi
RawIndexedColorConverter
Få eller indstille den indekserede farve konverter
public IIndexedColorConverter RawIndexedColorConverter { get; set; }Ejendomsværdi
RawLineSize
Få den rå linje størrelse i byte.
public virtual int RawLineSize { get; }Ejendomsværdi
TransparentColor
Giver billedet transparent farve.
public virtual Color TransparentColor { get; set; }Ejendomsværdi
UpdateXmpData
Få eller indstille en værdi, der angiver, om du skal opdatere XMP metadata.
public virtual bool UpdateXmpData { get; set; }Ejendomsværdi
UsePalette
Giver en værdi, der angiver, om billedpaletten anvendes.
public override bool UsePalette { get; }Ejendomsværdi
UseRawData
Giver eller indsætter en værdi, der angiver, om man skal bruge rå data opladning, når rå data opladning er tilgængelig.
public virtual bool UseRawData { get; set; }Ejendomsværdi
VerticalResolution
Få eller indstille den vertikale opløsning, i piksler pr. centimeter, af denne Aspose.Imaging.RasterImage.
public virtual double VerticalResolution { get; set; }Ejendomsværdi
Examples
Følgende eksempel viser, hvordan man indstiller en horisontal/vertikal opløsning af et rasterbillede.
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
Note by default denne værdi er altid 96 da forskellige platforme ikke kan returnere skærmresolution. Du kan overveje at bruge SetResolution-metoden til at opdatere begge resolutionsværdier i en enkelt opkald.
XmpData
Få eller indsætte XMP metadata.
public virtual XmpPacketWrapper XmpData { get; set; }Ejendomsværdi
Methods
AdjustBrightness(Int)
Tilpasning af lys for billedet.
public virtual void AdjustBrightness(int brightness)Parameters
brightness int
Lysets værdi.
Examples
Følgende eksempel foretager en klarhed korrigering af et billede.
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(Flåder)
Billedkontrast
public virtual void AdjustContrast(float contrast)Parameters
contrast float
Kontrastværdi (i rækkefølge [-100; 100])
Examples
Følgende eksempel udfører kontrast korrigering af et billede.
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(Flåder, Flåder og Flåder)
Gamma-korrektion af et billede.
public virtual void AdjustGamma(float gammaRed, float gammaGreen, float gammaBlue)Parameters
gammaRed float
Gamma for rødkanal koefficient
gammaGreen float
Gamma for grøn kanal koefficient
gammaBlue float
Gamma for blå kanal koefficient
Examples
Følgende eksempel udfører gamma-korrektion af et billede, der anvender forskellige koefficienter til farvekomponenter.
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(Flåder)
Gamma-korrektion af et billede.
public virtual void AdjustGamma(float gamma)Parameters
gamma float
Gamma for røde, grønne og blå kanaler
Examples
Følgende eksempel udfører gamma-korrektion af et billede.
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(dobbelt)
Binarisering af et billede ved hjælp af Bradley’s adaptive grænseoverskridende algoritme ved hjælp af den integrerede image grænseoverskridende
public virtual void BinarizeBradley(double brightnessDifference)Parameters
brightnessDifference double
Den lysforskel mellem piksler og gennemsnittet af et s x s vindue af piksler centreret omkring denne piksel.
BinarizeBradley(Dobbelt og int)
Binarisering af et billede ved hjælp af Bradley’s adaptive grænseoverskridende algoritme ved hjælp af den integrerede image grænseoverskridende
public virtual void BinarizeBradley(double brightnessDifference, int windowSize)Parameters
brightnessDifference double
Den lysforskel mellem piksler og gennemsnittet af et s x s vindue af piksler centreret omkring denne piksel.
windowSize int
Størrelsen af s x s vindue af piksler centreret omkring denne piksel
Examples
Følgende eksempel binariserer et rasterbillede med Bradley’s adaptive grænsefladealgoritme med den angivne vinduesstørrelse.
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)
Binarisering af et billede med en fordefineret grænse
public virtual void BinarizeFixed(byte threshold)Parameters
threshold byte
Hvis den tilsvarende grå værdi af en pixel er større end grænsen, vil der tildeles en værdi af 255 til den, 0 ellers.
Examples
Følgende eksempel binariserer et rasterbillede med den foruddefinerede grænse. binære billeder indeholder kun 2 farver - sort og hvid.
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()
Binarisering af et billede med Otsu
public virtual void BinarizeOtsu()Examples
Følgende eksempel binariserer et rasterbillede med Otsu-grænse. binære billeder indeholder kun 2 farver - sort og hvid.
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)
Blend denne billedinstans med overlay’ billedet.
public virtual void Blend(Point origin, RasterImage overlay, Rectangle overlayArea, byte overlayAlpha = 255)Parameters
origin Point
Den baggrundsbillede blendende oprindelse.
overlay RasterImage
Det overlydende billede.
overlayArea Rectangle
Det overladte område.
overlayAlpha byte
Den overladte alfa.
Blend(Størrelse, RasterImage, byte)
Blend denne billedinstans med overlay’ billedet.
public void Blend(Point origin, RasterImage overlay, byte overlayAlpha = 255)Parameters
origin Point
Den baggrundsbillede blendende oprindelse.
overlay RasterImage
Det overlydende billede.
overlayAlpha byte
Den overladte alfa.
Dither(DitheringMethode, int)
Der er tale om optagelse af det aktuelle billede.
public void Dither(DitheringMethod ditheringMethod, int bitsCount)Parameters
ditheringMethod DitheringMethod
Den dyderende metode.
bitsCount int
De sidste bits tæller for dithering.
Examples
Følgende eksempel oplader et rasterbillede og udfører grænse og flyd dithering ved hjælp af forskellige palet dybde.
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)
Der er tale om optagelse af det aktuelle billede.
public abstract void Dither(DitheringMethod ditheringMethod, int bitsCount, IColorPalette customPalette)Parameters
ditheringMethod DitheringMethod
Den dyderende metode.
bitsCount int
De sidste bits tæller for dithering.
customPalette IColorPalette
Det er den sædvanlige palette til dithering.
Filter(Rectangle, FilterOptionsBase)
Filtrer den angivne rektangle.
public virtual void Filter(Rectangle rectangle, FilterOptionsBase options)Parameters
rectangle Rectangle
Det rektangulære.
options FilterOptionsBase
De valgmuligheder.
Examples
Følgende eksempel anvender forskellige typer af filtre til et rasterbillede.
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(Det er int)
Få et billede med 32-bit ARGB pixel.
public int GetArgb32Pixel(int x, int y)Parameters
x int
Pixel x placering.
y int
Pixel og placering.
Returns
Den 32-bit ARGB-pixel til den angivne placering.
Examples
Følgende eksempel lader et rasterbillede og får farven på en vilkårlig pixel repræsenteret som en 32-bit helhed værdi.
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);
}Følgende eksempel viser, hvordan image caching påvirker ydeevnen. i almindelighed, læsning af cached data udføres hurtigere end læsningen af ikke-cached data.
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)
Få den standard 32-bit ARGB pixels rækkefølge.
public int[] GetDefaultArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Den rektangle til at få pixels for.
Returns
int []
Den standard pixels array.
GetDefaultPixels(Rectangle, IPartialArgb32PixelLoader)
Få de standard piksler arrangeret ved hjælp af partiel pixel loader.
public void GetDefaultPixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Den rektangle til at få pixels for.
partialPixelLoader IPartialArgb32PixelLoader
Den partielle pixellader.
GetDefaultRawData(Rectangle, IPartialRawDataLoader, RawDataSettings)
Få den standard rå data rækkefølge ved hjælp af en partiel pixel oplader.
public void GetDefaultRawData(Rectangle rectangle, IPartialRawDataLoader partialRawDataLoader, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Den rektangle til at få pixels for.
partialRawDataLoader IPartialRawDataLoader
Den delvis rå data loader.
rawDataSettings RawDataSettings
De rå data indstillinger.
GetDefaultRawData(Rectangle og RawDataSettings)
Få den standard rådata array.
public byte[] GetDefaultRawData(Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Den rektangle til at få rå data for.
rawDataSettings RawDataSettings
De rå data indstillinger.
Returns
byte []
Den standard rå data array.
GetModifyDate(Bool)
Giver datoen og tidspunktet for, at ressourcebilledet var sidst ændret.
public virtual DateTime GetModifyDate(bool useDefault)Parameters
useDefault bool
Hvis du er indstillet til ’true’, bruger du informationen fra FileInfo som standardværdi.
Returns
Datoen og tidspunktet for ressourcebilledet blev sidst ændret.
GetPixel(Det er int)
Få et billede pixel.
public Color GetPixel(int x, int y)Parameters
x int
Pixel x placering.
y int
Pixel og placering.
Returns
Pixelfarven til den angivne placering.
Examples
Følgende eksempel lader et rasterbillede og får farven på et vilkårligt 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()
Gør skovkuglen.Denne metode finder anvendelse på skannede tekstdokumenter, for at bestemme skivanglen ved skanning.
public float GetSkewAngle()Returns
Den skæve hjørne, i grader.
Grayscale()
Omdannelse af et billede til sin grayscale repræsentation
public virtual void Grayscale()Examples
Følgende eksempel forvandler et farvet rasterbillede til sin grayscale repræsentation.Grayescale billeder består udelukkende af skygge af grå og bærer kun intensitetsoplysninger.
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)
Lader 32-bit ARGB pixels.
public int[] LoadArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Den rektangle til at oplade pixels fra.
Returns
int []
Den ladede 32-bit ARGB pixels array.
Examples
Følgende eksempel viser, hvordan man oplader og behandler pixels af et rasterbillede.Pixels repræsenteres som 32-bit integrerede værdier.For eksempel, overveje et problem med at tælle fuldt gennemsigtige pixeler af en billed.
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)
Lader 64-bit ARGB pixels.
public long[] LoadArgb64Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Den rektangle til at oplade pixels fra.
Returns
long []
Den opladte 64-bit ARGB pixels array.
Examples
Følgende eksempel viser, hvordan man oplader og behandler pixels af et rasterbillede.Pixels repræsenteres som 64-bit integrerede værdier.For eksempel, overveje et problem med at tælle fuldt gennemsigtige pixeler af en billed.
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)
Lader pixels i CMYK format.
public int[] LoadCmyk32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Den rektangle til at oplade pixels fra.
Returns
int []
De opladte CMYK pixels præsenteres som 32-bit inateger værdier.
LoadCmykPixels(Rectangle)
Lader pixels i CMYK format.Denne metode er depreceret. bedes du bruge den mere effektive metode Aspose.Imaging.RasterImage.LoadCmyk32Pixels(W L 17 .Rectangle).
[Obsolete("Method is obsolete")]
public CmykColor[] LoadCmykPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Den rektangle til at oplade pixels fra.
Returns
CmykColor []
Den opladte CMYK pixels array.
LoadPartialArgb32Pixels(Rectangle, IPartialArgb32PixelLoader)
Lader 32-bit ARGB pixels delvist af pakker.
public void LoadPartialArgb32Pixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Den ønskede rektangle.
partialPixelLoader IPartialArgb32PixelLoader
Den 32-bit ARGB pixel oplader.
Examples
Følgende eksempel viser, hvordan man lader og behandler pixels af et rasterbillede ved hjælp af din egen delprocessor. For eksempel, overveje et problem med at tælle fuldt gennemsigtige piksler af en billede. Til tælling af transparente pixel ved brug af delloading mekanisme, indføres en separat klasse TransparentArgb32PixelCounter implementering Aspose.Imaging.IPartialArGB32PixelLoader.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\alpha.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Create an instance of the Aspose.Imaging.IPartialArgb32PixelLoader and pass it to the Aspose.Imaging.RasterImage.LoadPartialArgb32Pixels
TransparentArgb32PixelCounter counter = new TransparentArgb32PixelCounter();
// Load pixels for the whole image. Any rectangular part of the image can be specified as the first parameter of the Aspose.Imaging.RasterImage.LoadPartialArgb32Pixels method.
rasterImage.LoadPartialArgb32Pixels(rasterImage.Bounds, counter);
System.Console.WriteLine("The number of fully transparent pixels is {0}", counter.Count);
System.Console.WriteLine("The total number of pixels is {0}", image.Width * image.Height);
}
// The counter may look like this:
/// <summary>
/// Counts the number of fully transparent pixels with alpha channel value of 0.
/// </summary>
private class TransparentArgb32PixelCounter : IPartialArgb32PixelLoader
{
/// <summary>
/// The number of fully transparent pixels.
/// </summary>
private int count;
/// <summary>
/// Gets the number of fully transparent pixels.
/// </summary>
public int Count
{
get { return this.count; }
}
/// <summary>
/// Processes the loaded pixels. This method is called back every time when a new portion of pixels is loaded.
/// </summary>
/// <param name="pixelsRectangle"/>The pixels rectangle.
/// <param name="pixels"/>The 32-bit ARGB pixels.
/// <param name="start"/>The start pixels point.
/// <param name="end"/>The end pixels point.
public void Process(Aspose.Imaging.Rectangle pixelsRectangle, int[] pixels, Aspose.Imaging.Point start, Aspose.Imaging.Point end)
{
foreach (int pixel in pixels)
{
int alpha = (pixel >> 24) & 0xff;
if (alpha == 0)
{
this.count++;
}
}
}
}LoadPartialArgb64Pixels(Rectangle, IPartialArgb64PixelLoader)
Lader 64-bit ARGB pixels delvist af pakker.
public void LoadPartialArgb64Pixels(Rectangle rectangle, IPartialArgb64PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Den ønskede rektangle.
partialPixelLoader IPartialArgb64PixelLoader
Den 64-bit ARGB pixel oplader.
LoadPartialPixels(Rectangle og IPartialPixelLoader)
Lader pixels delvis af pakker.
public void LoadPartialPixels(Rectangle desiredRectangle, IPartialPixelLoader pixelLoader)Parameters
desiredRectangle Rectangle
Den ønskede rektangle.
pixelLoader IPartialPixelLoader
Det er Pixel Loader.
Examples
Følgende eksempel viser, hvordan man oplader og behandler pixels af et rasterbillede ved hjælp af din egen delprocessor. For eksempel, overveje et problem med at tælle fuldt gennemsigtige pixeler af en billede. Til at beregne transparent ved brug af delopladningsmekanisme, indføres en separat klasse TransparentPixelCounter implementering Aspose.Imaging.IPartialPxelLoader.
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)
Oplader pixels.
public Color[] LoadPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Den rektangle til at oplade pixels fra.
Returns
Color []
De ladede pixels array.
Examples
Følgende eksempel viser, hvordan man lader og behandler piksler af et rasterbillede. for eksempel, overveje et problem med at tælle fuldt gennemsigtige pixler på et billede.
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);
}Dette eksempel viser, hvordan du lader Pixel-oplysninger i en Array af Type Color, manipulerer array og sætter det tilbage til billedet. For at udføre disse operationer skaber dette eksempel en ny Image-fil (i 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)
Oplader rå data.
public void LoadRawData(Rectangle rectangle, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Den rektangle til at oplade rådata fra.
rawDataSettings RawDataSettings
De rådataindstillinger til brug for opladte data. Bemærk, hvis data ikke er i det angivne format, så data konvertering vil ske.
rawDataLoader IPartialRawDataLoader
Den rå data loader.
Examples
Følgende eksempel viser, hvordan man ekstrakter piksler fra de rå billeddata ved hjælp af RawDataSettings. for eksempel, overveje et problem med at tælle fuldt gennemsigtige pixler af et billede.
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)
Oplader rå data.
public void LoadRawData(Rectangle rectangle, Rectangle destImageBounds, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Den rektangle til at oplade rådata fra.
destImageBounds Rectangle
Billederne har grænser.
rawDataSettings RawDataSettings
De rådataindstillinger til brug for opladte data. Bemærk, hvis data ikke er i det angivne format, så data konvertering vil ske.
rawDataLoader IPartialRawDataLoader
Den rå data loader.
NormalizeAngle()
Normaliserer hjørnet.Denne metode finder anvendelse på scannede tekstdokumenter for at slippe af med den skudt scan.Denne metode anvender Aspose.Imaging.RasterImage.GetSkewAngle og W L17. Raster Image .Rotate(System.Single) metoder.
public void NormalizeAngle()NormalizeAngle(Bool, farve)
Normaliserer hjørnet.Denne metode finder anvendelse på scannede tekstdokumenter for at slippe af med den skudt scan.Denne metode anvender Aspose.Imaging.RasterImage.GetSkewAngle og W L 17. RasterIme.Rote(System.Single, System.Boolean,__W WL 17 _.Color) metoder.
public virtual void NormalizeAngle(bool resizeProportionally, Color backgroundColor)Parameters
resizeProportionally bool
Hvis du har indstillet til ’true’ vil du have din billedstørrelse ændret i henhold til roterede rektangle (kornpunkter) projektioner i andet tilfælde, der forlader dimensioner ukrudt og kun interne billedindhold er roteret.
backgroundColor Color
Farve af baggrunden.
Examples
Skew er et artefakt, der kan vises under dokumentskanningsprocessen, når teksten/billederne af dokumentet bliver roteret i en lille vinkel. Det kan have forskellige årsager, men det mest almindelige er, at papiret er misplaceret under en skanning. Derfor, deskev er processen med at opdage og fikse dette problem på scannede filer (dvs. bitmap) så dekkede dokumenter vil have tekst / billeder korrekt og horisontalt justeret.
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()
Normaliserer billedhistogrammet – justerer pixelværdier til at bruge alle de tilgængelige rækkevidde.
public virtual void NormalizeHistogram()ReadArgb32ScanLine(Int)
Læs hele skanningslinjen af den angivne skanningslinjen indeks.
public int[] ReadArgb32ScanLine(int scanLineIndex)Parameters
scanLineIndex int
Null baseret indeks af skanningslinjen.
Returns
int []
Skanningslinjen 32-bit ARGB farveværdier array.
ReadScanLine(Int)
Læs hele skanningslinjen af den angivne skanningslinjen indeks.
public Color[] ReadScanLine(int scanLineIndex)Parameters
scanLineIndex int
Null baseret indeks af skanningslinjen.
Returns
Color []
Skanningslinjen pixel farve værdier array.
ReleaseManagedResources()
Sørg for, at der ikke frigives uadministrerede ressourcer her, da de måske allerede er blevet frigivet.
protected override void ReleaseManagedResources()RemoveMetadata()
Fjern denne billedinstans metadata ved at indstille denne Aspose.Imaging.Xmp.IHasXMPData. Null.
public override void RemoveMetadata()ReplaceColor(Farve, byte og farve)
Det erstattes en farve til en anden med den tilladte forskel og bevarer den oprindelige alfa-værdi for at spare glatte edder.
public void ReplaceColor(Color oldColor, byte oldColorDiff, Color newColor)Parameters
oldColor Color
Den gamle farve skal erstattes.
oldColorDiff byte
Tilladt forskel i den gamle farve for at kunne udvide den erstattede farve tone.
newColor Color
Den nye farve erstatter den gamle farve.
ReplaceColor(Int, byte og int)
Det erstattes en farve til en anden med den tilladte forskel og bevarer den oprindelige alfa-værdi for at spare glatte edder.
public virtual void ReplaceColor(int oldColorArgb, byte oldColorDiff, int newColorArgb)Parameters
oldColorArgb int
Den gamle farve ARGB værdi skal erstattes.
oldColorDiff byte
Tilladt forskel i den gamle farve for at kunne udvide den erstattede farve tone.
newColorArgb int
Ny farve ARGB værdi til at erstatte den gamle farve med.
ReplaceNonTransparentColors(Color)
Udskift alle ikke-transparente farver med ny farve og bevarer den oprindelige alfa-værdi for at spare glatte edder.Bemærk: Hvis du bruger det på billeder uden gennemsigtighed, vil alle farver blive erstattet med en enkelt.
public void ReplaceNonTransparentColors(Color newColor)Parameters
newColor Color
Nye farver til at erstatte ikke-transparent farver med.
ReplaceNonTransparentColors(Int)
Udskift alle ikke-transparente farver med ny farve og bevarer den oprindelige alfa-værdi for at spare glatte edder.Bemærk: Hvis du bruger det på billeder uden gennemsigtighed, vil alle farver blive erstattet med en enkelt.
public virtual void ReplaceNonTransparentColors(int newColorArgb)Parameters
newColorArgb int
Ny farve ARGB værdi til at erstatte ikke gennemsigtige farver med.
Resize(Int, Int og ImageResizeSettings)
Du genopretter billedet med udvidede muligheder.
public override void Resize(int newWidth, int newHeight, ImageResizeSettings settings)Parameters
newWidth int
Den nye bredde.
newHeight int
Den nye højde.
settings ImageResizeSettings
De tilbagevendende indstillinger.
Examples
Dette eksempel oplader et rasterbillede og resyser det ved hjælp af forskellige resizing indstillinger.
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(flåd, bool, farve)
Gør billedet rundt i centrum.
public virtual void Rotate(float angle, bool resizeProportionally, Color backgroundColor)Parameters
angle float
Den roterende hjørne i grader. Positive værdier vil rotere klokkevis.
resizeProportionally bool
Hvis du har indstillet til ’true’ vil du have din billedstørrelse ændret i henhold til roterede rektangle (kornpunkter) projektioner i andet tilfælde, der forlader dimensioner ukrudt og kun interne billedindhold er roteret.
backgroundColor Color
Farve af baggrunden.
Exceptions
Ikke implementeret undtagelse
Rotate(Flåder)
Gør billedet rundt i centrum.
public override void Rotate(float angle)Parameters
angle float
Den roterende hjørne i grader. Positive værdier vil rotere klokkevis.
Save(Strøm, ImageOptionsBase, Rectangle)
Sparer billeddata til den angivne strøm i det angivne filformat i henhold til optioner for at gemme.
public override void Save(Stream stream, ImageOptionsBase optionsBase, Rectangle boundsRectangle)Parameters
stream Stream
Strømmen til at gemme billedets data til.
optionsBase ImageOptionsBase
Besparelse af mulighederne.
boundsRectangle Rectangle
Destinationsbilledet grænser rektangle. Set den tomme rektangle for at bruge kilde grænser.
SaveArgb32Pixels(Rigtangle, int[])
Sparer de 32-bit ARGB pixels.
public void SaveArgb32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Den rektangle til at gemme pixels til.
pixels int
[]
Den 32-bit ARGB pixels array.
Examples
Følgende eksempel fylder det centrale område af et rasterbillede med sorte pixels ved hjælp af Aspose.Imaging.RasterImage.SaveArgb32Pixels-metoden.
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(Rigtangle, int[])
Det sparer pixels.
public void SaveCmyk32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Den rektangle til at gemme pixels til.
pixels int
[]
De CMYK pixels præsenteres som de 32-bit integrerede værdier.
Examples
Følgende eksempel fylder det centrale område af et rasterbillede med sorte pixels ved hjælp af Aspose.Imaging.RasterImage.SaveCmyk32Pixels-metoden.
string dir = @"c:\temp\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Get an integer representation of black in the CMYK color space.
int blackCmyk = Aspose.Imaging.CmykColorHelper.ToCmyk(Color.Black);
// The black square.
int[] pixels = new int[(rasterImage.Width / 2) * (rasterImage.Height / 2)];
for (int i = 0; i < pixels.Length; i++)
{
pixels[i] = blackCmyk;
}
// Draw the black square at the center of the image.
Aspose.Imaging.Rectangle area = new Aspose.Imaging.Rectangle(rasterImage.Width / 4, rasterImage.Height / 4, rasterImage.Width / 2, rasterImage.Height / 2);
rasterImage.SaveCmyk32Pixels(area, pixels);
rasterImage.Save(dir + "sample.SaveCmyk32Pixels.png");
}SaveCmykPixels(Rektangle og CmykColor[])
Det sparer pixels.Denne metode er depreceret. bedes du bruge den mere effektive metode Aspose.Imaging.RasterImage.SaveCmyk32Pixels(W L 17 .Rectangle,System.Int32[]).
[Obsolete("Method is obsolete")]
public void SaveCmykPixels(Rectangle rectangle, CmykColor[] pixels)Parameters
rectangle Rectangle
Den rektangle til at gemme pixels til.
pixels CmykColor
[]
Den CMYK pixels array.
SavePixels(Rektangle og farve[])
Det sparer pixels.
public void SavePixels(Rectangle rectangle, Color[] pixels)Parameters
rectangle Rectangle
Den rektangle til at gemme pixels til.
pixels Color
[]
Pixelerne er på vej.
Examples
Følgende eksempel fylder det centrale område af et rasterbillede med sorte pixels ved hjælp af Aspose.Imaging.RasterImage.SavePixels-metoden.
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");
}Dette eksempel viser, hvordan du lader Pixel-oplysninger i en Array af Type Color, manipulerer array og sætter det tilbage til billedet. For at udføre disse operationer skaber dette eksempel en ny Image-fil (i 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)
Det sparer de rå data.
public void SaveRawData(byte[] data, int dataOffset, Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
data byte
[]
De rå data.
dataOffset int
De oprindelige råoplysninger afskrives.
rectangle Rectangle
Den rå data rektangle.
rawDataSettings RawDataSettings
De rådata indstillinger de data er i.
SetArgb32Pixel(Det er int, int, int)
Indsæt et 32-bit ARGB-pixel for den angivne position.
public void SetArgb32Pixel(int x, int y, int argb32Color)Parameters
x int
Pixel x placering.
y int
Pixel og placering.
argb32Color int
Den 32-bit ARGB-pixel til den angivne position.
Examples
Følgende eksempel oplader et rasterbillede, og sætter farven på et vilkårligt pixel.
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(Fællesskab, Bool)
Indsæt billedpaletten.
public override void SetPalette(IColorPalette palette, bool updateColors)Parameters
palette IColorPalette
Paletten skal indstilles.
updateColors bool
Hvis du er indstillet til ’true’ farver vil blive opdateret i henhold til den nye palet; ellers farveindekser forbliver uændrede. bemærke, at uændrede indekser kan bryde billedet på opladning, hvis nogle indekser ikke har de tilsvarende palet indtægter.
SetPixel(Int, int og farve)
Indsæt et billede pixel for den angivne position.
public void SetPixel(int x, int y, Color color)Parameters
x int
Pixel x placering.
y int
Pixel og placering.
color Color
Pixelfarven til den angivne position.
Examples
Følgende eksempel oplader et rasterbillede, og sætter farven på et vilkårligt pixel.
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(dobbelt, dobbelt)
Sæt opløsningen for dette Aspose.Imaging.RasterImage.
public virtual void SetResolution(double dpiX, double dpiY)Parameters
dpiX double
Den horisontale opløsning, i punkter pr. inch, af Aspose.Imaging.RasterImage.
dpiY double
Den vertikale opløsning, i punkter pr. inch, af Aspose.Imaging.RasterImage.
Examples
Følgende eksempel viser, hvordan man indstiller en horisontal/vertikal opløsning af et rasterbillede.
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()
Konverter rasterbilledet til bitmappen.Denne metode understøttes ikke i versioner fra .Net7.0 eller højere
public virtual Bitmap ToBitmap()Returns
Den bitmap
UpdateDimensions(Det er int)
Opdaterer billeddimensionerne.
protected abstract void UpdateDimensions(int newWidth, int newHeight)Parameters
newWidth int
Den nye billedvidde.
newHeight int
Den nye billed højde.
UpdateMetadata()
Opdaterer billederne med metadata.
protected virtual void UpdateMetadata()WriteArgb32ScanLine(Det er int[])
Skriv hele scanlinjen til den angivne scanlinjeindeks.
public void WriteArgb32ScanLine(int scanLineIndex, int[] argb32Pixels)Parameters
scanLineIndex int
Null baseret indeks af skanningslinjen.
argb32Pixels int
[]
Den 32-bit ARGB farve arrange til at skrive.
WriteScanLine(Ind, farve[])
Skriv hele scanlinjen til den angivne scanlinjeindeks.
public void WriteScanLine(int scanLineIndex, Color[] pixels)Parameters
scanLineIndex int
Null baseret indeks af skanningslinjen.
pixels Color
[]
Pixelfarverne er til at skrive.
