Class JpegImage

Class JpegImage

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

Αποτελεσματική χειραγώγηση εικόνων JPEG raster με το API μας, παρέχοντας υποστήριξηγια διάφορα προφίλ χρωμάτων, όπως RGB και CMYK, προσαρμόσιμα bit ανά pixelΔιαμόρφωση και επεξεργασία των μεταδεδομένων EXIF, JFIF και XMP.Απολαύστε την αυτόματη περιστροφή με βάση τα δεδομένα προσανατολισμού και επιλέξτε από διαφορετικάΕπίπεδα συμπίεσης, συμπεριλαμβανομένου του JPEG χωρίς απώλεια, για την επίτευξη της βέλτιστης ποιότητας εικόναςκαι ισορροπία μεγέθους για τα έργα σας.

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

Inheritance

object DisposableObject DataStreamSupporter Image RasterImage RasterCachedImage JpegImage

Implements

IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasJpegExifData , IHasExifData , 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

Πρόσβαση κάμερα κατασκευαστής σημειώσεις σε Jpeg εικόνα.

using (var image = (JpegImage)Image.Load("Sample.jpg"))
                                                                {
                                                                    foreach (var makerNote in image.ExifData.MakerNotes)
                                                                    {
                                                                        Console.WriteLine("Name = {0}, Value = {1}", makerNote.Name, makerNote.Value);
                                                                    }
                                                                }

Το παράδειγμα δείχνει πώς να φορτώσετε ένα JpegImage από ένα αρχείο.

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

                                                                 // Load a JPEG image from a file.
                                                                 using (Aspose.Imaging.FileFormats.Jpeg.JpegImage jpegImage = new Aspose.Imaging.FileFormats.Jpeg.JpegImage(dir + "sample.jpg"))
                                                                 {
                                                                     // Do some image processing.
                                                                     // Save to another JPEG file.
                                                                     jpegImage.Save(dir + "sample.output.jpg");
                                                                 }

Constructors

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

Η κατηγορία Aspose.Imaging.FileFormats.Jpeg.JpegImage ξεκινά χωρίς προσπάθεια, επικαλούμενη τηνκατασκευαστής με τον καθορισμένο παράμετρο δρόμου. αυτός ο κατασκευαστής επιτρέπει αδιάβροχοδημιουργία εικόνων JPEG, εξασφαλίζοντας γρήγορη ενσωμάτωση στα έργα σας με ευκολία.

public JpegImage(string path)

Parameters

path string

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

Examples

Το παράδειγμα δείχνει πώς να φορτώσετε ένα JpegImage από ένα αρχείο.

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

                                                                 // Load a JPEG image from a file.
                                                                 using (Aspose.Imaging.FileFormats.Jpeg.JpegImage jpegImage = new Aspose.Imaging.FileFormats.Jpeg.JpegImage(dir + "sample.jpg"))
                                                                 {
                                                                     // Do some image processing.
                                                                     // Save to another JPEG file.
                                                                     jpegImage.Save(dir + "sample.output.jpg");
                                                                 }

JpegImage(Stream)

Ξεκινήστε ένα αντικείμενο εικόνας JPEG με την κατηγορία Aspose.Imaging.FileFormats.Jpeg.JpegImage χρησιμοποιώντας έναπαράμετρο ροής. αυτός ο κατασκευαστής απλοποιεί τη διαδικασία εργασίας με JPEGεικόνες, προσφέροντας μια απλή προσέγγιση για την ενσωμάτωση τους στα έργα σαςΧωρίς προσπάθεια.

public JpegImage(Stream stream)

Parameters

stream Stream

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

Examples

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

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

                                                                        // Load a JPEG image from a file stream.
                                                                        using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.jpg"))
                                                                        {
                                                                            using (Aspose.Imaging.FileFormats.Jpeg.JpegImage jpegImage = new Aspose.Imaging.FileFormats.Jpeg.JpegImage(stream))
                                                                            {
                                                                                // Do some image processing.
                                                                                // Save to another JPEG file.
                                                                                jpegImage.Save(dir + "sample.output.jpg");
                                                                            }
                                                                        }

JpegImage(RasterImage)

Ξεκινήστε μια νέα περίπτωση της κατηγορίας Aspose.Imaging.FileFormats.Jpeg.JpegImage με μια εικόνα ράστερΑυτός ο κατασκευαστής παρέχει έναν βολικό τρόπο για τη δημιουργία εικόνων JPEGαπευθείας από εικόνες raster, απλοποιώντας τη ροή εργασίας για την εργασία με εικόνες JPEGστις εφαρμογές σας.

public JpegImage(RasterImage rasterImage)

Parameters

rasterImage RasterImage

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

Examples

Το παράδειγμα δείχνει πώς να φορτώσετε ένα JpegImage από άλλο RasterImage.

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

                                                                              // Load a JPEG image from another raster image.
                                                                              // First, create a temporal PNG image that will be a foundation for building a JPEG image.
                                                                              // You can also load PNG image from a file or use an image of any other raster format.
                                                                              Aspose.Imaging.ImageOptions.PngOptions createOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                              createOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream(), false);
                                                                              using (Aspose.Imaging.RasterImage rasterImage = (Aspose.Imaging.RasterImage)Aspose.Imaging.Image.Create(createOptions, 100, 100))
                                                                              {
                                                                                  // Fill the entire PNG image in red.
                                                                                  Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(rasterImage);
                                                                                  Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                  graphics.FillRectangle(brush, rasterImage.Bounds);

                                                                                  // Create a JPEG image based on the PNG image.
                                                                                  using (Aspose.Imaging.FileFormats.Jpeg.JpegImage jpegImage = new Aspose.Imaging.FileFormats.Jpeg.JpegImage(rasterImage))
                                                                                  {
                                                                                      // Save to a JPEG file
                                                                                      jpegImage.Save(dir + "output.jpg");
                                                                                  }
                                                                              }

