Class TiffImage

Class TiffImage

Nazwa przestrzeń: Aspose.Imaging.FileFormats.Tiff Zgromadzenie: Aspose.Imaging.dll (25.4.0)

Proces Tagged Image File Format (TIFF) raster obrazy z naszą API, oferujekompleksowe wsparcie dla różnych rozwiązań i zaawansowanych zdolności edycjijak manipulacja danych EXIF i kanały alfa. Normalizuj kąty dla skanowanych obrazów,odtworzyć, przekształcić w grayscale i zastosować filtry, korekty gamma i obrazparametry dostosowania z łatwością. bezprzewodowo obsługiwanie plików multi-frame TIFF,Tworzenie ścieżek graficznych, dodanie kształtów i bez wysiłku przechowywanie obrazów w różnych formach.

[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

Dziedziczeni członkowie

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

Tworzenie graficznych ścieżek z Path Resources w obrazie TIFF.

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");
                                                                  }

Tworzenie zasobów ścieżek przy użyciu Path Graphics.

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)

Inicjalizuj nowy obiekt klasy Aspose.Imaging.FileFormats.Tiff. TiffImage, określającparametr ramy. ten konstruktor ułatwia tworzenie TiffImagena przykład, umożliwiając deweloperom określenie ram do ładowania lub przetwarzania,ułatwianie zadań związanych z obsługą obrazu Tiff w ramach ich aplikacji.

public TiffImage(TiffFrame frame)

Parameters

frame TiffFrame

Ramy do inicjalizacji obrazu.

Examples

Ten przykład pokazuje, jak utworzyć obraz TIFF z skraju i przechowywać go do pliku.

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’ nie może być pusty.

TiffImage(TiffFrame[])

Tworzenie nowej instancji klasy Aspose.Imaging.FileFormats.Tiff. TiffImage, dostarczając listęramy jako parametr. ten konstruktor umożliwia inicjalizację TiffImageobiektów z wieloma ramami, ułatwiając efektywną obsługę i przetwarzanieSekwencje obrazów TIFF w aplikacjach oprogramowania.

public TiffImage(TiffFrame[] frames)

Parameters

frames TiffFrame [ ]

z ramami .

Examples

Ten przykład pokazuje, jak utworzyć obraz TIFF z 2 ramami i przechowywać go do pliku.

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

Ramy

Properties

ActiveFrame

Zarządzaj aktywnym ramy bezprzewodowo, ułatwiając dynamiczną nawigację imanipulacja w określonym kontekście. umożliwia aplikację do interakcjiefektywnie z treścią multimedialną, zwiększając zaangażowanie użytkowników i produktywność.

public TiffFrame ActiveFrame { get; set; }

Wartość nieruchomości

TiffFrame

Examples

Poniższy przykład pokazuje, jak skomponować mutlipage TIFF z poszczególnych obrazów rasterowych.

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

Łączyć rozkaz bytu dla plików TIFF bezprzewodowo, zapewniając precyzyjną kontrolę nadInterpretacja danych. Umożliwia aplikacje z elastycznością dostosowania się doróżnorodne specyfikacje plików, zwiększając kompatybilność i wydajność przetwarzania danych.

public TiffByteOrder ByteOrder { get; set; }

Wartość nieruchomości

TiffByteOrder

ExifData

Dostęp lub modyfikacja danych EXIF powiązanych z aktywnym ramy bezprzewodowo, umożliwiającdokładna kontrola metadatu obrazu. poprawa zdolności aplikacji przezzintegrować tę funkcję, zapewniając dokładną konserwację i dostosowanieWażne informacje obrazowe.

public ExifData ExifData { get; set; }

Wartość nieruchomości

ExifData

FileFormat

Przywróć wartość formatu pliku powiązaną z obrazem. ta właściwość służy jakokrytyczny aspekt odzyskiwania metadanych obrazu, umożliwiając aplikacje oprogramowania doskutecznie identyfikuje i interpretuje format danych obrazu.

public override FileFormat FileFormat { get; }

Wartość nieruchomości

FileFormat

Frames

