Class TiffImage

Class TiffImage

Именује се: Aspose.Imaging.FileFormats.Tiff Асамблеја: Aspose.Imaging.dll (25.4.0)

Процес означен са сликом формат датотеке (ТИФФ) растер слике са нашим АПИ, нудисвеобухватна подршка различитим резолуцијама и напредним способностима за уређивањекао што су EXIF манипулација подацима и алфа канали. нормализују углове за скениране слике,преобразити, трансформисати у грозну скалу и применити филтере, гамма корекције и сликуподешавања параметара са лакоћом. Бескорисно управљати мулти-фреме ТИФФ датотекама,креирајте графичке путеве, додајте облике и без напора сачувате слике у различитим форматима.

[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

Наслеђени чланови

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

Креирајте графички пут из ресурса пута у слици ТИФФ-а.

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

Креирајте Пут Ресурси користећи Графички Пат.

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)

Иницијалишете нови објекат класе Aspose.Imaging.FileFormats.Tiff. TiffImage, одређујућипараметар оквира. овај конструктор олакшава стварање TiffImageна пример, омогућавајући програмерима да одреде оквир који ће бити наплаћен или обрађен,усклађивање Тифф задатака за обраду слике унутар њихових апликација.

public TiffImage(TiffFrame frame)

Parameters

frame TiffFrame

Тиф оквир за иницијализацију слике са.

Examples

Овај пример показује како да креирате ТИФФ слику из скраћења и сачувате га у датотеку.

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’ ne može da bude prazan.

TiffImage(TiffFrame[])

Креирајте нову инстанцију класе Aspose.Imaging.FileFormats.Tiff. TiffImage, пружајући листуоквири као параметар. овај конструктор омогућава иницијализацију TiffImageобјекти са више оквира, олакшавајући ефикасно управљање и обрадуTIFF sekvencije slika u softverskim aplikacijama.

public TiffImage(TiffFrame[] frames)

Parameters

frames TiffFrame []

За оквире .

Examples

Овај пример показује како да креирате ТИФФ слику са 2 оквира и сачувате га у датотеку.

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

оквири

Properties

ActiveFrame

Управљање активним оквиром беспрекорно, олакшавајући динамичку навигацију иманипулација у одређеном контексту. омогућити вашој апликацији да интерактујеефикасно са мултимедијалним садржајем, побољшавајући ангажовање корисника и продуктивност.

public TiffFrame ActiveFrame { get; set; }

Вредност имовине

TiffFrame

Examples

Следећи пример показује како да се компонује мутипаж ТИФФ од појединачних растер слика.

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

Непрекидно комбинујте поруку бита за ТИФФ датотеке, обезбеђујући прецизну контролу надинтерпретација података. Омогућити ваше апликације са флексибилности да се прилагодеразличите спецификације датотека, побољшавајући компатибилност и ефикасност у обради података.

public TiffByteOrder ByteOrder { get; set; }

Вредност имовине

TiffByteOrder

ExifData

Доступ или модификовање ЕКСИФ података повезаних са активним оквиром без прекида, омогућавајућипрецизна контрола на метаданима слике. побољшање капацитета ваше апликацијеинтегрисање ове функције, обезбеђујући тачну очување и прилагођавањеОсновне информације о слици.

public ExifData ExifData { get; set; }

Вредност имовине

ExifData

FileFormat

Повратак вредности формата датотеке повезане са сликом. Ова својства служи каоКритичан аспект прикупљања метадата слике, омогућавајући софтверским апликацијама даидентификује и интерпретира формат података слике ефикасно.

public override FileFormat FileFormat { get; }

Вредност имовине

FileFormat

Frames

Преузмите низ примера Aspose.Imaging.FileFormats.Tiff. TiffFrame, омогућавајући свеобухватнеприступ и манипулација појединачним оквирима унутар слике ТИФФ-а.моћ овог уређаја за усклађивање радног тока обраде слике, обезбеђујући прецизностКонтрола и оптимизација визуелног садржаја.

public TiffFrame[] Frames { get; }

Вредност имовине

TiffFrame []

Examples

Следећи пример показује како да се компонује мутипаж ТИФФ од појединачних растер слика.

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

Одређивање да ли слика има алфа канал, пружајући кључне информацијеза рендеринг и композицију операција. Интегрирајте ову функцију да бисте оптимизоваливизуелне обраде радног тока, обезбеђујући тачну репрезентацију и манипулацијуПрозрачни елементи .

