Class TiffFrame

Class TiffFrame

Numele spaţiului: Aspose.Imaging.FileFormats.Tiff Asamblare: Aspose.Imaging.dll (25.4.0)

Frame de tifă.

[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

Membrii moștenitori

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

Acest exemplu arată cum să creați o imagine TIFF din scratch și să o salvați într-un fișier.

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)

Inițializează o nouă instanță a clasei Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(Stream stream)

Parameters

stream Stream

Fluxul pentru a încărca o imagine de la și inițializa pixel frame și datele de paletă cu.

TiffFrame(Cuvânt cheie, TiffOptions)

Inițializează o nouă instanță a clasei Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(Stream stream, TiffOptions options)

Parameters

stream Stream

Fluxul pentru a încărca o imagine de la și inițializa pixel frame și datele de paletă cu.

options TiffOptions

Opțiunile de utilizare pentru noul cadru creat.

TiffFrame(Strângere)

Inițializează o nouă instanță a clasei Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(string path)

Parameters

path string

Calea de încărcare a unei imagini și inițializarea pixelelor de cadru și a datelor de paletă.

TiffFrame(Cuvânt cheie, TiffOptions)

Inițializează o nouă instanță a clasei Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(string path, TiffOptions options)

Parameters

path string

Calea de încărcare a unei imagini și inițializarea pixelelor de cadru și a datelor de paletă.

options TiffOptions

Opțiunile de utilizare pentru noul cadru creat.

TiffFrame(RasterImage)

Inițializează o nouă instanță a clasei Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(RasterImage image)

Parameters

image RasterImage

Imaginea pentru a inițializa pixelul cadru și datele de paletă cu.

Examples

Următorul exemplu arată cum să compuneți un TIFF mutlipage din imagini individuale de raster.

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(RasterImage și TiffOptions)

Inițializează o nouă instanță a clasei Aspose.Imaging.FileFormats.Tiff. TiffFrame.

public TiffFrame(RasterImage image, TiffOptions options)

Parameters

image RasterImage

Imaginea pentru a inițializa pixelul cadru și datele de paletă cu.

options TiffOptions

Opțiunile de utilizare pentru noul cadru creat.

TiffFrame(Cuvânt cheie: int, int)

Inițializează o nouă instanță a clasei Aspose.Imaging.FileFormats.Tiff. TiffFrame.

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

Parameters

options TiffOptions

Opţiuni de cadru.

width int

în lățime .

height int

înălţime .

Examples

Acest exemplu arată cum să creați o imagine TIFF din scratch și să o salvați într-un fișier.

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

Acest exemplu arată cum să creați o imagine TIFF cu 2 cadre și să o salvați într-un fișier.

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

Parametrul opțiunilor este zero.

Properties

BackgroundColor

Obține sau stabilește o valoare pentru culoarea de fundal.

public override Color BackgroundColor { get; set; }

Valoarea proprietății

Color

BitsPerPixel

Obțineți bits de imagine pe pixel număr.

public override int BitsPerPixel { get; }

Valoarea proprietății

int

ExifData

Obține sau colectează datele EXIF din cadrul.

public ExifData ExifData { get; set; }

Valoarea proprietății

ExifData

FrameOptions

Creați un cadru pentru a crea opțiuni.

public TiffOptions FrameOptions { get; }

Valoarea proprietății

TiffOptions

HasAlpha

Obține o valoare care indică dacă această instanță are alfa.

public override bool HasAlpha { get; }

Valoarea proprietății

bool

Examples

Următorul exemplu încărcă o imagine TIFF și imprimează informații despre formatul de date crude și canalul 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

Obține o valoare care indică dacă imaginea are o culoare transparentă.

public override bool HasTransparentColor { get; set; }

Valoarea proprietății

bool

Height

Obține înălțimea imaginii.

public override int Height { get; }

Valoarea proprietății

int

HorizontalResolution

Obține sau stabilește rezoluția orizontală, în pixeli pe inch, a acestui Aspose.Imaging.RasterImage.

public override double HorizontalResolution { get; set; }

Valoarea proprietății

double

Examples

Următorul exemplu arată modul de setare a rezoluției orizontale/verticale a unui cadru 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

Obține sau stabilește resursele de drum.

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

Valoarea proprietății

List < PathResource >

Examples

Transfer Paths în timpul exportului de la TIFF la imaginea PSD.

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

Următorul exemplu arată cum să obțineți căi din imaginea TIFF și să afișați numele lor în consola.

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