JpegImage(ΕΝΤ, ΕΝΤ)

Δημιουργήστε μια νέα περίπτωση της κατηγορίας Aspose.Imaging.FileFormats.Jpeg.JpegImage με το καθορισμένο πλάτοςΑυτός ο κατασκευαστής σας επιτρέπει να δημιουργήσετε εικόνες JPEG μεΠροσαρμοσμένες διαστάσεις, δίνοντάς σας ευελιξία στη διαχείριση των μεγεθών εικόνας στην εφαρμογή σας.

public JpegImage(int width, int height)

Parameters

width int

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

height int

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

Examples

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

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

                                                                                      // Create a JPEG image of 100x100 px.
                                                                                      using (Aspose.Imaging.FileFormats.Jpeg.JpegImage jpegImage = new Aspose.Imaging.FileFormats.Jpeg.JpegImage(100, 100))
                                                                                      {
                                                                                          // Do some image processing.
                                                                                          // Save to a file.
                                                                                          jpegImage.Save(dir + "output.jpg");
                                                                                      }

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

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

                                                                                                   // Load a BMP image from a file.
                                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                   {
                                                                                                       // Do some image processing.

                                                                                                       // Use additional options to specify the desired image parameters.
                                                                                                       Aspose.Imaging.ImageOptions.JpegOptions saveOptions = new Aspose.Imaging.ImageOptions.JpegOptions();

                                                                                                       // The number of bits per channel is 8.
                                                                                                       // When a palette is used, the color index is stored in the image data instead of the color itself.
                                                                                                       saveOptions.BitsPerChannel = 8;

                                                                                                       // Set the progressive type of compression.
                                                                                                       saveOptions.CompressionType = Aspose.Imaging.FileFormats.Jpeg.JpegCompressionMode.Progressive;

                                                                                                       // Set the image quality. It is a value between 1 and 100.
                                                                                                       saveOptions.Quality = 100;

                                                                                                       // Set the horizontal/vertical resolution to 96 dots per inch.
                                                                                                       saveOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);
                                                                                                       saveOptions.ResolutionUnit = Aspose.Imaging.ResolutionUnit.Inch;

                                                                                                       // If the source image is colored, it will be converted to grayscaled.
                                                                                                       saveOptions.ColorType = Aspose.Imaging.FileFormats.Jpeg.JpegCompressionColorMode.Grayscale;

                                                                                                       // Use a palette to reduce the output size.
                                                                                                       saveOptions.Palette = Aspose.Imaging.ColorPaletteHelper.Create8BitGrayscale(false);

                                                                                                       image.Save(dir + "sample.palettized.jpg", saveOptions);
                                                                                                   }

JpegImage(Ετικέτες, int, int)

Ξεκινήστε ένα νέο αντικείμενο Aspose.Imaging.FileFormats.Jpeg.JpegImage με τις διαθέσιμες επιλογές JPEG.Αυτός ο κατασκευαστής σας επιτρέπει να προσαρμόσετε διάφορες ρυθμίσεις για την εικόνα JPEG, όπως:ως επίπεδο συμπίεσης, ποιότητα και πρόσθετες παραμέτρους, παρέχοντας ακριβή έλεγχοπάνω από τη μορφή εικόνας που προκύπτει.

public JpegImage(JpegOptions jpegOptions, int width, int height)

Parameters

jpegOptions JpegOptions

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

width int

Φωτογραφία πλάτος.

height int

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

Examples

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

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

                                                                                                   // Load a BMP image from a file.
                                                                                                   using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                   {
                                                                                                       // Do some image processing.

                                                                                                       // Use additional options to specify the desired image parameters.
                                                                                                       Aspose.Imaging.ImageOptions.JpegOptions saveOptions = new Aspose.Imaging.ImageOptions.JpegOptions();

                                                                                                       // The number of bits per channel is 8.
                                                                                                       // When a palette is used, the color index is stored in the image data instead of the color itself.
                                                                                                       saveOptions.BitsPerChannel = 8;

                                                                                                       // Set the progressive type of compression.
                                                                                                       saveOptions.CompressionType = Aspose.Imaging.FileFormats.Jpeg.JpegCompressionMode.Progressive;

                                                                                                       // Set the image quality. It is a value between 1 and 100.
                                                                                                       saveOptions.Quality = 100;

                                                                                                       // Set the horizontal/vertical resolution to 96 dots per inch.
                                                                                                       saveOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);
                                                                                                       saveOptions.ResolutionUnit = Aspose.Imaging.ResolutionUnit.Inch;

                                                                                                       // If the source image is colored, it will be converted to grayscaled.
                                                                                                       saveOptions.ColorType = Aspose.Imaging.FileFormats.Jpeg.JpegCompressionColorMode.Grayscale;

                                                                                                       // Use a palette to reduce the output size.
                                                                                                       saveOptions.Palette = Aspose.Imaging.ColorPaletteHelper.Create8BitGrayscale(false);

                                                                                                       image.Save(dir + "sample.palettized.jpg", saveOptions);
                                                                                                   }

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

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

                                                                                                                    // Create a JPEG image of 100x100 px.
                                                                                                                    // Use additional options to specify the desired image parameters.
                                                                                                                    Aspose.Imaging.ImageOptions.JpegOptions createOptions = new Aspose.Imaging.ImageOptions.JpegOptions();

                                                                                                                    // The number of bits per channel is 8, 8, 8 for Y, Cr, Cb components accordingly.
                                                                                                                    createOptions.BitsPerChannel = 8;

                                                                                                                    // Set the progressive type of compression.
                                                                                                                    createOptions.CompressionType = Aspose.Imaging.FileFormats.Jpeg.JpegCompressionMode.Progressive;

                                                                                                                    // Set the image quality. It is a value between 1 and 100.
                                                                                                                    createOptions.Quality = 100;

                                                                                                                    // Set the horizontal/vertical resolution to 96 dots per inch.
                                                                                                                    createOptions.ResolutionSettings = new Aspose.Imaging.ResolutionSetting(96.0, 96.0);
                                                                                                                    createOptions.ResolutionUnit = Aspose.Imaging.ResolutionUnit.Inch;

                                                                                                                    // This is a standard option for JPEG images.
                                                                                                                    // Two chroma components (Cb and Cr) can be bandwidth-reduced, subsampled, compressed.
                                                                                                                    createOptions.ColorType = Aspose.Imaging.FileFormats.Jpeg.JpegCompressionColorMode.YCbCr;

                                                                                                                    using (Aspose.Imaging.FileFormats.Jpeg.JpegImage jpegImage = new Aspose.Imaging.FileFormats.Jpeg.JpegImage(createOptions, 100, 100))
                                                                                                                    {
                                                                                                                        Aspose.Imaging.Graphics graphics = new Aspose.Imaging.Graphics(jpegImage);

                                                                                                                        Aspose.Imaging.Brushes.LinearGradientBrush gradientBrush = new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                                            new Aspose.Imaging.Point(0, 0),
                                                                                                                            new Aspose.Imaging.Point(jpegImage.Width, jpegImage.Height),
                                                                                                                            Aspose.Imaging.Color.Yellow,
                                                                                                                            Aspose.Imaging.Color.Blue);

                                                                                                                        // Fill the image with a grayscale gradient
                                                                                                                        graphics.FillRectangle(gradientBrush, jpegImage.Bounds);

                                                                                                                        // Save to a file.
                                                                                                                        jpegImage.Save(dir + "output.explicitoptions.jpg");
                                                                                                                    }

