图片处理项目

图片处理也是一个大项目中的一小部分，别的不多说，直接上代码吧。

 

配置文件操作基类：

  /// <summary>
    /// 配置文件操作基类
    /// </summary>
    /// <typeparam name="T">配置信息实体类</typeparam>
    public abstract class BaseConfig<T> where T : BaseConfig<T>, new()
    {
        private static string configFilePath = GetConfigPath();

        /// <summary>
        /// 实例化对象
        /// </summary>
        /// <returns>配置信息实体</returns>
        public static T Instance
        {
            get
            {
                T t = new T();
                return t.Get();
            }
        }

        private T Get()
        {
            Type configType = typeof(T);

            if (!File.Exists(configFilePath))
            {
                new T();
            }

            using (var xmlTextReader = new XmlTextReader(configFilePath))
            {
                var xmlSerializer = new XmlSerializer(configType);
                return (T)xmlSerializer.Deserialize(xmlTextReader);
            }
        }


        /// <summary>
        /// 配置文件路径
        /// </summary>
        protected virtual string ConfigPath
        {
            get
            {
                return configFilePath;
            }

            set
            {
                configFilePath = value;
            }
        }

        /// <summary>
        /// 保存配置文件
        /// </summary>
        public void Save()
        {
            this.Save(this as T);
        }

        /// <summary>
        /// 保存配置文件
        /// </summary>
        /// <param name="configInfo">配置信息临时变量</param>
        protected void Save(T configInfo)
        {
            Type configType = typeof(T);
            var xmlSerializer = new XmlSerializer(configType);
            using (var xmlTextWriter = new XmlTextWriter(configFilePath, Encoding.UTF8))
            {
                xmlTextWriter.Formatting = Formatting.Indented;
                var xmlNamespace = new XmlSerializerNamespaces();
                xmlNamespace.Add(string.Empty, string.Empty);
                xmlSerializer.Serialize(xmlTextWriter, configInfo, xmlNamespace);
            }
        }

        /// <summary>
        /// 获得配置文件名称
        /// </summary>
        /// <returns>配置文件所在路径</returns>
        private static string GetConfigPath()
        {
            string configStr = typeof(T).Name;
            if (configStr.ToLower().EndsWith("config"))
            {
                configStr = configStr.Substring(0, configStr.Length - 6);
            }
            string tmp = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName;
            tmp = System.Environment.CurrentDirectory;

            return string.Concat(tmp, "\\", configStr, ".config");
        }
    }

 

缩略图处理：

缩略模式：

  /// <summary>
    /// 缩略模式
    /// HW：按照指定高宽进行设置缩略(可能变形)
    /// H：指定高，宽按比例
    /// W：指定宽，高按比例
    /// CUTHW： 指定高宽裁减（不变形） 
    /// CUT：指定坐标和高宽进行裁剪某一区域
    /// </summary>
    public enum ThumbnailMode
    {
        HW = 1,
        H = 2,
        W = 3,
        CUTHW = 4,
        CUT = 5
    }

缩略配置：

    public class ThumbnailConfig : BaseConfig<ThumbnailConfig>
    {
        public ThumbnailConfig()
        {
            ThumMode = 1;
            ThumbnailX = 0;
            ThumbnailY = 0;
            ThumbnailWidth = 100;
            ThumbnailHeight = 200;
        }

        /// <summary>
        /// 缩略图模式
        /// </summary>
        public int ThumMode { get; set; }

        /// <summary>
        /// 缩略图保存路径
        /// </summary>
        public string ThumbnailPath { get; set; }

        /// <summary>
        /// 缩略坐标X
        /// </summary>
        public int ThumbnailX { get; set; }

        /// <summary>
        /// 缩略坐标Y
        /// </summary>
        public int ThumbnailY { get; set; }


        /// <summary>
        /// 缩略宽度
        /// </summary>
        public int ThumbnailWidth { get; set; }

        /// <summary>
        /// 缩略高度
        /// </summary>
        public int ThumbnailHeight { get; set; }
    }

