Inheritance: ICloneable
Exemple #1
0
 public DNA(Stream stream, int shapes, int vertices)
 {
     Shapes = new Shape[shapes];
     for (int i = 0; i < Shapes.Length; i++) {
         Shapes[i] = new Shape(stream, vertices);
     }
 }
Exemple #2
0
 public DNA(DNA other)
 {
     Shapes = new Shape[other.Shapes.Length];
     for (int i = 0; i < Shapes.Length; i++) {
         Shapes[i] = new Shape(other.Shapes[i]);
     }
     Divergence = other.Divergence;
 }
Exemple #3
0
 public DNA(NBTag tag)
 {
     Divergence = tag["Divergence"].GetDouble();
     var shapesTag = (NBTList)tag["Shapes"];
     Shapes = new Shape[shapesTag.Tags.Length];
     for (int i = 0; i < Shapes.Length; i++) {
         Shapes[i] = new Shape(shapesTag[i]);
     }
 }
        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;
     }
 }
Exemple #6
0
 // Randomly redistribute extra vertices by dividing edges of a given polygon
 static void Subdivide(Random rand, Shape shape, int extraVertices)
 {
     int points = shape.Points.Length;
     int assignedPoints = points - extraVertices;
     while (assignedPoints < points) {
         int p1 = rand.Next(0, assignedPoints);
         if (p1 == assignedPoints - 1) {
             shape.Points[assignedPoints] = Lerp(shape.Points[p1], shape.Points[0], 0.5f);
         } else {
             Array.Copy(shape.Points, p1 + 1, shape.Points, p1 + 2, assignedPoints - p1 - 1);
             shape.Points[p1 + 1] = Lerp(shape.Points[p1], shape.Points[p1 + 2], 0.5f);
         }
         assignedPoints++;
     }
 }
 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;
 }
 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 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 RotateShape( Random rand, Shape shape )
        {
            RectangleF rect = shape.GetBoundaries();
            PointF rectCenter = new PointF {
                X = rect.X + rect.Width / 2,
                Y = rect.Y + rect.Height / 2
            };

            double rotation = rand.NextDouble() * Math.PI * 2;

            for( int i = 0; i < shape.Points.Length; i++ ) {
                float alignedX = shape.Points[i].X - rectCenter.X;
                float alignedY = shape.Points[i].Y - rectCenter.Y;
                shape.Points[i].X =
                    (float)( rectCenter.X + alignedX * Math.Cos( rotation ) - alignedY * Math.Sin( rotation ) );
                shape.Points[i].Y =
                    (float)( rectCenter.Y + alignedX * Math.Sin( rotation ) + alignedY * Math.Cos( rotation ) );
            }
        }
 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;
     }
 }
 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;
     }
 }
Exemple #14
0
        void bImportDNA_Click(object sender, EventArgs e)
        {
            DNAImportWindow win = new DNAImportWindow();
            if (win.ShowDialog() == DialogResult.OK) {
                Reset();
                try {
                    string[] parts = win.DNA.Split(' ');
                    Stop();
                    State.Vertices = Int32.Parse(parts[0]);
                    State.Shapes = Int32.Parse(parts[1]);
                    nVertices.Value = State.Vertices;
                    nPolygons.Value = State.Shapes;
                    DNA importedDNA = new DNA {
                        Shapes = new Shape[State.Shapes]
                    };
                    int offset = 2;
                    for (int s = 0; s < State.Shapes; s++) {
                        Shape shape = new Shape {
                            Points = new PointF[State.Vertices]
                        };
                        int r = Int32.Parse(parts[offset]);
                        int g = Int32.Parse(parts[offset + 1]);
                        int b = Int32.Parse(parts[offset + 2]);
                        int a = (int)(float.Parse(parts[offset + 3])*255);
                        shape.Color = Color.FromArgb(a, r, g, b);
                        offset += 4;
                        for (int v = 0; v < State.Vertices; v++) {
                            float X = float.Parse(parts[offset]);
                            float Y = float.Parse(parts[offset + 1]);
                            shape.Points[v] = new PointF(X, Y);
                            offset += 2;
                        }
                        importedDNA.Shapes[s] = shape;
                    }
                    State.CurrentMatch = importedDNA;
                    State.BestMatch = importedDNA;
                    State.SetEvaluator(State.Evaluator);
                    UpdateTick();
                    picBestMatch.Invalidate();
                    picDiff.Invalidate();

                } catch (FormatException ex) {
                    MessageBox.Show("Could not import DNA!" + Environment.NewLine + ex);
                }
            }
        }
 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;
 }
