Class RasterImage
Název místa: Aspose.Imaging Shromáždění: Aspose.Imaging.dll (25.4.0)
Představuje rasterový obrázek, který podporuje rasterové grafické operace.
public abstract class RasterImage : Image, IDisposable, IObjectWithBounds, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, IHasXmpData, IHasMetadataInheritance
object ← DisposableObject ← DataStreamSupporter ← Image ← RasterImage
Derived
Implements
IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata
Dědiční členové
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
Tento příklad ukazuje, jak načítat informace Pixel v Array typu barvy, manipulovat array a nastavit ji zpět na obrázek. k provedení těchto operací, tento příklad vytváří nový soubor obrazu (v formátu GIF) uisng Objekt 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()
Začíná nový příklad třídy Aspose.Imaging.RasterImage.
[JsonConstructor]
protected RasterImage()RasterImage(Ikolorová paleta)
Začíná nový příklad třídy Aspose.Imaging.RasterImage.
protected RasterImage(IColorPalette colorPalette)Parameters
colorPalette IColorPalette
barevná paleta.
Fields
xmpData
Metodika XMP
[JsonProperty]
protected XmpPacketWrapper xmpDataPolní hodnota
Properties
DataLoader
Obdržíte nebo nastavíte data loader.
[JsonProperty]
protected IRasterImageArgb32PixelLoader DataLoader { get; set; }Hodnota nemovitosti
HasAlpha
Obdrží hodnotu, která naznačuje, zda tato instance má alfa.
public virtual bool HasAlpha { get; }Hodnota nemovitosti
Examples
Následující příklad nahrává rasterové obrázky a vytiskne informace o formátu surových dat a alfa kanálu.
// 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=TrueNásledující příklad ukazuje, jak extrahovat informace o formátu surových dat a alfa kanálu z BMP obrazu.
// 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
Obdrží hodnotu, která ukazuje, zda obraz má průhlednou barvu.
public virtual bool HasTransparentColor { get; set; }Hodnota nemovitosti
HorizontalResolution
Obdržíte nebo nastavíte horizontální rozlišení, v pixlech za palec, tohoto Aspose.Imaging.RasterImage.
public virtual double HorizontalResolution { get; set; }Hodnota nemovitosti
Examples
Následující příklad ukazuje, jak nastavit horizontální/vertikální rozlišení rasterového obrazu.
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
Poznámka dle výchozího nastavení Tato hodnota je vždy 96 protože různé platformy nemohou vrátit rozlišení obrazovky.Můžete zvážit použití metody SetResolution pro aktualizaci obou hodnot rozlišení v jednom volán.
ImageOpacity
Obdrží opacitu tohoto obrazu.
public virtual float ImageOpacity { get; }Hodnota nemovitosti
IsRawDataAvailable
Obdrží hodnotu, která naznačuje, zda je k dispozici surová data.
public bool IsRawDataAvailable { get; }Hodnota nemovitosti
PremultiplyComponents
Obdrží nebo nastaví hodnotu, která naznačuje, zda musí být složky obrazu předmětně rozmnožovány.
public virtual bool PremultiplyComponents { get; set; }Hodnota nemovitosti
Examples
Následující příklad vytváří nový rasterový obrázek, ušetří specifikované poloprávné pixely, pak tyto pixely nabírá a získá konečné barvy v předmětném tvaru.
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
Obdržíte nebo nastavte přizpůsobený barevný konvertor
public IColorConverter RawCustomColorConverter { get; set; }Hodnota nemovitosti
RawDataFormat
Dostane surový datový formát.
public virtual PixelDataFormat RawDataFormat { get; }Hodnota nemovitosti
Examples
Následující příklad nahrává rasterové obrázky a vytiskne informace o formátu surových dat a alfa kanálu.
// 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=TrueTento příklad ukazuje, jak nahrát obrázek DJVU z souborového toku a vytisknout informace o stránkách.
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
Získáte aktuální nastavení surových dat. Upozorňujeme, že při používání těchto nastavení se data nahrazují bez konverze.
[JsonIgnore]
public RawDataSettings RawDataSettings { get; }Hodnota nemovitosti
RawFallbackIndex
Obdržíte nebo nastavte index padnutí k použití, když je index palety mimo hranice
public int RawFallbackIndex { get; set; }Hodnota nemovitosti
RawIndexedColorConverter
Obdržíte nebo nastavíte indexovaný barevný konvertor
public IIndexedColorConverter RawIndexedColorConverter { get; set; }Hodnota nemovitosti
RawLineSize
Obdrží velikost surové čáry v bytech.
public virtual int RawLineSize { get; }Hodnota nemovitosti
TransparentColor
Obdrží obraz transparentní barvu.
public virtual Color TransparentColor { get; set; }Hodnota nemovitosti
UpdateXmpData
Obdrží nebo nastaví hodnotu, která naznačuje, zda aktualizovat metadata XMP.
public virtual bool UpdateXmpData { get; set; }Hodnota nemovitosti
UsePalette
Obdrží hodnotu, která naznačuje, zda je paleta obrazu používána.
public override bool UsePalette { get; }Hodnota nemovitosti
UseRawData
Obdrží nebo nastaví hodnotu, která naznačuje, zda použít surové data nabíjení, když surové data nabíjení je k dispozici.
public virtual bool UseRawData { get; set; }Hodnota nemovitosti
VerticalResolution
Obdržíte nebo nastavíte vertikální rozlišení, v pixlech za palec, tohoto Aspose.Imaging.RasterImage.
public virtual double VerticalResolution { get; set; }Hodnota nemovitosti
Examples
Následující příklad ukazuje, jak nastavit horizontální/vertikální rozlišení rasterového obrazu.
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
Poznámka dle výchozího nastavení Tato hodnota je vždy 96 protože různé platformy nemohou vrátit rozlišení obrazovky.Můžete zvážit použití metody SetResolution pro aktualizaci obou hodnot rozlišení v jednom volán.
XmpData
Získáte nebo nastavíte metadata XMP.
public virtual XmpPacketWrapper XmpData { get; set; }Hodnota nemovitosti
Methods
AdjustBrightness(Int)
Přizpůsobení jasu obrazu.
public virtual void AdjustBrightness(int brightness)Parameters
brightness int
Světelná hodnota.
Examples
Následující příklad provádí jasnou korekci obrazu.
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(flotila)
Obrázek kontrast
public virtual void AdjustContrast(float contrast)Parameters
contrast float
Kontrastní hodnota (v rozmezí [-100; 100])
Examples
Následující příklad provádí kontrastní korekci obrazu.
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(plavba, plavba, plavba)
Gamma korekce obrazu.
public virtual void AdjustGamma(float gammaRed, float gammaGreen, float gammaBlue)Parameters
gammaRed float
Gamma pro koeficient červeného kanálu
gammaGreen float
Gamma pro koeficient zeleného kanálu
gammaBlue float
Gamma pro koeficient modrého kanálu
Examples
Následující příklad provádí gamma-korekci obrazu, který aplikuje různé koeficienty pro barevné komponenty.
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(flotila)
Gamma korekce obrazu.
public virtual void AdjustGamma(float gamma)Parameters
gamma float
Koeficient pro červené, zelené a modré kanály
Examples
Následující příklad provádí gamma korekci obrazu.
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(Dvojitý)
Binarizace obrazu pomocí Bradleyho adaptivního prahu algoritmu pomocí integrovaného prahu obrazu
public virtual void BinarizeBradley(double brightnessDifference)Parameters
brightnessDifference double
Rozdíl v jasu mezi pixelem a průměrem okna s x s pixelů soustředěných kolem tohoto pixelu.
BinarizeBradley(Dvojnásobný, int)
Binarizace obrazu pomocí Bradleyho adaptivního prahu algoritmu pomocí integrovaného prahu obrazu
public virtual void BinarizeBradley(double brightnessDifference, int windowSize)Parameters
brightnessDifference double
Rozdíl v jasu mezi pixelem a průměrem okna s x s pixelů soustředěných kolem tohoto pixelu.
windowSize int
Velikost okna s x s pixely soustředěné kolem tohoto pixelu
Examples
Následující příklad binarizuje rasterový obrázek s adaptativním algoritmem Bradleyho s uvedenou velikostí okna. binarizované obrázky obsahují pouze 2 barvy - černou a bílou.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Binarize the image with a brightness difference of 5. The brightness is a difference between a pixel and the average of an 10 x 10 window of pixels centered around this pixel.
rasterImage.BinarizeBradley(5, 10);
rasterImage.Save(dir + "sample.BinarizeBradley5_10x10.png");
}BinarizeFixed(byte)
Binarizace obrazu s předdefinovaným prahem
public virtual void BinarizeFixed(byte threshold)Parameters
threshold byte
Pokud odpovídající šedá hodnota pixelu je větší než hranici, hodnota 255 bude přidělována, 0 jinak.
Examples
Následující příklad binarizuje rasterový obrázek s předdefinovaným prahem. binarizované obrázky obsahují pouze 2 barvy - černou a bílou.
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()
Binarizace obrazu s Otsu hranici
public virtual void BinarizeOtsu()Examples
Následující příklad binarizuje raster obrázek s Otsu hranici. binaryzované obrázky obsahují pouze 2 barvy - černá a bíl.
string dir = "c:\\temp\\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Binarize the image with Otsu thresholding.
rasterImage.BinarizeOtsu();
rasterImage.Save(dir + "sample.BinarizeOtsu.png");
}Blend(Počítač, RasterImage, Rectangle, byte)
Mícháme tento obrázek s obrázkem overlay.
public virtual void Blend(Point origin, RasterImage overlay, Rectangle overlayArea, byte overlayAlpha = 255)Parameters
origin Point
Pozadí obrázku smíšeného původu.
overlay RasterImage
Přesný obrázek.
overlayArea Rectangle
Oblast převrácen.
overlayAlpha byte
Převážná alfa.
Blend(Článek, RasterImage, byte)
Mícháme tento obrázek s obrázkem overlay.
public void Blend(Point origin, RasterImage overlay, byte overlayAlpha = 255)Parameters
origin Point
Pozadí obrázku smíšeného původu.
overlay RasterImage
Přesný obrázek.
overlayAlpha byte
Převážná alfa.
Dither(Závěrečná metoda, int)
Výsledky se vyskytují na současném obrazu.
public void Dither(DitheringMethod ditheringMethod, int bitsCount)Parameters
ditheringMethod DitheringMethod
Způsob rozptýlen.
bitsCount int
Poslední bity počítají na dithering.
Examples
Následující příklad nabírá rasterový obrázek a provádí hranici a vlhkost s použitím různé hloubky palety.
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(DitheringMetoda, int, IColorPalette)
Výsledky se vyskytují na současném obrazu.
public abstract void Dither(DitheringMethod ditheringMethod, int bitsCount, IColorPalette customPalette)Parameters
ditheringMethod DitheringMethod
Způsob rozptýlen.
bitsCount int
Poslední bity počítají na dithering.
customPalette IColorPalette
Závěrečná paleta pro dytován.
Filter(Rektangle, FilterOptionsBase)
Filtruje určený rektangul.
public virtual void Filter(Rectangle rectangle, FilterOptionsBase options)Parameters
rectangle Rectangle
V pravém úhlu.
options FilterOptionsBase
Tyto možnosti.
Examples
Následující příklad se vztahuje na různé typy filtrů k rasterovému obrazu.
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(a int, int)
Obdrží obrázek 32-bitový ARGB pixel.
public int GetArgb32Pixel(int x, int y)Parameters
x int
Poloha pixelů x.
y int
Pixel a poloha.
Returns
32bitový ARGB pixel pro určené umístěn.
Examples
Následující příklad nahrává rasterový obrázek a získává barvu arbitrážního pixelu, který je reprezentován jako celková hodnota 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);
}Následující příklad ukazuje, jak image caching ovlivňuje výkonnost.V obecném případě se čtení cache dat provádí rychleji než čtení non-cache dat.
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)
Obdržíme výchozí rozsah 32-bitových ARGB pixel.
public int[] GetDefaultArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Připojte se k tomu, abyste získali pixely.
Returns
int []a[]
Předpokládané pixely se rozšiřuj.
GetDefaultPixels(Rektangle, IPartialArgb32PixelLoader)
Získejte výchozí pořadí pixelů pomocí částečného pixelového nabíječe.
public void GetDefaultPixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Připojte se k tomu, abyste získali pixely.
partialPixelLoader IPartialArgb32PixelLoader
stečný pixelový nabíje.
GetDefaultRawData(Rectangle, IPartialRawDataLoader a RawDataSettings)
Získáte výchozí surový datový řetězec pomocí částečného pixelového nabíječe.
public void GetDefaultRawData(Rectangle rectangle, IPartialRawDataLoader partialRawDataLoader, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Připojte se k tomu, abyste získali pixely.
partialRawDataLoader IPartialRawDataLoader
stečný surový datový nabíje.
rawDataSettings RawDataSettings
Nastavení surových dat.
GetDefaultRawData(Přehrávač, RawDataSettings)
Obdržíme výchozí surový datový řetěz.
public byte[] GetDefaultRawData(Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Pravý úhel k získání surových dat pro.
rawDataSettings RawDataSettings
Nastavení surových dat.
Returns
byte []a[]
Předpokládaný surový datový array.
GetModifyDate(Bolíček)
Obdrží datum a čas, kdy byl obrázek zdroje naposledy upraven.
public virtual DateTime GetModifyDate(bool useDefault)Parameters
useDefault bool
Pokud je nastaven na “pravdivý”, použijte informace z FileInfo jako výchozí hodnotu.
Returns
Datum a čas, kdy byl obrázek zdrojů naposledy změněn.
GetPixel(a int, int)
Obdržíme obrazový pixel.
public Color GetPixel(int x, int y)Parameters
x int
Poloha pixelů x.
y int
Pixel a poloha.
Returns
Barva pixelů pro stanovenou polohu.
Examples
Následující příklad nabírá rasterový obrázek a získá barvu svévolného pixelu.
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()
Zobrazí se v úhlém úhlu.Tato metoda se vztahuje na skenované textové dokumenty, aby se při skenování určil úhel skvrny.
public float GetSkewAngle()Returns
hlový úhl, ve stupních.
Grayscale()
Přeměna obrazu na jeho grayscale reprezentace
public virtual void Grayscale()Examples
Následující příklad přeměňuje barevný rasterový obrázek na jeho grayscale reprezentaci. Grayscale obrazy se skládají výhradně ze odstínů šedé a nesou pouze informace o intenzit.
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)
Nabízí 32bitové pixely ARGB.
public int[] LoadArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Připojte se k tomu, abyste přenášeli pixely.
Returns
int []a[]
32bitový rozhraní ARGB pixel.
Examples
Následující příklad ukazuje, jak načítat a zpracovávat pixely rasterového obrazu.Pixely jsou reprezentovány jako 32-bitové celkové hodnoty.
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)
Nabízí 64bitové pixely ARGB.
public long[] LoadArgb64Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Připojte se k tomu, abyste přenášeli pixely.
Returns
long []a[]
Nabízené 64bitové ARGB pixely.
Examples
Následující příklad ukazuje, jak načítat a zpracovávat pixely rasterového obrazu.Pixely jsou reprezentovány jako 64-bitové celkové hodnoty.
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)
Obsahuje pixely ve formátu CMYK.
public int[] LoadCmyk32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Připojte se k tomu, abyste přenášeli pixely.
Returns
int []a[]
Naložené CMYK pixely jsou přítomny jako 32-bitové hodnoty.
LoadCmykPixels(Rectangle)
Obsahuje pixely ve formátu CMYK.Prosím, použijte efektivnější metodu Aspose.Imaging.RasterImage.LoadCmyk32Pixels(Aspose.Imaging.Rectangle.
[Obsolete("Method is obsolete")]
public CmykColor[] LoadCmykPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Připojte se k tomu, abyste přenášeli pixely.
Returns
CmykColor []a[]
Přehrávač CMYK pixel.
LoadPartialArgb32Pixels(Rektangle, IPartialArgb32PixelLoader)
Nabízí 32bitové ARGB pixely částečně balíky.
public void LoadPartialArgb32Pixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
požadovaný obdélník.
partialPixelLoader IPartialArgb32PixelLoader
32bitový pixelový nabíječ ARGB.
Examples
Následující příklad ukazuje, jak načítat a zpracovávat pixely rasterového obrazu pomocí vlastního částečného procesoru. Například, zvážit problém počítání plně průhledných pixelů obrazu. Chcete-li počítat průhledné pixely pomocí částečného načítání mechanismu, se zavádí samostatná třída 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(Rektangle, IPartialArgb64PixelLoader)
Nabízí 64bitové ARGB pixely částečně balíky.
public void LoadPartialArgb64Pixels(Rectangle rectangle, IPartialArgb64PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
požadovaný obdélník.
partialPixelLoader IPartialArgb64PixelLoader
64bitový pixelový nabíječ ARGB.
LoadPartialPixels(Přehrávač, IPartialPixelLoader)
Přehrávejte pixely částečně balíky.
public void LoadPartialPixels(Rectangle desiredRectangle, IPartialPixelLoader pixelLoader)Parameters
desiredRectangle Rectangle
požadovaný obdélník.
pixelLoader IPartialPixelLoader
Pixelový nabíje.
Examples
Následující příklad ukazuje, jak načítat a zpracovávat pixely rasterového obrazu pomocí vlastního částečného procesoru. Například, zvážit problém počítání plně průhledných pixelů obrazu. Chcete-li počítat průhledně pomocí částečného načítání mechanismu, se zavádí samostatná třída TransparentPixelCounter implementing 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)
Nabízí se pixely.
public Color[] LoadPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Připojte se k tomu, abyste přenášeli pixely.
Returns
Color []a[]
Přihlášené pixely se rozkládaj.
Examples
Následující příklad ukazuje, jak načítat a zpracovávat pixely rasterového obrazu. Například, zvážit problém počítání plně transparentních pixelů obrazu.
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);
}Tento příklad ukazuje, jak načítat informace Pixel v Array typu barvy, manipulovat array a nastavit ji zpět na obrázek. k provedení těchto operací, tento příklad vytváří nový soubor obrazu (v formátu GIF) uisng Objekt 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)
Skládá surové údaje.
public void LoadRawData(Rectangle rectangle, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Pravý úhel pro nabití surových dat z.
rawDataSettings RawDataSettings
Upozorňujeme, že pokud údaje nejsou ve specifikovaném formátu, pak se provede data konverze.
rawDataLoader IPartialRawDataLoader
Původní data loader.
Examples
Následující příklad ukazuje, jak extrahovat pixely z dat surového obrazu pomocí RawDataSettings.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\GrayscaleWithAlpha.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
Aspose.Imaging.RawDataSettings settings = rasterImage.RawDataSettings;
TransparentPixelRawDataCounter rawDataLoader = new TransparentPixelRawDataCounter(settings);
// Load pixels for the whole image. Any rectangular part of the image can be specified as a parameter of the Aspose.Imaging.RasterImage.LoadRawData method.
rasterImage.LoadRawData(rasterImage.Bounds, settings, rawDataLoader);
System.Console.WriteLine("The number of fully transparent pixels is {0}", rawDataLoader.Count);
System.Console.WriteLine("The total number of pixels is {0}", image.Width * image.Height);
}
// In case of raw data, the counter may look like this:
/// <summary>
/// Counts the number of fully transparent pixels with alpha channel value of 0.
/// </summary>
private class TransparentPixelRawDataCounter : IPartialRawDataLoader
{
/// <summary>
/// The number of fully transparent pixels.
/// </summary>
private int count;
/// <summary>
/// The raw data settings of the loaded image.
/// </summary>
private Aspose.Imaging.RawDataSettings rawDataSettings;
/// <summary>
/// Gets the number of fully transparent pixels.
/// </summary>
public int Count
{
get { return this.count; }
}
/// <summary>
/// Initializes a new instance of the <see transparentpixelrawdatacounter=""></see> class.
/// </summary>
/// <param name="settings"/>The raw data settings allow to extract color components from raw data.
public TransparentPixelRawDataCounter(Aspose.Imaging.RawDataSettings settings)
{
this.rawDataSettings = settings;
this.count = 0;
}
/// <summary>
/// Processes the loaded raw data. This method is called back every time when a new portion of raw data is loaded.
/// </summary>
/// <param name="dataRectangle"/>The raw data rectangle.
/// <param name="data"/>The raw data.
/// <param name="start"/>The start data point.
/// <param name="end"/>The end data point.
public void Process(Aspose.Imaging.Rectangle dataRectangle, byte[] data, Aspose.Imaging.Point start, Aspose.Imaging.Point end)
{
int[] channelBits = this.rawDataSettings.PixelDataFormat.ChannelBits;
// Only simple formats are consdired here to simplify the code.
// Let's consider only images with 8 bits per sample.
for (int i = 0; i < channelBits.Length; i++)
{
if (channelBits[i] != 8)
{
throw new System.NotSupportedException();
}
}
switch (this.rawDataSettings.PixelDataFormat.PixelFormat)
{
case PixelFormat.Rgb:
case PixelFormat.Bgr:
{
if (channelBits.Length == 4)
{
// ARGB
for (int i = 0; i < data.Length; i += 4)
{
// The alpha channel is stored last, after the color components.
if (data[i + 3] == 0)
{
this.count++;
}
}
}
}
break;
case PixelFormat.Grayscale:
{
if (channelBits.Length == 2)
{
// Grayscale Alpha
for (int i = 0; i < data.Length; i += 2)
{
// The alpha channel is stored last, after the color components.
if (data[i + 1] == 0)
{
this.count++;
}
}
}
}
break;
default:
throw new System.ArgumentOutOfRangeException("PixelFormat");
}
}
/// <summary>
/// Processes the loaded raw data. This method is called back every time when a new portion of raw data is loaded.
/// </summary>
/// <param name="dataRectangle"/>The raw data rectangle.
/// <param name="data"/>The raw data.
/// <param name="start"/>The start data point.
/// <param name="end"/>The end data point.
/// <param name="loadOptions"/>The load options.
public void Process(Aspose.Imaging.Rectangle dataRectangle, byte[] data, Aspose.Imaging.Point start, Aspose.Imaging.Point end, Aspose.Imaging.LoadOptions loadOptions)
{
this.Process(dataRectangle, data, start, end);
}
}LoadRawData(Rectangle, Rectangle, RawDataSettings, IPartialRawDataLoader)
Skládá surové údaje.
public void LoadRawData(Rectangle rectangle, Rectangle destImageBounds, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Pravý úhel pro nabití surových dat z.
destImageBounds Rectangle
Obsahuje limity obrazu.
rawDataSettings RawDataSettings
Upozorňujeme, že pokud údaje nejsou ve specifikovaném formátu, pak se provede data konverze.
rawDataLoader IPartialRawDataLoader
Původní data loader.
NormalizeAngle()
normalizuje úhel.Tato metoda se vztahuje na skáněné textové dokumenty, aby se zbavili špinavého skenován.Tato metoda používá metody Aspose.Imaging.RasterImage.GetSkewAngle a Aspose.Imaging.RasterImage.Rotate(System.Single.
public void NormalizeAngle()NormalizeAngle(barva, barva)
normalizuje úhel.Tato metoda se vztahuje na skáněné textové dokumenty, aby se zbavili špinavého skenován.Tato metoda používá metody Aspose.Imaging.RasterImage.GetSkewAngle a Aspose.Imaging.RasterImage.Rotate(System.Single,System.Boolean,Aspose.Imaging.Color.
public virtual void NormalizeAngle(bool resizeProportionally, Color backgroundColor)Parameters
resizeProportionally bool
Pokud je nastaven na “skutečný”, změní se velikost obrazu podle rotačních rektangulárních (kornových bodů) projekcí v jiném případě, které zanechávají rozměry bez dotyku a pouze vnitřní obsah obrazu je rotačn.
backgroundColor Color
Barva pozad.
Examples
Skew je artefakt, který se může objevit během procesu skenování dokumentů, když se text / obrázky dokumentu otáčí v mírném úhlu. To může mít různé příčiny, ale nejčastější je, že papír se během skenování špatně umístí. Proto, deskew je proces detekce a opravy tohoto problému na skenovaných souborech (tj. bitmap), takže deskewed dokumenty budou mít text / obrázky správně a horizontálně upraven.
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()
Normalizuje histogram obrazu – upravuje hodnoty pixelů pro použití všech dostupných rozsah.
public virtual void NormalizeHistogram()ReadArgb32ScanLine(Int)
Přečtěte si celou řadu skenování podle specifikovaného indexového řádku skenován.
public int[] ReadArgb32ScanLine(int scanLineIndex)Parameters
scanLineIndex int
Zero-základní index skenovací linie.
Returns
int []a[]
Skenovací řádek 32-bitové barevné hodnoty ARGB.
ReadScanLine(Int)
Přečtěte si celou řadu skenování podle specifikovaného indexového řádku skenován.
public Color[] ReadScanLine(int scanLineIndex)Parameters
scanLineIndex int
Zero-základní index skenovací linie.
Returns
Color []a[]
Skenovací linie pixel barevné hodnoty řady.
ReleaseManagedResources()
Ujistěte se, že zde nejsou zveřejněny žádné nezveřejněné zdroje, protože mohou být již zveřejněny.
protected override void ReleaseManagedResources()RemoveMetadata()
Odstraňuje metadata tohoto obrazu nastavením této hodnoty Aspose.Imaging.Xmp.IHasXMPData. nulová.
public override void RemoveMetadata()ReplaceColor(Barva, byte a barva)
Změní jednu barvu za jinou s povolenou rozdílem a zachovává původní alfa hodnotu, aby ušetřila hladké okraje.
public void ReplaceColor(Color oldColor, byte oldColorDiff, Color newColor)Parameters
oldColor Color
Stará barva je třeba nahradit.
oldColorDiff byte
Dovolil rozdíl ve staré barvě, aby mohly rozšířit nahrazený barevný tón.
newColor Color
Nová barva nahradí starou.
ReplaceColor(bytu, bytu a int)
Změní jednu barvu za jinou s povolenou rozdílem a zachovává původní alfa hodnotu, aby ušetřila hladké okraje.
public virtual void ReplaceColor(int oldColorArgb, byte oldColorDiff, int newColorArgb)Parameters
oldColorArgb int
Stará barva ARGB hodnota by měla být nahrazena.
oldColorDiff byte
Dovolil rozdíl ve staré barvě, aby mohly rozšířit nahrazený barevný tón.
newColorArgb int
Nová barevná hodnota ARGB nahradí starou barvu.
ReplaceNonTransparentColors(Color)
Změní všechny neprozorné barvy novou barvou a zachovává původní alfa hodnotu, aby ušetřila hladké okraje.Poznámka: Pokud ji použijete na snímcích bez průhlednosti, všechny barvy budou nahrazeny jedním.
public void ReplaceNonTransparentColors(Color newColor)Parameters
newColor Color
Nová barva nahradí neprozornou barvu.
ReplaceNonTransparentColors(Int)
Změní všechny neprozorné barvy novou barvou a zachovává původní alfa hodnotu, aby ušetřila hladké okraje.Poznámka: Pokud ji použijete na snímcích bez průhlednosti, všechny barvy budou nahrazeny jedním.
public virtual void ReplaceNonTransparentColors(int newColorArgb)Parameters
newColorArgb int
Nová barevná hodnota ARGB nahradí neprohledné barvy.
Resize(snímky, snímky, snímky)
Obnovte obrázek rozšířenými možnostmi.
public override void Resize(int newWidth, int newHeight, ImageResizeSettings settings)Parameters
newWidth int
A nová šířka.
newHeight int
A nová výška.
settings ImageResizeSettings
Zpětné nastaven.
Examples
Tento příklad nabírá rasterový obrázek a resize ho pomocí různých resizing nastaven.
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(plavba, bool, barva)
Obrázek se otáčí kolem centra.
public virtual void Rotate(float angle, bool resizeProportionally, Color backgroundColor)Parameters
angle float
Otevírací úhel v stupních. pozitivní hodnoty se otáčí po hodin.
resizeProportionally bool
Pokud je nastaven na “skutečný”, změní se velikost obrazu podle rotačních rektangulárních (kornových bodů) projekcí v jiném případě, které zanechávají rozměry bez dotyku a pouze vnitřní obsah obrazu je rotačn.
backgroundColor Color
Barva pozad.
Exceptions
Neimplementované výjimky
Rotate(flotila)
Obrázek se otáčí kolem centra.
public override void Rotate(float angle)Parameters
angle float
Otevírací úhel v stupních. pozitivní hodnoty se otáčí po hodin.
Save(Stream, ImageOptionsBase, Rectangle)
Uloží data snímku do specifikovaného toku ve specifikovaném formátu souboru podle možností uložen.
public override void Save(Stream stream, ImageOptionsBase optionsBase, Rectangle boundsRectangle)Parameters
stream Stream
Průtok zachraňuje data obrázku na.
optionsBase ImageOptionsBase
Možnosti ušetřen.
boundsRectangle Rectangle
Obrázek cíle omezuje pravý úhel. Nastavení prázdného pravého úhlu pro použití zdrojových hranic.
SaveArgb32Pixels(Vzdálenost, int[])
Ušetří 32bitové ARGB pixely.
public void SaveArgb32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Připojte se k tomu, abyste zachránili pixely.
pixels int
[]a[]
32bitové ARGB pixely.
Examples
Následující příklad vyplňuje ústřední oblast rasterového obrazu černými pixely pomocí metody 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(Vzdálenost, int[])
Ušetřete pixely.
public void SaveCmyk32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Připojte se k tomu, abyste zachránili pixely.
pixels int
[]a[]
CMYK pixely jsou prezentovány jako 32-bitové celkové hodnoty.
Examples
Následující příklad vyplňuje ústřední oblast rasterového obrazu černými pixely pomocí metody 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(Rektangle, CmykColor[])
Ušetřete pixely.Prosím, použijte efektivnější metodu Aspose.Imaging.RasterImage.SaveCmyk32Pixels(Aspose.Imaging.Rectangle,System.Int32.
[Obsolete("Method is obsolete")]
public void SaveCmykPixels(Rectangle rectangle, CmykColor[] pixels)Parameters
rectangle Rectangle
Připojte se k tomu, abyste zachránili pixely.
pixels CmykColor
[]a[]
CMYK pixely se rozkládaj.
SavePixels(Pravý úhel, barva[])
Ušetřete pixely.
public void SavePixels(Rectangle rectangle, Color[] pixels)Parameters
rectangle Rectangle
Připojte se k tomu, abyste zachránili pixely.
pixels Color
[]a[]
Pixel se rozklád.
Examples
Následující příklad vyplňuje ústřední oblast rasterového obrazu černými pixely pomocí metody 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");
}Tento příklad ukazuje, jak načítat informace Pixel v Array typu barvy, manipulovat array a nastavit ji zpět na obrázek. k provedení těchto operací, tento příklad vytváří nový soubor obrazu (v formátu GIF) uisng Objekt 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(byte[]a[], int, Rectangle, RawDataSettings)
Ušetřete surové údaje.
public void SaveRawData(byte[] data, int dataOffset, Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
data byte
[]a[]
To jsou surové údaje.
dataOffset int
Začátek surových dat je odpočítán.
rectangle Rectangle
Původní datový rektangle.
rawDataSettings RawDataSettings
Tyto surové údaje nastaví údaje, které jsou v.
SetArgb32Pixel(Třeba int, int, int)
Nastavení obrázku 32-bitový ARGB pixel pro specifikovanou polohu.
public void SetArgb32Pixel(int x, int y, int argb32Color)Parameters
x int
Poloha pixelů x.
y int
Pixel a poloha.
argb32Color int
32bitový ARGB pixel pro stanovenou polohu.
Examples
Následující příklad nabírá rasterový obrázek a stanoví barvu svévolného pixelu.
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(IkolorPalette, Boolová)
Vytvořte paletu obrazu.
public override void SetPalette(IColorPalette palette, bool updateColors)Parameters
palette IColorPalette
Paleta je na nastaven.
updateColors bool
pokud je nastaven na “skutečné” barvy budou aktualizovány podle nové palety; jinak barevné indexy zůstávají nezměněny.
SetPixel(int, int, barva)
Vytvořte obrazový pixel pro stanovenou polohu.
public void SetPixel(int x, int y, Color color)Parameters
x int
Poloha pixelů x.
y int
Pixel a poloha.
color Color
Barva pixelů pro stanovenou polohu.
Examples
Následující příklad nabírá rasterový obrázek a stanoví barvu svévolného pixelu.
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(dvojí, dvojí)
Nastavení rozlišení pro tento Aspose.Imaging.RasterImage.
public virtual void SetResolution(double dpiX, double dpiY)Parameters
dpiX double
Horizontální rozlišení, v bodách za palec, Aspose.Imaging.RasterImage.
dpiY double
Vertikální rozlišení, v bodách za palec, Aspose.Imaging.RasterImage.
Examples
Následující příklad ukazuje, jak nastavit horizontální/vertikální rozlišení rasterového obrazu.
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()
Převod rasterového obrazu na bitmap.Tato metoda není podporována v verzích z .Net7.0 a vyšších
public virtual Bitmap ToBitmap()Returns
Bitmapová
UpdateDimensions(a int, int)
Aktualizace rozměrů obrazu.
protected abstract void UpdateDimensions(int newWidth, int newHeight)Parameters
newWidth int
Nové obrazové šířky.
newHeight int
Nová výška obrazu.
UpdateMetadata()
Aktualizujte metadata snímku.
protected virtual void UpdateMetadata()WriteArgb32ScanLine(a int, int[])
Celá linka skenování se skládá z indexu specifikované linky skenován.
public void WriteArgb32ScanLine(int scanLineIndex, int[] argb32Pixels)Parameters
scanLineIndex int
Zero-základní index skenovací linie.
argb32Pixels int
[]a[]
32bitové barvy ARGB se připravují na psan.
WriteScanLine(barva, barva[])
Celá linka skenování se skládá z indexu specifikované linky skenován.
public void WriteScanLine(int scanLineIndex, Color[] pixels)Parameters
scanLineIndex int
Zero-základní index skenovací linie.
pixels Color
[]a[]
Pixelové barvy se připravují na psan.
