Class TiffFrame

Class TiffFrame

Το όνομα: Aspose.Imaging.FileFormats.Tiff Συγκέντρωση: Aspose.Imaging.dll (25.4.0)

Το TIFF Frame.

[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

Κληρονομημένα μέλη

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

Αυτό το παράδειγμα δείχνει πώς να δημιουργήσετε μια εικόνα TIFF από το scratch και να την αποθηκεύσετε σε ένα αρχείο.

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)

Αρχίζει μια νέα περίπτωση της κατηγορίας Aspose.Imaging.FileFormats.Tiff.TiffFrame.

public TiffFrame(Stream stream)

Parameters

stream Stream

Η ροή για να φορτώσει μια εικόνα από και να ξεκινήσει το pixel πλαίσιο και τα δεδομένα παλέτας με.

TiffFrame(Δραστηριότητες, TiffOptions)

Αρχίζει μια νέα περίπτωση της κατηγορίας Aspose.Imaging.FileFormats.Tiff.TiffFrame.

public TiffFrame(Stream stream, TiffOptions options)

Parameters

stream Stream

Η ροή για να φορτώσει μια εικόνα από και να ξεκινήσει το pixel πλαίσιο και τα δεδομένα παλέτας με.

options TiffOptions

Οι επιλογές που πρέπει να χρησιμοποιήσετε για το πρόσφατα δημιουργημένο πλαίσιο.

TiffFrame(Σύνδεσμος)

Αρχίζει μια νέα περίπτωση της κατηγορίας Aspose.Imaging.FileFormats.Tiff.TiffFrame.

public TiffFrame(string path)

Parameters

path string

Ο δρόμος για να κατεβάσετε μια εικόνα από και να ξεκινήσετε το pixel πλαίσιο και τα δεδομένα παλέτας με.

TiffFrame(Σύνδεσμος, TiffOptions)

Αρχίζει μια νέα περίπτωση της κατηγορίας Aspose.Imaging.FileFormats.Tiff.TiffFrame.

public TiffFrame(string path, TiffOptions options)

Parameters

path string

Ο δρόμος για να κατεβάσετε μια εικόνα από και να ξεκινήσετε το pixel πλαίσιο και τα δεδομένα παλέτας με.

options TiffOptions

Οι επιλογές που πρέπει να χρησιμοποιήσετε για το πρόσφατα δημιουργημένο πλαίσιο.

TiffFrame(RasterImage)

Αρχίζει μια νέα περίπτωση της κατηγορίας Aspose.Imaging.FileFormats.Tiff.TiffFrame.

public TiffFrame(RasterImage image)

Parameters

image RasterImage

Η εικόνα για να ξεκινήσει το pixel πλαίσιο και τα δεδομένα παλέτας με.

Examples

Το παρακάτω παράδειγμα δείχνει πώς να συνθέσετε ένα TIFF από ατομικές εικόνες ράστερ.

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(Ετικέτες, TiffOptions)

Αρχίζει μια νέα περίπτωση της κατηγορίας Aspose.Imaging.FileFormats.Tiff.TiffFrame.

public TiffFrame(RasterImage image, TiffOptions options)

Parameters

image RasterImage

Η εικόνα για να ξεκινήσει το pixel πλαίσιο και τα δεδομένα παλέτας με.

options TiffOptions

Οι επιλογές που πρέπει να χρησιμοποιήσετε για το πρόσφατα δημιουργημένο πλαίσιο.

TiffFrame(Τίτλος, int, int)

Αρχίζει μια νέα περίπτωση της κατηγορίας Aspose.Imaging.FileFormats.Tiff.TiffFrame.

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

Parameters

options TiffOptions

Οι επιλογές του Frame.

width int

Το πλάτος .

height int

Το ύψος.

Examples

Αυτό το παράδειγμα δείχνει πώς να δημιουργήσετε μια εικόνα TIFF από το scratch και να την αποθηκεύσετε σε ένα αρχείο.

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

