コード例 #1
0
        private ArrayList paint(Bitmap inImage, int winSize)
        {
            DateTime start = DateTime.Now;

            int       S;
            ArrayList list = null;
            int       count;
            int       factor, size, level;

            S = winSize;             //_DEFS;

            System.Console.WriteLine("Generating stroke area image.\n");


            DateTime startAnalysis = DateTime.Now;

            // Managed calculation of stroke area image
            ColorImage areaImg = GenerateStrokeArea(inImage, S);
            // End Managed calculation

            // Unmanaged calculation of stroke area image

            /*
             * DateTime startAnalysis = DateTime.Now;
             *          Color[] colors = StrokeAreaGenerator.GenerateFast1(new UnsafeBitmap(inImage), S);
             *
             *          ColorImage areaImg = new ColorImage(inImage.Width, inImage.Height);
             *          for (int y=0; y < inImage.Height; y++)
             *                  for (int x=0; x < inImage.Width; x++)
             *                          areaImg.singledata[y * inImage.Width + x] = colors[y * inImage.Width + x];
             */
            // End unmanaged calculation

            TimeSpan durationAnalysis = DateTime.Now - startAnalysis;

            StatusManager.Instance.StatusMessage("Analysis duration: " + durationAnalysis.TotalMilliseconds + "ms");


            //StatusReporter.Instance.SubmitWorkingImage(ImageTools.GenWorkingImage(areaImg));

            count = 0;
            list  = new ArrayList();

            factor = 1;
            level  = 1;
            size   = System.Math.Max(inImage.Width, inImage.Height);
            DateTime startStrokeGen = DateTime.Now;

            while (size > 4 * S)
            {
                System.Console.WriteLine("Processing level " + factor);
                count  += GenerateStrokesWithRawScaling(inImage, areaImg, list, S, factor, level);
                size   /= 2;
                factor *= 2;
                level++;
            }
            TimeSpan durationStrokeGen = DateTime.Now - startStrokeGen;

            StatusManager.Instance.StatusMessage("Stroke generation duration: " + durationStrokeGen.TotalMilliseconds + "ms");

            list.Sort();

            TimeSpan duration = DateTime.Now - start;

            StatusManager.Instance.StatusMessage("Duration of analysis, stroke gen and sorting: " + duration.TotalMilliseconds + "ms");

            return(list);
        }
コード例 #2
0
        public Bitmap Render(ArrayList strokes, Bitmap paintingBitmap)
        {
            ColorImage strokeImage = new ColorImage(new UnsafeBitmap(strokeBitmap));
            int        strokeCount = 0;

            Graphics gr = Graphics.FromImage(paintingBitmap);

            gr.Clear(System.Drawing.Color.White);
            ColorImage painting = new ColorImage(new UnsafeBitmap(paintingBitmap));

            double OneEightyOverPi = 180.0f / System.Math.PI;

            Hashtable scaledStrokeHash = new Hashtable();
            Hashtable scaledWidthHash  = new Hashtable();

            TimeSpan durationGDI      = TimeSpan.Zero;
            TimeSpan durationBlending = TimeSpan.Zero;
            TimeSpan durationScaling  = TimeSpan.Zero;

            DateTime start = DateTime.Now;

            foreach (Stroke stroke in strokes)
            {
                double radians = stroke.theta * -1.0;
                //int max = System.Math.Max((int)stroke.l, (int)stroke.w);

                if ((float.IsNaN(stroke.l)) || (float.IsNaN(stroke.w)))
                {
                    continue;
                }

                int scaledWidth  = (int)stroke.l;
                int scaledHeight = (int)stroke.w;

                if ((scaledWidth == 0) || (scaledHeight == 0))
                {
                    continue;
                }

                DateTime startScaling = DateTime.Now;
                Point    p            = new Point(scaledWidth, scaledHeight);
                Bitmap   newStrokeBmp = null;
                if (scaledStrokeHash.ContainsKey(p))
                {
                    newStrokeBmp = (Bitmap)scaledStrokeHash[p];
                }
                else
                {
                    ColorImage temp1;
                    if (scaledWidthHash.ContainsKey(scaledWidth))
                    {
                        temp1 = (ColorImage)scaledWidthHash[scaledWidth];
                    }
                    else
                    {
                        temp1 = ColorImage.ScaleWidth(strokeImage, scaledWidth);
                        scaledWidthHash[scaledWidth] = temp1;
                    }

                    temp1 = ColorImage.ScaleWidth(strokeImage, scaledWidth);
                    ColorImage scaledImage = ColorImage.ScaleHeight(temp1, scaledHeight);
                    newStrokeBmp        = scaledImage.GenerateBitmap();
                    scaledStrokeHash[p] = newStrokeBmp;
                }
                durationScaling += DateTime.Now - startScaling;

                DateTime startGDI = DateTime.Now;
                Bitmap   sbmp     = new Bitmap(newStrokeBmp.Width, newStrokeBmp.Height);
                Graphics g        = Graphics.FromImage(sbmp);
                g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.High;// HighQualityBicubic;
                g.TranslateTransform(-newStrokeBmp.Width / 2, -newStrokeBmp.Height / 2, System.Drawing.Drawing2D.MatrixOrder.Append);
                g.RotateTransform((float)(radians * OneEightyOverPi), System.Drawing.Drawing2D.MatrixOrder.Append);
                g.TranslateTransform(newStrokeBmp.Width / 2, newStrokeBmp.Height / 2, System.Drawing.Drawing2D.MatrixOrder.Append);
                g.DrawImage(newStrokeBmp, 0, 0, newStrokeBmp.Width, newStrokeBmp.Height);
                //sbmp.Save("newstroke" + stroke.theta.ToString() + ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
                sbmp.RotateFlip(System.Drawing.RotateFlipType.RotateNoneFlipY);
                Color c = Color.FromArgb(stroke.red, stroke.green, stroke.blue);
                durationGDI += DateTime.Now - startGDI;

                DateTime startBlending = DateTime.Now;
                ColorImage.Blend(ref painting, new ColorImage(new UnsafeBitmap(sbmp)), c, stroke.xc, stroke.yc);
                durationBlending += DateTime.Now - startBlending;

                //painting.GenerateBitmap().Save("intermediate-" + strokeCount + "n.jpg", System.Drawing.Imaging.ImageFormat.Jpeg);

                strokeCount++;

                //StatusReporter.Instance.SetPercentComplete((int)(((float)strokeCount / (float)(strokes.Count)) * 100.0));
            }

            /*
             * foreach (Point p in h.Keys)
             * {
             *      Console.WriteLine("Stroke size (" + p.X + "," + p.Y + ") = " + (int)h[p]);
             * }
             */

            TimeSpan duration = DateTime.Now - start;

            StatusManager.Instance.StatusMessage("Total GDI duration: " + durationGDI.TotalMilliseconds + "ms");
            StatusManager.Instance.StatusMessage("Total Scaling duration: " + durationScaling.TotalMilliseconds + "ms");
            StatusManager.Instance.StatusMessage("Total Blending duration: " + durationBlending.TotalMilliseconds + "ms");
            StatusManager.Instance.StatusMessage("Rendering duration: " + duration.TotalMilliseconds + "ms");


            //bmp.Save("newpainting.jpg", System.Drawing.Imaging.ImageFormat.Jpeg);

            return(painting.GenerateBitmap());;
        }