Class TiffImage

Class TiffImage

De naam: Aspose.Imaging.FileFormats.Tiff Verzameling: Aspose.Imaging.dll (25.4.0)

Process Tagged Image File Format (TIFF) raster afbeeldingen met onze API, biedtuitgebreide ondersteuning voor verschillende resoluties en geavanceerde bewerkingscapaciteitenzoals EXIF-data manipulatie en alfa-kanalen. normaliseren van de hoeken voor gescannelde afbeeldingen,hersteld, omgezet naar grayscale, en filters, gamma correcties en afbeeldingen toepassenparameter aanpassingen met gemakkelijkheid. makkelijk beheren multi-frame TIFF bestanden,Creëer grafische paden, voeg vormen toe en moeiteloos bewaar afbeeldingen naar verschillende formaten.

[JsonObject(MemberSerialization.OptIn)]
public class TiffImage : RasterCachedMultipageImage, IDisposable, IObjectWithBounds, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, IMultipageImageExt, IMultipageImage, IHasExifData, IHasXmpData, IHasMetadata

Inheritance

object DisposableObject DataStreamSupporter Image RasterImage RasterCachedImage RasterCachedMultipageImage TiffImage

Derived

BigTiffImage

Implements

IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IMultipageImageExt , IMultipageImage , IHasExifData , IHasXmpData , IHasMetadata

Geëerbiede leden

RasterCachedMultipageImage.AdjustBrightness(int) , RasterCachedMultipageImage.AdjustContrast(float) , RasterCachedMultipageImage.AdjustGamma(float, float, float) , RasterCachedMultipageImage.AdjustGamma(float) , RasterCachedMultipageImage.Blend(Point, RasterImage, Rectangle, byte) , RasterCachedMultipageImage.BinarizeFixed(byte) , RasterCachedMultipageImage.BinarizeBradley(double, int) , RasterCachedMultipageImage.BinarizeBradley(double) , RasterCachedMultipageImage.BinarizeOtsu() , RasterCachedMultipageImage.Crop(Rectangle) , RasterCachedMultipageImage.Crop(int, int, int, int) , RasterCachedMultipageImage.Dither(DitheringMethod, int, IColorPalette) , RasterCachedMultipageImage.Grayscale() , RasterCachedMultipageImage.NormalizeHistogram() , RasterCachedMultipageImage.Rotate(float, bool, Color) , RasterCachedMultipageImage.RotateFlip(RotateFlipType) , RasterCachedMultipageImage.RotateFlipAll(RotateFlipType) , RasterCachedMultipageImage.Resize(int, int, ResizeType) , RasterCachedMultipageImage.Resize(int, int, ImageResizeSettings) , RasterCachedMultipageImage.ResizeWidthProportionally(int, ResizeType) , RasterCachedMultipageImage.ResizeHeightProportionally(int, ResizeType) , RasterCachedMultipageImage.ReplaceColor(int, byte, int) , RasterCachedMultipageImage.ReplaceNonTransparentColors(int) , RasterCachedMultipageImage.Filter(Rectangle, FilterOptionsBase) , RasterCachedMultipageImage.NormalizeAngle(bool, Color) , RasterCachedMultipageImage.CacheData() , RasterCachedMultipageImage.ReleaseManagedResources() , RasterCachedMultipageImage.ResizeMain(int, int, ResizeType) , RasterCachedMultipageImage.RotateFlipMain(RotateFlipType) , RasterCachedMultipageImage.CropMain(int, int, int, int) , RasterCachedMultipageImage.SavePixelsInternalMain(Rectangle, int[]) , RasterCachedMultipageImage.CanDoAdjustments() , RasterCachedMultipageImage.GetPagesAsEnumerable() , RasterCachedMultipageImage.GetSerializedStream(ImageOptionsBase, Rectangle, out int) , RasterCachedMultipageImage.Height , RasterCachedMultipageImage.Width , RasterCachedMultipageImage.BitsPerPixel , RasterCachedMultipageImage.IsCached , RasterCachedMultipageImage.PageCount , RasterCachedMultipageImage.Pages , RasterCachedMultipageImage.HasAlpha , RasterCachedMultipageImage.HasTransparentColor , RasterCachedMultipageImage.ImageOpacity , RasterCachedMultipageImage.BackgroundColor , RasterCachedMultipageImage.XmpData , RasterCachedMultipageImage.PageExportingAction , RasterCachedImage.CacheData() , RasterCachedImage.Blend(Point, RasterImage, Rectangle, byte) , RasterCachedImage.Resize(int, int, ResizeType) , RasterCachedImage.Resize(int, int, ImageResizeSettings) , RasterCachedImage.RotateFlip(RotateFlipType) , RasterCachedImage.Rotate(float, bool, Color) , RasterCachedImage.Crop(Rectangle) , RasterCachedImage.Dither(DitheringMethod, int, IColorPalette) , RasterCachedImage.Grayscale() , RasterCachedImage.NormalizeHistogram() , RasterCachedImage.BinarizeFixed(byte) , RasterCachedImage.BinarizeOtsu() , RasterCachedImage.BinarizeBradley(double, int) , RasterCachedImage.BinarizeBradley(double) , RasterCachedImage.AdjustBrightness(int) , RasterCachedImage.AdjustContrast(float) , RasterCachedImage.AdjustGamma(float, float, float) , RasterCachedImage.AdjustGamma(float) , RasterCachedImage.OnCached() , RasterCachedImage.OnPaletteChanged(IColorPalette, IColorPalette) , RasterCachedImage.IsCached , RasterImage.xmpData , RasterImage.RemoveMetadata() , RasterImage.Save(Stream, ImageOptionsBase, Rectangle) , RasterImage.GetModifyDate(bool) , RasterImage.Dither(DitheringMethod, int) , RasterImage.Dither(DitheringMethod, int, IColorPalette) , RasterImage.GetDefaultPixels(Rectangle, IPartialArgb32PixelLoader) , RasterImage.GetDefaultRawData(Rectangle, IPartialRawDataLoader, RawDataSettings) , RasterImage.GetDefaultArgb32Pixels(Rectangle) , RasterImage.GetDefaultRawData(Rectangle, RawDataSettings) , RasterImage.GetArgb32Pixel(int, int) , RasterImage.GetPixel(int, int) , RasterImage.SetArgb32Pixel(int, int, int) , RasterImage.SetPixel(int, int, Color) , RasterImage.ReadScanLine(int) , RasterImage.ReadArgb32ScanLine(int) , RasterImage.WriteScanLine(int, Color[]) , RasterImage.WriteArgb32ScanLine(int, int[]) , RasterImage.LoadPartialArgb32Pixels(Rectangle, IPartialArgb32PixelLoader) , RasterImage.LoadPartialPixels(Rectangle, IPartialPixelLoader) , RasterImage.LoadArgb32Pixels(Rectangle) , RasterImage.LoadArgb64Pixels(Rectangle) , RasterImage.LoadPartialArgb64Pixels(Rectangle, IPartialArgb64PixelLoader) , RasterImage.LoadPixels(Rectangle) , RasterImage.LoadCmykPixels(Rectangle) , RasterImage.LoadCmyk32Pixels(Rectangle) , RasterImage.LoadRawData(Rectangle, RawDataSettings, IPartialRawDataLoader) , RasterImage.LoadRawData(Rectangle, Rectangle, RawDataSettings, IPartialRawDataLoader) , RasterImage.SaveRawData(byte[], int, Rectangle, RawDataSettings) , RasterImage.SaveArgb32Pixels(Rectangle, int[]) , RasterImage.SavePixels(Rectangle, Color[]) , RasterImage.SaveCmykPixels(Rectangle, CmykColor[]) , RasterImage.SaveCmyk32Pixels(Rectangle, int[]) , RasterImage.SetResolution(double, double) , RasterImage.SetPalette(IColorPalette, bool) , RasterImage.Resize(int, int, ImageResizeSettings) , RasterImage.Rotate(float, bool, Color) , RasterImage.Rotate(float) , RasterImage.BinarizeFixed(byte) , RasterImage.BinarizeOtsu() , RasterImage.BinarizeBradley(double) , RasterImage.BinarizeBradley(double, int) , RasterImage.Blend(Point, RasterImage, Rectangle, byte) , RasterImage.Blend(Point, RasterImage, byte) , RasterImage.Grayscale() , RasterImage.NormalizeHistogram() , RasterImage.AdjustBrightness(int) , RasterImage.AdjustContrast(float) , RasterImage.AdjustGamma(float, float, float) , RasterImage.AdjustGamma(float) , RasterImage.GetSkewAngle() , RasterImage.NormalizeAngle() , RasterImage.NormalizeAngle(bool, Color) , RasterImage.Filter(Rectangle, FilterOptionsBase) , RasterImage.ReplaceColor(Color, byte, Color) , RasterImage.ReplaceColor(int, byte, int) , RasterImage.ReplaceNonTransparentColors(Color) , RasterImage.ReplaceNonTransparentColors(int) , RasterImage.ToBitmap() , RasterImage.ReleaseManagedResources() , RasterImage.UpdateMetadata() , RasterImage.UpdateDimensions(int, int) , RasterImage.PremultiplyComponents , RasterImage.UseRawData , RasterImage.UpdateXmpData , RasterImage.XmpData , RasterImage.RawIndexedColorConverter , RasterImage.RawCustomColorConverter , RasterImage.RawFallbackIndex , RasterImage.RawDataSettings , RasterImage.UsePalette , RasterImage.RawDataFormat , RasterImage.RawLineSize , RasterImage.IsRawDataAvailable , RasterImage.HorizontalResolution , RasterImage.VerticalResolution , RasterImage.HasTransparentColor , RasterImage.HasAlpha , RasterImage.TransparentColor , RasterImage.ImageOpacity , RasterImage.DataLoader , 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