Exemple #16
0
        // Take a polygon and divide it into two, using the slot of a sacrificial polygon for second half
        public void DivideShape(Random rand, int shapeToDivide, int shapeToSacrifice)
        {
            Shape original = Shapes[shapeToDivide];
            int points = original.Points.Length;

            // Figure out which dividing vertex produces the shortest dividing edge.
            PointF divisionVertex1 = default(PointF);
            PointF divisionVertex2 = default(PointF);
            double shortestDividingEdgeLength = Double.MaxValue;
            Shape shifted = original;
            for (int shiftAmount = 0; shiftAmount < points; shiftAmount++) {
                Shape shiftedGuess = ShiftPoints(original, shiftAmount);
                // Find the two dividing vertices
                PointF vertexGuess1;
                if (points%2 == 1) {
                    // odd number of points
                    vertexGuess1 = shiftedGuess.Points[points/2];
                } else {
                    // even number of points
                    vertexGuess1 = Lerp(shiftedGuess.Points[points/2 - 1], shiftedGuess.Points[points/2], 0.5f);
                }
                PointF vertexGuess2 = Lerp(shiftedGuess.Points[0], shiftedGuess.Points[points - 1], 0.5f);
                double dividingEdgeLength =
                    Math.Sqrt((vertexGuess1.X - vertexGuess2.X)*(vertexGuess1.X - vertexGuess2.X) +
                              (vertexGuess1.Y - vertexGuess2.Y)*(vertexGuess1.Y - vertexGuess2.Y));
                if (dividingEdgeLength < shortestDividingEdgeLength) {
                    shortestDividingEdgeLength = dividingEdgeLength;
                    shifted = shiftedGuess;
                    divisionVertex1 = vertexGuess1;
                    divisionVertex2 = vertexGuess2;
                }
            }

            var half1 = new Shape(shifted);
            var half2 = new Shape(shifted);

            // Construct half-shape #1
            half1.Points[0] = divisionVertex1;
            half1.Points[1] = divisionVertex2;
            for (int i = 0; i < points/2; i++) {
                half1.Points[i + 2] = shifted.Points[i];
            }

            // Construct half-shape #2
            half2.Points[0] = divisionVertex2;
            half2.Points[1] = divisionVertex1;
            for (int i = 0; i < points/2; i++) {
                half2.Points[i + 2] = shifted.Points[points/2 + i + 1];
            }

            // Randomly redistribute extra vertices for each half (if there are any)
            int extraVertices = (points - 3)/2;
            Subdivide(rand, half1, extraVertices);
            Subdivide(rand, half2, extraVertices);

            // Write back the changes
            Shapes[shapeToDivide] = half1;
            Shapes[shapeToSacrifice] = half2;
            half1.OutlineColor = Color.Green;
            half2.OutlineColor = Color.Red;
            ShiftShapeIndex(shapeToSacrifice, shapeToDivide);
        }
 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 ) );
     }
 }
        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 )
        {
            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;
            }
        }
Exemple #20
0
 static Shape ShiftPoints(Shape shape, int shift)
 {
     var copy = new Shape(shape);
     int offset = shift%shape.Points.Length;
     Array.Copy(shape.Points, offset, copy.Points, 0, shape.Points.Length - offset);
     Array.Copy(shape.Points, 0, copy.Points, shape.Points.Length - offset, offset);
     return copy;
 }
 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;
     }
 }
Exemple #22
0
 public Shape( Shape other )
 {
     Color = other.Color;
     Points = (PointF[])other.Points.Clone();
     OutlineColor = other.OutlineColor;
 }