Odzyskaj szereg instancji Aspose.Imaging.FileFormats.Tiff. TiffFrame, umożliwiając kompleksowedostęp i manipulacja poszczególnych ram w obrazie TIFF.moc tego array do upraszczania przepływów roboczych przetwarzania obrazu, zapewniając precyzjęKontrola i optymalizacja treści wizualnych.

public TiffFrame[] Frames { get; }

Wartość nieruchomości

TiffFrame [ ]

Examples

Poniższy przykład pokazuje, jak skomponować mutlipage TIFF z poszczególnych obrazów rasterowych.

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

Określenie, czy obraz ma kanał alfa, dostarczając kluczowych informacjido renderowania i kompozycji operacji. Integruj tę funkcję, aby zoptymalizowaćprzepływów pracy przetwarzania wizualnego, zapewniając dokładną reprezentację i manipulacjęprzejrzystych elementów.

public override bool HasAlpha { get; }

Wartość nieruchomości

bool

Examples

Poniższy przykład pobiera obraz TIFF i drukuje informacje na temat formatu surowych danych i kanału alfa.

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

Przywróć rozdzielczość horyzontalną określonego Aspose.Imaging.ZDJĘCIA w pikselachna cala, ułatwiając precyzyjne dostosowanie i zdolności renderowania.niezbędne metadane obrazu bez wysiłku, umożliwiające upraszczone przetwarzanie obrazyPrzepływ pracy dla ulepszonych doświadczeń użytkowników.

public override double HorizontalResolution { get; set; }

Wartość nieruchomości

double

Examples

Poniższy przykład pokazuje, jak ustawić rozdzielczość horyzontalną / pionową obrazu TIFF.

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

Zazwyczaj wartość ta wynosi zawsze 96 ponieważ różne platformy nie mogą zwrócić rozdzielczości ekranu. Możesz rozważyć użycie metody SetResolution, aby zaktualizować oba wartości rozdzielczości w jednym wezwaniu.

PageCount

Przywróć całkowitą liczbę stron w określonym dokumencie, ułatwiającEfektywna nawigacja i zarządzanie treścią multi-page.funkcjonalności w celu poprawy doświadczenia użytkownika, umożliwiając bezprzewodowy dostęp dokompleksowe struktury dokumentów.

public override int PageCount { get; }

Wartość nieruchomości

int

Pages

Bezprzewodowy dostęp do stron dokumentu, umożliwiając dynamiczną nawigację imanipulacja wewnątrz struktury treści. upowszechnianie aplikacji w sposób efektywnydostęp do poszczególnych stron, ułatwiając upraszczone przetwarzanie dokumentów iWzmocniona interakcja użytkownika.

public override Image[] Pages { get; }

Wartość nieruchomości

Image [ ]

PremultiplyComponents

Wskaż, czy składniki wymagają wcześniejszej rozmnażania, zapewniając skuteczną obsługęz elementów wizualnych. ulepszanie procesów renderowania poprzez wstrząśnięcie tą własnością,ułatwienie przepływów graficznych pracy w celu optymalizacji wydajności.

public override bool PremultiplyComponents { get; set; }

Wartość nieruchomości

bool

Examples

Poniższy przykład tworzy nowy obraz TIFF, przechowuje określone półprzejrzałe piksele, a następnie ładuje te piksely i otrzymuje ostateczne kolory w uprzednio powiększonej formie.

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

Dostęp do rozdzielczości pionowej określonego Aspose.Imaging.Zdjęcia w pikselach nawęzły, umożliwiające precyzyjne dostosowania i optymalizacje.dane obrazu bez wysiłku do upraszczania przepływów roboczych przetwarzania obrazów, zapewniającWyższa jakość i wydajność w Twoich aplikacjach.

public override double VerticalResolution { get; set; }

Wartość nieruchomości

double

Examples

Poniższy przykład pokazuje, jak ustawić rozdzielczość horyzontalną / pionową obrazu TIFF.

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

Zazwyczaj wartość ta wynosi zawsze 96 ponieważ różne platformy nie mogą zwrócić rozdzielczości ekranu. Możesz rozważyć użycie metody SetResolution, aby zaktualizować oba wartości rozdzielczości w jednym wezwaniu.

Methods

Add(TiffImage)