Properties

BitsPerPixel

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

public override int BitsPerPixel { get; }

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

int

CmykColorProfile

Το προφίλ χρώματος CMYK που συνδέεται με εικόνες CMYK και YCCK JPEG εξασφαλίζει την ακρίβειαμετατροπή χρώματος και πιστότητα. λειτουργεί σε συνδυασμό με το RGBColorProfile γιαεγγυάται ακριβή απεικόνιση χρωμάτων σε διάφορες συσκευές και εφαρμογές.Αυτό το ζεύγος είναι ζωτικής σημασίας για τη διατήρηση της συνεκτικότητας στην παράδοση χρωμάτων καιΝα επιτευχθεί η βέλτιστη ποιότητα εικόνας.

public StreamSource CmykColorProfile { get; set; }

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

StreamSource

Examples

Το παρακάτω παράδειγμα φορτώνει το PNG και το αποθηκεύει στο CMYK JPEG χρησιμοποιώντας προσαρμοσμένο προφίλ ICC. Στη συνέχεια φορτώνει το CMYK JPEG και το αποθηκεύει πίσω στο PNG. Η μετατροπή χρώματος από RGB σε CMYK και από CMYK σε RGB πραγματοποιείται χρησιμοποιώντας προσαρμοσμένα προφίλ ICC.

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

                                                                                                                                                                                                                                                // Load PNG and save it to CMYK JPEG
                                                                                                                                                                                                                                                using (Aspose.Imaging.FileFormats.Png.PngImage image = (Aspose.Imaging.FileFormats.Png.PngImage)Image.Load(dir + "sample.png"))
                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                    using (System.IO.Stream rgbProfileStream = System.IO.File.OpenRead(dir + "eciRGB_v2.icc"))
                                                                                                                                                                                                                                                    using (System.IO.Stream cmykProfileStream = System.IO.File.OpenRead(dir + "ISOcoated_v2_FullGamut4.icc"))
                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                        Aspose.Imaging.ImageOptions.JpegOptions saveOptions = new Aspose.Imaging.ImageOptions.JpegOptions();
                                                                                                                                                                                                                                                        saveOptions.ColorType = Aspose.Imaging.FileFormats.Jpeg.JpegCompressionColorMode.Cmyk;

                                                                                                                                                                                                                                                        // Use custom ICC profiles
                                                                                                                                                                                                                                                        saveOptions.RgbColorProfile = new Aspose.Imaging.Sources.StreamSource(rgbProfileStream);
                                                                                                                                                                                                                                                        saveOptions.CmykColorProfile = new Aspose.Imaging.Sources.StreamSource(cmykProfileStream);

                                                                                                                                                                                                                                                        image.Save(dir + "output.cmyk.jpg", saveOptions);
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                // Load CMYK JPEG and save it to PNG
                                                                                                                                                                                                                                                using (Aspose.Imaging.FileFormats.Jpeg.JpegImage image = (Aspose.Imaging.FileFormats.Jpeg.JpegImage)Image.Load(dir + "output.cmyk.jpg"))
                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                    using (System.IO.Stream rgbProfileStream = System.IO.File.OpenRead(dir + "eciRGB_v2.icc"))
                                                                                                                                                                                                                                                    using (System.IO.Stream cmykProfileStream = System.IO.File.OpenRead(dir + "ISOcoated_v2_FullGamut4.icc"))
                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                        // Use custom ICC profiles
                                                                                                                                                                                                                                                        image.RgbColorProfile = new Aspose.Imaging.Sources.StreamSource(rgbProfileStream);
                                                                                                                                                                                                                                                        image.CmykColorProfile = new Aspose.Imaging.Sources.StreamSource(cmykProfileStream);

                                                                                                                                                                                                                                                        Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                                                                                                                                                        image.Save(dir + "output.rgb.png", saveOptions);
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                }

