C# IGraphics.DrawImageUnscaled方法代码示例

 private void PaintSecondMark(IGraphics g, int scrollBarWid, int width)
 {
     if (secondMark == null){
         CreateSecondMark(scrollBarWid);
     }
     int h = scrollBarWid - 1;
     switch (state){
         case ScrollBarState.HighlightSecondBox:
             g.DrawImageUnscaled(secondMarkHighlight, width - h, 1);
             break;
         case ScrollBarState.PressSecondBox:
             g.DrawImageUnscaled(secondMarkPress, width - h, 1);
             break;
         default:
             g.DrawImageUnscaled(secondMark, width - h, 1);
             break;
     }
 }

 private void PaintBar(IGraphics g, int scrollBarWid, int width)
 {
     if (!HasBar){
         return;
     }
     if (bar != null && CalcBarSize(width) != bar.Width){
         bar = null;
     }
     if (bar == null){
         CreateBar(scrollBarWid, width);
     }
     int h = CalcBarStart(width);
     switch (state){
         case ScrollBarState.HighlightBar:
             g.DrawImageUnscaled(barHighlight, h, 1);
             break;
         case ScrollBarState.PressBar:
             g.DrawImageUnscaled(barPress, h, 1);
             break;
         default:
             g.DrawImageUnscaled(bar, h, 1);
             break;
     }
 }

 private void PaintFirstMark(IGraphics g, int scrollBarWid)
 {
     if (firstMark == null){
         CreateFirstMark(scrollBarWid);
     }
     switch (state){
         case ScrollBarState.HighlightFirstBox:
             g.DrawImageUnscaled(firstMarkHighlight, 0, 1);
             break;
         case ScrollBarState.PressFirstBox:
             g.DrawImageUnscaled(firstMarkPress, 0, 1);
             break;
         default:
             g.DrawImageUnscaled(firstMark, 0, 1);
             break;
     }
 }

 /// <summary>
 /// Function that does the actual rendering
 /// </summary>
 /// <param name="pt">The point</param>
 /// <param name="g">The graphics object</param>
 internal override void OnRenderInternal(PointF ptf, IGraphics g)
 {
     Point pt = new Point(
         Convert.ToInt32(ptf.X), 
         Convert.ToInt32(ptf.Y));
     Image symbol = Symbol ?? DefaultSymbol;
     int width = Convert.ToInt32(symbol.Width * Scale);
     int height = Convert.ToInt32(symbol.Height * Scale);
     if (ImageAttributes == null)
     {
         if (Scale == 1f)
         {
             lock (symbol)
             {
                 g.DrawImageUnscaled(symbol, pt.X, pt.Y);
             }
         }
         else
         {
             lock (symbol)
             {
                 g.DrawImage(
                     symbol,
                     pt.X,
                     pt.Y,
                     width,
                     height);
             }
         }
     }
     else
     {
         g.DrawImage(
             symbol,
             pt.X, pt.Y, width, height,
             0, 0, symbol.Width, symbol.Height,
             GraphicsUnitType.Pixel,
             ImageAttributes);
     }
 }

 protected void PaintOnGraphicsBitmap(IGraphics g, int width, int height)
 {
     if (backBuffer == null || scatterPlot == null) {
         return;
     }
     UnsafeBitmap copyBackBuffer = new UnsafeBitmap(backBuffer);
     copyBackBuffer.LockBitmap();
     // selected data-points
     foreach (int s in scatterPlot.Selection) {
         double[] w = scatterPlot.GetDataAt(s);
         if (w.Length > 0){
             double x = w[0];
             double y = w[1];
             SymbolProperties gx = GetPointProperties != null ? GetPointProperties(s) : defaultSymbol;
             SymbolType symbolType = SymbolType.allSymbols[gx.Type];
             int symbolSize = gx.Size;
             if (symbolSize > 0){
                 int[] pathX;
                 int[] pathY;
                 symbolType.GetPath(symbolSize, out pathX, out pathY);
                 copyBackBuffer.DrawPath(SelectionColor, ModelToViewX(x, width), ModelToViewY(y, height), pathX, pathY);
             }
         }
     }
     copyBackBuffer.UnlockBitmap();
     // labels
     ScatterPlotLabelMode labelMode = scatterPlot.GetLabelMode();
     bool cutLabels = scatterPlot.CutLabels;
     if (labelMode == ScatterPlotLabelMode.All && scatterPlot.HasLabels) {
         Font font = new Font("Arial", scatterPlot.FontSize, scatterPlot.FontStyle);
         for (;;){
             double[] x;
             double[] y;
             double[] z;
             string[] labels;
             int index;
             try{
                 scatterPlot.GetData(out x, out y, out z, out labels, out index);
             } catch (IndexOutOfRangeException){
                 break;
             }
             if (x == null){
                 break;
             }
             SymbolProperties gx = GetPointProperties != null ? GetPointProperties(index) : defaultSymbol;
             for (int i = 0; i < x.Length; i++){
                 if (labelMode == ScatterPlotLabelMode.All || scatterPlot.IsSelected(i)) {
                     int ix = ModelToViewX(x[i], width);
                     int iy = ModelToViewY(y[i], height);
                     Color c;
                     if (z != null && colorScale != null){
                         c = colorScale.GetColor(z[i]);
                     } else{
                         c = gx.Color;
                     }
                     Brush b = new SolidBrush(c);
                     if (ix >= 0 && iy >= 0 && ix < width && iy < height){
                         if (labels[i] != null){
                             string s = labels[i];
                             if (cutLabels){
                                 if (s.Contains(";")){
                                     s = s.Substring(0, s.IndexOf(';'));
                                 }
                             }
                             copyBackBuffer.DrawString(s, font, b, ix, iy);
                         }
                     }
                 }
             }
         }
         scatterPlot.Reset();
     }
     if (labelMode == ScatterPlotLabelMode.Selected && scatterPlot.HasLabels) {
         Brush br = new SolidBrush(SelectionColor);
         Font font = new Font("Arial", scatterPlot.FontSize, scatterPlot.FontStyle);
         foreach (int s in scatterPlot.Selection) {
             double[] w = scatterPlot.GetDataAt(s);
             string label = scatterPlot.GetLabelAt(s);
             double x = w[0];
             double y = w[1];
             int ix = ModelToViewX(x, width);
             int iy = ModelToViewY(y, height);
             if (ix >= 0 && iy >= 0 && ix < width && iy < height){
                 if (label != null){
                     if (cutLabels){
                         if (label.Contains(";")){
                             label = label.Substring(0, label.IndexOf(';'));
                         }
                     }
                     copyBackBuffer.DrawString(label, font, br, ix, iy);
                 }
             }
         }
     }
     // draw the image
     g.DrawImageUnscaled(copyBackBuffer.Bitmap, 0, 0);
     copyBackBuffer.Dispose();
     g.SmoothingMode = SmoothingMode.AntiAlias;
     DrawPolygons(g, width, height);
     if (drawFunctions != null){
//.........这里部分代码省略.........

        private void RenderParellel(IGraphics g)
        {
            _images = new Image[_layers.Length];

            var res = Parallel.For(0, _layers.Length, RenderToImage);
            
            var tmpTransform = g.Transform;
            g.Transform = new Matrix();
            if (res.IsCompleted)
            {
                for (var i = 0; i < _images.Length; i++)
                {
                    if (_images[i] != null)
                    {
                        g.DrawImageUnscaled(_images[i], 0, 0);
                        //break;
                    }
                }
            }
            g.Transform = tmpTransform;
        }

        /// <summary>
        /// Renders the layer
        /// </summary>
        /// <param name="graphics">Graphics object reference</param>
        /// <param name="map">Map which is rendered</param>
        public override void Render(IGraphics graphics, Map map)
        {
            if (!map.Size.IsEmpty && map.Size.Width > 0 && map.Size.Height > 0)
            {
                var bmp = new Bitmap(map.Size.Width, map.Size.Height, PixelFormat.Format32bppArgb);
                
                using (IGraphics g = Graphics.FromImage(bmp).G())
                {
                    g.InterpolationMode = InterpolationMode;
                    g.Transform = graphics.Transform.Clone();

                    var extent = new Extent(map.Envelope.MinX, map.Envelope.MinY, 
                                            map.Envelope.MaxX, map.Envelope.MaxY);
                    var level = BruTile.Utilities.GetNearestLevel(_source.Schema.Resolutions, map.PixelSize);
                    var tiles = new List<TileInfo>(_source.Schema.GetTilesInView(extent, level));
                    var tileWidth = _source.Schema.GetTileWidth(level);
                    var tileHeight = _source.Schema.GetTileWidth(level);

                    IList<WaitHandle> waitHandles = new List<WaitHandle>();
                    var toRender = new Dictionary<TileIndex, Bitmap>();
                    var takenFromCache = new Dictionary<TileIndex,bool>();
                    foreach (TileInfo info in tiles)
                    {
                        var image = _bitmaps.Find(info.Index);
                        if (image != null)
                        {
                            toRender.Add(info.Index, image);
                            takenFromCache.Add(info.Index,true);
                            continue;
                        }
                        if (_fileCache != null && _fileCache.Exists(info.Index))
                        {
                            _bitmaps.Add(info.Index, GetImageFromFileCache(info) as Bitmap);
                            toRender.Add(info.Index, _bitmaps.Find(info.Index));
                            takenFromCache.Add(info.Index,true);
                            continue;
                        }

                        var waitHandle = new AutoResetEvent(false);
                        waitHandles.Add(waitHandle);
                        ThreadPool.QueueUserWorkItem(GetTileOnThread,
                                                     new object[] { _source.Provider, info, toRender, waitHandle, true });
                    }

                    foreach (var handle in waitHandles)
                        handle.WaitOne();

                    using (var ia = new ImageAttributes())
                    {
                        if (!_transparentColor.IsEmpty)
                            ia.SetColorKey(_transparentColor, _transparentColor);
#if !PocketPC
                        ia.SetWrapMode(WrapMode.TileFlipXY);
#endif

                        foreach (var info in tiles)
                        {
                            if (!toRender.ContainsKey(info.Index))
                                continue;

                            var bitmap = toRender[info.Index];//_bitmaps.Find(info.Index);
                            if (bitmap == null) continue;

                            var min = map.WorldToImage(new Coordinate(info.Extent.MinX, info.Extent.MinY));
                            var max = map.WorldToImage(new Coordinate(info.Extent.MaxX, info.Extent.MaxY));

                            min = new PointF((float) Math.Round(min.X), (float) Math.Round(min.Y));
                            max = new PointF((float) Math.Round(max.X), (float) Math.Round(max.Y));

                            try
                            {
                                g.DrawImage(bitmap,
                                    (int) min.X, (int) max.Y, (int) (max.X - min.X),
                                    (int) (min.Y - max.Y), 0, 0, tileWidth, tileHeight,
                                    GraphicsUnitType.Pixel, ia);
                            }
                            catch (Exception ee)
                            {
                                Logger.Error(ee.Message);
                            }

                        }
                    }

                    //Add rendered tiles to cache
                    foreach (var kvp in toRender)
                    {
                        if (takenFromCache.ContainsKey(kvp.Key) && !takenFromCache[kvp.Key])
                        {
                            _bitmaps.Add(kvp.Key, kvp.Value);
                        }
                    }

                    graphics.Transform = new Matrix();
                    graphics.DrawImageUnscaled(bmp, 0, 0);
//.........这里部分代码省略.........

        /// <summary>
        /// Do all rendering associated with this <see cref="CurveItem"/> to the specified
        /// <see cref="Graphics"/> device.  This method is normally only
        /// called by the Draw method of the parent <see cref="CurveList"/>
        /// collection object.
        /// </summary>
        /// <param name="g">
        /// A graphic device object to be drawn into.  This is normally e.Graphics from the
        /// PaintEventArgs argument to the Paint() method.
        /// </param>
        /// <param name="pane">
        /// A reference to the <see cref="GraphPane"/> object that is the parent or
        /// owner of this object.
        /// </param>
        /// <param name="pos">The ordinal position of the current <see cref="Bar"/>
        /// curve.</param>
        /// <param name="scaleFactor">
        /// The scaling factor to be used for rendering objects.  This is calculated and
        /// passed down by the parent <see cref="GraphPane"/> object using the
        /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
        /// font sizes, etc. according to the actual size of the graph.
        /// </param>
        public override void Draw(IGraphics g, GraphPane pane, int pos, float scaleFactor)
        {
            RectangleF rect = GetDrawingRect(pane);

            g.FillEllipse(MakeBrush(), rect);
            g.DrawEllipse(MakePen(), rect);

            if(Image != null)
            {
                var left = rect.Left + rect.Width / 2.0 - Image.Width / 2.0;
                var top = rect.Top + rect.Height / 2.0 - Image.Height / 2.0;
                var tmpRect = new RectangleF((float)left, (float)top, Image.Width, Image.Height);
                Region clip = g.Clip;
                g.SetClip(tmpRect);
                g.DrawImageUnscaled(Image, Rectangle.Round(tmpRect));
                g.SetClip(clip, CombineMode.Replace);

            }
        }

        public static void PaintOverview(IGraphics g, SizeI2 totalSize, RectangleI2 visibleWin,
			Func<int, int, Bitmap2> getOverviewBitmap, float zoomFactorX, float zoomFactorY)
        {
            Size2 overview = CalcOverviewSize(visibleWin.Width, visibleWin.Height, totalSize.Width, totalSize.Height);
            Rectangle2 win = CalcWin(overview, totalSize, visibleWin, zoomFactorX, zoomFactorY);
            g.FillRectangle(Brushes2.White, 0, visibleWin.Height - overview.Height, overview.Width, overview.Height);
            g.DrawImageUnscaled(getOverviewBitmap((int) overview.Width, (int) overview.Height), 0,
                visibleWin.Height - overview.Height);
            Brush2 b = new Brush2(Color2.FromArgb(30, 0, 0, 255));
            if (win.X > 0){
                g.FillRectangle(b, 0, visibleWin.Height - overview.Height, win.X, overview.Height);
            }
            if (overview.Width - win.X - win.Width > 0){
                g.FillRectangle(b, win.X + win.Width, visibleWin.Height - overview.Height, overview.Width - win.X - win.Width,
                    overview.Height);
            }
            if (win.Y > 0){
                g.FillRectangle(b, win.X, visibleWin.Height - overview.Height, win.Width, win.Y);
            }
            if (overview.Height - win.Y - win.Height > 0){
                g.FillRectangle(b, win.X, visibleWin.Height - overview.Height + win.Y + win.Height - 1, win.Width,
                    overview.Height - win.Y - win.Height);
            }
            g.DrawRectangle(Pens2.Black, 0, visibleWin.Height - overview.Height - 1, overview.Width, overview.Height);
            g.DrawRectangle(Pens2.Blue, win.X, visibleWin.Height - overview.Height - 1 + win.Y, win.Width, win.Height);
        }

        /// <summary>
        /// Render this object to the specified <see cref="Graphics"/> device
        /// This method is normally only called by the Draw method
        /// of the parent <see cref="GraphObjList"/> collection object.
        /// </summary>
        /// <param name="g">
        /// A graphic device object to be drawn into.  This is normally e.Graphics from the
        /// PaintEventArgs argument to the Paint() method.
        /// </param>
        /// <param name="pane">
        /// A reference to the <see cref="PaneBase"/> object that is the parent or
        /// owner of this object.
        /// </param>
        /// <param name="scaleFactor">
        /// The scaling factor to be used for rendering objects.  This is calculated and
        /// passed down by the parent <see cref="GraphPane"/> object using the
        /// <see cref="PaneBase.CalcScaleFactor"/> method, and is used to proportionally adjust
        /// font sizes, etc. according to the actual size of the graph.
        /// </param>
        public override void Draw( IGraphics g, PaneBase pane, float scaleFactor )
        {
            if ( _image != null )
            {
                // Convert the rectangle coordinates from the user coordinate system
                // to the screen coordinate system
                RectangleF tmpRect = _location.TransformRect( pane );

                if ( _isScaled )
                    g.DrawImage( _image, tmpRect );
                else
                {
                    Region clip = g.Clip;
                    g.SetClip( tmpRect );
                    g.DrawImageUnscaled( _image, Rectangle.Round( tmpRect ) );
                    g.SetClip( clip, CombineMode.Replace );
                    //g.DrawImageUnscaledAndClipped( image, Rectangle.Round( tmpRect ) );
                }
            }
        }