Creëer Graphics Path van Pate Resources in TIFF-beeld.

using (var image = (TiffImage)Image.Load("Bottle.tif"))
                                                                  {
                                                                      // Create the GraphicsPath using PathResources from TIFF image
                                                                      var graphicsPath = PathResourceConverter.ToGraphicsPath(image.ActiveFrame.PathResources.ToArray(), image.ActiveFrame.Size);
                                                                      var graphics = new Graphics(image);

                                                                      // Draw red line and save the image
                                                                      graphics.DrawPath(new Pen(Color.Red, 10), graphicsPath);
                                                                      image.Save("BottleWithRedBorder.tif");
                                                                  }

Creëer Path Resources met behulp van Graphics Patt.

static void Main(string[] args)
                                                     {
                                                         using (var image = (TiffImage)Image.Load("Bottle.tif"))
                                                         {
                                                             // Create rectangular Figure for GraphicsPath
                                                             var figure = new Figure();
                                                             figure.AddShape(CreateBezierShape(100f, 100f, 500f, 100f, 500f, 1000f, 100f, 1000f));

                                                             // Create GraphicsPath using our Figure
                                                             var graphicsPath = new GraphicsPath();
                                                             graphicsPath.AddFigure(figure);

                                                             // Set PathResources using GraphicsPath
                                                             var pathResouze = PathResourceConverter.FromGraphicsPath(graphicsPath, image.Size);
                                                             image.ActiveFrame.PathResources = new List<pathresource>(pathResouze);

                                                             // Save the image
                                                             image.Save("BottleWithRectanglePath.tif");
                                                         }
                                                     }

                                                     private static BezierShape CreateBezierShape(params float[] coordinates)
                                                     {
                                                         var bezierPoints = CoordinatesToBezierPoints(coordinates).ToArray();
                                                         return new BezierShape(bezierPoints, true);
                                                     }

                                                     private static IEnumerable<pointf> CoordinatesToBezierPoints(float[] coordinates)
                                                     {
                                                         for (var coordinateIndex = 0; coordinateIndex &lt; coordinates.Length; coordinateIndex += 2)
                                                             for (var index = 0; index &lt; 3; index++)
                                                                 yield return new PointF(coordinates[coordinateIndex], coordinates[coordinateIndex + 1]);
                                                     }</pointf></pathresource>

Constructors

TiffImage(TiffFrame)

Initialiseren van een nieuw object van de Aspose.Imaging.FileFormats.Tiff. TiffImage klasse, met de specificatie van hetframe parameter. deze constructor vergemakkelijkt de creatie van een TiffImagebijvoorbeeld, waardoor ontwikkelaars het kader kunnen specificeren dat moet worden geladen of verwerkt,het vergemakkelijken van de taken die Tiff beeldbehandeling binnen hun toepassingen uitvoert.

public TiffImage(TiffFrame frame)

Parameters

frame TiffFrame

De tiff frame om het beeld met te initialiseren.

Examples

Dit voorbeeld laat zien hoe u een TIFF-afbeelding kunt maken van scratch en het in een bestand kunt opslaan.

string dir = "c:\\temp\\";

                                                                                            Aspose.Imaging.ImageOptions.TiffOptions createOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                            // Set 8 bits for each color component.
                                                                                            createOptions.BitsPerSample = new ushort[] { 8, 8, 8 };

                                                                                            // Set the Big Endian byte order (Motorola)
                                                                                            createOptions.ByteOrder = Aspose.Imaging.FileFormats.Tiff.Enums.TiffByteOrder.BigEndian;

                                                                                            // Set the LZW compression.
                                                                                            createOptions.Compression = Aspose.Imaging.FileFormats.Tiff.Enums.TiffCompressions.Lzw;

                                                                                            // Set the RGB color model.
                                                                                            createOptions.Photometric = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPhotometrics.Rgb;

                                                                                            // All color components will be stored within a single plane.
                                                                                            createOptions.PlanarConfiguration = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPlanarConfigs.Contiguous;

                                                                                            // Create a TIFF Frame of 100x100 px.
                                                                                            // Note that you don't have to dispose a frame explicitly if it is included into TiffImage.
                                                                                            // When the container is disposed all frames will be disposed automatically.
                                                                                            Aspose.Imaging.FileFormats.Tiff.TiffFrame firstFrame = new Aspose.Imaging.FileFormats.Tiff.TiffFrame(createOptions, 100, 100);

                                                                                            // Fill the entire frame with the blue-yellow gradient.
                                                                                            Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                    new Aspose.Imaging.Point(0, 0),
                                                                                                    new Aspose.Imaging.Point(firstFrame.Width, firstFrame.Height),
                                                                                                    Aspose.Imaging.Color.Blue,
                                                                                                    Aspose.Imaging.Color.Yellow);

                                                                                            Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(firstFrame);
                                                                                            graphics.FillRectangle(gradientBrush, firstFrame.Bounds);

                                                                                            // Create a TIFF image.
                                                                                            using (Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = new Aspose.Imaging.FileFormats.Tiff.TiffImage(firstFrame))
                                                                                            {
                                                                                                tiffImage.Save(dir + "output.tif");
                                                                                            }

Exceptions

ArgumentNullException

Tiff frame’ kan niet leeg zijn.

TiffImage(TiffFrame[])

Creëer een nieuwe instantie van de Aspose.Imaging.FileFormats.Tiff. TiffImage-klasse, die een lijst metframe als een parameter. deze constructor maakt de initialisering van een TiffImage mogelijkobjecten met meerdere kaders, het vergemakkelijken van efficiënte beheer en verwerking vanTIFF-afbeeldingssecties binnen software-applicaties.

public TiffImage(TiffFrame[] frames)

Parameters

frames TiffFrame []

De kaders .

Examples

Dit voorbeeld laat zien hoe u een TIFF-afbeelding met 2 kaders kunt maken en deze in een bestand kunt opslaan.

string dir = "c:\\temp\\";

                                                                                             // Options for the first frame
                                                                                             Aspose.Imaging.ImageOptions.TiffOptions createOptions1 = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                             // Set 8 bits for each color component.
                                                                                             createOptions1.BitsPerSample = new ushort[] { 8, 8, 8 };

                                                                                             // Set the Big Endian byte order (Motorola)
                                                                                             createOptions1.ByteOrder = Aspose.Imaging.FileFormats.Tiff.Enums.TiffByteOrder.BigEndian;

                                                                                             // Set the LZW compression.
                                                                                             createOptions1.Compression = Aspose.Imaging.FileFormats.Tiff.Enums.TiffCompressions.Lzw;

                                                                                             // Set the RGB color model.
                                                                                             createOptions1.Photometric = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPhotometrics.Rgb;

                                                                                             // All color components will be stored within a single plane.
                                                                                             createOptions1.PlanarConfiguration = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPlanarConfigs.Contiguous;

                                                                                             // Create the first TIFF frame of 100x100 px.
                                                                                             // Note that you don't have to dispose frames explicitly if they are included into TiffImage.
                                                                                             // When the container is disposed all frames will be disposed automatically.
                                                                                             Aspose.Imaging.FileFormats.Tiff.TiffFrame frame1 = new Aspose.Imaging.FileFormats.Tiff.TiffFrame(createOptions1, 100, 100);

                                                                                             // Fill the first frame with the blue-yellow gradient.
                                                                                             Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                     new Aspose.Imaging.Point(0, 0),
                                                                                                     new Aspose.Imaging.Point(frame1.Width, frame1.Height),
                                                                                                     Aspose.Imaging.Color.Blue,
                                                                                                     Aspose.Imaging.Color.Yellow);

                                                                                             Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(frame1);
                                                                                             graphics.FillRectangle(gradientBrush, frame1.Bounds);

                                                                                             // Options for the first frame
                                                                                             Aspose.Imaging.ImageOptions.TiffOptions createOptions2 = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                             // Set 1 bit per pixel for a B/W image.
                                                                                             createOptions2.BitsPerSample = new ushort[] { 1 };

                                                                                             // Set the Little Endian byte order (Intel)
                                                                                             createOptions2.ByteOrder = Aspose.Imaging.FileFormats.Tiff.Enums.TiffByteOrder.LittleEndian;

                                                                                             // Set the CCITT Group 3 Fax compression.
                                                                                             createOptions2.Compression = Aspose.Imaging.FileFormats.Tiff.Enums.TiffCompressions.CcittFax3;

                                                                                             // Set the B/W color model where 0 is black, 1 is white.
                                                                                             createOptions2.Photometric = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPhotometrics.MinIsBlack;

                                                                                             // Create the second TIFF frame of 200x200px.
                                                                                             Aspose.Imaging.FileFormats.Tiff.TiffFrame frame2 = new Aspose.Imaging.FileFormats.Tiff.TiffFrame(createOptions2, 200, 200);

                                                                                             // Fill the second frame with the blue-yellow gradient.
                                                                                             // It will be automatically converted to the B/W format due to the corresponding settings of the frame.
                                                                                             Aspose.Imaging.Graphics graphics2 = new Aspose.Imaging.Graphics(frame2);
                                                                                             graphics2.FillRectangle(gradientBrush, frame2.Bounds);

                                                                                             // Create a TIFF image.
                                                                                             using (Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = new Aspose.Imaging.FileFormats.Tiff.TiffImage(
                                                                                                 new Aspose.Imaging.FileFormats.Tiff.TiffFrame[] { frame1, frame2 }))
                                                                                             {
                                                                                                 tiffImage.Save(dir + "output.mutliframe.tif");
                                                                                             }

