Class TiffFrame

Class TiffFrame

Nom dels espais: Aspose.Imaging.FileFormats.Tiff Assemblea: Aspose.Imaging.dll (25.4.0)

El quadre tifós.

[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

Membres heretats

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

Aquest exemple mostra com crear una imatge TIFF des de l’escratx i salvar-la a un fitxer.

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)

Inicialitza una nova instància de la classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(Stream stream)

Parameters

stream Stream

El flux per carregar una imatge i inicialitzar els píxels de quadre i les dades de paleta amb.

TiffFrame(Projecció, TiffOptions)

Inicialitza una nova instància de la classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(Stream stream, TiffOptions options)

Parameters

stream Stream

El flux per carregar una imatge i inicialitzar els píxels de quadre i les dades de paleta amb.

options TiffOptions

Les opcions a utilitzar per al nou quadre creat.

TiffFrame(Tàrrega)

Inicialitza una nova instància de la classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(string path)

Parameters

path string

El camí per carregar una imatge i iniciar el pixel de quadre i les dades de paleta amb.

TiffFrame(Llista, TiffOptions)

Inicialitza una nova instància de la classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(string path, TiffOptions options)

Parameters

path string

El camí per carregar una imatge i iniciar el pixel de quadre i les dades de paleta amb.

options TiffOptions

Les opcions a utilitzar per al nou quadre creat.

TiffFrame(RasterImage)

Inicialitza una nova instància de la classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(RasterImage image)

Parameters

image RasterImage

La imatge per iniciar el quadre de píxels i les dades de paletes amb.

Examples

L’exemple següent mostra com compondre un mutlipage TIFF de les imatges de rastres individuals.

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(Càtedra, TiffOptions)

Inicialitza una nova instància de la classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(RasterImage image, TiffOptions options)

Parameters

image RasterImage

La imatge per iniciar el quadre de píxels i les dades de paletes amb.

options TiffOptions

Les opcions a utilitzar per al nou quadre creat.

TiffFrame(Opcions, int i int)

Inicialitza una nova instància de la classe Aspose.Imaging.FileFormats.Tiff. TiffFrame.

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

Parameters

options TiffOptions

Les opcions del marc.

width int

La seva amplada.

height int

La seva alçada.

Examples

Aquest exemple mostra com crear una imatge TIFF des de l’escratx i salvar-la a un fitxer.

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

Aquest exemple mostra com crear una imatge TIFF amb 2 quadres i salvar-la a un fitxer.

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

El paràmetre d’opcions és zero.

Properties

BackgroundColor

Obté o fixa un valor per al color de fons.

public override Color BackgroundColor { get; set; }

Valor de la propietat

Color

BitsPerPixel

Obté les bits d’imatge per càlcul de píxels.

public override int BitsPerPixel { get; }

Valor de la propietat

int

ExifData

Obté o col·loca dades EXIF des del marc.

public ExifData ExifData { get; set; }

Valor de la propietat

ExifData

FrameOptions

Obtenir el marc crea opcions.

public TiffOptions FrameOptions { get; }

Valor de la propietat

TiffOptions

HasAlpha

Obté un valor que indica si aquesta instància té alfa.

public override bool HasAlpha { get; }

Valor de la propietat

bool

Examples

L’exemple següent carrega una imatge TIFF i imprimeix informació sobre el format de dades primeres i el canal 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

Obté un valor que indica si la imatge té color transparent.

public override bool HasTransparentColor { get; set; }

Valor de la propietat

bool

Height

Obté l’alçada de la imatge.

public override int Height { get; }

Valor de la propietat

int

HorizontalResolution

Obté o estableix la resolució horitzontal, en píxels per polz, d’aquest Aspose.Imaging.RasterImage.

public override double HorizontalResolution { get; set; }

Valor de la propietat

double

Examples

L’exemple següent mostra com configurar la resolució horitzontal/vertical d’un marc TIFF separat.

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

Obtenir o establir els recursos del camí.

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

Valor de la propietat

List < PathResource >

Examples

Transferència de Paths Clipping durant l’exportació de TIFF a la imatge PSD.

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

L’exemple següent mostra com recuperar els camins de la imatge TIFF i mostrar els seus noms en la consola.

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

L’exemple següent mostra com modificar els camins d’escalada ja existents. per exemple, només es pot mantenir un Camí de escalada en la imatge.

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

