zoukankan      html  css  js  c++  java
  • ASP.NET 图片上传工具类 upload image简单好用功能齐全

    使用方法:

    UploadImage ui = new UploadImage();
     
              /***可选参数***/
     
              ui.SetWordWater = "哈哈";//文字水印
              // ui.SetPicWater = Server.MapPath("2.png");//图片水印(图片和文字都赋值图片有效)
              ui.SetPositionWater = 4;//水印图片的位置 0居中、1左上角、2右上角、3左下角、4右下角
     
              ui.SetSmallImgHeight = "110,40,20";//设置缩略图可以多个
              ui.SetSmallImgWidth = "100,40,20";
     
              //保存图片生成缩略图
              var reponseMessage = ui.FileSaveAs(Request.Files[0], Server.MapPath("~/file/temp"));
     
              //裁剪图片
              var reponseMessage2 = ui.FileCutSaveAs(Request.Files[0], Server.MapPath("~/file/temp2"), 400, 300, UploadImage.CutMode.CutNo);
     
     
     
     
              /***返回信息***/
              var isError = reponseMessage.IsError;//是否异常
              var webPath = reponseMessage.WebPath;//web路径
              var filePath = reponseMessage.filePath;//物理路径
              var message = reponseMessage.Message;//错误信息
              var directory = reponseMessage.Directory;//目录
              var smallPath1 = reponseMessage.SmallPath(0);//缩略图路径1
              var smallPath2 = reponseMessage.SmallPath(1);//缩略图路径2
              var smallPath3 = reponseMessage.SmallPath(2);//缩略图路径3

    类:

    using System;
    using System.Collections.Generic;
    using System.Text;
    using System.IO;
    using System.Web;
    using System.Drawing;
    using System.Drawing.Imaging;
    using System.Drawing.Drawing2D;
    using System.Collections;
    using System.Net;
    using System.Text.RegularExpressions;
    using System.Configuration;
     
    namespace SyntacticSugar
    {
        /// <summary>
        /// ** 描述:图片上传类、支持水印、缩略图
        /// ** 创始时间:2015-5-28
        /// ** 修改时间:-
        /// ** 修改人:sunkaixuan
        /// ** 使用说明:http://www.cnblogs.com/sunkaixuan/p/4536626.html
        /// </summary>
        public class UploadImage
        {
     
            #region 属性
            /// <summary>
            /// 允许图片格式
            /// </summary>
            public string SetAllowFormat { get; set; }
            /// <summary>
            /// 允许上传图片大小
            /// </summary>
            public double SetAllowSize { get; set; }
            /// <summary>
            /// 文字水印字符
            /// </summary>
            public string SetWordWater { get; set; }
            /// <summary>
            /// 图片水印
            /// </summary>
            public string SetPicWater { get; set; }
            /// <summary>
            /// 水印图片的位置 0居中、1左上角、2右上角、3左下角、4右下角
            /// </summary>
            public int SetPositionWater { get; set; }
            /// <summary>
            /// 缩略图宽度多个逗号格开(例如:200,100)
            /// </summary>
            public string SetSmallImgWidth { get; set; }
            /// <summary>
            /// 缩略图高度多个逗号格开(例如:200,100)
            /// </summary>
            public string SetSmallImgHeight { get; set; }
            /// <summary>
            /// 是否限制最大宽度,默认为true
            /// </summary>
            public bool SetLimitWidth { get; set; }
            /// <summary>
            /// 最大宽度尺寸,默认为600
            /// </summary>
            public int SetMaxWidth { get; set; }
            /// <summary>
            /// 是否剪裁图片,默认true
            /// </summary>
            public bool SetCutImage { get; set; }
            /// <summary>
            /// 限制图片最小宽度,0表示不限制
            /// </summary>
            public int SetMinWidth { get; set; }
     
            #endregion
     
            public UploadImage()
            {
                SetAllowFormat = ".jpeg|.jpg|.bmp|.gif|.png";   //允许图片格式
                SetAllowSize = 1;       //允许上传图片大小,默认为1MB
                SetPositionWater = 4;
                SetCutImage = true;
            }
     
     
     
            #region main method
     
     
            /// <summary>
            /// 裁剪图片
            /// </summary>
            /// <param name="PostedFile">HttpPostedFile控件</param>
            /// <param name="SavePath">保存路径【sys.config配置路径】</param>
            /// <param name="oImgWidth">图片宽度</param>
            /// <param name="oImgHeight">图片高度</param>
            /// <param name="cMode">剪切类型</param>
            /// <param name="ext">返回格式</param>
            /// <returns>返回上传信息</returns>
            public ResponseMessage FileCutSaveAs(System.Web.HttpPostedFile PostedFile, string SavePath, int oImgWidth, int oImgHeight, CutMode cMode)
            {
                ResponseMessage rm = new ResponseMessage();
                try
                {
                    //获取上传文件的扩展名
                    string sEx = System.IO.Path.GetExtension(PostedFile.FileName);
                    if (!CheckValidExt(SetAllowFormat, sEx))
                    {
                        TryError(rm, 2);
                        return rm;
                    }
     
                    //获取上传文件的大小
                    double PostFileSize = PostedFile.ContentLength / 1024.0 / 1024.0;
     
                    if (PostFileSize > SetAllowSize)
                    {
                        TryError(rm, 3);
                        return rm;  //超过文件上传大小
                    }
                    if (!System.IO.Directory.Exists(SavePath))
                    {
                        System.IO.Directory.CreateDirectory(SavePath);
                    }
                    //重命名名称
                    string NewfileName = DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString() + DateTime.Now.Day.ToString() + DateTime.Now.Hour.ToString() + DateTime.Now.Minute.ToString() + DateTime.Now.Second.ToString() + DateTime.Now.Millisecond.ToString("000");
                    string fName = "s" + NewfileName + sEx;
                    string fullPath = Path.Combine(SavePath, fName);
                    PostedFile.SaveAs(fullPath);
     
                    //重命名名称
                    string sNewfileName = DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString() + DateTime.Now.Day.ToString() + DateTime.Now.Hour.ToString() + DateTime.Now.Minute.ToString() + DateTime.Now.Second.ToString() + DateTime.Now.Millisecond.ToString("000");
                    string sFName = sNewfileName + sEx;
                    rm.IsError = false;
                    rm.FileName = sFName;
                    string sFullPath = Path.Combine(SavePath, sFName);
                    rm.filePath = sFullPath;
                    rm.WebPath = "/"+sFullPath.Replace(HttpContext.Current.Server.MapPath("~/"), "").Replace("\", "/");
                    CreateSmallPhoto(fullPath, oImgWidth, oImgHeight, sFullPath, SetPicWater, SetWordWater, cMode);
                    if (File.Exists(fullPath))
                    {
                        File.Delete(fullPath);
                    }
                    //压缩
                    if (PostFileSize > 100)
                    {
                        CompressPhoto(sFullPath, 100);
                    }
                }
                catch (Exception ex)
                {
                    TryError(rm, ex.Message);
                }
                return rm;
            }
     
     
     
            /// <summary>
            /// 通用图片上传类
            /// </summary>
            /// <param name="PostedFile">HttpPostedFile控件</param>
            /// <param name="SavePath">保存路径【sys.config配置路径】</param>
            /// <param name="finame">返回文件名</param>
            /// <param name="fisize">返回文件大小</param>
            /// <returns>返回上传信息</returns>
            public ResponseMessage FileSaveAs(System.Web.HttpPostedFile PostedFile, string SavePath)
            {
                ResponseMessage rm = new ResponseMessage();
                try
                {
                    if (string.IsNullOrEmpty(PostedFile.FileName))
                    {
                        TryError(rm, 4);
                        return rm;
                    }
     
                    Random rd = new Random();
                    int rdInt = rd.Next(1000, 9999);
                    //重命名名称
                    string NewfileName = DateTime.Now.Year.ToString() + DateTime.Now.Month.ToString() + DateTime.Now.Day.ToString() + DateTime.Now.Hour.ToString() + DateTime.Now.Minute.ToString() + DateTime.Now.Second.ToString() + DateTime.Now.Millisecond.ToString() + rdInt;
     
                    //获取上传文件的扩展名
                    string sEx = System.IO.Path.GetExtension(PostedFile.FileName);
                    if (!CheckValidExt(SetAllowFormat, sEx))
                    {
                        TryError(rm, 2);
                        return rm;
                    }
     
                    //获取上传文件的大小
                    double PostFileSize = PostedFile.ContentLength / 1024.0 / 1024.0;
     
                    if (PostFileSize > SetAllowSize)
                    {
                        TryError(rm, 3);
                        return rm;
                    }
     
     
                    if (!System.IO.Directory.Exists(SavePath))
                    {
                        System.IO.Directory.CreateDirectory(SavePath);
                    }
     
                    rm.FileName = NewfileName + sEx;
                    string fullPath = SavePath.Trim('\') + "\" + rm.FileName;
                    rm.WebPath = "/"+fullPath.Replace(HttpContext.Current.Server.MapPath("~/"), "").Replace("\", "/");
                    rm.filePath = fullPath;
                    rm.Size = PostFileSize;
                    PostedFile.SaveAs(fullPath);
     
     
                    System.Drawing.Bitmap bmp = new Bitmap(fullPath);
                    int realWidth = bmp.Width;
                    int realHeight = bmp.Height;
                    bmp.Dispose();
     
                    #region 检测图片宽度限制
                    if (SetMinWidth > 0)
                    {
                        if (realWidth < SetMinWidth)
                        {
                            TryError(rm, 7);
                            return rm;
                        }
                    }
                    #endregion
     
                    #region 监测图片宽度是否超过600,超过的话,自动压缩到600
                    if (SetLimitWidth && realWidth > SetMaxWidth)
                    {
                        int mWidth = SetMaxWidth;
                        int mHeight = mWidth * realHeight / realWidth;
     
                        string tempFile = SavePath + Guid.NewGuid().ToString() + sEx;
                        File.Move(fullPath, tempFile);
                        CreateSmallPhoto(tempFile, mWidth, mHeight, fullPath, "", "");
                        File.Delete(tempFile);
                    }
                    #endregion
     
                    #region 压缩图片存储尺寸
                    if (sEx.ToLower() != ".gif")
                    {
                        CompressPhoto(fullPath, 100);
                    }
                    #endregion
     
     
     
                    //生成缩略图片高宽
                    if (string.IsNullOrEmpty(SetSmallImgWidth))
                    {
                        rm.Message = "上传成功,无缩略图";
                        return rm;
                    }
     
     
                    string[] oWidthArray = SetSmallImgWidth.Split(',');
                    string[] oHeightArray = SetSmallImgHeight.Split(',');
                    if (oWidthArray.Length != oHeightArray.Length)
                    {
                        TryError(rm, 6);
                        return rm;
                    }
     
     
                    for (int i = 0; i < oWidthArray.Length; i++)
                    {
                        if (Convert.ToInt32(oWidthArray[i]) <= 0 || Convert.ToInt32(oHeightArray[i]) <= 0)
                            continue;
     
                        string sImg = SavePath.TrimEnd('\') + '\' + NewfileName + "_" + i.ToString() + sEx;
     
                        //判断图片高宽是否大于生成高宽。否则用原图
                        if (realWidth > Convert.ToInt32(oWidthArray[i]))
                        {
                            if (SetCutImage)
                                CreateSmallPhoto(fullPath, Convert.ToInt32(oWidthArray[i]), Convert.ToInt32(oHeightArray[i]), sImg, "", "");
                            else
                                CreateSmallPhoto(fullPath, Convert.ToInt32(oWidthArray[i]), Convert.ToInt32(oHeightArray[i]), sImg, "", "", CutMode.CutNo);
                        }
                        else
                        {
                            if (SetCutImage)
                                CreateSmallPhoto(fullPath, realWidth, realHeight, sImg, "", "");
                            else
                                CreateSmallPhoto(fullPath, realWidth, realHeight, sImg, "", "", CutMode.CutNo);
                        }
                    }
     
                    #region 给大图添加水印
                    if (!string.IsNullOrEmpty(SetPicWater))
                        AttachPng(SetPicWater, fullPath);
                    else if (!string.IsNullOrEmpty(SetWordWater))
                        AttachText(SetWordWater, fullPath);
                    #endregion
     
     
                }
                catch (Exception ex)
                {
                    TryError(rm, ex.Message);
                }
                return rm;
            }
     
            #region 验证格式
            /// <summary>
            /// 验证格式
            /// </summary>
            /// <param name="allType">所有格式</param>
            /// <param name="chkType">被检查的格式</param>
            /// <returns>bool</returns>
            public bool CheckValidExt(string allType, string chkType)
            {
                bool flag = false;
                string[] sArray = allType.Split('|');
                foreach (string temp in sArray)
                {
                    if (temp.ToLower() == chkType.ToLower())
                    {
                        flag = true;
                        break;
                    }
                }
     
                return flag;
            }
            #endregion
     
            #region 根据需要的图片尺寸,按比例剪裁原始图片
            /// <summary>
            /// 根据需要的图片尺寸,按比例剪裁原始图片
            /// </summary>
            /// <param name="nWidth">缩略图宽度</param>
            /// <param name="nHeight">缩略图高度</param>
            /// <param name="img">原始图片</param>
            /// <returns>剪裁区域尺寸</returns>
            public Size CutRegion(int nWidth, int nHeight, Image img)
            {
                double width = 0.0;
                double height = 0.0;
     
                double nw = (double)nWidth;
                double nh = (double)nHeight;
     
                double pw = (double)img.Width;
                double ph = (double)img.Height;
     
                if (nw / nh > pw / ph)
                {
                    width = pw;
                    height = pw * nh / nw;
                }
                else if (nw / nh < pw / ph)
                {
                    width = ph * nw / nh;
                    height = ph;
                }
                else
                {
                    width = pw;
                    height = ph;
                }
     
                return new Size(Convert.ToInt32(width), Convert.ToInt32(height));
            }
            #endregion
     
            #region 等比例缩小图片
            public Size NewSize(int nWidth, int nHeight, Image img)
            {
                double w = 0.0;
                double h = 0.0;
                double sw = Convert.ToDouble(img.Width);
                double sh = Convert.ToDouble(img.Height);
                double mw = Convert.ToDouble(nWidth);
                double mh = Convert.ToDouble(nHeight);
     
                if (sw < mw && sh < mh)
                {
                    w = sw;
                    h = sh;
                }
                else if ((sw / sh) > (mw / mh))
                {
                    w = nWidth;
                    h = (w * sh) / sw;
                }
                else
                {
                    h = nHeight;
                    w = (h * sw) / sh;
                }
     
                return new Size(Convert.ToInt32(w), Convert.ToInt32(h));
            }
            #endregion
     
            #region 生成缩略图
     
            #region 生成缩略图,不加水印
            /// <summary>
            /// 生成缩略图,不加水印
            /// </summary>
            /// <param name="filename">源文件</param>
            /// <param name="nWidth">缩略图宽度</param>
            /// <param name="nHeight">缩略图高度</param>
            /// <param name="destfile">缩略图保存位置</param>
            public void CreateSmallPhoto(string filename, int nWidth, int nHeight, string destfile)
            {
                Image img = Image.FromFile(filename);
                ImageFormat thisFormat = img.RawFormat;
     
                Size CutSize = CutRegion(nWidth, nHeight, img);
                Bitmap outBmp = new Bitmap(nWidth, nHeight);
                Graphics g = Graphics.FromImage(outBmp);
     
                // 设置画布的描绘质量
                g.CompositingQuality = CompositingQuality.HighQuality;
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;
     
                int nStartX = (img.Width - CutSize.Width) / 2;
                int nStartY = (img.Height - CutSize.Height) / 2;
     
                g.DrawImage(img, new Rectangle(0, 0, nWidth, nHeight),
                    nStartX, nStartY, CutSize.Width, CutSize.Height, GraphicsUnit.Pixel);
                g.Dispose();
     
                //if (thisFormat.Equals(ImageFormat.Gif))
                //{
                //    Response.ContentType = "image/gif";
                //}
                //else
                //{
                //    Response.ContentType = "image/jpeg";
                //}
     
                // 以下代码为保存图片时,设置压缩质量
                EncoderParameters encoderParams = new EncoderParameters();
                long[] quality = new long[1];
                quality[0] = 100;
     
                EncoderParameter encoderParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
                encoderParams.Param[0] = encoderParam;
     
                //获得包含有关内置图像编码解码器的信息的ImageCodecInfo 对象。
                ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
                ImageCodecInfo jpegICI = null;
                for (int x = 0; x < arrayICI.Length; x++)
                {
                    if (arrayICI[x].FormatDescription.Equals("JPEG"))
                    {
                        jpegICI = arrayICI[x];//设置JPEG编码
                        break;
                    }
                }
     
                if (jpegICI != null)
                {
                    //outBmp.Save(Response.OutputStream, jpegICI, encoderParams);
                    outBmp.Save(destfile, jpegICI, encoderParams);
                }
                else
                {
                    //outBmp.Save(Response.OutputStream, thisFormat);
                    outBmp.Save(destfile, thisFormat);
                }
     
                img.Dispose();
                outBmp.Dispose();
            }
            #endregion
     
            #region 生成缩略图,加水印
            public void CreateSmallPhoto(string filename, int nWidth, int nHeight, string destfile, string sy, int nType)
            {
                if (nType == 0)
                    CreateSmallPhoto(filename, nWidth, nHeight, destfile, sy, "");
                else
                    CreateSmallPhoto(filename, nWidth, nHeight, destfile, "", sy);
            }
            #endregion
     
            #region 生成缩略图
            /// <summary>
            /// 生成缩略图
            /// </summary>
            /// <param name="filename">源文件</param>
            /// <param name="nWidth">缩略图宽度</param>
            /// <param name="nHeight">缩略图高度</param>
            /// <param name="destfile">缩略图保存位置</param>
            /// <param name="png">图片水印</param>
            /// <param name="text">文本水印</param>
            public void CreateSmallPhoto(string filename, int nWidth, int nHeight, string destfile, string png, string text)
            {
                Image img = Image.FromFile(filename);
                ImageFormat thisFormat = img.RawFormat;
     
                Size CutSize = CutRegion(nWidth, nHeight, img);
                Bitmap outBmp = new Bitmap(nWidth, nHeight);
                Graphics g = Graphics.FromImage(outBmp);
                g.Clear(Color.White);
     
                // 设置画布的描绘质量
                g.CompositingQuality = CompositingQuality.HighQuality;
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;
     
                int nStartX = (img.Width - CutSize.Width) / 2;
                int nStartY = (img.Height - CutSize.Height) / 2;
     
                g.DrawImage(img, new Rectangle(0, 0, nWidth, nHeight),
                    nStartX, nStartY, CutSize.Width, CutSize.Height, GraphicsUnit.Pixel);
                g.Dispose();
     
                // 以下代码为保存图片时,设置压缩质量
                EncoderParameters encoderParams = new EncoderParameters();
                long[] quality = new long[1];
                quality[0] = 100;
     
                EncoderParameter encoderParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
                encoderParams.Param[0] = encoderParam;
     
                //获得包含有关内置图像编码解码器的信息的ImageCodecInfo 对象。
                ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
                ImageCodecInfo jpegICI = null;
                for (int x = 0; x < arrayICI.Length; x++)
                {
                    if (arrayICI[x].FormatDescription.Equals("JPEG"))
                    {
                        jpegICI = arrayICI[x];//设置JPEG编码
                        break;
                    }
                }
     
                if (jpegICI != null)
                {
                    outBmp.Save(destfile, jpegICI, encoderParams);
                }
                else
                {
                    outBmp.Save(destfile, thisFormat);
                }
     
                img.Dispose();
                outBmp.Dispose();
     
                if (!string.IsNullOrEmpty(png))
                    AttachPng(png, destfile);
     
                if (!string.IsNullOrEmpty(text))
                    AttachText(text, destfile);
            }
     
     
            public void CreateSmallPhoto(string filename, int nWidth, int nHeight, string destfile, string png, string text, CutMode cMode)
            {
                Image img = Image.FromFile(filename);
     
                if (nWidth <= 0)
                    nWidth = img.Width;
                if (nHeight <= 0)
                    nHeight = img.Height;
     
                int towidth = nWidth;
                int toheight = nHeight;
     
                switch (cMode)
                {
                    case CutMode.CutWH://指定高宽缩放(可能变形)              
                        break;
                    case CutMode.CutW://指定宽,高按比例                  
                        toheight = img.Height * nWidth / img.Width;
                        break;
                    case CutMode.CutH://指定高,宽按比例
                        towidth = img.Width * nHeight / img.Height;
                        break;
                    case CutMode.CutNo: //缩放不剪裁
                        int maxSize = (nWidth >= nHeight ? nWidth : nHeight);
                        if (img.Width >= img.Height)
                        {
                            towidth = maxSize;
                            toheight = img.Height * maxSize / img.Width;
                        }
                        else
                        {
                            toheight = maxSize;
                            towidth = img.Width * maxSize / img.Height;
                        }
                        break;
                    default:
                        break;
                }
                nWidth = towidth;
                nHeight = toheight;
     
                ImageFormat thisFormat = img.RawFormat;
     
                Size CutSize = new Size(nWidth, nHeight);
                if (cMode != CutMode.CutNo)
                    CutSize = CutRegion(nWidth, nHeight, img);
     
                Bitmap outBmp = new Bitmap(CutSize.Width, CutSize.Height);
     
                Graphics g = Graphics.FromImage(outBmp);
                g.Clear(Color.White);
     
                // 设置画布的描绘质量
                g.CompositingQuality = CompositingQuality.HighQuality;
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;
     
                int nStartX = (img.Width - CutSize.Width) / 2;
                int nStartY = (img.Height - CutSize.Height) / 2;
     
                //int x1 = (outBmp.Width - nWidth) / 2;
                //int y1 = (outBmp.Height - nHeight) / 2;
     
                if (cMode != CutMode.CutNo)
                    g.DrawImage(img, new Rectangle(0, 0, nWidth, nHeight),
                        nStartX, nStartY, CutSize.Width, CutSize.Height, GraphicsUnit.Pixel);
                else
                    g.DrawImage(img, new Rectangle(0, 0, nWidth, nHeight),
                    0, 0, img.Width, img.Height, GraphicsUnit.Pixel);
                g.Dispose();
     
                // 以下代码为保存图片时,设置压缩质量
                EncoderParameters encoderParams = new EncoderParameters();
                long[] quality = new long[1];
                quality[0] = 100;
     
                EncoderParameter encoderParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
                encoderParams.Param[0] = encoderParam;
     
                //获得包含有关内置图像编码解码器的信息的ImageCodecInfo 对象。
                ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
                ImageCodecInfo jpegICI = null;
                for (int x = 0; x < arrayICI.Length; x++)
                {
                    if (arrayICI[x].FormatDescription.Equals("JPEG"))
                    {
                        jpegICI = arrayICI[x];//设置JPEG编码
                        break;
                    }
                }
     
                if (jpegICI != null)
                {
                    outBmp.Save(destfile, jpegICI, encoderParams);
                }
                else
                {
                    outBmp.Save(destfile, thisFormat);
                }
     
                img.Dispose();
                outBmp.Dispose();
     
                if (!string.IsNullOrEmpty(png))
                    AttachPng(png, destfile);
     
                if (!string.IsNullOrEmpty(text))
                    AttachText(text, destfile);
            }
            #endregion
     
            #endregion
     
            #region 添加文字水印
            public void AttachText(string text, string file)
            {
                if (string.IsNullOrEmpty(text))
                    return;
     
                if (!System.IO.File.Exists(file))
                    return;
     
                System.IO.FileInfo oFile = new System.IO.FileInfo(file);
                string strTempFile = System.IO.Path.Combine(oFile.DirectoryName, Guid.NewGuid().ToString() + oFile.Extension);
                oFile.CopyTo(strTempFile);
     
                Image img = Image.FromFile(strTempFile);
                ImageFormat thisFormat = img.RawFormat;
     
                int nHeight = img.Height;
                int nWidth = img.Width;
     
                Bitmap outBmp = new Bitmap(nWidth, nHeight);
                Graphics g = Graphics.FromImage(outBmp);
                g.Clear(Color.White);
     
                // 设置画布的描绘质量
                g.CompositingQuality = CompositingQuality.HighQuality;
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;
     
                g.DrawImage(img, new Rectangle(0, 0, nWidth, nHeight),
                    0, 0, nWidth, nHeight, GraphicsUnit.Pixel);
     
                int[] sizes = new int[] { 16, 14, 12, 10, 8, 6, 4 };
     
                Font crFont = null;
                SizeF crSize = new SizeF();
     
                //通过循环这个数组,来选用不同的字体大小
                //如果它的大小小于图像的宽度,就选用这个大小的字体
                for (int i = 0; i < 7; i++)
                {
                    //设置字体,这里是用arial,黑体
                    crFont = new Font("arial", sizes[i], FontStyle.Bold);
                    //Measure the Copyright string in this Font
                    crSize = g.MeasureString(text, crFont);
     
                    if ((ushort)crSize.Width < (ushort)nWidth)
                        break;
                }
     
                //因为图片的高度可能不尽相同, 所以定义了
                //从图片底部算起预留了5%的空间
                int yPixlesFromBottom = (int)(nHeight * .08);
     
                //现在使用版权信息字符串的高度来确定要绘制的图像的字符串的y坐标
     
                float yPosFromBottom = ((nHeight - yPixlesFromBottom) - (crSize.Height / 2));
     
                //计算x坐标
                float xCenterOfImg = (nWidth / 2);
     
                //把文本布局设置为居中
                StringFormat StrFormat = new StringFormat();
                StrFormat.Alignment = StringAlignment.Center;
     
                //通过Brush来设置黑色半透明
                SolidBrush semiTransBrush2 = new SolidBrush(Color.FromArgb(153, 0, 0, 0));
     
                //绘制版权字符串
                g.DrawString(text,                 //版权字符串文本
                    crFont,                                   //字体
                    semiTransBrush2,                           //Brush
                    new PointF(xCenterOfImg + 1, yPosFromBottom + 1),  //位置
                    StrFormat);
     
                //设置成白色半透明
                SolidBrush semiTransBrush = new SolidBrush(Color.FromArgb(153, 255, 255, 255));
     
                //第二次绘制版权字符串来创建阴影效果
                //记住移动文本的位置1像素
                g.DrawString(text,                 //版权文本
                    crFont,                                   //字体
                    semiTransBrush,                           //Brush
                    new PointF(xCenterOfImg, yPosFromBottom),  //位置
                    StrFormat);
     
                g.Dispose();
     
                // 以下代码为保存图片时,设置压缩质量
                EncoderParameters encoderParams = new EncoderParameters();
                long[] quality = new long[1];
                quality[0] = 100;
     
                EncoderParameter encoderParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
                encoderParams.Param[0] = encoderParam;
     
                //获得包含有关内置图像编码解码器的信息的ImageCodecInfo 对象。
                ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
                ImageCodecInfo jpegICI = null;
                for (int x = 0; x < arrayICI.Length; x++)
                {
                    if (arrayICI[x].FormatDescription.Equals("JPEG"))
                    {
                        jpegICI = arrayICI[x];//设置JPEG编码
                        break;
                    }
                }
     
                if (jpegICI != null)
                {
                    outBmp.Save(file, jpegICI, encoderParams);
                }
                else
                {
                    outBmp.Save(file, thisFormat);
                }
     
                img.Dispose();
                outBmp.Dispose();
     
                System.IO.File.Delete(strTempFile);
            }
            #endregion
     
            #region 添加图片水印
            ///<summary>
            /// 添加图片水印
            /// </summary>
            /// <param name="png">水印图片</param>
            /// <param name="file">原文件</param>
            /// <param name="position">水印图片的位置 0居中、1左上角、2右上角、3左下角、4右下角</param>
            public void AttachPng(string png, string file)
            {
                if (string.IsNullOrEmpty(png))
                    return;
     
                if (!System.IO.File.Exists(png))
                    return;
     
                if (!System.IO.File.Exists(file))
                    return;
     
                System.IO.FileInfo oFile = new System.IO.FileInfo(file);
                string strTempFile = System.IO.Path.Combine(oFile.DirectoryName, Guid.NewGuid().ToString() + oFile.Extension);
                oFile.CopyTo(strTempFile);
     
                Image img = Image.FromFile(strTempFile);
                ImageFormat thisFormat = img.RawFormat;
                int nHeight = img.Height;
                int nWidth = img.Width;
     
                Bitmap outBmp = new Bitmap(nWidth, nHeight);
                Graphics g = Graphics.FromImage(outBmp);
     
                // 设置画布的描绘质量
                g.CompositingQuality = CompositingQuality.HighQuality;
                g.SmoothingMode = SmoothingMode.HighQuality;
                g.InterpolationMode = InterpolationMode.HighQualityBicubic;
     
                g.DrawImage(img, new Rectangle(0, 0, nWidth, nHeight),
                    0, 0, nWidth, nHeight, GraphicsUnit.Pixel);
     
                img.Dispose();
     
                img = Image.FromFile(png);
     
                //Bitmap bmpPng = new Bitmap(img);
     
                //ImageAttributes imageAttr = new ImageAttributes();
                //Color bg = Color.Green;
                //imageAttr.SetColorKey(bg, bg);
     
                Size pngSize = NewSize(nWidth, nHeight, img);
                int nx = 0;
                int ny = 0;
                int padding = 10;
                if (SetPositionWater == 0)
                {
                    nx = (nWidth - pngSize.Width) / 2;
                    ny = (nHeight - pngSize.Height) / 2;
                }
                else if (SetPositionWater == 1)
                {
                    nx = padding;
                    ny = padding;
                }
                else if (SetPositionWater == 2)
                {
                    nx = (nWidth - pngSize.Width) - padding;
                    ny = padding;
                }
                else if (SetPositionWater == 3)
                {
                    nx = padding;
                    ny = (nHeight - pngSize.Height) - padding;
                }
                else
                {
                    nx = (nWidth - pngSize.Width) - padding;
                    ny = (nHeight - pngSize.Height) - padding;
                }
                g.DrawImage(img, new Rectangle(nx, ny, pngSize.Width, pngSize.Height),
                    0, 0, img.Width, img.Height, GraphicsUnit.Pixel);
     
                g.Dispose();
     
                // 以下代码为保存图片时,设置压缩质量
                EncoderParameters encoderParams = new EncoderParameters();
                long[] quality = new long[1];
                quality[0] = 100;
     
                EncoderParameter encoderParam = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, quality);
                encoderParams.Param[0] = encoderParam;
     
                //获得包含有关内置图像编码解码器的信息的ImageCodecInfo 对象。
                ImageCodecInfo[] arrayICI = ImageCodecInfo.GetImageEncoders();
                ImageCodecInfo jpegICI = null;
                for (int x = 0; x < arrayICI.Length; x++)
                {
                    if (arrayICI[x].FormatDescription.Equals("JPEG"))
                    {
                        jpegICI = arrayICI[x];//设置JPEG编码
                        break;
                    }
                }
     
                if (jpegICI != null)
                {
                    outBmp.Save(file, jpegICI, encoderParams);
                }
                else
                {
                    outBmp.Save(file, thisFormat);
                }
     
                img.Dispose();
                outBmp.Dispose();
     
                System.IO.File.Delete(strTempFile);
            }
            #endregion
     
            #region 得到指定mimeType的ImageCodecInfo
            /// <summary>
            /// 保存JPG时用
            /// </summary>
            /// <param name="mimeType"> </param>
            /// <returns>得到指定mimeType的ImageCodecInfo </returns>
            private ImageCodecInfo GetCodecInfo(string mimeType)
            {
                ImageCodecInfo[] CodecInfo = ImageCodecInfo.GetImageEncoders();
                foreach (ImageCodecInfo ici in CodecInfo)
                {
                    if (ici.MimeType == mimeType) return ici;
                }
                return null;
            }
            #endregion
     
            #region 保存为JPEG格式,支持压缩质量选项
            /// <summary>
            /// 保存为JPEG格式,支持压缩质量选项
            /// </summary>
            /// <param name="SourceFile"></param>
            /// <param name="FileName"></param>
            /// <param name="Qty"></param>
            /// <returns></returns>
            public bool KiSaveAsJPEG(string SourceFile, string FileName, int Qty)
            {
                Bitmap bmp = new Bitmap(SourceFile);
     
                try
                {
                    EncoderParameter p;
                    EncoderParameters ps;
     
                    ps = new EncoderParameters(1);
     
                    p = new EncoderParameter(System.Drawing.Imaging.Encoder.Quality, Qty);
                    ps.Param[0] = p;
     
                    bmp.Save(FileName, GetCodecInfo("image/jpeg"), ps);
     
                    bmp.Dispose();
     
                    return true;
                }
                catch
                {
                    bmp.Dispose();
                    return false;
                }
     
            }
            #endregion
     
            #region 将图片压缩到指定大小
            /// <summary>
            /// 将图片压缩到指定大小
            /// </summary>
            /// <param name="FileName">待压缩图片</param>
            /// <param name="size">期望压缩后的尺寸</param>
            public void CompressPhoto(string FileName, int size)
            {
                if (!System.IO.File.Exists(FileName))
                    return;
     
                int nCount = 0;
                System.IO.FileInfo oFile = new System.IO.FileInfo(FileName);
                long nLen = oFile.Length;
                while (nLen > size * 1024 && nCount < 10)
                {
                    string dir = oFile.Directory.FullName;
                    string TempFile = System.IO.Path.Combine(dir, Guid.NewGuid().ToString() + "." + oFile.Extension);
                    oFile.CopyTo(TempFile, true);
     
                    KiSaveAsJPEG(TempFile, FileName, 70);
     
                    try
                    {
                        System.IO.File.Delete(TempFile);
                    }
                    catch { }
     
                    nCount++;
     
                    oFile = new System.IO.FileInfo(FileName);
                    nLen = oFile.Length;
                }
            }
            #endregion
     
            #endregion
     
     
            #region common method
     
            /// <summary>
            /// 图片上传错误编码
            /// </summary>
            /// <param name="code"></param>
            /// <returns></returns>
            private string GetCodeMessage(int code)
            {
                var dic = new Dictionary<int, string>(){
            {0,"系统配置错误"},
            {1,"上传图片成功"},
            {2,string.Format( "对不起,上传格式错误!请上传{0}格式图片",SetAllowFormat)},
            {3,string.Format("超过文件上传大小,不得超过{0}M",SetAllowSize)},
            {4,"未上传文件"},
            {5,""},
            {6,"缩略图长度和宽度配置错误"},
            {7,"检测图片宽度限制"}
             };
                return dic[code];
            }
            private void TryError(ResponseMessage rm, int code)
            {
                rm.IsError = true;
                rm.Message = GetCodeMessage(code);
            }
            private void TryError(ResponseMessage rm, string message)
            {
                rm.IsError = true;
                rm.Message = message;
            }
            #endregion
     
            #region models
            public enum CutMode
            {
                /// <summary>
                /// 根据高宽剪切
                /// </summary>
                CutWH = 1,
                /// <summary>
                /// 根据宽剪切
                /// </summary>
                CutW = 2,
                /// <summary>
                /// 根据高剪切
                /// </summary>
                CutH = 3,
                /// <summary>
                /// 缩放不剪裁
                /// </summary>
                CutNo = 4
            }
            public class ResponseMessage
            {
                /// <summary>
                /// 是否遇到错误
                /// </summary>
                public bool IsError { get; set; }
                /// <summary>
                /// web路径
                /// </summary>
                public string WebPath { get; set; }
                /// <summary>
                /// 文件物理路径
                /// </summary>
                public string filePath { get; set; }
                /// <summary>
                /// 反回消息
                /// </summary>
                public string Message { get; set; }
                /// <summary>
                /// 文件大小
                /// </summary>
                public double Size { get; set; }
                /// <summary>
                /// 图片名
                /// </summary>
                public string FileName { get; set; }
                /// <summary>
                /// 图片目录
                /// </summary>
                public string Directory
                {
                    get
                    {
                        if (WebPath == null) return null;
                        return WebPath.Replace(FileName, "");
                    }
                }
                /// <summary>
                /// 缩略图路径
                /// </summary>
                public string SmallPath(int index)
                {
                    return string.Format("{0}{1}_{2}{3}", Directory, Path.GetFileNameWithoutExtension(FileName), index, Path.GetExtension(FileName));
                }
            }
            #endregion
        }
     
    }
  • 相关阅读:
    计算某一日期是在一年中第几周
    动态生成web表-asp.net table
    sql server 小技巧(7) 导出完整sql server 数据库成一个sql文件,包含表结构及数据
    循环取月的三位英语名 Jan Feb
    Python面向对象编程
    算法
    UDP Sockets in C#
    C++ 11
    GNU Make
    C++ 11
  • 原文地址:https://www.cnblogs.com/lsgsanxiao/p/7110978.html
Copyright © 2011-2022 走看看