Exceptions

ArgumentNullException

Frameën

Properties

ActiveFrame

beheer het actieve kader naadloos, faciliteert dynamische navigatie enmanipulatie binnen de aangegeven context. Uw applicatie in staat stellen om te interagerenefficiënt met multimedia-inhoud, het verbeteren van gebruikers engagement en productiviteit.

public TiffFrame ActiveFrame { get; set; }

Eigendomswaarde

TiffFrame

Examples

Het volgende voorbeeld toont hoe je een mutlipage TIFF kunt composeren van individuele rasterbeelden.

Aspose.Imaging.ImageOptions.TiffOptions createTiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Aspose.Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);
                                                                                                     createTiffOptions.Source = new Aspose.Imaging.Sources.FileCreateSource("c:\\temp\\multipage.tif", false);
                                                                                                     createTiffOptions.Photometric = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPhotometrics.Rgb;
                                                                                                     createTiffOptions.BitsPerSample = new ushort[] { 8, 8, 8 };

                                                                                                     using (Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Image.Create(createTiffOptions, 100, 100))
                                                                                                     {
                                                                                                         // This is Font and Brush for drawing text on individual frames.
                                                                                                         Aspose.Imaging.Font font = new Aspose.Imaging.Font("Arial", 64);
                                                                                                         Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.White);

                                                                                                         // Create 5 frames
                                                                                                         for (int i = 1; i &lt;= 5; i++)
                                                                                                         {
                                                                                                             Aspose.Imaging.ImageOptions.PngOptions createPngOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                             createPngOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());

                                                                                                             // Create a PNG image and draw the number of page on it.
                                                                                                             Aspose.Imaging.FileFormats.Png.PngImage pngImage = (Aspose.Imaging.FileFormats.Png.PngImage)Image.Create(createPngOptions, 100, 100);
                                                                                                             Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(pngImage);
                                                                                                             gr.DrawString(i.ToString(), font, brush, 10, 10);

                                                                                                             // Create a frame based on the PNG image.
                                                                                                             Aspose.Imaging.FileFormats.Tiff.TiffFrame frame = new Aspose.Imaging.FileFormats.Tiff.TiffFrame(pngImage);

                                                                                                             // Add the frame to the TIFF image.
                                                                                                             tiffImage.AddFrame(frame);
                                                                                                         }

                                                                                                         // The image was created with a single default frame. Let's remove it.
                                                                                                         Aspose.Imaging.FileFormats.Tiff.TiffFrame activeFrame = tiffImage.ActiveFrame;
                                                                                                         tiffImage.ActiveFrame = tiffImage.Frames[1];
                                                                                                         tiffImage.RemoveFrame(0);

                                                                                                         // Don't forget to dispose the frame if you won't add it to some other TiffImage
                                                                                                         activeFrame.Dispose();

                                                                                                         tiffImage.Save();
                                                                                                     }

ByteOrder

Samenvoegen van de bytebestelling voor TIFF-bestanden naadloos, waardoor nauwkeurige controle overdata interpretatie. vergemakkelijkt uw toepassingen met de flexibiliteit om aan te passen aandiverse bestandspecificaties, verbetering van de compatibiliteit en efficiëntie in de gegevensverwerking.

public TiffByteOrder ByteOrder { get; set; }

Eigendomswaarde

TiffByteOrder

ExifData

  • toegang tot of wijzigen van EXIF-gegevens die verband houden met het actieve kader, zonder nauwkeurignauwkeurige controle over beeldmetadata. verbeteren van de mogelijkheden van uw applicatie doorintegreren van deze functie, waarborgen van nauwkeurige bewaring en aanpassing vanEssentiële beeldinformatie.
public ExifData ExifData { get; set; }

Eigendomswaarde

ExifData

FileFormat

Verwijder de waarde van het bestandformaat geassocieerd met de afbeelding. deze eigenschap dient alseen kritisch aspect van beeldmetadata-opname, waardoor software-applicatiesidentificeren en interpreteren van het formaat van de afbeeldingsgegevens efficiënt.

public override FileFormat FileFormat { get; }

Eigendomswaarde

FileFormat

Frames

Verwijder een reeks van Aspose.Imaging.FileFormats.Tiff. TiffFrame-instanties, waardoor uitgebreidetoegang en manipulatie van individuele kaders binnen het TIFF-beeld.de kracht van deze array om de werkstromen voor het verwerken van afbeeldingen te stroomlijnen, waarborgen van nauwkeurigheidControle en optimalisatie van visuele inhoud.

public TiffFrame[] Frames { get; }

Eigendomswaarde

TiffFrame []

Examples

Het volgende voorbeeld toont hoe je een mutlipage TIFF kunt composeren van individuele rasterbeelden.

Aspose.Imaging.ImageOptions.TiffOptions createTiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Aspose.Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);
                                                                                                     createTiffOptions.Source = new Aspose.Imaging.Sources.FileCreateSource("c:\\temp\\multipage.tif", false);
                                                                                                     createTiffOptions.Photometric = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPhotometrics.Rgb;
                                                                                                     createTiffOptions.BitsPerSample = new ushort[] { 8, 8, 8 };

                                                                                                     using (Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Image.Create(createTiffOptions, 100, 100))
                                                                                                     {
                                                                                                         // This is Font and Brush for drawing text on individual frames.
                                                                                                         Aspose.Imaging.Font font = new Aspose.Imaging.Font("Arial", 64);
                                                                                                         Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.White);

                                                                                                         // Create 5 frames
                                                                                                         for (int i = 1; i &lt;= 5; i++)
                                                                                                         {
                                                                                                             Aspose.Imaging.ImageOptions.PngOptions createPngOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                             createPngOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());

                                                                                                             // Create a PNG image and draw the number of page on it.
                                                                                                             Aspose.Imaging.FileFormats.Png.PngImage pngImage = (Aspose.Imaging.FileFormats.Png.PngImage)Image.Create(createPngOptions, 100, 100);
                                                                                                             Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(pngImage);
                                                                                                             gr.DrawString(i.ToString(), font, brush, 10, 10);

                                                                                                             // Create a frame based on the PNG image.
                                                                                                             Aspose.Imaging.FileFormats.Tiff.TiffFrame frame = new Aspose.Imaging.FileFormats.Tiff.TiffFrame(pngImage);

                                                                                                             // Add the frame to the TIFF image.
                                                                                                             tiffImage.AddFrame(frame);
                                                                                                         }

                                                                                                         // The image was created with a single default frame. Let's remove it.
                                                                                                         Aspose.Imaging.FileFormats.Tiff.TiffFrame activeFrame = tiffImage.ActiveFrame;
                                                                                                         tiffImage.ActiveFrame = tiffImage.Frames[1];
                                                                                                         tiffImage.RemoveFrame(0);

                                                                                                         // Don't forget to dispose the frame if you won't add it to some other TiffImage
                                                                                                         activeFrame.Dispose();

                                                                                                         tiffImage.Save();
                                                                                                     }

HasAlpha

Bepaal of de afbeelding een alfa kanaal heeft, waardoor cruciale informatie wordt verstrektvoor rendering en compositing. integreren van deze functie om te optimaliserenvisuele verwerkingswerkstromen, waarborgen van nauwkeurige representatie en manipulatie vanDe transparante elementen.

public override bool HasAlpha { get; }

Eigendomswaarde

bool

Examples

In het volgende voorbeeld wordt een TIFF-afbeelding geladen en wordt informatie gedrukt over het grondgegevensformaat en het alfa-kanaal.

string dir = "c:\\temp\\";

                                                                                                                   string fileName = dir + "sample.tif";
                                                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(fileName))
                                                                                                                   {
                                                                                                                       Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                                                       // If the active TIFF frame has alpha channel, then the entire TIFF image is considered to have alpha channel.
                                                                                                                       System.Console.WriteLine("ImageFile={0}, FileFormat={1}, HasAlpha={2}", fileName, tiffImage.RawDataFormat, tiffImage.HasAlpha);

                                                                                                                       int i = 0;
                                                                                                                       foreach (Aspose.Imaging.FileFormats.Tiff.TiffFrame frame in tiffImage.Frames)
                                                                                                                       {
                                                                                                                           System.Console.WriteLine("Frame={0}, FileFormat={1}, HasAlpha={2}", ++i, frame.RawDataFormat, frame.HasAlpha);
                                                                                                                       }
                                                                                                                   }

                                                                                                                   // The output may look like this:
                                                                                                                   // ImageFile=c:\temp\sample.tif, FileFormat=RgbIndexed1Bpp, used channels: 1, HasAlpha=False
                                                                                                                   // Frame=1, FileFormat=RgbIndexed1Bpp, used channels: 1, HasAlpha=False
                                                                                                                   // Frame=2, FileFormat=RgbIndexed1Bpp, used channels: 1, HasAlpha=False