Dodaj ramy z określonego obrazu bezprzewodowo do bieżącego ramka,konsolidacja ich treści i zwiększenie elastyczności składowej.ta metoda ułatwia zarządzanie ramami i manipulację w TwoimUłatwienie efektywnej obsługi obrazów wielokształtowych.

public void Add(TiffImage image)

Parameters

image TiffImage

Zdjęcie źródłowe .

AddFrame(TiffFrame)

Włączyć określony ramy bezprzewodowo do obrazu, rozszerzając jego zawartośći wszechstronność. użyj tej metody, aby poprawić kompozycję obrazu i zarządzanie,Umożliwia efektywne zarządzanie obrazami wielokątnymi w Twojej aplikacji.

public void AddFrame(TiffFrame frame)

Parameters

frame TiffFrame

Ramy do dodania.

Examples

Poniższy przykład pokazuje, jak skomponować mutlipage TIFF z poszczególnych obrazów rasterowych.

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[])

Integruj szereg ram bezwzględnie do obrazu, wzbogacając jego zawartość iwszechstronność. użyj tej metody, aby poprawić kompozycję i zarządzanie obrazem,umożliwia efektywną obsługę obrazów wielokątnych w Twojej aplikacji.

public void AddFrames(TiffFrame[] frames)

Parameters

frames TiffFrame [ ]

Rękawiczki do dodawania

AddPage(RasterImage)

Włączyć nową stronę do istniejącego obrazu bezprzewodowo, rozszerzając jego zawartośći wszechstronność. użyj tej metody, aby poprawić skład dokumentu iZarządzanie, umożliwiając efektywne zarządzanie wielokątnymi obrazami w Twojej aplikacji.

public virtual void AddPage(RasterImage page)

Parameters

page RasterImage

Strona do dodania.

Exceptions

ArgumentNullException

page’ is null.

AdjustBrightness(Int)

Wdrażaj dostosowanie jasności do obrazu, umożliwiając themodifikację ogólnych poziomów światła. Włącz tę metodę do twojego przepływu roboczego przetwarzania obrazów w celu zwiększenia widoczności i poprawy jakości wizualnej zdjęć w Twojej aplikacji.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

Wartość jasności .

Examples

Poniższy przykład wykonuje poprawę jasności obrazu TIFF.

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(Floty)

Wzmocnienie kontrastu Aspose.Imaging.Image instancja,wzmacniają różnice między jego światłem a ciemnymi obszarami.funkcjonalność w celu poprawy jasności wizualnej i ogólnej jakości obrazuw ramach Twojego wniosku.

public override void AdjustContrast(float contrast)

Parameters

contrast float

Wartość kontrastu (w zakresie [-100; 100])

Examples

Poniższy przykład wykonuje korektę kontrastu obrazu TIFF.

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(Floty)

Zastosuj korektę gamma do obrazu, dostosowując intensywność pikseli do osiągnięciaPożądany równowaga kolorów. włączyć tę metodę do przetwarzania obrazuprzepływ pracy, aby poprawić jakość wizualną i zwiększyć dokładność następnychAnaliza lub wyświetlanie zadań w Twojej aplikacji.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Gamma dla współczynnika czerwonych, zielonych i niebieskich kanałów

Examples

Poniższy przykład wykonuje korektę gamma obrazu TIFF.

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(float, float i float)

Wykonaj korektę gamma na obrazie za pomocą indywidualnych współczynników dla czerwonego,zielone i niebieskie kanały, umożliwiające delikatnie dopasowane dostosowania równowagi kolorówIntegruj tę metodę w twoją rurociągu przetwarzania obrazu dozapewnienie precyzyjnej kontroli renderowania kolorów i zwiększenie lojalności wizualnej wewnątrzTwoja aplikacja .

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

Parameters

gammaRed float

Gamma dla współczynnika czerwonego kanału

gammaGreen float

Gamma dla współczynnika zielonego kanału

gammaBlue float

Gamma dla współczynnika niebieskiego kanału

Examples

Poniższy przykład wykonuje korektę gamma obrazu TIFF, stosując różne współczynniki dla komponentów kolorowych.

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()

