Class BmpImage

Class BmpImage

ชื่อพื้นที่: Aspose.Imaging.FileFormats.Bmp การประกอบ: Aspose.Imaging.dll (25.4.0)

คุณสามารถจัดการ Bitmap (BMP) และ Device Independent Bitmap ได้อย่างรวดเร็ว(DIB) ไฟล์ที่ช่วยให้การจัดการและการประมวลผลอย่างมีประสิทธิภาพภาพ. การดําเนินการต่างๆบนภาพ API นี้จะปรับปรุงการทํางานกระแสทํางานให้ผู้พัฒนาชุดเครื่องมือที่เชื่อถือได้สําหรับการทํางานกับ BMP และรูปแบบ DIB ในแอพซอฟต์แวร์ของพวกเขา

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

Inheritance

object DisposableObject DataStreamSupporter Image RasterImage RasterCachedImage BmpImage

Implements

IDisposable , IObjectWithBounds , IRasterImageArgb32PixelLoader , IRasterImageRawDataLoader , IHasXmpData , IHasMetadata

อนุญาโตตุลาการ

RasterCachedImage.CacheData() , RasterCachedImage.Blend(Point, RasterImage, Rectangle, byte) , RasterCachedImage.Resize(int, int, ResizeType) , RasterCachedImage.Resize(int, int, ImageResizeSettings) , RasterCachedImage.RotateFlip(RotateFlipType) , RasterCachedImage.Rotate(float, bool, Color) , RasterCachedImage.Crop(Rectangle) , RasterCachedImage.Dither(DitheringMethod, int, IColorPalette) , RasterCachedImage.Grayscale() , RasterCachedImage.NormalizeHistogram() , RasterCachedImage.BinarizeFixed(byte) , RasterCachedImage.BinarizeOtsu() , RasterCachedImage.BinarizeBradley(double, int) , RasterCachedImage.BinarizeBradley(double) , RasterCachedImage.AdjustBrightness(int) , RasterCachedImage.AdjustContrast(float) , RasterCachedImage.AdjustGamma(float, float, float) , RasterCachedImage.AdjustGamma(float) , RasterCachedImage.IsCached , RasterImage.RemoveMetadata() , RasterImage.Save(Stream, ImageOptionsBase, Rectangle) , RasterImage.GetModifyDate(bool) , RasterImage.Dither(DitheringMethod, int) , RasterImage.Dither(DitheringMethod, int, IColorPalette) , RasterImage.GetDefaultPixels(Rectangle, IPartialArgb32PixelLoader) , RasterImage.GetDefaultRawData(Rectangle, IPartialRawDataLoader, RawDataSettings) , RasterImage.GetDefaultArgb32Pixels(Rectangle) , RasterImage.GetDefaultRawData(Rectangle, RawDataSettings) , RasterImage.GetArgb32Pixel(int, int) , RasterImage.GetPixel(int, int) , RasterImage.SetArgb32Pixel(int, int, int) , RasterImage.SetPixel(int, int, Color) , RasterImage.ReadScanLine(int) , RasterImage.ReadArgb32ScanLine(int) , RasterImage.WriteScanLine(int, Color[]) , RasterImage.WriteArgb32ScanLine(int, int[]) , RasterImage.LoadPartialArgb32Pixels(Rectangle, IPartialArgb32PixelLoader) , RasterImage.LoadPartialPixels(Rectangle, IPartialPixelLoader) , RasterImage.LoadArgb32Pixels(Rectangle) , RasterImage.LoadArgb64Pixels(Rectangle) , RasterImage.LoadPartialArgb64Pixels(Rectangle, IPartialArgb64PixelLoader) , RasterImage.LoadPixels(Rectangle) , RasterImage.LoadCmykPixels(Rectangle) , RasterImage.LoadCmyk32Pixels(Rectangle) , RasterImage.LoadRawData(Rectangle, RawDataSettings, IPartialRawDataLoader) , RasterImage.LoadRawData(Rectangle, Rectangle, RawDataSettings, IPartialRawDataLoader) , RasterImage.SaveRawData(byte[], int, Rectangle, RawDataSettings) , RasterImage.SaveArgb32Pixels(Rectangle, int[]) , RasterImage.SavePixels(Rectangle, Color[]) , RasterImage.SaveCmykPixels(Rectangle, CmykColor[]) , RasterImage.SaveCmyk32Pixels(Rectangle, int[]) , RasterImage.SetResolution(double, double) , RasterImage.SetPalette(IColorPalette, bool) , RasterImage.Resize(int, int, ImageResizeSettings) , RasterImage.Rotate(float, bool, Color) , RasterImage.Rotate(float) , RasterImage.BinarizeFixed(byte) , RasterImage.BinarizeOtsu() , RasterImage.BinarizeBradley(double) , RasterImage.BinarizeBradley(double, int) , RasterImage.Blend(Point, RasterImage, Rectangle, byte) , RasterImage.Blend(Point, RasterImage, byte) , RasterImage.Grayscale() , RasterImage.NormalizeHistogram() , RasterImage.AdjustBrightness(int) , RasterImage.AdjustContrast(float) , RasterImage.AdjustGamma(float, float, float) , RasterImage.AdjustGamma(float) , RasterImage.GetSkewAngle() , RasterImage.NormalizeAngle() , RasterImage.NormalizeAngle(bool, Color) , RasterImage.Filter(Rectangle, FilterOptionsBase) , RasterImage.ReplaceColor(Color, byte, Color) , RasterImage.ReplaceColor(int, byte, int) , RasterImage.ReplaceNonTransparentColors(Color) , RasterImage.ReplaceNonTransparentColors(int) , RasterImage.ToBitmap() , RasterImage.PremultiplyComponents , RasterImage.UseRawData , RasterImage.UpdateXmpData , RasterImage.XmpData , RasterImage.RawIndexedColorConverter , RasterImage.RawCustomColorConverter , RasterImage.RawFallbackIndex , RasterImage.RawDataSettings , RasterImage.UsePalette , RasterImage.RawDataFormat , RasterImage.RawLineSize , RasterImage.IsRawDataAvailable , RasterImage.HorizontalResolution , RasterImage.VerticalResolution , RasterImage.HasTransparentColor , RasterImage.HasAlpha , RasterImage.TransparentColor , RasterImage.ImageOpacity , Image.CanLoad(string) , Image.CanLoad(string, LoadOptions) , Image.CanLoad(Stream) , Image.CanLoad(Stream, LoadOptions) , Image.Create(ImageOptionsBase, int, int) , Image.Create(Image[]) , Image.Create(MultipageCreateOptions) , Image.Create(string[], bool) , Image.Create(string[]) , Image.Create(Image[], bool) , Image.GetFileFormat(string) , Image.GetFileFormat(Stream) , Image.GetFittingRectangle(Rectangle, int, int) , Image.GetFittingRectangle(Rectangle, int[], int, int) , Image.Load(string, LoadOptions) , Image.Load(string) , Image.Load(Stream, LoadOptions) , Image.Load(Stream) , Image.GetProportionalWidth(int, int, int) , Image.GetProportionalHeight(int, int, int) , Image.RemoveMetadata() , Image.CanSave(ImageOptionsBase) , Image.Resize(int, int) , Image.Resize(int, int, ResizeType) , Image.Resize(int, int, ImageResizeSettings) , Image.GetDefaultOptions(object[]) , Image.GetOriginalOptions() , Image.ResizeWidthProportionally(int) , Image.ResizeHeightProportionally(int) , Image.ResizeWidthProportionally(int, ResizeType) , Image.ResizeHeightProportionally(int, ResizeType) , Image.ResizeWidthProportionally(int, ImageResizeSettings) , Image.ResizeHeightProportionally(int, ImageResizeSettings) , Image.RotateFlip(RotateFlipType) , Image.Rotate(float) , Image.Crop(Rectangle) , Image.Crop(int, int, int, int) , Image.Save() , Image.Save(string) , Image.Save(string, ImageOptionsBase) , Image.Save(string, ImageOptionsBase, Rectangle) , Image.Save(Stream, ImageOptionsBase) , Image.Save(Stream, ImageOptionsBase, Rectangle) , Image.GetSerializedStream(ImageOptionsBase, Rectangle, out int) , Image.SetPalette(IColorPalette, bool) , Image.BitsPerPixel , Image.Bounds , Image.Container , Image.Height , Image.Palette , Image.UsePalette , Image.Size , Image.Width , Image.InterruptMonitor , Image.BufferSizeHint , Image.AutoAdjustPalette , Image.HasBackgroundColor , Image.FileFormat , Image.BackgroundColor , DataStreamSupporter.CacheData() , DataStreamSupporter.Save() , DataStreamSupporter.Save(Stream) , DataStreamSupporter.Save(string) , DataStreamSupporter.Save(string, bool) , DataStreamSupporter.DataStreamContainer , DataStreamSupporter.IsCached , DisposableObject.Dispose() , DisposableObject.Disposed , object.GetType() , object.ToString() , object.Equals(object?) , object.Equals(object?, object?) , object.ReferenceEquals(object?, object?) , object.GetHashCode()

Examples

การบีบอัดภาพ BMP ที่ถูกบีบอัดก่อนหน้านี้โดยใช้ algorithm การบีบอัด DXT1

using (var image = Image.Load("CompressedTiger.bmp"))
                                                                                                 {
                                                                                                     image.Save("DecompressedTiger.bmp", new BmpOptions());
                                                                                                 }

การบีบอัดภาพ BMP โดยใช้แอลกอฮอร์โมนการบีบอัด DXT1

using (var image = Image.Load("Tiger.bmp"))
                                                               {
                                                                   image.Save("CompressedTiger.bmp", new BmpOptions { Compression = BitmapCompression.Dxt1 });
                                                               }

ตัวอย่างนี้แสดงให้เห็นวิธีการลบวัตถุใด ๆ จากภาพโดยใช้ Graphics Path ด้วยอัลกอริทึม Telea

var imageFilePath = "ball.png"; 
                                                                                                              using (var image = Image.Load(imageFilePath))
                                                                                                              {
                                                                                                                  var pngImage = (PngImage)image;

                                                                                                                  var mask = new GraphicsPath();
                                                                                                                  var firstFigure = new Figure();
                                                                                                                  firstFigure.AddShape(new EllipseShape(new RectangleF(350, 170, 570 - 350, 400 - 170)));
                                                                                                                  mask.AddFigure(firstFigure);

                                                                                                                  var options = new TeleaWatermarkOptions(mask);

                                                                                                                  var result = WatermarkRemover.PaintOver(pngImage, options);

                                                                                                                  result.Save(outputPath);
                                                                                                              }

ตัวอย่างแสดงให้เห็นว่าวิธีการส่งออก BmpImage กับประเภทการบีบอัด Rgb

