MYBLOG

using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace MyApp.AppFunction
{
    public enum WatermarkPosition
    {
        /// <summary>  
        /// 左上  
        /// </summary>  
        LeftTop,
        /// <summary>  
        /// 左中  
        /// </summary>  
        Left,
        /// <summary>  
        /// 左下  
        /// </summary>  
        LeftBottom,
        /// <summary>  
        /// 正上  
        /// </summary>  
        Top,
        /// <summary>  
        /// 正中  
        /// </summary>  
        Center,
        /// <summary>  
        /// 正下  
        /// </summary>  
        Bottom,
        /// <summary>  
        /// 右上  
        /// </summary>  
        RightTop,
        /// <summary>  
        /// 右中  
        /// </summary>  
        Right,
        /// <summary>  
        /// 右下  
        /// </summary>  
        RightBottom
    }

    public class WatermarkTool
    {
        /// <summary>
        /// 设置传入图片的透明度
        /// </summary>
        /// <param name="bm"></param>
        /// <param name="transparence"></param>
        /// <returns></returns>
        public Bitmap SetTransparence(Bitmap bm, float transparence)
        {
            if (transparence == 0.0f || transparence == 1.0f)
                throw new ArgumentException("透明度值只能在0.0f~1.0f之间");
            float[][] floatArray =   
            {  
                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, transparence, 0.0f },  
                new float[] { 0.0f, 0.0f, 0.0f, 0.0f, 1.0f }   
            };
            ImageAttributes imageAttributes = new ImageAttributes();
            imageAttributes.SetColorMatrix(new ColorMatrix(floatArray), ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
            Bitmap bitmap = new Bitmap(bm.Width, bm.Height);
            Graphics graphics = Graphics.FromImage(bitmap);
            graphics.DrawImage(bm, new Rectangle(0, 0, bm.Width, bm.Height), 0, 0, bm.Width, bm.Height, GraphicsUnit.Pixel, imageAttributes);
            graphics.Dispose();
            imageAttributes.Dispose();
            bm.Dispose();
            return bitmap;
        }


        /// <summary>
        /// 获取图片文件格式
        /// </summary>
        /// <param name="format"></param>
        /// <returns></returns>
        private ImageFormat GetImageFormat(string format)
        {
            switch (format)
            {
                case ".bmp":
                    return ImageFormat.Bmp;
                case ".emf":
                    return ImageFormat.Emf;
                case ".exif":
                    return ImageFormat.Exif;
                case ".gif":
                    return ImageFormat.Gif;
                case ".ico":
                    return ImageFormat.Icon;
                case ".png":
                    return ImageFormat.Png;
                case ".tif":
                    return ImageFormat.Tiff;
                case ".tiff":
                    return ImageFormat.Tiff;
                case ".wmf":
                    return ImageFormat.Wmf;
                default:
                    return ImageFormat.Jpeg;
            }
        }

        /// <summary>
        /// 获取水印相对应的Rectangle对象
        /// </summary>
        /// <param name="positon"></param>
        /// <param name="X"></param>
        /// <param name="Y"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="i"></param>
        /// <returns></returns>
        private Rectangle GetWatermarkRectangle(WatermarkPosition positon, int X, int Y, int x, int y, int i)
        {
            switch (positon)
            {
                case WatermarkPosition.LeftTop:
                    return new Rectangle(i, i, x, y);
                case WatermarkPosition.Left:
                    return new Rectangle(i, (Y - y) / 2, x, y);
                case WatermarkPosition.LeftBottom:
                    return new Rectangle(i, Y - y - i, x, y);
                case WatermarkPosition.Top:
                    return new Rectangle((X - x) / 2, i, x, y);
                case WatermarkPosition.Center:
                    return new Rectangle((X - x) / 2, (Y - y) / 2, x, y);
                case WatermarkPosition.Bottom:
                    return new Rectangle((X - x) / 2, Y - y - i, x, y);
                case WatermarkPosition.RightTop:
                    return new Rectangle(X - x - i, i, x, y);
                case WatermarkPosition.Right:
                    return new Rectangle(X - x - i, (Y - y) / 2, x, y);
                default:
                    return new Rectangle(X - x - i, Y - y - i, x, y);
            }
        }


        /// <summary>
        /// 为图片添加水印，返回添加Bitmap对象
        /// </summary>
        /// <param name="sBitmap"></param>
        /// <param name="wBitmap"></param>
        /// <param name="position"></param>
        /// <param name="Margin">水印边距</param>
        /// <returns></returns>
        public Bitmap ImageWatermark(Bitmap SourceMap, Bitmap WaterMap, WatermarkPosition Position, int Margin)
        {
            Graphics graphics = Graphics.FromImage(SourceMap);
            graphics.DrawImage(WaterMap, GetWatermarkRectangle(Position, SourceMap.Width, SourceMap.Height, WaterMap.Width, WaterMap.Height, Margin));
            graphics.Dispose();
            WaterMap.Dispose();
            return SourceMap;
        }


        /// <summary>
        /// 为图片添加水印，并保存
        /// </summary>
        /// <param name="sBitmap"></param>
        /// <param name="wBitmap"></param>
        /// <param name="Position"></param>
        /// <param name="Margin"></param>
        /// <param name="SavePath"></param>
        public void SaveImageWatermark(Bitmap sBitmap, Bitmap wBitmap, WatermarkPosition Position, int Margin, string SavePath)
        {
            Bitmap Map = ImageWatermark(sBitmap, wBitmap, Position, Margin);
            try
            {
                Map.Save(SavePath, GetImageFormat(Path.GetExtension(SavePath)));
                Map.Dispose();
            }
            catch
            {
                throw new ArgumentException("图片保存错误");
            }
        }


        /// <summary>
        /// 当设置透明度为0时直接保存图片
        /// </summary>
        /// <param name="SourcePath"></param>
        /// <param name="SavePath"></param>
        public void SaveImageWatermark(string SourcePath, string SavePath)
        {
            Bitmap Map = new Bitmap(SourcePath);
            try
            {
                Map.Save(SavePath, GetImageFormat(Path.GetExtension(SavePath)));
                Map.Dispose();
            }
            catch
            {
                throw new ArgumentException("图片保存错误");
            }
        }


        /// <summary>
        /// 为图片添加水印
        /// </summary>
        /// <param name="SourcePath"></param>
        /// <param name="WaterMarkPath"></param>
        /// <param name="Transparence"></param>
        /// <param name="Position"></param>
        /// <param name="Margin"></param>
        /// <param name="SavePath"></param>
        public void SaveImageWatermark(string SourcePath, string WaterMarkPath, float Transparence, WatermarkPosition Position, int Margin, string SavePath)
        {
            if (string.Compare(SourcePath, SavePath) == 0)
                throw new ArgumentException("源图片与目标图片地址相同");
            if (Transparence == 0.0f)
                SaveImageWatermark(SourcePath, SavePath);
            else if (Transparence == 1.0f)
                SaveImageWatermark(new Bitmap(SourcePath), new Bitmap(WaterMarkPath), Position, Margin, SavePath);
            else
                SaveImageWatermark(new Bitmap(SourcePath), SetTransparence(new Bitmap(WaterMarkPath), Transparence), Position, Margin, SavePath);
        }

        /// <summary>
        /// 为图片添加文字水印
        /// </summary>
        /// <param name="SourcePath"></param>
        /// <param name="SavePath"></param>
        /// <param name="Text"></param>
        /// <param name="TextColor"></param>
        /// <param name="FontSize"></param>
        /// <param name="FontType"></param>
        /// <param name="Position"></param>
        public void SaveTextWatermark(string SourcePath, string SavePath, string Text, Color TextColor, int FontSize, string FontType, WatermarkPosition Position)
        {
            Image image = Image.FromFile(SourcePath);
            Bitmap bitmap = new Bitmap(image.Width, image.Height);
            Graphics graphics = Graphics.FromImage(bitmap);
            graphics.Clear(Color.White);
            graphics.DrawImage(image, new Rectangle(0, 0, image.Width, image.Height), 0, 0, image.Width, image.Height, GraphicsUnit.Pixel);
            Font font = new Font(FontType, FontSize);
            SizeF ziSizeF = new SizeF();
            ziSizeF = graphics.MeasureString(Text, font);
            float x = 0f;
            float y = 0f;
            switch (Position)
            {
                case WatermarkPosition.LeftTop:
                    x = ziSizeF.Width / 2f;
                    y = 8f;
                    break;
                case WatermarkPosition.Left:
                    x = ziSizeF.Width / 2f;
                    y = (image.Width * 1f - ziSizeF.Width) / 2f;
                    break;
                case WatermarkPosition.LeftBottom:
                    x = ziSizeF.Width / 2f;
                    y = image.Height - ziSizeF.Height;
                    break;
                case WatermarkPosition.RightTop:
                    x = image.Width * 1f - ziSizeF.Width / 2f;
                    y = 8f;
                    break;
                case WatermarkPosition.Right:
                    x = (image.Width * 1f - ziSizeF.Width) / 2f;
                    y = image.Height - ziSizeF.Height;
                    break;
                case WatermarkPosition.RightBottom:
                    x = image.Width - ziSizeF.Width;
                    y = image.Height - ziSizeF.Height;
                    break;
                case WatermarkPosition.Center:
                    x = image.Width / 2;
                    y = image.Height / 2 - ziSizeF.Height / 2;
                    break;
                case WatermarkPosition.Top:
                    x = image.Width / 2;
                    y = 8f;
                    break;
                case WatermarkPosition.Bottom:
                      x = image.Width / 2;
                      y = image.Height - ziSizeF.Height;
                    break;
            }
            try
            {
                StringFormat stringFormat = new StringFormat { Alignment = StringAlignment.Center };
                SolidBrush solidBrush = new SolidBrush(TextColor);
                graphics.DrawString(Text, font, solidBrush, x, y, stringFormat);
                solidBrush.Dispose();
                bitmap.Save(SavePath, ImageFormat.Jpeg);
            }
            catch (Exception e)
            {


            }
            finally
            {
                bitmap.Dispose();
                image.Dispose();
            }

        }

        public Bitmap TextWatermark(string SourcePath, string Text, Color TextColor, int FontSize, string FontType, WatermarkPosition Position)
        {
            Image image = Image.FromFile(SourcePath);
            Bitmap bitmap = new Bitmap(image.Width, image.Height);
            Graphics graphics = Graphics.FromImage(bitmap);
            graphics.Clear(Color.White);
            graphics.DrawImage(image, new Rectangle(0, 0, image.Width, image.Height), 0, 0, image.Width, image.Height, GraphicsUnit.Pixel);
            Font font = new Font(FontType, FontSize);
            SizeF ziSizeF = new SizeF();
            ziSizeF = graphics.MeasureString(Text, font);
            float x = 0f;
            float y = 0f;
            switch (Position)
            {
                case WatermarkPosition.LeftTop:
                    x = ziSizeF.Width / 2f;
                    y = 8f;
                    break;
                case WatermarkPosition.Left:
                    x = ziSizeF.Width / 2f;
                    y = (image.Width * 1f - ziSizeF.Width) / 2f;
                    break;
                case WatermarkPosition.LeftBottom:
                    x = ziSizeF.Width / 2f;
                    y = image.Height - ziSizeF.Height;
                    break;
                case WatermarkPosition.RightTop:
                    x = image.Width * 1f - ziSizeF.Width / 2f;
                    y = 8f;
                    break;
                case WatermarkPosition.Right:
                    x = (image.Width * 1f - ziSizeF.Width) / 2f;
                    y = image.Height - ziSizeF.Height;
                    break;
                case WatermarkPosition.RightBottom:
                    x = image.Width * 1f - ziSizeF.Width / 2f;
                    y = image.Height - ziSizeF.Height;
                    break;
                case WatermarkPosition.Center:
                    x = image.Width / 2;
                    y = image.Height / 2 - ziSizeF.Height / 2;
                    break;
                case WatermarkPosition.Top:
                    x = image.Width / 2;
                    y = 8f;
                    break;
                case WatermarkPosition.Bottom:
                    x = image.Width / 2;
                    y = image.Height - ziSizeF.Height;
                    break;
            }
            try
            {
                StringFormat stringFormat = new StringFormat { Alignment = StringAlignment.Center };
                SolidBrush solidBrush = new SolidBrush(TextColor);
                graphics.DrawString(Text, font, solidBrush, x, y, stringFormat);
                solidBrush.Dispose();
                return bitmap;
            }
            catch (Exception e)
            {

                return null;
            }
            finally
            {
                image.Dispose();
            }

        }
    }
}



 public MyApp.AppFunction.WatermarkPosition GetPosition(string ImgWaterPosition)
        {
            switch (ImgWaterPosition)
            {
                case "1":
                    return MyApp.AppFunction.WatermarkPosition.Bottom;
                case "2":
                    return MyApp.AppFunction.WatermarkPosition.Center;
                case "3":
                    return MyApp.AppFunction.WatermarkPosition.Left;
                case "4":
                    return MyApp.AppFunction.WatermarkPosition.LeftBottom;
                case "5":
                    return MyApp.AppFunction.WatermarkPosition.LeftTop;
                case "6":
                    return MyApp.AppFunction.WatermarkPosition.Right;
                case "7":
                    return MyApp.AppFunction.WatermarkPosition.RightBottom;
                case "8":
                    return MyApp.AppFunction.WatermarkPosition.RightTop;
                case "9":
                    return MyApp.AppFunction.WatermarkPosition.Top;
                default:
                    return MyApp.AppFunction.WatermarkPosition.RightBottom;
            }
        }

        //图片水印调用示例
        string WaterPath = ConfigurationManager.AppSettings["ImgWater"].ToString().Trim();
        string ImgWaterPosition = ConfigurationManager.AppSettings["ImgWaterPosition"].ToString().Trim();
        string ImgWaterMargin = ConfigurationManager.AppSettings["ImgWaterMargin"].ToString().Trim();
        WatermarkTool Water = new WatermarkTool();
        Water.ImageWatermark(originalBmp, waterBmp, GetPosition(ImgWaterPosition), Convert.ToInt32(ImgWaterMargin))

        //文字水印调用示例
        string Str_WaterText = ConfigurationManager.AppSettings["TextWater"].ToString();
        string TextWaterPosition = ConfigurationManager.AppSettings["TextWaterPosition"].ToString().Trim();
        string TextWaterFont = ConfigurationManager.AppSettings["TextWaterFont"].ToString().Trim();
        string TextWaterFontSize = ConfigurationManager.AppSettings["TextWaterFontSize"].ToString().Trim();
        string TextWaterFontColor = ConfigurationManager.AppSettings["TextWaterFontColor"].ToString().Trim();
        WatermarkTool Water = new WatermarkTool();
        Water.ImageWatermark(originalBmp, waterBmp, GetPosition(ImgWaterPosition), Convert.ToInt32(ImgWaterMargin))