Următorul exemplu arată modul de modificare a căilor de clipping deja existente. de exemplu, puteți menține doar un Calea de Clipping în imagine.

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

Următorul exemplu arată cum să creați Calea Clipping în imaginea TIFF. Pentru a face acest lucru, trebuie să creezi o instanță a clasei PathResource. Codul de mai jos demonstrează modul în care puteți crea o cale goală într-o imagine 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>

Creați Calea Clipping manual.

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

Obține sau stabilește rezoluția verticală, în pixeli pe inch, a acestui Aspose.Imaging.RasterImage.

public override double VerticalResolution { get; set; }

Valoarea proprietății

double

Examples

Următorul exemplu arată modul de setare a rezoluției orizontale/verticale a unui cadru 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

Obțineți amploarea imaginii.

public override int Width { get; }

Valoarea proprietății

int

XmpData

Obține sau stabilește date Xmp.

public override XmpPacketWrapper XmpData { get; set; }

Valoarea proprietății

XmpPacketWrapper

Methods

AlignResolutions()

Metoda de ajutor pentru a face rezoluțiile orizontale și verticale egale.

public void AlignResolutions()

CopyFrame(TiffFrame)

Copiază întregul cadru (duplicate).

public static TiffFrame CopyFrame(TiffFrame tiffFrame)

Parameters

tiffFrame TiffFrame

Frame pentru a copia.

Returns

TiffFrame

Frame-ul de tif nou copiat.

CreateFrameFrom(Etichetă: TiffOptions)

Creează cadrul de la specificația tiffFrame’ folosind opțiunile specificate.Data de pixel este păstrată, dar convertită în formatul dorit.

public static TiffFrame CreateFrameFrom(TiffFrame tiffFrame, TiffOptions options)

Parameters

tiffFrame TiffFrame

Frame-ul pentru a crea din.

options TiffOptions

Noile opţiuni de utilizare.

Returns

TiffFrame

Noul cadru creat.

Examples

Următorul exemplu arată cum să creați o copie cu grayscale a unui cadru existent și să-l adăugați unei imagini 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)

Îmbrățișează imaginea.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

în rectanglu .

GetOriginalOptions()

Obține opțiunile bazate pe setările de fișier originale.Acest lucru poate fi util pentru a menține adâncimea și alte parametri ale imaginii originale inalterate.De exemplu, dacă încărcăm o imagine PNG alb-negru cu 1 bit pe pixel și apoi o salvăm folosindAspose.Imaging.DataStreamSupporter.Save(System.String) metoda, va fi produs imaginea PNG de ieșire cu 8 bit pe pixel.Pentru a evita acest lucru și pentru a salva imaginea PNG cu 1 bit pe pixel, utilizați această metodă pentru a obține opțiunile de salvare corespunzătoare și a le trecela metoda Aspose.Imaging.Image.Save(System.String,_W L17.ImagineOptionsBase) ca al doilea parametru.

public override ImageOptionsBase GetOriginalOptions()

Returns

ImageOptionsBase

Opțiunile bazate pe setările de fișier originale.

ReleaseManagedResources()

Asigurați-vă că resursele necontrolate nu sunt eliberate aici, deoarece acestea pot fi deja eliberate.

protected override void ReleaseManagedResources()

RemoveMetadata()

Îndepărtează aceste metadate de imagini prin setarea acestor valori Aspose.Imaging.Xmp.IHasXMPData.xmpDată și Wl17.Exif.IHasexifDată. zero.

public override void RemoveMetadata()

Resize(int, int, resizeType)

Reduceţi imaginea.

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

Parameters

newWidth int

În noua lățime.

newHeight int

Înălţimea nouă.

resizeType ResizeType

Tipul de rezistenţă.

Rotate(float, bool, culoare)

Imaginea rotată în jurul centrului.

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

Parameters

angle float

Angajul rotativ în grade. valorile pozitive se vor rotati pe oră.

resizeProportionally bool

în cazul în care este setat la “true”, veți avea dimensiunea imaginii modificate în funcție de proiecțiile rectangle rotate (punctele de coadă) în caz contrar care lasă dimensiunile necoșite și numai conținutul imaginii interne sunt rotate.

backgroundColor Color

Culoarea fundalului.

SaveData(Stream)

salvează datele.

protected override void SaveData(Stream stream)

Parameters

stream Stream

Stream pentru a salva datele la.

UpdateDimensions(int, int)

Actualizează dimensiunile imaginii.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

Noua dimensiune a imaginii.

newHeight int

Înălțimea noii imagini.

 Română