Class RasterImage
Namn på plats: Aspose.Imaging Församling: Aspose.Imaging.dll (25.4.0)
Representerar en rasterbild som stöder rastergrafikverksamhet.
public abstract class RasterImage : Image, IDisposable, IObjectWithBounds, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, IHasXmpData, IHasMetadataInheritance
object ← DisposableObject ← DataStreamSupporter ← Image ← RasterImage
Derived
Implements
IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata
Arvsmedlemmar
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
Detta exempel visar hur du laddar Pixel-information i en Array av Typfärg, manipulerar array och sätter den tillbaka till bilden. För att utföra dessa operationer skapar detta exempel en ny Bildfil (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()
Initialiserar en ny instans av Aspose.Imaging.RasterImage klass.
[JsonConstructor]
protected RasterImage()RasterImage(Färgpalett)
Initialiserar en ny instans av Aspose.Imaging.RasterImage klass.
protected RasterImage(IColorPalette colorPalette)Parameters
colorPalette IColorPalette
Färgpaletten är.
Fields
xmpData
XMP metadata
[JsonProperty]
protected XmpPacketWrapper xmpDataFältvärde
Properties
DataLoader
Få eller ställa in dataladdaren.
[JsonProperty]
protected IRasterImageArgb32PixelLoader DataLoader { get; set; }Fastighetsvärde
HasAlpha
Det får ett värde som indikerar om denna instans har alfa.
public virtual bool HasAlpha { get; }Fastighetsvärde
Examples
Följande exempel laddar rasterbilder och skriver ut information om rådataformat och 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öljande exempel visar hur man extraherar information om rådataformat och alfa-kanal från en BMP-bild.
// 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
Det får ett värde som indikerar om bilden har en transparent färg.
public virtual bool HasTransparentColor { get; set; }Fastighetsvärde
HorizontalResolution
Få eller ställa in den horisontella upplösningen, i pixlar per tum, av denna Aspose.Imaging.RasterImage.
public virtual double HorizontalResolution { get; set; }Fastighetsvärde
Examples
Följande exempel visar hur man ställer in en horisontell/vertikal upplösning av en rasterbild.
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
Detta värde är alltid 96 eftersom olika plattformar inte kan returnera skärmupplösningen. Du kan överväga att använda SetResolution-metoden för att uppdatera båda upplösningsvärdena i ett enda samtal.
ImageOpacity
Får opacitet av denna bild.
public virtual float ImageOpacity { get; }Fastighetsvärde
IsRawDataAvailable
Det får ett värde som indikerar om rådataladdningen är tillgänglig.
public bool IsRawDataAvailable { get; }Fastighetsvärde
PremultiplyComponents
Det får eller ställer in ett värde som anger om bildkomponenterna måste förmultipliceras.
public virtual bool PremultiplyComponents { get; set; }Fastighetsvärde
Examples
Följande exempel skapar en ny rasterbild, sparar de angivna halvtransparenta pixlarna, laddar sedan dessa pixlar och får slutliga färger i den förmånliga formen.
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 ställa in den anpassade färgkonverteraren
public IColorConverter RawCustomColorConverter { get; set; }Fastighetsvärde
RawDataFormat
Få den rådata formatet.
public virtual PixelDataFormat RawDataFormat { get; }Fastighetsvärde
Examples
Följande exempel laddar rasterbilder och skriver ut information om rådataformat och 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=TrueDetta exempel visar hur man laddar upp en DJVU-bild från en filström och skriver ut information om sidorna.
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
Få aktuella rådatainställningar. notera när du använder dessa inställningar datan laddas utan konvertering.
[JsonIgnore]
public RawDataSettings RawDataSettings { get; }Fastighetsvärde
RawFallbackIndex
Få eller sätta fallbackindexet att använda när palettindexet är utanför gränserna
public int RawFallbackIndex { get; set; }Fastighetsvärde
RawIndexedColorConverter
Få eller ställa in den indexerade färgkonverteraren
public IIndexedColorConverter RawIndexedColorConverter { get; set; }Fastighetsvärde
RawLineSize
Få den rålinje storleken i byter.
public virtual int RawLineSize { get; }Fastighetsvärde
TransparentColor
Få bilden transparent färg.
public virtual Color TransparentColor { get; set; }Fastighetsvärde
UpdateXmpData
Få eller ange ett värde som anger om du ska uppdatera XMP-metadata.
public virtual bool UpdateXmpData { get; set; }Fastighetsvärde
UsePalette
Det får ett värde som indikerar om bildpaletten används.
public override bool UsePalette { get; }Fastighetsvärde
UseRawData
Få eller ange ett värde som anger om du ska använda rådata laddning när rådata laddning är tillgänglig.
public virtual bool UseRawData { get; set; }Fastighetsvärde
VerticalResolution
Få eller ställa in den vertikala upplösningen, i pixlar per tum, av denna Aspose.Imaging.RasterImage.
public virtual double VerticalResolution { get; set; }Fastighetsvärde
Examples
Följande exempel visar hur man ställer in en horisontell/vertikal upplösning av en rasterbild.
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
Detta värde är alltid 96 eftersom olika plattformar inte kan returnera skärmupplösningen. Du kan överväga att använda SetResolution-metoden för att uppdatera båda upplösningsvärdena i ett enda samtal.
XmpData
Få eller ställa in XMP metadata.
public virtual XmpPacketWrapper XmpData { get; set; }Fastighetsvärde
Methods
AdjustBrightness(int)
Anpassa en ljusstyrka för bild.
public virtual void AdjustBrightness(int brightness)Parameters
brightness int
ljusets värde.
Examples
Följande exempel gör en ljuskorrigering av en bild.
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(Flotta)
bildkontrast
public virtual void AdjustContrast(float contrast)Parameters
contrast float
Kontrastvärde (i intervall [-100; 100])
Examples
Följande exempel gör kontrast korrigering av en bild.
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(flotta, flotta och flotta)
Gamma korrigering av en bild.
public virtual void AdjustGamma(float gammaRed, float gammaGreen, float gammaBlue)Parameters
gammaRed float
Gamma för rödkanalkoefficient
gammaGreen float
Gamma för grön kanalkoefficient
gammaBlue float
Gamma för blåkanalkoefficient
Examples
Följande exempel utför gamma-korrigering av en bild som tillämpar olika koefficienter för färgkomponenter.
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(Flotta)
Gamma korrigering av en bild.
public virtual void AdjustGamma(float gamma)Parameters
gamma float
Gamma för röda, gröna och blå kanaler koefficient
Examples
Följande exempel gör en gamma-korrigering av en bild.
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(dubbel)
Binarisering av en bild med hjälp av Bradleys adaptiva tröskelvärde algoritm med hjälp av integrerad bildtröskelvärde
public virtual void BinarizeBradley(double brightnessDifference)Parameters
brightnessDifference double
Skillnaden i ljusstyrka mellan pixel och genomsnittet av ett s x s fönster av pixlar som är inriktade runt denna pixel.
BinarizeBradley(dubbel, int)
Binarisering av en bild med hjälp av Bradleys adaptiva tröskelvärde algoritm med hjälp av integrerad bildtröskelvärde
public virtual void BinarizeBradley(double brightnessDifference, int windowSize)Parameters
brightnessDifference double
Skillnaden i ljusstyrka mellan pixel och genomsnittet av ett s x s fönster av pixlar som är inriktade runt denna pixel.
windowSize int
Storleken på s x s fönstret av pixlar som är inriktade runt denna pixel
Examples
Följande exempel binäriserar en rasterbild med Bradleys adaptiva gränsvärdealgoritm med angiven fönsterstorlek. binära bilder innehåller endast 2 färger - svart och vitt.
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 av en bild med fördefinierad gräns
public virtual void BinarizeFixed(byte threshold)Parameters
threshold byte
Om motsvarande gråvärde för en pixel är större än gränsen, tilldelas det ett värde av 255 eller 0 annars.
Examples
Följande exempel binariserar en rasterbild med den fördefinierade gränsen. binära bilder innehåller endast 2 färger - svart och vitt.
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 av en bild med Otsu-gränssnitt
public virtual void BinarizeOtsu()Examples
Följande exempel binariserar en rasterbild med Otsu gränssnitt. binära bilder innehåller bara 2 färger - svart och vitt.
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(Poäng, RasterImage, Rectangle, byte)
Blanda denna bild instans med bilden overlay".
public virtual void Blend(Point origin, RasterImage overlay, Rectangle overlayArea, byte overlayAlpha = 255)Parameters
origin Point
Bakgrunden bild bländande ursprung.
overlay RasterImage
Den överlägsna bilden.
overlayArea Rectangle
överlägset område.
overlayAlpha byte
Den överlägsen alfa.
Blend(Poäng, RasterImage, byte)
Blanda denna bild instans med bilden overlay".
public void Blend(Point origin, RasterImage overlay, byte overlayAlpha = 255)Parameters
origin Point
Bakgrunden bild bländande ursprung.
overlay RasterImage
Den överlägsna bilden.
overlayAlpha byte
Den överlägsen alfa.
Dither(DitheringMetod, int)
Föreställningar dyter på den nuvarande bilden.
public void Dither(DitheringMethod ditheringMethod, int bitsCount)Parameters
ditheringMethod DitheringMethod
Metoden för att diktera.
bitsCount int
De sista bitarna räknar för dithering.
Examples
Följande exempel laddar en rasterbild och utför gränsvärde och flytande dithering med olika palettdjup.
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)
Föreställningar dyter på den nuvarande bilden.
public abstract void Dither(DitheringMethod ditheringMethod, int bitsCount, IColorPalette customPalette)Parameters
ditheringMethod DitheringMethod
Metoden för att diktera.
bitsCount int
De sista bitarna räknar för dithering.
customPalette IColorPalette
Den vanliga paletten för dithering.
Filter(Rectangle, FilterOptionsBase)
Filterar den angivna rektangeln.
public virtual void Filter(Rectangle rectangle, FilterOptionsBase options)Parameters
rectangle Rectangle
och rektangeln.
options FilterOptionsBase
och alternativen .
Examples
Följande exempel tillämpar olika typer av filter på en rasterbild.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Apply a median filter with a rectangle size of 5 to the entire image.
rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MedianFilterOptions(5));
rasterImage.Save(dir + "sample.MedianFilter.png");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Apply a bilateral smoothing filter with a kernel size of 5 to the entire image.
rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.BilateralSmoothingFilterOptions(5));
rasterImage.Save(dir + "sample.BilateralSmoothingFilter.png");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Apply a Gaussian blur filter with a radius of 5 and a sigma value of 4.0 to the entire image.
rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.GaussianBlurFilterOptions(5, 4.0));
rasterImage.Save(dir + "sample.GaussianBlurFilter.png");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Apply a Gauss-Wiener filter with a radius of 5 and a smooth value of 4.0 to the entire image.
rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.GaussWienerFilterOptions(5, 4.0));
rasterImage.Save(dir + "sample.GaussWienerFilter.png");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Apply a motion wiener filter with a length of 5, a smooth value of 4.0 and an angle of 90.0 degrees to the entire image.
rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MotionWienerFilterOptions(10, 1.0, 90.0));
rasterImage.Save(dir + "sample.MotionWienerFilter.png");
}
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Apply a sharpen filter with a kernel size of 5 and a sigma value of 4.0 to the entire image.
rasterImage.Filter(rasterImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.SharpenFilterOptions(5, 4.0));
rasterImage.Save(dir + "sample.SharpenFilter.png");
}GetArgb32Pixel(int, int)
Få en bild med 32-bitars ARGB-pixel.
public int GetArgb32Pixel(int x, int y)Parameters
x int
Pixel x läge.
y int
Pixel och plats.
Returns
32-bitars ARGB-pixel för den angivna platsen.
Examples
Följande exempel lader en rasterbild och får färgen på en önskvärd pixel representerad som en 32-bitars helvärde.
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öljande exempel visar hur bildcaching påverkar prestanda.I allmänhet görs läsning av cached data snabbare än läsning av icke-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å standard 32-bitars ARGB-pixel array.
public int[] GetDefaultArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rektangeln för att få pixlar för.
Returns
int [ ]
Den standard pixlar array.
GetDefaultPixels(Rectangle, IPartialArgb32PixelLoader)
Få standard pixlar sorteras med hjälp av partiell pixel laddare.
public void GetDefaultPixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Rektangeln för att få pixlar för.
partialPixelLoader IPartialArgb32PixelLoader
Den partiella pixel laddaren.
GetDefaultRawData(Rectangle, IPartialRawDataLoader, RawDataSettings)
Få standard rådataserien med hjälp av partiell pixelladdare.
public void GetDefaultRawData(Rectangle rectangle, IPartialRawDataLoader partialRawDataLoader, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Rektangeln för att få pixlar för.
partialRawDataLoader IPartialRawDataLoader
Den partiella rådata laddaren.
rawDataSettings RawDataSettings
De rådata inställningarna.
GetDefaultRawData(Rectangle och RawDataSettings)
Få standard rådata array.
public byte[] GetDefaultRawData(Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
rektangeln för att få rådata för.
rawDataSettings RawDataSettings
De rådata inställningarna.
Returns
byte [ ]
Den förfalskade rådata array.
GetModifyDate(Bool)
Få datum och tid som resursbilden senast ändrats.
public virtual DateTime GetModifyDate(bool useDefault)Parameters
useDefault bool
Om du ställer in “true” använder du informationen från FileInfo som standardvärde.
Returns
Datum och tid resursbilden ändrades senast.
GetPixel(int, int)
Få en bild pixel.
public Color GetPixel(int x, int y)Parameters
x int
Pixel x läge.
y int
Pixel och plats.
Returns
Pixelfärgen för den angivna platsen.
Examples
Följande exempel lader en rasterbild och får färgen på en önskvärd 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()
Fångar den skiva vinkeln.Denna metod är tillämplig på skannade textdokument, för att bestämma skiv vinkeln vid skanning.
public float GetSkewAngle()Returns
Skivans vinkel, i grader.
Grayscale()
Omvandling av en bild till sin gråskala representation
public virtual void Grayscale()Examples
Följande exempel omvandlar en färgad rasterbild till sin gråskala representation. gråskala bilder består uteslutande av skuggor av grå och bär endast intensitetsinformation.
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)
Ladda 32-bitars ARGB pixlar.
public int[] LoadArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rektangeln för att ladda pixlar från.
Returns
int [ ]
Den laddade 32-bitars ARGB pixlar array.
Examples
Följande exempel visar hur man laddar och behandlar pixlar av en rasterbild. pixlarna representeras som 32-bitars totala värden. Till exempel, överväga ett problem med att räkna fullständigt transparenta pixlar av en bild.
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)
Ladda 64-bitars ARGB pixlar.
public long[] LoadArgb64Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rektangeln för att ladda pixlar från.
Returns
long [ ]
Den laddade 64-bitars ARGB pixlar array.
Examples
Följande exempel visar hur man laddar och behandlar pixlar av en rasterbild. pixlarna representeras som 64-bitars totala värden. Till exempel, överväga ett problem med att räkna fullständigt transparenta pixlar av en bild.
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)
Ladda pixlar i CMYK-format.
public int[] LoadCmyk32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rektangeln för att ladda pixlar från.
Returns
int [ ]
De laddade CMYK-pixlarna presenteras som 32-bitars inategervärden.
LoadCmykPixels(Rectangle)
Ladda pixlar i CMYK-format.Använd effektivare Aspose.Imaging.RasterImage.LoadCmyk32Pixels(Aspose.Imaging.Rectangle) metod.
[Obsolete("Method is obsolete")]
public CmykColor[] LoadCmykPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rektangeln för att ladda pixlar från.
Returns
CmykColor [ ]
Den laddade CMYK pixlar array.
LoadPartialArgb32Pixels(Rectangle, IPartialArgb32PixelLoader)
Ladda 32-bitars ARGB-pixel delvis med paket.
public void LoadPartialArgb32Pixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Den önskade rektangeln.
partialPixelLoader IPartialArgb32PixelLoader
32-bitars ARGB pixel laddare.
Examples
Följande exempel visar hur man ladda och behandlar pixlar av en rasterbild med hjälp av din egen partiell processor. Till exempel, överväga ett problem med att räkna fullständigt transparenta pixlar av en bild. För att räkna transparenta pixlar med hjälp av partiell laddningsmekanism, introduceras en separat klass 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)
Ladda 64-bitars ARGB-pixel delvis med paket.
public void LoadPartialArgb64Pixels(Rectangle rectangle, IPartialArgb64PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Den önskade rektangeln.
partialPixelLoader IPartialArgb64PixelLoader
64-bitars ARGB pixel laddare.
LoadPartialPixels(Rectangle och IPartialPixelLoader)
Ladda pixlar delvis med paket.
public void LoadPartialPixels(Rectangle desiredRectangle, IPartialPixelLoader pixelLoader)Parameters
desiredRectangle Rectangle
Den önskade rektangeln.
pixelLoader IPartialPixelLoader
och Pixel Loader.
Examples
Följande exempel visar hur man laddar och behandlar pixlar av en rasterbild med hjälp av din egen partiell processor. Till exempel, överväga ett problem med att räkna helt transparenta pixlar av en bild. För att räkna transparent med hjälp av partiell laddningsmekanism, introduceras en separat klass TransparentPixelCounter genom att implementera Aspose.Imaging.IPartialPixelLoader.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\alpha.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Create an instance of the Aspose.Imaging.IPartialPixelLoader and pass it to the Aspose.Imaging.RasterImage.LoadPartialPixels
TransparentPixelCounter counter = new TransparentPixelCounter();
// Load pixels for the whole image. Any rectangular part of the image can be specified as the first parameter of the Aspose.Imaging.RasterImage.LoadPartialPixels method.
rasterImage.LoadPartialPixels(rasterImage.Bounds, counter);
System.Console.WriteLine("The number of fully transparent pixels is {0}", counter.Count);
System.Console.WriteLine("The total number of pixels is {0}", image.Width * image.Height);
}
// The counter may look like this:
/// <summary>
/// Counts the number of fully transparent pixels with alpha channel value of 0.
/// </summary>
private class TransparentPixelCounter : IPartialPixelLoader
{
/// <summary>
/// The number of fully transparent pixels.
/// </summary>
private int count;
/// <summary>
/// Gets the number of fully transparent pixels.
/// </summary>
public int Count
{
get { return this.count; }
}
/// <summary>
/// Processes the loaded pixels. This method is called back every time when a new portion of pixels is loaded.
/// </summary>
/// <param name="pixelsRectangle"/>The pixels rectangle.
/// <param name="pixels"/>The 32-bit ARGB pixels.
/// <param name="start"/>The start pixels point.
/// <param name="end"/>The end pixels point.
public void Process(Aspose.Imaging.Rectangle pixelsRectangle, Aspose.Imaging.Color[] pixels, Aspose.Imaging.Point start, Aspose.Imaging.Point end)
{
foreach (Color pixel in pixels)
{
if (pixel.A == 0)
{
this.count++;
}
}
}
}LoadPixels(Rectangle)
Ladda upp pixlar.
public Color[] LoadPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rektangeln för att ladda pixlar från.
Returns
Color [ ]
De laddade pixlarna array.
Examples
Följande exempel visar hur man laddar och behandlar pixlar av en rasterbild. Till exempel, överväga ett problem med att räkna fullständigt transparenta pixlar av en bild.
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);
}Detta exempel visar hur du laddar Pixel-information i en Array av Typfärg, manipulerar array och sätter den tillbaka till bilden. För att utföra dessa operationer skapar detta exempel en ny Bildfil (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)
Ladda rådata.
public void LoadRawData(Rectangle rectangle, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
rektangeln för att ladda rådata från.
rawDataSettings RawDataSettings
De rådatainställningar som ska användas för laddade data. notera om data inte är i det angivna formatet då datakonvertering kommer att utföras.
rawDataLoader IPartialRawDataLoader
Den rådata laddaren.
Examples
Följande exempel visar hur man extraherar pixlar från råbilddata med hjälp av RawDataSettings. Till exempel, överväga ett problem med att räkna fullständigt transparenta pixlar av en bild.
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)
Ladda rådata.
public void LoadRawData(Rectangle rectangle, Rectangle destImageBounds, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
rektangeln för att ladda rådata från.
destImageBounds Rectangle
Den här bilden begränsar.
rawDataSettings RawDataSettings
De rådatainställningar som ska användas för laddade data. notera om data inte är i det angivna formatet då datakonvertering kommer att utföras.
rawDataLoader IPartialRawDataLoader
Den rådata laddaren.
NormalizeAngle()
Normaliserar vinkeln.Denna metod är tillämplig på skannade textdokument för att bli av med den skjutna skanningen.Denna metod använder Aspose.Imaging.RasterImage.GetSkewAngle och Aspose.Imaging.RasterImage.Rotate(System.Single) metoder.
public void NormalizeAngle()NormalizeAngle(bool, färg)
Normaliserar vinkeln.Denna metod är tillämplig på skannade textdokument för att bli av med den skjutna skanningen.Denna metod använder Aspose.Imaging.RasterImage.GetSkewAngle och Aspose.Imaging.RasterImage.Rotate(System.Single,System.Boolean,Aspose.Imaging.Color) metoder.
public virtual void NormalizeAngle(bool resizeProportionally, Color backgroundColor)Parameters
resizeProportionally bool
Om du ställer in “true” har du ändrat din bildstorlek i enlighet med roterade rektangulära (kornpunkter) projektioner i annat fall som lämnar dimensioner orörda och endast interna bildinnehåll roteras.
backgroundColor Color
Färgen på bakgrunden.
Examples
Skew är en artefakt som kan dyka upp under dokumentskanningsprocessen när texten/bilderna i dokumentet roteras i en liten vinkel. Det kan ha olika orsaker men det vanligaste är att papperet blir felplacerad under en skanning. Därför är deskew processen att upptäcka och fixa detta problem på skannade filer (dvs. bitmap) så deskewed dokument kommer att ha texten/bilderna korrekt och horisontellt justerade.
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()
Normaliserar bilden histogram – justerar pixelvärden för att använda alla tillgängliga intervall.
public virtual void NormalizeHistogram()ReadArgb32ScanLine(int)
Läser hela skanningslinjen genom den angivna skanningslinjekten.
public int[] ReadArgb32ScanLine(int scanLineIndex)Parameters
scanLineIndex int
Nollbaserad index av skanningslinjen.
Returns
int [ ]
Skanningslinjen 32-bitars ARGB färgvärden array.
ReadScanLine(int)
Läser hela skanningslinjen genom den angivna skanningslinjekten.
public Color[] ReadScanLine(int scanLineIndex)Parameters
scanLineIndex int
Nollbaserad index av skanningslinjen.
Returns
Color [ ]
Skanningslinjen pixel färgvärden array.
ReleaseManagedResources()
Se till att inga okontrollerade resurser släpps här, eftersom de kanske redan har släppts.
protected override void ReleaseManagedResources()RemoveMetadata()
Ta bort denna bild instans metadata genom att ställa in detta Aspose.Imaging.Xmp.IHasXMPData. noll.
public override void RemoveMetadata()ReplaceColor(Färg, byte och färg)
Ersätter en färg till en annan med tillåtna skillnader och bevarar ursprungliga alfa-värden för att spara smidiga gränser.
public void ReplaceColor(Color oldColor, byte oldColorDiff, Color newColor)Parameters
oldColor Color
Gamla färger att ersätta.
oldColorDiff byte
Tillåtet skillnad i gammal färg för att kunna utöka ersatt färgton.
newColor Color
Nya färger för att ersätta gamla färger med.
ReplaceColor(int, byte, int)
Ersätter en färg till en annan med tillåtna skillnader och bevarar ursprungliga alfa-värden för att spara smidiga gränser.
public virtual void ReplaceColor(int oldColorArgb, byte oldColorDiff, int newColorArgb)Parameters
oldColorArgb int
Gamla färg ARGB värde ska ersättas.
oldColorDiff byte
Tillåtet skillnad i gammal färg för att kunna utöka ersatt färgton.
newColorArgb int
Ny färg ARGB värde för att ersätta gammal färg med.
ReplaceNonTransparentColors(Color)
Den ersätter alla icke-transparenta färger med ny färg och bevarar ursprungliga alfa-värde för att spara smidiga ändar.Obs!: Om du använder den på bilder utan transparens kommer alla färger att ersättas med en enda.
public void ReplaceNonTransparentColors(Color newColor)Parameters
newColor Color
Nya färger för att ersätta icke-transparenta färger med.
ReplaceNonTransparentColors(int)
Den ersätter alla icke-transparenta färger med ny färg och bevarar ursprungliga alfa-värde för att spara smidiga ändar.Obs!: Om du använder den på bilder utan transparens kommer alla färger att ersättas med en enda.
public virtual void ReplaceNonTransparentColors(int newColorArgb)Parameters
newColorArgb int
Ny färg ARGB värde för att ersätta icke-transparent färger med.
Resize(int, int, ImageResizeSettings)
Återskapa bilden med utökade alternativ.
public override void Resize(int newWidth, int newHeight, ImageResizeSettings settings)Parameters
newWidth int
Den nya bredden.
newHeight int
Den nya höjden.
settings ImageResizeSettings
De återställda inställningarna.
Examples
Detta exempel laddar en rasterbild och resyser den med hjälp av olika resiseringsinställningar.
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, färg)
Rotera bilden runt centrum.
public virtual void Rotate(float angle, bool resizeProportionally, Color backgroundColor)Parameters
angle float
Den roterade vinkeln i grader. Positiva värden roterar klockvis.
resizeProportionally bool
Om du ställer in “true” har du ändrat din bildstorlek i enlighet med roterade rektangulära (kornpunkter) projektioner i annat fall som lämnar dimensioner orörda och endast interna bildinnehåll roteras.
backgroundColor Color
Färgen på bakgrunden.
Exceptions
Inga tillämpliga undantag
Rotate(Flotta)
Rotera bilden runt centrum.
public override void Rotate(float angle)Parameters
angle float
Den roterade vinkeln i grader. Positiva värden roterar klockvis.
Save(Ström, ImageOptionsBase, Rectangle)
Spara bilden data till den angivna strömmen i det angivna filformat enligt spara alternativ.
public override void Save(Stream stream, ImageOptionsBase optionsBase, Rectangle boundsRectangle)Parameters
stream Stream
Strömmen för att spara bildens data till.
optionsBase ImageOptionsBase
De spara alternativen.
boundsRectangle Rectangle
Destinationsbilden begränsar rektangeln. Ställ in den tomma rektangeln för att använda källgränser.
SaveArgb32Pixels(Rektangel, int[])
Spara 32-bitars ARGB pixlar.
public void SaveArgb32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Den rektangeln för att spara pixlar till.
pixels int
[ ]
Den 32-bitars ARGB pixlar array.
Examples
Följande exempel fyller det centrala området för en rasterbild med svarta pixlar med 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(Rektangel, int[])
Spara dina pixlar.
public void SaveCmyk32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Den rektangeln för att spara pixlar till.
pixels int
[ ]
De CMYK-pixlarna presenteras som de 32-bitars totala värdena.
Examples
Följande exempel fyller det centrala området för en rasterbild med svarta pixlar med 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, CmykColor[])
Spara dina pixlar.Använd effektivare Aspose.Imaging.RasterImage.SaveCmyk32Pixels(Aspose.Imaging.Rectangle,System.Int32[]) metod.
[Obsolete("Method is obsolete")]
public void SaveCmykPixels(Rectangle rectangle, CmykColor[] pixels)Parameters
rectangle Rectangle
Den rektangeln för att spara pixlar till.
pixels CmykColor
[ ]
Den CMYK pixlar array.
SavePixels(Rektangel, färg[])
Spara dina pixlar.
public void SavePixels(Rectangle rectangle, Color[] pixels)Parameters
rectangle Rectangle
Den rektangeln för att spara pixlar till.
pixels Color
[ ]
Pixel är på väg.
Examples
Följande exempel fyller det centrala området för en rasterbild med svarta pixlar med 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");
}Detta exempel visar hur du laddar Pixel-information i en Array av Typfärg, manipulerar array och sätter den tillbaka till bilden. För att utföra dessa operationer skapar detta exempel en ny Bildfil (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)
Spara de rådata.
public void SaveRawData(byte[] data, int dataOffset, Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
data byte
[ ]
och rådata.
dataOffset int
De ursprungliga rådata kompenseras.
rectangle Rectangle
Den rådata rektangeln.
rawDataSettings RawDataSettings
De rådata inställningar som data är i.
SetArgb32Pixel(int, int, int och int)
Ställ in en 32-bitars ARGB-pixel för den angivna positionen.
public void SetArgb32Pixel(int x, int y, int argb32Color)Parameters
x int
Pixel x läge.
y int
Pixel och plats.
argb32Color int
32-bitars ARGB-pixel för den angivna positionen.
Examples
Följande exempel ladda en rasterbild, och ställer in färgen på en önskvärd 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(IcolorPalette, Bool)
Ställ in bildpaletten.
public override void SetPalette(IColorPalette palette, bool updateColors)Parameters
palette IColorPalette
Paletten att ställa in.
updateColors bool
om du ställer in “true” färger kommer att uppdateras enligt den nya paletten; annars färgindex förblir oförändrade. notera att oförändrade index kan krascha bilden på laddningen om vissa index inte har motsvarande palettinsatser.
SetPixel(int, int, färg)
Ställ in en bildpixel för den angivna positionen.
public void SetPixel(int x, int y, Color color)Parameters
x int
Pixel x läge.
y int
Pixel och plats.
color Color
Pixelfärg för den angivna positionen.
Examples
Följande exempel ladda en rasterbild, och ställer in färgen på en önskvärd 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(dubbel, dubbel)
Ange upplösningen för denna Aspose.Imaging.RasterImage.
public virtual void SetResolution(double dpiX, double dpiY)Parameters
dpiX double
Den horisontella upplösningen, i punkter per tum, av Aspose.Imaging.RasterImage.
dpiY double
Den vertikala upplösningen, i punkter per tum, av Aspose.Imaging.RasterImage.
Examples
Följande exempel visar hur man ställer in en horisontell/vertikal upplösning av en rasterbild.
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()
Konverterar rasterbilden till bitmappen.Denna metod stöds inte i versioner från .Net7.0 och högre
public virtual Bitmap ToBitmap()Returns
Bitmappen
UpdateDimensions(int, int)
Uppdatera bilddimensionerna.
protected abstract void UpdateDimensions(int newWidth, int newHeight)Parameters
newWidth int
Den nya bilden bredd.
newHeight int
Den nya bilden höjd.
UpdateMetadata()
Uppdatera bildmetadata.
protected virtual void UpdateMetadata()WriteArgb32ScanLine(int, int[])
Skriv hela skanningslinjen till den angivna skanningslinjen index.
public void WriteArgb32ScanLine(int scanLineIndex, int[] argb32Pixels)Parameters
scanLineIndex int
Nollbaserad index av skanningslinjen.
argb32Pixels int
[ ]
32-bitars ARGB-färger gör det möjligt att skriva.
WriteScanLine(int, färg[])
Skriv hela skanningslinjen till den angivna skanningslinjen index.
public void WriteScanLine(int scanLineIndex, Color[] pixels)Parameters
scanLineIndex int
Nollbaserad index av skanningslinjen.
pixels Color
[ ]
Pixelfärgerna gör att du skriver.