string sourcePath = "input.png";
                                                                                    // Load a PNG image from a file.
                                                                                    using (Image pngImage = Image.Load(sourcePath))
                                                                                    {
                                                                                        // BMP image is saved with transparency support by default, that is achieved by using the BitmapCompression.Bitfields compression method. 
                                                                                        // To save a BMP image with the Rgb compression method, the BmpOptions with the Compression property set to BitmapCompression.Rgb should be specified.
                                                                                        pngImage.Save(outputPath, new BmpOptions() { Compression = BitmapCompression.Rgb });
                                                                                    }

ตัวอย่างนี้แสดงให้เห็นวิธีการลบวัตถุใด ๆ จากภาพโดยใช้ Graphics Path ด้วย Algorithm Fill Content Aware

var imageFilePath = "ball.png"; 
                                                                                                                           using (var image = Image.Load(imageFilePath))
                                                                                                                           {
                                                                                                                               var pngImage = (PngImage)image;

                                                                                                                               var mask = new GraphicsPath();
                                                                                                                               var firstFigure = new Figure();
                                                                                                                               firstFigure.AddShape(new EllipseShape(new RectangleF(350, 170, 570 - 350, 400 - 170)));
                                                                                                                               mask.AddFigure(firstFigure);

                                                                                                                               var options = new ContentAwareFillWatermarkOptions(mask) 
                                                                                                                               { 
                                                                                                                                   MaxPaintingAttempts = 4
                                                                                                                               };

                                                                                                                               var result = WatermarkRemover.PaintOver(pngImage, options);

                                                                                                                               result.Save(outputPath);
                                                                                                                           }

ตัวอย่างต่อไปนี้แสดงให้เห็นวิธีการสร้างภาพ BMP ของขนาดที่ระบุ

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

                                                                                       // Create a BMP image 100 x 100 px.
                                                                                       using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100))
                                                                                       {
                                                                                           // Fill the image with a simple linear red-black gradient.
                                                                                           int width = bmpImage.Width;
                                                                                           int height = bmpImage.Height;
                                                                                           for (int y = 0; y < height; y++)
                                                                                           {
                                                                                               for (int x = 0; x < width; x++)
                                                                                               {
                                                                                                   int hue = (255 * x) / width;
                                                                                                   bmpImage.SetPixel(x, y, Aspose.Imaging.Color.FromArgb(255, hue, 0, 0));
                                                                                               }
                                                                                           }

                                                                                           using (System.IO.FileStream stream = new System.IO.FileStream(dir + "output.bmp", System.IO.FileMode.Create))
                                                                                           {
                                                                                               bmpImage.Save(stream);
                                                                                           }
                                                                                       }

ตัวอย่างนี้แสดงให้เห็นวิธีการส่งออกไฟล์ BmpImage จากไฟล์ Png ในขณะที่เก็บช่อง alpha และบันทึกไฟล์ Bmp ด้วยความโปร่งใส

string sourcePath = "input.png";
                                                                                                                                         // Load a PNG image from a file.
                                                                                                                                         using (Image pngImage = Image.Load(sourcePath))
                                                                                                                                         {
                                                                                                                                             // BMP image is saved with transparency support by default. 
                                                                                                                                             // If you want to explicitly specify such mode, the BmpOptions's Compression property should be set to BitmapCompression.Bitfields.
                                                                                                                                             // The BitmapCompression.Bitfields compression method is the default compression method in the BmpOptions.
                                                                                                                                             // So the same result of exporting a Bmp image with transparency can be achieved by either one of the following ways.
                                                                                                                                             // With an implicit default options:
                                                                                                                                             pngImage.Save(outputPath);
                                                                                                                                             // With an explicit default options:
                                                                                                                                             pngImage.Save(outputPath, new BmpOptions());
                                                                                                                                             // Specifying the BitmapCompression.Bitfields compression method:
                                                                                                                                             pngImage.Save(outputPath, new BmpOptions() { Compression = BitmapCompression.Bitfields });
                                                                                                                                         }

Constructors

BmpImage(รั้ว)

เริ่มต้นใช้คลาส BmpImage โดยไม่มีความพยายามกับเครื่องสร้างนี้ที่เริ่มต้นตัวอย่างใหม่ เหมาะสําหรับนักพัฒนาที่ต้องการเพิ่มขึ้นและการทํางานกับ Aspose.Imaging.FileFormats.Bmp.BmpImage วัตถุได้อย่างรวดเร็วและมีประสิทธิภาพ

public BmpImage(string path)

Parameters

path string

เส้นทางในการโหลดภาพจากและเริ่มต้นข้อมูล pixel และ palette กับ

Examples

ตัวอย่างนี้แสดงให้เห็นวิธีการโหลด BmpImage จากไฟล์

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

                                                                // Load a BMP image from a file.
                                                                // The source pixels will be converted to 32-bpp format if required.
                                                                using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(dir + "sample.bmp"))
                                                                {
                                                                    // Do some image processing.
                                                                    // Save to another BMP file.
                                                                    bmpImage.Save(dir + "sample.output.32bpp.bmp");
                                                                }

Exceptions

ArgumentNullException

รูปภาพของ Raster เป็น null

BmpImageException

ความสูงควรจะเป็นเชิงบวก

ArgumentException

แพลตฟอร์มจะต้องระบุสําหรับภาพที่มี 8 บิตต่อพิกเซลหรือน้อยกว่า

BmpImage(string, ushort, BitmapCompression, คู่, คู่)

สร้างตัวอย่างใหม่ของคลาส Aspose.Imaging.FileFormats.Bmp.BmpImage ด้วยผู้สร้างนี้ใช้พารามิเตอร์ที่ระบุเช่นเส้นทาง bitsPerPixel และบีบอัด เหมาะสําหรับนักพัฒนากําลังมองหาการเริ่มต้นวัตถุ BmpImage ได้อย่างรวดเร็วและมีประสิทธิภาพด้วยการควบคุมที่แม่นยําเกี่ยวกับลักษณะของภาพ

public BmpImage(string path, ushort bitsPerPixel, BitmapCompression compression, double horizontalResolution, double verticalResolution)

Parameters

path string

เส้นทางในการโหลดภาพจากและเริ่มต้นข้อมูล pixel และ palette กับ

bitsPerPixel ushort

บิตต่อพิกเซล

compression BitmapCompression

การบีบอัดที่จะใช้

horizontalResolution double

โซลูชั่นแนวนอน หมายเหตุ เนื่องจากการหมุน โซลูชั่นที่เกิดขึ้นอาจแตกต่างกันเล็กน้อยจากที่ผ่านไป

verticalResolution double

ความละเอียดแนวตั้ง หมายเหตุ เนื่องจากการหมุนความละเอียดที่เกิดขึ้นอาจแตกต่างกันเล็กน้อยจากที่ผ่านไป

Examples

ตัวอย่างนี้แสดงให้เห็นวิธีการโหลด BmpImage จากไฟล์ที่มีความลึกและความละเอียดบิตที่ระบุ

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

                                                                                                            // Load a BMP image from a file.
                                                                                                            // The source pixels will be converted to 24-bpp format if required.
                                                                                                            // The resolution will be set to 96 dpi.
                                                                                                            using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage =
                                                                                                                new Aspose.Imaging.FileFormats.Bmp.BmpImage(dir + "sample.bmp", 24, Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb, 96.0, 96.0))
                                                                                                            {
                                                                                                                // Do some image processing.
                                                                                                                // Save to another BMP file.
                                                                                                                bmpImage.Save(dir + "sample.output.24bpp.96dpi.bmp");
                                                                                                            }

Exceptions

ArgumentNullException

รูปภาพของ Raster เป็น null

BmpImageException

ความสูงควรจะเป็นเชิงบวก

ArgumentException

แพลตฟอร์มจะต้องระบุสําหรับภาพที่มี 8 บิตต่อพิกเซลหรือน้อยกว่า

BmpImage(Stream)

เริ่มต้นใช้คลาส Aspose.Imaging.FileFormats.Bmp.BmpImage โดยเริ่มต้นตัวอย่างใหม่ด้วยเครื่องก่อสร้างนี้ใช้การไหลเป็น input เหมาะสําหรับนักพัฒนาที่กําลังมองหาวิธีที่สะดวกในการทํางานกับวัตถุ BmpImage จากแหล่งข้อมูลต่างๆให้ความยืดหยุ่นและความสะดวกในการรวมกัน

public BmpImage(Stream stream)

Parameters

stream Stream

กระแสที่จะโหลดภาพจากและเริ่มต้นข้อมูลพิกเซลและแพลตกับ

Examples

ตัวอย่างนี้แสดงให้เห็นวิธีการโหลด BmpImage จากการไหลของไฟล์

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

                                                                       // Load a BMP image from a file stream.
                                                                       // The source pixels will be converted to 32-bpp format if required.
                                                                       using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.bmp"))
                                                                       {
                                                                           using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(stream))
                                                                           {
                                                                               // Do some image processing.
                                                                               // Save to another BMP file.
                                                                               bmpImage.Save(dir + "sample.output.32bpp.bmp");
                                                                           }
                                                                       }

Exceptions

ArgumentNullException

รูปภาพของ Raster เป็น null

BmpImageException

ความสูงควรจะเป็นเชิงบวก

ArgumentException

แพลตฟอร์มจะต้องระบุสําหรับภาพที่มี 8 บิตต่อพิกเซลหรือน้อยกว่า

BmpImage(Stream, ushort, BitmapCompression, คู่, คู่)

เริ่มต้นทํางานกับ Aspose.Imaging.FileFormats.Bmp.BmpImage class โดยการสร้างตัวอย่างใหม่ที่ใช้กระแสพร้อมกับพารามิเตอร์ที่ระบุเช่น bitsPerPixelและบีบอัด เหมาะสําหรับนักพัฒนาที่กําลังมองหาวิธีที่เรียบง่ายในการจัดการBmpImage วัตถุเพื่อให้แน่ใจว่ามีความยืดหยุ่นและมีประสิทธิภาพในโครงการของพวกเขา

public BmpImage(Stream stream, ushort bitsPerPixel, BitmapCompression compression, double horizontalResolution, double verticalResolution)

Parameters

stream Stream

กระแสที่จะโหลดภาพจากและเริ่มต้นข้อมูลพิกเซลและแพลตกับ

bitsPerPixel ushort

บิตต่อพิกเซล

compression BitmapCompression

การบีบอัดที่จะใช้

horizontalResolution double

โซลูชั่นแนวนอน หมายเหตุ เนื่องจากการหมุน โซลูชั่นที่เกิดขึ้นอาจแตกต่างกันเล็กน้อยจากที่ผ่านไป

verticalResolution double

ความละเอียดแนวตั้ง หมายเหตุ เนื่องจากการหมุนความละเอียดที่เกิดขึ้นอาจแตกต่างกันเล็กน้อยจากที่ผ่านไป

Examples