Wdrożenie metody AlignResolutions pomaga synchronizować horyzontalnie irozdzielczości pionowej, gwarantującej jednolitość w wymiarach obrazu.ułatwia upraszczone przepływy robocze przetwarzania obrazu poprzez harmonizację rozdzielczościparametrów, optymalizując jakość wizualną i spójność na różnych platformach iUrządzenia .

public void AlignResolutions()

BinarizeBradley(podwójne, int)

Wdrożenie binaryzacji obrazu wykorzystującego adaptywną granicę Bradleyaalgorytm z integralnym granicą obrazu. ten podejście dynamicznie obliczalokalne granice oparte na sąsiedztwie obrazu, zwiększając adaptację dozróżnicowane warunki oświetlenia i zapewnienie solidnej segmentacji na następneZadania przetwarzania w ramach Twojej aplikacji.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

Różnica jasności pomiędzy pikselem a przeciętnym oknem s x s pixelówWystarczy skupić się wokół tego piksela.

windowSize int

Rozmiar okna s x s pikseli skoncentrowane wokół tego piksela

Examples

Poniższy przykład binaryzuje obraz TIFF z adaptowym algorytmem granicznym Bradleya o określonej wielkości okna.

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)

Zastosuj binaryzację do obrazu za pomocą uprzednio zdefiniowanego próg, przekształcając go wobraz binarny z odrębnymi obszarami przodu i tła.Metoda do Twojego przepływu roboczego przetwarzania obrazu, aby ułatwić segmentację i funkcjezadania ekstrakcyjne, zwiększając dokładność i efektywność analizy obrazu wTwoja aplikacja .

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

W przypadku, gdy odpowiednia wartość szarowa piksela jest większa niż granica, wartości255 zostanie przydzielone do niego, 0 inaczej.

Examples

Poniższy przykład binaryzuje obraz TIFF z uprzednio zdefiniowaną granicą. obrazy binarizowane zawierają tylko 2 kolory - czarny i biały.

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()

Użyj granicy Otsu, aby przeprowadzić binaryzację obrazu, automatycznieokreślając optymalną wartość granicę w oparciu o histogram obrazu.ta metoda wchodzi do twojego przepływu roboczego przetwarzania obrazu w celu osiągnięcia skutecznej segmentacjii funkcja ekstrakcji, zwiększając dokładność i niezawodność analizy obrazuZadania w Twojej aplikacji.

public override void BinarizeOtsu()

Examples

Poniższy przykład binaryzuje obraz TIFF z granicą Otsu. obrazy binarizowane zawierają tylko 2 kolory - czarny i biały.

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)

Roślina obrazu za pomocą określonego rektangularnego regionu, umożliwiając dokładny wybórIntegruj tę metodę w przepływ pracy przetwarzania obrazu doefektywnie usunąć niepożądane obszary i skupić się na istotnych szczegółach, poprawiającCałkowita jasność i skład obrazu.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

z rektangulą .

Examples

Poniższy przykład zawiera obraz TIFF. Obszar gromadzenia jest określony za pośrednictwem 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)

Wykonaj gromadzenie obrazu, określając zmiany w lewej, prawej, górnej iMetoda ta umożliwia dokładny wybór pożądanej porcjiułatwia efektywne usunięcie niepożądanych obszarów i skupia się naIntegruj tę funkcję w procesie obrazururociąg, aby zwiększyć jasność i kompozycję, jak to jest potrzebne w Twojej aplikacji.

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

Parameters

leftShift int

Po lewej zmianie.

rightShift int

Prawdziwa zmiana

topShift int

Najwyższa zmiana

bottomShift int

W dolnej zmianie.

Examples

W poniższym przykładzie rośnie obraz TIFF. Obszar gromadzenia jest określony za pośrednictwem lewicowych, górnych, prawych, dolnych marży.

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(DitheringMetoda, int, IColorPalette)

Wykonaj dystrybucję bieżącego obrazu, aby poprawić jego jakość wizualną i zmniejszyćIntegruj tę metodę w procesie obrazuzapewniają gładkie przejścia między kolorami, co prowadzi do poprawy ogólnego obrazuwygląd i jasność.

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

Parameters

ditheringMethod DitheringMethod

Metoda dystrybucji .

