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;
}