ตัวอย่างนี้แสดงให้เห็นวิธีการโหลด BmpImage จากการไหลของไฟล์ที่มีความลึกและความละเอียดบิตที่ระบุ

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

                                                                                                                   // Load a BMP image from a file stream.
                                                                                                                   // The source pixels will be converted to 24-bpp format if required.
                                                                                                                   // The resolution will be set to 96 dpi.
                                                                                                                   using (System.IO.Stream stream = System.IO.File.OpenRead(dir + "sample.bmp"))
                                                                                                                   {
                                                                                                                       using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage =
                                                                                                                           new Aspose.Imaging.FileFormats.Bmp.BmpImage(stream, 24, Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb, 96.0, 96.0))
                                                                                                                       {
                                                                                                                           // Do some image processing.
                                                                                                                           // Save to another BMP file.
                                                                                                                           bmpImage.Save(dir + "sample.output.24bpp.96dpi.bmp");
                                                                                                                       }
                                                                                                                   }

Exceptions

ArgumentNullException

รูปภาพของ Raster เป็น null

BmpImageException

ความสูงควรจะเป็นเชิงบวก

ArgumentException

แพลตฟอร์มจะต้องระบุสําหรับภาพที่มี 8 บิตต่อพิกเซลหรือน้อยกว่า

BmpImage(RasterImage)

สร้างตัวอย่างใหม่ของ Aspose.Imaging.FileFormats.Bmp.BmpImage classโดยเริ่มต้นด้วยวัตถุ RasterImage เหมาะสําหรับนักพัฒนาที่กําลังมองหาเพื่อแปลงภาพเรสเตอร์ที่มีอยู่เป็นรูปแบบ BmpImage เพื่อให้แน่ใจว่าความสอดคล้องและความสะดวกในการรวมเข้ากับโครงการของพวกเขา

public BmpImage(RasterImage rasterImage)

Parameters

rasterImage RasterImage

รูปภาพเพื่อเริ่มต้นข้อมูล pixel และ palette กับ.

Examples

ตัวอย่างนี้แสดงให้เห็นวิธีการโหลด BmpImage จากตัวอย่างอื่นของ RasterImage

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

                                                                                         // Create a new PNG image.
                                                                                         Aspose.Imaging.ImageOptions.PngOptions createOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                         createOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream(), true);
                                                                                         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 gr = new Aspose.Imaging.Graphics(rasterImage);
                                                                                             Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                             gr.FillRectangle(brush, rasterImage.Bounds);

                                                                                             // Create a BMP image based on the PNG image.
                                                                                             // The source pixels will be converted to 32-bpp format if required.
                                                                                             using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(rasterImage))
                                                                                             {
                                                                                                 // Save to a BMP file
                                                                                                 bmpImage.Save(dir + "output.32bpp.bmp");
                                                                                             }
                                                                                         }

Exceptions

ArgumentNullException

รูปภาพของ Raster เป็น null

BmpImageException

ความสูงควรจะเป็นเชิงบวก

ArgumentException

แพลตฟอร์มจะต้องระบุสําหรับภาพที่มี 8 บิตต่อพิกเซลหรือน้อยกว่า

BmpImage(RasterImage, ushort, BitmapCompression, คู่, คู่)

เริ่มต้นทํางานกับ Aspose.Imaging.FileFormats.Bmp.BmpImage class โดยการสร้างตัวอย่างใหม่ใช้ RasterImage พร้อมกับพารามิเตอร์ที่ระบุเช่น bitsPerPixel และบีบอัดเหมาะสําหรับนักพัฒนาที่กําลังมองหาวิธีที่เรียบง่ายในการจัดการกับวัตถุ BmpImageให้ความยืดหยุ่นและมีประสิทธิภาพในโครงการของพวกเขา

public BmpImage(RasterImage rasterImage, ushort bitsPerPixel, BitmapCompression compression, double horizontalResolution, double verticalResolution)

Parameters

rasterImage RasterImage

รูปภาพเพื่อเริ่มต้นข้อมูล pixel และ palette กับ.

bitsPerPixel ushort

บิตต่อพิกเซล

compression BitmapCompression

การบีบอัดที่จะใช้

horizontalResolution double

โซลูชั่นแนวนอน หมายเหตุ เนื่องจากการหมุน โซลูชั่นที่เกิดขึ้นอาจแตกต่างกันเล็กน้อยจากที่ผ่านไป

verticalResolution double

ความละเอียดแนวตั้ง หมายเหตุ เนื่องจากการหมุนความละเอียดที่เกิดขึ้นอาจแตกต่างกันเล็กน้อยจากที่ผ่านไป

Examples

ตัวอย่างนี้แสดงให้เห็นวิธีการโหลด BmpImage จากตัวอย่างอื่นของ RasterImage ด้วยความลึกและความบีบอัดที่ระบุ

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

                                                                                                                                      // Create a new PNG image.
                                                                                                                                      Aspose.Imaging.ImageOptions.PngOptions createOptions = new Aspose.Imaging.ImageOptions.PngOptions();
                                                                                                                                      createOptions.Source = new Aspose.Imaging.Sources.StreamSource(new System.IO.MemoryStream(), true);
                                                                                                                                      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 gr = new Aspose.Imaging.Graphics(rasterImage);
                                                                                                                                          Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                                                                          gr.FillRectangle(brush, rasterImage.Bounds);

                                                                                                                                          // Create a BMP image based on the PNG image.
                                                                                                                                          // The source pixels will be converted to 24-bpp format if required.
                                                                                                                                          // The resolution will be set to 96 dpi.
                                                                                                                                          using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(rasterImage, 24, Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb, 96.0, 96.0))
                                                                                                                                          {
                                                                                                                                              // Save to a BMP file
                                                                                                                                              bmpImage.Save(dir + "output.24bpp.96dpi.bmp");
                                                                                                                                          }
                                                                                                                                      }

Exceptions

ArgumentNullException

รูปภาพของ Raster เป็น null

BmpImageException

ความสูงควรจะเป็นเชิงบวก

ArgumentException

แพลตฟอร์มจะต้องระบุสําหรับภาพที่มี 8 บิตต่อพิกเซลหรือน้อยกว่า

BmpImage(int, int)

เริ่มต้นใช้คลาส Aspose.Imaging.FileFormats.Bmp.BmpImage โดยการสร้างตัวอย่างใหม่ด้วยพารามิเตอร์ความกว้างและความสูงที่ระบุ เหมาะสําหรับนักพัฒนาที่ต้องการวิธีที่สะดวกในการสร้างวัตถุ BmpImage ขนาดที่กําหนดเองเพื่อให้แน่ใจว่าความยืดหยุ่นและความสะดวกในการรวมเข้ากับโครงการของพวกเขา

public BmpImage(int width, int height)

Parameters

width int

ความกว้างของภาพ

height int

ความสูงของภาพ

Examples

ตัวอย่างแสดงให้เห็นวิธีการสร้าง BmpImage ขนาดที่ระบุ

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

                                                                            // Create a 32-bpp BMP image of 100 x 100 px.
                                                                            using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100))
                                                                            {
                                                                                // Fill the entire image in red.
                                                                                Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);
                                                                                Aspose.Imaging.Brushes.SolidBrush brush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                gr.FillRectangle(brush, bmpImage.Bounds);

                                                                                // Save to a BMP file
                                                                                bmpImage.Save(dir + "output.bmp");
                                                                            }

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าวิธีการ palletize ภาพ BMP เพื่อลดขนาดการผลิต

// Create a BMP image 100 x 100 px.
                                                                                              using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100))
                                                                                              {
                                                                                                  // The linear gradient from the left-top to the right-bottom corner of the image.
                                                                                                  Aspose.Imaging.Brushes.LinearGradientBrush brush =
                                                                                                      new Aspose.Imaging.Brushes.LinearGradientBrush(
                                                                                                          new Aspose.Imaging.Point(0, 0),
                                                                                                          new Aspose.Imaging.Point(bmpImage.Width, bmpImage.Height),
                                                                                                          Aspose.Imaging.Color.Red,
                                                                                                          Aspose.Imaging.Color.Green);

                                                                                                  // Fill the entire image with the linear gradient brush.
                                                                                                  Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);
                                                                                                  gr.FillRectangle(brush, bmpImage.Bounds);

                                                                                                  // Get the closest 8-bit color palette which covers as many pixels as possible, so that a palettized image
                                                                                                  // is almost visually indistinguishable from a non-palletized one.
                                                                                                  Aspose.Imaging.IColorPalette palette = Aspose.Imaging.ColorPaletteHelper.GetCloseImagePalette(bmpImage, 256);

                                                                                                  // 8-bit palette contains at most 256 colors.
                                                                                                  Aspose.Imaging.ImageOptions.BmpOptions saveOptions = new Aspose.Imaging.ImageOptions.BmpOptions();
                                                                                                  saveOptions.Palette = palette;
                                                                                                  saveOptions.BitsPerPixel = 8;

                                                                                                  using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                  {
                                                                                                      bmpImage.Save(stream, saveOptions);
                                                                                                      System.Console.WriteLine("The palettized image size is {0} bytes.", stream.Length);
                                                                                                  }

                                                                                                  using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                  {
                                                                                                      bmpImage.Save(stream);
                                                                                                      System.Console.WriteLine("The non-palettized image size is {0} bytes.", stream.Length);
                                                                                                  }
                                                                                              }

                                                                                              // The output looks like this:
                                                                                              // The palettized image size is 11078 bytes.
                                                                                              // The non-palettized image size is 40054 bytes.

Exceptions

BmpImageException

ความสูงควรจะเป็นเชิงบวก

ArgumentException

แพลตฟอร์มจะต้องระบุสําหรับภาพที่มี 8 บิตต่อพิกเซลหรือน้อยกว่า

BmpImage(int, int, ushort, IColorPalette)

เริ่มต้นใช้คลาส Aspose.Imaging.FileFormats.Bmp.BmpImage โดยเริ่มต้นตัวอย่างใหม่ด้วยพารามิเตอร์เช่นความกว้างความสูงความลึกและแพลตฟอร์ม เหมาะสําหรับผู้พัฒนาที่กําลังมองหาวิธีที่เรียบง่ายในการสร้างวัตถุ BmpImage กับขนาดที่กําหนดเองและการกําหนดค่าสีเพื่อให้แน่ใจว่ามีความยืดหยุ่นและมีประสิทธิภาพในโครงการของพวกเขา

public BmpImage(int width, int height, ushort bitsPerPixel, IColorPalette palette)

Parameters

width int

ความกว้างของภาพ

height int

ความสูงของภาพ

bitsPerPixel ushort

บิตต่อพิกเซล

palette IColorPalette

แผ่นสี

Examples