Αυτό το παράδειγμα δείχνει πώς να δημιουργήσετε μια εικόνα TIFF με 2 πλαίσια και να την αποθηκεύσετε σε ένα αρχείο.

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

                                                                                             // Options for the first frame
                                                                                             Aspose.Imaging.ImageOptions.TiffOptions createOptions1 = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                             // Set 8 bits for each color component.
                                                                                             createOptions1.BitsPerSample = new ushort[] { 8, 8, 8 };

                                                                                             // Set the Big Endian byte order (Motorola)
                                                                                             createOptions1.ByteOrder = Aspose.Imaging.FileFormats.Tiff.Enums.TiffByteOrder.BigEndian;

                                                                                             // Set the LZW compression.
                                                                                             createOptions1.Compression = Aspose.Imaging.FileFormats.Tiff.Enums.TiffCompressions.Lzw;

                                                                                             // Set the RGB color model.
                                                                                             createOptions1.Photometric = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPhotometrics.Rgb;

                                                                                             // All color components will be stored within a single plane.
                                                                                             createOptions1.PlanarConfiguration = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPlanarConfigs.Contiguous;

                                                                                             // Create the first TIFF frame of 100x100 px.
                                                                                             // Note that you don't have to dispose frames explicitly if they are included into TiffImage.
                                                                                             // When the container is disposed all frames will be disposed automatically.
                                                                                             Aspose.Imaging.FileFormats.Tiff.TiffFrame frame1 = new Aspose.Imaging.FileFormats.Tiff.TiffFrame(createOptions1, 100, 100);

                                                                                             // Fill the first frame with the blue-yellow gradient.
                                                                                             Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                     new Aspose.Imaging.Point(0, 0),
                                                                                                     new Aspose.Imaging.Point(frame1.Width, frame1.Height),
                                                                                                     Aspose.Imaging.Color.Blue,
                                                                                                     Aspose.Imaging.Color.Yellow);

                                                                                             Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(frame1);
                                                                                             graphics.FillRectangle(gradientBrush, frame1.Bounds);

                                                                                             // Options for the first frame
                                                                                             Aspose.Imaging.ImageOptions.TiffOptions createOptions2 = new Aspose.Imaging.ImageOptions.TiffOptions(Imaging.FileFormats.Tiff.Enums.TiffExpectedFormat.Default);

                                                                                             // Set 1 bit per pixel for a B/W image.
                                                                                             createOptions2.BitsPerSample = new ushort[] { 1 };

                                                                                             // Set the Little Endian byte order (Intel)
                                                                                             createOptions2.ByteOrder = Aspose.Imaging.FileFormats.Tiff.Enums.TiffByteOrder.LittleEndian;

                                                                                             // Set the CCITT Group 3 Fax compression.
                                                                                             createOptions2.Compression = Aspose.Imaging.FileFormats.Tiff.Enums.TiffCompressions.CcittFax3;

                                                                                             // Set the B/W color model where 0 is black, 1 is white.
                                                                                             createOptions2.Photometric = Aspose.Imaging.FileFormats.Tiff.Enums.TiffPhotometrics.MinIsBlack;

                                                                                             // Create the second TIFF frame of 200x200px.
                                                                                             Aspose.Imaging.FileFormats.Tiff.TiffFrame frame2 = new Aspose.Imaging.FileFormats.Tiff.TiffFrame(createOptions2, 200, 200);

                                                                                             // Fill the second frame with the blue-yellow gradient.
                                                                                             // It will be automatically converted to the B/W format due to the corresponding settings of the frame.
                                                                                             Aspose.Imaging.Graphics graphics2 = new Aspose.Imaging.Graphics(frame2);
                                                                                             graphics2.FillRectangle(gradientBrush, frame2.Bounds);

                                                                                             // Create a TIFF image.
                                                                                             using (Aspose.Imaging.FileFormats.Tiff.TiffImage tiffImage = new Aspose.Imaging.FileFormats.Tiff.TiffImage(
                                                                                                 new Aspose.Imaging.FileFormats.Tiff.TiffFrame[] { frame1, frame2 }))
                                                                                             {
                                                                                                 tiffImage.Save(dir + "output.mutliframe.tif");
                                                                                             }

Exceptions

ArgumentNullException

Το παράμετρο των επιλογών είναι μηδέν.

Properties

BackgroundColor

Αποκτά ή καθορίζει μια τιμή για το χρώμα του φόντου.

public override Color BackgroundColor { get; set; }

Αξία ιδιοκτησίας

Color

BitsPerPixel

Αποκτά τα bits της εικόνας ανά αριθμό pixel.

public override int BitsPerPixel { get; }

Αξία ιδιοκτησίας

int

ExifData

Αποκτά ή συλλέγει δεδομένα EXIF από το πλαίσιο.

public ExifData ExifData { get; set; }