L’exemple següent mostra com crear un camí de clic en la imatge TIFF. Per fer-ho cal crear una instància de la classe PathResource. El codi que segueix demostra la manera en què es pot crear el camí buit en l’imatge TFF.

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>

Creació de la ruta manualment.

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

Obté o estableix la resolució vertical, en píxels per polz, d’aquest Aspose.Imaging.RasterImage.

public override double VerticalResolution { get; set; }

Valor de la propietat

double

Examples

L’exemple següent mostra com configurar la resolució horitzontal/vertical d’un marc TIFF separat.

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

Obtenir l’amplada de la imatge.

public override int Width { get; }

Valor de la propietat

int

XmpData

Obté o col·loca dades Xmp.

public override XmpPacketWrapper XmpData { get; set; }

Valor de la propietat

XmpPacketWrapper

Methods

AlignResolutions()

Mètode més útil per fer iguals les resolucions horitzontals i verticals.

public void AlignResolutions()

CopyFrame(TiffFrame)

Copia tot el quadre (duplicat).

public static TiffFrame CopyFrame(TiffFrame tiffFrame)

Parameters

tiffFrame TiffFrame

El quadre tif per copiar.

Returns

TiffFrame

El nou quadre de tiff copiat.

CreateFrameFrom(TiffFrame i tiffOptions)

Crea el marc des de l’especificada tiffFrame’ utilitzant les opcions especificades.Les dades de píxels es conserven però es converteixen al format desitjat.

public static TiffFrame CreateFrameFrom(TiffFrame tiffFrame, TiffOptions options)

Parameters

tiffFrame TiffFrame

El quadre tif per crear.

options TiffOptions

Les noves opcions a utilitzar.

Returns

TiffFrame

El nou quadre creat.

Examples

L’exemple següent mostra com crear una còpia de graus d’un marc existent i afegir-lo a una imatge 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)

Creació de la imatge.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

El rectangle

GetOriginalOptions()

Obté les opcions basades en la configuració original del fitxer.Això pot ser útil per mantenir la profunditat de bit i altres paràmetres de la imatge original sense canvis.Per exemple, si carregem una imatge PNG de blanc i negre amb 1 bit per píxel i llavors l’emmagatzememàvem utilitzant elAspose.Imaging.DataStreamSupporter.Save(System.String) mètode, la imatge PNG de sortida amb 8 bits per píxel es produirà.Per evitar-ho i salvar la imatge PNG amb 1 bit per píxel, utilitzeu aquest mètode per obtenir les opcions d’estalvi corresponents i passar-losEl mètode Aspose.Imaging.Image.Save (System.String,_Wl17.ImagineOptionsBase) és el segon paràmetre.

public override ImageOptionsBase GetOriginalOptions()

Returns

ImageOptionsBase

Les opcions basades en la configuració original del fitxer.

ReleaseManagedResources()

Assegureu-vos que no es lliuren recursos no gestionats aquí, ja que poden haver estat ja alliberats.

protected override void ReleaseManagedResources()

RemoveMetadata()

Elimina aquesta imatge de metadades d’instància mitjançant l’establiment de Aspose.Imaging.Xmp.IHasXMPData.xmpDat i __ WL16__ .Exif.IhasExivDate.ExIFDati valors a Null.

public override void RemoveMetadata()

Resize(Int, int, ResizeTyp)

Recupera la imatge.

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

Parameters

newWidth int

La nova amplada.

newHeight int

La nova alçada.

resizeType ResizeType

El tipus de residus.

Rotate(Float, bool i color)

Rotació de la imatge al voltant del centre.

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

Parameters

angle float

L’angle de rotació en graus. els valors positius giraran de manera horària.

resizeProportionally bool

si s’estableix a ’true’ haurà canviat la mida de la imatge d’acord amb les projeccions rectangles (punts de cor) girats en un altre cas que deixen les dimensions sense tocar i només els continguts de l’imatge intern es giren.

backgroundColor Color

El color del fons.

SaveData(Stream)

Estalvia les dades.

protected override void SaveData(Stream stream)

Parameters

stream Stream

El flux per salvar les dades a.

UpdateDimensions(Int, Int)

Actualitza les dimensions de la imatge.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

La nova imatge d’amplada.

newHeight int

Alçada de la nova imatge.

 Català