ตัวอย่างแสดงให้เห็นวิธีการสร้าง BmpImage ขนาดที่ระบุด้วยแพลตฟอร์มที่ระบุ

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

                                                                                                       Aspose.Imaging.Color[] paletterColors = new Aspose.Imaging.Color[]
                                                                                                       {
                                                                                                           Aspose.Imaging.Color.Red,
                                                                                                           Aspose.Imaging.Color.Green,
                                                                                                       };

                                                                                                       // Create a monochrome palette which contains only red and green colors.
                                                                                                       Aspose.Imaging.IColorPalette palette = new Aspose.Imaging.ColorPalette(paletterColors);

                                                                                                       // Create a monochrome 1-bpp BMP image of 100 x 100 px.
                                                                                                       using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 1, palette))
                                                                                                       {
                                                                                                           Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);

                                                                                                           // Fill the upper half of the image in red.
                                                                                                           Aspose.Imaging.Brushes.SolidBrush redBrush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                                           gr.FillRectangle(redBrush, new Aspose.Imaging.Rectangle(0, 0, bmpImage.Width, bmpImage.Height / 2));

                                                                                                           // Fill the lower half of the image in green.
                                                                                                           Aspose.Imaging.Brushes.SolidBrush greenBrush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Green);
                                                                                                           gr.FillRectangle(greenBrush, new Aspose.Imaging.Rectangle(0, bmpImage.Height / 2, bmpImage.Width, bmpImage.Height / 2));

                                                                                                           // Save to BMP
                                                                                                           bmpImage.Save(dir + "output.monochrome.bmp");
                                                                                                       }

Exceptions

BmpImageException

ความสูงควรจะเป็นเชิงบวก

ArgumentException

แพลตฟอร์มจะต้องระบุสําหรับภาพที่มี 8 บิตต่อพิกเซลหรือน้อยกว่า

BmpImage(int, int, ushort, IColorPalette, BitmapCompression, คู่, คู่)

สร้างตัวอย่างใหม่ของคลาส Aspose.Imaging.FileFormats.Bmp.BmpImage ด้วยผู้สร้างนี้รายละเอียดพารามิเตอร์เช่นความกว้างความสูง bitsPerPixel และแพลตฟอร์ม เหมาะสําหรับนักพัฒนาค้นหาวิธีที่สะดวกในการสร้างวัตถุ BmpImage ที่มีขนาดที่กําหนดเองและการกําหนดค่าสีเพื่อให้แน่ใจว่ามีความยืดหยุ่นและง่ายต่อการรวมกันในโครงการของพวกเขา

public BmpImage(int width, int height, ushort bitsPerPixel, IColorPalette palette, BitmapCompression compression, double horizontalResolution, double verticalResolution)

Parameters

width int

ความกว้างของภาพ

height int

ความสูงของภาพ

bitsPerPixel ushort

บิตต่อพิกเซล

palette IColorPalette

แผ่นสี

compression BitmapCompression

การบีบอัดที่จะใช้

horizontalResolution double

โซลูชั่นแนวนอน หมายเหตุ เนื่องจากการหมุน โซลูชั่นที่เกิดขึ้นอาจแตกต่างกันเล็กน้อยจากที่ผ่านไป

verticalResolution double

ความละเอียดแนวตั้ง หมายเหตุ เนื่องจากการหมุนความละเอียดที่เกิดขึ้นอาจแตกต่างกันเล็กน้อยจากที่ผ่านไป

Examples

ตัวอย่างนี้แสดงให้เห็นวิธีการสร้าง BmpImage โดยใช้ตัวเลือกต่างๆ

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

                                                                            Aspose.Imaging.Color[] paletterColors = new Aspose.Imaging.Color[]
                                                                            {
                                                                                Aspose.Imaging.Color.Red,
                                                                                Aspose.Imaging.Color.Green,
                                                                            };

                                                                            // Create a monochrome palette which contains only red and green colors.
                                                                            Aspose.Imaging.IColorPalette palette = new Aspose.Imaging.ColorPalette(paletterColors);

                                                                            // Create a monochrome 1-bpp BMP image of 100 x 100 px.
                                                                            // The horizontal and vertical resolution will be set to 96 dpi.
                                                                            using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 1, palette, Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb, 96.0, 96.0))
                                                                            {
                                                                                Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);

                                                                                // Fill the upper half of the image in red.
                                                                                Aspose.Imaging.Brushes.SolidBrush redBrush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                gr.FillRectangle(redBrush, new Aspose.Imaging.Rectangle(0, 0, bmpImage.Width, bmpImage.Height / 2));

                                                                                // Fill the lower half of the image in green.
                                                                                Aspose.Imaging.Brushes.SolidBrush greenBrush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Green);
                                                                                gr.FillRectangle(greenBrush, new Aspose.Imaging.Rectangle(0, bmpImage.Height / 2, bmpImage.Width, bmpImage.Height / 2));

                                                                                // Save to a BMP file
                                                                                bmpImage.Save(dir + "output.monochrome.96dpi.bmp");
                                                                            }

Exceptions

BmpImageException

ความสูงควรจะเป็นเชิงบวก

ArgumentException

แพลตฟอร์มจะต้องระบุสําหรับภาพที่มี 8 บิตต่อพิกเซลหรือน้อยกว่า

Properties

BitmapInfoHeader

เข้าถึงรายละเอียดที่สําคัญเกี่ยวกับภาพ bitmap ของคุณได้อย่างรวดเร็วด้วยฟังก์ชั่นที่เรียบง่ายนี้เหมาะสําหรับนักพัฒนาที่จําเป็นต้องรับข้อมูลหัวสําหรับภาพของพวกเขา

public BitmapInfoHeader BitmapInfoHeader { get; }

คุณสมบัติมูลค่า

BitmapInfoHeader

Examples

ตัวอย่างต่อไปนี้จะได้รับข้อมูลจากหัว BMP และพิมพ์ไว้บนคอนโซล

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.bmp"))
                                                                                                       {
                                                                                                           Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;
                                                                                                           Aspose.Imaging.FileFormats.Bmp.BitmapInfoHeader header = bmpImage.BitmapInfoHeader;

                                                                                                           System.Console.WriteLine("The number of palette colors that are required for displaying the bitmap: {0}", header.BitmapColorsImportant);
                                                                                                           System.Console.WriteLine("The number of palette colors used in the bitmap: {0}", header.BitmapColorsUsed);
                                                                                                           System.Console.WriteLine("The bitmap compression: {0}", header.BitmapCompression);
                                                                                                           System.Console.WriteLine("The bitmap height: {0}", header.BitmapHeight);
                                                                                                           System.Console.WriteLine("The bitmap width: {0}", header.BitmapWidth);
                                                                                                           System.Console.WriteLine("The bitmap raw data size in bytes: {0}", header.BitmapImageSize);
                                                                                                           System.Console.WriteLine("The number of planes: {0}", header.BitmapPlanes);
                                                                                                           System.Console.WriteLine("The horizontal resolution of the bitmap, in pixels-per-meter: {0}", header.BitmapXPelsPerMeter);
                                                                                                           System.Console.WriteLine("The vertical resolution of the bitmap, in pixels-per-meter: {0}", header.BitmapYPelsPerMeter);
                                                                                                           System.Console.WriteLine("The number of bits per pixel: {0}", header.BitsPerPixel);
                                                                                                           System.Console.WriteLine("The extra bits masks: {0}", header.ExtraBitMasks);
                                                                                                           System.Console.WriteLine("The header size in bytes: {0}", header.HeaderSize);
                                                                                                       }

                                                                                                       //The output may look like this:
                                                                                                       //The number of palette colors that are required for displaying the bitmap: 0
                                                                                                       //The number of palette colors used in the bitmap: 0
                                                                                                       //The bitmap compression: 0
                                                                                                       //The bitmap height: 375
                                                                                                       //The bitmap width: 500
                                                                                                       //The bitmap raw data size in bytes: 562500
                                                                                                       //The number of planes: 1
                                                                                                       //The horizontal resolution of the bitmap, in pixels-per-meter: 0
                                                                                                       //The vertical resolution of the bitmap, in pixels-per-meter: 0
                                                                                                       //The number of bits per pixel: 24
                                                                                                       //The extra bits masks: 
                                                                                                       //The header size in bytes: 40

BitsPerPixel

เข้าถึงจํานวนบิตต่อพิกเซลสําหรับภาพได้อย่างง่ายดายโดยใช้คุณสมบัตินี้เหมาะสําหรับนักพัฒนาที่กําลังมองหาข้อมูลอย่างรวดเร็วเกี่ยวกับคุณภาพภาพและความลึก

public override int BitsPerPixel { get; }

คุณสมบัติมูลค่า

int

Examples

