Class RasterImage
ja nimityö: Aspose.Imaging Kokoelma: Aspose.Imaging.dll (25.4.0)
Se edustaa raster-kuvaa, joka tukee raster-grafiikkaoperaatioita.
public abstract class RasterImage : Image, IDisposable, IObjectWithBounds, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, IHasXmpData, IHasMetadataInheritance
object ← DisposableObject ← DataStreamSupporter ← Image ← RasterImage
Derived
Implements
IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata
Perintöjäsenet
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
Tämä esimerkki näyttää, miten Lataa Pixel-tietoja tyypin värijärjestelmässä, manipuloi järjestelmää ja asettaa sen takaisin kuviin. Näiden toimintojen suorittamiseksi tämä esimerki luo uuden kuvan tiedoston (GIF-muodossa) uisng MemoryStream-objekti.
//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()
Aloitetaan uusi esimerkki Aspose.Imaging.RasterImage luokasta.
[JsonConstructor]
protected RasterImage()RasterImage(ICOLORPALETTI)
Aloitetaan uusi esimerkki Aspose.Imaging.RasterImage luokasta.
protected RasterImage(IColorPalette colorPalette)Parameters
colorPalette IColorPalette
Ja väri paletti.
Fields
xmpData
XMP metatiedot
[JsonProperty]
protected XmpPacketWrapper xmpDatakentän arvo
Properties
DataLoader
Saat tai asettaa tietojen lataajan.
[JsonProperty]
protected IRasterImageArgb32PixelLoader DataLoader { get; set; }Omistuksen arvo
HasAlpha
Saat arvon, joka osoittaa, onko tässä tapauksessa alfa.
public virtual bool HasAlpha { get; }Omistuksen arvo
Examples
Seuraavassa esimerkissä ladataan raster-kuvia ja tulostetaan tietoa raaka-tietomuodosta ja alfa-kanavasta.
// 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=TrueSeuraava esimerkki näyttää, miten tietoa raaka-data muodossa ja alfa kanava BMP kuvan.
// 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
Saat arvon, joka osoittaa, onko kuvalla läpinäkyvä väri.
public virtual bool HasTransparentColor { get; set; }Omistuksen arvo
HorizontalResolution
Saa tai asettaa tämän Aspose.Imaging.RasterImagen horisontaalisen resoluution pikseleinä tuumaa kohti.
public virtual double HorizontalResolution { get; set; }Omistuksen arvo
Examples
Seuraava esimerkki osoittaa, miten asetetaan horisontaalinen/vertikaali resoluutio raster kuvan.
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
Oletuksena tämä arvo on aina 96 koska eri alustat eivät voi palauttaa näytön resoluution. Voit harkita käyttämällä SetResolution -menetelmää päivittää molemmat resoluution arvot yhden puhelun aikana.
ImageOpacity
Tällainen kuva on epäselvä.
public virtual float ImageOpacity { get; }Omistuksen arvo
IsRawDataAvailable
Saat arvon, joka osoittaa, onko raaka-tietojen lataus saatavilla.
public bool IsRawDataAvailable { get; }Omistuksen arvo
PremultiplyComponents
Se saa tai asettaa arvon, joka osoittaa, onko kuvan komponenttien oltava ennakkoluuloisia.
public virtual bool PremultiplyComponents { get; set; }Omistuksen arvo
Examples
Seuraava esimerkki luo uuden raster-kuvan, säästää määritellyt puoli läpinäkyvät pikselit, sitten ladata ne pikselit ja saada lopulliset värit ennakkoluuloisessa muodossa.
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
Valitse tai asettaa räätälöity väri muunnin
public IColorConverter RawCustomColorConverter { get; set; }Omistuksen arvo
RawDataFormat
Saat raaka-aineiden muodon.
public virtual PixelDataFormat RawDataFormat { get; }Omistuksen arvo
Examples
Seuraavassa esimerkissä ladataan raster-kuvia ja tulostetaan tietoa raaka-tietomuodosta ja alfa-kanavasta.
// 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=TrueTämä esimerkki näyttää, miten ladata DJVU-kuva tiedoston virtauksesta ja tulostaa tietoja sivuista.
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
Saat nykyiset raaka-aineasetukset. Huomaa, että näiden asetusten käytön aikana tiedot latautuvat ilman muuntamista.
[JsonIgnore]
public RawDataSettings RawDataSettings { get; }Omistuksen arvo
RawFallbackIndex
Saa tai asettaa laskuindeksin käytettäväksi, kun palettiindeksi ei ole rajoja
public int RawFallbackIndex { get; set; }Omistuksen arvo
RawIndexedColorConverter
Antaa tai asettaa indeksoidun värimuunnin
public IIndexedColorConverter RawIndexedColorConverter { get; set; }Omistuksen arvo
RawLineSize
Se saa raaka-linjan koon byteina.
public virtual int RawLineSize { get; }Omistuksen arvo
TransparentColor
Se saa kuvan läpinäkyvästä väristä.
public virtual Color TransparentColor { get; set; }Omistuksen arvo
UpdateXmpData
Saat tai asettaa arvon, joka osoittaa, päivitetäänkö XMP-metatietoja.
public virtual bool UpdateXmpData { get; set; }Omistuksen arvo
UsePalette
Saat arvon, joka osoittaa, käytetäänkö kuvan paletta.
public override bool UsePalette { get; }Omistuksen arvo
UseRawData
Se saa tai asettaa arvon, joka osoittaa, käytetäänkö raaka-aineen latausta, kun raaka-aineen lataus on käytettävissä.
public virtual bool UseRawData { get; set; }Omistuksen arvo
VerticalResolution
Saa tai asettaa tämän Aspose.Imaging.RasterImagen vertikaalinen resoluutio pikseleinä tuumaa kohden.
public virtual double VerticalResolution { get; set; }Omistuksen arvo
Examples
Seuraava esimerkki osoittaa, miten asetetaan horisontaalinen/vertikaali resoluutio raster kuvan.
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
Oletuksena tämä arvo on aina 96 koska eri alustat eivät voi palauttaa näytön resoluution. Voit harkita käyttämällä SetResolution -menetelmää päivittää molemmat resoluution arvot yhden puhelun aikana.
XmpData
Saa tai asettaa XMP-metatiedot.
public virtual XmpPacketWrapper XmpData { get; set; }Omistuksen arvo
Methods
AdjustBrightness(Sisältää)
Valitse kuvan kirkkauden mukauttaminen.
public virtual void AdjustBrightness(int brightness)Parameters
brightness int
ja kirkkauden arvo.
Examples
Seuraava esimerkki suorittaa kuvan kirkkauden korjauksen.
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(Flottaa)
Kuvan vastakohta
public virtual void AdjustContrast(float contrast)Parameters
contrast float
Kontrastin arvo (sarjassa [-100; 100])
Examples
Seuraava esimerkki suorittaa kuvan kontrastin korjauksen.
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(laivasto, laivasto ja laivasto)
Gamma-korjaus kuvasta
public virtual void AdjustGamma(float gammaRed, float gammaGreen, float gammaBlue)Parameters
gammaRed float
Punaisen kanavan koefficientti
gammaGreen float
Gamma vihreän kanavan koefficientille
gammaBlue float
Gamma sininen kanava koefficientti
Examples
Seuraava esimerkki suorittaa kuvan gamma-korjauksen, jossa värikomponenteille sovelletaan erilaisia koeficienteja.
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(Flottaa)
Gamma-korjaus kuvasta
public virtual void AdjustGamma(float gamma)Parameters
gamma float
Punaiset, vihreät ja siniset kanavat
Examples
Seuraava esimerkki suorittaa kuvan gamma-korjauksen.
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(Kaksinkertainen)
Binarisaatio kuvan käyttäen Bradleyn adaptiivisen raja-arvon algoritmia käyttäen integroitua kuvan raja-arvoa
public virtual void BinarizeBradley(double brightnessDifference)Parameters
brightnessDifference double
Pikselin ja s x s ikkunan välinen kirkkauden ero keskittyy tähän pikseliin.
BinarizeBradley(Kaksinkertainen int)
Binarisaatio kuvan käyttäen Bradleyn adaptiivisen raja-arvon algoritmia käyttäen integroitua kuvan raja-arvoa
public virtual void BinarizeBradley(double brightnessDifference, int windowSize)Parameters
brightnessDifference double
Pikselin ja s x s ikkunan välinen kirkkauden ero keskittyy tähän pikseliin.
windowSize int
S x s ikkunan koko pikselit keskittyvät tämän pikselin ympärille
Examples
Seuraava esimerkki binarisoi rasterin kuvan Bradleyn adaptiivisella raja-arvon algoritmilla, jossa on määritelty ikkunan koko.
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(bytejä)
Binarisaatio kuvasta, jolla on etukäteen määritelty raja
public virtual void BinarizeFixed(byte threshold)Parameters
threshold byte
Jos pixelin vastaava keltainen arvo on suurempi kuin raja, siihen määrätään 255 arvo, 0 muutoin.
Examples
Seuraava esimerkki binarisoi rasterin kuvan etukäteen määritellyllä kynnyksellä. binaryttiset kuvat sisältävät vain 2 väriä - musta ja valkoinen.
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()
Binarisaatio kuvan otsu rajauksella
public virtual void BinarizeOtsu()Examples
Seuraava esimerkki binarisoi rasterin kuvan Otsun kynnyksellä. binaryttiset kuvat sisältävät vain 2 väriä - musta ja valkoinen.
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(Pisteet, RasterImage, Rectangle, byte)
Sekoita tämä kuvan esimerkki overlay" -kuvan kanssa.
public virtual void Blend(Point origin, RasterImage overlay, Rectangle overlayArea, byte overlayAlpha = 255)Parameters
origin Point
Taustakuva sekoittaa alkuperää.
overlay RasterImage
Ylivoimainen kuva on.
overlayArea Rectangle
ylijäämätön alue.
overlayAlpha byte
Ylivoimainen alfa.
Blend(Pisteet, RasterImage, byte)
Sekoita tämä kuvan esimerkki overlay" -kuvan kanssa.
public void Blend(Point origin, RasterImage overlay, byte overlayAlpha = 255)Parameters
origin Point
Taustakuva sekoittaa alkuperää.
overlay RasterImage
Ylivoimainen kuva on.
overlayAlpha byte
Ylivoimainen alfa.
Dither(TietäminenMetodi, int)
Näytetään nykyisessä kuvassa.
public void Dither(DitheringMethod ditheringMethod, int bitsCount)Parameters
ditheringMethod DitheringMethod
Siirtymisen menetelmä on.
bitsCount int
Lopulliset bitit lasketaan mittaamiseen.
Examples
Seuraava esimerkki laittaa rasterin kuvan ja suorittaa kynnysarvon ja virtaamisen eri paletin syvyyden avulla.
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(DitheringMetodi, int, IColorPalette)
Näytetään nykyisessä kuvassa.
public abstract void Dither(DitheringMethod ditheringMethod, int bitsCount, IColorPalette customPalette)Parameters
ditheringMethod DitheringMethod
Siirtymisen menetelmä on.
bitsCount int
Lopulliset bitit lasketaan mittaamiseen.
customPalette IColorPalette
Käytettävissä oleva paletti Ditheringille.
Filter(Rectangle ja FilterOptionsBase)
Suodatetaan määritelty reaktio.
public virtual void Filter(Rectangle rectangle, FilterOptionsBase options)Parameters
rectangle Rectangle
Se on oikea.
options FilterOptionsBase
ja vaihtoehtoja.
Examples
Seuraava esimerkki soveltaa erilaisia suodattimia raster-kuvaan.
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(Sisä, sisä)
Saat 32-bittisen ARGB-pikselin kuvan.
public int GetArgb32Pixel(int x, int y)Parameters
x int
Pikselin x sijainti.
y int
Pikseli ja sijainti.
Returns
32-bittinen ARGB-pikseli määritellyn sijainnin osalta.
Examples
Seuraava esimerkki lataa raster-kuvan ja saa tahallisen pikselin värin, joka edustetaan 32-bittisenä kokonaisarvona.
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);
}Seuraava esimerkki osoittaa, miten kuvan kaavio vaikuttaa suorituskykyyn. Yleisesti ottaen kaaviettujen tietojen lukeminen suoritetaan nopeammin kuin ei-kaavietut tiedot.
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)
Saat oletusarvoisen 32-bittisen ARGB-pikselin järjestelmän.
public int[] GetDefaultArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Oikea kulma saada pikselejä.
Returns
int []
Oletusarvoiset pikselit array.
GetDefaultPixels(Rectangle ja IPartialArgb32PixelLoader)
Saat oletusarvoiset pikselit järjestetään käyttämällä osittaista pikselin latainta.
public void GetDefaultPixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Oikea kulma saada pikselejä.
partialPixelLoader IPartialArgb32PixelLoader
Pikselin osittainen lataus.
GetDefaultRawData(Rectangle, IPartialRawDataLoader, RawDataSettings)
Saat oletusarvoisen raaka-aineiston käyttämällä osittaista pikselin latainta.
public void GetDefaultRawData(Rectangle rectangle, IPartialRawDataLoader partialRawDataLoader, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Oikea kulma saada pikselejä.
partialRawDataLoader IPartialRawDataLoader
Osittainen raaka-tietojen lataus.
rawDataSettings RawDataSettings
raaka-aineita koskevat asetukset
GetDefaultRawData(Rectangle ja RawDataSettings)
Saat oletusarvoisen raaka-aineiston.
public byte[] GetDefaultRawData(Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
rectangle Rectangle
Oikea kulma saada raaka-aineita.
rawDataSettings RawDataSettings
raaka-aineita koskevat asetukset
Returns
byte []
Käytettävissä olevien raaka-aineiden käyttö.
GetModifyDate(Booli)
Saat päivämäärän ja ajan, jolloin resurssikuva on viimeksi muokattu.
public virtual DateTime GetModifyDate(bool useDefault)Parameters
useDefault bool
Jos asetat “todelliseksi”, käytä FileInfo -tietoja oletusarvoina.
Returns
Kuvan päivämäärä ja aika muutettiin viimeksi.
GetPixel(Sisä, sisä)
Se saa kuvan pixelin.
public Color GetPixel(int x, int y)Parameters
x int
Pikselin x sijainti.
y int
Pikseli ja sijainti.
Returns
Pikselin väri määritellyn sijainnin osalta.
Examples
Seuraava esimerkki lataa raster-kuvan ja saa tahallisen pikselin värin.
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()
Saa kaivoksen kulma.Tätä menetelmää sovelletaan skannattuihin tekstiasiakirjoihin, jotta skannatessasi määritetään kaareva kulma.
public float GetSkewAngle()Returns
Kynttilän kulma, asteikolla
Grayscale()
Kuvan muuntaminen sen grayscale edustukseen
public virtual void Grayscale()Examples
Seuraava esimerkki muuttaa värillisen rasterin kuvan sen harmaaseen kuvaukseen. Grayscale-kuvat koostuvat yksinomaan harmaa sävyistä ja tuovat vain intensiteetin tietoja.
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)
Lataa 32-bittiset ARGB-pikselit
public int[] LoadArgb32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Oikea kulma ladata pikselejä pois.
Returns
int []
Ladattu 32-bittinen ARGB-pikseli.
Examples
Seuraava esimerkki näyttää, miten ladata ja käsitellä pikselejä raster-kuvan. Pikselit edustetaan 32-bittinä kokonaisarvoina. Esimerkiksi, harkitse ongelmaa laskea täysin läpinäkyviä pikselit kuvaa.
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)
Lataa 64-bittiset ARGB-pikselit.
public long[] LoadArgb64Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Oikea kulma ladata pikselejä pois.
Returns
long []
Ladattu 64-bittinen ARGB-pikseli.
Examples
Seuraava esimerkki näyttää, miten ladata ja käsitellä pikselejä raster kuvan. Pikselit esitetään 64-bittinä kokonaisarvoina. Esimerkiksi, harkitse ongelma laskea täysin läpinäkyviä pikselit kuvaa.
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)
Lataa pikselit CMYK-muodossa.
public int[] LoadCmyk32Pixels(Rectangle rectangle)Parameters
rectangle Rectangle
Oikea kulma ladata pikselejä pois.
Returns
int []
Ladatut CMYK-pikselit ovat läsnä 32-bittinä inateger-arvoina.
LoadCmykPixels(Rectangle)
Lataa pikselit CMYK-muodossa.Käytä tehokkaammin Aspose.Imaging.RasterImage.LoadCmyk32Pixels(__W L17_Rectangle) -menetelmää.
[Obsolete("Method is obsolete")]
public CmykColor[] LoadCmykPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Oikea kulma ladata pikselejä pois.
Returns
CmykColor []
Ladattu CMYK pikselit array.
LoadPartialArgb32Pixels(Rectangle ja IPartialArgb32PixelLoader)
Lataa 32-bittiset ARGB-pikselit osittain pakkauksilla.
public void LoadPartialArgb32Pixels(Rectangle rectangle, IPartialArgb32PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Halutun reaktioinnin mukaan.
partialPixelLoader IPartialArgb32PixelLoader
32-bittinen ARGB pikselin lataus.
Examples
Seuraava esimerkki näyttää, miten ladata ja käsitellä raster-kuvan pikseleitä käyttämällä omaa osittaista prosessoria. Esimerkiksi harkitse ongelmaa kuvan täysin läpinäkyvien pikselien laskemisesta. Jotta laskettaisiin avoimia pakseleita osittain latausmekanismin avulla, erillinen luokka TransparentArgb32PixelCounter toteuttaa Aspose.Imaging.IPartialArGB32PixelLoader esitetään.
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\alpha.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Create an instance of the Aspose.Imaging.IPartialArgb32PixelLoader and pass it to the Aspose.Imaging.RasterImage.LoadPartialArgb32Pixels
TransparentArgb32PixelCounter counter = new TransparentArgb32PixelCounter();
// Load pixels for the whole image. Any rectangular part of the image can be specified as the first parameter of the Aspose.Imaging.RasterImage.LoadPartialArgb32Pixels method.
rasterImage.LoadPartialArgb32Pixels(rasterImage.Bounds, counter);
System.Console.WriteLine("The number of fully transparent pixels is {0}", counter.Count);
System.Console.WriteLine("The total number of pixels is {0}", image.Width * image.Height);
}
// The counter may look like this:
/// <summary>
/// Counts the number of fully transparent pixels with alpha channel value of 0.
/// </summary>
private class TransparentArgb32PixelCounter : IPartialArgb32PixelLoader
{
/// <summary>
/// The number of fully transparent pixels.
/// </summary>
private int count;
/// <summary>
/// Gets the number of fully transparent pixels.
/// </summary>
public int Count
{
get { return this.count; }
}
/// <summary>
/// Processes the loaded pixels. This method is called back every time when a new portion of pixels is loaded.
/// </summary>
/// <param name="pixelsRectangle"/>The pixels rectangle.
/// <param name="pixels"/>The 32-bit ARGB pixels.
/// <param name="start"/>The start pixels point.
/// <param name="end"/>The end pixels point.
public void Process(Aspose.Imaging.Rectangle pixelsRectangle, int[] pixels, Aspose.Imaging.Point start, Aspose.Imaging.Point end)
{
foreach (int pixel in pixels)
{
int alpha = (pixel >> 24) & 0xff;
if (alpha == 0)
{
this.count++;
}
}
}
}LoadPartialArgb64Pixels(Rectangle ja IPartialArgb64PixelLoader)
Lataa 64-bittiset ARGB-pikselit osittain pakkauksilla.
public void LoadPartialArgb64Pixels(Rectangle rectangle, IPartialArgb64PixelLoader partialPixelLoader)Parameters
rectangle Rectangle
Halutun reaktioinnin mukaan.
partialPixelLoader IPartialArgb64PixelLoader
64-bittinen ARGB pikselin lataus.
LoadPartialPixels(Rectangle ja IPartialPixelLoader)
Lataa pikselit osittain pakkauksilla.
public void LoadPartialPixels(Rectangle desiredRectangle, IPartialPixelLoader pixelLoader)Parameters
desiredRectangle Rectangle
Halutun reaktioinnin mukaan.
pixelLoader IPartialPixelLoader
Pikselin kuormituslaite.
Examples
Seuraava esimerkki näyttää, miten ladata ja käsitellä raster-kuvan pikseleitä käyttämällä omaa osittaista prosessoria. Esimerkiksi harkitse ongelmaa kuvan täysin läpinäkyvien pikselien laskemisesta. Jotta laskettaisiin avoimesti osittain latausmekanismin avulla, erillinen luokka TransparentPixelCounter toteuttaa Aspose.Imaging.IPartialPxelLoader esitetään.
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)
Lataa pikseliä
public Color[] LoadPixels(Rectangle rectangle)Parameters
rectangle Rectangle
Oikea kulma ladata pikselejä pois.
Returns
Color []
Ladattu pikseli on varustettu.
Examples
Seuraava esimerkki näyttää, miten ladata ja käsitellä raster-kuvan pikseleitä. Esimerkiksi harkitse ongelmaa kuvan täysin läpinäkyvien pikselien laskemisesta.
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);
}Tämä esimerkki näyttää, miten Lataa Pixel-tietoja tyypin värijärjestelmässä, manipuloi järjestelmää ja asettaa sen takaisin kuviin. Näiden toimintojen suorittamiseksi tämä esimerki luo uuden kuvan tiedoston (GIF-muodossa) uisng MemoryStream-objekti.
//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 ja IPartialRawDataLoader)
Lataa raakaa dataa.
public void LoadRawData(Rectangle rectangle, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Oikea kulma ladata raaka-aineita.
rawDataSettings RawDataSettings
Huomaa, että jos tiedot eivät ole määritellyssä muodossa, tietojen muuntaminen suoritetaan.
rawDataLoader IPartialRawDataLoader
raaka tietojen lataus.
Examples
Seuraava esimerkki näyttää, miten pikselit voidaan poistaa raaka-kuvan tiedosta RawDataSettingsin avulla. Esimerkiksi, harkitse ongelmaa kuvan täysin läpinäkyvien pikselien laskemisesta.
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)
Lataa raakaa dataa.
public void LoadRawData(Rectangle rectangle, Rectangle destImageBounds, RawDataSettings rawDataSettings, IPartialRawDataLoader rawDataLoader)Parameters
rectangle Rectangle
Oikea kulma ladata raaka-aineita.
destImageBounds Rectangle
Kuva on rajattu.
rawDataSettings RawDataSettings
Huomaa, että jos tiedot eivät ole määritellyssä muodossa, tietojen muuntaminen suoritetaan.
rawDataLoader IPartialRawDataLoader
raaka tietojen lataus.
NormalizeAngle()
Normalisoi kulman.Tätä menetelmää sovelletaan skannattuihin tekstiasiakirjoihin päästä eroon skannatuista skannista.Tällä menetelmällä käytetään Aspose.Imaging.RasterImage.GetSkewAngle- ja Wl17. RasterImage.Rootate(System.Single) -menetelmiä.
public void NormalizeAngle()NormalizeAngle(Punainen, väri)
Normalisoi kulman.Tätä menetelmää sovelletaan skannattuihin tekstiasiakirjoihin päästä eroon skannatuista skannista.Tällä menetelmällä käytetään Aspose.Imaging.RasterImage.GetSkewAngle- ja W L 17_ .Rasteraattorin (System.Single, System.Boolean,_Wl17.Color) menetelmiä.
public virtual void NormalizeAngle(bool resizeProportionally, Color backgroundColor)Parameters
resizeProportionally bool
Jos asetat “todelliseksi”, kuvan koon muuttuu kierrettyjen reikiä (kulmanpisteiden) projektioiden mukaan muissa tapauksissa, jotka jättävät ulottuvuudet koskemattomiksi ja vain sisäiset kuvan sisällöt kierrätetään.
backgroundColor Color
Taustan väri.
Examples
Skew on artifakti, joka saattaa näkyä asiakirjan skannausprosessin aikana, kun dokumentin teksti/kuvat käännetään kevyellä nurkalla. Se voi olla erilaisia syitä, mutta yleisintä on, että paperi vääristyy skannatessa. Näin ollen, deskev on prosessi havaita ja korjata tämä ongelma skannetussa tiedostossa (eli bitmap) niin deskettu dokumentti saa tekstin / kuvan oikein ja horisontaalisesti säädetty.
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()
Normalisoi kuvan histogrammi - säätää pixel-arvoja käyttämään kaikkia käytettävissä olevia taajuuksia.
public virtual void NormalizeHistogram()ReadArgb32ScanLine(Sisältää)
Lue koko skannauslinja määritellyn skannauslinjan indeksiin.
public int[] ReadArgb32ScanLine(int scanLineIndex)Parameters
scanLineIndex int
Nolla-pohjainen indeksi skannauslinjasta.
Returns
int []
32-bittisen ARGB-värin arvojen skannauslinja.
ReadScanLine(Sisältää)
Lue koko skannauslinja määritellyn skannauslinjan indeksiin.
public Color[] ReadScanLine(int scanLineIndex)Parameters
scanLineIndex int
Nolla-pohjainen indeksi skannauslinjasta.
Returns
Color []
Skannauslinja pixel värin arvot array.
ReleaseManagedResources()
Varmista, että hallitsemattomia resursseja ei ole vapautettu täällä, koska ne saattavat olla jo vapautettu.
protected override void ReleaseManagedResources()RemoveMetadata()
Poistaa tämän kuvan esimerkkinä metatiedot asettamalla tämän Aspose.Imaging.Xmp.IHasXMPData.xmpTata arvo nollan.
public override void RemoveMetadata()ReplaceColor(Väri, byte ja väri)
Se korvaa yhden värin toiseen sallitulla erolla ja säilyttää alkuperäisen alfa-arvon säästääkseen sileät reunat.
public void ReplaceColor(Color oldColor, byte oldColorDiff, Color newColor)Parameters
oldColor Color
Vanha väri on korvattava.
oldColorDiff byte
Vanhassa värissä sallittu ero pystyy laajentamaan korvattua väriä.
newColor Color
Uusi väri korvaa vanhan värin.
ReplaceColor(Inti, byte ja int)
Se korvaa yhden värin toiseen sallitulla erolla ja säilyttää alkuperäisen alfa-arvon säästääkseen sileät reunat.
public virtual void ReplaceColor(int oldColorArgb, byte oldColorDiff, int newColorArgb)Parameters
oldColorArgb int
Vanha väri ARGB arvo korvataan.
oldColorDiff byte
Vanhassa värissä sallittu ero pystyy laajentamaan korvattua väriä.
newColorArgb int
Uusi väri ARGB arvo korvata vanhan värin.
ReplaceNonTransparentColors(Color)
Korvaa kaikki läpinäkyvät värit uudella värillä ja säilyttää alkuperäisen alfa-arvon säästääkseen sileät reunat.Huomautus: Jos käytät sitä kuvia ilman läpinäkyvyyttä, kaikki värit korvataan yhdellä.
public void ReplaceNonTransparentColors(Color newColor)Parameters
newColor Color
Uusi väri korvaa läpinäkyviä värejä.
ReplaceNonTransparentColors(Sisältää)
Korvaa kaikki läpinäkyvät värit uudella värillä ja säilyttää alkuperäisen alfa-arvon säästääkseen sileät reunat.Huomautus: Jos käytät sitä kuvia ilman läpinäkyvyyttä, kaikki värit korvataan yhdellä.
public virtual void ReplaceNonTransparentColors(int newColorArgb)Parameters
newColorArgb int
Uusi väri ARGB-arvo korvaa läpinäkyviä värejä.
Resize(int, int, ImageResizeSettings)
Muokkaa kuvaa laajennetulla vaihtoehdolla.
public override void Resize(int newWidth, int newHeight, ImageResizeSettings settings)Parameters
newWidth int
Ja uusi leveys.
newHeight int
Ja uusi korkeus.
settings ImageResizeSettings
Siirretään uudelleen asetukset.
Examples
Tämä esimerkki laittaa raster-kuvan ja uudistaa sen käyttämällä erilaisia uudelleen asetuksia.
string dir = "c:\\temp\\";
Aspose.Imaging.ImageResizeSettings resizeSettings = new Aspose.Imaging.ImageResizeSettings();
// The adaptive algorithm based on weighted and blended rational function and lanczos3 interpolation.
resizeSettings.Mode = Aspose.Imaging.ResizeType.AdaptiveResample;
// The small rectangular filter
resizeSettings.FilterType = Aspose.Imaging.ImageFilterType.SmallRectangular;
// The number of colors in the palette.
resizeSettings.EntriesCount = 256;
// The color quantization is not used
resizeSettings.ColorQuantizationMethod = ColorQuantizationMethod.None;
// The euclidian method
resizeSettings.ColorCompareMethod = ColorCompareMethod.Euclidian;
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.gif"))
{
// Scale down by 2 times using adaptive resampling.
image.Resize(image.Width / 2, image.Height / 2, resizeSettings);
image.Save(dir + "downsample.adaptive.gif");
}Rotate(Float, Bool ja väri)
Kuvia kierrätetään keskustan ympärillä.
public virtual void Rotate(float angle, bool resizeProportionally, Color backgroundColor)Parameters
angle float
Kiertävä kulma asteina. Positiiviset arvot kiertävät kelloa.
resizeProportionally bool
Jos asetat “todelliseksi”, kuvan koon muuttuu kierrettyjen reikiä (kulmanpisteiden) projektioiden mukaan muissa tapauksissa, jotka jättävät ulottuvuudet koskemattomiksi ja vain sisäiset kuvan sisällöt kierrätetään.
backgroundColor Color
Taustan väri.
Exceptions
Ei toteutettu poikkeus
Rotate(Flottaa)
Kuvia kierrätetään keskustan ympärillä.
public override void Rotate(float angle)Parameters
angle float
Kiertävä kulma asteina. Positiiviset arvot kiertävät kelloa.
Save(Virtaa, ImageOptionsBase, Rectangle)
Tallenna kuvan tiedot määritellylle virtaukselle määritellyssä tiedostomuodossa tallennusvaihtoehtojen mukaisesti.
public override void Save(Stream stream, ImageOptionsBase optionsBase, Rectangle boundsRectangle)Parameters
stream Stream
Virta tallentaa kuvan tiedot.
optionsBase ImageOptionsBase
säästämisvaihtoehtoja.
boundsRectangle Rectangle
Kohde-kuva rajoittaa oikea kulma. Aseta tyhjä oikea kulma käyttämään lähde rajoja.
SaveArgb32Pixels(Säätiö, int[])
Säästää 32-bittiset ARGB-pikselit.
public void SaveArgb32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Pikselit tallennetaan pikseleihin.
pixels int
[]
32-bittinen ARGB-pikseli on käytössä.
Examples
Seuraava esimerkki täyttää raster-kuvan keskeisen alueen mustilla pikseleillä Aspose.Imaging.RasterImage.SaveArgb32Pixels -menetelmän avulla.
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(Säätiö, int[])
Se säästää pikselejä.
public void SaveCmyk32Pixels(Rectangle rectangle, int[] pixels)Parameters
rectangle Rectangle
Pikselit tallennetaan pikseleihin.
pixels int
[]
CMYK-pikselit esitetään 32-bittinä kokonaisarvoina.
Examples
Seuraava esimerkki täyttää raster-kuvan keskeisen alueen mustilla pikseleillä Aspose.Imaging.RasterImage.SaveCmyk32Pixels -menetelmän avulla.
string dir = @"c:\temp\";
using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.png"))
{
Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)image;
// Get an integer representation of black in the CMYK color space.
int blackCmyk = Aspose.Imaging.CmykColorHelper.ToCmyk(Color.Black);
// The black square.
int[] pixels = new int[(rasterImage.Width / 2) * (rasterImage.Height / 2)];
for (int i = 0; i < pixels.Length; i++)
{
pixels[i] = blackCmyk;
}
// Draw the black square at the center of the image.
Aspose.Imaging.Rectangle area = new Aspose.Imaging.Rectangle(rasterImage.Width / 4, rasterImage.Height / 4, rasterImage.Width / 2, rasterImage.Height / 2);
rasterImage.SaveCmyk32Pixels(area, pixels);
rasterImage.Save(dir + "sample.SaveCmyk32Pixels.png");
}SaveCmykPixels(Rectangle ja CmykColor[])
Se säästää pikselejä.Käytä tehokkaammin Aspose.Imaging.RasterImage.SaveCmyk32Pixels(W L 17 .Rectangle,System.Int32[]) menetelmää.
[Obsolete("Method is obsolete")]
public void SaveCmykPixels(Rectangle rectangle, CmykColor[] pixels)Parameters
rectangle Rectangle
Pikselit tallennetaan pikseleihin.
pixels CmykColor
[]
CMYK-pikselit ovat järjestettyjä.
SavePixels(Väri, väri[])
Se säästää pikselejä.
public void SavePixels(Rectangle rectangle, Color[] pixels)Parameters
rectangle Rectangle
Pikselit tallennetaan pikseleihin.
pixels Color
[]
Pikselit ovat sijoittuneet.
Examples
Seuraava esimerkki täyttää raster-kuvan keskeisen alueen mustilla pikseleillä Aspose.Imaging.RasterImage.SavePixels -menetelmän avulla.
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");
}Tämä esimerkki näyttää, miten Lataa Pixel-tietoja tyypin värijärjestelmässä, manipuloi järjestelmää ja asettaa sen takaisin kuviin. Näiden toimintojen suorittamiseksi tämä esimerki luo uuden kuvan tiedoston (GIF-muodossa) uisng MemoryStream-objekti.
//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(bytejä[], int, Rectangle ja RawDataSettings)
Se säästää raaka-aineita.
public void SaveRawData(byte[] data, int dataOffset, Rectangle rectangle, RawDataSettings rawDataSettings)Parameters
data byte
[]
raakaa dataa varten.
dataOffset int
Alkuperäiset raaka-aineet korvaavat.
rectangle Rectangle
raaka-aineiden oikea kulma on oikea.
rawDataSettings RawDataSettings
Tuoreet tiedot asetukset, joihin tietoja on.
SetArgb32Pixel(Inti, Inti ja Inti)
Aseta kuvan 32-bittinen ARGB-pikseli määritellylle sijainnille.
public void SetArgb32Pixel(int x, int y, int argb32Color)Parameters
x int
Pikselin x sijainti.
y int
Pikseli ja sijainti.
argb32Color int
32-bittinen ARGB-pikseli määritellyn sijainnin osalta.
Examples
Seuraava esimerkki laittaa raster-kuvan ja asettaa tahallisen pixelin värin.
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 ja Bool)
Aseta kuvan paletti.
public override void SetPalette(IColorPalette palette, bool updateColors)Parameters
palette IColorPalette
Paletti on asetettu.
updateColors bool
jos “todellinen” väri päivitetään uuden paletin mukaan; muuten väriindeksit pysyvät muuttumattomina. Huomaa, että muuttumattomat indeksit voivat rikkoa kuvan latauksessa, jos joillakin indeksit eivät ole vastaavia paletin tuloksia.
SetPixel(värit, värit ja värit)
Aseta kuvan pixel määritellylle sijainnille.
public void SetPixel(int x, int y, Color color)Parameters
x int
Pikselin x sijainti.
y int
Pikseli ja sijainti.
color Color
Pikselin väri määritellyn sijainnin osalta.
Examples
Seuraava esimerkki laittaa raster-kuvan ja asettaa tahallisen pixelin värin.
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(kaksinkertainen, kaksinkertainen)
Aseta resoluutio tähän Aspose.Imaging.RasterImage.
public virtual void SetResolution(double dpiX, double dpiY)Parameters
dpiX double
Horisontaalinen resoluutio, pisteissä per tuumaa, Aspose.Imaging.RasterImage.
dpiY double
Vertikaalinen resoluutio, pisteinä tuumaa kohti, Aspose.Imaging.RasterImage.
Examples
Seuraava esimerkki osoittaa, miten asetetaan horisontaalinen/vertikaali resoluutio raster kuvan.
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()
Muunna raster-kuva bitmapiksi.Tätä menetelmää ei tueta versioissa .Net7.0 ja uudemmissa
public virtual Bitmap ToBitmap()Returns
Bitmap on
UpdateDimensions(Sisä, sisä)
Päivitä kuvan ulottuvuudet.
protected abstract void UpdateDimensions(int newWidth, int newHeight)Parameters
newWidth int
Uuden kuvan leveys.
newHeight int
Uuden kuvan korkeus.
UpdateMetadata()
Päivitä kuvan metatietoja.
protected virtual void UpdateMetadata()WriteArgb32ScanLine(Sisä, sisä[])
Kirjoita koko skannauslinja määritellyn skannauslinjan indeksiin.
public void WriteArgb32ScanLine(int scanLineIndex, int[] argb32Pixels)Parameters
scanLineIndex int
Nolla-pohjainen indeksi skannauslinjasta.
argb32Pixels int
[]
32-bittinen ARGB-väri voi kirjoittaa.
WriteScanLine(väri, väri[])
Kirjoita koko skannauslinja määritellyn skannauslinjan indeksiin.
public void WriteScanLine(int scanLineIndex, Color[] pixels)Parameters
scanLineIndex int
Nolla-pohjainen indeksi skannauslinjasta.
pixels Color
[]
Pikselin värejä voi kirjoittaa.