public override bool HasAlpha { get; }

Вредност имовине

bool

Examples

Следећи пример преузима слику ТИФФ-а и штампа информације о формату сирових података и алфа каналу.

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

Повратак хоризонталне резолуције одређеног Aspose.Imaging.Слика у пикселимапо инчу, олакшавајући прецизну прилагођавање и перформансе.неопходни метадани слике без напора, омогућавајући усклађене обраде сликаРадни токови за побољшане корисничке искуства.

public override double HorizontalResolution { get; set; }

Вредност имовине

double

Examples

Следећи пример показује како подесити хоризонталну/вертикалну резолуцију слике ТИФФ-а.

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

Напомена по подразумевању ова вредност је увек 96 јер различите платформе не могу вратити резолуцију екрана.Можете размотрити коришћење метода Резолуције за ажурирање оба вредности резолуције у једном позиву.

PageCount

Повратак укупног броја страница у одређеном документу, олакшавајућиЕфикасна навигација и управљање вишестраничним садржајем.функционалност за побољшање корисничког искуства, омогућавајући беспрекоран приступСвеобухватне структуре документа.

public override int PageCount { get; }

Вредност имовине

int

Pages

Доступ страницама документа беспрекорно, омогућавајући динамичку навигацију иманипулација унутар структуре садржаја. Омогућити вашу апликацију ефикасноприступ појединачним страницама, олакшавајући усклађене обраде докумената иПобољшање интеракције корисника.

public override Image[] Pages { get; }

Вредност имовине

Image []

PremultiplyComponents

Наведите да ли компоненте захтевају премножавање, обезбеђујући ефикасну обрадуу визуелним елементима. побољшање процеса рендерације узимајући у обзир овај својство,усклађивање графичких радног тока за оптимизоване перформансе.

public override bool PremultiplyComponents { get; set; }

Вредност имовине

bool

Examples

Следећи пример ствара нову слику ТИФФ-а, сачува одређене полупрозрачне пикселе, затим наплаћује те пикселе и добија коначне боје у премноженом облику.

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

Приступ вертикалној резолуцији одређеног Aspose.Imaging.Слика у пикселима поинча, омогућавајући прецизне прилагођавања и оптимизације.подаци слике без напора да поједностављају радне токове обраде слика, обезбеђујућиВишег квалитета и перформанси у вашим апликацијама.

public override double VerticalResolution { get; set; }

Вредност имовине

double

Examples

Следећи пример показује како подесити хоризонталну/вертикалну резолуцију слике ТИФФ-а.

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

Напомена по подразумевању ова вредност је увек 96 јер различите платформе не могу вратити резолуцију екрана.Можете размотрити коришћење метода Резолуције за ажурирање оба вредности резолуције у једном позиву.

Methods

Add(TiffImage)

Додајте оквире из одређене слике беспрекорно у тренутну оквир,консолидација њиховог садржаја и побољшање флексибилности композиције.Овај метод за усклађивање управљања оквиром и манипулације унутар вашегапликација, олакшавајући ефикасну обраду мулти-фрам слике.

public void Add(TiffImage image)

Parameters

image TiffImage

Извор слике .

AddFrame(TiffFrame)

Инкорпорирајте одређени оквир беспрекорно у слику, проширујући његов садржајИскористите ову методу како бисте побољшали састав и управљање сликом,Омогућавање ефикасног управљања мулти-фремом сликама у вашој апликацији.

public void AddFrame(TiffFrame frame)

Parameters

frame TiffFrame

Рам за додавање.

Examples

Следећи пример показује како да се компонује мутипаж ТИФФ од појединачних растер слика.

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

Интегрирајте низ оквира беспрекорно у слику, обогаћујући његов садржај икористите ову методу за побољшање састава и управљања сликом,омогућавање ефикасног управљања мулти-фрам сликама унутар ваше апликације.

public void AddFrames(TiffFrame[] frames)

Parameters

frames TiffFrame []

Рамке су спремне да додају

AddPage(RasterImage)

Уградите нову страницу у постојећу слику беспрекорно, проширујући његов садржајИскористите ову методу како бисте побољшали састав документа иУправљање, омогућавање ефикасног управљања мулти-страница слике унутар ваше апликације.

public virtual void AddPage(RasterImage page)

Parameters

page RasterImage

Странице које треба додати.

Exceptions

ArgumentNullException

page’ is null.

AdjustBrightness(Инт)