ตัวอย่างต่อไปนี้จะได้รับข้อมูลทั่วไปเกี่ยวกับภาพรวมถึงรูปแบบพิกเซลขนาดภาพความละเอียดการบีบอัด ฯลฯ

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.bmp"))
                                                                                                                                              {
                                                                                                                                                  Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;                

                                                                                                                                                  System.Console.WriteLine("The pixel format: {0}", bmpImage.RawDataFormat);                
                                                                                                                                                  System.Console.WriteLine("The raw line size in bytes: {0}", bmpImage.RawLineSize);
                                                                                                                                                  System.Console.WriteLine("The bitmap compression: {0}", bmpImage.Compression);
                                                                                                                                                  System.Console.WriteLine("The bitmap width: {0}", bmpImage.Width);
                                                                                                                                                  System.Console.WriteLine("The bitmap height: {0}", bmpImage.Height);
                                                                                                                                                  System.Console.WriteLine("The number of bits per pixel: {0}", bmpImage.BitsPerPixel);

                                                                                                                                                  double hres = bmpImage.HorizontalResolution;
                                                                                                                                                  double vres = bmpImage.VerticalResolution;
                                                                                                                                                  System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", hres);
                                                                                                                                                  System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", vres);

                                                                                                                                                  if (hres != 96.0 || vres != 96.0)
                                                                                                                                                  {
                                                                                                                                                      // You may consider using the SetResolution method for updating both resolution values in single call.
                                                                                                                                                      System.Console.WriteLine("Set resolution values to 96 dpi");
                                                                                                                                                      bmpImage.SetResolution(96.0, 96.0);

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

                                                                                                                                                  //The output may look like this:
                                                                                                                                                  //The pixel format: Rgb24Bpp, used channels: 8,8,8
                                                                                                                                                  //The raw line size in bytes: 1500
                                                                                                                                                  //The bitmap compression: Rgb
                                                                                                                                                  //The bitmap width: 500
                                                                                                                                                  //The bitmap height: 375
                                                                                                                                                  //The number of bits per pixel: 24
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 0
                                                                                                                                                  //The vertical resolution, in pixels per inch: 0
                                                                                                                                                  //Set resolution values to 96 dpi
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 96.012
                                                                                                                                                  //The vertical resolution, in pixels per inch: 96.012
                                                                                                                                              }

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าการบีบอัด bitmap จะส่งผลกระทบต่อขนาดภาพการส่งออก

Aspose.Imaging.FileFormats.Bmp.BitmapCompression[] compressions = new Aspose.Imaging.FileFormats.Bmp.BitmapCompression[]
                                                                                                {
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb,
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rle8,
                                                                                                };

                                                                                                Aspose.Imaging.Color[] paletterColors = new Aspose.Imaging.Color[]
                                                                                                {
                                                                                                    Aspose.Imaging.Color.Red,
                                                                                                    Aspose.Imaging.Color.Green,
                                                                                                };

                                                                                                // Create a monochrome palette which contains only red and green colors.
                                                                                                Aspose.Imaging.IColorPalette palette = new Aspose.Imaging.ColorPalette(paletterColors);

                                                                                                foreach (Aspose.Imaging.FileFormats.Bmp.BitmapCompression compression in compressions)
                                                                                                {
                                                                                                    // Create a 8-bpp BMP image of 100 x 100 px.
                                                                                                    using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 8, palette, compression, 0.0, 0.0))
                                                                                                    {
                                                                                                        Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);

                                                                                                        // Fill the entire image in red.
                                                                                                        Aspose.Imaging.Brushes.SolidBrush redBrush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                                        gr.FillRectangle(redBrush, bmpImage.Bounds);

                                                                                                        // Save the image to a stream to get the output image size.
                                                                                                        using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                        {
                                                                                                            bmpImage.Save(stream);

                                                                                                            System.Console.WriteLine("---------------------------------------------");
                                                                                                            System.Console.WriteLine("The compression={0}", bmpImage.Compression);
                                                                                                            System.Console.WriteLine("The number of bits per pixel={0}", bmpImage.BitsPerPixel);
                                                                                                            System.Console.WriteLine("The image dimensions={0} x {1}", bmpImage.Width, bmpImage.Height);
                                                                                                            System.Console.WriteLine("The raw line size={0}", bmpImage.RawLineSize);
                                                                                                            System.Console.WriteLine("The output size in bytes={0}", stream.Length);
                                                                                                        }
                                                                                                    }
                                                                                                }

                                                                                                // The output looks like this:
                                                                                                // ---------------------------------------------
                                                                                                // The compression = Rgb
                                                                                                // The number of bits per pixel = 8
                                                                                                // The image dimensions = 100 x 100
                                                                                                // The raw line size = 100
                                                                                                // The output size in bytes = 11078
                                                                                                // ---------------------------------------------
                                                                                                // The compression = Rle8
                                                                                                // The number of bits per pixel = 8
                                                                                                // The image dimensions = 100 x 100
                                                                                                // The raw line size = 100
                                                                                                // The output size in bytes = 856

Compression

รับประเภทการบีบอัดที่ใช้สําหรับภาพได้อย่างง่ายดายด้วยคุณสมบัตินี้เหมาะสําหรับนักพัฒนาที่ต้องเข้าถึงข้อมูลเกี่ยวกับการบีบอัดภาพได้อย่างรวดเร็ว

public BitmapCompression Compression { get; }

คุณสมบัติมูลค่า

BitmapCompression

Examples

ตัวอย่างต่อไปนี้จะได้รับข้อมูลทั่วไปเกี่ยวกับภาพรวมถึงรูปแบบพิกเซลขนาดภาพความละเอียดการบีบอัด ฯลฯ

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.bmp"))
                                                                                                                                              {
                                                                                                                                                  Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;                

                                                                                                                                                  System.Console.WriteLine("The pixel format: {0}", bmpImage.RawDataFormat);                
                                                                                                                                                  System.Console.WriteLine("The raw line size in bytes: {0}", bmpImage.RawLineSize);
                                                                                                                                                  System.Console.WriteLine("The bitmap compression: {0}", bmpImage.Compression);
                                                                                                                                                  System.Console.WriteLine("The bitmap width: {0}", bmpImage.Width);
                                                                                                                                                  System.Console.WriteLine("The bitmap height: {0}", bmpImage.Height);
                                                                                                                                                  System.Console.WriteLine("The number of bits per pixel: {0}", bmpImage.BitsPerPixel);

                                                                                                                                                  double hres = bmpImage.HorizontalResolution;
                                                                                                                                                  double vres = bmpImage.VerticalResolution;
                                                                                                                                                  System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", hres);
                                                                                                                                                  System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", vres);

                                                                                                                                                  if (hres != 96.0 || vres != 96.0)
                                                                                                                                                  {
                                                                                                                                                      // You may consider using the SetResolution method for updating both resolution values in single call.
                                                                                                                                                      System.Console.WriteLine("Set resolution values to 96 dpi");
                                                                                                                                                      bmpImage.SetResolution(96.0, 96.0);

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

                                                                                                                                                  //The output may look like this:
                                                                                                                                                  //The pixel format: Rgb24Bpp, used channels: 8,8,8
                                                                                                                                                  //The raw line size in bytes: 1500
                                                                                                                                                  //The bitmap compression: Rgb
                                                                                                                                                  //The bitmap width: 500
                                                                                                                                                  //The bitmap height: 375
                                                                                                                                                  //The number of bits per pixel: 24
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 0
                                                                                                                                                  //The vertical resolution, in pixels per inch: 0
                                                                                                                                                  //Set resolution values to 96 dpi
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 96.012
                                                                                                                                                  //The vertical resolution, in pixels per inch: 96.012
                                                                                                                                              }

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าการบีบอัด bitmap จะส่งผลกระทบต่อขนาดภาพการส่งออก

Aspose.Imaging.FileFormats.Bmp.BitmapCompression[] compressions = new Aspose.Imaging.FileFormats.Bmp.BitmapCompression[]
                                                                                                {
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb,
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rle8,
                                                                                                };

                                                                                                Aspose.Imaging.Color[] paletterColors = new Aspose.Imaging.Color[]
                                                                                                {
                                                                                                    Aspose.Imaging.Color.Red,
                                                                                                    Aspose.Imaging.Color.Green,
                                                                                                };

                                                                                                // Create a monochrome palette which contains only red and green colors.
                                                                                                Aspose.Imaging.IColorPalette palette = new Aspose.Imaging.ColorPalette(paletterColors);

                                                                                                foreach (Aspose.Imaging.FileFormats.Bmp.BitmapCompression compression in compressions)
                                                                                                {
                                                                                                    // Create a 8-bpp BMP image of 100 x 100 px.
                                                                                                    using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 8, palette, compression, 0.0, 0.0))
                                                                                                    {
                                                                                                        Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);

                                                                                                        // Fill the entire image in red.
                                                                                                        Aspose.Imaging.Brushes.SolidBrush redBrush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                                        gr.FillRectangle(redBrush, bmpImage.Bounds);

                                                                                                        // Save the image to a stream to get the output image size.
                                                                                                        using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                        {
                                                                                                            bmpImage.Save(stream);

                                                                                                            System.Console.WriteLine("---------------------------------------------");
                                                                                                            System.Console.WriteLine("The compression={0}", bmpImage.Compression);
                                                                                                            System.Console.WriteLine("The number of bits per pixel={0}", bmpImage.BitsPerPixel);
                                                                                                            System.Console.WriteLine("The image dimensions={0} x {1}", bmpImage.Width, bmpImage.Height);
                                                                                                            System.Console.WriteLine("The raw line size={0}", bmpImage.RawLineSize);
                                                                                                            System.Console.WriteLine("The output size in bytes={0}", stream.Length);
                                                                                                        }
                                                                                                    }
                                                                                                }

                                                                                                // The output looks like this:
                                                                                                // ---------------------------------------------
                                                                                                // The compression = Rgb
                                                                                                // The number of bits per pixel = 8
                                                                                                // The image dimensions = 100 x 100
                                                                                                // The raw line size = 100
                                                                                                // The output size in bytes = 11078
                                                                                                // ---------------------------------------------
                                                                                                // The compression = Rle8
                                                                                                // The number of bits per pixel = 8
                                                                                                // The image dimensions = 100 x 100
                                                                                                // The raw line size = 100
                                                                                                // The output size in bytes = 856

FileFormat

รับค่ารูปแบบไฟล์ได้อย่างง่ายดายด้วยคุณสมบัติที่เป็นมิตรกับผู้ใช้นี้เหมาะสําหรับนักพัฒนาที่กําลังมองหาการเข้าถึงข้อมูลเกี่ยวกับรูปแบบไฟล์ได้อย่างรวดเร็ว

public override FileFormat FileFormat { get; }

คุณสมบัติมูลค่า

FileFormat

Examples

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าวิธีการสกัดข้อมูลเกี่ยวกับรูปแบบข้อมูลดิบและช่องอัลฟาจากภาพ BMP

// Create a 32-bpp BMP image of 100 x 100 px.
                                                                                                                           using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 32, null))
                                                                                                                           {
                                                                                                                               System.Console.WriteLine("FileFormat={0}, RawDataFormat={1}, HasAlpha={2}", bmpImage.FileFormat, bmpImage.RawDataFormat, bmpImage.HasAlpha);
                                                                                                                           };

                                                                                                                           // Create a 24-bpp BMP image of 100 x 100 px.
                                                                                                                           using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 24, null))
                                                                                                                           {
                                                                                                                               System.Console.WriteLine("FileFormat={0}, RawDataFormat={1}, HasAlpha={2}", bmpImage.FileFormat, bmpImage.RawDataFormat, bmpImage.HasAlpha);
                                                                                                                           };

                                                                                                                           // Generally, BMP doesn't support alpha channel so the output will look like this:
                                                                                                                           // FileFormat = Bmp, RawDataFormat = Rgb32Bpp, used channels: 8,8,8,8, HasAlpha = False
                                                                                                                           // FileFormat = Bmp, RawDataFormat = Rgb24Bpp, used channels: 8,8,8, HasAlpha = False

HasAlpha

ได้รับค่าแสดงให้เห็นว่าตัวอย่างนี้มีอัลฟาหรือไม่

public override bool HasAlpha { get; }

คุณสมบัติมูลค่า

bool

Height

รับความสูงของภาพได้อย่างง่ายดายด้วยคุณสมบัตินี้ เหมาะสําหรับนักพัฒนาต้องการเข้าถึงข้อมูลเกี่ยวกับขนาดภาพอย่างรวดเร็ว

public override int Height { get; }

คุณสมบัติมูลค่า

int

Examples