Comment

Διαχειριστείτε σχόλια αρχείου JPEG με αυτή την ιδιοκτησία, επιτρέποντάς σας να προσθέσετε ή να ανακτήσετεπεριγραφικές σημειώσεις που σχετίζονται με την εικόνα. αν είναι η ετικέτα εικόνων μεμεταδεδομένα ή προσθέτοντας πρόσθετο πλαίσιο, αυτή η ιδιοκτησία προσφέρει ευελιξία στηνΟργάνωση και κατηγοριοποίηση των αρχείων JPEG σας.

public string Comment { get; set; }

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

string

DestinationCmykColorProfile

Το προφίλ χρωμάτων CMYK είναι ζωτικής σημασίας για την ακριβή μετατροπή χρωμάτων CMYK και YCCKJPEG εικόνες κατά τη διάρκεια της διαδικασίας αποθήκευσης. λειτουργεί ταυτόχρονα με το RGBColorProfileγια να διασφαλιστεί η σωστή απεικόνιση των χρωμάτων, διατηρώντας τη συνοχή και την ποιότητα μεταξύ τουςδιαφόρων συσκευών και λογισμικού. αυτή η συγχρονισμός είναι ζωτικής σημασίας για την επίτευξηΑξιοσημείωτη και αξιόπιστη απεικόνιση χρωμάτων στις τελικές αποθηκευμένες εικόνες.

public StreamSource DestinationCmykColorProfile { get; set; }

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

StreamSource

DestinationRgbColorProfile

Το RGBColorProfile είναι απαραίτητο για την ακριβή μετατροπή χρωμάτων CMYK και YCCKJPEG εικόνες κατά τη διάρκεια της διαδικασίας αποθήκευσης. Όταν συσχετιστεί με το CMYKColorProfile, τοδιασφαλίζει ότι τα χρώματα αποτυπώνονται σωστά και διατηρεί τη συνοχή μεταξύ τουςδιαφορετικές συσκευές και εφαρμογές. αυτός ο συνδυασμός είναι ζωτικής σημασίας για τη διατήρηση τηςπροορισμένη απεικόνιση χρώματος και την επίτευξη υψηλής ποιότητας παραγωγής εικόνας.

public StreamSource DestinationRgbColorProfile { get; set; }

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

StreamSource

ExifData

Διαχειριστείτε τα δεδομένα EXIF με αυτή την ιδιοκτησία, επιτρέποντάς σας να προσθέσετε ή να ανακτήσετε μεταδεδομένασυνδεδεμένη με την εικόνα. είτε πρόκειται για την εξαγωγή πληροφοριών σχετικά με την κάμεραρυθμίσεις ή την τροποποίηση των υφιστάμενων μεταδεδομένων, αυτή η ιδιότητα προσφέρει ευελιξία στηνΔιαχείριση του δοχείου δεδομένων EXIF.

public JpegExifData ExifData { get; set; }

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

JpegExifData

Examples

Το παρακάτω παράδειγμα δείχνει πώς να εξαγάγετε τις ετικέτες EXIF από μια εικόνα JPEG.

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

                                                                                  using (Aspose.Imaging.FileFormats.Jpeg.JpegImage image = (Aspose.Imaging.FileFormats.Jpeg.JpegImage)Image.Load(dir + "original.jpg"))
                                                                                  {
                                                                                      Aspose.Imaging.Exif.ExifData exifData = image.ExifData;

                                                                                      System.Console.WriteLine("The general EXIF data");
                                                                                      System.Console.WriteLine("------------------------------------------");
                                                                                      if (exifData != null)
                                                                                      {
                                                                                          System.Console.WriteLine("The EXIF version: {0}", exifData.ExifVersion);
                                                                                          System.Console.WriteLine("The camera serial number: {0}", exifData.BodySerialNumber);
                                                                                          System.Console.WriteLine("The color space: {0}", exifData.ColorSpace);
                                                                                          System.Console.WriteLine("The brightness: {0}", exifData.BrightnessValue);
                                                                                          System.Console.WriteLine("The contrast: {0}", exifData.Contrast);
                                                                                          System.Console.WriteLine("The gamma: {0}", exifData.Gamma);
                                                                                          System.Console.WriteLine("The sharpness: {0}", exifData.Sharpness);
                                                                                          System.Console.WriteLine("The aperture: {0}", exifData.ApertureValue);
                                                                                          System.Console.WriteLine("The exposure mode: {0}", exifData.ExposureMode);
                                                                                          System.Console.WriteLine("The exposure bias: {0}", exifData.ExposureBiasValue);
                                                                                          System.Console.WriteLine("The exposure time: {0}", exifData.ExposureTime);
                                                                                          System.Console.WriteLine("The focal length: {0}", exifData.FocalLength);
                                                                                          System.Console.WriteLine("The focal plane resolution unit: {0}", exifData.FocalPlaneResolutionUnit);
                                                                                          System.Console.WriteLine("The lens model: {0}", exifData.LensModel);
                                                                                          System.Console.WriteLine("The shutter speed: {0}", exifData.ShutterSpeedValue);
                                                                                      }

                                                                                      System.Console.WriteLine("The JPEG EXIF data");
                                                                                      System.Console.WriteLine("------------------------------------------");
                                                                                      Aspose.Imaging.Exif.JpegExifData jpegExifData = image.ExifData as Aspose.Imaging.Exif.JpegExifData;
                                                                                      if (jpegExifData != null)
                                                                                      {
                                                                                          System.Console.WriteLine("The camera manufacturer: {0}", jpegExifData.Make);
                                                                                          System.Console.WriteLine("The camera model: {0}", jpegExifData.Model);
                                                                                          System.Console.WriteLine("The photometric interpretation: {0}", jpegExifData.PhotometricInterpretation);
                                                                                          System.Console.WriteLine("The artist: {0}", jpegExifData.Artist);
                                                                                          System.Console.WriteLine("The copyright: {0}", jpegExifData.Copyright);
                                                                                          System.Console.WriteLine("The image description: {0}", jpegExifData.ImageDescription);
                                                                                          System.Console.WriteLine("The orientation: {0}", jpegExifData.Orientation);
                                                                                          System.Console.WriteLine("The software: {0}", jpegExifData.Software);
                                                                                      }
                                                                                  }

                                                                                  //The output looks like this:
                                                                                  //The general EXIF data
                                                                                  //------------------------------------------
                                                                                  //The EXIF version: System.Byte[]
                                                                                  //The camera serial number: 7100536
                                                                                  //The color space: SRgb
                                                                                  //The brightness:
                                                                                  //The contrast: Normal
                                                                                  //The gamma:
                                                                                  //The sharpness: 0
                                                                                  //The aperture: 4.64(4643856 / 1000000)
                                                                                  //The exposure mode: Manual
                                                                                  //The exposure bias: 0.67(4 / 6)
                                                                                  //The exposure time: 0.01(1 / 160)
                                                                                  //The focal length: 145.00(1450 / 10)
                                                                                  //The focal plane resolution unit: Cm
                                                                                  //The lens model: 70.0 - 200.0 mm f/ 4.0
                                                                                  //The shutter speed: 7.32(7321928 / 1000000)
                                                                                  //The JPEG EXIF data
                                                                                  //------------------------------------------
                                                                                  //The camera manufacturer: NIKON CORPORATION
                                                                                  //The camera model: NIKON D5
                                                                                  //The photometric interpretation: 0
                                                                                  //The artist: 
                                                                                  //The copyright: 
                                                                                  //The image description:
                                                                                  //The orientation: TopLeft
                                                                                  //The software: Adobe Photoshop Camera Raw 9.9(Macintosh)

