圖片檔之壓縮

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
 namespace myclass

{
    /// <summary>
    /// 圖片壓縮輔助類別
    /// </summary>
    public class ImageResizer
    {
        private string _path;
        private double _maxDimension;
        private double _width;
        private double _height;

        /// <summary>
        /// 圖片壓縮輔助建構式
        /// </summary>
        /// <param name="path">圖片路徑</param>
        /// <param name="maxDimension">最大尺寸大小</param>
        public ImageResizer(string path, int maxDimension)
        {
            _path = path;
            _maxDimension = maxDimension;
        }

        /// <summary>
        ///  取得壓縮圖片資料流
        /// </summary>
        /// <returns>壓縮圖片資料流</returns>
        public MemoryStream GetImage()
        {
            MemoryStream stream = null;

            try
            {
                Bitmap orgImage = new Bitmap(_path);

                stream = new MemoryStream();

                if (InitDimension(orgImage.Height, orgImage.Width))
                {
                    Bitmap bmpImage = new Bitmap(orgImage, new Size((int)_width, (int)_height));

                    bmpImage.Save(stream, orgImage.RawFormat);
                }
                else
                {
                    stream = ConvertBitmapToStream();
                }
            }
            catch (Exception ex)
            {                 throw;
            }

            return stream;
        }

        /// <summary>
        /// 取得高品質壓縮圖片資料流
        /// </summary>
        /// <returns>高品質壓縮圖片資料流</returns>
        public MemoryStream GetHighQualityImage()
        {
            return GetImageByQualityLevel(100L);
        }

        /// <summary>
        /// 取得指定壓縮品質的圖片資料流
        /// </summary>
        /// <param name="level">圖片品質(0L~100L:數字越高保留越多細節)</param>
        /// <returns>圖片資料流</returns>
        public MemoryStream GetImageByQualityLevel(long level)
        {
            MemoryStream stream = null;

            try
            {
                using (Image orgImg = Image.FromFile(_path))
                {
                    if (!InitDimension(orgImg.Height, orgImg.Width))
                    {
                        return ConvertBitmapToStream();
                    }
                    else
                    {
                        using (Bitmap bitmap = new Bitmap((int)_width, (int)_height))
                        {
                            using (Graphics graphics = Graphics.FromImage(bitmap))
                            {
                                graphics.SmoothingMode = SmoothingMode.HighQuality;
                                graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
                                graphics.DrawImage(orgImg, 0, 0, bitmap.Width, bitmap.Height);

                                stream = new MemoryStream();

                                if (orgImg.RawFormat.Guid == ImageFormat.Jpeg.Guid)
                                {
                                    ImageCodecInfo codecInfo = GetJpegEncoder(orgImg);

                                    if (codecInfo != null)
                                    {
                                        EncoderParameters param = new EncoderParameters(1);

                                        long value = level < 0 ? 0L : (level > 100 ? 100 : level);

                                        param.Param[0] = new EncoderParameter(Encoder.Quality, value);

                                        bitmap.Save(stream, codecInfo, param);
                                    }
                                    else
                                    {
                                        bitmap.Save(stream, orgImg.RawFormat);
                                    }
                                }
                                else
                                {
                                    graphics.FillRectangle(Brushes.Transparent, 0, 0, bitmap.Width, bitmap.Height);

                                    bitmap.Save(stream, orgImg.RawFormat);
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                                 throw;
            }

            return stream;
        }

        /// <summary>
        /// 轉換圖檔為資料流
        /// </summary>
        /// <returns>資料流</returns>
        private MemoryStream ConvertBitmapToStream()
        {
            Bitmap img = new Bitmap(_path);

            MemoryStream stream = new MemoryStream();

            img.Save(stream, img.RawFormat);

            return stream;
        }

        /// <summary>
        /// 取得Jpeg編碼
        /// </summary>
        /// <param name="orgImg">Image object</param>
        /// <returns>Jpeg編碼</returns>
        private ImageCodecInfo GetJpegEncoder(Image orgImg)
        {
            ImageCodecInfo codecInfo = null;

            if (codecInfo == null)
            {
                ImageCodecInfo[] infos = ImageCodecInfo.GetImageDecoders();

                foreach (ImageCodecInfo info in infos)
                {
                    if (info.FormatID == ImageFormat.Jpeg.Guid)
                    {
                        codecInfo = info;
                        break;
                    }
                }
            }

            return codecInfo;
        }

        /// <summary>
        /// 初始壓縮圖片的尺寸大小
        /// </summary>
        /// <param name="height">原始圖片高度</param>
        /// <param name="width">原始圖片寬度</param>
        /// <returns>若原始圖片大小已小於指定尺寸大小時回傳False,反之回傳True</returns>
        private bool InitDimension(int height, int width)
        {
            if (_maxDimension < (height > width ? height : width))
            {
                if (height < width)
                {
                    _width = _maxDimension;
                    _height = (_maxDimension / (double)width) * height;
                }
                else
                {
                    _height = _maxDimension;
                    _width = (_maxDimension / (double)height) * width;
                }

                return true;
            }
            else
            {
                _height = height;
                _width = width;

                return false;
            }
        }
    }
}