ตัวอย่างต่อไปนี้จะได้รับข้อมูลทั่วไปเกี่ยวกับภาพรวมถึงรูปแบบพิกเซลขนาดภาพความละเอียดการบีบอัด ฯลฯ

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.bmp"))
                                                                                                                                              {
                                                                                                                                                  Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;                

                                                                                                                                                  System.Console.WriteLine("The pixel format: {0}", bmpImage.RawDataFormat);                
                                                                                                                                                  System.Console.WriteLine("The raw line size in bytes: {0}", bmpImage.RawLineSize);
                                                                                                                                                  System.Console.WriteLine("The bitmap compression: {0}", bmpImage.Compression);
                                                                                                                                                  System.Console.WriteLine("The bitmap width: {0}", bmpImage.Width);
                                                                                                                                                  System.Console.WriteLine("The bitmap height: {0}", bmpImage.Height);
                                                                                                                                                  System.Console.WriteLine("The number of bits per pixel: {0}", bmpImage.BitsPerPixel);

                                                                                                                                                  double hres = bmpImage.HorizontalResolution;
                                                                                                                                                  double vres = bmpImage.VerticalResolution;
                                                                                                                                                  System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", hres);
                                                                                                                                                  System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", vres);

                                                                                                                                                  if (hres != 96.0 || vres != 96.0)
                                                                                                                                                  {
                                                                                                                                                      // You may consider using the SetResolution method for updating both resolution values in single call.
                                                                                                                                                      System.Console.WriteLine("Set resolution values to 96 dpi");
                                                                                                                                                      bmpImage.SetResolution(96.0, 96.0);

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

                                                                                                                                                  //The output may look like this:
                                                                                                                                                  //The pixel format: Rgb24Bpp, used channels: 8,8,8
                                                                                                                                                  //The raw line size in bytes: 1500
                                                                                                                                                  //The bitmap compression: Rgb
                                                                                                                                                  //The bitmap width: 500
                                                                                                                                                  //The bitmap height: 375
                                                                                                                                                  //The number of bits per pixel: 24
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 0
                                                                                                                                                  //The vertical resolution, in pixels per inch: 0
                                                                                                                                                  //Set resolution values to 96 dpi
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 96.012
                                                                                                                                                  //The vertical resolution, in pixels per inch: 96.012
                                                                                                                                              }

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าการบีบอัด bitmap จะส่งผลกระทบต่อขนาดภาพการส่งออก

Aspose.Imaging.FileFormats.Bmp.BitmapCompression[] compressions = new Aspose.Imaging.FileFormats.Bmp.BitmapCompression[]
                                                                                                {
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb,
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rle8,
                                                                                                };

                                                                                                Aspose.Imaging.Color[] paletterColors = new Aspose.Imaging.Color[]
                                                                                                {
                                                                                                    Aspose.Imaging.Color.Red,
                                                                                                    Aspose.Imaging.Color.Green,
                                                                                                };

                                                                                                // Create a monochrome palette which contains only red and green colors.
                                                                                                Aspose.Imaging.IColorPalette palette = new Aspose.Imaging.ColorPalette(paletterColors);

                                                                                                foreach (Aspose.Imaging.FileFormats.Bmp.BitmapCompression compression in compressions)
                                                                                                {
                                                                                                    // Create a 8-bpp BMP image of 100 x 100 px.
                                                                                                    using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 8, palette, compression, 0.0, 0.0))
                                                                                                    {
                                                                                                        Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);

                                                                                                        // Fill the entire image in red.
                                                                                                        Aspose.Imaging.Brushes.SolidBrush redBrush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                                        gr.FillRectangle(redBrush, bmpImage.Bounds);

                                                                                                        // Save the image to a stream to get the output image size.
                                                                                                        using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                        {
                                                                                                            bmpImage.Save(stream);

                                                                                                            System.Console.WriteLine("---------------------------------------------");
                                                                                                            System.Console.WriteLine("The compression={0}", bmpImage.Compression);
                                                                                                            System.Console.WriteLine("The number of bits per pixel={0}", bmpImage.BitsPerPixel);
                                                                                                            System.Console.WriteLine("The image dimensions={0} x {1}", bmpImage.Width, bmpImage.Height);
                                                                                                            System.Console.WriteLine("The raw line size={0}", bmpImage.RawLineSize);
                                                                                                            System.Console.WriteLine("The output size in bytes={0}", stream.Length);
                                                                                                        }
                                                                                                    }
                                                                                                }

                                                                                                // The output looks like this:
                                                                                                // ---------------------------------------------
                                                                                                // The compression = Rgb
                                                                                                // The number of bits per pixel = 8
                                                                                                // The image dimensions = 100 x 100
                                                                                                // The raw line size = 100
                                                                                                // The output size in bytes = 11078
                                                                                                // ---------------------------------------------
                                                                                                // The compression = Rle8
                                                                                                // The number of bits per pixel = 8
                                                                                                // The image dimensions = 100 x 100
                                                                                                // The raw line size = 100
                                                                                                // The output size in bytes = 856

HorizontalResolution

คุณสมบัตินี้ช่วยให้คุณสามารถรับหรือตั้งค่าความละเอียดแนวนอนได้อย่างง่ายดายวัดในพิกเซลต่อ นิ้วของ Aspose.Imaging.RasterImage วัตถุ เหมาะสําหรับผู้พัฒนาต้องการการควบคุมความละเอียดภาพที่แม่นยําสําหรับการใช้งานของพวกเขา

public override double HorizontalResolution { get; set; }

คุณสมบัติมูลค่า

double

Examples

ตัวอย่างต่อไปนี้แสดงให้เห็นวิธีการตั้งค่าความละเอียดแนวนอน/แนวตั้งของภาพ BMP

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

                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                {
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;

                                                                                                    // Get horizontal and vertical resolution of the BmpImage
                                                                                                    double horizontalResolution = bmpImage.HorizontalResolution;
                                                                                                    double verticalResolution = bmpImage.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");
                                                                                                        bmpImage.SetResolution(96.0, 96.0);

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

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

ตัวอย่างต่อไปนี้จะได้รับข้อมูลทั่วไปเกี่ยวกับภาพรวมถึงรูปแบบพิกเซลขนาดภาพความละเอียดการบีบอัด ฯลฯ

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.bmp"))
                                                                                                                                              {
                                                                                                                                                  Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;                

                                                                                                                                                  System.Console.WriteLine("The pixel format: {0}", bmpImage.RawDataFormat);                
                                                                                                                                                  System.Console.WriteLine("The raw line size in bytes: {0}", bmpImage.RawLineSize);
                                                                                                                                                  System.Console.WriteLine("The bitmap compression: {0}", bmpImage.Compression);
                                                                                                                                                  System.Console.WriteLine("The bitmap width: {0}", bmpImage.Width);
                                                                                                                                                  System.Console.WriteLine("The bitmap height: {0}", bmpImage.Height);
                                                                                                                                                  System.Console.WriteLine("The number of bits per pixel: {0}", bmpImage.BitsPerPixel);

                                                                                                                                                  double hres = bmpImage.HorizontalResolution;
                                                                                                                                                  double vres = bmpImage.VerticalResolution;
                                                                                                                                                  System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", hres);
                                                                                                                                                  System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", vres);

                                                                                                                                                  if (hres != 96.0 || vres != 96.0)
                                                                                                                                                  {
                                                                                                                                                      // You may consider using the SetResolution method for updating both resolution values in single call.
                                                                                                                                                      System.Console.WriteLine("Set resolution values to 96 dpi");
                                                                                                                                                      bmpImage.SetResolution(96.0, 96.0);

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

                                                                                                                                                  //The output may look like this:
                                                                                                                                                  //The pixel format: Rgb24Bpp, used channels: 8,8,8
                                                                                                                                                  //The raw line size in bytes: 1500
                                                                                                                                                  //The bitmap compression: Rgb
                                                                                                                                                  //The bitmap width: 500
                                                                                                                                                  //The bitmap height: 375
                                                                                                                                                  //The number of bits per pixel: 24
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 0
                                                                                                                                                  //The vertical resolution, in pixels per inch: 0
                                                                                                                                                  //Set resolution values to 96 dpi
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 96.012
                                                                                                                                                  //The vertical resolution, in pixels per inch: 96.012
                                                                                                                                              }

Remarks

หมายเหตุตาม default หมายเลขนี้เป็น 96 เนื่องจากแพลตฟอร์มที่แตกต่างกันไม่สามารถคืนความละเอียดหน้าจอได้ คุณสามารถพิจารณาการใช้วิธีการ SetResolution เพื่อปรับปรุงค่าความละเอียดทั้งสองในโทรเดียว

RawDataFormat

ได้รับรูปแบบของข้อมูลดิบของคุณได้อย่างง่ายดายด้วยฟังก์ชั่นที่เป็นมิตรกับผู้ใช้นี้เหมาะสําหรับนักพัฒนาที่ต้องการเข้าถึงข้อมูลที่สําคัญเกี่ยวกับรูปแบบข้อมูลของพวกเขาอย่างรวดเร็ว

public override PixelDataFormat RawDataFormat { get; }

คุณสมบัติมูลค่า

PixelDataFormat

Examples

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าวิธีการสกัดข้อมูลเกี่ยวกับรูปแบบข้อมูลดิบและช่องอัลฟาจากภาพ BMP

// Create a 32-bpp BMP image of 100 x 100 px.
                                                                                                                           using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 32, null))
                                                                                                                           {
                                                                                                                               System.Console.WriteLine("FileFormat={0}, RawDataFormat={1}, HasAlpha={2}", bmpImage.FileFormat, bmpImage.RawDataFormat, bmpImage.HasAlpha);
                                                                                                                           };

                                                                                                                           // Create a 24-bpp BMP image of 100 x 100 px.
                                                                                                                           using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 24, null))
                                                                                                                           {
                                                                                                                               System.Console.WriteLine("FileFormat={0}, RawDataFormat={1}, HasAlpha={2}", bmpImage.FileFormat, bmpImage.RawDataFormat, bmpImage.HasAlpha);
                                                                                                                           };

                                                                                                                           // Generally, BMP doesn't support alpha channel so the output will look like this:
                                                                                                                           // FileFormat = Bmp, RawDataFormat = Rgb32Bpp, used channels: 8,8,8,8, HasAlpha = False
                                                                                                                           // FileFormat = Bmp, RawDataFormat = Rgb24Bpp, used channels: 8,8,8, HasAlpha = False

