Class TiffFrame

Class TiffFrame

Il nome: Aspose.Imaging.FileFormats.Tiff Assemblea: Aspose.Imaging.dll (25.4.0)

Il frame tiff.

[JsonObject(MemberSerialization.OptIn)]
public sealed class TiffFrame : RasterCachedImage, IDisposable, IObjectWithBounds, IRasterImageArgb32PixelLoader, IRasterImageRawDataLoader, IHasExifData, IHasXmpData, IHasMetadata

Inheritance

object DisposableObject DataStreamSupporter Image RasterImage RasterCachedImage TiffFrame

Implements

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

I membri ereditari

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.IsCached , 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.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 , 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.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.CacheData() , DataStreamSupporter.Save() , DataStreamSupporter.Save(Stream) , DataStreamSupporter.Save(string) , DataStreamSupporter.Save(string, bool) , DataStreamSupporter.DataStreamContainer , DataStreamSupporter.IsCached , DisposableObject.Dispose() , DisposableObject.Disposed , object.GetType() , object.ToString() , object.Equals(object?) , object.Equals(object?, object?) , object.ReferenceEquals(object?, object?) , object.GetHashCode()

Examples

Questo esempio mostra come creare un’immagine TIFF da scratch e salvarla in un file.

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

Constructors

TiffFrame(Stream)

Inizia una nuova instanza della classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(Stream stream)

Parameters

stream Stream

Il flusso per caricare un’immagine da e inizializzare i pixel quadro e i dati di palette con.

TiffFrame(Strumento, TiffOptions)

Inizia una nuova instanza della classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(Stream stream, TiffOptions options)

Parameters

stream Stream

Il flusso per caricare un’immagine da e inizializzare i pixel quadro e i dati di palette con.

options TiffOptions

Le opzioni da utilizzare per il frame appena creato.

TiffFrame(String)

Inizia una nuova instanza della classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(string path)

Parameters

path string

Il percorso per caricare un’immagine e inizializzare i pixel quadro e i dati di palette.

TiffFrame(String e TiffOptions)

Inizia una nuova instanza della classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(string path, TiffOptions options)

Parameters

path string

Il percorso per caricare un’immagine e inizializzare i pixel quadro e i dati di palette.

options TiffOptions

Le opzioni da utilizzare per il frame appena creato.

TiffFrame(RasterImage)

Inizia una nuova instanza della classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(RasterImage image)

Parameters

image RasterImage

L’immagine per inizializzare i pixel e i dati di palette.

Examples

L’esempio seguente mostra come comporre un mutlipage TIFF da immagini di raster individuali.

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 <= 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();
                                                                                                     }

TiffFrame(Riflessioni, TiffOptions)

Inizia una nuova instanza della classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(RasterImage image, TiffOptions options)

Parameters

image RasterImage

L’immagine per inizializzare i pixel e i dati di palette.

options TiffOptions

Le opzioni da utilizzare per il frame appena creato.

TiffFrame(Sviluppo int, int)

Inizia una nuova instanza della classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(TiffOptions options, int width, int height)

Parameters

options TiffOptions

Le opzioni di frame.

width int

La larghezza .

height int

La altezza .

Examples

Questo esempio mostra come creare un’immagine TIFF da scratch e salvarla in un file.

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

Questo esempio mostra come creare un’immagine TIFF con 2 quadri e salvarla in un file.

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

Il parametro delle opzioni è zero.

Properties

BackgroundColor

Riceve o impone un valore per il colore di sfondo.

public override Color BackgroundColor { get; set; }

Valore di proprietà

Color

BitsPerPixel

Riceve i bit di immagine per pixel.

public override int BitsPerPixel { get; }

Valore di proprietà

int

ExifData

Riceve o imposta i dati EXIF dal frame.

public ExifData ExifData { get; set; }

Valore di proprietà

ExifData

FrameOptions

Il frame crea le opzioni.

public TiffOptions FrameOptions { get; }

Valore di proprietà

TiffOptions

HasAlpha

Riceve un valore indicando se questa instanza ha alfa.

public override bool HasAlpha { get; }

Valore di proprietà

bool

Examples

L’esempio seguente carica un’immagine TIFF e stampa informazioni sul formato dei dati crudi e il canale alfa.

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

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

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

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

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