FileFormat

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

public override FileFormat FileFormat { get; }

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

FileFormat

Height

Αποκτήστε το ύψος της εικόνας χωρίς προσπάθεια με αυτή την ιδιότητα. παρέχει γρήγοραπρόσβαση στην κάθετη διάσταση της εικόνας, επιτρέποντας την αποτελεσματικήνα καθορίσει το μέγεθος και τη σχέση πτυχής του χωρίς την ανάγκη για σύνθετους υπολογισμούς ήπρόσθετες μεθόδους.

public override int Height { get; }

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

int

HorizontalResolution

Αυτή η ιδιοκτησία σας δίνει πρόσβαση στην οριζόντια ανάλυση τηςAspose.Imaging.RasterImage, μετρημένο σε pixels ανά ίντσα.Αυτή η τιμή, μπορείτε να ελέγξετε με ακρίβεια την ανάλυση της εικόνας, διασφαλίζοντας ότιικανοποιεί τις συγκεκριμένες απαιτήσεις σας για την ποιότητα και την σαφήνεια.

public override double HorizontalResolution { get; set; }

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

double

Examples

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

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

                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.jpg"))
                                                                                                 {
                                                                                                     Aspose.Imaging.FileFormats.Jpeg.JpegImage jpegImage = (Aspose.Imaging.FileFormats.Jpeg.JpegImage)image;

                                                                                                     // Get horizontal and vertical resolution of the BmpImage
                                                                                                     double horizontalResolution = jpegImage.HorizontalResolution;
                                                                                                     double verticalResolution = jpegImage.VerticalResolution;
                                                                                                     System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", horizontalResolution);
                                                                                                     System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", verticalResolution);

                                                                                                     if (horizontalResolution != 96.0 || verticalResolution != 96.0)
                                                                                                     {
                                                                                                         // Use the SetResolution method for updating both resolution values in a single call.
                                                                                                         System.Console.WriteLine("Set resolution values to 96 dpi");
                                                                                                         jpegImage.SetResolution(96.0, 96.0);

                                                                                                         System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", jpegImage.HorizontalResolution);
                                                                                                         System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", jpegImage.VerticalResolution);
                                                                                                     }

                                                                                                     // The output may look like this:
                                                                                                     // The horizontal resolution, in pixels per inch: 300
                                                                                                     // The vertical resolution, in pixels per inch: 300
                                                                                                     // Set resolution values to 96 dpi
                                                                                                     // The horizontal resolution, in pixels per inch: 96
                                                                                                     // The vertical resolution, in pixels per inch: 96
                                                                                                 }

Remarks

Σημειώστε προεπιλογή αυτή η τιμή είναι πάντα 96 καθώς διαφορετικές πλατφόρμες δεν μπορούν να επιστρέψουν την ανάλυση οθόνης. Μπορείτε να εξετάσετε τη χρήση της μεθόδου SetResolution για την ενημέρωση και των δύο τιμών ανάλυση σε μία κλήση.

IgnoreEmbeddedColorProfile

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

public bool IgnoreEmbeddedColorProfile { get; set; }

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

bool

Jfif

Αυτή η ιδιότητα σας επιτρέπει να έχετε πρόσβαση ή να τροποποιήσετε το JFIF (JPEG File Interchange)Format) δεδομένα που σχετίζονται με την εικόνα JPEG. JFIF είναι μια τυποποιημένη μορφή γιαανταλλαγή εικόνων συμπιεσμένων με JPEG μεταξύ υπολογιστών και άλλων συσκευών.ή τη ρύθμιση αυτής της ιδιοκτησίας, μπορείτε να αλληλεπιδράτε με τα δεδομένα JFIF, τα οποία μπορεί να περιλαμβάνουνπληροφορίες όπως η ανάλυση της εικόνας, η αναλογία πτυχών και το ελαφρύ.

