Class RasterImage
Il nome: Aspose.Imaging Assemblea: Aspose.Imaging.dll (25.4.0)
Rappresenta un’immagine raster che supporta le operazioni grafiche 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
I membri ereditari
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
Questo esempio mostra come caricare le informazioni di Pixel in un Array di Tipo di colore, manipola l’array e la mette indietro all’immagine.Per eseguire queste operazioni, questo esempio crea un nuovo file di Immagine (in formato GIF) uisng oggetto MemoryStream.
//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()
Inizia una nuova instanza della classe Aspose.Imaging.RasterImage.
[JsonConstructor]
protected RasterImage()RasterImage(Il colore)
Inizia una nuova instanza della classe Aspose.Imaging.RasterImage.
protected RasterImage(IColorPalette colorPalette)Parameters
colorPalette IColorPalette
La paletta dei colori.
Fields
xmpdato
I metadati XMP
[JsonProperty]
protected XmpPacketWrapper xmpDataValore di campo
Properties
DataLoader
Riceve o impone il caricabatterie dati.
[JsonProperty]
protected IRasterImageArgb32PixelLoader DataLoader { get; set; }Valore di proprietà
HasAlpha
Riceve un valore indicando se questa instanza ha alfa.
public virtual bool HasAlpha { get; }Valore di proprietà
Examples
L’esempio seguente carica immagini di raster e imprima informazioni sul formato dei dati crudi e sul canale 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=TrueL’esempio seguente mostra come estrarre informazioni sul formato dei dati crudi e il canale alfa da un’immagine 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
Riceve un valore che indica se l’immagine ha un colore trasparente.
public virtual bool HasTransparentColor { get; set; }Valore di proprietà
HorizontalResolution
Riceve o impone la risoluzione orizzontale, in pixel per pollice, di questo Aspose.Imaging.RasterImage.
public virtual double HorizontalResolution { get; set; }Valore di proprietà
Examples
L’esempio seguente mostra come impostare la risoluzione orizzontale/vertica di un’immagine di 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
Nota per impostazione predefinita questo valore è sempre 96 poiché diverse piattaforme non possono restituire la risoluzione dello schermo. Puoi considerare l’uso del metodo SetResolution per aggiornare entrambi i valori di risoluzione in una singola chiamata.
ImageOpacity
Ricevi l’opacità di questa immagine.
public virtual float ImageOpacity { get; }Valore di proprietà
IsRawDataAvailable
Riceve un valore che indica se il caricamento dei dati crudi è disponibile.
public bool IsRawDataAvailable { get; }Valore di proprietà
PremultiplyComponents
Riceve o impone un valore che indica se i componenti dell’immagine devono essere premultipliati.
public virtual bool PremultiplyComponents { get; set; }Valore di proprietà
Examples
L’esempio seguente crea una nuova immagine di raster, salva i pixel semi-transparenti specificati, quindi carica questi pixeli e ottiene i colori finali nella forma premultiplicata.
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
Riceve o impone il convertitore di colore personalizzato
public IColorConverter RawCustomColorConverter { get; set; }Valore di proprietà
RawDataFormat
Ottieni il formato dei dati crudi.
public virtual PixelDataFormat RawDataFormat { get; }Valore di proprietà
Examples
L’esempio seguente carica immagini di raster e imprima informazioni sul formato dei dati crudi e sul canale 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=TrueQuesto esempio mostra come caricare un’immagine DJVU da un flusso di file e stampare informazioni sulle pagine.
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
Nota quando si utilizzano queste impostazioni i dati vengono caricati senza conversione.
[JsonIgnore]
public RawDataSettings RawDataSettings { get; }Valore di proprietà
RawFallbackIndex
Riceve o impone l’indice fallback per essere utilizzato quando l’indice di palette è fuori dai limiti
public int RawFallbackIndex { get; set; }Valore di proprietà
RawIndexedColorConverter
Ottenere o impostare il convertitore di colore indexato
public IIndexedColorConverter RawIndexedColorConverter { get; set; }Valore di proprietà
RawLineSize
Riceve la dimensione della linea cruda in byte.
public virtual int RawLineSize { get; }Valore di proprietà
TransparentColor
Riceve il colore trasparente dell’immagine.
public virtual Color TransparentColor { get; set; }Valore di proprietà
UpdateXmpData
Riceve o impone un valore che indica se aggiornare i metadati XMP.
public virtual bool UpdateXmpData { get; set; }Valore di proprietà
UsePalette
Riceve un valore che indica se la paletta immagine è utilizzata.
public override bool UsePalette { get; }Valore di proprietà
UseRawData
Riceve o impone un valore che indica se utilizzare il carico di dati crudi quando il carico di dati crudi è disponibile.
public virtual bool UseRawData { get; set; }Valore di proprietà
VerticalResolution
Riceve o impone la risoluzione verticale, in pixel per pollice, di questo Aspose.Imaging.RasterImage.
public virtual double VerticalResolution { get; set; }Valore di proprietà
Examples
L’esempio seguente mostra come impostare la risoluzione orizzontale/vertica di un’immagine di 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
Nota per impostazione predefinita questo valore è sempre 96 poiché diverse piattaforme non possono restituire la risoluzione dello schermo. Puoi considerare l’uso del metodo SetResolution per aggiornare entrambi i valori di risoluzione in una singola chiamata.
XmpData
Riceve o imposta i metadati XMP.
public virtual XmpPacketWrapper XmpData { get; set; }Valore di proprietà
Methods
AdjustBrightness(int)
Adattare una luminosità per l’immagine.
public virtual void AdjustBrightness(int brightness)Parameters
brightness int
Il valore della luminosità.
Examples
Il seguente esempio esegue la correzione di luminosità di un’immagine.
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)
Immagini contrasti
public virtual void AdjustContrast(float contrast)Parameters
contrast float
Valore di contrasto (in gamma [-100; 100])
Examples
Il seguente esempio esegue la correzione di contrasto di un’immagine.
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 e flotta)
Correzione gamma di un’immagine.
public virtual void AdjustGamma(float gammaRed, float gammaGreen, float gammaBlue)Parameters
gammaRed float
Gamma per il coefficiente del canale rosso
gammaGreen float
Gamma per il coefficiente del canale verde
gammaBlue float
Gamma per il coefficiente del canale blu
Examples
L’esempio seguente esegue la correzione gamma di un’immagine che applica coefficienti diversi per i componenti di colore.
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)
Correzione gamma di un’immagine.
public virtual void AdjustGamma(float gamma)Parameters
gamma float
Gamma per il coefficiente dei canali rosso, verde e blu
Examples
Il seguente esempio esegue la correzione gamma di un’immagine.
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(Doppio)
Binarizzazione di un’immagine utilizzando l’algoritmo di soglia adattabile di Bradley utilizzando il soglia immagine integrale
public virtual void BinarizeBradley(double brightnessDifference)Parameters
brightnessDifference double
La differenza di luminosità tra il pixel e la media di una finestra s x s di pixel centrati intorno a questo pixel.
BinarizeBradley(Il doppio int)
Binarizzazione di un’immagine utilizzando l’algoritmo di soglia adattabile di Bradley utilizzando il soglia immagine integrale
public virtual void BinarizeBradley(double brightnessDifference, int windowSize)Parameters
brightnessDifference double
La differenza di luminosità tra il pixel e la media di una finestra s x s di pixel centrati intorno a questo pixel.
windowSize int
La dimensione della finestra s x s dei pixel centrati intorno a questo pixel
Examples
L’esempio seguente binarisce un’immagine di raster con l’algoritmo adattivo di Bradley con la dimensione specifica della finestra. immagini binarie contengono solo 2 colori - nero e bianco.
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(di byte)
Binarizzazione di un’immagine con soglia predefinita
public virtual void BinarizeFixed(byte threshold)Parameters
threshold byte
Se il valore grigio corrispondente di un pixel è superiore al limite, un valore di 255 sarà assegnato a esso, 0 altrimenti.
Examples
L’esempio seguente binarisce un’immagine di raster con il limite predefinito. immagini binarie contengono solo 2 colori - nero e bianco.
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()
Binarizzazione di un’immagine con soglia Otsu
public virtual void BinarizeOtsu()Examples
L’esempio seguente binarisce un’immagine di raster con il margine Otsu. immagini binarie contengono solo 2 colori - nero e bianco.
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(Punto, RasterImage, Rectangle, byte)
Mescolare questo esempio di immagine con l’immagine overlay".
public virtual void Blend(Point origin, RasterImage overlay, Rectangle overlayArea, byte overlayAlpha = 255)Parameters
origin Point
L’immagine di sfondo miele origine.
overlay RasterImage
L’immagine di overlay.
overlayArea Rectangle
La zona di overlay.
overlayAlpha byte
L’alfabeto superato.
Blend(Punto, RasterImage, byte)
Mescolare questo esempio di immagine con l’immagine overlay".
public void Blend(Point origin, RasterImage overlay, byte overlayAlpha = 255)Parameters
origin Point
L’immagine di sfondo miele origine.
overlay RasterImage
L’immagine di overlay.
overlayAlpha byte
L’alfabeto superato.
Dither(Il metodo, int)
Performanze che si riflettono sull’immagine attuale.
public void Dither(DitheringMethod ditheringMethod, int bitsCount)Parameters
ditheringMethod DitheringMethod
Il metodo di diffusione.
bitsCount int
I bit finali contano per il dithering.
Examples
L’esempio seguente carica un’immagine di raster e esegue la soglia e il flusso di dithering utilizzando diverse profondità di palette.
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)
Performanze che si riflettono sull’immagine attuale.
public abstract void Dither(DitheringMethod ditheringMethod, int bitsCount, IColorPalette customPalette)Parameters
ditheringMethod DitheringMethod
Il metodo di diffusione.
bitsCount int
I bit finali contano per il dithering.
customPalette IColorPalette
La paletta personalizzata per il dithering.
Filter(Rettangolo, FilterOptionsBase)
Filtrare il rectangolo specificato.
public virtual void Filter(Rectangle rectangle, FilterOptionsBase options)Parameters
rectangle Rectangle
Il rectangolo .
options FilterOptionsBase
Le opzioni .
Examples
L’esempio seguente applica diversi tipi di filtri a un’immagine 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(di int, int)
Ricevi un’immagine con un pixel ARGB da 32 bit.
public int GetArgb32Pixel(int x, int y)Parameters
x int
La posizione del pixel x.
y int
Il pixel e la posizione.
Returns
Il 32-bit ARGB pixel per la posizione specificata.
Examples
L’esempio seguente carica un’immagine di raster e ottiene il colore di un pixel arbitrario rappresentato come un valore complessivo di 32 bit.
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);
}L’esempio seguente mostra come il caching immagine influisce sul rendimento.In generale, la lettura dei dati cache viene eseguita più velocemente di quella di non-caching dati.
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)
Riceve la gamma standard di 32-bit ARGB pixel.
public int[] GetDefaultArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Il rectangolo per ottenere i pixel.
Returns
int [ ]
I pixel predefiniti sono array.
GetDefaultPixels(Rettangolo, IPartialArgb32PixelLoader)
Ricevi i pixel predefiniti in ordine utilizzando un caricabatterie pixel parziale.
public void GetDefaultPixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Il rectangolo per ottenere i pixel.
partialPixelLoader IPartialArgb32PixelLoader
Il caricabatterie del pixel parziale.
GetDefaultRawData(Rectangle, IPartialRawDataLoader e RawDataSettings)
Riceve il file di dati crudi predefinito utilizzando un caricabatterie a pixel parziali.
public void GetDefaultRawData(Rectangle rectangle, IPartialRawDataLoader partialRawDataLoader, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Il rectangolo per ottenere i pixel.
partialRawDataLoader IPartialRawDataLoader
Il caricabatterie partiale dei dati crudi.
rawDataSettings RawDataSettings
Le impostazioni dei dati crudi.
GetDefaultRawData(Sito ufficiale: RawDataSettings)
Riceve l’array dei dati crudi predefiniti.
public byte[] GetDefaultRawData(Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Il rectangolo per ottenere i dati crudi.
rawDataSettings RawDataSettings
Le impostazioni dei dati crudi.
Returns
byte [ ]
Il default raw data array.
GetModifyDate(di bool)
Riceve la data e l’ora che l’immagine risorsa è stata modificata per l’ultima volta.
public virtual DateTime GetModifyDate(bool useDefault)Parameters
useDefault bool
se impostato a ’true’ utilizza le informazioni di FileInfo come valore predefinito.
Returns
La data e l’ora dell’immagine risorsa è stata modificata per l’ultima volta.
GetPixel(di int, int)
Ottieni un pixel di immagine.
public Color GetPixel(int x, int y)Parameters
x int
La posizione del pixel x.
y int
Il pixel e la posizione.
Returns
Il colore del pixel per la posizione specificata.
Examples
L’esempio seguente carica un’immagine di raster e ottiene il colore di un pixel arbitrario.
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()
Riceve l’angolo scudo.Questo metodo si applica ai documenti di testo scansionati, per determinare l’angolo di scavo durante la scansione.
public float GetSkewAngle()Returns
L’angolo scudo, in gradi.
Grayscale()
Trasformazione di un’immagine nella sua rappresentazione grayscale
public virtual void Grayscale()Examples
L’esempio seguente trasforma un’immagine di raster colorata alla sua rappresentazione griglia. le immagini di grayscale si compongono esclusivamente di ombre di gri e portano solo informazioni di intensità.
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)
Carica i 32 bit di pixel ARGB.
public int[] LoadArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Il rectangolo per caricare i pixel da.
Returns
int [ ]
Il caricato 32-bit ARGB pixel array.
Examples
L’esempio seguente mostra come caricare e elaborare i pixel di un’immagine di raster. I pixeli sono rappresentati come valori integrali a 32 bit. Ad esempio, considerare un problema di conteggio di pixeli completamente trasparenti di una immagine.
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)
Carica i 64 bit di pixel ARGB.
public long[] LoadArgb64Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Il rectangolo per caricare i pixel da.
Returns
long [ ]
Il caricato 64-bit ARGB pixel array.
Examples
L’esempio seguente mostra come caricare e elaborare i pixel di un’immagine di raster. I pixeli sono rappresentati come valori integrali di 64 bit. Ad esempio, considerare un problema di conteggio di pixeli completamente trasparenti di una immagine.
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)
Carica i pixel in formato CMYK.
public int[] LoadCmyk32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Il rectangolo per caricare i pixel da.
Returns
int [ ]
I pixel CMYK caricati sono presenti come valori 32-bit inateger.
LoadCmykPixels(Rectangle)
Carica i pixel in formato CMYK.Si prega di utilizzare più efficacemente il metodo Aspose.Imaging.RasterImage.LoadCmyk32Pixels(_W L17.Rectangle).
[Obsolete("Method is obsolete")]
public CmykColor[] LoadCmykPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Il rectangolo per caricare i pixel da.
Returns
CmykColor [ ]
Il carico di CMYK pixel array.
LoadPartialArgb32Pixels(Rettangolo, IPartialArgb32PixelLoader)
Carica 32-bit ARGB pixel parzialmente con pacchetti.
public void LoadPartialArgb32Pixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Il rectangolo desiderato.
partialPixelLoader IPartialArgb32PixelLoader
Il caricabatterie da 32 bit ARGB.
Examples
L’esempio seguente mostra come caricare e elaborare i pixel di un’immagine raster utilizzando il proprio processore parziale. Ad esempio, considerare un problema di conteggio di pixelli completamente trasparenti di una immagine. Per contare pixeli trasporti utilizzando il meccanismo di caricamento parziale, viene introdotta una classe separata TransparentArgb32PixelCounter implementing 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(Rettangolo, IPartialArgb64PixelLoader)
Carica 64 bit di pixel ARGB parzialmente con pacchetti.
public void LoadPartialArgb64Pixels(Rectangle rectangle, IPartialArgb64PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Il rectangolo desiderato.
partialPixelLoader IPartialArgb64PixelLoader
Il caricabatterie di 64 bit ARGB.
LoadPartialPixels(Rettangolo, IPartialPixelLoader)
Carica i pixel parzialmente con pacchetti.
public void LoadPartialPixels(Rectangle desiredRectangle, IPartialPixelLoader pixelLoader)Parameters
desiredRectangle Rectangle
Il rectangolo desiderato.
pixelLoader IPartialPixelLoader
Il pixel caricabatterie.
Examples
L’esempio seguente mostra come caricare e elaborare i pixel di un’immagine raster utilizzando il proprio processore parziale. Ad esempio, considerare un problema di conteggio di pixelli pienamente trasparenti di una immagine. Per contare attraverso il meccanismo di caricamento parziale, viene introdotta una classe separata di TransparentPixelCounter che implementa 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)
Carica i pixel.
public Color[] LoadPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Il rectangolo per caricare i pixel da.
Returns
Color [ ]
I pixel caricati sono array.
Examples
L’esempio seguente mostra come caricare e elaborare i pixel di un’immagine raster. ad esempio, considerare un problema di conteggio di pixelli completamente trasparenti di una immagine.
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);
}Questo esempio mostra come caricare le informazioni di Pixel in un Array di Tipo di colore, manipola l’array e la mette indietro all’immagine.Per eseguire queste operazioni, questo esempio crea un nuovo file di Immagine (in formato GIF) uisng oggetto MemoryStream.
//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)
Carica i dati crudi.
public void LoadRawData(Rectangle rectangle, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Il rectangolo per caricare i dati crudi da.
rawDataSettings RawDataSettings
Le impostazioni dei dati crudi da utilizzare per i dati caricati. Nota se i dati non sono nel formato specificato, la conversione dei dati verrà eseguita.
rawDataLoader IPartialRawDataLoader
Il caricabatterie dei dati crudi.
Examples
L’esempio seguente mostra come estrarre i pixel dai dati di immagine cruda utilizzando RawDataSettings. ad esempio, considerare un problema di conteggio di pixelli completamente trasparenti di un’immagine.
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)
Carica i dati crudi.
public void LoadRawData(Rectangle rectangle, Rectangle destImageBounds, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Il rectangolo per caricare i dati crudi da.
destImageBounds Rectangle
L’immagine è limitata.
rawDataSettings RawDataSettings
Le impostazioni dei dati crudi da utilizzare per i dati caricati. Nota se i dati non sono nel formato specificato, la conversione dei dati verrà eseguita.
rawDataLoader IPartialRawDataLoader
Il caricabatterie dei dati crudi.
NormalizeAngle()
Normalizza l’angolo.Questo metodo si applica ai documenti di testo scansionati per sbarazzarsi della scansione schiacciata.Questo metodo utilizza i metodi di Aspose.Imaging.RasterImage.GetSkewAngle e W L17.
public void NormalizeAngle()NormalizeAngle(Bool, colore)
Normalizza l’angolo.Questo metodo si applica ai documenti di testo scansionati per sbarazzarsi della scansione schiacciata.Questo metodo utilizza i metodi di Aspose.Imaging.RasterImage.GetSkewAngle e W L17 Raster Image .Rotate(System.Single, System.Boolean,Wl17__.Color).
public virtual void NormalizeAngle(bool resizeProportionally, Color backgroundColor)Parameters
resizeProportionally bool
se impostato a ’true’ avrai la dimensione dell’immagine modificata in base alle proiezioni rettangoli rotate (punti angolare) in caso diverso che lascia le dimensioni non toccate e solo i contenuti dell’immagine interna sono rotati.
backgroundColor Color
Il colore del background.
Examples
Skew è un artefatto che potrebbe apparire durante il processo di scansione dei documenti quando il testo/immagine del documento viene girato ad un angolo leggero. Può avere varie cause ma la cosa più comune è che il carta viene sbagliato durante uno scanamento. Pertanto, deskiew è il procedimento di rilevazione e riparazione di questo problema su file scansionati (cioè bitmap) in modo che i documentati scandati avranno il texto/imagini correttamente e orizzontalmente adattati.
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()
Normalizza l’istogramma dell’immagine - regola i valori dei pixel per utilizzare tutti i range disponibili.
public virtual void NormalizeHistogram()ReadArgb32ScanLine(int)
Leggi l’intera linea di scansione dall’indice della linea di scansione specificata.
public int[] ReadArgb32ScanLine(int scanLineIndex)Parameters
scanLineIndex int
Indice basato su zero della linea di scansione.
Returns
int [ ]
La linea di scansione 32-bit ARGB valori colorati.
ReadScanLine(int)
Leggi l’intera linea di scansione dall’indice della linea di scansione specificata.
public Color[] ReadScanLine(int scanLineIndex)Parameters
scanLineIndex int
Indice basato su zero della linea di scansione.
Returns
Color [ ]
La linea di scansione pixel valori colorati.
ReleaseManagedResources()
Assicurati di non rilasciare risorse non gestite qui, poiché potrebbero essere già state rilasciate.
protected override void ReleaseManagedResources()RemoveMetadata()
Rimuove questi metadati di instanza dell’immagine impostando questo valore Aspose.Imaging.Xmp.IHasXMPData. Null.
public override void RemoveMetadata()ReplaceColor(Colore, byte e colore)
Sostituisce un colore all’altro con la differenza consentita e conserva il valore alfa originale per salvare bordi lisci.
public void ReplaceColor(Color oldColor, byte oldColorDiff, Color newColor)Parameters
oldColor Color
Il vecchio colore da sostituire.
oldColorDiff byte
Permesso di differenza nel vecchio colore per essere in grado di ampliare il tono di colore sostituito.
newColor Color
Nuovo colore per sostituire il vecchio colore.
ReplaceColor(int, byte, int)
Sostituisce un colore all’altro con la differenza consentita e conserva il valore alfa originale per salvare bordi lisci.
public virtual void ReplaceColor(int oldColorArgb, byte oldColorDiff, int newColorArgb)Parameters
oldColorArgb int
Il vecchio valore di colore ARGB deve essere sostituito.
oldColorDiff byte
Permesso di differenza nel vecchio colore per essere in grado di ampliare il tono di colore sostituito.
newColorArgb int
Nuovo valore colore ARGB per sostituire il vecchio colore con.
ReplaceNonTransparentColors(Color)
Sostituisce tutti i colori non trasparenti con un nuovo colore e conserva il valore alfa originale per salvare i confini lisci.Nota: se si utilizza su immagini senza trasparenza, tutti i colori saranno sostituiti da uno unico.
public void ReplaceNonTransparentColors(Color newColor)Parameters
newColor Color
Nuovo colore per sostituire i colori non trasparenti.
ReplaceNonTransparentColors(int)
Sostituisce tutti i colori non trasparenti con un nuovo colore e conserva il valore alfa originale per salvare i confini lisci.Nota: se si utilizza su immagini senza trasparenza, tutti i colori saranno sostituiti da uno unico.
public virtual void ReplaceNonTransparentColors(int newColorArgb)Parameters
newColorArgb int
Nuovo valore di colore ARGB per sostituire i colori non trasparenti con.
Resize(int, int, immagineResizeSettings)
Ristrutturare l’immagine con le opzioni estese.
public override void Resize(int newWidth, int newHeight, ImageResizeSettings settings)Parameters
newWidth int
La nuova larghezza.
newHeight int
La nuova altezza.
settings ImageResizeSettings
Il ripristino delle impostazioni.
Examples
Questo esempio carica un’immagine di raster e la risuona utilizzando varie impostazioni di rigenerazione.
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(Flotta, Bool, Colore)
Immagini girate intorno al centro.
public virtual void Rotate(float angle, bool resizeProportionally, Color backgroundColor)Parameters
angle float
L’angolo di rotazione in gradi. valori positivi gireranno in orologio.
resizeProportionally bool
se impostato a ’true’ avrai la dimensione dell’immagine modificata in base alle proiezioni rettangoli rotate (punti angolare) in caso diverso che lascia le dimensioni non toccate e solo i contenuti dell’immagine interna sono rotati.
backgroundColor Color
Il colore del background.
Exceptions
eccezioni non applicate
Rotate(flotta)
Immagini girate intorno al centro.
public override void Rotate(float angle)Parameters
angle float
L’angolo di rotazione in gradi. valori positivi gireranno in orologio.
Save(Stream, ImmaginiOpzioniBase, Rectangle)
Salva i dati dell’immagine al flusso specificato nel formato file specificato in base alle opzioni di salvataggio.
public override void Save(Stream stream, ImageOptionsBase optionsBase, Rectangle boundsRectangle)Parameters
stream Stream
Il flusso per salvare i dati dell’immagine.
optionsBase ImageOptionsBase
Le opzioni di risparmio.
boundsRectangle Rectangle
L’immagine di destinazione limita il rettangolo. impostare il rettangolo vuoto per utilizzare i limiti sorgente.
SaveArgb32Pixels(Il ritorno, int[])
Conserva i 32-bit ARGB pixel.
public void SaveArgb32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Il rectangolo per salvare i pixel.
pixels int
[ ]
Il 32-bit di ARGB pixel.
Examples
L’esempio seguente riempie l’area centrale di un’immagine raster con pixel neri utilizzando il metodo 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(Il ritorno, int[])
Salva i pixel.
public void SaveCmyk32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Il rectangolo per salvare i pixel.
pixels int
[ ]
I pixel CMYK presentati come i valori integrali 32-bit.
Examples
L’esempio seguente riempie l’area centrale di un’immagine di raster con pixel neri utilizzando il metodo 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(Rettangolo, CmykColor[])
Salva i pixel.Si prega di utilizzare più efficacemente il metodo Aspose.Imaging.RasterImage.SaveCmyk32Pixels(_W L17.Rectangle,System.Int32[]).
[Obsolete("Method is obsolete")]
public void SaveCmykPixels(Rectangle rectangle, CmykColor[] pixels)Parameters
rectangle Rectangle
Il rectangolo per salvare i pixel.
pixels CmykColor
[ ]
I pixel CMYK sono array.
SavePixels(Rettangolo, colore[])
Salva i pixel.
public void SavePixels(Rectangle rectangle, Color[] pixels)Parameters
rectangle Rectangle
Il rectangolo per salvare i pixel.
pixels Color
[ ]
I pixel sono arredati.
Examples
L’esempio seguente riempie l’area centrale di un’immagine di raster con pixel neri utilizzando il metodo 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");
}Questo esempio mostra come caricare le informazioni di Pixel in un Array di Tipo di colore, manipola l’array e la mette indietro all’immagine.Per eseguire queste operazioni, questo esempio crea un nuovo file di Immagine (in formato GIF) uisng oggetto MemoryStream.
//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(di byte[ ], int, Rectangle, RawDataSettings)
Conservare i dati crudi.
public void SaveRawData(byte[] data, int dataOffset, Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
data byte
[ ]
I dati crudi.
dataOffset int
Iniziamo con i dati crudi.
rectangle Rectangle
Il rectangolo dei dati crudi.
rawDataSettings RawDataSettings
I dati crudi sono le impostazioni che i dati sono in.
SetArgb32Pixel(int, int, int)
Imposta un pixel ARGB 32-bit per la posizione specificata.
public void SetArgb32Pixel(int x, int y, int argb32Color)Parameters
x int
La posizione del pixel x.
y int
Il pixel e la posizione.
argb32Color int
Il 32-bit ARGB pixel per la posizione specificata.
Examples
L’esempio seguente carica un’immagine raster, e impone il colore di un pixel arbitrario.
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)
Inserisci la paletta dell’immagine.
public override void SetPalette(IColorPalette palette, bool updateColors)Parameters
palette IColorPalette
La paletta da impostare.
updateColors bool
se impostati a colori ‘giuri’ verrà aggiornato in base alla nuova paletta; altrimenti gli indici di colore rimangono invariati. Nota che gli indici invariati possono crollare l’immagine sul carico se alcuni indici non hanno entrate di paletta corrispondenti.
SetPixel(int, int, colore)
Inserisci un pixel immagine per la posizione specificata.
public void SetPixel(int x, int y, Color color)Parameters
x int
La posizione del pixel x.
y int
Il pixel e la posizione.
color Color
Il colore del pixel per la posizione specificata.
Examples
L’esempio seguente carica un’immagine raster, e impone il colore di un pixel arbitrario.
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(Il doppio, il doppio)
Inserisci la risoluzione per questo Aspose.Imaging.RasterImage.
public virtual void SetResolution(double dpiX, double dpiY)Parameters
dpiX double
La risoluzione orizzontale, in punti per pollice, del Aspose.Imaging.RasterImage.
dpiY double
La risoluzione verticale, in punti per pollice, del Aspose.Imaging.RasterImage.
Examples
L’esempio seguente mostra come impostare la risoluzione orizzontale/vertica di un’immagine di 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()
Convertire l’immagine del raster in bitmap.Questo metodo non è supportato in versioni di .Net7.0 o superiori
public virtual Bitmap ToBitmap()Returns
Il bitmap
UpdateDimensions(di int, int)
Aggiornare le dimensioni dell’immagine.
protected abstract void UpdateDimensions(int newWidth, int newHeight)Parameters
newWidth int
La nuova larghezza dell’immagine.
newHeight int
L’altezza della nuova immagine.
UpdateMetadata()
Aggiornare i metadati di immagine.
protected virtual void UpdateMetadata()WriteArgb32ScanLine(di int, int[])
Inserisci l’intera linea di scansione all’indice della linea di scansione specifica.
public void WriteArgb32ScanLine(int scanLineIndex, int[] argb32Pixels)Parameters
scanLineIndex int
Indice basato su zero della linea di scansione.
argb32Pixels int
[ ]
I colori 32-bit ARGB sono disponibili per scrivere.
WriteScanLine(Il colore, colore[])
Inserisci l’intera linea di scansione all’indice della linea di scansione specifica.
public void WriteScanLine(int scanLineIndex, Color[] pixels)Parameters
scanLineIndex int
Indice basato su zero della linea di scansione.
pixels Color
[ ]
I colori del pixel possono scrivere.