Implement brightness’ adjustment for the image, allowing themodification of overall luminance levels.Uključite ovu metodu u svoj radni tok za obrazu kako biste poboljšali vidljivost i poboljšli vizualnu kvalitetu slika unutar vaše aplikacije.

public override void AdjustBrightness(int brightness)

Parameters

brightness int

вредност светлости .

Examples

Следећи пример врши корекцију светлости слике ТИФФ-а.

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(Флоат)

Побољшати контраст Aspose.Imaging.Име инстанце,појачање разлике између светлости и тамних подручја.Функционалност за побољшање визуелне јасноће и општег квалитета сликеУнутар ваше апликације.

public override void AdjustContrast(float contrast)

Parameters

contrast float

Вредност контраста (у опсегу [-100; 100])

Examples

Следећи пример врши корекцију контраста слике ТИФФ-а.

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(Флоат)

Нанесите гама корекцију на слику, прилагођавајући интензитет пиксела за постизањежељени баланс боја. Инкорпорирајте ову методу у обраду сликерадног тока како би се побољшала визуелна квалитет и повећала тачност следећегАнализа или приказивање задатака у вашој апликацији.

public override void AdjustGamma(float gamma)

Parameters

gamma float

Гама за коефицијент црвених, зелених и плавих канала

Examples

Следећи пример врши гама-корекцију слике ТИФФ-а.

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(пловила, пловила и пловила)

Извршити гама корекцију на слици користећи појединачне коефицијенте за црвену,зелени и плави канали, омогућавајући фино прилагођене подешавања баланса бојаИнтегрирајте ову методу у вашу цев за обраду слике наобезбедити прецизну контролу над рендерирањем боја и побољшати визуелну верност унутарВаша апликација .

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

Parameters

gammaRed float

Гама за коефицијент црвеног канала

gammaGreen float

Гама за зелени канал коефицијент

gammaBlue float

Гама за коефицијент плавог канала

Examples

Следећи пример врши гама-корекцију слике ТИФФ примењујући различите коефицијенте за компоненте боје.

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

Имплементација метода АлингРезолуције помаже да се синхронизује хоризонтално ивертикалне резолуције, обезбеђујући јединственост у сличним димензијама.олакшава усклађене обраде слике радног тока хармонизацијом резолуцијепараметри, оптимизирајући визуелну квалитет и конзистентност на различитим платформама иУређаји .

public void AlignResolutions()

BinarizeBradley(Двоструки, инт)

Имплементација бинаризације на слици користећи Бредлеи адаптивне праговеалгоритам са интегрисаним границе слике. овај приступ динамички рачуналокалне границе засноване на окружењу слике, побољшавајући прилагодљивостразличите услове осветљења и обезбеђивање јаке сегментације за каснијеОбрада задатака унутар ваше апликације.

public override void BinarizeBradley(double brightnessDifference, int windowSize)

Parameters

brightnessDifference double

Разлика у светлости између пиксела и просека прозора с x с пикселаТо је око овог пиксела.

windowSize int

Величина s x s прозора пиксела усредсређен око овог пиксела

Examples

Sledeći primer binarizuje TIFF sliku sa Bradleyjevim adaptivnim algoritmom ograničenja sa određenom veličinom prozora.

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(Бајте)

Примените бинарност на слику користећи претходно дефинисани праг, конвертујући га убинарну слику са различитим предњим и позадиним регионима.Метода у вашем обраду слике радног тока да олакша сегментацију и карактеристикезадатак екстракције, побољшање тачности и ефикасности анализе слике унутарВаша апликација .

public override void BinarizeFixed(byte threshold)

Parameters

threshold byte

Ако је одговарајућа сива вредност пиксела већа од границе,255 ће му бити додељено, 0 другачије.

Examples

Следећи пример бинаризује слику ТИФФ са претходно дефинисаним прагом. бинарни слике садрже само 2 боје - црну и белу.

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

Искористите Оцу пределу да бисте извршили бинарност на слици, аутоматскиодређивање оптималне граничне вредности на основу хистограма слике.Овај метод у вашем обраду слике радног тока да би се постигла ефикасна сегментацијаи карактеристичне екстракције, побољшавајући тачност и поузданост анализе сликеЗадаци у вашој апликацији.

public override void BinarizeOtsu()

Examples

Sledeći primer binarizuje TIFF sliku sa Otsu ograničenjem.Binarizovane slike sadrže samo 2 boje - crno i belo.

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)

