private static SourceImage GetIntensityMap(SourceImage sourceImage, int workerMin, int range)
        {
            var newSourceImage = new SourceImage();
            newSourceImage.Height = sourceImage.Height;
            newSourceImage.Width = sourceImage.Width;
            newSourceImage.Pixels = new Pixel[newSourceImage.Width*newSourceImage.Height];
            for (int y = 0; y < sourceImage.Height; y++)
            {
                for (int x = 0; x < sourceImage.Width; x++)
                {
                    Color c = sourceImage.GetPixel(x, y);
                    var intensity = (int) (c.GetBrightness()*255);

                    if (intensity >= workerMin && intensity <= workerMin + range)
                    {
											newSourceImage.SetPixel( x, y, c );
                    }
                    else
                    {
											newSourceImage.SetPixel( x, y, Color.Black );
                    }
                }
            }

            return newSourceImage;
        }
Beispiel #2
0
 public LayeredWorker(SourceImage sourceImage, Settings settings)
 {
     this.settings = settings;
     CurrentDrawing = GetNewInitializedDrawing(settings);
     CurrentDrawing.SourceImage = sourceImage;
     CurrentErrorLevel = double.MaxValue;
 }
Beispiel #3
0
        internal static long GetDrawingFitness(DnaDrawing newDrawing, SourceImage sourceImage, Bitmap bgImage, Bitmap fgImage)
        {
            
            long error = 0;

            if (bmp == null)
            {
                bmp = new Bitmap(sourceImage.Width, sourceImage.Height, PixelFormat.Format32bppArgb);
                g = Graphics.FromImage(bmp);
            }

            if (bgImage != null)
                g.DrawImage(bgImage,0,0);
            else
                g.Clear(Color.Black);


            Renderer.Render(newDrawing, g, 1);

            if (fgImage != null)
                g.DrawImage(fgImage,0,0);

            BitmapData bd = bmp.LockBits(
                new Rectangle(0, 0, sourceImage.Width, sourceImage.Height),
                ImageLockMode.ReadOnly,
                PixelFormat.Format32bppArgb);

            unchecked
            {
                unsafe
                {
                    fixed (Pixel* psourcePixels = sourceImage.Pixels)
                    {
                        int partitionEnd = sourceImage.Height*sourceImage.Width;
                        var p1 = (Pixel*) bd.Scan0.ToPointer();
                        Pixel* p2 = psourcePixels;

                        for (int i = 0; i < partitionEnd; i++, p1++, p2++)
                        {
                            int R = p1->R - p2->R;
                            int G = p1->G - p2->G;
                            int B = p1->B - p2->B;
                            error += R * R + G * G + B * B;
                        }
                    }
                }
            }

            bmp.UnlockBits(bd);


            // error += newDrawing.Polygons.Count * 3 ;
            return error;
        }
Beispiel #4
0
        private void StartEvolution()
        {
            var sourceImage = new SourceImage
                                  {
                                      Pixels = SetupSourceColorMatrix(picPattern.Image as Bitmap),
                                      Width = picPattern.Width,
                                      Height = picPattern.Height
                                  };

            var info = new JobInfo
                           {
                               Settings = Project.Settings,
                               SourceImage = sourceImage,
                           };
            //IEvolutionJob job = new LayeredEvolutionJob(sourceImage, 4);

            //DefaultEvolutionJob job = new DefaultEvolutionJob(sourceImage, currentDrawing);
            //IEvolutionJob job = new DefaultEvolutionJob(info);
            IEvolutionJob job = new ClusteredEvolutionJob(info);

            while (Project.IsRunning)
            {
                double newErrorLevel = job.GetNextErrorLevel();
                var defJob = job as DefaultEvolutionJob;
                if (defJob != null)
                    Project.Generations += defJob.Generations;

                Project.Mutations++;

                if (newErrorLevel <= Project.ErrorLevel)
                {
                    Project.Selected++;

                    if (newErrorLevel < Project.ErrorLevel)
                        Project.Positive++;
                    else
                        Project.Neutral++;

                    DnaDrawing newDrawing = job.GetDrawing();
                    if (currentDrawing == null) // to make always lockable...
                        currentDrawing = new DnaDrawing();

                    lock (currentDrawing)
                    {
                        currentDrawing = newDrawing;
                        Project.Drawing = currentDrawing.Clone();
                    }

                    Project.ErrorLevel = newErrorLevel;

                    SaveAnimationImage(newDrawing);
                }
            }
        }