HasTransparentColor

Riceve un valore che indica se l’immagine ha un colore trasparente.

public override bool HasTransparentColor { get; set; }

Valore di proprietà

bool

Height

Ottieni l’altezza dell’immagine.

public override int Height { get; }

Valore di proprietà

int

HorizontalResolution

Riceve o impone la risoluzione orizzontale, in pixel per pollice, di questo Aspose.Imaging.RasterImage.

public override double HorizontalResolution { get; set; }

Valore di proprietà

double

Examples

L’esempio seguente mostra come impostare una risoluzione orizzontale/vertica di un quadro TIFF separato.

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

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

                                                                                                              int i = 0;
                                                                                                              foreach (Aspose.Imaging.FileFormats.Tiff.TiffFrame frame in tiffImage.Frames)
                                                                                                              {
                                                                                                                  // Get horizontal and vertical resolution of the TiffFrame.
                                                                                                                  double horizontalResolution = frame.HorizontalResolution;
                                                                                                                  double verticalResolution = frame.VerticalResolution;
                                                                                                                  System.Console.WriteLine("The horizontal resolution of frame {0}, pixels per inch: {1}", i, horizontalResolution);
                                                                                                                  System.Console.WriteLine("The vertical resolution, of frame {0}, pixels per inch: {1}", i, 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");
                                                                                                                      frame.SetResolution(96.0, 96.0);

                                                                                                                      System.Console.WriteLine("The horizontal resolution of frame {0}, pixels per inch: {1}", i, horizontalResolution);
                                                                                                                      System.Console.WriteLine("The vertical resolution, of frame {0}, pixels per inch: {1}", i, verticalResolution);
                                                                                                                  }

                                                                                                                  ++i;
                                                                                                              }
                                                                                                          }

PathResources

Riceve o mette le risorse stradali.

public List<pathresource> PathResources { get; set; }

Valore di proprietà

List di < PathResource >

Examples

Trasferimento di Clipping Paths durante l’esportazione da TIFF all’immagine PSD.

using (var image = Image.Load("Sample.tif"))
                                                                        {
                                                                            image.Save("SampleWithPaths.psd", new PsdOptions());
                                                                        }

L’esempio seguente mostra come recuperare i percorsi dall’immagine TIFF e mostrare i loro nomi nella console.

using (var image = (TiffImage)Image.Load("Sample.tif"))
                                                                                                                    {
                                                                                                                        foreach (var path in image.ActiveFrame.PathResources)
                                                                                                                        {
                                                                                                                            Console.WriteLine(path.Name);
                                                                                                                        }
                                                                                                                    }

L’esempio seguente mostra come modificare le Paths di Clipping già esistenti. per esempio, è possibile mantenere solo una Pattacco di clipping nell’immagine.

using (var image = (TiffImage)Image.Load("Sample.tif"))
                                                                                                                                                     {
                                                                                                                                                         var paths = image.ActiveFrame.PathResources;
                                                                                                                                                         image.ActiveFrame.PathResources = paths.Take(1).ToList();
                                                                                                                                                         image.Save();
                                                                                                                                                     }

L’esempio seguente mostra come creare Clipping Path nell’immagine TIFF. Per fare questo è necessario creare un’indagine della classe PithResource. Il codice qui sotto mostra il modo in cui è possibile creare una strada vuota nella immagine tiff.

var options = new TiffOptions(TiffExpectedFormat.Default);
                                                                                                                                                                                                                                                   var frame = new TiffFrame(options, 800, 600);

                                                                                                                                                                                                                                                   using (var image = new TiffImage(frame))
                                                                                                                                                                                                                                                   {
                                                                                                                                                                                                                                                       image.ActiveFrame.PathResources = new List<pathresource>
                                                                                                                                                                                                                                                       {
                                                                                                                                                                                                                                                           new PathResource
                                                                                                                                                                                                                                                           {
                                                                                                                                                                                                                                                               BlockId = 2000,
                                                                                                                                                                                                                                                               Name = "My Clipping Path",
                                                                                                                                                                                                                                                               Records = new List<vectorpathrecord>()
                                                                                                                                                                                                                                                           }
                                                                                                                                                                                                                                                       };

                                                                                                                                                                                                                                                       image.Save("ImageWithEmptyPath.tiff");
                                                                                                                                                                                                                                                   }</vectorpathrecord></pathresource>