HorizontalResolution

Verwijder de horizontale resolutie van de aangegeven Aspose.Imaging.Image in pixelsper inch, het vergemakkelijken van nauwkeurige aanpassing en renderingcapaciteiten.essentieel beeldmetadata moeiteloos, het vergemakkelijken van nauwkeurig beeldverwerkingwerkstromen voor verbeterde gebruikerservaringen.

public override double HorizontalResolution { get; set; }

Eigendomswaarde

double

Examples

Het volgende voorbeeld toont hoe je een horizontale/verticale resolutie van een TIFF-afbeelding kunt instellen.

string dir = "c:\\temp\\";

                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                 {
                                                                                                     Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                                     // Get horizontal and vertical resolution of the TiffImage.
                                                                                                     double horizontalResolution = tiffImage.HorizontalResolution;
                                                                                                     double verticalResolution = tiffImage.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");
                                                                                                         tiffImage.SetResolution(96.0, 96.0);

                                                                                                         System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", tiffImage.HorizontalResolution);
                                                                                                         System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", tiffImage.VerticalResolution);
                                                                                                     }
                                                                                                 }

Remarks

Opmerking per standaard deze waarde is altijd 96 omdat verschillende platforms de resolutie van het scherm niet kunnen retourneren. u kunt overwegen om de SetResolution-methode te gebruiken om beide resolutiewaarden in één oproep te updaten.

PageCount

Verwijder het totale aantal pagina’s binnen het aangegeven document, faciliterenefficiënte navigatie en het beheer van meerpagina-inhoud.functionaliteit om de gebruikerservaring te verbeteren, waardoor onmiddellijk toegang totuitgebreide documentstructuur.

public override int PageCount { get; }

Eigendomswaarde

int

Pages

Onmiddellijk toegang tot de pagina’s van het document, waardoor dynamische navigatie enmanipulatie binnen de inhoudstructuur. versterken uw applicatie efficiënttoegang tot individuele pagina’s, het vergemakkelijken van een snelle documentverwerking enVerbeterde gebruikersinteractie.

public override Image[] Pages { get; }

Eigendomswaarde

Image []

PremultiplyComponents

Indiceren of de componenten een premultiplicatie nodig hebben, waardoor efficiënte manipulatie wordt gewaarborgdvan visuele elementen. verbetering van renderingsprocessen door deze eigenschap te genomen,Graphic workflows voor geoptimaliseerde prestaties.

public override bool PremultiplyComponents { get; set; }

Eigendomswaarde

bool

Examples

Het volgende voorbeeld creëert een nieuwe TIFF-afbeelding, slaat de aangegeven halve transparante pixels op, loopt dan die pixelen en krijgt uiteindelijke kleuren in de premultiplierde vorm.

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.TiffOptions createOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Aspose.Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.TiffDeflateRgba);
                                                                                                                                                                                createOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream(), true);

                                                                                                                                                                                using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Create(createOptions, imageWidth, imageHeight))
                                                                                                                                                                                {
                                                                                                                                                                                    // Save pixels for the whole image.
                                                                                                                                                                                    image.SavePixels(image.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;
                                                                                                                                                                                    image.PremultiplyComponents = true;
                                                                                                                                                                                    Aspose.Imaging.Color[] premultipliedColors = image.LoadPixels(image.Bounds);

                                                                                                                                                                                    for (int i = 0; i &lt; colors.Length; i++)
                                                                                                                                                                                    {
                                                                                                                                                                                        System.Console.WriteLine("Original color: {0}", colors[i].ToString());
                                                                                                                                                                                        System.Console.WriteLine("Premultiplied color: {0}", premultipliedColors[i].ToString());
                                                                                                                                                                                    }
                                                                                                                                                                                }

                                                                                                                                                                                //The output will look like this:
                                                                                                                                                                                //Original color: Color [A=127, R=255, G=0, B=0]
                                                                                                                                                                                //Premultiplied color: Color [A=127, R=127, G=0, B=0]
                                                                                                                                                                                //Original color: Color [A=127, R=0, G=255, B=0]
                                                                                                                                                                                //Premultiplied color: Color [A=127, R=0, G=127, B=0]
                                                                                                                                                                                //Original color: Color [A=127, R=0, G=0, B=255]
                                                                                                                                                                                //Premultiplied color: Color [A=127, R=0, G=0, B=127]
                                                                                                                                                                                //Original color: Color [A=127, R=255, G=255, B=0]
                                                                                                                                                                                //Premultiplied color: Color [A=127, R=127, G=127, B=0]
                                                                                                                                                                                //Original color: Color [A=127, R=255, G=0, B=255]
                                                                                                                                                                                //Premultiplied color: Color [A=127, R=127, G=0, B=127]
                                                                                                                                                                                //Original color: Color [A=127, R=0, G=255, B=255]
                                                                                                                                                                                //Premultiplied color: Color [A=127, R=0, G=127, B=127]

VerticalResolution

Toegang tot de verticale resolutie van de aangegeven Aspose.Imaging.Image in pixels perinch, waardoor nauwkeurige aanpassingen en rendering optimalisaties mogelijk zijn.beeldgegevens moeiteloos om beeldverwerking werkstromen te vergemakkelijken, waarborgenhogere kwaliteit en prestaties in uw toepassingen.

public override double VerticalResolution { get; set; }

Eigendomswaarde

double

Examples

Het volgende voorbeeld toont hoe je een horizontale/verticale resolutie van een TIFF-afbeelding kunt instellen.

string dir = "c:\\temp\\";

                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                 {
                                                                                                     Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                                     // Get horizontal and vertical resolution of the TiffImage.
                                                                                                     double horizontalResolution = tiffImage.HorizontalResolution;
                                                                                                     double verticalResolution = tiffImage.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");
                                                                                                         tiffImage.SetResolution(96.0, 96.0);

                                                                                                         System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", tiffImage.HorizontalResolution);
                                                                                                         System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", tiffImage.VerticalResolution);
                                                                                                     }
                                                                                                 }

Remarks

Opmerking per standaard deze waarde is altijd 96 omdat verschillende platforms de resolutie van het scherm niet kunnen retourneren. u kunt overwegen om de SetResolution-methode te gebruiken om beide resolutiewaarden in één oproep te updaten.

Methods

Add(TiffImage)

Voeg de kaders van de aangegeven afbeelding naadloos toe aan het huidige kader,consolidatie van hun inhoud en verbetering van de samenstellingsflexibiliteit.deze methode om het frame management en de manipulatie binnen uwtoepassing, het vergemakkelijken van efficiënte verwerking van multi-frame beelden.

public void Add(TiffImage image)

Parameters

image TiffImage

De bron van het beeld.

AddFrame(TiffFrame)

Introduceer het aangegeven kader naadloos in de afbeelding, uitbreid zijn inhoudgebruik deze methode om de beeldcompositie en het beheer te verbeteren,het verbeteren van de efficiënte beheer van multi-frame beelden binnen uw applicatie.

public void AddFrame(TiffFrame frame)

Parameters

frame TiffFrame

Het frame om toe te voegen.

Examples

Het volgende voorbeeld toont hoe je een mutlipage TIFF kunt composeren van individuele rasterbeelden.

Aspose.Imaging.ImageOptions.TiffOptions createTiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Aspose.Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);
                                                                                                     createTiffOptions.Source = new Aspose.Imaging.Sources.FileCreateSource("c:\\temp\\multipage.tif", false);
                                                                                                     createTiffOptions.Photometric = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPhotometrics.Rgb;
                                                                                                     createTiffOptions.BitsPerSample = new ushort[] { 8, 8, 8 };

                                                                                                     using (Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Image.Create(createTiffOptions, 100, 100))
                                                                                                     {
                                                                                                         // This is Font and Brush for drawing text on individual frames.
                                                                                                         Aspose.Imaging.Font font = new Aspose.Imaging.Font("Arial", 64);
                                                                                                         Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.White);

                                                                                                         // Create 5 frames
                                                                                                         for (int i = 1; i &lt;= 5; i++)
                                                                                                         {
                                                                                                             Aspose.Imaging.ImageOptions.PngOptions createPngOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                             createPngOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());

                                                                                                             // Create a PNG image and draw the number of page on it.
                                                                                                             Aspose.Imaging.FileFormats.Png.PngImage pngImage = (Aspose.Imaging.FileFormats.Png.PngImage)Image.Create(createPngOptions, 100, 100);
                                                                                                             Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(pngImage);
                                                                                                             gr.DrawString(i.ToString(), font, brush, 10, 10);

                                                                                                             // Create a frame based on the PNG image.
                                                                                                             Aspose.Imaging.FileFormats.Tiff.TiffFrame frame = new Aspose.Imaging.FileFormats.Tiff.TiffFrame(pngImage);

                                                                                                             // Add the frame to the TIFF image.
                                                                                                             tiffImage.AddFrame(frame);
                                                                                                         }

                                                                                                         // The image was created with a single default frame. Let's remove it.
                                                                                                         Aspose.Imaging.FileFormats.Tiff.TiffFrame activeFrame = tiffImage.ActiveFrame;
                                                                                                         tiffImage.ActiveFrame = tiffImage.Frames[1];
                                                                                                         tiffImage.RemoveFrame(0);

                                                                                                         // Don't forget to dispose the frame if you won't add it to some other TiffImage
                                                                                                         activeFrame.Dispose();

                                                                                                         tiffImage.Save();
                                                                                                     }

