戏说 .NET GDI+系列学习教程(三、Graphics类的应用_验证码)

关于Graphics也有了基本了解下面想说的的是学这个东东干什么呢，到底如何应用
目前常见应用
1、验证码（参照网上的）
2、打印排版（会提到关于条形码大小设置）
3、自定义控件

一、验证码

    class ValidateCode
    {
        #region 定义和初始化配置字段

        //用户存取验证码字符串
        public string validationCode = String.Empty;

        //生成的验证码字符串
        public char[] chars = null;

        /// <summary>
        /// 获取随机验证码
        /// </summary>
        public String ValidationCode
        {
            get { return validationCode; }
        }

        /// <summary>
        /// 验证码字符串的长度
        /// </summary>
        private Int32 validationCodeCount = 4;

        /// <summary>
        /// 获取和设置验证码字符串的长度
        /// </summary>
        public Int32 ValidationCodeCount
        {
            get { return validationCodeCount; }
            set { validationCodeCount = value; }
        }

        /// <summary>
        /// 画板对象
        /// </summary>
        Graphics dc = null;

        //验证码的宽度，默认为130
        private int bgWidth = 130;

        /// <summary>
        /// 验证码的宽度，默认为130
        /// </summary>
        public Int32 Width
        {
            get { return bgWidth; }
            set { bgWidth = value; }
        }

        //验证码的宽度，默认为130
        private int bgHeight = 40;

        /// <summary>
        /// 验证码的高度，默认为40
        /// </summary>
        public Int32 Height
        {
            get { return bgHeight; }
            set { bgHeight = value; }
        }

        //字体大小 字体最小值
        private int fontMinSize = 20;

        /// <summary>
        /// 验证码字体的最小值，默认为20,建议不小于15像素
        /// </summary>
        public Int32 FontMinSize
        {
            get { return fontMinSize; }
            set { fontMinSize = value; }
        }
        //字体大小 字体最大值
        private Int32 fontMaxSize = 25;

        /// <summary>
        /// 验证码字体的最大值，默认为25
        /// </summary>
        public Int32 FontMaxSize
        {
            get { return fontMaxSize; }
            set { fontMaxSize = value; }
        }

        //验证码字体的颜色
        private Color[] fontColor = { };

        /// <summary>
        /// 验证码字体的颜色，默认为系统自动生成字体颜色
        /// </summary>
        public Color[] FontColor
        {
            get { return fontColor; }
            set { fontColor = value; }
        }

        private Color backColor = Color.FromArgb(243, 255, 255);

        /// <summary>
        /// 验证码的背景色，默认为Color.FromArgb(243, 251, 254)
        /// </summary>
        public Color BackgroundColor
        {
            get { return backColor; }
            set { backColor = value; }
        }

        //贝塞尔曲线的条数,默认为3条
        private Int32 bezierCount = 3;

        /// <summary>
        /// 贝塞尔曲线的条数,默认为3条
        /// </summary>
        public Int32 BezierCount
        {
            get { return bezierCount; }
            set { bezierCount = value; }
        }

        //直线条数，默认为3条
        private Int32 lineCount = 3;

        /// <summary>
        /// 直线条数，默认为3条
        /// </summary>
        public Int32 LineCount
        {
            get { return lineCount; }
            set { lineCount = value; }
        }

        //随机字符串列表
        private String charCollection = "2,3,4,5,6,7,8,9,a,s,d,f,g,h,z,c,v,b,n,m,k,q,w,e,r,t,y,u,p,A,S,D,F,G,H,Z,C,V,B,N,M,K,Q,W,E,R,T,Y,U,P"; //定义验证码字符及出现频次 ,避免出现0 o j i l 1 x; 

        /// <summary>
        /// 随机字符串列表，请使用英文状态下的逗号分隔
        /// </summary>
        public String CharCollection
        {
            get { return charCollection; }
            set { charCollection = value; }
        }

        //验证码字符串个数，默认为4个字符
        private Int32 intCount = 4;

        /// <summary>
        /// 验证码字符串个数，默认为4个字符
        /// </summary>
        public Int32 IntCount
        {
            get { return intCount; }
            set { intCount = value; }
        }

        //是否添加噪点，默认添加，噪点颜色为系统随机生成。
        private Boolean isPixel = true;
        /// <summary>
        /// 是否添加噪点，默认添加，噪点颜色为系统随机生成。
        /// </summary>
        public Boolean IsPixel
        {
            get { return isPixel; }
            set { isPixel = value; }
        }

        //是否添加随机噪点字符串，默认添加
        private Boolean isRandString = true;
        /// <summary>
        /// 是否添加随机噪点字符串，默认添加
        /// </summary>
        public Boolean IsRandString
        {
            get { return isRandString; }
            set { isRandString = value; }
        }

        /// <summary>
        /// 随机背景字符串的个数
        /// </summary>
        public Int32 RandomStringCount
        {
            get; set;
        }

        //随机背景字符串的大小
        private Int32 randomStringFontSize = 9;
        /// <summary>
        /// 随机背景字符串的大小
        /// </summary>
        public Int32 RandomStringFontSize
        {
            get { return randomStringFontSize; }
            set { randomStringFontSize = value; }
        }

        /// <summary>
        /// 是否对图片进行扭曲
        /// </summary>
        public Boolean IsTwist
        {
            get; set;
        }

        /// <summary>
        /// 边框样式
        /// </summary>
        public enum BorderStyle
        {
            /// <summary>
            /// 无边框
            /// </summary>
            None,
            /// <summary>
            /// 矩形边框
            /// </summary>
            Rectangle,
            /// <summary>
            /// 圆角边框
            /// </summary>
            RoundRectangle
        }

        /// <summary>
        /// 验证码字符串随机转动的角度 默认40
        /// </summary>
        private Int32 rotationAngle = 40;
        /// <summary>
        /// 验证码字符串随机转动的角度的最大值
        /// </summary>
        public Int32 RotationAngle
        {
            get { return rotationAngle; }
            set { rotationAngle = value; }
        }

        /// <summary>
        /// 设置或获取边框样式
        /// </summary>
        public BorderStyle Border
        {
            get; set;
        }

        /// <summary>
        /// 对验证码图片进行高斯模糊的阀值，如果设置为0
        /// </summary>
        private Double gaussianDeviation = 0;

        /// <summary>
        /// 对验证码图片进行高斯模糊的阀值，如果设置为0，则不对图片进行高斯模糊，该设置可能会对图片处理的性能有较大影响
        /// </summary>
        public Double GaussianDeviation
        {
            get { return gaussianDeviation; }
            set { gaussianDeviation = value; }
        }
        private Int32 brightnessValue = 0;
        /// <summary>
        /// 对图片进行暗度和亮度的调整，如果该值为0，则不调整。该设置会对图片处理性能有较大影响
        /// </summary>
        public Int32 BrightnessValue
        {
            get { return brightnessValue; }
            set { brightnessValue = value; }
        }

        #endregion


        private Point[] strPoint = null;

        Random random = new Random();

        /// <summary>
        /// 构造函数，用于初始化常用变量
        /// </summary>
        public void DrawValidationCode()
        {
            //随机对象 
            //Random类所取到的系统时钟种子接近甚至完全一样
            //解决方案：new Random(Guid.NewGuid().GetHashCode());
            random = new Random(Guid.NewGuid().GetHashCode());
            //坐标数组
            strPoint = new Point[validationCodeCount + 1];
            if (gaussianDeviation < 0)
                gaussianDeviation = 0;
        }

        /// <summary>
        /// 生成验证码
        /// 思路：多张图片合成
        /// 1.验证码背景图片
        /// 1.1.背景包含
        /// 1.1.1.背景颜色
        /// 1.1.2.噪点
        /// 1.1.3.干扰文字
        /// 1.1.4.干扰线条（直线、曲线）
        /// 2.验证码字符
        /// 3.验证码图片扭曲
        /// 4.验证码图片模糊
        /// 5.验证码图片亮度
        /// 6.验证码图片保持在内存流中
        /// </summary>
        /// <param name="target">用于存储图片的一般字节序列</param>
        public MemoryStream CreateImage(string code)
        {
            MemoryStream target = new MemoryStream();
            // 定义图片对象大小，
            Bitmap bit = new Bitmap(bgWidth + 1, bgHeight + 1);
            // 定义 Graphics（画板）根据图片对象 
            dc = Graphics.FromImage(bit);
            /*
                SmoothingModeAntiAlias      指定消除锯齿的呈现。
                SmoothingModeDefault        指定默认模式。
                SmoothingModeHighQuality    指定高质量、低速度呈现。
                SmoothingModeHighSpeed      指定高速度、低质量呈现。
                SmoothingModeInvalid        指定一个无效模式。
                SmoothingModeNone           指定不消除锯齿。
            */
            dc.SmoothingMode = SmoothingMode.HighQuality;
            //文本的呈现模式
            dc.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
            // 插补模式
            dc.InterpolationMode = InterpolationMode.HighQualityBilinear;
            //合成图像的呈现质量
            dc.CompositingQuality = CompositingQuality.HighQuality;
            try
            {
                //清空画板，指定背景色（白色）
                dc.Clear(Color.White);
                DrawValidationCode();
                //DrawImageUnscaled 在指定的位置使用图像的原始物理大小绘制指定的图像
                // 验证码背景
                dc.DrawImageUnscaled(DrawBackground(), 0, 0);
                // 验证码字符
                dc.DrawImageUnscaled(DrawRandomString(code), 0, 0);
                //对图片文字进行扭曲
                bit = AdjustRippleEffect(bit, 5);
                //对图片进行高斯模糊
                if (gaussianDeviation > 0)
                {
                    Gaussian gau = new Gaussian();
                    bit = gau.FilterProcessImage(gaussianDeviation, bit);
                }
                //进行暗度和亮度处理
                if (brightnessValue != 0)
                {
                    //对图片进行调暗处理 
                    bit = AdjustBrightness(bit, brightnessValue);
                }
                bit.Save(target, ImageFormat.Jpeg);
                //输出图片流                    
                return target;

            }
            finally
            {
                //brush.Dispose();        
                bit.Dispose();
                dc.Dispose();
            }
        }

        #region 画验证码背景，例如，增加早点，添加曲线和直线等            
        /// <summary>
        /// 画验证码背景，例如，增加早点，添加曲线和直线等
        /// 1.1.背景包含
        /// 1.1.1.背景颜色
        /// 1.1.2.噪点
        /// 1.1.3.干扰文字
        /// 1.1.4.干扰线条（直线、曲线）
        /// </summary>
        /// <returns>Bitmap 对象</returns>
        private Bitmap DrawBackground()
        {
            Bitmap bit = new Bitmap(bgWidth + 1, bgHeight + 1);
            Graphics g = Graphics.FromImage(bit);
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.Clear(Color.White);
            Rectangle rectangle = new Rectangle(0, 0, bgWidth, bgHeight);
            Brush brush = new SolidBrush(backColor);
            //填充矩形
            g.FillRectangle(brush, rectangle);
            //画噪点           
            if (isPixel)
            {
                g.DrawImageUnscaled(DrawRandomPixel(30), 0, 0);
            }
            // 背景干扰字符
            g.DrawImageUnscaled(DrawRandBgString(), 0, 0);
            //画曲线              
            //g.DrawImageUnscaled(DrawRandomBezier(bezierCount), 0, 0);
            //画直线      
            //g.DrawImageUnscaled(DrawRandomLine(lineCount), 0, 0);
            if (Border == BorderStyle.Rectangle)
            {
                //绘制边框            
                g.DrawRectangle(new Pen(Color.FromArgb(90, 87, 46)), 0, 0, bgWidth, bgHeight);
            }
            else if (Border == BorderStyle.RoundRectangle)
            {
                //画圆角      
                DrawRoundRectangle(g, rectangle, Color.FromArgb(90, 87, 46), 1, 3);
            }
            return bit;
        }
        #endregion

        #region 画随机噪点
        /// <summary>            
        /// 画随机噪点
        /// 在指定区域中随机设置像素点的颜色
        /// </summary>            
        /// <param name="pixNum">噪点的百分比</param>            
        /// <returns></returns>           
        public Bitmap DrawRandomPixel(Int32 pixNum)
        {
            Bitmap b = new Bitmap(bgWidth, bgHeight);
            //透明化
            b.MakeTransparent();
            Graphics graph = Graphics.FromImage(b);
            graph.SmoothingMode = SmoothingMode.HighQuality;
            graph.InterpolationMode = InterpolationMode.HighQualityBilinear;
            //画噪点                
            for (int i = 0; i < (bgHeight * bgWidth) / pixNum; i++)
            {
                int x = random.Next(b.Width);
                int y = random.Next(b.Height);
                //设置随机像素点的颜色
                b.SetPixel(x, y, GetRandomDeepColor());
                //下移坐标重新画点                    
                if ((x + 1) < b.Width && (y + 1) < b.Height)
                {
                    //画图片的前景噪音点   
                    graph.DrawRectangle(new Pen(Color.Silver), random.Next(b.Width), random.Next(b.Height), 1, 1);
                }
            }
            return b;
        }
        #endregion

        #region 画干扰背景文字    
        /// <summary>            
        /// 画背景干扰文字            
        /// </summary>            
        /// <returns></returns>           
        private Bitmap DrawRandBgString()
        {
            Bitmap b = new Bitmap(bgWidth, bgHeight);
            String[] randStr = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" };
            //设置透明
            b.MakeTransparent();
            Graphics g = Graphics.FromImage(b);
            g.Clear(Color.Transparent);
            g.PixelOffsetMode = PixelOffsetMode.HighQuality;
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.TextRenderingHint = TextRenderingHint.AntiAlias;
            g.InterpolationMode = InterpolationMode.HighQualityBilinear;
            //设置字体显示格式         
            StringFormat format = new StringFormat(StringFormatFlags.NoClip);
            format.Alignment = StringAlignment.Center;
            format.LineAlignment = StringAlignment.Center;
            FontFamily f = new FontFamily(GenericFontFamilies.Serif);
            Font textFont = new Font(f, randomStringFontSize, FontStyle.Underline);
            int randAngle = 60; //随机转动角度
            for (int i = 0; i < RandomStringCount; i++)
            {
                Brush brush = new System.Drawing.SolidBrush(GetRandomLightColor());
                Point pot = new Point(random.Next(5, bgWidth - 5), random.Next(5, bgHeight - 5));
                //随机转动的度数                
                float angle = random.Next(-randAngle, randAngle);
                //转动画布                 
                g.RotateTransform(angle);
                g.DrawString(randStr[random.Next(randStr.Length)], textFont, brush, pot, format);
                //转回去，为下一个字符做准备
                g.RotateTransform(-angle);
                //释放资源
                brush.Dispose();
            }
            textFont.Dispose();
            format.Dispose();
            f.Dispose();
            return b;
        }
        #endregion

        #region 随机生成贝塞尔曲线           
        /// <summary>            
        /// 随机生成贝塞尔曲线            
        /// </summary>            
        /// <param name="bmp">一个图片的实例</param>            
        /// <param name="lineNum">线条数量</param>            
        /// <returns></returns>       
        public Bitmap DrawRandomBezier(Int32 lineNum)
        {
            Bitmap b = new Bitmap(bgWidth, bgHeight);
            b.MakeTransparent();
            Graphics g = Graphics.FromImage(b);
            g.Clear(Color.Transparent);
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.PixelOffsetMode = PixelOffsetMode.HighQuality;
            GraphicsPath gPath1 = new GraphicsPath();
            Int32 lineRandNum = random.Next(lineNum);
            for (int i = 0; i < (lineNum - lineRandNum); i++)
            {
                Pen p = new Pen(GetRandomDeepColor());
                Point[] point = {
                    new Point(random.Next(1, (b.Width / 10)), random.Next(1, (b.Height))),
                    new Point(random.Next((b.Width / 10) * 2, (b.Width / 10) * 4), random.Next(1, (b.Height))),
                    new Point(random.Next((b.Width / 10) * 4, (b.Width / 10) * 6), random.Next(1, (b.Height))),
                    new Point(random.Next((b.Width / 10) * 8, b.Width), random.Next(1, (b.Height)))
                };
                gPath1.AddBeziers(point);
                g.DrawPath(p, gPath1);
                p.Dispose();
            }
            for (int i = 0; i < lineRandNum; i++)
            {
                Pen p = new Pen(GetRandomDeepColor());
                Point[] point = {
                    new Point(random.Next(1, b.Width), random.Next(1, b.Height)),
                    new Point(random.Next((b.Width / 10) * 2, b.Width), random.Next(1, b.Height)),
                    new Point(random.Next((b.Width / 10) * 4, b.Width), random.Next(1, b.Height)),
                    new Point(random.Next(1, b.Width), random.Next(1, b.Height))
                };
                gPath1.AddBeziers(point);
                g.DrawPath(p, gPath1);
                p.Dispose();
            }
            return b;
        }
        #endregion

        #region 画直线            
        /// <summary>            
        /// 画直线            
        /// </summary>            
        /// <param name="bmp">一个bmp实例</param>            
        /// <param name="lineNum">线条个数</param>            
        /// <returns></returns>           
        public Bitmap DrawRandomLine(Int32 lineNum)
        {
            if (lineNum < 0) throw new ArgumentNullException("参数bmp为空！");
            Bitmap b = new Bitmap(bgWidth, bgHeight);
            b.MakeTransparent();
            Graphics g = Graphics.FromImage(b);
            g.Clear(Color.Transparent);
            g.PixelOffsetMode = PixelOffsetMode.HighQuality;
            g.SmoothingMode = SmoothingMode.HighQuality;
            for (int i = 0; i < lineNum; i++)
            {
                Pen p = new Pen(GetRandomDeepColor());
                Point pt1 = new Point(random.Next(1, (b.Width / 5) * 2), random.Next(b.Height));
                Point pt2 = new Point(random.Next((b.Width / 5) * 3, b.Width), random.Next(b.Height));
                g.DrawLine(p, pt1, pt2);
                p.Dispose();
            }
            return b;
        }
        #endregion

        #region 写入验证码的字符串            
        /// <summary>            
        /// 写入验证码的字符串            
        /// </summary>            
        private Bitmap DrawRandomString(string Code)
        {
            if (fontMaxSize >= (bgHeight / 5) * 4)
                throw new ArgumentException("字体最大值参数FontMaxSize与验证码高度相近，这会导致描绘验证码字符串时出错，请重新设置参数！");
            Bitmap b = new Bitmap(bgWidth, bgHeight);
            b.MakeTransparent();
            Graphics g = Graphics.FromImage(b);
            g.Clear(Color.Transparent);
            g.PixelOffsetMode = PixelOffsetMode.Half;
            g.SmoothingMode = SmoothingMode.HighQuality;
            g.TextRenderingHint = TextRenderingHint.SingleBitPerPixelGridFit;
            g.InterpolationMode = InterpolationMode.HighQualityBilinear;
            chars = Code.ToCharArray();            //拆散字符串成单字符数组     
            validationCode = chars.ToString();
            //设置字体显示格式            
            StringFormat format = new StringFormat(StringFormatFlags.NoClip);
            format.Alignment = StringAlignment.Center;
            format.LineAlignment = StringAlignment.Center;
            FontFamily f = new FontFamily(GenericFontFamilies.Monospace);
            Int32 charNum = chars.Length;
            Point sPoint = new Point();
            Int32 fontSize = 12;
            validationCodeCount = charNum;
            for (int i = 0; i < validationCodeCount; i++)
            {
                //定义字体                 
                Font textFont = new Font(f, random.Next(fontMinSize, fontMaxSize), FontStyle.Bold);
                //定义画刷，用于写字符串          
                //Brush brush = new SolidBrush(GetRandomDeepColor());    
                Int32 textFontSize = Convert.ToInt32(textFont.Size);
                fontSize = textFontSize;
                //Point point = new Point(random.Next((bgWidth / charNum) * i + 5, (bgWidth / charNum) * (i + 1)), random.Next(bgHeight / 5 + textFontSize / 2, bgHeight - textFontSize / 2));
                // 字符位置坐标
                Point point = new Point(random.Next((bgWidth / charNum) * i + 2, (bgWidth / charNum) * (i + 1) - (textFontSize / 2)), random.Next(bgHeight / 5 + textFontSize / 2, bgHeight - textFontSize / 2));
                //如果当前字符X坐标小于字体的二分之一大小     
                if (point.X < textFontSize / 2)
                {
                    point.X = point.X + textFontSize / 2;
                }
                //防止文字叠加         
                if (i > 0 && (point.X - sPoint.X < (textFontSize / 2 + textFontSize / 2)))
                {
                    point.X = point.X + textFontSize;
                }
                //如果当前字符X坐标大于图片宽度，就减去字体的宽度        
                if (point.X > (bgWidth - textFontSize / 2))
                {
                    point.X = bgWidth - textFontSize / 2;
                }
                sPoint = point;
                float angle = random.Next(-rotationAngle, rotationAngle);//转动的度数   
                g.TranslateTransform(point.X, point.Y);
                g.RotateTransform(angle);

                Rectangle myretang = new Rectangle(0, 1, Convert.ToInt32(textFont.Size), Convert.ToInt32(textFont.Size));
                Color c = GetRandomDeepColor();
                //设置渐变画刷
                LinearGradientBrush mybrush2 = new LinearGradientBrush(myretang, c, GetLightColor(c, 120), random.Next(180));
                g.DrawString(chars[i].ToString(), textFont, mybrush2, 1, 1, format);

                g.RotateTransform(-angle);//转回去
                g.TranslateTransform(-point.X, -point.Y);//移动光标到指定位置，每个字符紧凑显示，避免被软件识别
                strPoint[i] = point;
                textFont.Dispose();
                mybrush2.Dispose();
            }
            return b;
        }
        #endregion

        #region 增加或減少亮度
        /// <summary>            
        /// 增加或減少亮度            
        /// </summary>            
        /// <param name="img">System.Drawing.Image Source </param>           
        /// <param name="valBrightness">0~255</param>            
        /// <returns></returns>       
        public System.Drawing.Bitmap AdjustBrightness(System.Drawing.Image img, int valBrightness)
        {
            // 讀入欲轉換的圖片並轉成為 Bitmap             
            System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(img);
            for (int y = 0; y < bitmap.Height; y++)
            {
                for (int x = 0; x < bitmap.Width; x++)
                {
                    // 取得每一個 pixel         
                    var pixel = bitmap.GetPixel(x, y);
                    // 判斷 如果處理過後 255 就設定為 255 如果小於則設定為 0         
                    var pR = ((pixel.R + valBrightness > 255) ? 255 : pixel.R + valBrightness) < 0 ? 0 : ((pixel.R + valBrightness > 255) ? 255 : pixel.R + valBrightness);
                    var pG = ((pixel.G + valBrightness > 255) ? 255 : pixel.G + valBrightness) < 0 ? 0 : ((pixel.G + valBrightness > 255) ? 255 : pixel.G + valBrightness);
                    var pB = ((pixel.B + valBrightness > 255) ? 255 : pixel.B + valBrightness) < 0 ? 0 : ((pixel.B + valBrightness > 255) ? 255 : pixel.B + valBrightness);
                    // 將改過的 RGB 寫回         
                    System.Drawing.Color newColor = System.Drawing.Color.FromArgb(pixel.A, pR, pG, pB);
                    bitmap.SetPixel(x, y, newColor);
                }
            }
            // 回傳結果      
            return bitmap;
        }
        #endregion

        #region 水波纹效果    
        /// <summary>           
        /// 水波纹效果            
        /// </summary>            
        /// <param name="src"></param>            
        /// <param name="nWave">坡度</param>            
        /// www.it165.net            
        /// <returns></returns>            
        public Bitmap AdjustRippleEffect(Bitmap src, short nWave)
        {
            int nWidth = src.Width;
            int nHeight = src.Height;
            // 透过公式进行水波纹的採样             
            PointF[,] fp = new PointF[nWidth, nHeight];
            Point[,] pt = new Point[nWidth, nHeight];
            Point mid = new Point();
            mid.X = nWidth / 2;
            mid.Y = nHeight / 2;
            double newX, newY;
            double xo, yo;
            //先取样将水波纹座标跟RGB取出  
            for (int x = 0; x < nWidth; ++x)
                for (int y = 0; y < nHeight; ++y)
                {
                    xo = ((double)nWave * Math.Sin(2.0 * 3.1415 * (float)y / 128.0));
                    yo = ((double)nWave * Math.Cos(2.0 * 3.1415 * (float)x / 128.0));
                    newX = (x + xo);
                    newY = (y + yo);
                    if (newX > 0 && newX < nWidth)
                    {
                        fp[x, y].X = (float)newX;
                        pt[x, y].X = (int)newX;
                    }
                    else
                    {
                        fp[x, y].X = (float)0.0;
                        pt[x, y].X = 0;
                    }
                    if (newY > 0 && newY < nHeight)
                    {
                        fp[x, y].Y = (float)newY;
                        pt[x, y].Y = (int)newY;
                    }
                    else
                    {
                        fp[x, y].Y = (float)0.0;
                        pt[x, y].Y = 0;
                    }
                }
            //进行合成              
            Bitmap bSrc = (Bitmap)src.Clone();
            // 依照 Format24bppRgb 每三个表示一 Pixel 0: 蓝 1: 绿 2: 红   
            BitmapData bitmapData = src.LockBits(new Rectangle(0, 0, src.Width, src.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            BitmapData bmSrc = bSrc.LockBits(new Rectangle(0, 0, bSrc.Width, bSrc.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            int scanline = bitmapData.Stride;
            IntPtr Scan0 = bitmapData.Scan0;
            IntPtr SrcScan0 = bmSrc.Scan0;
            //指针在c#中是不提倡使用的，有关指针的操作被认为是不安全的(unsafe)。因此运行这段代码之前，先要改一个地方，否则编译不过无法运行。
            //修改方法：找到你的项目，在项目图标上点右键，选项目属性（Properties）,Build标签页里把Allow unsafe code勾选上
            unsafe
            {
                //指针
                byte* p = (byte*)(void*)Scan0;
                byte* pSrc = (byte*)(void*)SrcScan0;
                int nOffset = bitmapData.Stride - src.Width * 3;
                int xOffset, yOffset;
                for (int y = 0; y < nHeight; ++y)
                {
                    for (int x = 0; x < nWidth; ++x)
                    {
                        xOffset = pt[x, y].X;
                        yOffset = pt[x, y].Y;
                        if (yOffset >= 0 && yOffset < nHeight && xOffset >= 0 && xOffset < nWidth)
                        {
                            p[0] = pSrc[(yOffset * scanline) + (xOffset * 3)];
                            p[1] = pSrc[(yOffset * scanline) + (xOffset * 3) + 1];
                            p[2] = pSrc[(yOffset * scanline) + (xOffset * 3) + 2];
                        }
                        p += 3;
                    }
                    p += nOffset;
                }
            }
            src.UnlockBits(bitmapData);
            bSrc.UnlockBits(bmSrc);
            return src;
        }
        #endregion

        #region 生成随机字符串
        /// <summary>            
        /// 生成随机字符串                
        /// </summary>            
        /// <returns></returns>            
        public string GetRandomString(Int32 textLength)
        {
            string[] randomArray = charCollection.Split(','); //将字符串生成数组        
            int arrayLength = randomArray.Length;
            string randomString = "";
            for (int i = 0; i < textLength; i++)
            {
                randomString += randomArray[random.Next(0, arrayLength)];
            }
            return randomString; //长度是textLength +1          
        }
        #endregion

        #region 随机生成颜色值    
        /// <summary>      
        /// 生成随机深颜色            
        /// </summary>            
        /// <returns></returns>  
        public Color GetRandomDeepColor()
        {
            int nRed, nGreen, nBlue;
            // nBlue,nRed  nGreen 相差大一点 nGreen 小一些    
            //int high = 255;                     
            int redLow = 160;
            int greenLow = 100;
            int blueLow = 160;
            nRed = random.Next(redLow);
            nGreen = random.Next(greenLow);
            nBlue = random.Next(blueLow);
            Color color = Color.FromArgb(nRed, nGreen, nBlue);
            return color;
        }
        /// <summary>            
        /// 生成随机浅颜色            
        /// </summary>            
        /// <returns>randomColor</returns>     
        public Color GetRandomLightColor()
        {
            int nRed, nGreen, nBlue;
            //越大颜色越浅       
            int low = 180;            //色彩的下限              
            int high = 255;            //色彩的上限          
            nRed = random.Next(high) % (high - low) + low;
            nGreen = random.Next(high) % (high - low) + low;
            nBlue = random.Next(high) % (high - low) + low;
            Color color = Color.FromArgb(nRed, nGreen, nBlue);
            return color;
        }
        /// <summary>            
        /// 获取与当前颜色值相加后的颜色            
        /// </summary>            
        /// <param name="c"></param>            
        /// <returns></returns>           
        public Color GetLightColor(Color c, Int32 value)
        {
            int nRed = c.R, nGreen = c.G, nBlue = c.B;
            //越大颜色越浅               
            if (nRed + value < 255 && nRed + value > 0)
            {
                nRed = c.R + 40;
            }
            if (nGreen + value < 255 && nGreen + value > 0)
            {
                nGreen = c.G + 40;
            }
            if (nBlue + value < 255 && nBlue + value > 0)
            {
                nBlue = c.B + 40;
            }
            Color color = Color.FromArgb(nRed, nGreen, nBlue);
            return color;
        }
        #endregion

        #region 绘制圆角矩形      
        /// <summary>            
        /// C# GDI+ 绘制圆角矩形            
        /// </summary>            
        /// <param name="g">Graphics 对象</param>           
        /// <param name="rectangle">Rectangle 对象，圆角矩形区域</param>           
        /// <param name="borderColor">边框颜色</param>            
        /// <param name="borderWidth">边框宽度</param>            
        /// <param name="r">圆角半径</param>           
        private static void DrawRoundRectangle(Graphics g, Rectangle rectangle, Color borderColor, float borderWidth, int r)
        {
            // 如要使边缘平滑，请取消下行的注释      
            g.SmoothingMode = SmoothingMode.HighQuality;  
            Pen p = new Pen(borderColor, borderWidth);
            // 调用 getRoundRectangle 得到圆角矩形的路径，然后再进行绘制     
            g.DrawPath(p, getRoundRectangle(rectangle, r));
        }
        #endregion

        #region 根据普通矩形得到圆角矩形的路径      
        /// <summary>            
        /// 根据普通矩形得到圆角矩形的路径            
        /// </summary>           
        /// <param name="rectangle">原始矩形</param>
        /// <param name="r">半径</param>     
        /// <returns>图形路径</returns> 
        private static GraphicsPath getRoundRectangle(Rectangle rectangle, int r)
        {
            int l = 2 * r;
            // 把圆角矩形分成八段直线、弧的组合，依次加到路径中           
            GraphicsPath gp = new GraphicsPath();
            gp.AddLine(new Point(rectangle.X + r, rectangle.Y), new Point(rectangle.Right - r, rectangle.Y));
            gp.AddArc(new Rectangle(rectangle.Right - l, rectangle.Y, l, l), 270F, 90F);
            gp.AddLine(new Point(rectangle.Right, rectangle.Y + r), new Point(rectangle.Right, rectangle.Bottom - r));
            gp.AddArc(new Rectangle(rectangle.Right - l, rectangle.Bottom - l, l, l), 0F, 90F);
            gp.AddLine(new Point(rectangle.Right - r, rectangle.Bottom), new Point(rectangle.X + r, rectangle.Bottom));
            gp.AddArc(new Rectangle(rectangle.X, rectangle.Bottom - l, l, l), 90F, 90F);
            gp.AddLine(new Point(rectangle.X, rectangle.Bottom - r), new Point(rectangle.X, rectangle.Y + r));
            gp.AddArc(new Rectangle(rectangle.X, rectangle.Y, l, l), 180F, 90F);
            return gp;
        }
        #endregion
    }

调用

        private void frmValidateCode_Load(object sender, EventArgs e)
        {
            ValidateCode vCode = new ValidateCode();
            string code = vCode.GetRandomString(5);
            MemoryStream stream = vCode.CreateImage(code);
            pictureBox1.Image = new Bitmap(stream);
        }

效果