Crea il Clipping Path manualmente.

static void Main()
                                         {
                                             using (var image = (TiffImage)Image.Load("Sample.tif"))
                                             {
                                                 image.ActiveFrame.PathResources = new List<pathresource> { new PathResource
                                                 {
                                                     BlockId = 2000,                                                          // Block Id according to Photoshop specification
                                                     Name = "My Clipping Path",                                               // Path name
                                                     Records = CreateRecords(0.2f, 0.2f, 0.8f, 0.2f, 0.8f, 0.8f, 0.2f, 0.8f)  // Create path records using coordinates
                                                 }};

                                                 image.Save("ImageWithPath.tif");
                                             }
                                         }

                                         private static List<vectorpathrecord> CreateRecords(params float[] coordinates)
                                         {
                                             var records = CreateBezierRecords(coordinates);                                  // Create Bezier records using coordinates

                                             records.Insert(0, new LengthRecord                                               // LengthRecord required by Photoshop specification
                                             {
                                                 IsOpen = false,                                                              // Lets create closed path
                                                 RecordCount = (ushort)records.Count                                          // Record count in the path
                                             });

                                             return records;
                                         }

                                         private static List<vectorpathrecord> CreateBezierRecords(float[] coordinates)
                                         {
                                             return CoordinatesToPoints(coordinates)
                                                 .Select(CreateBezierRecord)
                                                 .ToList();
                                         }

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

                                         private static VectorPathRecord CreateBezierRecord(PointF point)
                                         {
                                             return new BezierKnotRecord { PathPoints = new[] { point, point, point } };
                                         }</pointf></vectorpathrecord></vectorpathrecord></pathresource>

VerticalResolution

Riceve o impone la risoluzione verticale, in pixel per pollice, di questo Aspose.Imaging.RasterImage.

public override double VerticalResolution { get; set; }

Valore di proprietà

double

Examples

L’esempio seguente mostra come impostare una risoluzione orizzontale/vertica di un quadro TIFF separato.

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

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

                                                                                                              int i = 0;
                                                                                                              foreach (Aspose.Imaging.FileFormats.Tiff.TiffFrame frame in tiffImage.Frames)
                                                                                                              {
                                                                                                                  // Get horizontal and vertical resolution of the TiffFrame.
                                                                                                                  double horizontalResolution = frame.HorizontalResolution;
                                                                                                                  double verticalResolution = frame.VerticalResolution;
                                                                                                                  System.Console.WriteLine("The horizontal resolution of frame {0}, pixels per inch: {1}", i, horizontalResolution);
                                                                                                                  System.Console.WriteLine("The vertical resolution, of frame {0}, pixels per inch: {1}", i, 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");
                                                                                                                      frame.SetResolution(96.0, 96.0);

                                                                                                                      System.Console.WriteLine("The horizontal resolution of frame {0}, pixels per inch: {1}", i, horizontalResolution);
                                                                                                                      System.Console.WriteLine("The vertical resolution, of frame {0}, pixels per inch: {1}", i, verticalResolution);
                                                                                                                  }

                                                                                                                  ++i;
                                                                                                              }
                                                                                                          }

Width

Ottieni la larghezza dell’immagine.

public override int Width { get; }

Valore di proprietà

int

XmpData

Riceve o imposta i dati Xmp.

public override XmpPacketWrapper XmpData { get; set; }

Valore di proprietà

XmpPacketWrapper

Methods

AlignResolutions()

Metodo più utile per rendere uguali le risoluzioni orizzontali e verticali.

public void AlignResolutions()

CopyFrame(TiffFrame)

Copia l’intero quadro (duplicate)

public static TiffFrame CopyFrame(TiffFrame tiffFrame)

Parameters

tiffFrame TiffFrame

Il frame tiff per copiare.

Returns

TiffFrame

La nuova copia del tiff frame.

CreateFrameFrom(TiffFrame e tiffOptions)

Crea il frame dal specifico tiffFrame’ utilizzando le opzioni specificate ’.I dati del pixel sono conservati ma convertiti nel formato desiderato.

public static TiffFrame CreateFrameFrom(TiffFrame tiffFrame, TiffOptions options)