bitsCount int

Ostatnie bity liczą na dystrybucję.

customPalette IColorPalette

Przygotowuje się paletę do Dithering.

Examples

Poniższy przykład ładuje obraz TIFF i wykonuje granicę i przepływ dystrybucji za pomocą różnych głębokości palety.

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)

Filtrowanie treści w określonym rektanglu, stosując wyznaczony obrazfiltr przetwarzania w celu ulepszenia lub modyfikacji wybranego regionu.do przepływu roboczego manipulacji obrazu w celu osiągnięcia celowych ulepszeń lubZmiany w Twojej aplikacji.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

z rektangulą .

options FilterOptionsBase

i opcji .

Examples

Poniższy przykład stosuje różne rodzaje filtrów do obrazu TIFF.

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 opcje pochodzące z oryginalnych ustawień plików, ułatwiając bezprzewodowezachowanie kluczowych parametrów, takich jak głębokość bit i inne istotne atrybutyUżyj tej metody, aby utrzymać lojalność i spójność wZadania przetwarzania obrazu, zapewniające optymalne wyniki bez niepotrzebnych zmian.Na przykład, jeśli ładujemy czarno-biały obraz PNG o 1 bit na piksel, a następnie przechowujemy go za pomocąAspose.Imaging.DataStreamSupporter.Save(System.String) metoda, wydajny obraz PNG z 8-bitowym na piksel zostanie wyprodukowany.Aby tego uniknąć i zaoszczędzić obraz PNG z 1 bitem na piksel, użyj tej metody, aby uzyskać odpowiednie opcje oszczędnościowe i przejść jedo metody Aspose.Imaging.Image.Save(System.String,_Wl17.ImageOptionsBase) jako drugiego parametru.

public override ImageOptionsBase GetOriginalOptions()

Returns

ImageOptionsBase

Opcje oparte na oryginalnych ustawieniach pliku.

Exceptions

TiffImageException

Nie ma oryginalnych opcji, które można wyciągnąć z obrazu

Grayscale()

Konwertuj obraz w jego grayscale, przekształcając go wobraz jednego kanału, w którym każdy piksel reprezentuje intensywność.do Twojego rurociągu przetwarzania obrazu, aby ułatwić analizę i poprawićkompatybilność z algorytmami opartymi na grayscale, ułatwiając różne komputeryZadanie wizji i analizy obrazu w Twojej aplikacji.

public override void Grayscale()

Examples

Poniższy przykład przekształca kolorowy obraz TIFF w jego reprezentację grayscale. obrazy Graysscale składają się wyłącznie z odcieni szary i przynoszą tylko informacje o intensywności.

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(Tłumaczenie: TiffFrame)

Wprowadź nową ramę do określonego indeksu w sekwencji ramowej, zapewniającPrecyzyjna kontrola aranżacji ram. Użyj tej metody do zarządzania ramamisekwencje skutecznie, ułatwiając dynamiczną manipulację i organizację obrazuzawartość w Twojej aplikacji.

public void InsertFrame(int index, TiffFrame frameToInsert)

Parameters

index int

Indeks nowej ramki na liście ram

frameToInsert TiffFrame

Ramy do wprowadzania.

NormalizeAngle(Bool, Kolor)

Użyj metody NormalizeAngle specjalnie zaprojektowane dla skanowanych dokumentów tekstowychdo naprawy skanowanych szkenników, zapewniając precyzyjną dopasowanie.Integruj tę funkcję w twoich przepływach pracy przetwarzania tekstu, aby poprawićczytelność i jakość dokumentów, poprawa ogólnej efektywności w rozpoznawaniu tekstui zadań analitycznych.Metoda ta wykorzystuje metody Aspose.Imaging.RasterImage.GetSkewAngle i Wl17.FileFormats.Tiff. TiffImages.Rootate(System.Single,Systems.Boolean,W L17__.Color).

public override void NormalizeAngle(bool resizeProportionally, Color backgroundColor)

Parameters

resizeProportionally bool

Jeśli ustawione na “prawdziwe”, zmieni się rozmiar obrazu w zależności od obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu.

backgroundColor Color

Kolor z tła.

ReleaseManagedResources()