ตัวอย่างต่อไปนี้จะได้รับข้อมูลทั่วไปเกี่ยวกับภาพรวมถึงรูปแบบพิกเซลขนาดภาพความละเอียดการบีบอัด ฯลฯ

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.bmp"))
                                                                                                                                              {
                                                                                                                                                  Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;                

                                                                                                                                                  System.Console.WriteLine("The pixel format: {0}", bmpImage.RawDataFormat);                
                                                                                                                                                  System.Console.WriteLine("The raw line size in bytes: {0}", bmpImage.RawLineSize);
                                                                                                                                                  System.Console.WriteLine("The bitmap compression: {0}", bmpImage.Compression);
                                                                                                                                                  System.Console.WriteLine("The bitmap width: {0}", bmpImage.Width);
                                                                                                                                                  System.Console.WriteLine("The bitmap height: {0}", bmpImage.Height);
                                                                                                                                                  System.Console.WriteLine("The number of bits per pixel: {0}", bmpImage.BitsPerPixel);

                                                                                                                                                  double hres = bmpImage.HorizontalResolution;
                                                                                                                                                  double vres = bmpImage.VerticalResolution;
                                                                                                                                                  System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", hres);
                                                                                                                                                  System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", vres);

                                                                                                                                                  if (hres != 96.0 || vres != 96.0)
                                                                                                                                                  {
                                                                                                                                                      // You may consider using the SetResolution method for updating both resolution values in single call.
                                                                                                                                                      System.Console.WriteLine("Set resolution values to 96 dpi");
                                                                                                                                                      bmpImage.SetResolution(96.0, 96.0);

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

                                                                                                                                                  //The output may look like this:
                                                                                                                                                  //The pixel format: Rgb24Bpp, used channels: 8,8,8
                                                                                                                                                  //The raw line size in bytes: 1500
                                                                                                                                                  //The bitmap compression: Rgb
                                                                                                                                                  //The bitmap width: 500
                                                                                                                                                  //The bitmap height: 375
                                                                                                                                                  //The number of bits per pixel: 24
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 0
                                                                                                                                                  //The vertical resolution, in pixels per inch: 0
                                                                                                                                                  //Set resolution values to 96 dpi
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 96.012
                                                                                                                                                  //The vertical resolution, in pixels per inch: 96.012
                                                                                                                                              }

RawLineSize

ความเร็วในการเข้าถึงขนาดของแต่ละสายดิบในไบต์ด้วยคุณสมบัติที่เรียบง่ายนี้เหมาะสําหรับนักพัฒนาที่จําเป็นต้องจัดการข้อมูลภาพดิบได้อย่างมีประสิทธิภาพ

public override int RawLineSize { get; }

คุณสมบัติมูลค่า

int

Examples

ตัวอย่างต่อไปนี้จะได้รับข้อมูลทั่วไปเกี่ยวกับภาพรวมถึงรูปแบบพิกเซลขนาดภาพความละเอียดการบีบอัด ฯลฯ

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.bmp"))
                                                                                                                                              {
                                                                                                                                                  Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;                

                                                                                                                                                  System.Console.WriteLine("The pixel format: {0}", bmpImage.RawDataFormat);                
                                                                                                                                                  System.Console.WriteLine("The raw line size in bytes: {0}", bmpImage.RawLineSize);
                                                                                                                                                  System.Console.WriteLine("The bitmap compression: {0}", bmpImage.Compression);
                                                                                                                                                  System.Console.WriteLine("The bitmap width: {0}", bmpImage.Width);
                                                                                                                                                  System.Console.WriteLine("The bitmap height: {0}", bmpImage.Height);
                                                                                                                                                  System.Console.WriteLine("The number of bits per pixel: {0}", bmpImage.BitsPerPixel);

                                                                                                                                                  double hres = bmpImage.HorizontalResolution;
                                                                                                                                                  double vres = bmpImage.VerticalResolution;
                                                                                                                                                  System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", hres);
                                                                                                                                                  System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", vres);

                                                                                                                                                  if (hres != 96.0 || vres != 96.0)
                                                                                                                                                  {
                                                                                                                                                      // You may consider using the SetResolution method for updating both resolution values in single call.
                                                                                                                                                      System.Console.WriteLine("Set resolution values to 96 dpi");
                                                                                                                                                      bmpImage.SetResolution(96.0, 96.0);

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

                                                                                                                                                  //The output may look like this:
                                                                                                                                                  //The pixel format: Rgb24Bpp, used channels: 8,8,8
                                                                                                                                                  //The raw line size in bytes: 1500
                                                                                                                                                  //The bitmap compression: Rgb
                                                                                                                                                  //The bitmap width: 500
                                                                                                                                                  //The bitmap height: 375
                                                                                                                                                  //The number of bits per pixel: 24
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 0
                                                                                                                                                  //The vertical resolution, in pixels per inch: 0
                                                                                                                                                  //Set resolution values to 96 dpi
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 96.012
                                                                                                                                                  //The vertical resolution, in pixels per inch: 96.012
                                                                                                                                              }

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าการบีบอัด bitmap จะส่งผลกระทบต่อขนาดภาพการส่งออก

Aspose.Imaging.FileFormats.Bmp.BitmapCompression[] compressions = new Aspose.Imaging.FileFormats.Bmp.BitmapCompression[]
                                                                                                {
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb,
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rle8,
                                                                                                };

                                                                                                Aspose.Imaging.Color[] paletterColors = new Aspose.Imaging.Color[]
                                                                                                {
                                                                                                    Aspose.Imaging.Color.Red,
                                                                                                    Aspose.Imaging.Color.Green,
                                                                                                };

                                                                                                // Create a monochrome palette which contains only red and green colors.
                                                                                                Aspose.Imaging.IColorPalette palette = new Aspose.Imaging.ColorPalette(paletterColors);

                                                                                                foreach (Aspose.Imaging.FileFormats.Bmp.BitmapCompression compression in compressions)
                                                                                                {
                                                                                                    // Create a 8-bpp BMP image of 100 x 100 px.
                                                                                                    using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 8, palette, compression, 0.0, 0.0))
                                                                                                    {
                                                                                                        Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);

                                                                                                        // Fill the entire image in red.
                                                                                                        Aspose.Imaging.Brushes.SolidBrush redBrush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                                        gr.FillRectangle(redBrush, bmpImage.Bounds);

                                                                                                        // Save the image to a stream to get the output image size.
                                                                                                        using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                        {
                                                                                                            bmpImage.Save(stream);

                                                                                                            System.Console.WriteLine("---------------------------------------------");
                                                                                                            System.Console.WriteLine("The compression={0}", bmpImage.Compression);
                                                                                                            System.Console.WriteLine("The number of bits per pixel={0}", bmpImage.BitsPerPixel);
                                                                                                            System.Console.WriteLine("The image dimensions={0} x {1}", bmpImage.Width, bmpImage.Height);
                                                                                                            System.Console.WriteLine("The raw line size={0}", bmpImage.RawLineSize);
                                                                                                            System.Console.WriteLine("The output size in bytes={0}", stream.Length);
                                                                                                        }
                                                                                                    }
                                                                                                }

                                                                                                // The output looks like this:
                                                                                                // ---------------------------------------------
                                                                                                // The compression = Rgb
                                                                                                // The number of bits per pixel = 8
                                                                                                // The image dimensions = 100 x 100
                                                                                                // The raw line size = 100
                                                                                                // The output size in bytes = 11078
                                                                                                // ---------------------------------------------
                                                                                                // The compression = Rle8
                                                                                                // The number of bits per pixel = 8
                                                                                                // The image dimensions = 100 x 100
                                                                                                // The raw line size = 100
                                                                                                // The output size in bytes = 856

VerticalResolution

รับหรือตั้งค่าความละเอียดแนวตั้งได้อย่างง่ายดายวัดในพิกเซลต่อ นิ้วของนี้ Aspose.Imaging.RasterImage วัตถุที่มีคุณสมบัตินี้ เหมาะสําหรับนักพัฒนาที่ต้องการการควบคุมความละเอียดภาพที่แม่นยําในการใช้งานของพวกเขา

public override double VerticalResolution { get; set; }

คุณสมบัติมูลค่า

double

Examples