Parameters

tiffFrame TiffFrame

Il frame tiff da creare.

options TiffOptions

Le nuove opzioni da utilizzare.

Returns

TiffFrame

Il nuovo quadro creato.

Examples

L’esempio seguente mostra come creare una copia di grayscale di un quadro esistente e aggiungerlo a un’immagine TIFF.

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 + "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))
                                                                                                                      {
                                                                                                                          // 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 a linear gradient brush.
                                                                                                                          Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(tiffImage.ActiveFrame);
                                                                                                                          gr.FillRectangle(brush, tiffImage.Bounds);

                                                                                                                          // Grayscale options
                                                                                                                          Aspose.Imaging.ImageOptions.TiffOptions createTiffFrameOptions = new Aspose.Imaging.ImageOptions.TiffOptions(Aspose.Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);
                                                                                                                          createTiffFrameOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream());
                                                                                                                          createTiffFrameOptions.Photometric = Imaging.FileFormats.Tiff.Enums.TiffPhotometrics.MinIsBlack;
                                                                                                                          createTiffFrameOptions.BitsPerSample = new ushort[] { 8 };

                                                                                                                          // Create a grayscale copy of the active frame.
                                                                                                                          // The pixel data is preserved but converted to the desired format.
                                                                                                                          Aspose.Imaging.FileFormats.Tiff.TiffFrame grayscaleFrame = Aspose.Imaging.FileFormats.Tiff.TiffFrame.CreateFrameFrom(tiffImage.ActiveFrame, createTiffFrameOptions);

                                                                                                                          // Add the newly created frame to the TIFF image.
                                                                                                                          tiffImage.AddFrame(grayscaleFrame);

                                                                                                                          tiffImage.Save();
                                                                                                                      }

Crop(Rectangle)

Scopri l’immagine.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

Il rectangolo .

GetOriginalOptions()

Riceve le opzioni in base alle impostazioni del file originale.Questo può essere utile per mantenere la profondità del bit e altri parametri dell’immagine originale invariati.Ad esempio, se caricamo un’immagine PNG in bianco e nero con 1 bit per pixel e lo salviamo utilizzando ilAspose.Imaging.DataStreamSupporter.Save(System.String) metodo, l’immagine PNG di uscita con 8 bit per pixel sarà prodotto.Per evitare e salvare l’immagine PNG con 1 bit per pixel, utilizzare questo metodo per ottenere le opzioni di risparmio corrispondenti e passare loroper il metodo Aspose.Imaging.Image.Save(System.String,_W L17.ImagineOptionsBase) come secondo parametro.

public override ImageOptionsBase GetOriginalOptions()

Returns

ImageOptionsBase

Le opzioni basate sulle impostazioni del file originale.

ReleaseManagedResources()

Assicurati di non rilasciare risorse non gestite qui, poiché potrebbero essere già state rilasciate.

protected override void ReleaseManagedResources()

RemoveMetadata()

Rimuove i metadati di instanza di questa immagine impostando questi valori Aspose.Imaging.Xmp.IHasXMPData.xmpDat e __ WL16__ .Exif.IhasExivDate.ExIFDato a Null.

public override void RemoveMetadata()

Resize(int, int, resizeType)

Ristrutturare l’immagine.

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

Parameters

newWidth int

La nuova larghezza.

newHeight int

La nuova altezza.

resizeType ResizeType

Il tipo di ritorno.

Rotate(Flotta, Bool, Colore)

Immagini girate intorno al centro.

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

Parameters

angle float

L’angolo di rotazione in gradi. valori positivi gireranno in orologio.

resizeProportionally bool

se impostato a ’true’ avrai la dimensione dell’immagine modificata in base alle proiezioni rettangoli rotate (punti angolare) in caso diverso che lascia le dimensioni non toccate e solo i contenuti dell’immagine interna sono rotati.

backgroundColor Color

Il colore del background.

SaveData(Stream)

Salva i dati.

protected override void SaveData(Stream stream)

Parameters

stream Stream

Il flusso per salvare i dati.

UpdateDimensions(di int, int)

Aggiornare le dimensioni dell’immagine.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

La nuova larghezza dell’immagine.

newHeight int

L’altezza della nuova immagine.

 Italiano