public JFIFData Jfif { get; set; }

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

JFIFData

JpegOptions

Αποκτήστε πρόσβαση στις επιλογές JPEG που χρησιμοποιήθηκαν κατά τη δημιουργία ή την φόρτιση αυτούΕισαγωγή.Imaging.FileFormats.Jpeg.JpegImage παράδειγμα με ευκολία. Αυτή η ιδιοκτησία προσφέρει πολύτιμες λεπτομέρειεςσχετικά με τις συγκεκριμένες ρυθμίσεις που χρησιμοποιούνται, επιτρέποντας στους χρήστες να κατανοήσουν και να επαναλάβουνεπεξεργασία εικόνας ροές εργασίας αποτελεσματικά. αν είναι τα επίπεδα συμπίεσης, ποιότηταρυθμίσεις, ή άλλες παραμέτρους, αυτή η ιδιοκτησία παρέχει βασικές ενδείξεις γιαΜειωμένη χειραγώγηση εικόνας.

public JpegOptions JpegOptions { get; }

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

JpegOptions

Examples

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

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

                                                                                               using (Aspose.Imaging.FileFormats.Jpeg.JpegImage image = (Aspose.Imaging.FileFormats.Jpeg.JpegImage)Image.Load(dir + "original.jpg"))
                                                                                               {
                                                                                                   Aspose.Imaging.ImageOptions.JpegOptions jpegOptions = image.JpegOptions;

                                                                                                   System.Console.WriteLine("The number of bits per channel: {0}", jpegOptions.BitsPerChannel);
                                                                                                   System.Console.WriteLine("The max allowed size for all internal buffers: {0}", jpegOptions.BufferSizeHint);
                                                                                                   System.Console.WriteLine("The color type: {0}", jpegOptions.ColorType);
                                                                                                   System.Console.WriteLine("The compression type: {0}", jpegOptions.CompressionType);
                                                                                                   System.Console.WriteLine("The image quality: {0}", jpegOptions.Quality);

                                                                                                   if (jpegOptions.ResolutionSettings != null)
                                                                                                   {
                                                                                                       System.Console.WriteLine("The horizontal resolution: {0}", jpegOptions.ResolutionSettings.HorizontalResolution);
                                                                                                       System.Console.WriteLine("The vertical resolution: {0}", jpegOptions.ResolutionSettings.VerticalResolution);
                                                                                                   }

                                                                                                   for (int i = 0; i < jpegOptions.HorizontalSampling.Length; i++)
                                                                                                   {
                                                                                                       System.Console.WriteLine("The sampling for component {0}: {1}x{2}", i, jpegOptions.HorizontalSampling[i], jpegOptions.VerticalSampling[i]);
                                                                                                   }
                                                                                               }

                                                                                               //The output looks like this:
                                                                                               //The number of bits per channel: 8
                                                                                               //The max allowed size for all internal buffers: 0
                                                                                               //The color type: YCbCr
                                                                                               //The compression type: Baseline
                                                                                               //The image quality: 75
                                                                                               //The sampling for component 0: 1x1
                                                                                               //The sampling for component 1: 1x1
                                                                                               //The sampling for component 2: 1x1

RawDataFormat

Αυτή η ιδιοκτησία ανακτά τη μορφή πρώτων δεδομένων της εικόνας, η οποία υποδεικνύει πώςΤα δεδομένα εικόνας είναι διαρθρωμένα και κρυπτογραφημένα. κατανοώντας τη μορφή πρώτων δεδομένων είναιΕίναι απαραίτητο για την αποτελεσματική επεξεργασία ή χειραγώγηση των δεδομένων εικόνας.Εμφάνιση της υποκείμενης εκπροσώπησης της εικόνας, όπως αν είναισυμπιεσμένο, κωδικοποιημένο σε ένα συγκεκριμένο χώρο χρώματος ή αποθηκευμένο σε ένα συγκεκριμένο αρχείοΗ πρόσβαση σε αυτή την ιδιοκτησία σας επιτρέπει να αποκτήσετε πολύτιμες πληροφορίες σχετικά με τηνΗ δομή δεδομένων της εικόνας, που σας επιτρέπει να εκτελέσετε διάφορες λειτουργίες ή βελτιστοποιήσειςπροσαρμοσμένο στην ειδική του μορφή.

public override PixelDataFormat RawDataFormat { get; }

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

PixelDataFormat

RgbColorProfile

Το προφίλ χρώματος RGB για εικόνες CMYK και YCCK JPEG εξασφαλίζει ακριβή χρώμαμετατροπή και εκπροσώπηση. πρέπει να συσχετιστεί με το CMYKColorProfile γιαδιατηρήστε τη συνοχή και την πιστότητα στην παράδοση χρωμάτων.Αυτό το ζεύγος είναι απαραίτητο γιαεφαρμογές που απαιτούν ακριβή διαχείριση χρωμάτων και αναπαραγωγή εικόνων,να διασφαλιστεί ότι τα δεδομένα RGB ερμηνεύονται και εμφανίζονται σωστά.

public StreamSource RgbColorProfile { get; set; }

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

StreamSource

Examples