AddFrames(TiffFrame[])

Integreer de reeks frame’s naadloos in de afbeelding, verrijkt de inhoud enversatiliteit. gebruik deze methode om de beeldcompositie en het beheer te verbeteren,het mogelijk maken van efficiënte verwerking van multi-frame beelden binnen uw applicatie.

public void AddFrames(TiffFrame[] frames)

Parameters

frames TiffFrame []

De frame’s array toe te voegen

AddPage(RasterImage)

Incorporeren van een nieuwe pagina in de bestaande afbeelding naadloos, het uitbreiden van de inhouden versatiliteit. gebruik deze methode om de samenstelling van het document te verbeteren enbeheer, het efficiënt beheren van meerdere pagina’s afbeeldingen binnen uw applicatie.

public virtual void AddPage(RasterImage page)

Parameters

page RasterImage

De pagina om toe te voegen.

Exceptions

ArgumentNullException

page’ is null.

AdjustBrightness(Int)

Implementeren brightness’ aanpassing voor de afbeelding, waardoor de themodification van de algemene luminance niveaus mogelijk is.Integreer deze methode in uw beeldverwerkingswerkstroom om zichtbaarheid te verbeteren en de visuele kwaliteit van foto’s binnen uw applicatie.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

De briljante waarde.

Examples

Het volgende voorbeeld uitvoert de helderheidcorrectie van een TIFF-afbeelding.

