public static void Mutate(this DnaBrush dnaBrush, DnaDrawing dnaDrawing) { if (Tools.WillMutate(Settings.ActiveRedMutationRate)) { dnaBrush.Red = Tools.GetRandomNumber(Settings.ActiveRedRangeMin, Settings.ActiveRedRangeMax); dnaDrawing.SetDirty(); } if (Tools.WillMutate(Settings.ActiveGreenMutationRate)) { dnaBrush.Green = Tools.GetRandomNumber(Settings.ActiveGreenRangeMin, Settings.ActiveGreenRangeMax); dnaDrawing.SetDirty(); } if (Tools.WillMutate(Settings.ActiveBlueMutationRate)) { dnaBrush.Blue = Tools.GetRandomNumber(Settings.ActiveBlueRangeMin, Settings.ActiveBlueRangeMax); dnaDrawing.SetDirty(); } if (Tools.WillMutate(Settings.ActiveAlphaMutationRate)) { dnaBrush.Alpha = Tools.GetRandomNumber(Settings.ActiveAlphaRangeMin, Settings.ActiveAlphaRangeMax); dnaDrawing.SetDirty(); } }
public static void Mutate(this DnaDrawing dnaDrawing) { if (Tools.WillMutate(Settings.ActiveAddPolygonMutationRate)) { if (dnaDrawing.AddPolygon()) { dnaDrawing.SetDirty(); } } if (Tools.WillMutate(Settings.ActiveRemovePolygonMutationRate)) { if (dnaDrawing.RemovePolygon()) { dnaDrawing.SetDirty(); } } if (Tools.WillMutate(Settings.ActiveMovePolygonMutationRate)) { if (dnaDrawing.MovePolygon()) { dnaDrawing.SetDirty(); } } foreach (DnaPolygon polygon in dnaDrawing.Polygons) { polygon.Mutate(dnaDrawing); } }
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 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 (Exception) { } } else { SerializeBinary(drawing, fileName); } }
private static DnaDrawing GetNewInitializedDrawing(JobInfo info) { var drawing = new DnaDrawing(); drawing.Init(info); return(drawing); }
private void StartEvolution() { SetupSourceColorMatrix(); if (currentDrawing == null) { currentDrawing = GetNewInitializedDrawing(); } lastSelected = 0; const int numThreads = 16; var tasks = new Task <Tuple <DnaDrawing, double> > [numThreads]; while (isRunning) { for (var i = 0; i < numThreads; i++) { tasks[i] = Task.Factory.StartNew(() => Work(currentDrawing, sourceColors)); } Task.WaitAll(tasks); foreach (var task in tasks) { if (task.Result.Item1 == null || task.Result.Item2 > errorLevel) { continue; } selected++; currentDrawing = task.Result.Item1; errorLevel = task.Result.Item2; } generation++; } }
private void redraw() { guiDrawing = currentDrawing; pnlCanvas.Invalidate(); lastRepaint = DateTime.Now; lastSelected = currentEvolver.selected; }
//Render a Drawing public static void Render(DnaDrawing drawing,Graphics g,int scale) { g.Clear(Color.Black); foreach (DnaShape s in drawing.Shapes) s.Render(g, scale); }
private void WorkerThreadStart() { Initialize(); while (isRunning) { //assign current work data to a tmp var, so that we use the same data through the entire itteration //even if data is changed by the main thread, nothing will break or go wrong. WorkerData tmpData = data; if (tmpData.hasNewParent) { Tools.InitRandom(tmpData.randomSeed); tmpData.hasNewParent = false; } DnaDrawing newDrawing = GetMutatedSeedSyncedDrawing(); double newErrorLevel = FitnessCalculator.GetDrawingFitness(newDrawing, info.SourceImage, partitionY, partitionHeight); var result = new DnaPartitionResult { Drawing = newDrawing, ErrorLevel = newErrorLevel, }; tmpData.workerTail.Enqueue(result); } }
private DnaDrawing GetMutatedSeedSyncedDrawing() { DnaDrawing newDrawing = parentDrawing.Clone(); newDrawing.Mutate(info); return(newDrawing); }
private static DnaDrawing GetNewInitializedDrawing() { var drawing = new DnaDrawing(); drawing.Init(); // HAKKAB for loobis Settings.cs-is sätestatud minimaalselt arvu Polügoone lisama return(drawing); }
public double GetNextErrorLevel() { var drawing = new DnaDrawing(); drawing.SourceImage = sourceImage; drawing.Polygons = new List <DnaPolygon>(); int i = 0; foreach (LayeredWorker worker in workers) { i++; if (i == 1) { continue; } DnaDrawing workerDrawing = worker.GetDrawing(); drawing.Polygons.AddRange(workerDrawing.Clone().Polygons); //drawing = worker.GetDrawing(); } currentDrawing = drawing; currentErrorLevel = FitnessCalculator.GetDrawingFitness(drawing, sourceImage); return(currentErrorLevel); }
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); }
public static double GetDrawingFitness(DnaDrawing newDrawing, Color[,] sourceColors) { double error = 0; { Renderer.Render(newDrawing, g, 1); BitmapData bmd1 = b.LockBits(new Rectangle(0, 0, Tools.MaxWidth, Tools.MaxHeight), ImageLockMode.ReadOnly, PixelFormat.Format24bppRgb); for (int y = 0; y < Tools.MaxHeight; y++) { for (int x = 0; x < Tools.MaxWidth; x++) { Color c1 = GetPixel(bmd1, x, y); Color c2 = sourceColors[x, y]; double pixelError = GetColorFitness(c1, c2); error += pixelError; } } b.UnlockBits(bmd1); } return(error); }
private static DnaDrawing GetNewInitializedDrawing(Settings settings) { var drawing = new DnaDrawing(); drawing.Init(settings); return(drawing); }
internal static long GetDrawingFitness(DnaDrawing newDrawing, SourceImage sourceImage, Bitmap bgImage, Bitmap fgImage) { long error = 0; if (bmp == null) { bmp = new Bitmap(sourceImage.Width, sourceImage.Height, PixelFormat.Format32bppArgb); g = Graphics.FromImage(bmp); } if (bgImage != null) { g.DrawImage(bgImage, 0, 0); } else { g.Clear(Color.Black); } Renderer.Render(newDrawing, g, 1); if (fgImage != null) { g.DrawImage(fgImage, 0, 0); } BitmapData bd = bmp.LockBits( new Rectangle(0, 0, sourceImage.Width, sourceImage.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); unchecked { unsafe { fixed(Pixel *psourcePixels = sourceImage.Pixels) { int partitionEnd = sourceImage.Height * sourceImage.Width; var p1 = (Pixel *)bd.Scan0.ToPointer(); Pixel *p2 = psourcePixels; for (int i = 0; i < partitionEnd; 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); // error += newDrawing.Polygons.Count * 3 ; return(error); }
//Render a Drawing internal static void Render(DnaDrawing drawing, Graphics g, int scale) { for (int i = 0; i < drawing.Polygons.Count; i++) { DnaPolygon polygon = drawing.Polygons[i]; Render(polygon, g, scale); } }
//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 void Init() { Drawing = new DnaDrawing(); Drawing.Init(); Settings = new Settings(); ErrorLevel = double.MaxValue; LastSavedFitness = double.MaxValue; }
private void Initialize() { Tools.InitRandom(data.randomSeed); parentDrawing = new DnaDrawing { Polygons = new List <DnaPolygon>(), }; }
//Render a Drawing public static void Render(DnaDrawing drawing, Graphics g, int scale) { g.Clear(Color.Black); foreach (DnaShape s in drawing.Shapes) { s.Render(g, scale); } }
public static bool RemovePolygon(this DnaDrawing dnaDrawing) { if (dnaDrawing.Polygons.Count > Settings.ActivePolygonsMin) { int index = Tools.GetRandomNumber(0, dnaDrawing.Polygons.Count); dnaDrawing.Polygons.RemoveAt(index); return(true); } return(false); }
internal WorkerInstance(int randomSeed, JobInfo info) { this.randomSeed = randomSeed; this.info = info; info.InitRandom(randomSeed); parentDrawing = new DnaDrawing { Polygons = new List <DnaPolygon>(), }; }
private static void SaveDnaDrawingToFile(string fileName, DnaDrawing drawing) { DnaDrawing clone; clone = drawing.Clone(); if (clone != null) { Serializer.Serialize(clone, fileName); } }
private void Redraw() { lock (currentDrawing) { guiDrawing = currentDrawing.Clone(); } pnlCanvas.Invalidate(); lastRepaint = DateTime.Now; lastSelected = selected; }
public override void Mutate(DnaDrawing drawing) { if (tool.WillMutate(Settings.ActiveCircleWidthMutationRate)) { rx = ry = mutateScalar(rx, 0, Settings.ActiveMaxCircleRadius, drawing); } Brush.Mutate(drawing); MutateOrigin(drawing); }
public static Bitmap RenderToBitmap(DnaDrawing drawing, int scale) { var bitmap = new Bitmap(Tools.MaxWidth * scale, Tools.MaxHeight * scale, PixelFormat.Format32bppArgb); using (Graphics g = Graphics.FromImage(bitmap)) { Render(drawing, g, scale); } return(bitmap); }
// private void StartEvolution() // { // double errorLevelAtLastSave = double.MaxValue; // Bitmap sourceBitmap = GetSourceBitmap(); // // if (currentCandidate == null) // { // currentCandidate = new Candidate(); // } // lastSelected = 0; // // while (isRunning) // { // var newCandidiate = new Candidate(currentCandidate); // newCandidiate.Drawing.Mutate(); // // if (newCandidiate.Drawing.IsDirty) // { // generation++; // // newCandidiate.CalculateErrorLevel(sourceBitmap); // // if (newCandidiate.ErrorLevel <= currentCandidate.ErrorLevel) // { // selected++; // // lock (currentCandidate) // { // currentCandidate = newCandidiate; // } // // // double percentChange = (errorLevelAtLastSave - newCandidiate.ErrorLevel) / // errorLevelAtLastSave; // if (percentChange > 0.005) // { // SaveImageToFile(newCandidiate.Drawing); // // errorLevelAtLastSave = newCandidiate.ErrorLevel; // // TimeSpan totalTime = DateTime.Now - startTime; // double generationsPerSec = generation/totalTime.TotalSeconds; // int polygons = currentCandidate.Drawing.Polygons.Count; // int points = currentCandidate.Drawing.PointCount; // double pointsPerPolygon = 0; // if (polygons != 0) // pointsPerPolygon = (double)points / polygons; // // // Trace.WriteLine(string.Format( // "{0:yyyy-MM-dd HH:mm:ss} {1,15} {2,15} {3,9:0.0} {4,9} {5,9} {6,9:0.0}", // DateTime.Now, errorLevelAtLastSave, generation, generationsPerSec, points, polygons, pointsPerPolygon)); // } // // } // } // //else, discard new drawing // } // } private void SaveImageToFile(DnaDrawing drawing) { const string filenameFormat = @"F:\Temp\EvoLisaRender\EvoLisa-{0:000000000}.png"; const int scale = 3; string filename = string.Format(filenameFormat, sequence++); using (Bitmap buffer = Renderer.RenderToBitmap(drawing, scale)) { buffer.Save(filename, ImageFormat.Png); } }
public static bool AddPolygon(this DnaDrawing dnaDrawing) { if (dnaDrawing.Polygons.Count < Settings.ActivePolygonsMax) { var newPolygon = DnaPolygon.GetRandom(dnaDrawing.Width, dnaDrawing.Height); int index = Tools.GetRandomNumber(0, dnaDrawing.Polygons.Count); dnaDrawing.Polygons.Insert(index, newPolygon); return(true); } return(false); }
private void tmrRedraw_Tick(object sender, EventArgs e) { if (currentDrawing == null) { return; } int polygons = currentDrawing.Polygons.Count; int points = currentDrawing.PointCount; double avg = 0; if (polygons != 0) { avg = points / polygons; } toolStripStatusLabelFitness.Text = errorLevel.ToString(); toolStripStatusLabelGeneration.Text = generation.ToString(); toolStripStatusLabelSelected.Text = selected.ToString(); toolStripStatusLabelPoints.Text = points.ToString(); toolStripStatusLabelPolygons.Text = polygons.ToString(); toolStripStatusLabelAvgPoints.Text = avg.ToString(); bool shouldRepaint = false; if (repaintIntervall.Ticks > 0) { if (lastRepaint < DateTime.Now - repaintIntervall) { shouldRepaint = true; } } if (repaintOnSelectedSteps > 0) { if (lastSelected + repaintOnSelectedSteps < selected) { shouldRepaint = true; } } if (shouldRepaint) { lock (currentDrawing) { guiDrawing = currentDrawing.Clone(); } pnlCanvas.Invalidate(); lastRepaint = DateTime.Now; lastSelected = selected; } }
private void OpenDNA() { Stop(); DnaDrawing drawing = Serializer.DeserializeDnaDrawing(FileUtil.GetOpenFileName(FileUtil.DnaExtension)); if (drawing != null) { currentCandidate = new Candidate(drawing); pnlCanvas.Invalidate(); lastRepaint = DateTime.Now; } }
private void OpenDNA() { _evolutionEngine.Stop(); string openFileName = FileUtil.GetOpenFileName(FileUtil.DnaExtension); if (_evolutionEngine.OpenDNA(openFileName)) { guiDrawing = _evolutionEngine.GetGuiDrawing(); pnlCanvas.Invalidate(); lastRepaint = DateTime.Now; } }
private static bool RemovePoint(this DnaPolygon dnaPolygon, DnaDrawing drawing) { if (dnaPolygon.Points.Count > Settings.ActivePointsPerPolygonMin) { if (drawing.PointCount > Settings.ActivePointsMin) { int index = Tools.GetRandomNumber(0, dnaPolygon.Points.Count); dnaPolygon.Points.RemoveAt(index); return true; } } return false; }
public static void Mutate(this DnaPoint dnaPoint, DnaDrawing dnaDrawing) { if (Tools.WillMutate(Settings.ActiveMovePointMaxMutationRate)) { dnaPoint.X = Tools.GetRandomNumber(0, dnaDrawing.Width); dnaPoint.Y = Tools.GetRandomNumber(0, dnaDrawing.Height); dnaDrawing.SetDirty(); } if (Tools.WillMutate(Settings.ActiveMovePointMidMutationRate)) { dnaPoint.X = MathUtils.Clamp( dnaPoint.X + Tools.GetRandomNumber(-Settings.ActiveMovePointRangeMid, Settings.ActiveMovePointRangeMid), 0, dnaDrawing.Width); dnaPoint.Y = MathUtils.Clamp( dnaPoint.Y + Tools.GetRandomNumber(-Settings.ActiveMovePointRangeMid, Settings.ActiveMovePointRangeMid), 0, dnaDrawing.Height); dnaDrawing.SetDirty(); } if (Tools.WillMutate(Settings.ActiveMovePointMinMutationRate)) { dnaPoint.X = MathUtils.Clamp( dnaPoint.X + Tools.GetRandomNumber(-Settings.ActiveMovePointRangeMin, Settings.ActiveMovePointRangeMin), 0, dnaDrawing.Width); dnaPoint.Y = MathUtils.Clamp( dnaPoint.Y + Tools.GetRandomNumber(-Settings.ActiveMovePointRangeMin, Settings.ActiveMovePointRangeMin), 0, dnaDrawing.Height); dnaDrawing.SetDirty(); } }
public static void Mutate(this DnaPolygon dnaPolygon, DnaDrawing drawing) { if (Tools.WillMutate(Settings.ActiveAddPointMutationRate)) { if (dnaPolygon.AddPoint(drawing)) { drawing.SetDirty(); } } if (Tools.WillMutate(Settings.ActiveRemovePointMutationRate)) { if (dnaPolygon.RemovePoint(drawing)) { drawing.SetDirty(); } } dnaPolygon.Brush.Mutate(drawing); dnaPolygon.Points.ForEach(p => p.Mutate(drawing)); }
private static bool AddPoint(this DnaPolygon dnaPolygon, DnaDrawing drawing) { if (dnaPolygon.Points.Count < Settings.ActivePointsPerPolygonMax) { if (drawing.PointCount < Settings.ActivePointsMax) { int index = Tools.GetRandomNumber(1, dnaPolygon.Points.Count - 1); DnaPoint prev = dnaPolygon.Points[index - 1]; DnaPoint next = dnaPolygon.Points[index]; var newPointX = (prev.X + next.X)/2; var newPointY = (prev.Y + next.Y)/2; var newPoint = new DnaPoint(newPointX, newPointY); dnaPolygon.Points.Insert(index, newPoint); return true; } } return false; }
public virtual 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); }
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; }
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(); } }
private void RemovePoint(DnaDrawing drawing) { if (Points.Count > Settings.ActivePointsPerPolygonMin) { int index = tool.GetRandomNumber(0, Points.Count); Points.RemoveAt(index); drawing.SetDirty(); } }
private void AddPoint(DnaDrawing drawing) { if (Points.Count < Settings.ActivePointsPerPolygonMax) { var newPoint = new DnaPoint(); int index = tool.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(); } }
public void breed(DnaDrawing other) { lock (this) { lock (other) { shuffleShapes(); other.shuffleShapes(); List<DnaShape> otherFirst = other.firstHalf; List<DnaShape> otherSnd = other.secondHalf; List<DnaShape> thisFirst = firstHalf; List<DnaShape> thisSnd = secondHalf; otherFirst.AddRange(thisSnd); thisFirst.AddRange(otherSnd); Shapes = thisFirst; other.Shapes = otherFirst; } } }
public DnaDrawing Clone() { lock (this) { var drawing = new DnaDrawing(seed); drawing.tool = tool; drawing.Shapes = new List<DnaShape>(); foreach (DnaShape shape in Shapes) drawing.Shapes.Add(shape.Clone()); return drawing; } }
public new void Mutate(DnaDrawing drawing) { Brush.Mutate(drawing); MutateOrigin(drawing); }
public void Mutate(DnaDrawing drawing) { if (tool.WillMutate(Settings.ActiveAddPointMutationRate)) AddPoint(drawing); if (tool.WillMutate(Settings.ActiveRemovePointMutationRate)) RemovePoint(drawing); Brush.Mutate(drawing); Points.ForEach(p => p.Mutate(drawing)); }