ตัวอย่างต่อไปนี้แสดงให้เห็นวิธีการตั้งค่าความละเอียดแนวนอน/แนวตั้งของภาพ BMP

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

                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                {
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;

                                                                                                    // Get horizontal and vertical resolution of the BmpImage
                                                                                                    double horizontalResolution = bmpImage.HorizontalResolution;
                                                                                                    double verticalResolution = bmpImage.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");
                                                                                                        bmpImage.SetResolution(96.0, 96.0);

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

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

ตัวอย่างต่อไปนี้จะได้รับข้อมูลทั่วไปเกี่ยวกับภาพรวมถึงรูปแบบพิกเซลขนาดภาพความละเอียดการบีบอัด ฯลฯ

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.bmp"))
                                                                                                                                              {
                                                                                                                                                  Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;                

                                                                                                                                                  System.Console.WriteLine("The pixel format: {0}", bmpImage.RawDataFormat);                
                                                                                                                                                  System.Console.WriteLine("The raw line size in bytes: {0}", bmpImage.RawLineSize);
                                                                                                                                                  System.Console.WriteLine("The bitmap compression: {0}", bmpImage.Compression);
                                                                                                                                                  System.Console.WriteLine("The bitmap width: {0}", bmpImage.Width);
                                                                                                                                                  System.Console.WriteLine("The bitmap height: {0}", bmpImage.Height);
                                                                                                                                                  System.Console.WriteLine("The number of bits per pixel: {0}", bmpImage.BitsPerPixel);

                                                                                                                                                  double hres = bmpImage.HorizontalResolution;
                                                                                                                                                  double vres = bmpImage.VerticalResolution;
                                                                                                                                                  System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", hres);
                                                                                                                                                  System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", vres);

                                                                                                                                                  if (hres != 96.0 || vres != 96.0)
                                                                                                                                                  {
                                                                                                                                                      // You may consider using the SetResolution method for updating both resolution values in single call.
                                                                                                                                                      System.Console.WriteLine("Set resolution values to 96 dpi");
                                                                                                                                                      bmpImage.SetResolution(96.0, 96.0);

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

                                                                                                                                                  //The output may look like this:
                                                                                                                                                  //The pixel format: Rgb24Bpp, used channels: 8,8,8
                                                                                                                                                  //The raw line size in bytes: 1500
                                                                                                                                                  //The bitmap compression: Rgb
                                                                                                                                                  //The bitmap width: 500
                                                                                                                                                  //The bitmap height: 375
                                                                                                                                                  //The number of bits per pixel: 24
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 0
                                                                                                                                                  //The vertical resolution, in pixels per inch: 0
                                                                                                                                                  //Set resolution values to 96 dpi
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 96.012
                                                                                                                                                  //The vertical resolution, in pixels per inch: 96.012
                                                                                                                                              }

Remarks

หมายเหตุตาม default หมายเลขนี้เป็น 96 เนื่องจากแพลตฟอร์มที่แตกต่างกันไม่สามารถคืนความละเอียดหน้าจอได้ คุณสามารถพิจารณาการใช้วิธีการ SetResolution เพื่อปรับปรุงค่าความละเอียดทั้งสองในโทรเดียว

Width

เข้าถึงความกว้างของภาพได้อย่างง่ายดายด้วยคุณสมบัตินี้ เหมาะสําหรับนักพัฒนาค้นหาข้อมูลอย่างรวดเร็วเกี่ยวกับขนาดของภาพ

public override int Width { get; }

คุณสมบัติมูลค่า

int

Examples

ตัวอย่างต่อไปนี้จะได้รับข้อมูลทั่วไปเกี่ยวกับภาพรวมถึงรูปแบบพิกเซลขนาดภาพความละเอียดการบีบอัด ฯลฯ

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.bmp"))
                                                                                                                                              {
                                                                                                                                                  Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;                

                                                                                                                                                  System.Console.WriteLine("The pixel format: {0}", bmpImage.RawDataFormat);                
                                                                                                                                                  System.Console.WriteLine("The raw line size in bytes: {0}", bmpImage.RawLineSize);
                                                                                                                                                  System.Console.WriteLine("The bitmap compression: {0}", bmpImage.Compression);
                                                                                                                                                  System.Console.WriteLine("The bitmap width: {0}", bmpImage.Width);
                                                                                                                                                  System.Console.WriteLine("The bitmap height: {0}", bmpImage.Height);
                                                                                                                                                  System.Console.WriteLine("The number of bits per pixel: {0}", bmpImage.BitsPerPixel);

                                                                                                                                                  double hres = bmpImage.HorizontalResolution;
                                                                                                                                                  double vres = bmpImage.VerticalResolution;
                                                                                                                                                  System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", hres);
                                                                                                                                                  System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", vres);

                                                                                                                                                  if (hres != 96.0 || vres != 96.0)
                                                                                                                                                  {
                                                                                                                                                      // You may consider using the SetResolution method for updating both resolution values in single call.
                                                                                                                                                      System.Console.WriteLine("Set resolution values to 96 dpi");
                                                                                                                                                      bmpImage.SetResolution(96.0, 96.0);

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

                                                                                                                                                  //The output may look like this:
                                                                                                                                                  //The pixel format: Rgb24Bpp, used channels: 8,8,8
                                                                                                                                                  //The raw line size in bytes: 1500
                                                                                                                                                  //The bitmap compression: Rgb
                                                                                                                                                  //The bitmap width: 500
                                                                                                                                                  //The bitmap height: 375
                                                                                                                                                  //The number of bits per pixel: 24
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 0
                                                                                                                                                  //The vertical resolution, in pixels per inch: 0
                                                                                                                                                  //Set resolution values to 96 dpi
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 96.012
                                                                                                                                                  //The vertical resolution, in pixels per inch: 96.012
                                                                                                                                              }

ตัวอย่างต่อไปนี้แสดงให้เห็นว่าการบีบอัด bitmap จะส่งผลกระทบต่อขนาดภาพการส่งออก

Aspose.Imaging.FileFormats.Bmp.BitmapCompression[] compressions = new Aspose.Imaging.FileFormats.Bmp.BitmapCompression[]
                                                                                                {
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rgb,
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BitmapCompression.Rle8,
                                                                                                };

                                                                                                Aspose.Imaging.Color[] paletterColors = new Aspose.Imaging.Color[]
                                                                                                {
                                                                                                    Aspose.Imaging.Color.Red,
                                                                                                    Aspose.Imaging.Color.Green,
                                                                                                };

                                                                                                // Create a monochrome palette which contains only red and green colors.
                                                                                                Aspose.Imaging.IColorPalette palette = new Aspose.Imaging.ColorPalette(paletterColors);

                                                                                                foreach (Aspose.Imaging.FileFormats.Bmp.BitmapCompression compression in compressions)
                                                                                                {
                                                                                                    // Create a 8-bpp BMP image of 100 x 100 px.
                                                                                                    using (Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = new Aspose.Imaging.FileFormats.Bmp.BmpImage(100, 100, 8, palette, compression, 0.0, 0.0))
                                                                                                    {
                                                                                                        Aspose.Imaging.Graphics gr = new Aspose.Imaging.Graphics(bmpImage);

                                                                                                        // Fill the entire image in red.
                                                                                                        Aspose.Imaging.Brushes.SolidBrush redBrush = new Aspose.Imaging.Brushes.SolidBrush(Aspose.Imaging.Color.Red);
                                                                                                        gr.FillRectangle(redBrush, bmpImage.Bounds);

                                                                                                        // Save the image to a stream to get the output image size.
                                                                                                        using (System.IO.MemoryStream stream = new System.IO.MemoryStream())
                                                                                                        {
                                                                                                            bmpImage.Save(stream);

                                                                                                            System.Console.WriteLine("---------------------------------------------");
                                                                                                            System.Console.WriteLine("The compression={0}", bmpImage.Compression);
                                                                                                            System.Console.WriteLine("The number of bits per pixel={0}", bmpImage.BitsPerPixel);
                                                                                                            System.Console.WriteLine("The image dimensions={0} x {1}", bmpImage.Width, bmpImage.Height);
                                                                                                            System.Console.WriteLine("The raw line size={0}", bmpImage.RawLineSize);
                                                                                                            System.Console.WriteLine("The output size in bytes={0}", stream.Length);
                                                                                                        }
                                                                                                    }
                                                                                                }

                                                                                                // The output looks like this:
                                                                                                // ---------------------------------------------
                                                                                                // The compression = Rgb
                                                                                                // The number of bits per pixel = 8
                                                                                                // The image dimensions = 100 x 100
                                                                                                // The raw line size = 100
                                                                                                // The output size in bytes = 11078
                                                                                                // ---------------------------------------------
                                                                                                // The compression = Rle8
                                                                                                // The number of bits per pixel = 8
                                                                                                // The image dimensions = 100 x 100
                                                                                                // The raw line size = 100
                                                                                                // The output size in bytes = 856

Methods

GetDefaultOptions(วัตถุ[])

แก้ไขตัวเลือกที่กําหนดเองได้อย่างง่ายดายด้วยวิธีการที่เรียบง่ายนี้เหมาะสําหรับนักพัฒนาที่กําลังมองหาการเข้าถึงที่รวดเร็วในการตั้งค่าภาพหรือการกําหนดค่าแบบกําหนดเอง

public override ImageOptionsBase GetDefaultOptions(object[] args)

Parameters

args object [ ]

ข้อตกลง

Returns

ImageOptionsBase

ตัวเลือกที่กําหนดเอง

OnCached()

การเรียกเมื่อข้อมูลถูกซ่อนอยู่และทรัพยากรที่เกี่ยวข้องทั้งหมดอาจถูกยกเลิก

protected override void OnCached()

OnPaletteChanging(IColorPalette, IColorPalette)

การเรียกเมื่อแพลตฟอร์มจะเปลี่ยนแปลง

protected override void OnPaletteChanging(IColorPalette oldPalette, IColorPalette newPalette)

Parameters

oldPalette IColorPalette

แพลิเคชันเก่า

newPalette IColorPalette

แพลิเคชันใหม่

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

ตัวอย่างต่อไปนี้แสดงให้เห็นวิธีการตั้งค่าความละเอียดแนวนอน/แนวตั้งของภาพ BMP

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

                                                                                                using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(dir + "sample.bmp"))
                                                                                                {
                                                                                                    Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;

                                                                                                    // Get horizontal and vertical resolution of the BmpImage
                                                                                                    double horizontalResolution = bmpImage.HorizontalResolution;
                                                                                                    double verticalResolution = bmpImage.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");
                                                                                                        bmpImage.SetResolution(96.0, 96.0);

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

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

ตัวอย่างต่อไปนี้จะได้รับข้อมูลทั่วไปเกี่ยวกับภาพรวมถึงรูปแบบพิกเซลขนาดภาพความละเอียดการบีบอัด ฯลฯ

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.bmp"))
                                                                                                                                              {
                                                                                                                                                  Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;                

                                                                                                                                                  System.Console.WriteLine("The pixel format: {0}", bmpImage.RawDataFormat);                
                                                                                                                                                  System.Console.WriteLine("The raw line size in bytes: {0}", bmpImage.RawLineSize);
                                                                                                                                                  System.Console.WriteLine("The bitmap compression: {0}", bmpImage.Compression);
                                                                                                                                                  System.Console.WriteLine("The bitmap width: {0}", bmpImage.Width);
                                                                                                                                                  System.Console.WriteLine("The bitmap height: {0}", bmpImage.Height);
                                                                                                                                                  System.Console.WriteLine("The number of bits per pixel: {0}", bmpImage.BitsPerPixel);

                                                                                                                                                  double hres = bmpImage.HorizontalResolution;
                                                                                                                                                  double vres = bmpImage.VerticalResolution;
                                                                                                                                                  System.Console.WriteLine("The horizontal resolution, in pixels per inch: {0}", hres);
                                                                                                                                                  System.Console.WriteLine("The vertical resolution, in pixels per inch: {0}", vres);

                                                                                                                                                  if (hres != 96.0 || vres != 96.0)
                                                                                                                                                  {
                                                                                                                                                      // You may consider using the SetResolution method for updating both resolution values in single call.
                                                                                                                                                      System.Console.WriteLine("Set resolution values to 96 dpi");
                                                                                                                                                      bmpImage.SetResolution(96.0, 96.0);

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

                                                                                                                                                  //The output may look like this:
                                                                                                                                                  //The pixel format: Rgb24Bpp, used channels: 8,8,8
                                                                                                                                                  //The raw line size in bytes: 1500
                                                                                                                                                  //The bitmap compression: Rgb
                                                                                                                                                  //The bitmap width: 500
                                                                                                                                                  //The bitmap height: 375
                                                                                                                                                  //The number of bits per pixel: 24
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 0
                                                                                                                                                  //The vertical resolution, in pixels per inch: 0
                                                                                                                                                  //Set resolution values to 96 dpi
                                                                                                                                                  //The horizontal resolution, in pixels per inch: 96.012
                                                                                                                                                  //The vertical resolution, in pixels per inch: 96.012
                                                                                                                                              }

ToBitmap()

แปลงภาพ raster ของคุณได้อย่างง่ายดายเป็น bitmap ด้วยวิธีการที่เรียบง่ายนี้เหมาะสําหรับนักพัฒนาที่จําเป็นต้องเปลี่ยนระหว่างรูปแบบภาพที่แตกต่างกัน

public override Bitmap ToBitmap()

Returns

Bitmap

บิตการ์ด

Examples

ตัวอย่างต่อไปนี้แปลงภาพ BMP ไปยัง GDI bitmap

using (Aspose.Imaging.Image image = Aspose.Imaging.Image.Load(@"c:\temp\sample.bmp"))
                                                                      {
                                                                          Aspose.Imaging.FileFormats.Bmp.BmpImage bmpImage = (Aspose.Imaging.FileFormats.Bmp.BmpImage)image;
                                                                          System.Drawing.Bitmap bitmap = bmpImage.ToBitmap();

                                                                          // Process the GDI bitmap.
                                                                      }

UpdateDimensions(int, int)

ปรับปรุงขนาดภาพ

protected override void UpdateDimensions(int newWidth, int newHeight)

Parameters

newWidth int

ความกว้างของภาพใหม่

newHeight int

ความสูงของภาพใหม่

 แบบไทย