DNA IMutator.Mutate( Random rand, DNA oldDNA, TaskState task ) { DNA newDNA = new DNA( oldDNA ); if( rand.Next( 20 ) == 0 ) { newDNA.SwapShapes( rand ); } else { MutateShape( rand, newDNA, newDNA.Shapes[rand.Next( newDNA.Shapes.Length )], task ); } return newDNA; }
public DNA Initialize( Random rand, TaskState task ) { DNA dna = new DNA { Shapes = new Shape[task.Shapes] }; int shapesPerSegment = task.Shapes / 9; int shapeCounter = 0; for( int i = 0; i < task.Shapes - shapesPerSegment * 9; i++ ) { Shape shape = new Shape { Color = Color.FromArgb( StartingAlpha, Color.R, Color.G, Color.B ), Points = new PointF[task.Vertices] }; for( int j = 0; j < shape.Points.Length; j++ ) { shape.Points[j] = new PointF( rand.NextFloat( -MaxOverlap, task.ImageWidth + MaxOverlap ), rand.NextFloat( -MaxOverlap, task.ImageHeight + MaxOverlap ) ); } dna.Shapes[i] = shape; shapeCounter++; } for( int x = 0; x < 3; x++ ) { for( int y = 0; y < 3; y++ ) { for( int i = 0; i < shapesPerSegment; i++ ) { Shape shape = new Shape { Color = Color.FromArgb( StartingAlpha, Color.R, Color.G, Color.B ), Points = new PointF[task.Vertices] }; for( int j = 0; j < shape.Points.Length; j++ ) { shape.Points[j] = new PointF( rand.NextFloat( task.ImageWidth / 3f * x - MaxOverlap, task.ImageWidth / 3f * ( x + 1 ) + MaxOverlap ), rand.NextFloat( task.ImageHeight / 3f * y - MaxOverlap, task.ImageHeight / 3f * ( y + 1 ) + MaxOverlap ) ); } dna.Shapes[shapeCounter] = shape; shapeCounter++; } } } return dna; }
static void MutateShape( Random rand, DNA dna, Shape shape, TaskState task ) { int maxOverlap = task.ProjectOptions.MaxOverlap; shape.PreviousState = shape.Clone() as Shape; switch( rand.Next( 9 ) ) { case 0: shape.Color = Color.FromArgb( (byte)rand.Next( task.ProjectOptions.MinAlpha, 256 ), shape.Color.R, shape.Color.G, shape.Color.B ); dna.LastMutation = MutationType.ReplaceColor; break; case 1: shape.Color = Color.FromArgb( shape.Color.A, (byte)rand.Next( 256 ), shape.Color.G, shape.Color.B ); dna.LastMutation = MutationType.ReplaceColor; break; case 2: shape.Color = Color.FromArgb( shape.Color.A, shape.Color.R, (byte)rand.Next( 256 ), shape.Color.B ); dna.LastMutation = MutationType.ReplaceColor; break; case 3: shape.Color = Color.FromArgb( shape.Color.A, shape.Color.R, shape.Color.G, (byte)rand.Next( 256 ) ); dna.LastMutation = MutationType.ReplaceColor; break; case 4: case 5: shape.Points[rand.Next( shape.Points.Length )].X = rand.NextFloat( -maxOverlap, task.ImageWidth + maxOverlap ); dna.LastMutation = MutationType.ReplacePoint; break; case 6: case 7: shape.Points[rand.Next( shape.Points.Length )].Y = rand.NextFloat( -maxOverlap, task.ImageHeight + maxOverlap ); dna.LastMutation = MutationType.ReplacePoint; break; case 8: shape.Points[rand.Next( shape.Points.Length )].X = rand.NextFloat( -maxOverlap, task.ImageWidth + maxOverlap ); shape.Points[rand.Next( shape.Points.Length )].Y = rand.NextFloat( -maxOverlap, task.ImageHeight + maxOverlap ); dna.LastMutation = MutationType.ReplacePoints; break; } }
public DNA Mutate( Random rand, DNA oldDNA, TaskState task ) { DNA newDNA = new DNA( oldDNA ); int s1 = rand.Next( newDNA.Shapes.Length ); Shape shape = newDNA.Shapes[s1]; switch( rand.Next( 20 ) ) { case 0: newDNA.SwapShapes( rand ); break; case 1: RandomizeShape( rand, shape, task ); newDNA.LastMutation = MutationType.ReplaceShape; break; default: MutateShape( rand, newDNA, shape, task ); break; } return newDNA; }
public DNA Mutate( Random rand, DNA oldDNA, TaskState task ) { int maxOverlap = task.ProjectOptions.MaxOverlap; DNA newDNA = new DNA( oldDNA ); Shape shape = newDNA.Shapes[rand.Next( newDNA.Shapes.Length )]; shape.PreviousState = shape.Clone() as Shape; shape.Color = Color.FromArgb( rand.Next( task.ProjectOptions.MinAlpha, 256 ), rand.NextByte(), rand.NextByte(), rand.NextByte() ); double area, maxArea = MaxPolygonArea * task.ImageWidth * task.ImageHeight; do { for( int i = 0; i < shape.Points.Length; i++ ) { shape.Points[i] = new PointF( rand.NextFloat( -maxOverlap, task.ImageWidth + maxOverlap ), rand.NextFloat( -maxOverlap, task.ImageHeight + maxOverlap ) ); } area = CalculateArea( shape.Points ); } while( area > maxArea ); newDNA.LastMutation = MutationType.ReplaceShape; return newDNA; }
public static ShapeEvaluation[] SortShapes(TaskState state) { var results = new List<ShapeEvaluation>(); using (var testCanvas = new Bitmap(state.ImageWidth, state.ImageHeight)) { double baseDivergence = state.Evaluator.CalculateDivergence(testCanvas, state.BestMatch, state, 1); for (int i = 0; i < state.BestMatch.Shapes.Length; i++) { var dnaWithoutShape = new DNA(state.BestMatch); dnaWithoutShape.Shapes[i].Color = Color.Transparent; double diffDivergence = state.Evaluator.CalculateDivergence(testCanvas, dnaWithoutShape, state, 1); results.Add(new ShapeEvaluation { Ordinal = i, Divergence = diffDivergence - baseDivergence, Shape = state.BestMatch.Shapes[i] }); } } results.Sort((r1, r2) => Math.Sign(r2.Divergence - r1.Divergence)); return results.ToArray(); }
static PointF MutatePoint( Random rand, DNA dna, PointF point, TaskState task ) { int maxOverlap = task.ProjectOptions.MaxOverlap; switch( rand.Next( 5 ) ) { case 0: case 1: point.X = rand.NextFloat( -maxOverlap, task.ImageWidth + maxOverlap ); dna.LastMutation = MutationType.ReplacePoint; break; case 2: case 3: point.Y = rand.NextFloat( -maxOverlap, task.ImageHeight + maxOverlap ); dna.LastMutation = MutationType.ReplacePoint; break; case 4: point.X = rand.NextFloat( -maxOverlap, task.ImageWidth + maxOverlap ); point.Y = rand.NextFloat( -maxOverlap, task.ImageHeight + maxOverlap ); dna.LastMutation = MutationType.ReplacePoints; break; } return point; }
static void ChangeColor(Random rand, Shape shape, TaskState task) { shape.PreviousState = shape.Clone() as Shape; switch (rand.Next(4)) { case 0: shape.Color = Color.FromArgb(rand.NextByte(task.ProjectOptions.MinAlpha, 256), shape.Color.R, shape.Color.G, shape.Color.B); break; case 1: shape.Color = Color.FromArgb(shape.Color.A, rand.NextByte(), shape.Color.G, shape.Color.B); break; case 2: shape.Color = Color.FromArgb(shape.Color.A, shape.Color.R, rand.NextByte(), shape.Color.B); break; case 3: shape.Color = Color.FromArgb(shape.Color.A, shape.Color.R, shape.Color.G, rand.NextByte()); break; } }
public void Initialize( TaskState state ) { }
void MutateShape(Random rand, DNA dna, Shape shape, TaskState task) { int maxOverlap = task.ProjectOptions.MaxOverlap; shape.PreviousState = shape.Clone() as Shape; int colorDelta = (byte)rand.Next(1, MaxColorDelta + 1) * (rand.Next(2) == 0 ? 1 : -1); float posDelta = (float)rand.NextDouble() * MaxPosDelta * (rand.Next(2) == 0 ? 1 : -1); switch (rand.Next(9)) { case 0: shape.Color = Color.FromArgb( Math.Max(task.ProjectOptions.MinAlpha, Math.Min(255, shape.Color.A + colorDelta)), shape.Color.R, shape.Color.G, shape.Color.B); dna.LastMutation = MutationType.AdjustColor; break; case 1: shape.Color = Color.FromArgb(shape.Color.A, Math.Max(0, Math.Min(255, shape.Color.R + colorDelta)), shape.Color.G, shape.Color.B); dna.LastMutation = MutationType.AdjustColor; break; case 2: shape.Color = Color.FromArgb(shape.Color.A, shape.Color.R, Math.Max(0, Math.Min(255, shape.Color.G + colorDelta)), shape.Color.B); dna.LastMutation = MutationType.AdjustColor; break; case 3: shape.Color = Color.FromArgb(shape.Color.A, shape.Color.R, shape.Color.G, Math.Max(0, Math.Min(255, shape.Color.B + colorDelta))); dna.LastMutation = MutationType.AdjustColor; break; case 4: case 5: int pt1 = rand.Next(shape.Points.Length); shape.Points[pt1].X = Math.Max(-maxOverlap, Math.Min(task.ImageWidth - 1 + maxOverlap, shape.Points[pt1].X + posDelta)); dna.LastMutation = MutationType.AdjustPoint; break; case 6: case 7: int pt2 = rand.Next(shape.Points.Length); shape.Points[pt2].Y = Math.Max(-maxOverlap, Math.Min(task.ImageHeight - 1 + maxOverlap, shape.Points[pt2].Y + posDelta)); dna.LastMutation = MutationType.AdjustPoint; break; case 8: int pt3 = rand.Next(shape.Points.Length); shape.Points[pt3].X = Math.Max(-maxOverlap, Math.Min(task.ImageWidth - 1 + maxOverlap, shape.Points[pt3].X + posDelta)); shape.Points[pt3].Y = Math.Max(-maxOverlap, Math.Min(task.ImageHeight - 1 + maxOverlap, shape.Points[pt3].Y + posDelta)); dna.LastMutation = MutationType.AdjustPoints; break; } }
public void Initialize( TaskState state ) { halfResImage = new Bitmap( state.ImageWidth / 2, state.ImageHeight / 2, PixelFormat.Format32bppArgb ); using( Graphics g = Graphics.FromImage( halfResImage ) ) { g.InterpolationMode = InterpolationMode.HighQualityBicubic; g.SmoothingMode = SmoothingMode.HighQuality; g.DrawImage( state.WorkingImageCopy, 0, 0, halfResImage.Width, halfResImage.Height ); } halfResData = halfResImage.LockBits( new Rectangle( Point.Empty, halfResImage.Size ), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb ); }
void MutateMultiplePoints( Shape shape, Random rand, DNA dna, TaskState task ) { int index = rand.Next( shape.Points.Length ); shape.Points[index] = MutatePoint( rand, dna, shape.Points[index], task ); if( rand.Next( 2 ) == 0 ) { index = ( index + 1 ) % shape.Points.Length; shape.Points[index] = MutatePoint( rand, dna, shape.Points[index], task ); if( rand.Next( 2 ) == 0 ) { index = ( index + 1 ) % shape.Points.Length; shape.Points[index] = MutatePoint( rand, dna, shape.Points[index], task ); } dna.LastMutation = MutationType.ReplacePoints; } else { dna.LastMutation = MutationType.ReplacePoint; } }
void MutateShape( Random rand, DNA dna, Shape shape, TaskState task ) { shape.PreviousState = shape.Clone() as Shape; switch( rand.Next( 10 ) ) { case 0: shape.Color = Color.FromArgb( (byte)rand.Next( task.ProjectOptions.MinAlpha, 256 ), shape.Color.R, shape.Color.G, shape.Color.B ); dna.LastMutation = MutationType.ReplaceColor; if( rand.Next( 10 ) == 0 ) { MutateMultiplePoints( shape, rand, dna, task ); dna.LastMutation = MutationType.ReplaceShape; } break; case 1: shape.Color = Color.FromArgb( shape.Color.A, rand.NextByte(), shape.Color.G, shape.Color.B ); dna.LastMutation = MutationType.ReplaceColor; if( rand.Next( 10 ) == 0 ) { MutateMultiplePoints( shape, rand, dna, task ); dna.LastMutation = MutationType.ReplaceShape; } break; case 2: shape.Color = Color.FromArgb( shape.Color.A, shape.Color.R, rand.NextByte(), shape.Color.B ); dna.LastMutation = MutationType.ReplaceColor; if( rand.Next( 10 ) == 0 ) { MutateMultiplePoints( shape, rand, dna, task ); dna.LastMutation = MutationType.ReplaceShape; } break; case 3: shape.Color = Color.FromArgb( shape.Color.A, shape.Color.R, shape.Color.G, rand.NextByte() ); dna.LastMutation = MutationType.ReplaceColor; if( rand.Next( 10 ) == 0 ) { MutateMultiplePoints( shape, rand, dna, task ); dna.LastMutation = MutationType.ReplaceShape; } break; default: MutateMultiplePoints( shape, rand, dna, task ); break; } }
void ChangeColor( Random rand, Shape shape, TaskState task ) { shape.PreviousState = shape.Clone() as Shape; int delta = rand.NextByte( 1, (int)( MaxColorDelta + 1 ) ) * ( rand.Next( 2 ) == 0 ? 1 : -1 ); switch( rand.Next( 4 ) ) { case 0: shape.Color = Color.FromArgb( Math.Max( task.ProjectOptions.MinAlpha, Math.Min( 255, shape.Color.A + delta ) ), shape.Color.R, shape.Color.G, shape.Color.B ); break; case 1: shape.Color = Color.FromArgb( shape.Color.A, Math.Max( 0, Math.Min( 255, shape.Color.R + delta ) ), shape.Color.G, shape.Color.B ); break; case 2: shape.Color = Color.FromArgb( shape.Color.A, shape.Color.R, Math.Max( 0, Math.Min( 255, shape.Color.G + delta ) ), shape.Color.B ); break; case 3: shape.Color = Color.FromArgb( shape.Color.A, shape.Color.R, shape.Color.G, Math.Max( 0, Math.Min( 255, shape.Color.B + delta ) ) ); break; } }
static void RandomizeShape( Random rand, Shape shape, TaskState task ) { int maxOverlap = task.ProjectOptions.MaxOverlap; shape.PreviousState = shape.Clone() as Shape; shape.Color = Color.FromArgb( rand.Next( task.ProjectOptions.MinAlpha, 256 ), rand.Next( 256 ), rand.Next( 256 ), rand.Next( 256 ) ); for( int i = 0; i < shape.Points.Length; i++ ) { shape.Points[i] = new PointF( rand.NextFloat( -maxOverlap, task.ImageWidth + maxOverlap ), rand.NextFloat( -maxOverlap, task.ImageHeight + maxOverlap ) ); } }
public DNA Initialize(Random rand, TaskState task) { var dna = new DNA { Shapes = new Shape[task.Shapes] }; for (int s = 0; s < task.Shapes; s++) { var shape = new Shape { Color = Color.FromArgb(StartingAlpha, Color.R, Color.G, Color.B), Points = new PointF[task.Vertices] }; int maxRadius = (int)Math.Round(Math.Min(task.ImageWidth, task.ImageHeight)*MaxRadiusRatio); int radius = rand.Next(MinRadius, maxRadius); var center = new Point(rand.Next(radius - MaxOverlap, task.ImageWidth - radius + MaxOverlap), rand.Next(radius - MaxOverlap, task.ImageHeight - radius + MaxOverlap)); for (int v = 0; v < task.Vertices; v++) { double t = v*Math.PI*2*Revolutions/task.Vertices + Angle*Math.PI*2 + Math.PI/task.Vertices; shape.Points[v].X = (float)(center.X + Math.Cos(t)*radius); shape.Points[v].Y = (float)(center.Y + Math.Sin(t)*radius); } if (shape.GetBoundaries().Width < 1 || shape.GetBoundaries().Height < 1) { continue; } dna.Shapes[s] = shape; } return dna; }
public double CalculateDivergence(Bitmap testImage, DNA dna, TaskState state, double maxAcceptableDivergence) { double maxDivergence = state.ImageWidth * state.ImageHeight * 2 * 255; long sum = 0; long roundedMax = (long)(maxAcceptableDivergence * maxDivergence + 1); using (Graphics g = Graphics.FromImage(testImage)) { g.Clear(state.ProjectOptions.Matte); g.SmoothingMode = (Smooth ? SmoothingMode.HighQuality : SmoothingMode.HighSpeed); for (int i = 0; i < dna.Shapes.Length; i++) { g.FillPolygon(new SolidBrush(dna.Shapes[i].Color), dna.Shapes[i].Points, FillMode.Alternate); } } BitmapData testData = testImage.LockBits(new Rectangle(Point.Empty, testImage.Size), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); for (int i = 0; i < state.ImageHeight; i++) { byte *originalPointer = (byte *)state.WorkingImageData.Scan0 + state.WorkingImageData.Stride * i; byte *testPointer = (byte *)testData.Scan0 + testData.Stride * i; for (int j = 0; j < state.ImageWidth; j++) { /* * int originalLuma = (299 * originalPointer[2] + 587 * originalPointer[1] + 114 * *originalPointer) / 1000; * int testLuma = (299 * testPointer[2] + 587 * testPointer[1] + 114 * *testPointer) / 1000; * int deltaLuma = (299 * Math.Abs( originalPointer[2] - testPointer[2] ) + * 587 * Math.Abs( originalPointer[1] - testPointer[1] ) + * 114 * Math.Abs( *originalPointer - *testPointer )) / 1500; // 0-511 * * int deltaU = Math.Abs( (originalPointer[2] - originalLuma) - (testPointer[2] - testLuma) ); // 0-255 * int deltaV = Math.Abs( (*originalPointer - originalLuma) - (*testPointer - testLuma) ); // 0-255 * * sum += deltaLuma + (deltaU + deltaV)/2; */ int originalLumi = (Math.Min(Math.Min(originalPointer[2], originalPointer[1]), *originalPointer) + Math.Max(Math.Max(originalPointer[2], originalPointer[1]), *originalPointer)) / 2; int testLumi = (Math.Min(Math.Min(testPointer[2], testPointer[1]), *testPointer) + Math.Max(Math.Max(testPointer[2], testPointer[1]), *testPointer)) / 2; byte lumiDelta = (byte)Math.Abs(originalLumi - testLumi); int oringinalChroma = (Math.Max(Math.Max(originalPointer[2], originalPointer[1]), *originalPointer) - Math.Min(Math.Min(originalPointer[2], originalPointer[1]), *originalPointer)); int testChroma = (Math.Max(Math.Max(testPointer[2], testPointer[1]), *testPointer) - Math.Min(Math.Min(testPointer[2], testPointer[1]), *testPointer)); sum += lumiDelta * 2 + (byte)(Math.Abs(oringinalChroma - testChroma) * lumiDelta / 255); originalPointer += 4; testPointer += 4; } if (sum > roundedMax) { break; } } testImage.UnlockBits(testData); return(sum / maxDivergence); }
public DNA Mutate( Random rand, DNA oldDNA, TaskState task ) { DNA newDNA = new DNA( oldDNA ); Shape shape = newDNA.Shapes[rand.Next( newDNA.Shapes.Length )]; int choice = rand.Next( ( EnableRotation ? 16 : 12 ) ); switch( choice ) { case 0: case 1: shape.PreviousState = shape.Clone() as Shape; MoveShape( rand, shape, task ); newDNA.LastMutation = MutationType.Move; break; case 2: case 3: shape.PreviousState = shape.Clone() as Shape; ScaleShape( rand, shape, task ); newDNA.LastMutation = MutationType.Scale; break; case 4: shape.PreviousState = shape.Clone() as Shape; ScaleShape( rand, shape, task ); MoveShape( rand, shape, task ); newDNA.LastMutation = MutationType.Transform; break; case 5: shape.PreviousState = shape.Clone() as Shape; MoveShape( rand, shape, task ); ScaleShape( rand, shape, task ); newDNA.LastMutation = MutationType.Transform; break; case 6: case 7: case 8: case 9: shape.PreviousState = shape.Clone() as Shape; ChangeColor( rand, shape, task ); newDNA.LastMutation = MutationType.ReplaceColor; break; case 10: newDNA.SwapShapes( rand ); break; case 11: shape.PreviousState = shape.Clone() as Shape; MoveShape( rand, shape, task ); ScaleShape( rand, shape, task ); ChangeColor( rand, shape, task ); newDNA.LastMutation = MutationType.Transform; break; case 12: case 13: shape.PreviousState = shape.Clone() as Shape; RotateShape( rand, shape ); newDNA.LastMutation = MutationType.Rotate; break; case 14: shape.PreviousState = shape.Clone() as Shape; MoveShape( rand, shape, task ); RotateShape( rand, shape ); newDNA.LastMutation = MutationType.Transform; break; case 15: shape.PreviousState = shape.Clone() as Shape; ChangeColor( rand, shape, task ); newDNA.LastMutation = MutationType.ReplaceColor; break; } return newDNA; }
void CreateProject(string fileName) { Bitmap image = (Bitmap)Image.FromFile(fileName); State = new TaskState(); SetImage(image); Reset(); ResetUI(); State.SetEvaluator(State.Evaluator); UpdateTick(); picDiff.Invalidate(); picBestMatch.Invalidate(); bStart.Enabled = true; bRestart.Enabled = true; bSaveProject.Enabled = true; bSaveProjectAs.Enabled = true; menuExport.Enabled = true; }
void ScaleShape( Random rand, Shape shape, TaskState task ) { RectangleF rect = shape.GetBoundaries(); int maxOverlap = task.ProjectOptions.MaxOverlap; int maxWidth = (int)( Math.Min( rect.X, task.ImageWidth - rect.Right ) + rect.Width ) + maxOverlap * 2; int maxHeight = (int)( Math.Min( rect.Y, task.ImageHeight - rect.Bottom ) + rect.Height ) + maxOverlap * 2; double newWidthRatio = rand.Next( 3, maxWidth + 1 ) / rect.Width; double newHeightRatio = rand.Next( 3, maxHeight + 1 ) / rect.Height; if( PreserveAspectRatio ) { newWidthRatio = Math.Min( newWidthRatio, newHeightRatio ); newHeightRatio = newWidthRatio; } PointF rectCenter = new PointF { X = rect.X + rect.Width / 2f, Y = rect.Y + rect.Height / 2f }; for( int i = 0; i < shape.Points.Length; i++ ) { shape.Points[i].X = (float)( rectCenter.X + ( shape.Points[i].X - rectCenter.X ) * newWidthRatio ); shape.Points[i].Y = (float)( rectCenter.Y + ( shape.Points[i].Y - rectCenter.Y ) * newHeightRatio ); } }
static void MoveShape( Random rand, Shape shape, TaskState task ) { RectangleF rect = shape.GetBoundaries(); int maxOverlap = task.ProjectOptions.MaxOverlap; PointF delta = new PointF { X = rand.NextFloat( -rect.X - maxOverlap, task.ImageWidth - rect.Right + maxOverlap ), Y = rand.NextFloat( -rect.Y - maxOverlap, task.ImageHeight - rect.Bottom + maxOverlap ) }; for( int i = 0; i < shape.Points.Length; i++ ) { shape.Points[i].X += delta.X; shape.Points[i].Y += delta.Y; } }
static void ChangeColor( Random rand, Shape shape, TaskState task ) { shape.PreviousState = shape.Clone() as Shape; switch( rand.Next( 4 ) ) { case 0: shape.Color = Color.FromArgb( rand.NextByte( task.ProjectOptions.MinAlpha, 256 ), shape.Color.R, shape.Color.G, shape.Color.B ); break; case 1: shape.Color = Color.FromArgb( shape.Color.A, rand.NextByte(), shape.Color.G, shape.Color.B ); break; case 2: shape.Color = Color.FromArgb( shape.Color.A, shape.Color.R, rand.NextByte(), shape.Color.B ); break; case 3: shape.Color = Color.FromArgb( shape.Color.A, shape.Color.R, shape.Color.G, rand.NextByte() ); break; } }
public double CalculateDivergence( Bitmap testImage, DNA dna, TaskState state, double maxAcceptableDivergence ) { if( Emphasized ) { if( EmphasisAmount == 2 ) { maxDivergence = 3L * state.ImageWidth * state.ImageHeight * 255L * 255L; } else { maxDivergence = 3L * state.ImageWidth * state.ImageHeight * Math.Pow( 255, EmphasisAmount ); } } else { maxDivergence = 3L * state.ImageWidth * state.ImageHeight * 255L; } double sum = 0; double roundedMax = ( maxAcceptableDivergence * maxDivergence + 1 ); using( Graphics g = Graphics.FromImage( testImage ) ) { g.Clear( state.ProjectOptions.Matte ); g.SmoothingMode = ( Smooth ? SmoothingMode.HighQuality : SmoothingMode.HighSpeed ); for( int i = 0; i < dna.Shapes.Length; i++ ) { g.FillPolygon( new SolidBrush( dna.Shapes[i].Color ), dna.Shapes[i].Points, FillMode.Alternate ); } } byte* originalPointer, testPointer; BitmapData testData = testImage.LockBits( new Rectangle( Point.Empty, testImage.Size ), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb ); if( Emphasized ) { if( EmphasisAmount == 2 ) { for( int i = 0; i < state.ImageHeight; i++ ) { originalPointer = (byte*)state.WorkingImageData.Scan0 + state.WorkingImageData.Stride * i; testPointer = (byte*)testData.Scan0 + testData.Stride * i; for( int j = 0; j < state.ImageWidth; j++ ) { int b = Math.Abs( *originalPointer - *testPointer ); int g = Math.Abs( originalPointer[1] - testPointer[1] ); int r = Math.Abs( originalPointer[2] - testPointer[2] ); sum += r * r + b * b + g * g; originalPointer += 4; testPointer += 4; } if( sum > roundedMax ) { sum = maxDivergence; break; } } } else { for( int i = 0; i < state.ImageHeight; i++ ) { originalPointer = (byte*)state.WorkingImageData.Scan0 + state.WorkingImageData.Stride*i; testPointer = (byte*)testData.Scan0 + testData.Stride*i; for( int j = 0; j < state.ImageWidth; j++ ) { int b = Math.Abs( *originalPointer - *testPointer ); int g = Math.Abs( originalPointer[1] - testPointer[1] ); int r = Math.Abs( originalPointer[2] - testPointer[2] ); sum += Math.Pow( r, EmphasisAmount ) + Math.Pow( g, EmphasisAmount ) + Math.Pow( b, EmphasisAmount ); originalPointer += 4; testPointer += 4; } if( sum > roundedMax ) { sum = maxDivergence; break; } } } } else { for( int i = 0; i < state.ImageHeight; i++ ) { originalPointer = (byte*)state.WorkingImageData.Scan0 + state.WorkingImageData.Stride * i; testPointer = (byte*)testData.Scan0 + testData.Stride * i; for( int j = 0; j < state.ImageWidth; j++ ) { int b = Math.Abs( *originalPointer - *testPointer ); int g = Math.Abs( originalPointer[1] - testPointer[1] ); int r = Math.Abs( originalPointer[2] - testPointer[2] ); sum += r + b + g; originalPointer += 4; testPointer += 4; } if( sum > roundedMax ) { sum = maxDivergence; break; } } } testImage.UnlockBits( testData ); if( Emphasized ) { return Math.Pow( sum / maxDivergence, 1 / EmphasisAmount ); } else { return sum / maxDivergence; } }
DNA IInitializer.Initialize( Random rand, TaskState task ) { DNA dna = new DNA { Shapes = new Shape[task.Shapes] }; for( int i = 0; i < dna.Shapes.Length; i++ ) { Shape shape = new Shape { Color = Color.FromArgb( StartingAlpha, Color.R, Color.G, Color.B ), Points = new PointF[task.Vertices] }; for( int j = 0; j < shape.Points.Length; j++ ) { shape.Points[j] = new PointF( rand.NextFloat( -MaxOverlap, task.ImageWidth + MaxOverlap ), rand.NextFloat( -MaxOverlap, task.ImageHeight + MaxOverlap ) ); } dna.Shapes[i] = shape; } return dna; }
public double CalculateDivergence(Bitmap testImage, DNA dna, TaskState state, double maxAcceptableDivergence) { if (Emphasized) { if (EmphasisAmount == 2) { maxDivergence = 3L * state.ImageWidth * state.ImageHeight * 255L * 255L; } else { maxDivergence = 3L * state.ImageWidth * state.ImageHeight * Math.Pow(255, EmphasisAmount); } } else { maxDivergence = 3L * state.ImageWidth * state.ImageHeight * 255L; } double sum = 0; double roundedMax = (maxAcceptableDivergence * maxDivergence + 1); using (Graphics g = Graphics.FromImage(testImage)) { g.Clear(state.ProjectOptions.Matte); g.SmoothingMode = (Smooth ? SmoothingMode.HighQuality : SmoothingMode.HighSpeed); for (int i = 0; i < dna.Shapes.Length; i++) { g.FillPolygon(new SolidBrush(dna.Shapes[i].Color), dna.Shapes[i].Points, FillMode.Alternate); } } byte *originalPointer, testPointer; BitmapData testData = testImage.LockBits(new Rectangle(Point.Empty, testImage.Size), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb); if (Emphasized) { if (EmphasisAmount == 2) { for (int i = 0; i < state.ImageHeight; i++) { originalPointer = (byte *)state.WorkingImageData.Scan0 + state.WorkingImageData.Stride * i; testPointer = (byte *)testData.Scan0 + testData.Stride * i; for (int j = 0; j < state.ImageWidth; j++) { int b = Math.Abs(*originalPointer - *testPointer); int g = Math.Abs(originalPointer[1] - testPointer[1]); int r = Math.Abs(originalPointer[2] - testPointer[2]); sum += r * r + b * b + g * g; originalPointer += 4; testPointer += 4; } if (sum > roundedMax) { sum = maxDivergence; break; } } } else { for (int i = 0; i < state.ImageHeight; i++) { originalPointer = (byte *)state.WorkingImageData.Scan0 + state.WorkingImageData.Stride * i; testPointer = (byte *)testData.Scan0 + testData.Stride * i; for (int j = 0; j < state.ImageWidth; j++) { int b = Math.Abs(*originalPointer - *testPointer); int g = Math.Abs(originalPointer[1] - testPointer[1]); int r = Math.Abs(originalPointer[2] - testPointer[2]); sum += Math.Pow(r, EmphasisAmount) + Math.Pow(g, EmphasisAmount) + Math.Pow(b, EmphasisAmount); originalPointer += 4; testPointer += 4; } if (sum > roundedMax) { sum = maxDivergence; break; } } } } else { for (int i = 0; i < state.ImageHeight; i++) { originalPointer = (byte *)state.WorkingImageData.Scan0 + state.WorkingImageData.Stride * i; testPointer = (byte *)testData.Scan0 + testData.Stride * i; for (int j = 0; j < state.ImageWidth; j++) { int b = Math.Abs(*originalPointer - *testPointer); int g = Math.Abs(originalPointer[1] - testPointer[1]); int r = Math.Abs(originalPointer[2] - testPointer[2]); sum += r + b + g; originalPointer += 4; testPointer += 4; } if (sum > roundedMax) { sum = maxDivergence; break; } } } testImage.UnlockBits(testData); if (Emphasized) { return(Math.Pow(sum / maxDivergence, 1 / EmphasisAmount)); } else { return(sum / maxDivergence); } }
void OpenProject(string filename) { if (!stopped) Stop(); NBTag taskData = NBTag.ReadFile(filename); State = new TaskState(taskData); BackColor = State.ProjectOptions.BackColor; if (filename.EndsWith(".autosave.sie")) { State.ProjectFileName = filename.Substring(0, filename.Length - 13); } else { State.ProjectFileName = filename; } Text = Path.GetFileName(State.ProjectFileName) + " | SuperImageEvolver"; nVertices.Value = State.Vertices; nPolygons.Value = State.Shapes; SetImage(State.OriginalImage); if (taskData.Contains("Presentation")) { NBTag presentationTag = taskData["Presentation"]; picOriginal.Visible = presentationTag.GetBool("OriginalVisible", picOriginal.Visible); OriginalZoom = presentationTag.GetFloat("OriginalZoom", OriginalZoom); picBestMatch.Visible = presentationTag.GetBool("BestMatchVisible", picBestMatch.Visible); picBestMatch.Zoom = presentationTag.GetFloat("BestMatchZoom", picBestMatch.Zoom); picBestMatch.Wireframe = presentationTag.GetBool("BestMatchWireframe", picBestMatch.Wireframe); picBestMatch.ShowLastChange = presentationTag.GetBool("BestMatchShowLastChange", picBestMatch.ShowLastChange); picDiff.Visible = presentationTag.GetBool("DiffVisible", picDiff.Visible); picDiff.Invert = presentationTag.GetBool("DiffInvert", picDiff.Invert); picDiff.Exaggerate = presentationTag.GetBool("DiffExaggerate", picDiff.Exaggerate); picDiff.ShowColor = presentationTag.GetBool("DiffShowColor", picDiff.ShowColor); picDiff.Zoom = presentationTag.GetFloat("DiffZoom", picDiff.Zoom); picDiff.ShowLastChange = presentationTag.GetBool("DiffShowLastChange", picDiff.ShowLastChange); } State.SetEvaluator(State.Evaluator); UpdateTick(); picDiff.Invalidate(); picBestMatch.Invalidate(); State.HasChangedSinceSave = false; bStart.Enabled = true; bRestart.Enabled = true; bSaveProject.Enabled = true; bSaveProjectAs.Enabled = true; menuExport.Enabled = true; }
public DNA Mutate(Random rand, DNA oldDNA, TaskState task) { DNA newDNA = new DNA(oldDNA); Shape shape = newDNA.Shapes[rand.Next(newDNA.Shapes.Length)]; int choice = rand.Next((EnableRotation ? 16 : 12)); switch (choice) { case 0: case 1: shape.PreviousState = shape.Clone() as Shape; MoveShape(rand, shape, task); newDNA.LastMutation = MutationType.Move; break; case 2: case 3: shape.PreviousState = shape.Clone() as Shape; ScaleShape(rand, shape, task); newDNA.LastMutation = MutationType.Scale; break; case 4: shape.PreviousState = shape.Clone() as Shape; ScaleShape(rand, shape, task); MoveShape(rand, shape, task); newDNA.LastMutation = MutationType.Transform; break; case 5: shape.PreviousState = shape.Clone() as Shape; MoveShape(rand, shape, task); ScaleShape(rand, shape, task); newDNA.LastMutation = MutationType.Transform; break; case 6: case 7: case 8: case 9: shape.PreviousState = shape.Clone() as Shape; ChangeColor(rand, shape, task); newDNA.LastMutation = MutationType.AdjustColor; break; case 10: newDNA.SwapShapes(rand); break; case 11: shape.PreviousState = shape.Clone() as Shape; MoveShape(rand, shape, task); ScaleShape(rand, shape, task); ChangeColor(rand, shape, task); newDNA.LastMutation = MutationType.Transform; break; case 12: case 13: shape.PreviousState = shape.Clone() as Shape; RotateShape(rand, shape); newDNA.LastMutation = MutationType.Rotate; break; case 14: shape.PreviousState = shape.Clone() as Shape; MoveShape(rand, shape, task); RotateShape(rand, shape); newDNA.LastMutation = MutationType.Transform; break; case 15: shape.PreviousState = shape.Clone() as Shape; ChangeColor(rand, shape, task); newDNA.LastMutation = MutationType.AdjustColor; break; } return(newDNA); }
public void Init( TaskState _state ) { state = _state; canvasImage = new Bitmap( state.ImageWidth, state.ImageHeight ); Zoom = zoom; }
public void Init(TaskState _state) { state = _state; canvasImage = new Bitmap(state.ImageWidth, state.ImageHeight); Zoom = zoom; }
PointF MutatePoint( Random rand, DNA dna, PointF point, TaskState task ) { float posDelta = (float)rand.NextDouble() * MaxPosDelta * ( rand.Next( 2 ) == 0 ? 1 : -1 ); int maxOverlap = task.ProjectOptions.MaxOverlap; switch( rand.Next( 5 ) ) { case 0: case 1: point.X = Math.Max( -maxOverlap, Math.Min( task.ImageWidth - 1 + maxOverlap, point.X + posDelta ) ); dna.LastMutation = MutationType.AdjustPoint; break; case 2: case 3: point.Y = Math.Max( -maxOverlap, Math.Min( task.ImageHeight - 1 + maxOverlap, point.Y + posDelta ) ); dna.LastMutation = MutationType.AdjustPoint; break; case 4: point.X = Math.Max( -maxOverlap, Math.Min( task.ImageWidth - 1 + maxOverlap, point.X + posDelta ) ); point.Y = Math.Max( -maxOverlap, Math.Min( task.ImageHeight - 1 + maxOverlap, point.Y + posDelta ) ); dna.LastMutation = MutationType.AdjustPoints; break; } return point; }
public void Initialize(TaskState state) { }
void MutateShape( Random rand, DNA dna, Shape shape, TaskState task ) { shape.PreviousState = shape.Clone() as Shape; int colorDelta = (byte)rand.Next( 1, MaxColorDelta + 1 ) * ( rand.Next( 2 ) == 0 ? 1 : -1 ); switch( rand.Next( 10 ) ) { case 0: shape.Color = Color.FromArgb( Math.Max( task.ProjectOptions.MinAlpha, Math.Min( 255, shape.Color.A + colorDelta ) ), shape.Color.R, shape.Color.G, shape.Color.B ); dna.LastMutation = MutationType.AdjustColor; if( rand.Next( 10 ) == 0 ) { MutateMultiplePoints( shape, rand, dna, task ); dna.LastMutation = MutationType.ReplaceShape; } break; case 1: shape.Color = Color.FromArgb( shape.Color.A, Math.Max( 0, Math.Min( 255, shape.Color.R + colorDelta ) ), shape.Color.G, shape.Color.B ); dna.LastMutation = MutationType.AdjustColor; if( rand.Next( 10 ) == 0 ) { MutateMultiplePoints( shape, rand, dna, task ); dna.LastMutation = MutationType.ReplaceShape; } break; case 2: shape.Color = Color.FromArgb( shape.Color.A, shape.Color.R, Math.Max( 0, Math.Min( 255, shape.Color.G + colorDelta ) ), shape.Color.B ); dna.LastMutation = MutationType.AdjustColor; if( rand.Next( 10 ) == 0 ) { MutateMultiplePoints( shape, rand, dna, task ); dna.LastMutation = MutationType.ReplaceShape; } break; case 3: shape.Color = Color.FromArgb( shape.Color.A, shape.Color.R, shape.Color.G, Math.Max( 0, Math.Min( 255, shape.Color.B + colorDelta ) ) ); dna.LastMutation = MutationType.AdjustColor; if( rand.Next( 10 ) == 0 ) { MutateMultiplePoints( shape, rand, dna, task ); dna.LastMutation = MutationType.ReplaceShape; } break; default: MutateMultiplePoints( shape, rand, dna, task ); break; } }
void MutateShape( Random rand, DNA dna, Shape shape, TaskState task ) { int maxOverlap = task.ProjectOptions.MaxOverlap; shape.PreviousState = shape.Clone() as Shape; int colorDelta = (byte)rand.Next( 1, MaxColorDelta + 1 ) * ( rand.Next( 2 ) == 0 ? 1 : -1 ); float posDelta = (float)rand.NextDouble() * MaxPosDelta * ( rand.Next( 2 ) == 0 ? 1 : -1 ); switch( rand.Next( 9 ) ) { case 0: shape.Color = Color.FromArgb( Math.Max( task.ProjectOptions.MinAlpha, Math.Min( 255, shape.Color.A + colorDelta ) ), shape.Color.R, shape.Color.G, shape.Color.B ); dna.LastMutation = MutationType.AdjustColor; break; case 1: shape.Color = Color.FromArgb( shape.Color.A, Math.Max( 0, Math.Min( 255, shape.Color.R + colorDelta ) ), shape.Color.G, shape.Color.B ); dna.LastMutation = MutationType.AdjustColor; break; case 2: shape.Color = Color.FromArgb( shape.Color.A, shape.Color.R, Math.Max( 0, Math.Min( 255, shape.Color.G + colorDelta ) ), shape.Color.B ); dna.LastMutation = MutationType.AdjustColor; break; case 3: shape.Color = Color.FromArgb( shape.Color.A, shape.Color.R, shape.Color.G, Math.Max( 0, Math.Min( 255, shape.Color.B + colorDelta ) ) ); dna.LastMutation = MutationType.AdjustColor; break; case 4: case 5: int pt1 = rand.Next( shape.Points.Length ); shape.Points[pt1].X = Math.Max( -maxOverlap, Math.Min( task.ImageWidth - 1 + maxOverlap, shape.Points[pt1].X + posDelta ) ); dna.LastMutation = MutationType.AdjustPoint; break; case 6: case 7: int pt2 = rand.Next( shape.Points.Length ); shape.Points[pt2].Y = Math.Max( -maxOverlap, Math.Min( task.ImageHeight - 1 + maxOverlap, shape.Points[pt2].Y + posDelta ) ); dna.LastMutation = MutationType.AdjustPoint; break; case 8: int pt3 = rand.Next( shape.Points.Length ); shape.Points[pt3].X = Math.Max( -maxOverlap, Math.Min( task.ImageWidth - 1 + maxOverlap, shape.Points[pt3].X + posDelta ) ); shape.Points[pt3].Y = Math.Max( -maxOverlap, Math.Min( task.ImageHeight - 1 + maxOverlap, shape.Points[pt3].Y + posDelta ) ); dna.LastMutation = MutationType.AdjustPoints; break; } }
public DNA Mutate( Random rand, DNA oldDNA, TaskState task ) { DNA newDNA = new DNA( oldDNA ); int s1 = rand.Next( newDNA.Shapes.Length ); Shape shape = newDNA.Shapes[s1]; if( rand.Next( 20 ) == 0 ) { newDNA.SwapShapes( rand ); } else { MutateShape( rand, newDNA, shape, task ); } return newDNA; }