Покретање слике користећи одређену правоугаони регион, омогућавајући прецизан изборИнтегрирајте ову методу у свој радни ток обраде слике наефикасно уклања нежељене подручје и фокусира се на важне детаље, побољшавајућиОпшта јасноћа и састав слике.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

То је правоугао.

Examples

Следећи пример узгаја слику ТИФФ. Област узгоја се одређује путем 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)

Извршите копање на слици одређујући промене на левој, десној, горњој иОвај метод омогућава прецизан избор жељеног деласлику, олакшавајући ефикасно уклањање нежељених подручја и фокусирајући се наВажни садржај. Интегрирајте ову функционалност у вашу обраду сликацеви за побољшање јасноће и састава као што је потребно у вашој апликацији.

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

Parameters

leftShift int

Левица се мења.

rightShift int

И прави промен.

topShift int

На врхунском прелазу.

bottomShift int

Доњи промен.

Examples

Следећи пример узгаја слику ТИФФ. Област узгоја се одређује преко левих, горњих, десних, доњим маргинима.

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(ДитарингМетод, инт, ИцлорПалет)

Извршити дитрирање на тренутном слици како би се побољшала његова визуелна квалитет и смањилаИнтегрирајте ову методу у свој радни ток обраде сликеобезбедити глаткије транзиције између боја, што доводи до побољшања укупне сликеизглед и јасноћу.

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

Parameters

ditheringMethod DitheringMethod

То је дитринг метода.

bitsCount int

Последњи битови рачунају за дитирање.

customPalette IColorPalette

Прилагођена палета за дитирање.

Examples

Следећи пример наплаћује слику ТИФФ-а и врши граничне и течне дитирања користећи различите дубине палете.

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(Ректонгле, ФилтерОпцијеБазе)

Филтрирајте садржај у одређеном правоугао, примењујући одређену сликуобрада филтера за побољшање или модификацију изабраног региона. Интегрирајте ову методуу ваш образац манипулације радног тока за постизање циљних побољшања илиТрансформације у вашој апликацији.

public override void Filter(Rectangle rectangle, FilterOptionsBase options)

Parameters

rectangle Rectangle

То је правоугао.

options FilterOptionsBase

о опцијама .

Examples

Следећи пример примењује различите врсте филтера на слику ТИФФ-а.

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

Опоравите опције које се деривирају из оригиналних подешавања датотеке, олакшавајући бескорисноочување кључних параметара као што су бит-дубина и други суштински атрибутиИскористите овај метод да бисте одржали верност и конзистентност уЗадаци обраде слике, обезбеђујући оптималне резултате без непотребних промена.На пример, ако наплаћујемо црно-белу ПНГ слику са 1 битом по пикселу, а затим га сачувате користећиAspose.Imaging.DataStreamSupporter.Save(System.String) метода, излазна ПНГ слика са 8 бита по пикселу ће бити произведена.Да бисте то избегли и сачували ПНГ слику са 1 битом по пикселу, користите ову методу да бисте добили одговарајуће опције за штедњу и прошли их.до метода Aspose.Imaging.Image.Save(System.String,_Wl17.ImageOptionsBase) као други параметар.

public override ImageOptionsBase GetOriginalOptions()

Returns

ImageOptionsBase

Опције засноване на оригиналним поставкама датотеке.

Exceptions

TiffImageException

Нема оригиналних опција које се могу извући из слике

Grayscale()

Конвертује слику у његову графичку репрезентацију, претварајући је уједноканална слика у којој сваки пиксел представља интензитет. Интегрирајте овај методу вашу обраду слике цев за поједностављање анализе и побољшањекомпатибилност са графичким алгоритмима, олакшавајући различите рачунареЗадаци визије и анализе слике у вашој апликацији.

public override void Grayscale()

Examples

Следећи пример трансформише обојени ТИФФ слику у његову графичку репрезентацију. графичке слике се састоје искључиво од сенки сиве и носе само информације интензитета.

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(ТИФФРАМЕ)

Унесите нови оквир на одређеном индексу у оквиру секвенције оквира, осигуравајућипрецизна контрола над распоредом оквира.Употреба овог метода за управљање оквиромефикасно, олакшавајући динамичку манипулацију и организацију сликесадржај у вашој апликацији.

public void InsertFrame(int index, TiffFrame frameToInsert)

Parameters

index int

Индекс новог оквира на листи рамка

frameToInsert TiffFrame

Рам за убацивање.

NormalizeAngle(боја, боја)