Upewnij się, że nie zarządzane zasoby nie są tutaj uwalniane, ponieważ mogą być już uwalniane.

protected override void ReleaseManagedResources()

RemoveFrame(Int)

bezproblemowo usunąć ramę zidentyfikowaną przez jej indeks z sekwencji obrazu,zarządzanie ramami w Twojej aplikacji.Integruj tenfunkcjonalność w celu zwiększenia efektywności i precyzji manipulacji ramową,ułatwia bezprzewodową organizację i prezentację treści obrazu.

public TiffFrame RemoveFrame(int index)

Parameters

index int

Indeks ramowy należy usunąć.

Returns

TiffFrame

Usunięte ramy.

Examples

Poniższy przykład pokazuje, jak skomponować mutlipage TIFF z poszczególnych obrazów rasterowych.

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

Uwaga: nie zapomnij umieścić ramkę, jeśli nie dodasz jej do innego programu TiffImage.

RemoveFrame(TiffFrame)

Efektywnie usunąć określony ramy z sekwencji obrazu, ułatwiającSzybkie zarządzanie ramami w Twojej aplikacji. integruj tę funkcjonalnośćzwiększenie precyzji i elastyczności manipulacji ramy, zapewniając bezprzewodoweOrganizacja i prezentacja treści obrazu.

public void RemoveFrame(TiffFrame frame)

Parameters

frame TiffFrame

Ramy do usunięcia.

Remarks

Uwaga: nie zapomnij umieścić ramkę, jeśli nie dodasz jej do innego programu TiffImage.

RemoveMetadata()

Usunąć te metadane przykładu obrazu poprzez ustawienie tych wartości Aspose.Imaging.Xmp.IHasXMPData.xmpDate i Wl17.Exif.IHasexifDato. zero.

public override void RemoveMetadata()

ReplaceFrame(Tłumaczenie: TiffFrame)

Zastąpić ramy w wyznaczonej pozycji innym ramięciem bezprzewodowo,ułatwianie dynamicznego zarządzania ramami w sekwencji obrazu.metodą zwiększenia elastyczności i precyzji w manipulacji ramy, zapewniającoptymalna organizacja i prezentacja treści obrazu w Twojej aplikacji.

public TiffFrame ReplaceFrame(int index, TiffFrame frameToReplace)

Parameters

index int

Pozycja ramy bazująca na zero.

frameToReplace TiffFrame

Ramy do zastąpienia.

Returns

TiffFrame

Usunięte ramy.

Remarks

Uwaga: nie zapomnij umieścić ramkę, jeśli nie dodasz jej do innego programu TiffImage.

Resize(int, int, resizeType)

Odtwarzanie obrazu według określonego typu odtwarzania, ułatwiając elastycznedostosowanie wymiarów obrazu przy zachowaniu stosunku aspektu lub zastosowanie określonegoWłącz tę metodę do swojego przepływu roboczego przetwarzania obrazuaby uzyskać precyzyjną kontrolę nad operacjami restrukturyzacji w ramach Twojej aplikacji.

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

Parameters

newWidth int

Nowa szerokość .

newHeight int

Nowa wysokość .

resizeType ResizeType

Ten rodzaj rewizji.

Examples

Ten przykład ładuje obraz TIFF i odtwarza go za pomocą różnych metod odświeżania.

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)

Dostosuj rozmiar obrazu w oparciu o określone ustawienia, umożliwiając dokładnośćkontrola wymiarów, stosunku aspektów i zachowania skalowania.Metoda do Twojego przepływu roboczego przetwarzania obrazu w celu osiągnięcia dostosowanego ponownegooperacje dostosowane do specyficznych wymagań Twojej aplikacji.

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

Parameters

newWidth int

Nowa szerokość .

newHeight int

Nowa wysokość .

settings ImageResizeSettings

Zmiany w ustawieniach.

Examples

Ten przykład ładuje obraz TIFF i odtwarza go za pomocą różnych ustawień odświeżania.

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(Tłumaczenie, ResizeType)

