EasyFRMS.Image C# 實現圖片剪切、縮放、旋轉、水印操作

    /// <summary>
    /// 功能：Shenxu 水印位置模式
    /// 作者：Tianeyi 申栩
    /// 日期：2009-03-18
    /// </summary>
    public enum PositionMode
    {
        None, TopLeft, TopRight, Middle, BottomLeft, BottomRight
    }

    /// <summary>
    /// 功能：Shenxu 圖片縮放模式
    /// 作者：Tianeyi 申栩
    /// 日期：2009-03-18
    /// </summary>
    public enum ResizeMode
    {
        Center, Stretch
    }

    /// <summary>
    /// 功能：Shenxu 圖片旋轉模式
    /// 作者：Tianeyi 申栩
    /// 日期：2009-03-18
    /// </summary>
    public enum RotateMode
    {
        TurnLeft, TurnRight, TurnVertical, TurnHorizontal
    }

        /// <summary>
        /// 從源圖剪切圖片至目標位置
        /// </summary>
        /// <param name="ImageBytes">byte[] 源圖數據</param>
        /// <param name="Width">int 寬度</param>
        /// <param name="Height">int 高度</param>
        /// <param name="Position">PositionMode 位置</param>
        /// <returns>byte[] 目標圖數據</returns>
        public static byte[] CutImage(byte[] ImageBytes, int Width, int Height, PositionMode Position)
        {
            Image _SourceImage = Image.FromStream(new MemoryStream(ImageBytes));
            Bitmap _CanvasBitmap = new Bitmap(Width, Height, PixelFormat.Format24bppRgb);
            Graphics _CanvasGraphics = Graphics.FromImage(_CanvasBitmap);
            Rectangle _SourceRect = GetCutRect(new Rectangle(0, 0, _SourceImage.Width, _SourceImage.Height), Position, Width, Height);
            Rectangle _TargetRect = GetCutRect(new Rectangle(0, 0, _SourceImage.Width, _SourceImage.Height), Width, Height);
            _CanvasGraphics.CompositingQuality = CompositingQuality.HighQuality;
            _CanvasGraphics.SmoothingMode = SmoothingMode.AntiAlias;
            _CanvasGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
            _CanvasGraphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
            _CanvasGraphics.FillRectangle(new SolidBrush(Color.White), 0, 0, _CanvasBitmap.Width, _CanvasBitmap.Height);
            _CanvasGraphics.DrawImage(_SourceImage, _TargetRect, _SourceRect, GraphicsUnit.Pixel);
            EncoderParameters _TargetEncoder = new EncoderParameters(1);
            _TargetEncoder.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)100);
            ImageCodecInfo _TargetCodec = GetEncoderInfo("image/jpeg");
            MemoryStream _TargetMemory = new MemoryStream();
            if (_TargetCodec != null)
            {
                _CanvasBitmap.Save(_TargetMemory, _TargetCodec, _TargetEncoder);
            }
            else
            {
                _CanvasBitmap.Save(_TargetMemory, ImageFormat.Jpeg);
            }
            _TargetEncoder.Dispose();
            _TargetEncoder = null;
            _CanvasGraphics.Dispose();
            _CanvasGraphics = null;
            _CanvasBitmap.Dispose();
            _CanvasBitmap = null;
            _SourceImage.Dispose();
            _SourceImage = null;
            return _TargetMemory.GetBuffer();
        }

        /// <summary>
        /// 對圖片進行縮放操作
        /// </summary>
        /// <param name="ImageBytes">byte[] 源圖數據</param>
        /// <param name="Size">double 縮放參數</param>
        /// <returns>byte[] 目標圖數據</returns>
        public static byte[] ZoomImage(byte[] ImageBytes, double Size)
        {
            Image _SourceImage = Image.FromStream(new MemoryStream(ImageBytes));
            Rectangle _SourceRect = new Rectangle(0, 0, _SourceImage.Width, _SourceImage.Height);
            Rectangle _TargetRect = GetZoomRect(_SourceRect, Size);
            Bitmap _CanvasBitmap = new Bitmap(_TargetRect.Width, _TargetRect.Height, PixelFormat.Format24bppRgb);
            Graphics _CanvasGraphics = Graphics.FromImage(_CanvasBitmap);
            _CanvasGraphics.CompositingQuality = CompositingQuality.HighQuality;
            _CanvasGraphics.SmoothingMode = SmoothingMode.AntiAlias;
            _CanvasGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
            _CanvasGraphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
            _CanvasGraphics.DrawImage(_SourceImage, _TargetRect, _SourceRect, GraphicsUnit.Pixel);
            EncoderParameters _TargetEncoder = new EncoderParameters(1);
            _TargetEncoder.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)100);
            ImageCodecInfo _TargetCodec = GetEncoderInfo("image/jpeg");
            MemoryStream _TargetMemory = new MemoryStream();
            if (_TargetCodec != null)
            {
                _CanvasBitmap.Save(_TargetMemory, _TargetCodec, _TargetEncoder);
            }
            else
            {
                _CanvasBitmap.Save(_TargetMemory, ImageFormat.Jpeg);
            }
            _TargetEncoder.Dispose();
            _TargetEncoder = null;
            _CanvasGraphics.Dispose();
            _CanvasGraphics = null;
            _CanvasBitmap.Dispose();
            _CanvasBitmap = null;
            _SourceImage.Dispose();
            _SourceImage = null;
            return _TargetMemory.GetBuffer();
        }

        /// <summary>
        /// 對圖片進行填充操作
        /// </summary>
        /// <param name="ImageBytes">byte[] 源圖數據</param>
        /// <param name="Width">int 寬度</param>
        /// <param name="Height">int 高度</param>
        /// <param name="BackColor">string 顏色名稱</param>
        /// <param name="Position">PositionMode 位置</param>
        /// <returns>byte[] 目標圖數據</returns>
        public static byte[] CenterImage(byte[] ImageBytes, int Width, int Height, string BackColor, PositionMode Position)
        {
            Image _SourceImage = Image.FromStream(new MemoryStream(ImageBytes));
            Bitmap _CanvasBitmap = new Bitmap(Width, Height, PixelFormat.Format24bppRgb);
            Graphics _CanvasGraphics = Graphics.FromImage(_CanvasBitmap);
            Rectangle _SourceRect = new Rectangle(0, 0, _SourceImage.Width, _SourceImage.Height);
            Rectangle _TargetRect = GetCenterRect(_SourceRect, Position, Width, Height);
            _CanvasGraphics.CompositingQuality = CompositingQuality.HighQuality;
            _CanvasGraphics.SmoothingMode = SmoothingMode.AntiAlias;
            _CanvasGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
            _CanvasGraphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
            _CanvasGraphics.FillRectangle(new SolidBrush(Color.FromName(BackColor)), 0, 0, _CanvasBitmap.Width, _CanvasBitmap.Height);
            _CanvasGraphics.DrawImage(_SourceImage, _TargetRect, _SourceRect, GraphicsUnit.Pixel);
            EncoderParameters _TargetEncoder = new EncoderParameters(1);
            _TargetEncoder.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)100);
            ImageCodecInfo _TargetCodec = GetEncoderInfo("image/jpeg");
            MemoryStream _TargetMemory = new MemoryStream();
            if (_TargetCodec != null)
            {
                _CanvasBitmap.Save(_TargetMemory, _TargetCodec, _TargetEncoder);
            }
            else
            {
                _CanvasBitmap.Save(_TargetMemory, ImageFormat.Jpeg);
            }
            _TargetEncoder.Dispose();
            _TargetEncoder = null;
            _CanvasGraphics.Dispose();
            _CanvasGraphics = null;
            _CanvasBitmap.Dispose();
            _CanvasBitmap = null;
            _SourceImage.Dispose();
            _SourceImage = null;
            return _TargetMemory.GetBuffer();
        }

        /// <summary>
        /// 對圖片進行旋轉操作
        /// </summary>
        /// <param name="ImageBytes">byte[] 源圖數據</param>
        /// <param name="Mode">RotateMode 旋轉模式</param>
        /// <returns>byte[] 目標圖數據</returns>
        public static byte[] RotateImage(byte[] ImageBytes, RotateMode Mode)
        {
            Image _SourceImage = Image.FromStream(new MemoryStream(ImageBytes));
            Bitmap _CanvasBitmap = new Bitmap(_SourceImage.Width, _SourceImage.Height);
            _CanvasBitmap.SetResolution(72f, 72f);
            Graphics _CanvasGraphics = Graphics.FromImage(_CanvasBitmap);
            _CanvasGraphics.SmoothingMode = SmoothingMode.HighQuality;
            _CanvasGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
            _CanvasGraphics.DrawImage(_SourceImage, new Rectangle(new Point(0, 0), new Size(_SourceImage.Width, _SourceImage.Height)), 0, 0, _SourceImage.Width, _SourceImage.Height, GraphicsUnit.Pixel);
            switch (Mode)
            {
                case RotateMode.TurnLeft:
                    _CanvasBitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
                    break;
                case RotateMode.TurnRight:
                    _CanvasBitmap.RotateFlip(RotateFlipType.Rotate90FlipNone);
                    break;
                case RotateMode.TurnHorizontal:
                    _CanvasBitmap.RotateFlip(RotateFlipType.RotateNoneFlipX);
                    break;
                case RotateMode.TurnVertical:
                    _CanvasBitmap.RotateFlip(RotateFlipType.RotateNoneFlipY);
                    break;
            }
            EncoderParameters _TargetEncoder = new EncoderParameters(1);
            _TargetEncoder.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)100);
            ImageCodecInfo _TargetCodec = GetEncoderInfo("image/jpeg");
            MemoryStream _TargetMemory = new MemoryStream();
            if (_TargetCodec != null)
            {
                _CanvasBitmap.Save(_TargetMemory, _TargetCodec, _TargetEncoder);
            }
            else
            {
                _CanvasBitmap.Save(_TargetMemory, ImageFormat.Jpeg);
            }
            _CanvasGraphics.Dispose();
            _CanvasGraphics = null;
            _CanvasBitmap.Dispose();
            _CanvasBitmap = null;
            _SourceImage.Dispose();
            _SourceImage = null;
            return _TargetMemory.GetBuffer();
        }

        /// <summary>
        /// 對圖片進行拉伸操作
        /// </summary>
        /// <param name="ImageBytes">byte[] 源圖數據</param>
        /// <param name="Size">double 縮放參數</param>
        /// <returns>byte[] 目標圖數據</returns>
        public static byte[] StretchImage(byte[] ImageBytes, int Width, int Height)
        {
            Image _SourceImage = Image.FromStream(new MemoryStream(ImageBytes));
            Rectangle _SourceRect = new Rectangle(0, 0, _SourceImage.Width, _SourceImage.Height);
            Rectangle _TargetRect = new Rectangle(0, 0, Width, Height);
            Bitmap _CanvasBitmap = new Bitmap(_TargetRect.Width, _TargetRect.Height, PixelFormat.Format24bppRgb);
            Graphics _CanvasGraphics = Graphics.FromImage(_CanvasBitmap);
            _CanvasGraphics.CompositingQuality = CompositingQuality.HighQuality;
            _CanvasGraphics.SmoothingMode = SmoothingMode.AntiAlias;
            _CanvasGraphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
            _CanvasGraphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
            _CanvasGraphics.DrawImage(_SourceImage, _TargetRect, _SourceRect, GraphicsUnit.Pixel);
            EncoderParameters _TargetEncoder = new EncoderParameters(1);
            _TargetEncoder.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)100);
            ImageCodecInfo _TargetCodec = GetEncoderInfo("image/jpeg");
            MemoryStream _TargetMemory = new MemoryStream();
            if (_TargetCodec != null)
            {
                _CanvasBitmap.Save(_TargetMemory, _TargetCodec, _TargetEncoder);
            }
            else
            {
                _CanvasBitmap.Save(_TargetMemory, ImageFormat.Jpeg);
            }
            _TargetEncoder.Dispose();
            _TargetEncoder = null;
            _CanvasGraphics.Dispose();
            _CanvasGraphics = null;
            _CanvasBitmap.Dispose();
            _CanvasBitmap = null;
            _SourceImage.Dispose();
            _SourceImage = null;
            return _TargetMemory.GetBuffer();
        }

        /// <summary>
        /// 添加圖片水印
        /// </summary>
        /// <param name="ImageBytes">byte[] 源圖數據</param>
        /// <param name="WatermarkBytes">byte[]</param>
        /// <param name="Alpha">int 透明度</param>
        /// <param name="Position">PositionMode 位置</param>
        /// <returns>byte[] 目標圖數據</returns>
        public static byte[] ImageWatermark(byte[] ImageBytes, byte[] WatermarkBytes, int Alpha, PositionMode Position)
        {
            Image _SourceImage = Image.FromStream(new MemoryStream(ImageBytes));
            Image _WatermarkImage = Image.FromStream(new MemoryStream(WatermarkBytes));
            float _XPos = 0;
            float _YPos = 0;
            switch (Position)
            {
                case PositionMode.TopLeft:
                    _XPos = (int)(_SourceImage.Width * (float).01);
                    _YPos = (int)(_SourceImage.Height * (float).01);
                    break;
                case PositionMode.TopRight:
                    _XPos = (int)((_SourceImage.Width * (float).99) - (_WatermarkImage.Width));
                    _YPos = (int)(_SourceImage.Height * (float).01);
                    break;
                case PositionMode.Middle:
                    _XPos = (int)((_SourceImage.Width * (float).50) - (_WatermarkImage.Width / 2));
                    _YPos = (int)((_SourceImage.Height * (float).50) - (_WatermarkImage.Height / 2));
                    break;
                case PositionMode.BottomLeft:
                    _XPos = (int)(_SourceImage.Width * (float).01);
                    _YPos = (int)((_SourceImage.Height * (float).99) - _WatermarkImage.Height);
                    break;
                case PositionMode.BottomRight:
                    _XPos = (int)((_SourceImage.Width * (float).99) - _WatermarkImage.Width);
                    _YPos = (int)((_SourceImage.Height * (float).99) - _WatermarkImage.Height);
                    break;
            }
            if (_XPos > 0 && _YPos > 0 && (_XPos + _WatermarkImage.Width) < _SourceImage.Width && (_YPos + +_WatermarkImage.Height) < _SourceImage.Height)
            {
                float _Transparency = ((Alpha >= 1 && Alpha <= 10) ? (Alpha / 10.0F) : 0.5F);
                float[][] _MatrixElements = {
                                                new float[] {1.0f,  0.0f,  0.0f,  0.0f, 0.0f},
                                                new float[] {0.0f,  1.0f,  0.0f,  0.0f, 0.0f},
                                                new float[] {0.0f,  0.0f,  1.0f,  0.0f, 0.0f},
                                                new float[] {0.0f,  0.0f,  0.0f,  _Transparency, 0.0f},
                                                new float[] {0.0f,  0.0f,  0.0f,  0.0f, 1.0f}
                                            };
                ColorMap _ColorMap = new ColorMap();
                _ColorMap.OldColor = Color.FromArgb(255, 0, 255, 0);
                _ColorMap.NewColor = Color.FromArgb(0, 0, 0, 0);
                ColorMap[] _RemapTable = { _ColorMap };
                ColorMatrix _ColorMatrix = new ColorMatrix(_MatrixElements);
                ImageAttributes _ImageAttributes = new ImageAttributes();
                _ImageAttributes.SetRemapTable(_RemapTable, ColorAdjustType.Bitmap);
                _ImageAttributes.SetColorMatrix(_ColorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
                MemoryStream _TargetMemory = new MemoryStream();
                Graphics _CanvasGraphics = Graphics.FromImage(_SourceImage);
                _CanvasGraphics.InterpolationMode = InterpolationMode.High;
                _CanvasGraphics.SmoothingMode = SmoothingMode.HighQuality;
                _CanvasGraphics.DrawImage(_WatermarkImage, new Rectangle((int)_XPos, (int)_YPos, _WatermarkImage.Width, _WatermarkImage.Height), 0, 0, _WatermarkImage.Width, _WatermarkImage.Height, GraphicsUnit.Pixel, _ImageAttributes);
                EncoderParameters _TargetEncoder = new EncoderParameters(1);
                _TargetEncoder.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)100);
                ImageCodecInfo _TargetCodec = GetEncoderInfo("image/jpeg");
                if (_TargetCodec != null)
                {
                    _SourceImage.Save(_TargetMemory, _TargetCodec, _TargetEncoder);
                }
                else
                {
                    _SourceImage.Save(_TargetMemory, ImageFormat.Jpeg);
                }
                _TargetEncoder.Dispose();
                _TargetEncoder = null;
                _CanvasGraphics.Dispose();
                _CanvasGraphics = null;
                _ImageAttributes.Dispose();
                _ImageAttributes = null;
                _WatermarkImage.Dispose();
                _WatermarkImage = null;
                _SourceImage.Dispose();
                _SourceImage = null;
                return _TargetMemory.GetBuffer();
            }
            else
            {
                _WatermarkImage.Dispose();
                _WatermarkImage = null;
                _SourceImage.Dispose();
                _SourceImage = null;
                return ImageBytes;
            }
        }

        /// <summary>
        /// 添加文字水印
        /// </summary>
        /// <param name="ImageBytes">byte[] 源圖數據</param>
        /// <param name="WatermarkText">string 水印文本</param>
        /// <param name="FontName">string 字體名稱</param>
        /// <param name="FontSize">int 字體大小</param>
        /// <param name="Position">PositionMode 位置</param>
        /// <returns>byte[] 目標圖數據</returns>
        public static byte[] TextWatermark(byte[] ImageBytes, string WatermarkText, string FontName, int FontSize, PositionMode Position)
        {
            Image _SourceImage = Image.FromStream(new MemoryStream(ImageBytes));
            MemoryStream _TargetMemory = new MemoryStream();
            Graphics _CanvasGraphics = Graphics.FromImage(_SourceImage);
            Font _CanvasFont = new Font(FontName, FontSize, FontStyle.Regular, GraphicsUnit.Pixel);
            SizeF _CanvasSize = _CanvasGraphics.MeasureString(WatermarkText, _CanvasFont);
            float _XPos = 0;
            float _YPos = 0;
            switch (Position)
            {
                case PositionMode.TopLeft:
                    _XPos = (int)(_SourceImage.Width * (float).01);
                    _YPos = (int)(_SourceImage.Height * (float).01);
                    break;
                case PositionMode.TopRight:
                    _XPos = (int)((_SourceImage.Width * (float).99) - (_CanvasSize.Width));
                    _YPos = (int)(_SourceImage.Height * (float).01);
                    break;
                case PositionMode.Middle:
                    _XPos = (int)((_SourceImage.Width * (float).50) - (_CanvasSize.Width / 2));
                    _YPos = (int)((_SourceImage.Height * (float).50) - (_CanvasSize.Height / 2));
                    break;
                case PositionMode.BottomLeft:
                    _XPos = (int)(_SourceImage.Width * (float).01);
                    _YPos = (int)((_SourceImage.Height * (float).99) - _CanvasSize.Height);
                    break;
                case PositionMode.BottomRight:
                    _XPos = (int)((_SourceImage.Width * (float).99) - _CanvasSize.Width);
                    _YPos = (int)((_SourceImage.Height * (float).99) - _CanvasSize.Height);
                    break;
            }
            if (_XPos > 0 && _YPos > 0 && (_XPos + _CanvasSize.Width) < _SourceImage.Width && (_YPos + +_CanvasSize.Height) < _SourceImage.Height)
            {
                int _Offset = (FontSize > 20 ? 2 : 1);
                _CanvasGraphics.TextRenderingHint = TextRenderingHint.AntiAlias;
                _CanvasGraphics.DrawString(WatermarkText, _CanvasFont, new SolidBrush(Color.FromArgb(75, Color.White)), _XPos + _Offset, _YPos + _Offset);
                _CanvasGraphics.DrawString(WatermarkText, _CanvasFont, new SolidBrush(Color.FromArgb(75, Color.Black)), _XPos, _YPos);
            }
            EncoderParameters _TargetEncoder = new EncoderParameters(1);
            _TargetEncoder.Param[0] = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, (long)100);
            ImageCodecInfo _TargetCodec = GetEncoderInfo("image/jpeg");
            if (_TargetCodec != null)
            {
                _SourceImage.Save(_TargetMemory, _TargetCodec, _TargetEncoder);
            }
            else
            {
                _SourceImage.Save(_TargetMemory, ImageFormat.Jpeg);
            }
            _TargetEncoder.Dispose();
            _TargetEncoder = null;
            _CanvasGraphics.Dispose();
            _CanvasGraphics = null;
            _SourceImage.Dispose();
            _SourceImage = null;
            return _TargetMemory.GetBuffer();
        }

        /// <summary>
        /// 獲取剪切目標尺寸
        /// </summary>
        /// <param name="Source">Rectangle 源圖尺寸</param>
        /// <param name="Width">int 寬度</param>
        /// <param name="Height">int 高度</param>
        /// <returns>Rectangle 縮放後的尺寸</returns>
        private static Rectangle GetCutRect(Rectangle Source, int Width, int Height)
        {
            if (Source.Width < Width || Source.Height < Height)
            {
                int _TargetX = (Source.Width < Width ? (int)Math.Floor(((double)Width - (double)Source.Width) / 2) : 0);
                int _TargetY = (Source.Height < Height ? (int)Math.Floor(((double)Height - (double)Source.Height) / 2) : 0);
                int _TargetWidth = (Source.Width < Width ? Source.Width : Width);
                int _TargetHeight = (Source.Height < Height ? Source.Height : Height);
                return new Rectangle(_TargetX, _TargetY, _TargetWidth, _TargetHeight);
            }
            else
            {
                return new Rectangle(0, 0, Width, Height);
            }
        }

        /// <summary>
        /// 獲取剪切源圖尺寸
        /// </summary>
        /// <param name="Source">Rectangle 源圖尺寸</param>
        /// <param name="Position">PositionMode 目標位置</param>
        /// <param name="Width">int 寬度</param>
        /// <param name="Height">int 高度</param>
        /// <returns>Rectangle 縮放後的尺寸</returns>
        private static Rectangle GetCutRect(Rectangle Source, PositionMode Position, int Width, int Height)
        {
            int _TargetX;
            int _TargetY;
            int _TargetWidth;
            int _TargetHeight;
            if (Source.Width > Width && Source.Height > Height)
            {
                double _PresentWidth = ((double)Source.Width / (double)Width);
                double _PresentHeight = ((double)Source.Height / (double)Height);
                if (_PresentWidth > _PresentHeight)
                {
                    _TargetWidth = (int)Math.Floor(_PresentHeight * (double)Width);
                    _TargetHeight = Source.Height;
                }
                else
                {
                    _TargetWidth = Source.Width;
                    _TargetHeight = (int)Math.Floor(_PresentWidth * (double)Height);
                }
                Console.WriteLine(_TargetWidth + "|" + _TargetHeight);
            }
            else
            {
                _TargetWidth = (Source.Width > Width ? Width : Source.Width);
                _TargetHeight = (Source.Height > Height ? Height : Source.Height);
            }
            switch (Position)
            {
                case PositionMode.TopLeft:
                    _TargetX = 0;
                    _TargetY = 0;
                    break;
                case PositionMode.TopRight:
                    _TargetX = (int)Math.Floor(((double)Source.Width - (double)_TargetWidth) / 2);
                    _TargetY = 0;
                    break;
                case PositionMode.BottomLeft:
                    _TargetX = (int)Math.Floor(((double)Source.Width - (double)_TargetWidth) / 2);
                    _TargetY = Height - _TargetHeight;
                    break;
                case PositionMode.BottomRight:
                    _TargetX = Width - _TargetHeight;
                    _TargetY = (int)Math.Floor(((double)Source.Height - (double)_TargetHeight) / 2);
                    break;
                default:
                    _TargetX = (int)Math.Floor(((double)Source.Width - (double)_TargetWidth) / 2);
                    _TargetY = (int)Math.Floor(((double)Source.Height - (double)_TargetHeight) / 2);
                    break;
            }
            return new Rectangle(_TargetX, _TargetY, _TargetWidth, _TargetHeight);
        }

        /// <summary>
        /// 獲取縮放後的尺寸
        /// </summary>
        /// <param name="Source">Rectangle 源圖尺寸</param>
        /// <param name="Size">double 縮放參數</param>
        /// <returns>Rectangle 縮放後的尺寸</returns>
        private static Rectangle GetZoomRect(Rectangle Source, double Size)
        {
            if (Size > 1)
            {
                if (Source.Width > Source.Height)
                {
                    return new Rectangle(0, 0, (int)Math.Floor(Size), (int)Math.Floor((double)Source.Height * (Size / (double)Source.Width)));
                }
                else
                {
                    return new Rectangle(0, 0, (int)Math.Floor((double)Source.Width * (Size / (double)Source.Height)), (int)Math.Floor(Size));
                }
            }
            else
            {
                return new Rectangle(0, 0, (int)Math.Floor((double)Source.Width * Size), (int)Math.Floor((double)Source.Height * Size));
            }
        }

        /// <summary>
        /// 填充目標位置
        /// </summary>
        /// <param name="Source">Rectangle 源圖尺寸</param>
        /// <param name="Position">PositionMode 目標位置</param>
        /// <param name="Width">int 寬度</param>
        /// <param name="Height">int 高度</param>
        /// <returns>Rectangle 縮放後的尺寸</returns>
        private static Rectangle GetCenterRect(Rectangle Source, PositionMode Position, int Width, int Height)
        {
            int _TargetX;
            int _TargetY;
            int _TargetWidth;
            int _TargetHeight;
            if (Source.Width > Width || Source.Height > Height)
            {
                double _PresentWidth = ((double)Width / (double)Source.Width);
                double _PresentHeight = ((double)Height / (double)Source.Height);
                if (_PresentWidth > _PresentHeight)
                {
                    _TargetWidth = (int)Math.Floor(_PresentHeight * (double)Source.Width);
                    _TargetHeight = Height;
                }
                else
                {
                    _TargetWidth = Width;
                    _TargetHeight = (int)Math.Floor(_PresentWidth * (double)Source.Height);
                }
            }
            else
            {
                _TargetWidth = Source.Width;
                _TargetHeight = Source.Height;
            }
            switch (Position)
            {
                case PositionMode.TopLeft:
                    _TargetX = 0;
                    _TargetY = 0;
                    break;
                case PositionMode.TopRight:
                    _TargetX = (int)Math.Floor(((double)Width - (double)_TargetWidth) / 2);
                    _TargetY = 0;
                    break;
                case PositionMode.BottomLeft:
                    _TargetX = (int)Math.Floor(((double)Width - (double)_TargetWidth) / 2);
                    _TargetY = Height - _TargetHeight;
                    break;
                case PositionMode.BottomRight:
                    _TargetX = Width - _TargetHeight;
                    _TargetY = (int)Math.Floor(((double)Height - (double)_TargetHeight) / 2);
                    break;
                default:
                    _TargetX = (int)Math.Floor(((double)Width - (double)_TargetWidth) / 2);
                    _TargetY = (int)Math.Floor(((double)Height - (double)_TargetHeight) / 2);
                    break;
            }
            return new Rectangle(_TargetX, _TargetY, _TargetWidth, _TargetHeight);
        }

        /// <summary>
        /// 獲取指定圖片數據類型
        /// </summary>
        /// <param name="TargetMimeType">string 數據類型</param>
        /// <returns>ImageCodecInfo 返回圖像參數</returns>
        private static ImageCodecInfo GetEncoderInfo(string TargetMimeType)
        {
            ImageCodecInfo[] _Codec = ImageCodecInfo.GetImageEncoders();
            for (int j = 0; j < _Codec.Length; ++j)
            {
                if (_Codec[j].MimeType == TargetMimeType)
                {
                    return _Codec[j];
                }
            }
            return null;
        }