string dir = "c:\\temp\\";

                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                {
                                                                                    Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                    // Set the brightness value. The accepted values of brightness are in the range [-255, 255].
                                                                                    tiffImage.AdjustBrightness(50);
                                                                                    tiffImage.Save(dir + "sample.AdjustBrightness.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                }

AdjustContrast(Vloot)

Verbeter het contrast van de Aspose.Imaging.Image instantie,versterking van de verschillen tussen de licht- en donkere gebieden.functionaliteit om de visuele duidelijkheid en de algemene kwaliteit van het beeld te verbeterenbinnen uw aanvraag.

public override void AdjustContrast(float contrast)

Parameters

contrast float

Contrastwaarde (in bereik [-100; 100])

Examples

Het volgende voorbeeld uitvoert een contrastcorrectie van een TIFF-afbeelding.

string dir = "c:\\temp\\";

                                                                              using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                              {
                                                                                  Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                  // Set the contrast value. The accepted values of contrast are in the range [-100f, 100f].
                                                                                  tiffImage.AdjustContrast(50f);
                                                                                  tiffImage.Save(dir + "sample.AdjustContrast.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                              }

AdjustGamma(Vloot)

Gamma-correctie toepassen op de afbeelding, pixelintensiteiten aanpassen totgewenst kleurbalans.Integreer deze methode in uw beeldverwerkingwerkstromen om de visuele kwaliteit te verbeteren en de nauwkeurigheid van deAnalyse of weergave taken binnen uw aanvraag.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma voor rode, groene en blauwe kanalen coëfficiënt

Examples

Het volgende voorbeeld uitvoert een gamma-correctie van een TIFF-afbeelding.

string dir = "c:\\temp\\";

                                                                           using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                           {
                                                                               Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                               // Set gamma coefficient for red, green and blue channels.
                                                                               tiffImage.AdjustGamma(2.5f);
                                                                               tiffImage.Save(dir + "sample.AdjustGamma.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                           }

AdjustGamma(De vloot, de vloot, de vloot)

Gema-correctie uitvoeren op het beeld met behulp van individuele coëfficiënten voor rood,groene en blauwe kanalen, waardoor fijne aanpassingen van kleurbalans mogelijk zijnen contrast. integreren van deze methode in uw beeldverwerking pipeline omZorg voor nauwkeurige controle over kleur rendering en verbeterde visuele trouwheid binnenUw aanvraag .

public override void AdjustGamma(float gammaRed, float gammaGreen, float gammaBlue)

Parameters

gammaRed float

Gamma voor de rode kanaal coefficiënt

gammaGreen float

Gamma voor groene kanaal coëfficiënt

gammaBlue float

Gamma voor blauw kanaal coefficiënt

Examples

Het volgende voorbeeld uitvoert een gamma-correctie van een TIFF-afbeelding die verschillende coëfficiënten toepast op kleurcomponenten.

string dir = "c:\\temp\\";

                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                {
                                                                                                                                    Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                                                                    // Set individual gamma coefficients for red, green and blue channels.
                                                                                                                                    tiffImage.AdjustGamma(1.5f, 2.5f, 3.5f);
                                                                                                                                    tiffImage.Save(dir + "sample.AdjustGamma.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                }

AlignResolutions()

Implementeren van de AlignResolutions helper methode om horizontale synchronisatie enverticale resoluties, het garanderen van uniformiteit in beelddimensies. deze functionaliteitvergemakkelijkt snelle beeldverwerking werkstromen door harmonisatie van resolutieparameters, het optimaliseren van visuele kwaliteit en consistentie op verschillende platforms enDe apparaten.

public void AlignResolutions()

BinarizeBradley(Twee keer, int)

Implementeren van binarisatie op het beeld met behulp van Bradley’s adaptieve thresholdingalgorithme met integrale beeldgrenzen. deze benadering dynamisch berekentlokale grenzen gebaseerd op de nabijheid van de afbeelding, waardoor de aanpassingsvermogen wordt verbeterd totvariërende verlichtingsomstandigheden en een stevige segmentatie te garanderen voor latereverwerking van taken binnen uw aanvraag.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

Het lichtverschil tussen de pixel en het gemiddelde van een s x s venster van pixelsHet gaat om deze pixel.

windowSize int

De grootte van de s x s venster van pixels centraal rond deze pixel

Examples

Het volgende voorbeeld binarisert een TIFF-afbeelding met Bradley’s adaptieve grenzenalgoritme met de aangegeven venstergrootte.

string dir = "c:\\temp\\";

                                                                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                                                                                {
                                                                                                                                                                                                    Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)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.
                                                                                                                                                                                                    tiffImage.BinarizeBradley(5, 10);
                                                                                                                                                                                                    tiffImage.Save(dir + "sample.BinarizeBradley5_10x10.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                                                }

BinarizeFixed(byte)

Binarisatie toepassen op de afbeelding met behulp van een vooraf gedefinieerde drempel, om te zetten ineen binaire afbeelding met onderscheidende voor- en achtergrondgebieden.methode in uw beeldverwerking workflow om segmentatie en functie te vergemakkelijkenextract taken, het verbeteren van de nauwkeurigheid en efficiëntie van beeldanalyse binnenUw aanvraag .

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

als de overeenkomstige grijze waarde van een pixel groter is dan de grenswaarde, een255 wordt daartoe toegewezen, 0 anders.

Examples

Het volgende voorbeeld binarisert een TIFF-afbeelding met de vooraf gedefinieerde drempel.Binariseerde afbeeldingen bevatten slechts 2 kleuren - zwart en wit.

string dir = "c:\\temp\\";

                                                                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                                {
                                                                                                                                                    Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)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.
                                                                                                                                                    tiffImage.BinarizeFixed(127);
                                                                                                                                                    tiffImage.Save(dir + "sample.BinarizeFixed.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                }

BinarizeOtsu()

Gebruik Otsu thresholding om binarisatie op het beeld uit te voeren, automatischhet bepalen van de optimale grenswaarde op basis van het histogram.deze methode in uw beeldverwerkingswerkstroom om effectieve segmentatie te bereikenen functie extractie, het verbeteren van de nauwkeurigheid en betrouwbaarheid van beeldanalysetaken binnen uw aanvraag.

public override void BinarizeOtsu()

Examples

Het volgende voorbeeld binarisert een TIFF-afbeelding met Otsu thresholding. Binariseerde afbeeldingen bevatten slechts 2 kleuren - zwart en wit.

string dir = "c:\\temp\\";

                                                                                                                                         using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                         {
                                                                                                                                             Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                                                                             // Binarize the image with Otsu thresholding.
                                                                                                                                             tiffImage.BinarizeOtsu();
                                                                                                                                             tiffImage.Save(dir + "sample.BinarizeOtsu.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                         }

Crop(Rectangle)

Groeien de afbeelding met behulp van een aangegeven rectangulaire regio, waardoor nauwkeurige selectie vangeïntegreer deze methode in uw beeldverwerking workflowefficiënt verwijderen van ongewenste gebieden en zich richten op essentiële details, het verbeteren van dealgemene duidelijkheid en samenstelling van het beeld.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

De rechthoek.

Examples

Het volgende voorbeeld verzamelt een TIFF-afbeelding. het vergrendelingsgebied wordt aangegeven via Aspose.Imaging.Rectangle.

string dir = "c:\\temp\\";

                                                                                                                    using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                    {
                                                                                                                        Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                                                        // Crop the image. The cropping area is the rectangular central area of the image.
                                                                                                                        Aspose.Imaging.Rectangle area = new Aspose.Imaging.Rectangle(tiffImage.Width / 4, tiffImage.Height / 4, tiffImage.Width / 2, tiffImage.Height / 2);
                                                                                                                        tiffImage.Crop(area);

                                                                                                                        // Save the cropped image to PNG
                                                                                                                        tiffImage.Save(dir + "sample.Crop.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                    }

Crop(int, int, int, int, int)

Het uitvoeren van het graven op de afbeelding door wijzigingen in de linker, rechter, bovenste endeze methode zorgt voor een nauwkeurige selectie van de gewenste portiehet beeld, het vergemakkelijken van efficiënte verwijdering van ongewenste gebieden en het focussen opessentieel content. integreren van deze functionaliteit in uw beeldverwerkingpipeline om de helderheid en samenstelling te verbeteren als nodig binnen uw toepassing.

public override void Crop(int leftShift, int rightShift, int topShift, int bottomShift)

Parameters

leftShift int

De linker verandert.

rightShift int

De juiste wisseling.

topShift int

De top shift.

bottomShift int

De bodem verandert.

Examples

Het volgende voorbeeld groeit een TIFF-afbeelding. de groeiplaats wordt aangegeven via de linker, top, rechter, onderste marge.

string dir = @"c:\temp\";

                                                                                                                         using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                         {
                                                                                                                             Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                                                             // Crop again. Set a margin of 10% of the image size.
                                                                                                                             int horizontalMargin = tiffImage.Width / 10;
                                                                                                                             int verticalMargin = tiffImage.Height / 10;
                                                                                                                             tiffImage.Crop(horizontalMargin, horizontalMargin, verticalMargin, verticalMargin);

                                                                                                                             // Save the cropped image to PNG.
                                                                                                                             tiffImage.Save(dir + "sample.Crop.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                         }

Dither(DitheringMethod, int, IColorPalette)

Het uitvoeren van de dithering op het huidige beeld om de visuele kwaliteit te verbeteren en te verminderenkleur binding artefacten. integreren van deze methode in uw beeldverwerking workflowzorgen voor gladere overgangen tussen kleuren, wat resulteert in een betere algemene afbeeldingverschijning en duidelijkheid.

public override void Dither(DitheringMethod ditheringMethod, int bitsCount, IColorPalette customPalette)

Parameters

ditheringMethod DitheringMethod

De Dithering Methode.

bitsCount int

De laatste bits tellen voor dithering.

customPalette IColorPalette

De gewone palet voor dithering.

Examples

Het volgende voorbeeld loopt een TIFF-afbeelding en uitvoert grenzen en vloeibare dithering met behulp van verschillende paletdichtheid.

string dir = "c:\\temp\\";

                                                                                                                             using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                             {
                                                                                                                                 Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)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.
                                                                                                                                 tiffImage.Dither(Aspose.Imaging.DitheringMethod.ThresholdDithering, 4, null);

                                                                                                                                 tiffImage.Save(dir + "sample.ThresholdDithering4.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                             }

                                                                                                                             using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                             {
                                                                                                                                 Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)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.
                                                                                                                                 tiffImage.Dither(Aspose.Imaging.DitheringMethod.FloydSteinbergDithering, 1, null);

                                                                                                                                 tiffImage.Save(dir + "sample.FloydSteinbergDithering1.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                             }

Filter(Rectangle, FilterOptionsBase)

Filteren van de inhoud binnen de aangegeven rectangle, het toepassen van een aangewezen afbeeldingverwerkingsfilter om de geselecteerde regio te verbeteren of te wijzigen.in uw beeldmanipulatie werkstromen om gerichte verbeteringen te bereiken ofTransformaties binnen uw applicatie.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

De rechthoek.

options FilterOptionsBase

De opties .

Examples

Het volgende voorbeeld geldt voor verschillende soorten filters voor een TIFF-afbeelding.

string dir = "c:\\temp\\";

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                      // Apply a median filter with a rectangle size of 5 to the entire image.
                                                                                      tiffImage.Filter(tiffImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MedianFilterOptions(5));
                                                                                      tiffImage.Save(dir + "sample.MedianFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                      // Apply a bilateral smoothing filter with a kernel size of 5 to the entire image.
                                                                                      tiffImage.Filter(tiffImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.BilateralSmoothingFilterOptions(5));
                                                                                      tiffImage.Save(dir + "sample.BilateralSmoothingFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                      // Apply a Gaussian blur filter with a radius of 5 and a sigma value of 4.0 to the entire image.
                                                                                      tiffImage.Filter(tiffImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.GaussianBlurFilterOptions(5, 4.0));
                                                                                      tiffImage.Save(dir + "sample.GaussianBlurFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                      // Apply a Gauss-Wiener filter with a radius of 5 and a smooth value of 4.0 to the entire image.
                                                                                      tiffImage.Filter(tiffImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.GaussWienerFilterOptions(5, 4.0));
                                                                                      tiffImage.Save(dir + "sample.GaussWienerFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)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.
                                                                                      tiffImage.Filter(tiffImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.MotionWienerFilterOptions(10, 1.0, 90.0));
                                                                                      tiffImage.Save(dir + "sample.MotionWienerFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

                                                                                  using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                  {
                                                                                      Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                      // Apply a sharpen filter with a kernel size of 5 and a sigma value of 4.0 to the entire image.
                                                                                      tiffImage.Filter(tiffImage.Bounds, new Aspose.Imaging.ImageFilters.FilterOptions.SharpenFilterOptions(5, 4.0));
                                                                                      tiffImage.Save(dir + "sample.SharpenFilter.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                  }

GetOriginalOptions()

Retrieve opties die afkomstig zijn van de oorspronkelijke bestandinstellingen, het vergemakkelijken van seamlessbehoud van belangrijke parameters zoals bit-diepte en andere essentiële attributen vangebruik deze methode om trouw en consistentie te behouden inbeeldverwerking taken, het garanderen van optimale resultaten zonder onnodige wijzigingen.Bijvoorbeeld, als we een zwarte en witte PNG-afbeelding opladen met 1 bit per pixel en dan het opslaan met behulp van deAspose.Imaging.DataStreamSupporter.Save(System.String) methode, de output PNG-afbeelding met 8 bits per pixel zal worden geproduceerd.Om dit te voorkomen en PNG-afbeelding met 1 bits per pixel te besparen, gebruik deze methode om de overeenkomstige besparingsopties te krijgen en ze te passeren.De methode Aspose.Imaging.Image.Save(System.String,_Wl17. ImageOptionsBase) is de tweede parameter.

public override ImageOptionsBase GetOriginalOptions()

Returns

ImageOptionsBase

De opties gebaseerd op de oorspronkelijke bestandinstellingen.

Exceptions

TiffImageException

Er zijn geen originele opties die uit de afbeelding kunnen worden geïntroduceerd

Grayscale()

Converteer het beeld naar zijn grayscale vertegenwoordiging, waardoor het in eenéén kanaal beeld waar elk pixel de intensiteit vertegenwoordigt.in uw beeldverwerking pipeline om de analyse te vereenvoudigen en te verbeterencompatibiliteit met grayscale-gebaseerde algoritmen, het vergemakkelijken van verschillende computersvisuele en beeldanalyse taken binnen uw applicatie.

public override void Grayscale()

Examples

Het volgende voorbeeld transformeert een gekleurde TIFF-afbeelding naar zijn grayscale-representatie.Grayescale’s zijn uitsluitend samengesteld uit schaduwen van grijze en dragen alleen informatie over intensiteit.

string dir = "c:\\temp\\";

                                                                                                                                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                                                                                   {
                                                                                                                                                                                                       Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                                                                                                                                       tiffImage.Grayscale();
                                                                                                                                                                                                       tiffImage.Save(dir + "sample.Grayscale.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                                                   }

InsertFrame(Het is TiffFrame)

Introduceer het nieuwe kader in de aangegeven index binnen de kaderseksen, zodatnauwkeurige controle over frame arrangement. gebruik deze methode om frame te beherensequenties effectief, faciliteren dynamische manipulatie en organisatie van het beeldInhoud binnen uw aanvraag.

public void InsertFrame(int index, TiffFrame frameToInsert)

Parameters

index int

Index van het nieuwe kader in de lijst van kaders

frameToInsert TiffFrame

Het frame om in te voeren.

NormalizeAngle(Bool, kleur)

Gebruik de NormalizeAngle-methode die specifiek is ontworpen voor gescande tekstdocumentenom gescheide scans te corrigeren, waarborgen voor nauwkeurige aanpassing.integreren van deze functionaliteit in uw tekstverwerking werkstromen om te verbeterendocument leesbaarheid en kwaliteit, het verbeteren van de algemene efficiëntie in de tekstrecognitieen analytische taken.Deze methode maakt gebruik van de Aspose.Imaging.RasterImage.GetSkewAngle en de Wl17.FileFormats.Tiff. TiffImages.Rootate(System.Single,Systems.Boolean,W L17__.Color) methoden.

public override void NormalizeAngle(bool resizeProportionally, Color backgroundColor)

Parameters

resizeProportionally bool

als je ’true’ hebt ingesteld, zal je afbeeldingsgrootte worden gewijzigd in overeenstemming met rotatie rectangle (kornpunten) projecties in het andere geval dat de afmetingen niet aanraakt en alleen de interne afbeeldingsinhoud wordt rotatieerd.

backgroundColor Color

De kleur van de achtergrond.

ReleaseManagedResources()

Verwijder de beheerde middelen. zorg ervoor dat geen beheerde middelen hier worden vrijgegeven, omdat ze misschien al zijn vrijgegeven.

protected override void ReleaseManagedResources()

RemoveFrame(Int)

Onvoldoende verwijderen van het door zijn index geïdentificeerde kader uit de afbeeldingssecentie,Frame management in uw applicatie. integreren ditfunctionaliteit om efficiëntie en nauwkeurigheid in frame manipulatie te verbeteren,het vergemakkelijken van onbeperkte organisatie en presentatie van beeldinhoud.

public TiffFrame RemoveFrame(int index)

Parameters

index int

De index van het frame moet worden verwijderd.

Returns

TiffFrame

De verwijderde frame.

Examples

Het volgende voorbeeld toont hoe je een mutlipage TIFF kunt composeren van individuele rasterbeelden.

Aspose.Imaging.ImageOptions.TiffOptions createTiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Aspose.Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);
                                                                                                     createTiffOptions.Source = new Aspose.Imaging.Sources.FileCreateSource("c:\\temp\\multipage.tif", false);
                                                                                                     createTiffOptions.Photometric = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPhotometrics.Rgb;
                                                                                                     createTiffOptions.BitsPerSample = new ushort[] { 8, 8, 8 };

                                                                                                     using (Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Image.Create(createTiffOptions, 100, 100))
                                                                                                     {
                                                                                                         // This is Font and Brush for drawing text on individual frames.
                                                                                                         Aspose.Imaging.Font font = new Aspose.Imaging.Font("Arial", 64);
                                                                                                         Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.White);

                                                                                                         // Create 5 frames
                                                                                                         for (int i = 1; i &lt;= 5; i++)
                                                                                                         {
                                                                                                             Aspose.Imaging.ImageOptions.PngOptions createPngOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                             createPngOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());

                                                                                                             // Create a PNG image and draw the number of page on it.
                                                                                                             Aspose.Imaging.FileFormats.Png.PngImage pngImage = (Aspose.Imaging.FileFormats.Png.PngImage)Image.Create(createPngOptions, 100, 100);
                                                                                                             Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(pngImage);
                                                                                                             gr.DrawString(i.ToString(), font, brush, 10, 10);

                                                                                                             // Create a frame based on the PNG image.
                                                                                                             Aspose.Imaging.FileFormats.Tiff.TiffFrame frame = new Aspose.Imaging.FileFormats.Tiff.TiffFrame(pngImage);

                                                                                                             // Add the frame to the TIFF image.
                                                                                                             tiffImage.AddFrame(frame);
                                                                                                         }

                                                                                                         // The image was created with a single default frame. Let's remove it.
                                                                                                         Aspose.Imaging.FileFormats.Tiff.TiffFrame activeFrame = tiffImage.ActiveFrame;
                                                                                                         tiffImage.ActiveFrame = tiffImage.Frames[1];
                                                                                                         tiffImage.RemoveFrame(0);

                                                                                                         // Don't forget to dispose the frame if you won't add it to some other TiffImage
                                                                                                         activeFrame.Dispose();

                                                                                                         tiffImage.Save();
                                                                                                     }

Remarks

Opmerking: vergeet niet om het kader te plaatsen als u het niet toevoegt aan een andere TiffImage.

RemoveFrame(TiffFrame)

Effectief verwijderen van de aangegeven frame uit de afbeeldingssecentie, het vergemakkelijken vangerenoveerd kaderbeheer binnen uw applicatie. integreren van deze functionaliteitom nauwkeurigheid en flexibiliteit te verbeteren in het kader van de manipulatie, waarborgenOrganisatie en presentatie van beeldinhoud.

public void RemoveFrame(TiffFrame frame)

Parameters

frame TiffFrame

Het frame om te verwijderen.

Remarks

Opmerking: vergeet niet om het kader te plaatsen als u het niet toevoegt aan een andere TiffImage.

RemoveMetadata()

Verwijder deze afbeeldingsinstantie metadata door deze Aspose.Imaging.Xmp.IHasXmpData.xmpDat en Wl17.Exif.IHasExifDate. Null.

public override void RemoveMetadata()

ReplaceFrame(Het is TiffFrame)

Vervang het kader in de aangegeven positie met een ander frame naadloos,het faciliteren van dynamische kaderbeheer binnen de beeldsequentie.methode om flexibiliteit en nauwkeurigheid te verbeteren in frame manipulatie,optimale organisatie en presentatie van beeldinhoud binnen uw applicatie.

public TiffFrame ReplaceFrame(int index, TiffFrame frameToReplace)

Parameters

index int

De nul gebaseerde frame positie.

frameToReplace TiffFrame

Het frame om te vervangen.

Returns

TiffFrame

De verwijderde frame.

Remarks

Opmerking: vergeet niet om het kader te plaatsen als u het niet toevoegt aan een andere TiffImage.

Resize(int, int, resizeType)

Reset de afbeelding volgens een bepaald resingtype, waardoor het flexibel isaanpassing van afbeeldingsdimensies terwijl het aspectverhouding behouden of specifieke toepassingenscaling algorithmen. integreren van deze methode in uw beeldverwerking workflowom nauwkeurige controle te bereiken over resing-operaties binnen uw aanvraag.

public override void Resize(int newWidth, int newHeight, ResizeType resizeType)

Parameters

newWidth int

De nieuwe breedte.

newHeight int

De nieuwe hoogte.

resizeType ResizeType

De resize type.

Examples

Dit voorbeeld loopt een TIFF-afbeelding en resecteert het met behulp van verschillende resisatiemethoden.

string dir = "c:\\temp\\";

                                                                                         using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                         {
                                                                                             // Scale up by 2 times using Nearest Neighbour resampling.
                                                                                             image.Resize(image.Width* 2, image.Height* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                             // Save to PNG with default options.
                                                                                             image.Save(dir + "upsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                         }

                                                                                         using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                         {
                                                                                             // Scale down by 2 times using Nearest Neighbour resampling.
                                                                                             image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                             // Save to PNG with default options.
                                                                                             image.Save(dir + "downsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                         }

                                                                                         using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                         {
                                                                                             // Scale up by 2 times using Bilinear resampling.
                                                                                             image.Resize(image.Width* 2, image.Height* 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                             // Save to PNG with default options.
                                                                                             image.Save(dir + "upsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                         }

                                                                                         using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                         {
                                                                                             // Scale down by 2 times using Bilinear resampling.
                                                                                             image.Resize(image.Width / 2, image.Height / 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                             // Save to PNG with default options.
                                                                                             image.Save(dir + "downsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                         }

Resize(int, int, ImageResizeSettings)

De grootte van de afbeelding aanpassen op basis van specifieke instellingen, waardoor de nauwkeurigheidcontrole over dimensies, aspect ratio en scaling gedrag.methode in uw beeldverwerking workflow om aangepaste resing te bereikenactiviteiten die zijn aangepast aan de specifieke vereisten van uw aanvraag.

public override void Resize(int newWidth, int newHeight, ImageResizeSettings settings)

Parameters

newWidth int

De nieuwe breedte.

newHeight int

De nieuwe hoogte.

settings ImageResizeSettings

De resize instellingen.

Examples

Dit voorbeeld laden een TIFF-afbeelding op en resiseert het met behulp van verschillende resizing-instellingen.

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)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                          {
                                                                                              Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                              // Scale down by 2 times using adaptive resampling.
                                                                                              tiffImage.Resize(image.Width / 2, image.Height / 2, resizeSettings);

                                                                                              // Save to PNG
                                                                                              tiffImage.Save(dir + "downsample.adaptive.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                          }

ResizeHeightProportionally(Int, ResizeType)

Een proportionele aanpassing van de hoogte van het beeld uitvoeren, het aspect behoudenverhouding voor consistente visuele integriteit. gebruik deze methode om dynamisch te herzienafbeeldingen binnen uw applicatie, zorgen voor een optimale weergave op verschillende platformsen apparaten zonder de kwaliteit van de inhoud te ondermijnen.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

De nieuwe hoogte.

resizeType ResizeType

Type van de resize.

Examples

Dit voorbeeld loopt een TIFF-afbeelding en resecteert het evenredig met behulp van verschillende resisatiemethoden. alleen de hoogte wordt aangegeven, de breedte wordt automatisch berekend.

string dir = "c:\\temp\\";

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale up by 2 times using Nearest Neighbour resampling.
                                                                                                                                                                                 image.ResizeHeightProportionally(image.Height* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                                                                                                                 // Save to PNG with the default options.
                                                                                                                                                                                 image.Save(dir + "upsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                             }

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale down by 2 times using Nearest Neighbour resampling.
                                                                                                                                                                                 image.ResizeHeightProportionally(image.Height / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                                                                                                                 // Save to PNG with the default options.
                                                                                                                                                                                 image.Save(dir + "downsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                             }

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale up by 2 times using Bilinear resampling.
                                                                                                                                                                                 image.ResizeHeightProportionally(image.Height* 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                                                                                                                 // Save to PNG with the default options.
                                                                                                                                                                                 image.Save(dir + "upsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                             }

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale down by 2 times using Bilinear resampling.
                                                                                                                                                                                 image.ResizeHeightProportionally(image.Height / 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                                                                                                                 // Save to PNG with the default options.
                                                                                                                                                                                 image.Save(dir + "downsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                             }

ResizeProportional(int, int, resizeType)

Gebruik deze methode om de afbeeldingen dynamisch te scalenIn uw applicatie, zorgen voor consistente visuele vertegenwoordiging van de inhoudintegriteit.De proportionele resize zal elke frame resimeren volgens het ratio van newWidth’/width en newHeight'.

public void ResizeProportional(int newWidth, int newHeight, ResizeType resizeType)

Parameters

newWidth int

De nieuwe breedte.

newHeight int

De nieuwe hoogte.

resizeType ResizeType

De resize type.

ResizeWidthProportionally(Int, ResizeType)

De breedte van de afbeelding aanpassen terwijl het aspectverhouding behoudt, waardoorproportionele resing voor optimale visuele presentatie. gebruik deze methode omdynamisch scaleer afbeeldingen binnen uw applicatie, het faciliteren van consistente enAesthetisch plezierige rendering over verschillende displaycontexten.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

De nieuwe breedte.

resizeType ResizeType

Type van de resize.

Examples

Dit voorbeeld loopt een TIFF-afbeelding en resecteert het evenredig met behulp van verschillende resisatiemethoden. alleen de breedte wordt aangegeven, de hoogte wordt automatisch berekend.

string dir = "c:\\temp\\";

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale up by 2 times using Nearest Neighbour resampling.
                                                                                                                                                                                 image.ResizeWidthProportionally(image.Width* 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                                                                                                                 // Save to PNG with the default options.
                                                                                                                                                                                 image.Save(dir + "upsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                             }

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale down by 2 times using Nearest Neighbour resampling.
                                                                                                                                                                                 image.ResizeWidthProportionally(image.Width / 2, Aspose.Imaging.ResizeType.NearestNeighbourResample);

                                                                                                                                                                                 // Save to PNG with the default options.
                                                                                                                                                                                 image.Save(dir + "downsample.nearestneighbour.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                             }

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale up by 2 times using Bilinear resampling.
                                                                                                                                                                                 image.ResizeWidthProportionally(image.Width* 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                                                                                                                 // Save to PNG with the default options.
                                                                                                                                                                                 image.Save(dir + "upsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                             }

                                                                                                                                                                             using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                                                             {
                                                                                                                                                                                 // Scale down by 2 times using Bilinear resampling.
                                                                                                                                                                                 image.ResizeWidthProportionally(image.Width / 2, Aspose.Imaging.ResizeType.BilinearResample);

                                                                                                                                                                                 // Save to PNG with the default options.
                                                                                                                                                                                 image.Save(dir + "downsample.bilinear.png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                                             }

Rotate(Float, bool, kleur)

Roteren van de afbeelding rond zijn centraal punt met een bepaald hoek, waardoor nauwkeurigheidgeoriënteerde aanpassingen. integreren van deze functionaliteit in uw beeldverwerkingpipeline om nauwkeurige transformaties te vergemakkelijken, optimale aanpassing te garanderen enpresentatie van visuele inhoud binnen uw applicatie.

public override void Rotate(float angle, bool resizeProportionally, Color backgroundColor)

Parameters

angle float

De rotatie van de hoek in graden. positieve waarden zullen rotatie horloge.

resizeProportionally bool

als je ’true’ hebt ingesteld, zal je afbeeldingsgrootte worden gewijzigd in overeenstemming met rotatie rectangle (kornpunten) projecties in het andere geval dat de afmetingen niet aanraakt en alleen de interne afbeeldingsinhoud wordt rotatieerd.

backgroundColor Color

De kleur van de achtergrond.

Examples

Het volgende voorbeeld toont hoe je een TIFF-afbeelding rond het centrum met 45 graden horloge kunt draaien.

string dir = "c:\\temp\\";
                                                                                                            Aspose.Imaging.ImageOptions.TiffOptions createTiffOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Aspose.Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                                            // Create a permanent, not temporary file source.
                                                                                                            createTiffOptions.Source = new Aspose.Imaging.Sources.FileCreateSource(dir + "rotated.tif", false);
                                                                                                            createTiffOptions.Photometric = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPhotometrics.Rgb;
                                                                                                            createTiffOptions.BitsPerSample = new ushort[] { 8, 8, 8 };

                                                                                                            using (Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Image.Create(createTiffOptions, 100, 100))
                                                                                                            {
                                                                                                                // The linear gradient from the left-top to the right-bottom corner of the image.
                                                                                                                Aspose.Imaging.Brushes.LinearGradientBrush brush =
                                                                                                                    new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                                        new Aspose.Imaging.Point(0, 0),
                                                                                                                        new Aspose.Imaging.Point(tiffImage.Width, tiffImage.Height),
                                                                                                                        Aspose.Imaging.Color.Red,
                                                                                                                        Aspose.Imaging.Color.Green);

                                                                                                                // Fill the active frame with the linear gradient brush.
                                                                                                                Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(tiffImage);
                                                                                                                gr.FillRectangle(brush, tiffImage.Bounds);

                                                                                                                // Rotate the image around the center by 45 degrees clockwise. 
                                                                                                                // The image size changed according to rotated rectangle (corner points).
                                                                                                                tiffImage.Rotate(45f, true, Aspose.Imaging.Color.Black);
                                                                                                                tiffImage.Save();

                                                                                                                // Rotate the image around the center by 45 degrees clockwise.
                                                                                                                // Leave the image dimensions untouched and only the internal image content are rotated.
                                                                                                                tiffImage.Rotate(45f, false, Aspose.Imaging.Color.Gray);
                                                                                                                tiffImage.Save(dir + "rotated.preservesize.tif");
                                                                                                            }

RotateFlip(RotateFlipType)

Doen rotatie, flipping of een combinatie van beide operaties uitsluitend op deactief kader. deze methode zorgt voor nauwkeurige manipulatie van individuele kaders binnende beeldsequentie, verbeteren van de flexibiliteit in beeldbewerking en samenstelling binnenUw aanvraag .

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

De rotated flip type.

Examples

Dit voorbeeld laden een TIFF-afbeelding op, draait het rond met 90 graden horloge en flipt optioneel het beeld horizontaal en/of verticaal.

string dir = "c:\\temp\\";

                                                                                                                                              Aspose.Imaging.RotateFlipType[] rotateFlipTypes = new Aspose.Imaging.RotateFlipType[]
                                                                                                                                              {
                                                                                                                                                  Aspose.Imaging.RotateFlipType.Rotate90FlipNone,
                                                                                                                                                  Aspose.Imaging.RotateFlipType.Rotate90FlipX,
                                                                                                                                                  Aspose.Imaging.RotateFlipType.Rotate90FlipXY,
                                                                                                                                                  Aspose.Imaging.RotateFlipType.Rotate90FlipY,
                                                                                                                                              };

                                                                                                                                              foreach (Aspose.Imaging.RotateFlipType rotateFlipType in rotateFlipTypes)
                                                                                                                                              {
                                                                                                                                                  // Rotate, flip and save to the output file.
                                                                                                                                                  using (Aspose.Imaging.FileFormats.Tiff.TiffImage image = (Aspose.Imaging.FileFormats.Tiff.TiffImage)Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                                                                  {
                                                                                                                                                      image.RotateFlip(rotateFlipType);
                                                                                                                                                      image.Save(dir + "sample." + rotateFlipType + ".png", new Aspose.Imaging.ImageOptions.PngOptions());
                                                                                                                                                  }
                                                                                                                                              }

SaveData(Stream)

Speelt de gegevens van het object naar de aangegeven stroom.

protected override void SaveData(Stream stream)

Parameters

stream Stream

De stroom om de gegevens van het object op te slaan.

SetResolution(dubbele, dubbele)

Stel de resolutie voor de aangegeven Aspose.Imaging.RasterImage vast, waardoornauwkeurige controle over beeld rendering en display eigenschappen. integreren dezefunctionaliteit om de visuele output te optimaliseren en compatibiliteit te garanderen met diverseoutput apparaten en platforms, het verbeteren van de algemene gebruikerservaring.

public override void SetResolution(double dpiX, double dpiY)

Parameters

dpiX double

De horizontale resolutie, in punten per inch, van de Aspose.Imaging.RasterImage.

dpiY double

De verticale resolutie, in punten per inch, van de Aspose.Imaging.RasterImage.

Examples

Het volgende voorbeeld toont hoe je een horizontale/verticale resolutie van een TIFF-afbeelding kunt instellen.

string dir = "c:\\temp\\";

                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.tif"))
                                                                                                 {
                                                                                                     Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = (Aspose.Imaging.FileFormats.Tiff.TiffImage)image;

                                                                                                     // Get horizontal and vertical resolution of the TiffImage.
                                                                                                     double horizontalResolution = tiffImage.HorizontalResolution;
                                                                                                     double verticalResolution = tiffImage.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");
                                                                                                         tiffImage.SetResolution(96.0, 96.0);

                                                                                                         System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", tiffImage.HorizontalResolution);
                                                                                                         System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", tiffImage.VerticalResolution);
                                                                                                     }
                                                                                                 }

UpdateDimensions(int, int)

Update de afbeeldingsdimensies.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

De nieuwe beeldbreedte.

newHeight int

De nieuwe beeldhoogte.

Exceptions

NotImplementedException

 Nederlands