Beispiel #5
0
        private static SourceImage GetSourceImage()
        {
            Bitmap bitmap = Resources.MonaLisa;
            var image = new SourceImage
                            {
                                Pixels = SetupSourceColorMatrix(bitmap),
                                Width = bitmap.Width,
                                Height = bitmap.Height
                            };

            return image;
        }
Beispiel #6
0
        public static double GetDrawingFitness(DnaDrawing newDrawing, SourceImage sourceImage,int partitionY,int partitionHeight)
        {
            double error = 0;

            using (var bmp = new Bitmap(sourceImage.Width, sourceImage.Height))
            using (Graphics g = Graphics.FromImage(bmp))
            {
                g.SetClip(new Rectangle(0,partitionY,sourceImage.Width,partitionHeight));
                Renderer.Render(newDrawing, g, 1);
                g.ResetClip();

                BitmapData bd = bmp.LockBits(
                    new Rectangle(0, 0, sourceImage.Width, sourceImage.Height),
                    ImageLockMode.ReadOnly,
                    PixelFormat.Format32bppArgb);

                unchecked
                {
                    unsafe
                    {
                        fixed (Pixel* psourcePixels = sourceImage.Pixels)
                        {
                            int partitionOffset = partitionY * sourceImage.Width;
                            int partitionEnd = partitionOffset + partitionHeight * sourceImage.Width;
                            var p1 = (Pixel*)bd.Scan0.ToPointer() + partitionOffset;
                            Pixel* p2 = psourcePixels + partitionOffset;
                            for (int i = partitionOffset; i < partitionEnd; i++, p1++, p2++)
                            {
                                int R = p1->R - p2->R;
                                int G = p1->G - p2->G;
                                int B = p1->B - p2->B;
                                error += R * R + G * G + B * B;
                            }
                        }
                    }
                }

                bmp.UnlockBits(bd);
            }

            // error += newDrawing.Polygons.Count * 3 ;
            return error;
        }
        public LayeredEvolutionJob(SourceImage sourceImage, int layerCount, Settings settings)
        {
            this.sourceImage = sourceImage;
            LayerCount = layerCount;
            workers = new List<LayeredWorker>();
            int range = 255/LayerCount;
            int workerMin = 0;
            for (int i = 0; i < LayerCount; i++)
            {
                SourceImage newSourceImage = GetIntensityMap(sourceImage, workerMin, range);

                var worker = new LayeredWorker(newSourceImage, settings)
                                 {
                                     MinIntensity = workerMin,
                                     MaxIntensity = (workerMin + range),
                                 };

                workers.Add(worker);
                workerMin += range;
            }
        }
Beispiel #8
0
        // 2008-12-14 DanByström: method optimized for speed
        public static double GetDrawingFitness(DnaDrawing newDrawing, SourceImage sourceImage)
        {
            double error = 0;

            using (var bmp = new Bitmap(sourceImage.Width, sourceImage.Height))
            using (Graphics g = Graphics.FromImage(bmp))
            {
                Renderer.Render(newDrawing, g, 1);

                BitmapData bd = bmp.LockBits(
                    new Rectangle(0, 0, sourceImage.Width, sourceImage.Height),
                    ImageLockMode.ReadOnly,
                    PixelFormat.Format32bppArgb);

                unchecked
                {
                    unsafe
                    {
                        fixed (Pixel* psourcePixels = sourceImage.Pixels)
                        {
                            var p1 = (Pixel*) bd.Scan0.ToPointer();
                            Pixel* p2 = psourcePixels;
                            for (int i = sourceImage.Pixels.Length; i > 0; i--, p1++, p2++)
                            {
                                int R = p1->R - p2->R;
                                int G = p1->G - p2->G;
                                int B = p1->B - p2->B;
                                error += R*R + G*G + B*B;
                            }
                        }
                    }
                }

                bmp.UnlockBits(bd);
            }

           // error += newDrawing.Polygons.Count * 3 ;
            return error;
        }