Το παρακάτω παράδειγμα φορτώνει το PNG και το αποθηκεύει στο CMYK JPEG χρησιμοποιώντας προσαρμοσμένο προφίλ ICC. Στη συνέχεια φορτώνει το CMYK JPEG και το αποθηκεύει πίσω στο PNG. Η μετατροπή χρώματος από RGB σε CMYK και από CMYK σε RGB πραγματοποιείται χρησιμοποιώντας προσαρμοσμένα προφίλ ICC.

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

                                                                                                                                                                                                                                                // Load PNG and save it to CMYK JPEG
                                                                                                                                                                                                                                                using (Aspose.Imaging.FileFormats.Png.PngImage image = (Aspose.Imaging.FileFormats.Png.PngImage)Image.Load(dir + "sample.png"))
                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                    using (System.IO.Stream rgbProfileStream = System.IO.File.OpenRead(dir + "eciRGB_v2.icc"))
                                                                                                                                                                                                                                                    using (System.IO.Stream cmykProfileStream = System.IO.File.OpenRead(dir + "ISOcoated_v2_FullGamut4.icc"))
                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                        Aspose.Imaging.ImageOptions.JpegOptions saveOptions = new Aspose.Imaging.ImageOptions.JpegOptions();
                                                                                                                                                                                                                                                        saveOptions.ColorType = Aspose.Imaging.FileFormats.Jpeg.JpegCompressionColorMode.Cmyk;

                                                                                                                                                                                                                                                        // Use custom ICC profiles
                                                                                                                                                                                                                                                        saveOptions.RgbColorProfile = new Aspose.Imaging.Sources.StreamSource(rgbProfileStream);
                                                                                                                                                                                                                                                        saveOptions.CmykColorProfile = new Aspose.Imaging.Sources.StreamSource(cmykProfileStream);

                                                                                                                                                                                                                                                        image.Save(dir + "output.cmyk.jpg", saveOptions);
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                // Load CMYK JPEG and save it to PNG
                                                                                                                                                                                                                                                using (Aspose.Imaging.FileFormats.Jpeg.JpegImage image = (Aspose.Imaging.FileFormats.Jpeg.JpegImage)Image.Load(dir + "output.cmyk.jpg"))
                                                                                                                                                                                                                                                {
                                                                                                                                                                                                                                                    using (System.IO.Stream rgbProfileStream = System.IO.File.OpenRead(dir + "eciRGB_v2.icc"))
                                                                                                                                                                                                                                                    using (System.IO.Stream cmykProfileStream = System.IO.File.OpenRead(dir + "ISOcoated_v2_FullGamut4.icc"))
                                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                                        // Use custom ICC profiles
                                                                                                                                                                                                                                                        image.RgbColorProfile = new Aspose.Imaging.Sources.StreamSource(rgbProfileStream);
                                                                                                                                                                                                                                                        image.CmykColorProfile = new Aspose.Imaging.Sources.StreamSource(cmykProfileStream);

                                                                                                                                                                                                                                                        Aspose.Imaging.ImageOptions.PngOptions saveOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                                                                                                                                                        image.Save(dir + "output.rgb.png", saveOptions);
                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                }

VerticalResolution

Αυτή η ιδιότητα διαχειρίζεται την κάθετη ανάλυση, εκφρασμένη σε pixels per inch, γιατο συνδεδεμένο Aspose.Imaging.RasterImage. η προσαρμογή αυτής της ανάλυσης επηρεάζει τηνΤο μέγεθος και η ποιότητα της εικόνας όταν εκτυπώνεται ή εμφανίζεται σε ένα σταθερό φυσικό μέγεθος.Με τη ρύθμιση αυτής της ιδιότητας, ελέγχετε πόσο πυκνά συσκευάζονται τα pixels της εικόναςκάθετα, επηρεάζοντας τη συνολική οξύτητα και σαφήνεια του.

public override double VerticalResolution { get; set; }

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

double

Examples

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

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

                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.jpg"))
                                                                                                 {
                                                                                                     Aspose.Imaging.FileFormats.Jpeg.JpegImage jpegImage = (Aspose.Imaging.FileFormats.Jpeg.JpegImage)image;

                                                                                                     // Get horizontal and vertical resolution of the BmpImage
                                                                                                     double horizontalResolution = jpegImage.HorizontalResolution;
                                                                                                     double verticalResolution = jpegImage.VerticalResolution;
                                                                                                     System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", horizontalResolution);
                                                                                                     System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", verticalResolution);

                                                                                                     if (horizontalResolution != 96.0 || verticalResolution != 96.0)
                                                                                                     {
                                                                                                         // Use the SetResolution method for updating both resolution values in a single call.
                                                                                                         System.Console.WriteLine("Set resolution values to 96 dpi");
                                                                                                         jpegImage.SetResolution(96.0, 96.0);

                                                                                                         System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", jpegImage.HorizontalResolution);
                                                                                                         System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", jpegImage.VerticalResolution);
                                                                                                     }

                                                                                                     // The output may look like this:
                                                                                                     // The horizontal resolution, in pixels per inch: 300
                                                                                                     // The vertical resolution, in pixels per inch: 300
                                                                                                     // Set resolution values to 96 dpi
                                                                                                     // The horizontal resolution, in pixels per inch: 96
                                                                                                     // The vertical resolution, in pixels per inch: 96
                                                                                                 }

Remarks

Σημειώστε προεπιλογή αυτή η τιμή είναι πάντα 72 καθώς διαφορετικές πλατφόρμες δεν μπορούν να επιστρέψουν την ανάλυση οθόνης. Μπορείτε να εξετάσετε τη χρήση της μεθόδου SetResolution για την ενημέρωση και των δύο τιμών ανάλυση σε μία κλήση.

Width

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

public override int Width { get; }

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

int

XmpData

λαμβάνει ή συλλέγει μεταδεδομένα XMP, επιτρέποντας την αδιάβροχη ενσωμάτωση τωνπεριγραφικές πληροφορίες στο αρχείο εικόνας. αν εξάγετε το υπάρχον XMPμεταδεδομένα ή την ενημέρωσή τους με νέες πληροφορίες, αυτή η ιδιότητα απλοποιεί τηνΔιαχείριση εκτεταμένων μεταδεδομένων, διασφάλιση της συμβατότητας με διάφορες εφαρμογέςκαι τις ροές εργασίας.

