public void Mutate(DnaDrawing drawing)
{
if (Tools.WillMutate(Settings.ActiveRedMutationRate))
{
Red = Tools.GetRandomNumber(Settings.ActiveRedRangeMin, Settings.ActiveRedRangeMax);
drawing.SetDirty();
}
if (Tools.WillMutate(Settings.ActiveGreenMutationRate))
{
Green = Tools.GetRandomNumber(Settings.ActiveGreenRangeMin, Settings.ActiveGreenRangeMax);
drawing.SetDirty();
}
if (Tools.WillMutate(Settings.ActiveBlueMutationRate))
{
Blue = Tools.GetRandomNumber(Settings.ActiveBlueRangeMin, Settings.ActiveBlueRangeMax);
drawing.SetDirty();
}
if (Tools.WillMutate(Settings.ActiveAlphaMutationRate))
{
Alpha = Tools.GetRandomNumber(Settings.ActiveAlphaRangeMin, Settings.ActiveAlphaRangeMax);
drawing.SetDirty();
}
}
public double GetDrawingFitness(DnaDrawing newDrawing)
{
double error = 0;
Renderer.Render(newDrawing, _g, 1);
BitmapData bd = _bmp.LockBits(
new Rectangle(0, 0, newDrawing.Width, newDrawing.Height),
ImageLockMode.ReadOnly,
PixelFormat.Format32bppArgb);
unchecked
{
unsafe
{
fixed (Pixel* psourcePixels = _sourceImagePixels)
{
Pixel* p1 = (Pixel*)bd.Scan0.ToPointer();
Pixel* p2 = psourcePixels;
for (int i = _sourceImagePixels.Length; i > 0; i--, p1++, p2++)
{
int r = p1->R - p2->R;
int g = p1->G - p2->G;
int b = p1->B - p2->B;
error += r * r + g * g + b * b;
}
}
}
}
_bmp.UnlockBits(bd);
return error;
}
public double GetDrawingFitness(DnaDrawing newDrawing)
{
double error = 0;
using (var b = new Bitmap(newDrawing.Width, newDrawing.Height, PixelFormat.Format24bppRgb))
using (Graphics g = Graphics.FromImage(b))
{
Renderer.Render(newDrawing, g, 1);
BitmapData bmd1 = b.LockBits(new Rectangle(0, 0, b.Width, b.Height), ImageLockMode.ReadOnly,
PixelFormat.Format24bppRgb);
for (int y = 0; y < b.Height; y++)
{
for (int x = 0; x < b.Width; x++)
{
Color c1 = GetPixel(bmd1, x, y);
Color c2 = _sourceColors[x, y];
double pixelError = GetColorFitness(c1, c2);
error += pixelError;
}
}
b.UnlockBits(bmd1);
}
return error;
}
//Render a Drawing
public static void Render(DnaDrawing drawing,Graphics g,int scale)
{
g.Clear(Color.Black);
foreach (DnaPolygon polygon in drawing.Polygons)
Render(polygon, g, scale);
}
public static DnaDrawing GetRandom(int width, int height)
{
var drawing = new DnaDrawing(width, height);
for (int i = 0; i < Settings.ActivePolygonsMin; i++)
{
drawing.AddPolygon();
}
return drawing;
}
public static DnaDrawing GetRandom(int width, int height)
{
var drawing = new DnaDrawing(width, height);
for (int i = 0; i < Settings.ActivePolygonsMin; i++)
{
drawing.AddPolygon();
}
return(drawing);
}
override public void Mutate(DnaDrawing drawing)
{
if (tool.WillMutate(Settings.ActiveCircleWidthMutationRate))
{
rx = ry = mutateScalar(rx, 0, Settings.ActiveMaxCircleRadius, drawing);
}
Brush.Mutate(drawing);
MutateOrigin(drawing);
}
private void OpenDNA()
{
_evolutionEngine.Stop();
string openFileName = FileUtil.GetOpenFileName(FileUtil.DnaExtension);
if (_evolutionEngine.OpenDNA(openFileName))
{
guiDrawing = _evolutionEngine.GetGuiDrawing();
pnlCanvas.Invalidate();
lastRepaint = DateTime.Now;
}
}
public DnaDrawing Clone()
{
var drawing = new DnaDrawing();
drawing.Polygons = new List <DnaPolygon>();
foreach (DnaPolygon polygon in Polygons)
{
drawing.Polygons.Add(polygon.Clone());
}
return(drawing);
}
private void RemovePoint(DnaDrawing drawing)
{
if (Points.Count > Settings.ActivePointsPerPolygonMin)
{
if (drawing.PointCount > Settings.ActivePointsMin)
{
int index = Tools.GetRandomNumber(0, Points.Count);
Points.RemoveAt(index);
drawing.SetDirty();
}
}
}
public void Mutate(DnaDrawing drawing)
{
if (Tools.WillMutate(Settings.ActiveAddPointMutationRate))
{
AddPoint(drawing);
}
if (Tools.WillMutate(Settings.ActiveRemovePointMutationRate))
{
RemovePoint(drawing);
}
Brush.Mutate(drawing);
Points.ForEach(p => p.Mutate(drawing));
}
public void MutateOrigin(DnaDrawing drawing)
{
if (tool.WillMutate(Settings.ActiveMovePointMaxMutationRate))
{
origin.X = tool.GetRandomNumber(-Settings.ActiveMaxCircleRadius, Tools.MaxWidth + Settings.ActiveMaxCircleRadius);
origin.Y = tool.GetRandomNumber(-Settings.ActiveMaxCircleRadius, Tools.MaxHeight + Settings.ActiveMaxCircleRadius);
drawing.SetDirty();
}
if (tool.WillMutate(Settings.ActiveMovePointMidMutationRate))
{
origin.X =
Math.Min(
Math.Max(-Settings.ActiveMaxCircleRadius,
origin.X +
tool.GetRandomNumber(-Settings.ActiveMovePointRangeMid,
Settings.ActiveMovePointRangeMid)), Tools.MaxWidth + Settings.ActiveMaxCircleRadius);
origin.Y =
Math.Min(
Math.Max(-Settings.ActiveMaxCircleRadius,
origin.Y +
tool.GetRandomNumber(-Settings.ActiveMovePointRangeMid,
Settings.ActiveMovePointRangeMid)), Tools.MaxHeight + Settings.ActiveMaxCircleRadius);
drawing.SetDirty();
}
if (tool.WillMutate(Settings.ActiveMovePointMinMutationRate))
{
origin.X =
Math.Min(
Math.Max(-Settings.ActiveMaxCircleRadius,
origin.X +
tool.GetRandomNumber(-Settings.ActiveMovePointRangeMin,
Settings.ActiveMovePointRangeMin)), Tools.MaxWidth + Settings.ActiveMaxCircleRadius);
origin.Y =
Math.Min(
Math.Max(-Settings.ActiveMaxCircleRadius,
origin.Y +
tool.GetRandomNumber(-Settings.ActiveMovePointRangeMin,
Settings.ActiveMovePointRangeMin)), Tools.MaxHeight + Settings.ActiveMaxCircleRadius);
drawing.SetDirty();
}
}
public void Mutate(DnaDrawing drawing)
{
if (Tools.WillMutate(Settings.ActiveMovePointMaxMutationRate))
{
X = Tools.GetRandomNumber(0, Tools.MaxWidth);
Y = Tools.GetRandomNumber(0, Tools.MaxHeight);
drawing.SetDirty();
}
if (Tools.WillMutate(Settings.ActiveMovePointMidMutationRate))
{
X =
Math.Min(
Math.Max(0,
X +
Tools.GetRandomNumber(-Settings.ActiveMovePointRangeMid,
Settings.ActiveMovePointRangeMid)), Tools.MaxWidth);
Y =
Math.Min(
Math.Max(0,
Y +
Tools.GetRandomNumber(-Settings.ActiveMovePointRangeMid,
Settings.ActiveMovePointRangeMid)), Tools.MaxHeight);
drawing.SetDirty();
}
if (Tools.WillMutate(Settings.ActiveMovePointMinMutationRate))
{
X =
Math.Min(
Math.Max(0,
X +
Tools.GetRandomNumber(-Settings.ActiveMovePointRangeMin,
Settings.ActiveMovePointRangeMin)), Tools.MaxWidth);
Y =
Math.Min(
Math.Max(0,
Y +
Tools.GetRandomNumber(-Settings.ActiveMovePointRangeMin,
Settings.ActiveMovePointRangeMin)), Tools.MaxHeight);
drawing.SetDirty();
}
}
public double mutateScalar(double scalar, double min, double max, DnaDrawing drawing)
{
if (tool.WillMutate(Settings.ActiveCircleSizeMidMutationRate))
{
drawing.SetDirty();
return(Math.Min(Math.Max(min, scalar +
tool.GetRandomNumber(-Settings.ActiveCircleSizeRangeMid,
Settings.ActiveCircleSizeRangeMid)), max));
}
if (tool.WillMutate(Settings.ActiveCircleSizeMinMutationRate))
{
drawing.SetDirty();
return(Math.Min(Math.Max(min, scalar +
tool.GetRandomNumber(-Settings.ActiveCircleSizeRangeMin,
Settings.ActiveCircleSizeRangeMin)), max));
}
return(scalar);
}
virtual public void Mutate(DnaDrawing drawing)
{
Console.WriteLine("Mutating Ellipse");
if (tool.WillMutate(Settings.ActiveCircleWidthMutationRate))
{
rx = mutateScalar(rx, 0, Settings.ActiveMaxCircleRadius, drawing);
}
if (tool.WillMutate(Settings.ActiveCircleHeightMutationRate))
{
ry = mutateScalar(ry, 0, Settings.ActiveMaxCircleRadius, drawing);
}
if (tool.WillMutate(Settings.ActiveRotationMutationRate))
{
rotation = mutateScalar(rotation, -999.0, 999.0, drawing);
}
Brush.Mutate(drawing);
MutateOrigin(drawing);
}
private void AddPoint(DnaDrawing drawing)
{
if (Points.Count < Settings.ActivePointsPerPolygonMax)
{
if (drawing.PointCount < Settings.ActivePointsMax)
{
var newPoint = new DnaPoint();
int index = Tools.GetRandomNumber(1, Points.Count - 1);
DnaPoint prev = Points[index - 1];
DnaPoint next = Points[index];
newPoint.X = (prev.X + next.X) / 2;
newPoint.Y = (prev.Y + next.Y) / 2;
Points.Insert(index, newPoint);
drawing.SetDirty();
}
}
}
new public void Mutate(DnaDrawing drawing)
{
Brush.Mutate(drawing);
MutateOrigin(drawing);
}
public bool OpenDNA(string openFileName)
{
Stop();
DnaDrawing drawing = Serializer.DeserializeDnaDrawing(openFileName);
if (drawing != null)
{
if (_currentDrawing == null)
{
_currentDrawing = drawing;
}
else
{
lock (_currentDrawing)
{
_currentDrawing = drawing;
}
}
return true;
}
return false;
}
private void StartEvolution()
{
if (_currentDrawing == null)
_currentDrawing = GetNewInitializedDrawing(_sourceBitmap.Width, _sourceBitmap.Height);
while (IsRunning)
{
DnaDrawing newDrawing;
lock (_currentDrawing)
{
newDrawing = _currentDrawing.Clone();
}
newDrawing.Mutate();
_candidates++;
if (newDrawing.IsDirty)
{
_generation++;
double newErrorLevel = _fitnessCalculator.GetDrawingFitness(newDrawing);
if (newErrorLevel <= _errorLevel)
{
_selected++;
lock (_currentDrawing)
{
_currentDrawing = newDrawing;
}
_errorLevel = newErrorLevel;
Console.WriteLine("{0} {1} {2}",
_selected,
_generation,
_errorLevel);
}
}
//else, discard new drawing
}
}
private void tmrRedraw_Tick(object sender, EventArgs e)
{
// if (_evolutionEngine.CurrentDrawing == null)
// return;
var stats = _evolutionEngine.CalculateStatistics();
toolStripStatusLabelFitness.Text = stats.ErrorLevel.ToString();
toolStripStatusLabelGeneration.Text = stats.Generation.ToString();
toolStripStatusLabelSelected.Text = stats.Selected.ToString();
toolStripStatusLabelPoints.Text = stats.NumPoints.ToString();
toolStripStatusLabelPolygons.Text = stats.NumPolygons.ToString();
toolStripStatusLabelAvgPoints.Text = string.Format("{0:0.00}", stats.AveragePointsPerPolygon);
bool shouldRepaint = false;
if (repaintIntervall.Ticks > 0)
if (lastRepaint < DateTime.Now - repaintIntervall)
shouldRepaint = true;
if (repaintOnSelectedSteps > 0)
if (lastSelected + repaintOnSelectedSteps < stats.Selected)
shouldRepaint = true;
if (shouldRepaint)
{
guiDrawing = _evolutionEngine.GetGuiDrawing();
pnlCanvas.Invalidate();
lastRepaint = DateTime.Now;
lastSelected = stats.Selected;
}
}
public static void SerializeBinary(DnaDrawing drawing, string fileName)
{
if (fileName == null)
return;
try
{
var formatter = new BinaryFormatter();
using (var writer = new FileStream(fileName, FileMode.Create))
{
formatter.Serialize(writer, drawing);
}
}
catch
{
// do nothing
}
}
public static void Serialize(DnaDrawing drawing, string fileName)
{
if (fileName == null)
return;
if (fileName.EndsWith("xml"))
{
try
{
var serializer = new XmlSerializer(drawing.GetType());
using (var writer = new FileStream(fileName, FileMode.Create))
{
serializer.Serialize(writer, drawing);
}
}
catch
{
// do nothing
}
}
else
{
SerializeBinary(drawing, fileName);
}
}