Користите методу NormalizeAngle посебно дизајниран за скениране текстуалне документеда исправљају скеиране скане, обезбеђујући тачну усклађеност.интегришете ову функционалност у ваше текстове за обраду радног тока како бисте побољшаличитавост и квалитет докумената, побољшање укупне ефикасности у препознавању текстаи аналитичке задатке.Ова метода користи методе Aspose.Imaging.RasterImage.GetSkewAngle и _ВЛ17.FileFormats.Тифф.TiffИмаге.Ротате(Систем.Сингле,Систер.Боолеан,__УЛ 17_цолр).

public override void NormalizeAngle(bool resizeProportionally, Color backgroundColor)

Parameters

resizeProportionally bool

ако сте постављени на ‘истину’ ћете имати величину ваше слике промењена према ротираним правоугао (угао тачке) пројекције у другом случају које остављају димензије нетакнуте и само унутрашњи садржај слике се ротирају.

backgroundColor Color

Боја позадине.

ReleaseManagedResources()

Ослобађа управљане ресурсе. Уверите се да се овде не ослобађају управљани ресурси, јер се они можда већ ослобађају.

protected override void ReleaseManagedResources()

RemoveFrame(Инт)

Неуспешно елиминисати оквир идентификован његовим индексом из серије слике,усклађивање управљања оквиром у вашој апликацији. интегрисати овофункционалност за побољшање ефикасности и прецизности у манипулацији оквиром,олакшање беспрекорног организације и презентације садржаја слике.

public TiffFrame RemoveFrame(int index)

Parameters

index int

Индекс оквира треба уклонити.

Returns

TiffFrame

Уклоњени оквир

Examples

Следећи пример показује како да се компонује мутипаж ТИФФ од појединачних растер слика.

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

Napomena: nemojte zaboraviti da postavite okvir ako ga ne dodate nekom drugom TiffImage-u.

RemoveFrame(TiffFrame)

Ефикасно уклоните одређени оквир из серије слике, олакшавајућиусклађено управљање оквиром у вашој апликацији. Интегрирајте ову функционалностпобољшати прецизност и флексибилност у манипулацији оквиром, обезбеђујући беспрекорноОрганизација и презентација садржаја слике.

public void RemoveFrame(TiffFrame frame)

Parameters

frame TiffFrame

Рам за уклањање.

Remarks

Napomena: nemojte zaboraviti da postavite okvir ako ga ne dodate nekom drugom TiffImage-u.

RemoveMetadata()

Уклоните ове метадане примјер слике постављајући ове вредности Aspose.Imaging.Xmp.IHasXMPData.xmpДata и _ВЛ17.Exif.IHasEksifДата. нуле.

public override void RemoveMetadata()

ReplaceFrame(ТИФФРАМЕ)

Замените оквир на одређеном положају са другим оквиром,олакшање динамичког управљања оквиром у сличној секвенцији.метода за побољшање флексибилности и прецизности у манипулацији оквиром, обезбеђујућиОптимална организација и презентација садржаја слике у вашој апликацији.

public TiffFrame ReplaceFrame(int index, TiffFrame frameToReplace)

Parameters

index int

Позиција нуле заснована на оквиру.

frameToReplace TiffFrame

Рам за замену.

Returns

TiffFrame

Уклоњени оквир

Remarks

Napomena: nemojte zaboraviti da postavite okvir ako ga ne dodate nekom drugom TiffImage-u.

Resize(int, int, resizeType)

Рециклирајте слику према одређеном типу рецификације, олакшавајући флексибилностприлагођавање димензија слике док се чува однос аспекта или примењује специфичнеуградите ову методу у свој радни ток обраде сликеда бисте постигли прецизну контролу над операцијама рецидива унутар ваше апликације.

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

Parameters

newWidth int

Нова ширина је.

newHeight int

Нова висина је.

resizeType ResizeType

Тип рецидива .

Examples

Овај пример наплаћује слику ТИФФ-а и рецизира га користећи различите методе рецесирања.

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, ImageResizeСеттингс)

Прилагодите величину слике на основу одређених подешавања, омогућавајући прецизностконтроле над димензијама, аспектног односа и скалирања понашања.метода у вашем обраду слике радног тока да би се постигао прилагођен рецесингоперације прилагођене специфичним захтевима ваше апликације.

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

Parameters

newWidth int

Нова ширина је.

newHeight int

Нова висина је.

settings ImageResizeSettings

