Class JpegImage

Class JpegImage

이름 공간 : Aspose.Imaging.FileFormats.Jpeg 모임: Aspose.Imaging.dll (25.4.0)

효율적으로 우리의 API를 사용하여 JPEG raster 이미지를 조작하여 지원을 제공합니다.RGB 및 CMYK와 같은 다양한 색상 프로파일, 픽셀 당 사용자 지정 가능한 비트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

이미지를 로드하고 픽셀과 팔레트 데이터를 시작하는 경로.

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)

Aspose.Imaging.FileFormats.Jpeg.JpegImage 클래스를 사용하여 JPEG 이미지 개체를 시작합니다.스트림 매개 변수.이 컨버터는 JPEG 작업을 단순화합니다.이미지, 프로젝트에 그들을 통합하기위한 간단한 접근 방식을 제공힘들지 않게

public JpegImage(Stream stream)

Parameters

stream Stream

흐름에서 이미지를 로드하고 픽셀과 팔레트 데이터를 시작합니다.

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 이미지를 만드는 편리한 방법을 제공합니다.라스터 이미지에서 직접, JPEG 이미지와 함께 작업하는 작업 흐름을 단순화당신의 응용 프로그램에서.

public JpegImage(RasterImage rasterImage)

Parameters

rasterImage RasterImage

이미지와 함께 픽셀 및 팔레트 데이터를 시작합니다.

Examples

예제는 다른 RasterImage에서 JpegImage를 업로드하는 방법을 보여줍니다.

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(Jpeg옵션, int, int)

제공된 JPEG 옵션으로 새로운 Aspose.Imaging.FileFormats.Jpeg.JpegImage 개체를 시작합니다.이 디자이너는 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

이 속성으로 이미지의 픽셀 깊이를 열심히 회복, 제공색의 풍부함이나 회색 표현의 풍부함에 대한 인식.활기찬 사진 또는 모노크롬 그림,이 속성은 중요한이미지의 시각적 복잡성에 대한 정보.

public override int BitsPerPixel { get; }

부동산 가치

int

CmykColorProfile

CMYK 및 YCCK JPEG 이미지와 관련된 CMYK 색상 프로파일은 정확성을 보장합니다.색상 변환 및 충성도. 그것은 RGBColorProfile과 함께 작동합니다.다양한 장치 및 응용 프로그램에서 정확한 색상 표현을 보장합니다.이 쌍은 색상 렌더링의 일관성을 유지하는 데 필수적이며최적의 이미지 품질을 제공합니다.

public StreamSource CmykColorProfile { get; set; }

부동산 가치

StreamSource

Examples

다음 예제는 사용자 지정 ICC 프로필을 사용하여 PNG를 충전하고 CMYK JPEG로 저장합니다. 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 및 YCCK의 정확한 색상 변환에 필수적입니다.저장 과정에서 JPEG 이미지. 그것은 RGBColorProfile와 동시에 작동합니다.올바른 색상 표현을 보장하고 각각의 일관성과 품질을 유지하기 위해다양한 장치 및 소프트웨어.이 동기화는 달성에 필수적입니다최종 저장된 이미지에서 정확하고 신뢰할 수 있는 색상 렌더링.

public StreamSource DestinationCmykColorProfile { get; set; }

부동산 가치

StreamSource

DestinationRgbColorProfile

RGBColorProfile은 CMYK 및 YCCK의 정확한 색상 변환에 필수적입니다.저장 과정에서 JPEG 이미지. CMYKColorProfile와 함께 파이어 할 때, 그것은색상이 올바르게 재생되고 일관성을 유지하는 것을 보장합니다.다양한 장치 및 응용 프로그램.이 조합은 보존에 필수적입니다.목적 색상 표현 및 높은 품질의 이미지 생산을 달성.

public StreamSource DestinationRgbColorProfile { get; set; }

부동산 가치

StreamSource

ExifData

이 재산을 사용하여 EXIF 데이터를 관리하여 메타 데이터를 추가하거나 수신할 수 있습니다.사진과 관련된.그것이 카메라에 대한 정보를 추출하는지 여부설정 또는 기존 메타 데이터를 변경, 이 속성은 유연성을 제공합니다EXIF 데이터 컨테이너를 관리합니다.

public JpegExifData ExifData { get; set; }

부동산 가치

JpegExifData

Examples

다음 예제는 JPEG 이미지에서 EXIF 태그를 추출하는 방법을 보여줍니다.

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, 인치 당 픽셀으로 측정이 값, 당신은 정확하게 이미지의 해상도를 제어 할 수 있습니다, 그것을 보장품질과 명확성에 대한 특정 요구 사항을 충족합니다.

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 파일 교환)에 액세스하거나 변경할 수 있습니다.형식) JPEG 이미지와 관련된 데이터.JFIF는 표준 형식입니다컴퓨터와 다른 장치 사이에 JPEG 압축 이미지를 교환합니다.또는 이 속성을 설정하면 JFIF 데이터와 상호 작용할 수 있습니다.예를 들어 이미지의 해상도, 측면 비율 및 미묘함과 같은 정보.

public JFIFData Jfif { get; set; }

부동산 가치

JFIFData

JpegOptions

JPEG 옵션을 만들거나 업로드하는 동안 사용하는 액세스를 얻으십시오.Aspose.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

CMYK 및 YCCK JPEG 이미지의 RGB 색상 프로파일은 정확한 색상을 보장합니다.변환 및 대표.그것은 CMYKColorProfile와 조화되어야합니다색상에서 일관성과 충성도를 유지합니다.이 커플링은 필수적입니다.정확한 색상 관리 및 이미지 재생을 요구하는 응용 프로그램,RGB 데이터가 적절하게 해석되고 표시되는 것을 보장합니다.

public StreamSource RgbColorProfile { get; set; }

부동산 가치

StreamSource

Examples

다음 예제는 사용자 지정 ICC 프로필을 사용하여 PNG를 충전하고 CMYK JPEG로 저장합니다. 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

이 속성은 인치 당 픽셀로 표현된 수직 해상도를 관리합니다.관련 Aspose.Imaging.RasterImage.이 해상도를 조정하면그림의 크기와 품질은 고정된 물리적 크기로 인쇄되거나 표시됩니다.이 속성을 설정함으로써 이미지의 픽셀이 얼마나 밀접하게 포장되는지를 제어합니다.수직적으로, 그것의 전체 뚜렷성과 명확성에 영향을 미칩니다.

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

이 속성은 픽셀로 표현된 이미지의 폭을 얻습니다.이미지의 차원에 대한 필수 정보, 정확한 렌더링을 가능하게,조작 또는 이미지 데이터를 표시합니다.

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’의 ‘Orientation’ 값은 허용 범위 [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.xmpdata 및 VL16 .Exif.IhasExivDat.ExIFDate 값을 설정합니다. 0 0 0 0.

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()
 한국어