缩略图处理类：

    /// <summary>
    /// 缩略图处理类
    /// </summary>
    public class Thumbnail
    {
        private ThumbnailConfig config = null;
        private byte[] imgBuffer;

        public ThumbnailConfig Config
        {
            get
            {
                return config;
            }
            set
            {
                config = value;
            }
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="filePath">文件路径</param>
        /// <param name="outputPath">输出文件路径</param>
        /// <param name="x">x坐标</param>
        /// <param name="y">y坐标</param>
        /// <param name="width">缩略/裁剪宽度</param>
        /// <param name="height">缩略/裁剪高度</param>
        /// <param name="mode">缩略类型</param>
        public Thumbnail(string filePath, string outputPath, int x, int y, int width, int height, ThumbnailMode mode)
        {
            this.Config = new ThumbnailConfig();
            this.FilePath = filePath;
            Config.ThumbnailPath = outputPath;
            Config.ThumbnailX = x;
            Config.ThumbnailY = y;
            Config.ThumbnailWidth = width;
            Config.ThumbnailHeight = height;
            Config.ThumMode = (int)mode;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="filePath"></param>
        /// <param name="outputPath"></param>
        /// <param name="config"></param>
        public Thumbnail(string filePath, ThumbnailConfig config)
        {
            this.Config = config;
            this.FilePath = filePath;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="buffer"></param>
        /// <param name="config"></param>
        public Thumbnail(byte[] buffer, ThumbnailConfig config)
        {
            this.imgBuffer = buffer;
            this.Config = config;
        }

        /// <summary>
        /// 文件路径
        /// </summary>
        public string FilePath { get; set; }

        #region 保存缩略图
        /// <summary>
        /// 保存缩略图
        /// </summary>
        public void MakeThumbnailImage()
        {
            this.MakeThumbnailImage(false);
        }
        #endregion

        #region 预览缩略图
        /// <summary>
        /// 获得缩略图后的图片流
        /// </summary>
        /// <returns></returns>
        public byte[] GetThumbnailStream()
        {
            if (!string.IsNullOrEmpty(this.FilePath) && this.imgBuffer == null)
            {
                if (this.FilePath.Contains("http://"))
                {
                    MakeRemoteThumbnailImage(null, (ThumbnailMode)Config.ThumMode, true);
                }
            }
            MakeThumbnailImage(true);
            if (imgBuffer != null)
            {
                return imgBuffer;
            }
            return null;
        }
        #endregion

        #region 远程图片
        /// <summary>
        /// 根据URL获取图片流
        /// </summary>
        /// <param name="url">图片地址</param>
        /// <returns></returns>
        private Stream GetRemoteImage(string url)
        {
            HttpWebRequest request = (HttpWebRequest)HttpWebRequest.Create(url);
            request.ContentLength = 0;
            request.Timeout = 2000;
            HttpWebResponse response = null;

            try
            {
                response = (HttpWebResponse)request.GetResponse();
                return response.GetResponseStream();
            }
            catch
            {
                return null;
            }
        }

        /// <summary>
        /// 制作远程图片缩略图
        /// </summary>
        /// <param name="outputPath"></param>
        /// <param name="width"></param>
        /// <param name="height"></param>
        /// <param name="mode"></param>
        private void MakeRemoteThumbnailImage(string outputPath, ThumbnailMode mode, bool isPreview)
        {
            if (string.IsNullOrEmpty(this.FilePath))
            {
                return;
            }
            Stream stream = GetRemoteImage(this.FilePath);
            if (stream == null)
            {
                return;
            }
            Image img = Image.FromStream(stream);
            MakeThumbnailImage(isPreview);
        }
        #endregion

        #region 制作缩略图
        /// <summary>
        /// 制作缩略图
        /// </summary>
        /// <param name="img"></param>
        /// <param name="mode"></param>
        /// <returns></returns>
        private void MakeThumbnailImage(bool isPreview)
        {
            Image sourceImg = null;
            if (string.IsNullOrWhiteSpace(this.FilePath) || !File.Exists(this.FilePath))
            {
                if (this.imgBuffer != null)
                {
                    sourceImg = ImageDealHelper.StreamToImage(imgBuffer);
                }
            }
            else
            {
                sourceImg = Image.FromFile(this.FilePath);
            }

            if (isPreview == false && string.IsNullOrEmpty(this.Config.ThumbnailPath))
            {
                Config.ThumbnailPath = GetThumbnailFilePath(this.FilePath);
            }

            //如果传值超过原文件的高宽，将原文件的高宽设置为缩略高宽
            int thumbWidth = Config.ThumbnailWidth;
            int thumbHeight = Config.ThumbnailHeight;
            thumbWidth = thumbWidth > sourceImg.Width ? sourceImg.Width : thumbWidth;
            thumbHeight = thumbHeight > sourceImg.Height ? sourceImg.Height : thumbHeight;

            if (sourceImg.RawFormat.Guid == ImageFormat.Gif.Guid)
            {
                int sourceImgSize = sourceImg.Width > sourceImg.Height ? sourceImg.Width : sourceImg.Height;
                int customSize = thumbWidth > thumbHeight ? thumbWidth : thumbHeight;
                double rate = (double)customSize / (double)sourceImgSize;
                //Rectangle rec = GetRectangle(mode);
                sourceImg.Dispose();
                if (imgBuffer != null)
                {
                    imgBuffer = GifHelper.GetThumbnail(imgBuffer, rate, this.Config.ThumbnailPath, isPreview);
                }
                else
                {
                    imgBuffer = GifHelper.GetThumbnail(this.FilePath, rate, Config.ThumbnailPath, isPreview);
                }
                //imgBuffer = GifHelper.GetThumbnail(this.FilePath, this.Width, this.Height, rec, this.ThumbnailPath, isPreview);    //动态图片会变形
                return;
            }

            Graphics g = Graphics.FromImage(sourceImg);
            Rectangle rec = GetRectangle(sourceImg, (ThumbnailMode)Config.ThumMode);

            Bitmap bitmap = new Bitmap(thumbWidth, thumbHeight);
            Graphics graphics = Graphics.FromImage(bitmap);
            graphics.Clear(Color.Transparent);
            graphics.InterpolationMode = InterpolationMode.High;
            graphics.SmoothingMode = SmoothingMode.HighQuality;
            graphics.FillRectangle(Brushes.White, 0, 0, bitmap.Width, bitmap.Height);
            graphics.DrawImage(sourceImg, new Rectangle(0, 0, thumbWidth, thumbHeight), rec, GraphicsUnit.Pixel);

            try
            {
                if (isPreview)
                {
                    MemoryStream ms = new MemoryStream();
                    bitmap.Save(ms, sourceImg.RawFormat);
                    imgBuffer = ms.GetBuffer();
                }
                else
                {
                    bitmap.Save(Config.ThumbnailPath, sourceImg.RawFormat);
                }
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                sourceImg.Dispose();
                bitmap.Dispose();
                graphics.Dispose();
            }
        }
        #endregion

        #region 获得缩略图的位置和大小
        /// <summary>
        /// 获取缩略图的位置和大小
        /// </summary>
        /// <param name="sourceImg"></param>
        /// <param name="mode"></param>
        /// <returns></returns>
        private Rectangle GetRectangle(Image sourceImg, ThumbnailMode mode)
        {
            int x = 0;
            int y = 0;
            int sh = sourceImg.Height;
            int sw = sourceImg.Width;
            int thumbWidth = Config.ThumbnailWidth;
            int thumbHeight = Config.ThumbnailHeight;
            switch (mode)
            {
                case ThumbnailMode.HW:
                    break;
                case ThumbnailMode.H:
                    thumbWidth = sourceImg.Height * thumbWidth / sourceImg.Width;
                    break;
                case ThumbnailMode.W:
                    thumbHeight = sourceImg.Width * thumbHeight / sourceImg.Height;
                    break;
                case ThumbnailMode.CUTHW:
                    if ((double)sourceImg.Width / (double)sourceImg.Height > (double)thumbWidth / (double)thumbHeight)
                    {
                        sh = sourceImg.Height;
                        sw = sourceImg.Height * thumbWidth / thumbHeight;
                        y = 0;
                        x = (sourceImg.Width - sw) / 2;
                    }
                    else
                    {
                        sw = sourceImg.Width;
                        sh = sourceImg.Width * thumbHeight / thumbWidth;
                        x = 0;
                        y = (sourceImg.Height - sh) / 2;
                    }
                    break;
                case ThumbnailMode.CUT:
                    x = Config.ThumbnailX;
                    y = Config.ThumbnailY;
                    sw = Config.ThumbnailWidth;
                    sh = Config.ThumbnailHeight;
                    break;
                default: break;
            }
            return new Rectangle(x, y, sw, sh);
        }
        #endregion

        #region 获得缩略图文件保存名称
        /// <summary>
        /// 获得缩略图文件保存名称
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public string GetThumbnailFilePath(string filePath)
        {
            string extention = Path.GetExtension(this.FilePath);
            string fileName = Path.GetFileNameWithoutExtension(this.FilePath);
            string fullPath = Path.GetFullPath(this.FilePath);
            return string.Concat(fullPath, fileName, "_", Config.ThumbnailWidth, "_", Config.ThumbnailHeight, extention);
        }
        #endregion
    }

 

水印使用助手类：

水印类型

 

    /// <summary>
    /// 水印图片类型
    /// TEXT:文本类型
    /// Image:图片类型
    /// </summary>
    public enum WatermarkType
    {
        Text = 1,
        Image = 2
    }

 

水印位置：

    /// <summary>
    /// 水印模式
    /// Center:中间;
    /// CenterUp:中上;
    /// CenterDown:中下;
    /// LeftUp:左上;
    /// LeftDown:左下;
    /// RightUp:右上;
    /// RightDown:右下;
    /// Random:随机;
    /// Manual:手动设置
    /// </summary>
    public enum WatermarkPosition
    {
        Center = 1,
        CenterUp = 2,
        CenterDown = 3,
        LeftUp = 4,
        LeftDown = 5,
        RightUp = 6,
        RightDown = 7,
        Random = 8,
        Manual = 9
    }

水印配置信息类：

    [Serializable]
    public class WaterMarkConfig : BaseConfig<WaterMarkConfig>
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        public WaterMarkConfig()
        {
            IsEnableWatermark = false;
            Type = (int)WatermarkType.Image;
            WatermarkImagePath = "~/Content/";
            Opacity = 100;
            Position = (int)WatermarkPosition.LeftDown;
            Quality = 100;
            Text = "动易网络";
            FontSize = 24;
            FontColor = ColorTranslator.ToHtml(Color.Black);
            FontStyle = 1;
            FontBroderColor = ColorTranslator.ToHtml(Color.Black);
            FontBroderSize = 0;
            //     WaterMarkSavePath = PathHelper.GetFilePath("~/Content/");
        }

        /// <summary>
        /// 是否开启水印处理功能
        /// </summary>
        [CategoryAttribute("常用"), Description("是否开启水印处理功能")]
        public bool IsEnableWatermark { get; set; }

        /// <summary>
        /// 水印类型
        /// </summary>
        [CategoryAttribute("常用"), Description("{1:'文本类型',2:'图片类型'}")]
        public int Type { get; set; }

        #region 文字水印
        /// <summary>
        /// 水印文字内容
        /// </summary>
        [CategoryAttribute("文字水印"), Description("水印文字内容")]
        public string Text { get; set; }

        /// <summary>
        /// 文字大小
        /// </summary>
        [CategoryAttribute("文字水印"), Description("文字大小")]
        public int FontSize { get; set; }

        /// <summary>
        /// 字体名称
        /// </summary>
        [CategoryAttribute("文字水印"), Description("字体名称")]
        public string FontFamily { get; set; }

        /// <summary>
        /// 字体颜色
        /// </summary>
        [CategoryAttribute("文字水印"), Description("字体颜色")]
        public string FontColor { get; set; }

        /// <summary>
        /// 字体样式
        /// </summary>
        [CategoryAttribute("文字水印"), Description("字体样式")]
        public int FontStyle { get; set; }

        /// <summary>
        /// 是否设置字体阴影
        /// </summary>
        [CategoryAttribute("文字水印"), Description("是否设置字体阴影")]
        public bool IsSetBadge { get; set; }

        /// <summary>
        /// 横向偏移量
        /// </summary>
        [CategoryAttribute("文字水印"), Description("横向偏移量，设置背景阴影的横向偏移量，设置为负数为左偏移，正数为右偏移，只有在开启阴影效果后才有效果")]
        public int OffsetU { get; set; }

        /// <summary>
        /// 纵向偏移量
        /// </summary>
        [CategoryAttribute("文字水印"), Description("纵向偏移量，设置背景阴影的横向偏移量，设置为负数为上偏移，正数为下偏移，只有在开启阴影效果后才有效果")]

        public int OffsetV { get; set; }

        /// <summary>
        /// 阴影颜色
        /// </summary>
        [CategoryAttribute("文字水印"), Description("阴影颜色")]
        public string ShadowColor { get; set; }

        /// <summary>
        /// 阴影大小
        /// </summary>
        [CategoryAttribute("文字水印"), Description("阴影大小,设置阴影的大小，只有在开启阴影效果后才有效果")]
        public int ShadowSize { get; set; }

        [CategoryAttribute("文字水印"), Description("字体边框大小")]
        public int FontBroderSize { get; set; }

        [CategoryAttribute("文字水印"), Description("字体边框颜色")]
        public string FontBroderColor { get; set; }
        #endregion

        #region 图片水印
        /// <summary>
        /// 水印图片地址
        /// </summary>
        [CategoryAttribute("图片水印"), Description("水印图片地址")]
        public string WatermarkImagePath { get; set; }

        /// <summary>
        /// 不透明度(最高可设置为10)
        /// </summary>
        [CategoryAttribute("图片水印"), Description("不透明度")]
        public Single Opacity { get; set; }
        #endregion

        /// <summary>
        /// 水印位置
        /// </summary>
       [CategoryAttribute("常用"), Description("水印标注位置，{1:'中间',2:'中上',3:'中下',4:'左上',5:'左下',6:'右上',7:'右下',8:'随机',9:'自定义'}")]
        public int Position { get; set; }

        [CategoryAttribute("常用"), Description("偏移量，当设置非自定义标注位置时，可设置偏移量进行适当的调整")]
        public float Offset { get; set; }

        /// <summary>
        ///   水印坐标位置：X
        /// </summary>
          [CategoryAttribute("常用"), Description("水印坐标位置X：设置水印图片显示坐标，只有在水印位置标注为自定义时才有效")]
        public float X { get; set; }

        /// <summary>
        /// 水印坐标位置：Y
        /// </summary>
           [CategoryAttribute("常用"), Description("水印坐标位置Y：设置水印图片显示坐标，只有在水印位置标注为自定义时才有效")]
 
        public float Y { get; set; }

        /// <summary>
        /// 水印质量(最高可设置为100)
        /// </summary>
        [CategoryAttribute("常用"), Description("水印质量")]
        public int Quality { get; set; }

        /// <summary>
        /// 水印图片存放路径
        /// </summary>
        [CategoryAttribute("常用"), Description("水印图片存放路径，即最后生成的水印图片存放的路径")]
        public string WaterMarkSavePath { get; set; }

    }

水印处理类：

   /// <summary>
    /// 水印处理类
    /// </summary>
    public class WaterMark
    {
        private WaterMarkConfig config = null;
        public Image sourceImg;
        private byte[] imgBuffer;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="filePath">源文件路径</param>
        /// <param name="outputPath">水印文件保存路径</param>
        /// <param name="config">水印配置信息</param>
        public WaterMark(string sourceFilePath, string outputPath, WaterMarkConfig config)
        {
            this.SourceImgPath = sourceFilePath;
            this.FileSavePath = outputPath;
            this.Config = config;
        }

        public WaterMark(byte[] buffer, string outputPath, WaterMarkConfig config)
        {
            imgBuffer = buffer;
            this.FileSavePath = outputPath;
            this.Config = config;
        }

        /// <summary>
        /// 水印配置信息
        /// </summary>
        public WaterMarkConfig Config
        {
            get
            {
                return config;
            }
            set
            {
                config = value;
            }
        }

        /// <summary>
        /// 原图片路径
        /// </summary>
        public string SourceImgPath { get; set; }

        /// <summary>
        /// 文件保存路径
        /// </summary>
        public string FileSavePath { get; set; }

        #region 制作水印
        /// <summary>
        /// 制作水印
        /// </summary>
        public void MakeWaterMark()
        {
            MakeWaterMark(false);
        }

        /// <summary>
        /// 制作水印
        /// </summary>
        /// <param name="isPreview">是否为预览状态</param>
        private void MakeWaterMark(bool isPreview)
        {
            if (null == Config)
            {
                return;
            }
            //判断是否开启水印功能
            if (Config.IsEnableWatermark == false)
            {
                return;
            }

            if (string.IsNullOrEmpty(this.SourceImgPath) || !File.Exists(this.SourceImgPath))
            {
                if (imgBuffer != null)
                {
                    this.sourceImg = ImageDealHelper.StreamToImage(imgBuffer);
                }
            }
            else
            {
                this.sourceImg = Image.FromFile(this.SourceImgPath);
            }

            if (!isPreview)
            {
                string fileExtention = Path.GetExtension(this.SourceImgPath);
                this.FileSavePath = GetFileSavePath(this.FileSavePath, fileExtention);
            }

            if ((WatermarkType)config.Type == WatermarkType.Image)
            {
                this.sourceImg = MakeImageWaterMark(isPreview);
            }
            else
            {
                this.sourceImg = MakeTextWaterMark(isPreview);
            }
            if (null == this.sourceImg)
            {
                return;
            }
            //设置是生成质量
            ImageCodecInfo ici = null;
            EncoderParameters ep = null;
            SetQuality(ref ici, ref ep, Config.Quality);

            if (ici != null && isPreview == true)
            {
                MemoryStream ms = new MemoryStream();
                this.sourceImg.Save(ms, this.sourceImg.RawFormat);
                imgBuffer = ms.GetBuffer();
            }
            else
            {
                this.sourceImg.Save(this.FileSavePath, ici, ep);
            }
            this.sourceImg.Dispose();
            //if (!isPreview)
            //{
            //  File.Delete(this.SourceImgPath);       //生成水印图后，将原图删除
            //}
        }
        #endregion

        #region 文字水印
        /// <summary>
        /// 文字水印
        /// </summary>
        /// <param name="image"></param>
        /// <returns></returns>
        private Image MakeTextWaterMark(bool isPreview)
        {
            Graphics g = Graphics.FromImage(this.sourceImg);

            //设置质量
            g.InterpolationMode = InterpolationMode.High;
            g.SmoothingMode = SmoothingMode.HighQuality;
            FontStyle fontStyle = (FontStyle)Config.FontStyle;
            Font font = new Font(Config.FontFamily, Config.FontSize, fontStyle);

            //设置位置
            SizeF imageSize = new SizeF(this.sourceImg.Width, this.sourceImg.Height);
            SizeF watermarkSize = g.MeasureString(Config.Text, font);
            PointF point = CalculationPoint(imageSize, watermarkSize);

            if (this.sourceImg.RawFormat.Guid == ImageFormat.Gif.Guid)
            {
                if (this.sourceImg != null)
                {
                    this.sourceImg.Dispose();
                    g.Dispose();
                }
                if (imgBuffer != null)
                {
                    imgBuffer = GifHelper.SmartWaterMark(imgBuffer, Config.Text, ColorTranslator.FromHtml(Config.FontColor), font, point, this.FileSavePath, isPreview);
                }
                else
                {
                    imgBuffer = GifHelper.SmartWaterMark(this.SourceImgPath, Config.Text, ColorTranslator.FromHtml(Config.FontColor), font, point, this.FileSavePath, isPreview);
                }
                return null;
            }

            //设置边框
            if (Config.FontBroderSize > 0)
            {
                SetBorder(g, point, watermarkSize);
            }

            //设置文字阴影
            if (Config.IsSetBadge)
            {
                SetBadge(this.sourceImg, font, point, watermarkSize);
            }
            g.DrawString(Config.Text, font, new SolidBrush(ColorTranslator.FromHtml(Config.FontColor)), point);
            g.Dispose();
            return this.sourceImg;
        }
        #endregion

        #region 制作图片水印
        /// <summary>
        /// 制作图片水印
        /// </summary>
        /// <param name="SourceImg"></param>
        /// <returns></returns>
        private Image MakeImageWaterMark(bool isPreview)
        {
            Graphics g = Graphics.FromImage(sourceImg);

            //设置质量
            g.InterpolationMode = InterpolationMode.High;
            g.SmoothingMode = SmoothingMode.HighQuality;

            string waterImgPath = Path.GetFullPath(Config.WatermarkImagePath);
            //判断当前水印图片是否存在
            if (string.IsNullOrEmpty(waterImgPath) || !File.Exists(waterImgPath))
            {
                return null;
            }
            Bitmap watermarkImg = new Bitmap(waterImgPath);
            //透明属性
            float opacity = Config.Opacity / 100.0F;
            ImageAttributes imageAttr = GetOpacityAttribute(opacity);

            //设置位置
            SizeF imageSize = new SizeF(sourceImg.Width, sourceImg.Height);
            SizeF watermarkSize = new SizeF(watermarkImg.Width, watermarkImg.Height);
            PointF point = CalculationPoint(imageSize, watermarkSize);
            Rectangle rec = new Rectangle((int)point.X, (int)point.Y, (int)watermarkSize.Width, (int)watermarkSize.Height);
            if (this.sourceImg.RawFormat == ImageFormat.Gif)
            {
                this.sourceImg.Dispose();
                g.Dispose();
                imgBuffer = GifHelper.WaterMark(this.SourceImgPath, watermarkImg, rec, watermarkSize, imageAttr, this.FileSavePath, isPreview);
                return null;
            }

            g.DrawImage(watermarkImg, rec, 0, 0, watermarkImg.Width, watermarkImg.Height, GraphicsUnit.Pixel, imageAttr);
            watermarkImg.Dispose();
            return sourceImg;
        }
        #endregion

        #region 设置边框
        /// <summary>
        /// 设置边框
        /// </summary>
        /// <param name="g"></param>
        /// <param name="point"></param>
        /// <param name="watermarkSize"></param>
        public void SetBorder(Graphics g, PointF point, SizeF watermarkSize)
        {
            SolidBrush solid = new SolidBrush(ColorTranslator.FromHtml(Config.FontBroderColor));
            int fontWidth = Config.FontBroderSize;
            Pen pen = new Pen(solid, fontWidth);
            int x = (int)point.X;
            int y = (int)point.Y;
            int width = (int)(watermarkSize.Width);
            int height = (int)(watermarkSize.Height);
            int text = fontWidth / 2;
            g.DrawLine(pen, new Point(x - fontWidth, y - text), new Point((int)(x + fontWidth + width), y - text));
            g.DrawLine(pen, new Point(x - text, y - text), new Point((int)(x - text), y + height + text));
            g.DrawLine(pen, new Point(x - fontWidth, y + text + height), new Point((int)(x + fontWidth + width), y + text + height));
            g.DrawLine(pen, new Point(x + text + width, y - text), new Point((int)(x + text + width), y + height + text));
        }
        #endregion

        #region 获得和设置透明属性
        /// <summary>
        /// 获得和设置透明属性
        /// </summary>
        /// <param name="opacity"></param>
        /// <returns></returns>
        public ImageAttributes GetOpacityAttribute(float opacity)
        {
            ImageAttributes imgAttributes = new ImageAttributes();
            ColorMap colorMap = new ColorMap();
            colorMap.OldColor = Color.FromArgb(255, 0, 255, 0);
            colorMap.NewColor = Color.FromArgb(0, 0, 0, 0);
            ColorMap[] remapTable = { colorMap };
            imgAttributes.SetRemapTable(remapTable, ColorAdjustType.Bitmap);

            float[][] colorMatrixElements = { 
                                   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,  opacity, 0.0f}, 
                                   new float[] {0.0f,  0.0f,  0.0f,  0.0f, 1.0f}
                                };

            ColorMatrix wmColorMatrix = new ColorMatrix(colorMatrixElements);
            imgAttributes.SetColorMatrix(wmColorMatrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
            return imgAttributes;
        }
        #endregion

        #region 设置文字的阴影
        /// <summary>
        ///  设置文字的阴影
        /// </summary>
        /// <param name="Pict"></param>
        /// <param name="Str"></param>
        /// <param name="font"></param>
        /// <param name="pointf"></param>
        /// <returns></returns>
        private Image SetBadge(Image image, Font font, PointF pointf, SizeF watermarkSize)
        {
            String str = Config.Text;
            int fontSize = (int)font.Size;
            FontStyle fontStyle = (FontStyle)Config.FontStyle;
            //bool isSetFont = false;   //当前水印文字大小是否超过图片大小
            int imageWidth = image.Width;
            int imageHeight = image.Height;
            int Var_StrX = (int)pointf.X;
            int Var_StrY = (int)pointf.Y;
            Color foreColor = ColorTranslator.FromHtml(Config.ShadowColor);

            Bitmap Var_bmp = new Bitmap(imageWidth, imageHeight);
            Bitmap Var_SaveBmp = new Bitmap(image);
            Graphics g = Graphics.FromImage(Var_bmp);
            Graphics tem_Graphics = Graphics.FromImage(image);
            SizeF Var_Size = new SizeF(imageWidth, imageHeight);
            g.Clear(Color.Transparent);

            g.DrawString(str, font, new SolidBrush(foreColor), Var_StrX, Var_StrY);
            int tem_Become = 100;
            for (int x = 1; x < Var_bmp.Width; x++)
            {
                for (int y = 1; y < Var_bmp.Height; y++)
                {
                    int tem_a, tem_r, tem_g, tem_b, tem_r1, tem_g1, tem_b1;
                    if (Var_bmp.GetPixel(x, y).ToArgb() == foreColor.ToArgb()
                        || foreColor == ColorTranslator.FromHtml(Config.FontColor))
                    {
                        tem_a = Var_SaveBmp.GetPixel(x, y).A;
                        tem_r = Var_SaveBmp.GetPixel(x, y).R;
                        tem_g = Var_SaveBmp.GetPixel(x, y).G;
                        tem_b = Var_SaveBmp.GetPixel(x, y).B;
                        tem_r1 = tem_r;
                        tem_g1 = tem_g;
                        tem_b1 = tem_b;

                        if (tem_b + tem_Become < 255)
                            tem_b = tem_b + 255;
                        if (tem_g + tem_Become < 255)
                            tem_g = tem_g + 255;
                        if (tem_r + tem_Become < 255)
                            tem_r = tem_r + 255;
                        if (tem_r1 - tem_Become > 0)
                            tem_r1 = tem_r1 - tem_Become;
                        if (tem_g1 - tem_Become > 0)
                            tem_g1 = tem_g1 - tem_Become;
                        if (tem_b1 - tem_Become > 0)
                            tem_b1 = tem_b1 - tem_Become;
                        tem_Graphics.DrawEllipse(new Pen(new SolidBrush(foreColor)), x + Config.OffsetU, y + Config.OffsetV, Config.ShadowSize, Config.ShadowSize);//绘制文字的阴影
                        tem_Graphics.DrawEllipse(new Pen(new SolidBrush(Color.FromArgb(tem_a, tem_r1, tem_g1, tem_b1))), x, y, 1, 1);
                    }
                }
            }
            return image;
        }
        #endregion

        #region 设置生成质量
        /// <summary>
        /// 设置生成质量
        /// </summary>
        /// <param name="ici"></param>
        /// <param name="ep"></param>
        /// <param name="quality"></param>
        public void SetQuality(ref ImageCodecInfo ici, ref EncoderParameters ep, long quality)
        {
            ImageCodecInfo[] icis = ImageCodecInfo.GetImageEncoders();
            foreach (ImageCodecInfo i in icis)
            {
                if (i.MimeType == "image/jpeg" || i.MimeType == "image/bmp" || i.MimeType == "image/png" || i.MimeType == "image/gif")
                {
                    ici = i;
                }
            }
            long[] qualityParam = new long[1];
            qualityParam[0] = quality;
            ep = new EncoderParameters(1);
            ep.Param[0] = new EncoderParameter(Encoder.Quality, qualityParam);
        }
        #endregion

        #region 获得显示坐标
        /// <summary>
        /// 获得显示坐标
        /// </summary>
        /// <returns></returns>
        private PointF CalculationPoint(SizeF ImageSize, SizeF watermarkSize)
        {
            PointF pointf = new PointF();
            if ((WatermarkPosition)Config.Position == WatermarkPosition.Manual)
            {
                pointf.X = Config.X;
                pointf.Y = Config.Y;
                return pointf;
            }

            float width = ImageSize.Width;
            float height = ImageSize.Height;
            float waterMarkWidth = watermarkSize.Width;
            float waterMarkHeight = watermarkSize.Height;
            WatermarkPosition position = (WatermarkPosition)Config.Position;

            switch (position)
            {
                case WatermarkPosition.Center:
                    pointf.X = (width - waterMarkWidth) / 2;
                    pointf.Y = (height - waterMarkHeight) / 2;
                    break;
                case WatermarkPosition.CenterDown:
                    pointf.X = (width - waterMarkWidth) / 2;
                    pointf.Y = (height - waterMarkHeight);
                    break;
                case WatermarkPosition.CenterUp:
                    pointf.X = (width - waterMarkWidth) / 2;
                    pointf.Y = 0;
                    break;
                case WatermarkPosition.LeftDown:
                    pointf.X = 0;
                    pointf.Y = (height - waterMarkHeight) / 2;
                    break;
                case WatermarkPosition.LeftUp:
                    pointf.X = 0;
                    pointf.Y = 0;
                    break;
                case WatermarkPosition.Random:
                    Random random = new Random();
                    int x = random.Next(0, (int)width);
                    int y = random.Next(0, (int)height);
                    pointf.X = x > (width - waterMarkWidth) / 2 ? (width - waterMarkWidth) / 2 : x;
                    pointf.Y = y > ((height - waterMarkHeight) / 2) ? (height - waterMarkHeight) / 2 : y;
                    break;
                case WatermarkPosition.RightDown:
                    pointf.X = width - waterMarkWidth;
                    pointf.Y = height - waterMarkHeight;
                    break;
                case WatermarkPosition.RightUp:
                    pointf.X = width - waterMarkWidth;
                    pointf.Y = 0;
                    break;
            }

            float offset = Config.Offset;
            pointf.X = pointf.X + offset;
            pointf.Y = pointf.Y + offset;
            return pointf;
        }
        #endregion

        #region 获得文件流
        /// <summary>
        /// 获得添加水印后的文件流
        /// </summary>
        /// <returns></returns>
        public byte[] GetWatermarkStream(string sourceFilePath)
        {
            MakeWaterMark(true);
            if (imgBuffer != null)
            {
                return imgBuffer;
            }
            return null;
        }

        /// <summary>
        /// 获得添加水印后的文件流
        /// </summary>
        /// <param name="buffer"></param>
        /// <returns></returns>
        public byte[] GetWatermarkStream(byte[] buffer)
        {
            this.imgBuffer = buffer;
            MakeWaterMark(true);
            if (imgBuffer != null)
            {
                return imgBuffer;
            }
            return null;
        }
        #endregion

        #region 获得保存路径
        /// <summary>
        ///获得保存路径 （指定的保存路径->配置文件中的保存路径->默认保存路径）
        /// </summary>
        /// <param name="outputPath">指定的保存路径</param>
        /// <param name="fileExtention">文件后缀</param>
        /// <returns></returns>
        public string GetFileSavePath(string outputPath, string fileExtention)
        {
            string filePath = null;
            if (!string.IsNullOrEmpty(outputPath))
            {
                filePath = string.Concat(outputPath, "_", Path.GetFileName(this.SourceImgPath));
            }
            else
            {
                string fileName = Path.GetFileName(this.SourceImgPath);
                if (string.IsNullOrEmpty(Config.WaterMarkSavePath))
                {
                    string path = string.Concat(Path.GetDirectoryName(this.SourceImgPath), "\\_", fileName);
                    filePath = path;
                }
                else
                {
                    filePath = Path.GetFullPath(string.Concat(Config.WaterMarkSavePath, "_", fileName));
                }
            }
            return filePath;
        }
        #endregion

    }

图片处理类：

    /// <summary>
    /// 图片处理类
    /// </summary>
    public class ImageDealHelper
    {

        #region 水印处理
        /// <summary>
        /// 设置水印(水印图片路径根据配置信息中的水印保存路径保存)
        ///                当配置信息中水印保存路径不存在时，在源文件当前目录下保存
        /// </summary>
        /// <param name="filePath">源文件路径</param>
        public static string MakeWaterMark(string fileSourcePath)
        {
            return MakeWaterMark(fileSourcePath, null);
        }

        /// <summary>
        /// 保存图片
        /// </summary>
        /// <param name="fileSourcePath">源文件路径</param>
        /// <param name="outputPath">水印文件保存路径</param>
        /// <returns></returns>
        public static string MakeWaterMark(string fileSourcePath, string outputPath)
        {
            return MakeWaterMark(fileSourcePath, outputPath, WaterMarkConfig.Instance);
        }

        /// <summary>
        /// 保存图片
        /// </summary>
        /// <param name="fileSourcePath">源文件路径</param>
        /// <param name="outputPath">水印文件保存路径</param>
        /// <param name="config"></param>
        /// <returns></returns>
        public static string MakeWaterMark(string fileSourcePath, string outputPath, WaterMarkConfig config)
        {
            WaterMark watermark = new WaterMark(fileSourcePath, outputPath, config);
            watermark.MakeWaterMark();
            return watermark.FileSavePath;
        }

        /// <summary>
        /// 预览水印图片
        /// </summary>
        /// <returns></returns>
        public static byte[] WatermarkPreview(string fileSourcePath)
        {
            WaterMark watermark = new WaterMark(fileSourcePath, null, WaterMarkConfig.Instance);
            return watermark.GetWatermarkStream(fileSourcePath);
        }

        /// <summary>
        /// 预览水印图片
        /// </summary>
        /// <param name="buffer"></param>
        /// <returns></returns>
        public static byte[] WatermarkPreview(byte[] buffer)
        {
            WaterMark watermark = new WaterMark(buffer, null, WaterMarkConfig.Instance);
            return watermark.GetWatermarkStream(buffer);
        }
        #endregion

        #region 判断文件类型是否为WEB格式图片
        /// <summary>
        /// 判断文件类型是否为WEB格式图片
        /// (注：JPG,GIF,BMP,PNG)
        /// </summary>
        /// <param name="extention">HttpPostedFile.ContentType</param>
        /// <returns></returns>
        internal static bool IsWebImage(string extention)
        {
            extention = extention.ToLower();
            if (extention == ".jpeg" || extention == ".jpeg" || extention == ".gif" || extention == ".bmp" || extention == ".png")
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        #endregion

        #region 根据后缀返回相应图片格式类型
        /// <summary>
        /// 根据后缀返回相应图片格式类型
        /// </summary>
        /// <param name="extention"></param>
        /// <returns></returns>
        public static ImageFormat GetImageFormart(string extention)
        {
            if (string.IsNullOrEmpty(extention))
            {
                return null;
            }
            extention = extention.ToLower();
            ImageFormat imgFormart = default(ImageFormat);
            switch (extention)
            {
                case ".jpeg":
                    imgFormart = ImageFormat.Jpeg;
                    break;
                case ".gif":
                    imgFormart = ImageFormat.Gif;
                    break;
                case ".bmp":
                    imgFormart = ImageFormat.Bmp;
                    break;
                case "png":
                    imgFormart = ImageFormat.Png;
                    break;
                default: imgFormart = ImageFormat.Jpeg;
                    break;
            }
            return imgFormart;
        }
        #endregion

        #region 图片转化为流
        /// <summary>
        /// 图片转化为流
        /// </summary>
        /// <param name="img"></param>
        /// <param name="extention"></param>
        /// <returns></returns>
        public static byte[] ImageToStream(Image img, ImageFormat imgFormart)
        {
            MemoryStream ms = new MemoryStream();
            img.Save(ms, imgFormart);
            return ms.GetBuffer();
        }

        #endregion

        #region 流转化为图片
        /// <summary>
        /// 流转化为图片
        /// </summary>
        /// <param name="buffer"></param>
        /// <returns></returns>
        public static Image StreamToImage(byte[] buffer)
        {
            MemoryStream ms = new MemoryStream(buffer);
            return Image.FromStream(ms);
        }
        #endregion

        #region 根据URL返回文件二进制流
        /// <summary>
        /// 根据URL返回文件二进制流
        /// </summary>
        /// <param name="url"></param>
        /// <returns></returns>
        public static byte[] URLToStream(string url)
        {
            WebRequest request = WebRequest.Create(url);
            WebResponse response = request.GetResponse();
            Stream stream = response.GetResponseStream();
            Image img = Image.FromStream(stream);
            byte[] buffer = ImageToStream(img, img.RawFormat);
            return buffer;
        }
        #endregion
    }

 

 

---

 

 

源码下载：点击下载