C# RenderTargetBitmap.Clear方法代码示例

        void RenderTile(RenderTargetBitmap renderBitmap, int w, int h) {
// Measure and arrange the surface
            // VERY IMPORTANT
            var size = new Size(w, h);
            _graphCanvas.Measure(size);
            _graphCanvas.Arrange(new Rect(size));
            renderBitmap.Clear();
            renderBitmap.Render(_graphCanvas);
        }

        /// <summary>
        /// Creates image from canvas with map background.
        /// </summary>
        /// <param name="mapImage">Map image.</param>
        /// <param name="canvas">Canvas to draw.</param>
        /// <returns>Created image.</returns>
        private Image _CreateImage(MapImage mapImage, SysControls.Canvas canvas)
        {
            Debug.Assert(null != mapImage);
            Debug.Assert(null != canvas);

            Image imageWithData = null;

            RenderTargetBitmap bmp = null;
            SysControls.Canvas outer = null;

            Image sourceImage = null;
            using (MemoryStream sourceStream = new MemoryStream((byte[])mapImage.ImageData))
                sourceImage = Image.FromStream(sourceStream);

            try
            {

                var bitmap = sourceImage as Bitmap;
                Debug.Assert(null != bitmap);
                ImageBrush imageBrush = _CreateImageBrush(bitmap);

                outer = new SysControls.Canvas();

                outer.Width = mapImage.ImageWidth;
                outer.Height = mapImage.ImageHeight;
                outer.Children.Add(canvas);
                outer.Background = (ImageBrush)imageBrush.GetCurrentValueAsFrozen();
                outer.Arrange(new Rect(0, 0, outer.Width, outer.Height));

                bmp = new RenderTargetBitmap((int)outer.Width,
                                             (int)outer.Height,
                                             mapImage.ImageDPI,
                                             mapImage.ImageDPI,
                                             PixelFormats.Pbgra32);
                bmp.Render(outer);

                var encoder = new PngBitmapEncoder();
                encoder.Frames.Add(BitmapFrame.Create(bmp));

                using (MemoryStream stream = new MemoryStream())
                {
                    encoder.Save(stream);
                    imageWithData = Image.FromStream(stream);
                }
            }
            finally
            {   // Clear and dispose all used stuff
                if (outer != null)
                {
                    outer.UpdateLayout();
                    outer.Children.Clear();
                }

                canvas.UpdateLayout();
                foreach (object child in canvas.Children)
                {
                    var symbolControl = child as SymbolControl;
                    if (symbolControl != null)
                        symbolControl.Template = null;
                }
                canvas.Children.Clear();

                if (bmp != null)
                    bmp.Clear();

                if (sourceImage != null)
                    sourceImage.Dispose();
            }

            return imageWithData;
        }

        public System.Drawing.Bitmap RenderIcon(string iconText)
        {
            var text = new FormattedText(
                iconText,
                this.CultureInfo,
                this.FlowDirection,
                this.typeface,
                this.fontSize,
                this.foreground);

            var drawingVisual = new DrawingVisual();
            var drawingContext = drawingVisual.RenderOpen();
            drawingContext.DrawText(text, new Point(2, 2));
            drawingContext.Close();

            var target = new RenderTargetBitmap(
                this.iconSize,
                this.iconSize,
                TrayIconDPI,
                TrayIconDPI,
                PixelFormats.Default);

            target.Clear();
            target.Render(drawingVisual);

            var enc = new PngBitmapEncoder();
            enc.Frames.Add(BitmapFrame.Create(target));

            using (var ms = new MemoryStream())
            {
                enc.Save(ms);
                ms.Position = 0;

                return (System.Drawing.Bitmap)System.Drawing.Bitmap.FromStream(ms);
            }
        }

        void frameThread_DoWork(object sender, DoWorkEventArgs e)
        {
            BackgroundWorker bw = (BackgroundWorker)sender;

             MediaPlayer myPlayer = new MediaPlayer();
             myPlayer.Open(parameters.SourceUri);
             myPlayer.Volume = 0;
             myPlayer.Play();

             while (myPlayer.NaturalVideoWidth < 1)
            System.Threading.Thread.Sleep(100);

             myState = ScallopSensorState.Active;
             this.StatusChanged(this, new ScallopSensorStatusChangedEventArgs(ScallopSensorState.Idle, ScallopSensorState.Active));

             RenderTargetBitmap rtb = new RenderTargetBitmap(myPlayer.NaturalVideoWidth, myPlayer.NaturalVideoHeight,
                                                           96, 96, PixelFormats.Pbgra32);

             while (true)
             {
            if (bw.CancellationPending == true)
            {
               myPlayer.Stop();
               e.Cancel = true;
               return;
            }

            DrawingVisual dv = new DrawingVisual();
            DrawingContext dc = dv.RenderOpen();

            dc.DrawVideo(myPlayer, new Rect(0, 0, myPlayer.NaturalVideoWidth, myPlayer.NaturalVideoHeight));
            dc.Close();

            rtb.Clear();
            rtb.Render(dv);

            BitmapFrame bmp = BitmapFrame.Create(rtb);

            switch (parameters.FrameFormat)
            {
               case ("System.Drawing.Bitmap"):

                  using (MemoryStream memoryStream = new MemoryStream())
                  {
                     //bitmapEncoder.Frames.Add(BitmapFrame.Create(bmp));
                     PngBitmapEncoder bitmapEncoder = new PngBitmapEncoder();
                     bitmapEncoder.Frames.Add(bmp);
                     bitmapEncoder.Save(memoryStream);
                     memoryStream.Flush();

                     using (Bitmap bmp2 = Bitmap.FromStream(memoryStream) as Bitmap,
                                   bmp3 = new Bitmap(bmp2.Width,bmp2.Height,System.Drawing.Imaging.PixelFormat.Format24bppRgb))
                     {
                        bmp3.SetResolution(bmp2.HorizontalResolution, bmp2.VerticalResolution);

                        using (System.Drawing.Graphics g = System.Drawing.Graphics.FromImage(bmp3))
                        {
                           g.DrawImage(bmp2, 0, 0);
                        }

                        if (this.Data != null)
                           this.Data(this, new ScallopSensorDataEventArgs((System.Drawing.Bitmap)bmp3.Clone(), "new frame"));
                     }

                  }
                  break;

               case ("System.Windows.Media.Imaging.BitmapSource"):
                  if (this.Data != null)
                     this.Data(this, new ScallopSensorDataEventArgs(bmp as BitmapSource, "new frame"));
                  break;
            }

            if (myPlayer.Position >= myPlayer.NaturalDuration)
            {
               myPlayer.Stop();
               myPlayer.Position = TimeSpan.Zero;
               myPlayer.Play();
            }
             }
        }