Wykonaj proporcjonalne dostosowanie wysokości obrazu, zachowując jego wyglądstosunek dla spójnej integralności wizualnej. zastosować tę metodę do dynamicznego odświeżaniaobrazy w Twojej aplikacji, zapewniając optymalny wyświetlacz na różnych platformachi urządzeń bez zakłócania jakości treści.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

Nowa wysokość .

resizeType ResizeType

Rodzaj rezygnacji.

Examples

Ten przykład ładuje obraz TIFF i odtwarza go proporcjonalnie przy użyciu różnych metod odświeżania.

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)

Wykonaj operację proporcjonalnego odświeżania obrazu, zachowując jego aspekt ratowile dostosowywania jego wymiarów. Użyj tej metody do dynamicznego skaliowania obrazóww ramach aplikacji, zapewniając konsekwentną wizualną reprezentację integralności treści.Proporcjonalny odśnieżanie będzie rozciągać każdy ramy zgodnie z stosunkiem newWidth’/width i newHeight’ / height.

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

Parameters

newWidth int

Nowa szerokość .

newHeight int

Nowa wysokość .

resizeType ResizeType

Ten rodzaj rewizji.

ResizeWidthProportionally(Tłumaczenie, ResizeType)

Dostosuj szerokość obrazu przy jednoczesnym utrzymaniu jego stosunku aspektowego, zapewniającproporcjonalne odtwarzanie dla optymalnej prezentacji wizualnej. użyj tej metody dodynamicznie skalać obrazy w Twojej aplikacji, ułatwiając konsekwentne iAestetycznie przyjemne renderowanie w różnych kontekstach wyświetlania.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

Nowa szerokość .

resizeType ResizeType

Rodzaj rezygnacji.

Examples

Ten przykład ładuje obraz TIFF i odtwarza go proporcjonalnie przy użyciu różnych metod odświeżania.

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, Kolor)

Obrót obrazu wokół jego punktu centralnego przez określony kąt, umożliwiając dokładnośćWprowadź tę funkcję do przetwarzania obrazuw celu ułatwienia precyzyjnych transformacji, zapewnienia optymalnego dopasowania iprezentacja treści wizualnych w Twojej aplikacji.

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

Parameters

angle float

Kąt obrotowy w stopniach. wartości pozytywne będą obrotować zegarem.

resizeProportionally bool

Jeśli ustawione na “prawdziwe”, zmieni się rozmiar obrazu w zależności od obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu obrazu.

backgroundColor Color

Kolor z tła.

Examples

Poniższy przykład pokazuje, jak rotować obraz TIFF wokół środka o 45 stopni.

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)

Wykonywanie rotacji, flipping lub połączenia obu operacji wyłącznie naMetoda ta umożliwia precyzyjną manipulację poszczególnych ram wewnątrzsekwencja obrazu, zwiększając elastyczność w edycji i kompozycji wTwoja aplikacja .

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

Rodzaj rotacji flip.

Examples

Ten przykład ładuje obraz TIFF, rotuje go o 90 stopni w świetle zegara i opcjonalnie flips obraz horyzontalnie i (lub) pionowo.

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)

Przechowuje dane obiektu do określonego strumienia.

protected override void SaveData(Stream stream)

Parameters

stream Stream

Przepływ do przechowywania danych obiektu do.

SetResolution(podwójne, podwójne)

Ustaw rozdzielczość dla określonego Aspose.Imaging.RasterImage, umożliwiającdokładna kontrola renderowania obrazu i właściwości wyświetlania.funkcjonalność w celu optymalizacji wydajności wizualnej i zapewnienia kompatybilności z różnorodnościąurządzeń wyjściowych i platform, poprawiając ogólny doświadczenie użytkownika.

public override void SetResolution(double dpiX, double dpiY)

Parameters

dpiX double

Rozdzielczość horyzontalna, w punktach na cala, Aspose.Imaging.RasterImage.

dpiY double

Rozdzielczość pionowa, w punktach na cala, Aspose.Imaging.RasterImage.

Examples

Poniższy przykład pokazuje, jak ustawić rozdzielczość horyzontalną / pionową obrazu TIFF.

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(i int, int)

Aktualizacja wymiarów obrazu.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

Nowy widok obrazu.

newHeight int

Nowa wysokość obrazu.

Exceptions

NotImplementedException

 Polski