Αξία ιδιοκτησίας

ExifData

FrameOptions

Το πλαίσιο δημιουργεί επιλογές.

public TiffOptions FrameOptions { get; }

Αξία ιδιοκτησίας

TiffOptions

HasAlpha

Αποκτά μια τιμή που υποδεικνύει εάν αυτή η περίπτωση έχει alpha.

public override bool HasAlpha { get; }

Αξία ιδιοκτησίας

bool

Examples

Το παρακάτω παράδειγμα φορτώνει μια εικόνα TIFF και εκτυπώνει πληροφορίες σχετικά με τη μορφή πρώτων δεδομένων και το αλφα κανάλι.

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

Αποκτά μια τιμή που υποδεικνύει αν η εικόνα έχει διαφανές χρώμα.

public override bool HasTransparentColor { get; set; }

Αξία ιδιοκτησίας

bool

Height

Πάρτε το ύψος της εικόνας.

public override int Height { get; }

Αξία ιδιοκτησίας

int

HorizontalResolution

Αποκτά ή ρυθμίζει την οριζόντια ανάλυση, σε pixels ανά δισκίο, αυτού του Aspose.Imaging.RasterImage.

public override double HorizontalResolution { get; set; }

Αξία ιδιοκτησίας

double

Examples

Το παρακάτω παράδειγμα δείχνει πώς να ρυθμίσετε την οριζόντια / κάθετη ανάλυση ενός ξεχωριστού πλαίσιο TIFF.

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

Αποκτά ή καθορίζει τους πόρους του δρόμου.

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

Αξία ιδιοκτησίας

List &lt · PathResource >

Examples

Μεταφορά Clipping Paths κατά την εξαγωγή από TIFF σε PSD εικόνα.

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

Το παρακάτω παράδειγμα δείχνει πώς να ανακτήσετε τα μονοπάτια από την εικόνα TIFF και να εμφανίσετε τα ονόματά τους στην κονσόλα.

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

Το παρακάτω παράδειγμα δείχνει πώς να τροποποιήσετε ήδη υπάρχοντα μονοπάτια κλιπ. Για παράδειγμα, μπορείτε να κρατήσετε μόνο ένα μονοπάτι κλιπ στην εικόνα.

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

Το παρακάτω παράδειγμα δείχνει πώς να δημιουργήσετε το Clipping Path στην εικόνα TIFF. Για να το κάνετε αυτό, πρέπει να δημιουργήσετε μια παράσταση της κατηγορίας PathResource. Ο παρακάτω κώδικας δείχνει τον τρόπο με τον οποίο μπορείτε να δημιουργήσετε ένα κενό μονοπάτι στην εικόνα TIFF.

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

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

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

Δημιουργήστε το Clipping Path χειροκίνητα.

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

Αποκτά ή ρυθμίζει την κάθετη ανάλυση, σε pixels ανά ιντσάκι, αυτού του Aspose.Imaging.RasterImage.

public override double VerticalResolution { get; set; }

Αξία ιδιοκτησίας

double

Examples

Το παρακάτω παράδειγμα δείχνει πώς να ρυθμίσετε την οριζόντια / κάθετη ανάλυση ενός ξεχωριστού πλαίσιο TIFF.

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

Πάρτε το πλάτος της εικόνας.

public override int Width { get; }

Αξία ιδιοκτησίας

int

XmpData

Αποκτά ή συλλέγει δεδομένα Xmp.

public override XmpPacketWrapper XmpData { get; set; }

Αξία ιδιοκτησίας

XmpPacketWrapper

Methods

AlignResolutions()

Βοηθητική μέθοδος για να κάνουν οριζόντιες και κάθετες λύσεις ίσες.

public void AlignResolutions()

CopyFrame(TiffFrame)

Αντιγράφει ολόκληρο το πλαίσιο (διπλασιάζει).

public static TiffFrame CopyFrame(TiffFrame tiffFrame)

Parameters

tiffFrame TiffFrame

Το τετράγωνο για να αντιγράψουμε.

Returns

TiffFrame

Το πρόσφατα αντιγράφημα Tiff Frame.

CreateFrameFrom(Ετικέτες, TiffOptions)

Δημιουργεί το πλαίσιο από το καθορισμένο tiffFrame’ χρησιμοποιώντας τις καθορισμένες επιλογές’.Τα δεδομένα pixel διατηρούνται αλλά μετατρέπονται στην επιθυμητή μορφή.