Успостављају се подешавања.

Examples

Овај пример наплаћује слику ТИФФ-а и рецидира га користећи различите подешавања ресинга.

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(Инт, РезимеТип)

Проведите пропорционалну прилагођавање висине слике, задржавајући његов изгледу односу на конзистентну визуелну интегритет. Искористите ову методу да динамично рецимиратеслике у вашој апликацији, обезбеђујући оптималну приказивање на различитим платформамаи уређаји без угрожавања квалитета садржаја.

public override void ResizeHeightProportionally(int newHeight, ResizeType resizeType)

Parameters

newHeight int

Нова висина је.

resizeType ResizeType

Тип резиме.

Examples

Овај пример наплаћује слику ТИФФ-а и рецизира га пропорционално користећи различите методе рецесирања.

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)

Извршите пропорционалну резиз операцију на слици, задржавајући његов аспект рационално прилагођавање његових димензија. Искористите ову методу да динамички скалирају сликеунутар апликације, обезбеђујући конзистентну визуелну репрезентацију интегритета садржаја.Пропорцијални ресиз ће рецизирати сваки оквир према односу newWidth’/width и newHeight’ / height.

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

Parameters

newWidth int

Нова ширина је.

newHeight int

Нова висина је.

resizeType ResizeType

Тип рецидива .

ResizeWidthProportionally(Инт, РезимеТип)

Прилагодите ширину слике док одржавате његов однос аспекта, осигуравајућиПропорционално резање за оптималну визуелну презентацију.динамички скалирају слике унутар ваше апликације, олакшавајући конзистентну иЕстетички задовољан рендеринг кроз различите контексте приказивања.

public override void ResizeWidthProportionally(int newWidth, ResizeType resizeType)

Parameters

newWidth int

Нова ширина је.

resizeType ResizeType

Тип резиме.

Examples

Овај пример наплаћује слику ТИФФ-а и рецизира га пропорционално користећи различите методе ресинга. само ширина се одређује, висина се израчунава аутоматски.

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(флот, боол, боја)

Ротирајте слику око његове централне тачке одређеним углом, омогућавајући прецизностИнкорпорирајте ову функционалност у обраду сликецеви да олакшају прецизне трансформације, обезбеђујући оптималну усклађеност иПрезентација визуелног садржаја у вашој апликацији.

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

Parameters

angle float

Угао ротације у степени. позитивне вредности ће ротирати сат.

resizeProportionally bool

ако сте постављени на ‘истину’ ћете имати величину ваше слике промењена према ротираним правоугао (угао тачке) пројекције у другом случају које остављају димензије нетакнуте и само унутрашњи садржај слике се ротирају.

backgroundColor Color

Боја позадине.

Examples

Следећи пример показује како ротирати ТИФФ слику око центра са 45 степени сата.

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)

Извршити ротацију, флипирање или комбинацију оба операције искључиво наОвај метод омогућава прецизну манипулацију појединачних оквира унутару реду слике, побољшавајући флексибилност у уређивању и саставу слика уВаша апликација .

public override void RotateFlip(RotateFlipType rotateFlipType)

Parameters

rotateFlipType RotateFlipType

Тип ротираног флипа.

Examples

Овај пример оптерећује слику ТИФФ-а, окреће је на 90 степени са часовима и опционално флипира слике хоризонтално и (или) вертикално.

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)

Сачува податке објекта у одређеном току.

protected override void SaveData(Stream stream)

Parameters

stream Stream

Поток да сачувате податке објекта на.

SetResolution(двоструко, двоструко)

Успоставља резолуцију за одређени Aspose.Imaging.RasterImage, омогућавајућипрецизна контрола над својствима рендерирања и приказивања слике. Интегрирајте овофункционалност за оптимизацију визуелног излаза и обезбеђивање компатибилности са различитимизлазни уређаји и платформе, побољшавајући опште корисничко искуство.

public override void SetResolution(double dpiX, double dpiY)

Parameters

dpiX double

Хоризонтална резолуција, у тачкама по инчу, Aspose.Imaging.RasterImage.

dpiY double

Вертикална резолуција, у тачкама по инчу, Aspose.Imaging.RasterImage.

Examples

Следећи пример показује како подесити хоризонталну/вертикалну резолуцију слике ТИФФ-а.

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(Инт, Инт)

Ажурирајте димензије слике.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

Нова ширина слике.

newHeight int

Нова висина слике.

Exceptions

NotImplementedException

 Српски