【Code Art / C#】随机贝塞尔曲线效果测试

贝塞尔曲线是通过几个控制点来绘制曲线的一种方法。通过若干个贝塞尔曲线随机组合，然后随机移动每个控制点，会实现怎样的效果呢？

用这样简单粗暴的思路，写了以下绘制代码。

然后将画完的一帧做模糊处理，不擦除画布继续画一帧，然后用Timer循环绘制，便实现了如图所示的效果。

以下为随机绘制一帧的代码，如需要动画效果和如图所示的效果请参照以上思路自行实现。

using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Runtime.InteropServices;
using sf = RandBezier.SystemFramework;

namespace RandBezier
{
/// <summary>
/// 贝塞尔节点结构
/// </summary>
public class RandPoint
{
public RandPoint()
{
this.X = sf.Rand.Next(0, sf.Win_Width);
this.Y = sf.Rand.Next(0, sf.Win_Height);
this.dx = sf.Rand.Next(-100, 100) * 1f / 100;
this.dy = sf.Rand.Next(-100, 100) * 1f / 100;
this.offset_dx = sf.Rand.Next(-100, 100) * 1f / 1000;
this.offset_dy = sf.Rand.Next(-100, 100) * 1f / 1000;
}

public float X { get; set; }
public float Y { get; set; }
public float dx = 0f;
public float dy = 0f;

private float offset_dx = 0f;
private float offset_dy = 0f;
private int count = 0;

/// <summary>
/// 移动处理
/// </summary>
public void Do()
{
this.X += this.dx;
if (this.X < 0 || this.X > sf.Win_Width)
{
this.dx = -this.dx;
this.offset_dx = -this.offset_dx;
}
this.Y += this.dy;
if (this.Y < 0  || this.Y > sf.Win_Height)
{
this.dy = -this.dy;
this.offset_dy = -this.offset_dy;
}
this.dx += this.offset_dx;
if (Math.Abs(this.dx) > 10)
{
this.offset_dx = -this.offset_dx;
}
this.dy += this.offset_dy;
if (Math.Abs(this.dy) > 10)
{
this.offset_dy = -this.offset_dy;
}
if (this.count > 150)
{
this.count = 0;
this.offset_dx = sf.Rand.Next(-100, 100) * 1f / 1000;
this.offset_dy = sf.Rand.Next(-100, 100) * 1f / 1000;
}
this.count++;
}
}

/// <summary>
/// 颜色结构
/// </summary>
public class RandColor
{
private int min = 180;
private int max = 255;

public RandColor()
{
this.R = sf.Rand.Next(min, max);
this.G = sf.Rand.Next(min, max);
this.B = sf.Rand.Next(min, max);
this.offset_r = sf.Rand.Next(-5, 5);
this.offset_g = sf.Rand.Next(-5, 5);
this.offset_b = sf.Rand.Next(-5, 5);
}

public int R { get; set; }
public int G { get; set; }
public int B { get; set; }

private int offset_r = 0;
private int offset_g = 0;
private int offset_b = 0;
private int count = 0;

public void Do()
{
this.R += this.offset_r;
if (this.R < min)
{
this.R = min;
this.offset_r = -this.offset_r;
}
if (this.R > max)
{
this.R = max;
this.offset_r = -this.offset_r;
}
this.G += this.offset_g;
if (this.G < min)
{
this.G = min;
this.offset_g = -this.offset_g;
}
if (this.G > max)
{
this.G = max;
this.offset_g = -this.offset_g;
}
this.B += this.offset_b;
if (this.B < min)
{
this.B = min;
this.offset_b = -this.offset_b;
}
if (this.B > max)
{
this.B = max;
this.offset_b = -this.offset_b;
}
if (this.count > 100)
{
this.count = 0;
this.offset_r = sf.Rand.Next(-5, 5);
this.offset_g = sf.Rand.Next(-5, 5);
this.offset_b = sf.Rand.Next(-5, 5);
}
this.count++;
}

public Color GetColor()
{
return Color.FromArgb(this.R, this.G, this.B);
}
}

/// <summary>
/// 贝塞尔绘制器
/// </summary>
public class BezierDraw
{
private int Width = 800;
private int Height = 600;
private Graphics graphics = null;
private Bitmap bmp_temp = null;
private Bitmap bmp_back = null;
private List<RandPoint> pointList;
private List<PointF> pointDrawList;
private RandColor randColor;

/// <summary>
/// 构造函数
/// </summary>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="g"></param>
public BezierDraw(int width,int height,Graphics g)
{
this.Width = width;
this.Height = height;
this.graphics = g;
this.bmp_temp = new Bitmap(width, height);
this.bmp_back = new Bitmap(width, height);
this.pointList = new List<RandPoint>();
this.randColor = new RandColor();
this.pointDrawList = new List<PointF>();
for (int i = 0; i < 100; i++)
{
pointList.Add(new RandPoint());
}
}

/// <summary>
/// 处理
/// </summary>
public void Do()
{
if (randColor != null)
{
randColor.Do();
}
if (pointDrawList != null && pointList != null)
{
pointDrawList.Clear();
foreach (RandPoint p in pointList)
{
p.Do();
pointDrawList.Add(new PointF(p.X,p.Y));
}
}
}

private int count = 0;

/// <summary>
/// 画出
/// </summary>
public void Draw()
{
if (graphics != null && bmp_temp != null && randColor != null)
{
// 背景图
Graphics gb = Graphics.FromImage(bmp_back);
gb.FillRectangle(new SolidBrush(Color.Black), 0, 0, Width, Height);

// 渐变
if (count > 25)
{
bmp_temp = BitmapCtrlOpacity(bmp_temp, 0.89f);
count = 0;
}
else
{
bmp_temp = BitmapCtrlOpacity(bmp_temp, 0.95f);
}
count++;
bmp_temp = BimapZoom(bmp_temp);
// bmp_temp = GaussianBlur(bmp_temp);
// bmp_temp = BitmapOpacity(bmp_temp, 0.95f);
Graphics g = Graphics.FromImage(bmp_temp);
g.SmoothingMode = SmoothingMode.AntiAlias;

// 画曲线
Pen pen = new Pen(randColor.GetColor());
pen.Width = 1.5f;
g.DrawBeziers(pen, pointDrawList.ToArray());

// 画到背景上
gb.DrawImage(bmp_temp, 0, 0);
// 画到设备上
graphics.DrawImage(bmp_back, 0, 0);
}
}

public static Bitmap BimapZoom(Bitmap srcBitmap)
{
Bitmap bmp = new Bitmap(srcBitmap.Width, srcBitmap.Height);
Bitmap bmp_temp = new Bitmap((int)(srcBitmap.Width / 2.5), (int)(srcBitmap.Height / 2.5));
Graphics g = Graphics.FromImage(bmp_temp);
g.SmoothingMode = SmoothingMode.HighSpeed;
g.DrawImage(srcBitmap, 0, 0, bmp_temp.Width, bmp_temp.Height);
g = Graphics.FromImage(bmp);
g.SmoothingMode = SmoothingMode.HighSpeed;
g.DrawImage(bmp_temp, 0, 0, srcBitmap.Width, srcBitmap.Height);
return bmp;
}

/// <summary>
/// 设置图像透明度
/// </summary>
/// <param name="srcImage">源图像</param>
/// <param name="opacity">透明度</param>
/// <returns>返回图像</returns>
public static Bitmap BitmapCtrlOpacity(Bitmap srcImage, float opacity)
{
float[][] nArray ={ new float[] {1, 0, 0, 0, 0},
new float[] {0, 1, 0, 0, 0},
new float[] {0, 0, 1, 0, 0},
new float[] {0, 0, 0, opacity, 0},
new float[] {0, 0, 0, 0, 1}
};
ColorMatrix matrix = new ColorMatrix(nArray);
ImageAttributes attributes = new ImageAttributes();
attributes.SetColorMatrix(matrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
Bitmap resultImage = new Bitmap(srcImage.Width, srcImage.Height);
Graphics g = Graphics.FromImage(resultImage);
g.SmoothingMode = SmoothingMode.HighSpeed;
g.DrawImage(srcImage, new Rectangle(0, 0, srcImage.Width, srcImage.Height), 0, 0, srcImage.Width, srcImage.Height, GraphicsUnit.Pixel, attributes);
//DrawImage(srcImage, ref resultImage, new Rectangle(0, 0, srcImage.Width, srcImage.Height), new Point(0, 0));
g.Dispose();
return resultImage;
}
}
}