Class RasterImage
Numele spaţiului: Aspose.Imaging Asamblare: Aspose.Imaging.dll (25.4.0)
Reprezintă o imagine raster care susține operațiunile grafice raster.
public abstract class RasterImage : Image, IDisposable, IObjectWithBounds, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, IHasXmpData, IHasMetadataInheritance
object ← DisposableObject ← DataStreamSupporter ← Image ← RasterImage
Derived
Implements
IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata
Membrii moștenitori
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
Acest exemplu arată cum să încărcați informațiile Pixel într-un Array de tip de culoare, să manipulați array-ul și să-l puneți înapoi la imagine. Pentru a efectua aceste operații, acest exemplu creează un nou fișier Image (în format GIF) uisng MemoryStream obiect.
//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()
Inițializează o nouă instanță a clasei Aspose.Imaging.RasterImage.
[JsonConstructor]
protected RasterImage()RasterImage(Întâlnirea)
Inițializează o nouă instanță a clasei Aspose.Imaging.RasterImage.
protected RasterImage(IColorPalette colorPalette)Parameters
colorPalette IColorPalette
Paleta de culori.
Fields
xmpData
Metadata XMP
[JsonProperty]
protected XmpPacketWrapper xmpDataValoarea câmpului
Properties
DataLoader
Obține sau stabilește încărcătorul de date.
[JsonProperty]
protected IRasterImageArgb32PixelLoader DataLoader { get; set; }Valoarea proprietății
HasAlpha
Obține o valoare care indică dacă această instanță are alfa.
public virtual bool HasAlpha { get; }Valoarea proprietății
Examples
Următorul exemplu încărcă imagini raster și imprimează informații despre formatul de date crude și canalul alfa.
// The image files to load.
string[] fileNames = new string[]
{
@"c:\temp\sample.bmp",
@"c:\temp\alpha.png",
};
foreach (string fileName in fileNames)
{
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(fileName))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
System.Console.WriteLine("ImageFile={0}, FileFormat={1}, HasAlpha={2}", fileName, rasterImage.RawDataFormat, rasterImage.HasAlpha);
}
}
// The output may look like this:
// ImageFile=c:\temp\sample.bmp, FileFormat=Rgb24Bpp, used channels: 8,8,8, HasAlpha=False
// ImageFile=c:\temp\alpha.png, FileFormat=RGBA32Bpp, used channels: 8,8,8,8, HasAlpha=TrueUrmătorul exemplu arată cum să extrageți informații despre formatul de date crude și canalul alfa dintr-o imagine BMP.
// Create a 32-bpp BMP image of 100 x 100 px.
using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 32, null))
{
System.Console.WriteLine("FileFormat={0}, RawDataFormat={1}, HasAlpha={2}", bmpImage.FileFormat, bmpImage.RawDataFormat, bmpImage.HasAlpha);
};
// Create a 24-bpp BMP image of 100 x 100 px.
using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 24, null))
{
System.Console.WriteLine("FileFormat={0}, RawDataFormat={1}, HasAlpha={2}", bmpImage.FileFormat, bmpImage.RawDataFormat, bmpImage.HasAlpha);
};
// Generally, BMP doesn't support alpha channel so the output will look like this:
// FileFormat = Bmp, RawDataFormat = Rgb32Bpp, used channels: 8,8,8,8, HasAlpha = False
// FileFormat = Bmp, RawDataFormat = Rgb24Bpp, used channels: 8,8,8, HasAlpha = FalseHasTransparentColor
Obține o valoare care indică dacă imaginea are o culoare transparentă.
public virtual bool HasTransparentColor { get; set; }Valoarea proprietății
HorizontalResolution
Obține sau stabilește rezoluția orizontală, în pixeli pe inch, a acestui Aspose.Imaging.RasterImage.
public virtual double HorizontalResolution { get; set; }Valoarea proprietății
Examples
Următorul exemplu arată cum să stabiliți rezoluția orizontală/verticală a unei imagini de raster.
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
Notă în mod implicit această valoare este întotdeauna 96 deoarece diferitele platforme nu pot întoarce rezoluția ecranului. puteți lua în considerare utilizarea metodei SetResolution pentru a actualiza ambele valori de rezoluție într-un singur apel.
ImageOpacity
Obține opacitatea acestei imagini.
public virtual float ImageOpacity { get; }Valoarea proprietății
IsRawDataAvailable
Obține o valoare care indică dacă încărcarea de date crude este disponibilă.
public bool IsRawDataAvailable { get; }Valoarea proprietății
PremultiplyComponents
Obține sau stabilește o valoare care indică dacă componentele imaginii trebuie să fie preliminare.
public virtual bool PremultiplyComponents { get; set; }Valoarea proprietății
Examples
Următorul exemplu creează o nouă imagine raster, salvează pixelele semi-transparente specificate, apoi încărcă acele pixeli și obține culori finale în forma premultiplicată.
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
Obține sau stabilește convertorul de culoare personalizat
public IColorConverter RawCustomColorConverter { get; set; }Valoarea proprietății
RawDataFormat
Obțineți formatul de date crude.
public virtual PixelDataFormat RawDataFormat { get; }Valoarea proprietății
Examples
Următorul exemplu încărcă imagini raster și imprimează informații despre formatul de date crude și canalul alfa.
// The image files to load.
string[] fileNames = new string[]
{
@"c:\temp\sample.bmp",
@"c:\temp\alpha.png",
};
foreach (string fileName in fileNames)
{
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(fileName))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
System.Console.WriteLine("ImageFile={0}, FileFormat={1}, HasAlpha={2}", fileName, rasterImage.RawDataFormat, rasterImage.HasAlpha);
}
}
// The output may look like this:
// ImageFile=c:\temp\sample.bmp, FileFormat=Rgb24Bpp, used channels: 8,8,8, HasAlpha=False
// ImageFile=c:\temp\alpha.png, FileFormat=RGBA32Bpp, used channels: 8,8,8,8, HasAlpha=TrueAcest exemplu arată cum să încărcați o imagine DJVU dintr-un flux de fișiere și să imprimați informații despre paginile.
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
Obține setările actuale de date crude. rețineți atunci când utilizați aceste setări, datele sunt încărcate fără conversie.
[JsonIgnore]
public RawDataSettings RawDataSettings { get; }Valoarea proprietății
RawFallbackIndex
Obține sau stabilește indexul de descărcare pentru a fi utilizat atunci când indexul de paletă este în afara limitelor
public int RawFallbackIndex { get; set; }Valoarea proprietății
RawIndexedColorConverter
Obține sau stabilește convertorul de culoare indexat
public IIndexedColorConverter RawIndexedColorConverter { get; set; }Valoarea proprietății
RawLineSize
Obține dimensiunea liniei crude în byte.
public virtual int RawLineSize { get; }Valoarea proprietății
TransparentColor
Obține culoarea transparentă a imaginii.
public virtual Color TransparentColor { get; set; }Valoarea proprietății
UpdateXmpData
Obține sau stabilește o valoare care indică dacă să actualizeze metadata XMP.
public virtual bool UpdateXmpData { get; set; }Valoarea proprietății
UsePalette
Obține o valoare care indică dacă se utilizează paleta de imagine.
public override bool UsePalette { get; }Valoarea proprietății
UseRawData
Obține sau stabilește o valoare care indică dacă trebuie să se utilizeze încărcarea de date crude atunci când încărcarea de date crude este disponibilă.
public virtual bool UseRawData { get; set; }Valoarea proprietății
VerticalResolution
Obține sau stabilește rezoluția verticală, în pixeli pe inch, a acestui Aspose.Imaging.RasterImage.
public virtual double VerticalResolution { get; set; }Valoarea proprietății
Examples
Următorul exemplu arată cum să stabiliți rezoluția orizontală/verticală a unei imagini de raster.
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
Notă în mod implicit această valoare este întotdeauna 96 deoarece diferitele platforme nu pot întoarce rezoluția ecranului. puteți lua în considerare utilizarea metodei SetResolution pentru a actualiza ambele valori de rezoluție într-un singur apel.
XmpData
Obține sau stabilește metadata XMP.
public virtual XmpPacketWrapper XmpData { get; set; }Valoarea proprietății
Methods
AdjustBrightness(int)
Adaptarea luminozității pentru imagine.
public virtual void AdjustBrightness(int brightness)Parameters
brightness int
Valori de lumină.
Examples
Următorul exemplu efectuează corectarea luminozității unei imagini.
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(float)
Imagini contraste
public virtual void AdjustContrast(float contrast)Parameters
contrast float
Valoarea contrastului (în interval [-100; 100])
Examples
Următorul exemplu efectuează corectarea contrastului unei imagini.
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(în float, float, float)
Corectarea gamma a unei imagini.
public virtual void AdjustGamma(float gammaRed, float gammaGreen, float gammaBlue)Parameters
gammaRed float
Gama pentru coeficientul canalului roșu
gammaGreen float
Gama pentru coeficientul canalului verde
gammaBlue float
Gamma pentru coeficientul canalului albastru
Examples
Următorul exemplu efectuează corecția gamma a unei imagini aplicând coeficienți diferiți pentru componentele de culoare.
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(float)
Corectarea gamma a unei imagini.
public virtual void AdjustGamma(float gamma)Parameters
gamma float
Gama pentru coeficientul canalelor roșii, verzi și albastru
Examples
Următorul exemplu efectuează corecția gamma a unei imagini.
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(Dublă)
Binarizarea unei imagini folosind algoritmul adaptiv de limită al lui Bradley folosind limitele integrale ale imaginii
public virtual void BinarizeBradley(double brightnessDifference)Parameters
brightnessDifference double
Diferența de luminozitate dintre pixel și medie a unei ferestre s x s a pixelelor centrate în jurul acestui pixel.
BinarizeBradley(Două ori, int)
Binarizarea unei imagini folosind algoritmul adaptiv de limită al lui Bradley folosind limitele integrale ale imaginii
public virtual void BinarizeBradley(double brightnessDifference, int windowSize)Parameters
brightnessDifference double
Diferența de luminozitate dintre pixel și medie a unei ferestre s x s a pixelelor centrate în jurul acestui pixel.
windowSize int
Dimensiunea ferestrei s x s a pixelelor centrate în jurul acestui pixel
Examples
Următorul exemplu binarizează o imagine raster cu algoritmul adaptiv al lui Bradley cu dimensiunea fereastră specificată. imagini binare conțin doar 2 culori - negru și alb.
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(în byte)
Binarizarea unei imagini cu un prag predefinit
public virtual void BinarizeFixed(byte threshold)Parameters
threshold byte
Dacă valoarea gri corespunzătoare a unui pixel este mai mare decât pragul, o valoare de 255 va fi atribuită acestuia, 0 altfel.
Examples
Următorul exemplu binarizează o imagine raster cu pragul predefinit. imagini binare conțin doar 2 culori - negru și alb.
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()
Binarizarea unei imagini cu pragul Otsu
public virtual void BinarizeOtsu()Examples
Următorul exemplu binarizează o imagine de raster cu pragul Otsu. imagini binare conțin doar 2 culori - negru și alb.
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(Poziție, RasterImage, Rectangle, byte)
Amestecați această imagine cu imaginea overlay".
public virtual void Blend(Point origin, RasterImage overlay, Rectangle overlayArea, byte overlayAlpha = 255)Parameters
origin Point
Imaginea de fundal amestecă originea.
overlay RasterImage
Imaginea supraîncărcată.
overlayArea Rectangle
Zona de supraîncărcare.
overlayAlpha byte
Cuvânt cheie alfa.
Blend(Poziție, RasterImage, byte)
Amestecați această imagine cu imaginea overlay".
public void Blend(Point origin, RasterImage overlay, byte overlayAlpha = 255)Parameters
origin Point
Imaginea de fundal amestecă originea.
overlay RasterImage
Imaginea supraîncărcată.
overlayAlpha byte
Cuvânt cheie alfa.
Dither(Metodă de utilizare, int)
Imaginea se bazează pe imaginea actuală.
public void Dither(DitheringMethod ditheringMethod, int bitsCount)Parameters
ditheringMethod DitheringMethod
Metoda de depăşire.
bitsCount int
Ultimele bite contează pentru dithering.
Examples
Următorul exemplu încărcă o imagine de raster și realizează pragul și fluiditatea cu ajutorul unei adâncimi diferite a paletei.
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(DitheringMetodă, int, IColorPalette)
Imaginea se bazează pe imaginea actuală.
public abstract void Dither(DitheringMethod ditheringMethod, int bitsCount, IColorPalette customPalette)Parameters
ditheringMethod DitheringMethod
Metoda de depăşire.
bitsCount int
Ultimele bite contează pentru dithering.
customPalette IColorPalette
Paleta obișnuită pentru dithering.
Filter(Rectangle, FilterOptionsBase)
Filtrează rectanglul specificat.
public virtual void Filter(Rectangle rectangle, FilterOptionsBase options)Parameters
rectangle Rectangle
în rectanglu .
options FilterOptionsBase
ale opţiunilor .
Examples
Următorul exemplu se aplică diferitelor tipuri de filtre unei imagini raster.
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)
Obțineți un pictogram ARGB 32-bit.
public int GetArgb32Pixel(int x, int y)Parameters
x int
Localizarea pixelului X.
y int
pixel și locație.
Returns
Pixelul ARGB de 32 de biți pentru locația specificată.
Examples
Următorul exemplu încărcă o imagine raster și obține culoarea unui pixel arbitrar reprezentat ca o valoare integrală de 32 de biți.
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);
}Următorul exemplu arată modul în care caching-ul imaginii afectează performanța. în general, citirea datelor cache este efectuată mai repede decât citirea datelor non-cache.
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)
Obține aranjamentul de 32-bit de pixeli ARGB.
public int[] GetDefaultArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rectangul pentru a obține pixeli pentru.
Returns
int []
Pixelele standard sunt array.
GetDefaultPixels(Rectangle, IPartialArgb32PixelLoader)
Obțineți pixelele predefinite aranjate folosind un încărcător de pixel parțial.
public void GetDefaultPixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Rectangul pentru a obține pixeli pentru.
partialPixelLoader IPartialArgb32PixelLoader
Încărcătorul de pixel parțial.
GetDefaultRawData(Rectangle, IPartialRawDataLoader, Setări RawData)
Obține aria de date crude standard folosind un încărcător de pixel parțial.
public void GetDefaultRawData(Rectangle rectangle, IPartialRawDataLoader partialRawDataLoader, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Rectangul pentru a obține pixeli pentru.
partialRawDataLoader IPartialRawDataLoader
Încărcătorul partial de date crude.
rawDataSettings RawDataSettings
setările de date crude.
GetDefaultRawData(Rectangle și RawDataSettings)
Obține arrayul de date crude standard.
public byte[] GetDefaultRawData(Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Rectangul pentru a obține date crude pentru.
rawDataSettings RawDataSettings
setările de date crude.
Returns
byte []
Deficitul de date crude array.
GetModifyDate(Boulă)
Obțineți data și timpul când imaginea de resurse a fost ultima modificare.
public virtual DateTime GetModifyDate(bool useDefault)Parameters
useDefault bool
în cazul în care este setat la „true”, utilizați informațiile din FileInfo ca valoare predefinită.
Returns
Data și timpul a fost ultima modificare a imaginii de resurse.
GetPixel(int, int)
Obțineți un pixel de imagine.
public Color GetPixel(int x, int y)Parameters
x int
Localizarea pixelului X.
y int
pixel și locație.
Returns
Culoarea pixelului pentru locația specificată.
Examples
Următorul exemplu încărcă o imagine raster și obține culoarea unui pixel arbitrar.
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ăsește unghiul schiului.Această metodă se aplică documentelor de text scanate, pentru a determina unghiul de scanare în timpul scanării.
public float GetSkewAngle()Returns
Un unghi de schi, în grade.
Grayscale()
Transformarea unei imagini în reprezentarea sa grayscale
public virtual void Grayscale()Examples
Următorul exemplu transformă o imagine colorată a rasterului în reprezentarea sa grayscale. imagini gray scale sunt compuse exclusiv din nuanțe de gri și poartă doar informații de intensitate.
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)
Încărcați 32-bit pixeli ARGB.
public int[] LoadArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rectangul pentru a încărca pixeli de la.
Returns
int []
Încărcat 32-bit ARGB pixel array.
Examples
Următorul exemplu arată cum să încărcați și să prelucrați pixelele unei imagini raster.Pixelele sunt reprezentate ca valori integrale de 32 de biți.De exemplu, luați în considerare o problemă de numărare a pixelelor complet transparente ale imaginii.
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)
Încărcă 64-bit pixeli ARGB.
public long[] LoadArgb64Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rectangul pentru a încărca pixeli de la.
Returns
long []
Încărcat 64-bit ARGB pixel array.
Examples
Următorul exemplu arată cum să încărcați și să prelucrați pixelele unei imagini raster.Pixelele sunt reprezentate ca valori integrale de 64 de biți.De exemplu, luați în considerare o problemă de numărare a pixelelor complet transparente ale imaginii.
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)
Încărcați pixeli în format CMYK.
public int[] LoadCmyk32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rectangul pentru a încărca pixeli de la.
Returns
int []
Pixelele CMYK încărcate sunt prezente ca valori inategorice 32-bit.
LoadCmykPixels(Rectangle)
Încărcați pixeli în format CMYK.Vă rugăm să utilizați mai eficient metoda Aspose.Imaging.RasterImage.LoadCmyk32Pixels(_W L17.Rectangle).
[Obsolete("Method is obsolete")]
public CmykColor[] LoadCmykPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rectangul pentru a încărca pixeli de la.
Returns
CmykColor []
Pixelele CMYK încărcate sunt array.
LoadPartialArgb32Pixels(Rectangle, IPartialArgb32PixelLoader)
Încărcă parțial pixelele ARGB de 32 de bit prin pachete.
public void LoadPartialArgb32Pixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
rectangul dorit.
partialPixelLoader IPartialArgb32PixelLoader
Încărcătorul de pixel ARGB 32-bit.
Examples
Următorul exemplu arată cum să încărcați și să prelucrați pixele unei imagini raster folosind propriul procesor parțial. De exemplu, luați în considerare o problemă de numărare a pixelelor complet transparente ale imaginii. Pentru a număra pixeli transparenți utilizând mecanismul partial, se introduce o clasă separată TransparentArgb32PixelCounter implementarea 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)
Încărcă 64-bit de pixeli ARGB parțial prin pachete.
public void LoadPartialArgb64Pixels(Rectangle rectangle, IPartialArgb64PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
rectangul dorit.
partialPixelLoader IPartialArgb64PixelLoader
Încărcătorul de pixeli ARGB 64-bit.
LoadPartialPixels(Cuvânt cheie: IPartialPixelLoader)
Încărcă pixelele parțial prin pachete.
public void LoadPartialPixels(Rectangle desiredRectangle, IPartialPixelLoader pixelLoader)Parameters
desiredRectangle Rectangle
rectangul dorit.
pixelLoader IPartialPixelLoader
Încarcătorul de pixel.
Examples
Următorul exemplu arată cum să încărcați și să prelucrați pixele unei imagini raster folosind propriul procesor parțial. De exemplu, luați în considerare o problemă de numărare a pixelelor complet transparente ale imaginii. Pentru a număra transparența utilizând mecanismul partial, se introduce o clasă separată TransparentPixelCounter implementând Aspose.Imaging.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\alpha.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Create an instance of the Aspose.Imaging.IPartialPixelLoader and pass it to the Aspose.Imaging.RasterImage.LoadPartialPixels
TransparentPixelCounter counter = new TransparentPixelCounter();
// Load pixels for the whole image. Any rectangular part of the image can be specified as the first parameter of the Aspose.Imaging.RasterImage.LoadPartialPixels method.
rasterImage.LoadPartialPixels(rasterImage.Bounds, counter);
System.Console.WriteLine("The number of fully transparent pixels is {0}", counter.Count);
System.Console.WriteLine("The total number of pixels is {0}", image.Width * image.Height);
}
// The counter may look like this:
/// <summary>
/// Counts the number of fully transparent pixels with alpha channel value of 0.
/// </summary>
private class TransparentPixelCounter : IPartialPixelLoader
{
/// <summary>
/// The number of fully transparent pixels.
/// </summary>
private int count;
/// <summary>
/// Gets the number of fully transparent pixels.
/// </summary>
public int Count
{
get { return this.count; }
}
/// <summary>
/// Processes the loaded pixels. This method is called back every time when a new portion of pixels is loaded.
/// </summary>
/// <param name="pixelsRectangle"/>The pixels rectangle.
/// <param name="pixels"/>The 32-bit ARGB pixels.
/// <param name="start"/>The start pixels point.
/// <param name="end"/>The end pixels point.
public void Process(Aspose.Imaging.Rectangle pixelsRectangle, Aspose.Imaging.Color[] pixels, Aspose.Imaging.Point start, Aspose.Imaging.Point end)
{
foreach (Color pixel in pixels)
{
if (pixel.A == 0)
{
this.count++;
}
}
}
}LoadPixels(Rectangle)
Încărcați pixeli.
public Color[] LoadPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Rectangul pentru a încărca pixeli de la.
Returns
Color []
Pixelele încărcate sunt array.
Examples
Următorul exemplu arată cum să încărcați și să procesați pixele unei imagini raster. de exemplu, luați în considerare o problemă de numărare a pixelor complet transparente ale imaginii.
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);
}Acest exemplu arată cum să încărcați informațiile Pixel într-un Array de tip de culoare, să manipulați array-ul și să-l puneți înapoi la imagine. Pentru a efectua aceste operații, acest exemplu creează un nou fișier Image (în format GIF) uisng MemoryStream obiect.
//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(Cuvânt cheie: Rectangle, RawDataSettings, IPartialRawDataLoader)
încărcă datele crude.
public void LoadRawData(Rectangle rectangle, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Rectangolul pentru a încărca datele crude de la.
rawDataSettings RawDataSettings
Setările de date crude pentru a fi utilizate pentru datele încărcate. Notă dacă datele nu sunt în formatul specificat, atunci conversia datelor va fi efectuată.
rawDataLoader IPartialRawDataLoader
încărcătorul de date crude.
Examples
Următorul exemplu arată cum să extrageți pixeli din datele de imagine crude folosind RawDataSettings. de exemplu, luați în considerare o problemă de numărare a pixelelor complet transparente ale unei imagini.
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)
încărcă datele crude.
public void LoadRawData(Rectangle rectangle, Rectangle destImageBounds, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Rectangolul pentru a încărca datele crude de la.
destImageBounds Rectangle
Imaginea este limitată.
rawDataSettings RawDataSettings
Setările de date crude pentru a fi utilizate pentru datele încărcate. Notă dacă datele nu sunt în formatul specificat, atunci conversia datelor va fi efectuată.
rawDataLoader IPartialRawDataLoader
încărcătorul de date crude.
NormalizeAngle()
Normalizează unghiul.Această metodă se aplică documentelor de text scanate pentru a scăpa de scanarea scanată.Această metodă utilizează metodele Aspose.Imaging.RasterImage.GetSkewAngle și W L17.
public void NormalizeAngle()NormalizeAngle(Culoare , Culoare)
Normalizează unghiul.Această metodă se aplică documentelor de text scanate pentru a scăpa de scanarea scanată.Această metodă utilizează metodele Aspose.Imaging.RasterImage.GetSkewAngle și W L17. RasterImea.Roate(System.Single,Sistem.Boolean,Wl17__.Color).
public virtual void NormalizeAngle(bool resizeProportionally, Color backgroundColor)Parameters
resizeProportionally bool
în cazul în care este setat la “true”, veți avea dimensiunea imaginii modificate în funcție de proiecțiile rectangle rotate (punctele de coadă) în caz contrar care lasă dimensiunile necoșite și numai conținutul imaginii interne sunt rotate.
backgroundColor Color
Culoarea fundalului.
Examples
Skew este un artefacte care ar putea apărea în timpul procesului de scanare a documentelor atunci când textul/imaginea documentului este rotați într-un unghi ușor. poate avea diferite cauze, dar cel mai frecvent este că hârtia este greșit localizată în cursul unei scane. Prin urmare, deskiew este procesul de detectare și corectarea acestei probleme pe fișierele scrise (de exemplu, bitmap), astfel încât documentele dezkived vor avea text / imagini corecte și orizontale ajustate.
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()
Normalizează histogramul imaginii – ajustați valorile pixelelor pentru a utiliza toate gamele disponibile.
public virtual void NormalizeHistogram()ReadArgb32ScanLine(int)
Citiți întreaga linie de scanare prin indicele liniei de scanare specificate.
public int[] ReadArgb32ScanLine(int scanLineIndex)Parameters
scanLineIndex int
Indicele bazat pe zero al liniei de scanare.
Returns
int []
Linia de scanare 32-bit ARGB valori de culoare array.
ReadScanLine(int)
Citiți întreaga linie de scanare prin indicele liniei de scanare specificate.
public Color[] ReadScanLine(int scanLineIndex)Parameters
scanLineIndex int
Indicele bazat pe zero al liniei de scanare.
Returns
Color []
Linia de scanare pixelă valori de culoare array.
ReleaseManagedResources()
Asigurați-vă că resursele necontrolate nu sunt eliberate aici, deoarece acestea pot fi deja eliberate.
protected override void ReleaseManagedResources()RemoveMetadata()
Îndepărtează aceste metadate de imagine prin setarea acestui Aspose.Imaging.Xmp.IHasXMPData.xmpValuate pentru zero.
public override void RemoveMetadata()ReplaceColor(Culoare, byte, culoare)
Înlocuiește o culoare la alta cu o diferență permisă și păstrează valoarea alfa originală pentru a salva marginea netedă.
public void ReplaceColor(Color oldColor, byte oldColorDiff, Color newColor)Parameters
oldColor Color
Culoarea veche trebuie înlocuită.
oldColorDiff byte
Permite diferența de culoare veche pentru a putea extinde tonul de culoare înlocuit.
newColor Color
Culoare nouă pentru a înlocui culoarea veche cu.
ReplaceColor(int, byte, int)
Înlocuiește o culoare la alta cu o diferență permisă și păstrează valoarea alfa originală pentru a salva marginea netedă.
public virtual void ReplaceColor(int oldColorArgb, byte oldColorDiff, int newColorArgb)Parameters
oldColorArgb int
Valoarea veche de culoare ARGB va fi înlocuită.
oldColorDiff byte
Permite diferența de culoare veche pentru a putea extinde tonul de culoare înlocuit.
newColorArgb int
Valoare nouă ARGB pentru a înlocui culoarea veche cu.
ReplaceNonTransparentColors(Color)
Înlocuiește toate culorile non-transparente cu o nouă culoare și păstrează valoarea alfa originală pentru a salva marginea netedă.Notă: dacă o utilizați pe imagini fără transparență, toate culorile vor fi înlocuite cu un singur.
public void ReplaceNonTransparentColors(Color newColor)Parameters
newColor Color
O nouă culoare pentru a înlocui culorile cu nu transparente.
ReplaceNonTransparentColors(int)
Înlocuiește toate culorile non-transparente cu o nouă culoare și păstrează valoarea alfa originală pentru a salva marginea netedă.Notă: dacă o utilizați pe imagini fără transparență, toate culorile vor fi înlocuite cu un singur.
public virtual void ReplaceNonTransparentColors(int newColorArgb)Parameters
newColorArgb int
Noua valoare de culoare ARGB pentru a înlocui culorile cu nu transparente.
Resize(int, int, ImageResizeSettings)
Recuperați imaginea cu opțiuni extinse.
public override void Resize(int newWidth, int newHeight, ImageResizeSettings settings)Parameters
newWidth int
În noua lățime.
newHeight int
Înălţimea nouă.
settings ImageResizeSettings
Împreună cu setările de rezistență.
Examples
Acest exemplu încărcă o imagine raster și o revizuiesc folosind diferite setări de revizuire.
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, culoare)
Imaginea rotată în jurul centrului.
public virtual void Rotate(float angle, bool resizeProportionally, Color backgroundColor)Parameters
angle float
Angajul rotativ în grade. valorile pozitive se vor rotati pe oră.
resizeProportionally bool
în cazul în care este setat la “true”, veți avea dimensiunea imaginii modificate în funcție de proiecțiile rectangle rotate (punctele de coadă) în caz contrar care lasă dimensiunile necoșite și numai conținutul imaginii interne sunt rotate.
backgroundColor Color
Culoarea fundalului.
Exceptions
Excepţie neimplementată
Rotate(float)
Imaginea rotată în jurul centrului.
public override void Rotate(float angle)Parameters
angle float
Angajul rotativ în grade. valorile pozitive se vor rotati pe oră.
Save(Stream, Opțiuni de imagineBase, Rectangle)
Salvează datele imaginii în fluxul specificat în formatul de fișier specificat în funcție de opțiunile de salvare.
public override void Save(Stream stream, ImageOptionsBase optionsBase, Rectangle boundsRectangle)Parameters
stream Stream
Stream pentru a salva datele imaginii la.
optionsBase ImageOptionsBase
Opţiunile de salvare.
boundsRectangle Rectangle
Imaginea de destinație limitează rectangolul. Setarea rectangolului gol pentru a utiliza limitele de sursă.
SaveArgb32Pixels(Călărașul, int[])
Scăderea pixelelor ARGB de 32 de bite.
public void SaveArgb32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Rectangul pentru a salva pixeli la.
pixels int
[]
32-bit ARGB pixeli array.
Examples
Următorul exemplu umple zona centrală a unei imagini raster cu pixeli negri folosind metoda Aspose.Imaging.RasterImage.SaveArgb32Pixels.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// The black square
int[] pixels = new int[(rasterImage.Width / 2) * (rasterImage.Height / 2)];
for (int i = 0; i < pixels.Length; i++)
{
pixels[i] = Color.Black.ToArgb();
}
// Draw the black square at the center of the image.
Aspose.Imaging.Rectangle area = new Aspose.Imaging.Rectangle(rasterImage.Width / 4, rasterImage.Height / 4, rasterImage.Width / 2, rasterImage.Height / 2);
rasterImage.SaveArgb32Pixels(area, pixels);
rasterImage.Save(dir + "sample.SaveArgb32Pixels.png");
}SaveCmyk32Pixels(Călărașul, int[])
salvează pixelele.
public void SaveCmyk32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Rectangul pentru a salva pixeli la.
pixels int
[]
Pixele CMYK sunt prezentate ca valori integrale 32-bit.
Examples
Următorul exemplu umple zona centrală a unei imagini raster cu pixeli negri folosind metoda Aspose.Imaging.RasterImage.SaveCmyk32Pixels.
string dir = @"c:\temp\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Get an integer representation of black in the CMYK color space.
int blackCmyk = Aspose.Imaging.CmykColorHelper.ToCmyk(Color.Black);
// The black square.
int[] pixels = new int[(rasterImage.Width / 2) * (rasterImage.Height / 2)];
for (int i = 0; i < pixels.Length; i++)
{
pixels[i] = blackCmyk;
}
// Draw the black square at the center of the image.
Aspose.Imaging.Rectangle area = new Aspose.Imaging.Rectangle(rasterImage.Width / 4, rasterImage.Height / 4, rasterImage.Width / 2, rasterImage.Height / 2);
rasterImage.SaveCmyk32Pixels(area, pixels);
rasterImage.Save(dir + "sample.SaveCmyk32Pixels.png");
}SaveCmykPixels(Rectangle și CmykColor[])
salvează pixelele.Vă rugăm să folosiți mai eficient metoda Aspose.Imaging.RasterImage.SaveCmyk32Pixels(__W L17_Rectangle,System.Int32[]).
[Obsolete("Method is obsolete")]
public void SaveCmykPixels(Rectangle rectangle, CmykColor[] pixels)Parameters
rectangle Rectangle
Rectangul pentru a salva pixeli la.
pixels CmykColor
[]
Pixelele CMYK sunt array.
SavePixels(Rețeaua, culoarea[])
salvează pixelele.
public void SavePixels(Rectangle rectangle, Color[] pixels)Parameters
rectangle Rectangle
Rectangul pentru a salva pixeli la.
pixels Color
[]
Pixelele sunt aranjate.
Examples
Următorul exemplu umple zona centrală a unei imagini raster cu pixeli negri folosind metoda Aspose.Imaging.RasterImage.SavePixels.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// The black square
Color[] pixels = new Color[(rasterImage.Width / 2) * (rasterImage.Height / 2)];
for (int i = 0; i < pixels.Length; i++)
{
pixels[i] = Color.Black;
}
// Draw the black square at the center of the image.
Aspose.Imaging.Rectangle area = new Aspose.Imaging.Rectangle(rasterImage.Width / 4, rasterImage.Height / 4, rasterImage.Width / 2, rasterImage.Height / 2);
rasterImage.SavePixels(area, pixels);
rasterImage.Save(dir + "sample.SavePixels.png");
}Acest exemplu arată cum să încărcați informațiile Pixel într-un Array de tip de culoare, să manipulați array-ul și să-l puneți înapoi la imagine. Pentru a efectua aceste operații, acest exemplu creează un nou fișier Image (în format GIF) uisng MemoryStream obiect.
//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(în byte[], int, rectangle, RawDataSettings)
salvează datele crude.
public void SaveRawData(byte[] data, int dataOffset, Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
data byte
[]
Datele crude sunt.
dataOffset int
Datele prime de pornire sunt compensate.
rectangle Rectangle
Rectanglul datelor crude.
rawDataSettings RawDataSettings
Datele prime sunt setările în care se află datele.
SetArgb32Pixel(int, int, int)
Setati un pixel ARGB de 32 de bit pentru pozitia specificata.
public void SetArgb32Pixel(int x, int y, int argb32Color)Parameters
x int
Localizarea pixelului X.
y int
pixel și locație.
argb32Color int
Pixelul ARGB de 32 de biți pentru poziția specificată.
Examples
Următorul exemplu încărcă o imagine raster, și stabilește culoarea unui pixel arbitrar.
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(Cuvânt cheie, bool)
Puneți paleta de imagine.
public override void SetPalette(IColorPalette palette, bool updateColors)Parameters
palette IColorPalette
Paleta care trebuie stabilită.
updateColors bool
în cazul în care este setat la culori “reale” va fi actualizat în funcție de noua paletă; în caz contrar, indicele de culoare rămân inalterate.
SetPixel(int, int, culoare)
Setă un pixel de imagine pentru poziția specificată.
public void SetPixel(int x, int y, Color color)Parameters
x int
Localizarea pixelului X.
y int
pixel și locație.
color Color
Culoarea pixelului pentru poziția specificată.
Examples
Următorul exemplu încărcă o imagine raster, și stabilește culoarea unui pixel arbitrar.
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(dublu, dublu)
Setă rezoluția pentru acest Aspose.Imaging.RasterImage.
public virtual void SetResolution(double dpiX, double dpiY)Parameters
dpiX double
Rezoluția orizontală, în puncte pe inch, a Aspose.Imaging.RasterImage.
dpiY double
Rezoluția verticală, în puncte pe inch, a Aspose.Imaging.RasterImage.
Examples
Următorul exemplu arată cum să stabiliți rezoluția orizontală/verticală a unei imagini de raster.
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()
Convertează imaginea rasterului în bitmap.Această metodă nu este susținută în versiunile .Net7.0 și mai mari.
public virtual Bitmap ToBitmap()Returns
Bitmapul
UpdateDimensions(int, int)
Actualizează dimensiunile imaginii.
protected abstract void UpdateDimensions(int newWidth, int newHeight)Parameters
newWidth int
Noua dimensiune a imaginii.
newHeight int
Înălțimea noii imagini.
UpdateMetadata()
Actualizează metadata imaginii.
protected virtual void UpdateMetadata()WriteArgb32ScanLine(int, int[])
Scrie întreaga linie de scanare la indicele liniei de scanare specificate.
public void WriteArgb32ScanLine(int scanLineIndex, int[] argb32Pixels)Parameters
scanLineIndex int
Indicele bazat pe zero al liniei de scanare.
argb32Pixels int
[]
Culoarele ARGB de 32 de bite pot fi folosite pentru a scrie.
WriteScanLine(Culoare , culoare[])
Scrie întreaga linie de scanare la indicele liniei de scanare specificate.
public void WriteScanLine(int scanLineIndex, Color[] pixels)Parameters
scanLineIndex int
Indicele bazat pe zero al liniei de scanare.
pixels Color
[]
Culoarea pixelului se pregătește să scrie.