public override XmpPacketWrapper XmpData { get; set; }

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

XmpPacketWrapper

Methods

AutoRotate()

Αυτόματα περιστρέφεται η εικόνα με βάση τα δεδομένα προσανατολισμού που εξάγονται από το ExifΑυτή η μέθοδος εξασφαλίζει ότι οι εικόνες εμφανίζονται στην σωστή κατεύθυνση,βελτίωση της εμπειρίας του χρήστη και εξάλειψη της ανάγκης για χειροκίνητες προσαρμογές.αναλύοντας τις πληροφορίες του Exif, η εικόνα περιστρέφεται ανάλογα, παρέχοντας μια αδιάβροχηΕμπειρία προβολής σε διαφορετικές πλατφόρμες και συσκευές. Αυτή η αυτόματη περιστροφήΗ διαδικασία απλοποιεί την επεξεργασία εικόνας και βελτιώνει τη συνολική χρησιμότητα, ειδικά ότανΑντιμετώπιση μεγάλων τμημάτων εικόνων με διαφορετικές κατευθύνσεις.

public void AutoRotate()

Exceptions

ArgumentOutOfRangeException

Η τιμή «Αποκατεύθυνση» του «JpegExifData» είναι εκτός του επιτρεπόμενου εύρους [1…8], οπότε δεν μπορεί να εφαρμοστεί αυτόματη περιστροφή.

GetModifyDate(Μπόλ)

Επαναλαμβάνει την ημερομηνία και την ώρα κατά την οποία η εικόνα του πόρου υπέστη την τελευταία τηςΑυτή η μέθοδος παρέχει πολύτιμα μεταδεδομένα, επιτρέποντας στους χρήστες να παρακολουθούν καιδιαχείριση των ενημερώσεων στο αρχείο εικόνας αποτελεσματικά. με την πρόσβαση σε αυτές τις πληροφορίες, οι χρήστεςμπορεί να εξασφαλίσει την ακεραιότητα και το νόμισμα των περιουσιακών στοιχείων της εικόνας τους, διευκολύνοντας την πληροφόρησηλήψη αποφάσεων σχετικά με τη χρήση και τη συντήρηση της εικόνας.

public override DateTime GetModifyDate(bool useDefault)

Parameters

useDefault bool

εάν ορίσετε στο “πραγματικό”, χρησιμοποιήστε τις πληροφορίες από το FileInfo ως προεπιλεγμένη τιμή.

Returns

DateTime

Η ημερομηνία και η ώρα της εικόνας πόρων τροποποιήθηκε τελευταία.

ReleaseManagedResources()

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

protected override void ReleaseManagedResources()

RemoveMetadata()

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

public override void RemoveMetadata()

SaveData(Stream)

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

protected override void SaveData(Stream stream)

Parameters

stream Stream

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

SetResolution(ΔΥΟ, ΔΥΟ)

Καθορίζει την ανάλυση για το καθορισμένο Aspose.Imaging.RasterImage, διασφαλίζοντας ότιακριβείς ικανότητες κλίσης και εκτύπωσης. αυτή η μέθοδος επιτρέπει στους χρήστες να προσαρμόζονταιτην ανάλυση εικόνας για να ταιριάζει στις συγκεκριμένες απαιτήσεις τους, είτε για ψηφιακήπροβολή ή φυσική αναπαραγωγή. με τη ρύθμιση της ανάλυσης, οι χρήστες μπορούν να βελτιστοποιήσουντην ποιότητα της εικόνας και τη διασφάλιση της συμβατότητας με διάφορες συσκευές και μέσους παραγωγής,βελτίωση της συνολικής οπτικής εμπειρίας και της χρήσιμης εικόνας.

public override void SetResolution(double dpiX, double dpiY)

Parameters

dpiX double

Η οριζόντια ανάλυση, σε σημεία ανά ίντσα, του Aspose.Imaging.RasterImage.

dpiY double

Η κάθετη ανάλυση, σε σημεία ανά ίντσα, του Aspose.Imaging.RasterImage.

Examples

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

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

                                                                                                 using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.jpg"))
                                                                                                 {
                                                                                                     Aspose.Imaging.FileFormats.Jpeg.JpegImage jpegImage = (Aspose.Imaging.FileFormats.Jpeg.JpegImage)image;

                                                                                                     // Get horizontal and vertical resolution of the BmpImage
                                                                                                     double horizontalResolution = jpegImage.HorizontalResolution;
                                                                                                     double verticalResolution = jpegImage.VerticalResolution;
                                                                                                     System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", horizontalResolution);
                                                                                                     System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", verticalResolution);

                                                                                                     if (horizontalResolution != 96.0 || verticalResolution != 96.0)
                                                                                                     {
                                                                                                         // Use the SetResolution method for updating both resolution values in a single call.
                                                                                                         System.Console.WriteLine("Set resolution values to 96 dpi");
                                                                                                         jpegImage.SetResolution(96.0, 96.0);

                                                                                                         System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", jpegImage.HorizontalResolution);
                                                                                                         System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", jpegImage.VerticalResolution);
                                                                                                     }

                                                                                                     // The output may look like this:
                                                                                                     // The horizontal resolution, in pixels per inch: 300
                                                                                                     // The vertical resolution, in pixels per inch: 300
                                                                                                     // Set resolution values to 96 dpi
                                                                                                     // The horizontal resolution, in pixels per inch: 96
                                                                                                     // The vertical resolution, in pixels per inch: 96
                                                                                                 }

UpdateDimensions(ΕΝΤ, ΕΝΤ)

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

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

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

newHeight int

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

UpdateMetadata()

Αναβαθμίζει τα μεταδεδομένα εικόνας.

protected override void UpdateMetadata()
 Ελληνικά