public static TiffFrame CreateFrameFrom(TiffFrame tiffFrame, TiffOptions options)

Parameters

tiffFrame TiffFrame

Το τετράγωνο για να δημιουργηθεί.

options TiffOptions

Οι νέες επιλογές που θα χρησιμοποιηθούν.

Returns

TiffFrame

Το πρόσφατα δημιουργημένο πλαίσιο.

Examples

Το παρακάτω παράδειγμα δείχνει πώς να δημιουργήσετε ένα αντίγραφο γκρίζας ενός υπάρχοντος πλαισίου και να το προσθέσετε σε μια εικόνα 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)

Κρατώντας την εικόνα.

public override void Crop(Rectangle rectangle)

Parameters

rectangle Rectangle

Η Ορθόδοξη.

GetOriginalOptions()

Αποκτά τις επιλογές με βάση τις αρχικές ρυθμίσεις αρχείου.Αυτό μπορεί να είναι χρήσιμο για τη διατήρηση του βάθους του bit και άλλων παραμέτρων της αρχικής εικόνας αμετάβλητη.Για παράδειγμα, αν φορτώσουμε μια μαύρη-λευκή εικόνα PNG με 1 bit ανά pixel και στη συνέχεια την αποθηκεύουμε χρησιμοποιώντας τοΜε τη μέθοδο Aspose.Imaging.DataStreamSupporter.Save(System.String), θα παράγεται η εικόνα PNG εξόδου με 8 bit ανά pixel.Για να αποφύγετε αυτό και να αποθηκεύσετε την εικόνα PNG με 1 bit ανά pixel, χρησιμοποιήστε αυτή τη μέθοδο για να πάρετε τις αντίστοιχες επιλογές αποθήκευσης και να τις περάσετεΗ μέθοδος Aspose.Imaging.Image.Save (System.String,Aspose.Imaging.ImageOptionsBase) είναι η δεύτερη παράμετρος.

public override ImageOptionsBase GetOriginalOptions()

Returns

ImageOptionsBase

Οι επιλογές βασίζονται στις αρχικές ρυθμίσεις αρχείου.

ReleaseManagedResources()

Απελευθερώστε τους διαχειριζόμενους πόρους. Βεβαιωθείτε ότι δεν απελευθερώνονται εδώ μη διαχειριζόμενοι πόροι, καθώς μπορεί να έχουν ήδη απελευθερωθεί.

protected override void ReleaseManagedResources()

RemoveMetadata()

Αφαιρέστε αυτά τα μεταδεδομένα παραδείγματος εικόνας ρυθμίζοντας αυτές τις τιμές Aspose.Imaging.xmp.IHasXmpData.Xmph.Exif.IHasExifDate. μηδέν.

public override void RemoveMetadata()

Resize(ΠΕΡΙΣΣΟΤΕΡΑ, ΕΠΙΧΕΙΡΗΣΗ)

Αναζωογονεί την εικόνα.

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

Parameters

newWidth int

Το νέο πλάτος.

newHeight int

Το νέο ύψος.

resizeType ResizeType

Ο τύπος αναζωογόνησης.

Rotate(Φλωτ, μπολ, χρώμα)

Ρυθμίστε την εικόνα γύρω από το κέντρο.

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

Parameters

angle float

Η γωνία περιστροφής σε βαθμούς. θετικές τιμές θα περιστρέφονται με το ρολόι.

resizeProportionally bool

εάν ορίσετε στο “πραγματικό” θα έχετε το μέγεθος της εικόνας σας αλλάξει ανάλογα με τα περιστρεφόμενα ορθογώνια (κενά σημεία) προβολές σε άλλη περίπτωση που αφήνει τις διαστάσεις αγγίξει και μόνο το εσωτερικό περιεχόμενο της εικόνας περιστρέφεται.

backgroundColor Color

Το χρώμα του φόντου.

SaveData(Stream)

Αποθηκεύει τα δεδομένα.

protected override void SaveData(Stream stream)

Parameters

stream Stream

Η ροή για να αποθηκεύσετε τα δεδομένα.

UpdateDimensions(ΕΝΤ, ΕΝΤ)

Αναβαθμίζει τις διαστάσεις της εικόνας.

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

Το νέο πλάτος της εικόνας.

newHeight int

Το νέο ύψος της εικόνας.

 Ελληνικά