Beispiel #1
0
        /// <summary>
        /// Creates a new instance of DrawArgs
        /// </summary>
        public MapDrawArgs(Graphics inGraphics, Rectangle clipRectangle, IMapFrame inMapFrame)
        {
            _graphics = inGraphics;
            _geoGraphics = new MapArgs(clipRectangle, inMapFrame.ViewExtents);

            _clipRectangle = clipRectangle;
        }
        /// <summary>
        /// This draws to the back buffer.  If the Backbuffer doesn't exist, this will create one.
        /// This will not flip the back buffer to the front.
        /// </summary>
        /// <param name="args"></param>
        /// <param name="regions"></param>
        /// <param name="clipRectangles"></param>
        private void DrawWindows(MapArgs args, IList<Extent> regions, IList<Rectangle> clipRectangles)
        {
            Graphics g = args.Device;
            int numBounds = Math.Min(regions.Count, clipRectangles.Count);

            for (int i = 0; i < numBounds; i++)
            {
                Bitmap bmp = DataSet.GetBitmap(regions[i], clipRectangles[i].Size);
                if (bmp != null) g.DrawImage(bmp, clipRectangles[i]);
            }
            if (args.Device == null) g.Dispose();
        }
Beispiel #3
0
 /// <summary>
 /// Draw features
 /// </summary>
 /// <param name="args">The GeoArgs that control how these features should be drawn.</param>
 /// <param name="indices">The features that should be drawn.</param>
 /// <param name="clipRectangles">If an entire chunk is drawn and an update is specified, this clarifies the changed rectangles.</param>
 /// <param name="useChunks">Boolean, if true, this will refresh the buffer in chunks.</param>
 public virtual void DrawFeatures(MapArgs args, List<int> indices, List<Rectangle> clipRectangles, bool useChunks)
 {
     this.DrawUsingChunks(args, indices, clipRectangles, useChunks, DrawFeatures);
 }
Beispiel #4
0
        // This draws the individual line features
        private void DrawFeatures(MapArgs e, IEnumerable <int> features)
        {
            Graphics g = e.Device ?? Graphics.FromImage(_backBuffer);

            // Only draw features that are currently visible.

            if (FastDrawnStates == null)
            {
                CreateIndexedLabels();
            }
            FastLabelDrawnState[] drawStates = FastDrawnStates;
            if (drawStates == null)
            {
                return;
            }
            //Sets the graphics objects smoothing modes
            g.TextRenderingHint = TextRenderingHint.AntiAlias;
            g.SmoothingMode     = SmoothingMode.AntiAlias;
            FeatureType type = FeatureSet.FeatureType;

            foreach (ILabelCategory category in Symbology.Categories)
            {
                List <int> catFeatures = new List <int>();
                foreach (int fid in features)
                {
                    if (drawStates[fid] == null || drawStates[fid].Category == null)
                    {
                        continue;
                    }
                    if (drawStates[fid].Category == category)
                    {
                        catFeatures.Add(fid);
                    }
                }
                // Now that we are restricted to a certain category, we can look at
                // priority
                if (category.Symbolizer.PriorityField != "FID")
                {
                    Feature.ComparisonField = category.Symbolizer.PriorityField;
                    catFeatures.Sort();
                    // When preventing collisions, we want to do high priority first.
                    // otherwise, do high priority last.
                    if (category.Symbolizer.PreventCollisions)
                    {
                        if (!category.Symbolizer.PrioritizeLowValues)
                        {
                            catFeatures.Reverse();
                        }
                    }
                    else
                    {
                        if (category.Symbolizer.PrioritizeLowValues)
                        {
                            catFeatures.Reverse();
                        }
                    }
                }
                foreach (int fid in catFeatures)
                {
                    IFeature feature = FeatureSet.GetFeature(fid);
                    switch (type)
                    {
                    case FeatureType.Polygon:
                        DrawPolygonFeature(e, g, feature, drawStates[fid].Category, drawStates[fid].Selected, ExistingLabels);
                        break;

                    case FeatureType.Line:
                        DrawLineFeature(e, g, feature, drawStates[fid].Category, drawStates[fid].Selected, ExistingLabels);
                        break;

                    case FeatureType.Point:
                        DrawPointFeature(e, g, feature, drawStates[fid].Category, drawStates[fid].Selected, ExistingLabels);
                        break;
                    }
                }
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
        }
Beispiel #5
0
        private static void BuildLineString(GraphicsPath path, double[] vertices, ShapeRange shpx, MapArgs args, Rectangle clipRect)
        {
            var minX = args.MinX;
            var maxY = args.MaxY;
            var dx = args.Dx;
            var dy = args.Dy;

            foreach (var prtx in shpx.Parts)
            {
                var points = prtx.Select(v => new Vertex((v.X - minX) * dx, (maxY - v.Y) * dy)).ToList();
                List<List<Vertex>> multiLinestrings;

                if (!shpx.Extent.Within(args.GeographicExtents))
                {
                    multiLinestrings = CohenSutherland.ClipLinestring(points, clipRect.Left, clipRect.Top,
                        clipRect.Right, clipRect.Bottom);
                }
                else
                {
                    multiLinestrings = new List<List<Vertex>> { points };
                }

                foreach (var linestring in multiLinestrings)
                {
                    var intPoints = DuplicationPreventer.Clean(linestring).ToArray();
                    if (intPoints.Length < 2) continue;

                    path.StartFigure();
                    path.AddLines(intPoints);
                }
            }
        }
Beispiel #6
0
        /// <summary>
        /// Appends the specified polygon to the graphics path.
        /// </summary>
        private static void BuildPolygon(double[] vertices, ShapeRange shpx, GraphicsPath borderPath, MapArgs args, SoutherlandHodgman shClip)
        {
            double minX = args.MinX;
            double maxY = args.MaxY;
            double dx = args.Dx;
            double dy = args.Dy;

            for (int prt = 0; prt < shpx.Parts.Count; prt++)
            {
                PartRange prtx = shpx.Parts[prt];
                int start = prtx.StartIndex;
                int end = prtx.EndIndex;
                var points = new List<double[]>(end - start + 1);

                for (int i = start; i <= end; i++)
                {
                    var pt = new[]
                    {
                        (vertices[i*2] - minX)*dx,
                        (maxY - vertices[i*2 + 1])*dy
                    };
                    points.Add(pt);
                }
                if (null != shClip)
                {
                    points = shClip.Clip(points);
                }
                var intPoints = DuplicationPreventer.Clean(points).ToArray();
                if (intPoints.Length < 2)
                {
                    continue;
                }

                borderPath.StartFigure();
                borderPath.AddLines(intPoints);
            }
        }
Beispiel #7
0
        private void DrawFeatures(MapArgs e, IEnumerable <int> indices, bool selected)
        {
            if (selected && !DrawnStatesNeeded)
            {
                return;
            }

            Graphics g = e.Device ?? Graphics.FromImage(BackBuffer);

            g.SetClip(new Rectangle(0, 0, e.ImageRectangle.Width, e.ImageRectangle.Height));
            var indiceList = indices as IList <int> ?? indices.ToList();

            Action <GraphicsPath, Rectangle, IEnumerable <int> > drawFeature = (graphPath, clipRect, features) =>
            {
                foreach (int shp in features)
                {
                    ShapeRange shape = DataSet.ShapeIndices[shp];
                    BuildLineString(graphPath, DataSet.Vertex, shape, e, clipRect);
                }
            };

            if (DrawnStatesNeeded)
            {
                FastDrawnState[] states = DrawnStates;

                if (indiceList.Max() >= states.Length)
                {
                    AssignFastDrawnStates();
                    states = DrawnStates;
                }

                Rectangle rTest = Rectangle.Empty;
                DotSpatial.Controls.Core.CGX_Mask cgxMask = DotSpatial.Controls.Core.CGX_Mask_List.GetMasks(this.Name);
                if (cgxMask != null)
                {
                    foreach (DotSpatial.Controls.Core.CGX_MaskBounds mask in cgxMask.Masks)
                    {
                        RectangleF rectBounds = mask.Bounds;
                        if (rectBounds.IsEmpty)
                        {
                            if (mask.Center != null)
                            {
                                Point pTest1 = e.ProjToPixel(mask.Center);
                                pTest1.X  -= (int)(mask.Width / 2);
                                pTest1.Y  -= (int)(mask.Height / 2);
                                rectBounds = new RectangleF(pTest1, new SizeF((float)mask.Width, (float)mask.Height));
                            }
                        }

                        if (!rectBounds.IsEmpty)
                        {
                            float cx = rectBounds.X + (int)(mask.Width / 2);
                            float cy = rectBounds.Y + +(int)(mask.Height / 2);

                            System.Drawing.Drawing2D.Matrix oldTrans = g.Transform.Clone();
                            g.ResetTransform();
                            g.TranslateTransform(-cx, -cy, MatrixOrder.Append);
                            g.RotateTransform((float)mask.Rotation, MatrixOrder.Append);
                            g.TranslateTransform(cx, cy, MatrixOrder.Append);

                            RectangleF rectWithMargin = new RectangleF(
                                (float)((rectBounds.Location.X - cgxMask.OffsetLeft + 1)),
                                (float)((rectBounds.Location.Y - cgxMask.OffsetTop + 1)),
                                (float)((rectBounds.Width + cgxMask.OffsetLeft + cgxMask.OffsetRight)),
                                (float)((rectBounds.Height + cgxMask.OffsetTop + cgxMask.OffsetBottom)));
                            g.ExcludeClip(Rectangle.Round(rectWithMargin));

                            g.Transform = oldTrans;
                        }
                    }

                    cgxMask.ResetBounds();
                }

                if (selected && !states.Any(_ => _.Selected))
                {
                    return;
                }

                foreach (ILineCategory category in Symbology.Categories)
                {
                    // Define the symbology based on the category and selection state
                    ILineSymbolizer ls       = selected ? category.SelectionSymbolizer : category.Symbolizer;
                    var             features = GetFeatures(indiceList, states, category, selected);

                    DrawPath(g, ls, e, drawFeature, features);
                }

                g.ResetClip();
            }
            else
            {
                // Selection state is disabled and there is only one category
                ILineSymbolizer ls = Symbology.Categories[0].Symbolizer;
                DrawPath(g, ls, e, drawFeature, indiceList);
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
        }
Beispiel #8
0
        /*
        private static Extent FromBruTileExtent(BruTile.Extent extent)
        {
            return new Extent(extent.MinX, extent.MinY, extent.MaxX, extent.MaxY);
        }
         */
        /// <summary>
        /// This draws content from the specified geographic regions onto the specified graphics
        /// object specified by MapArgs.
        /// </summary>
        public void DrawRegions(MapArgs args, List<Extent> regions)
        {
            System.Windows.Threading.Dispatcher dispatcher = System.Windows.Application.Current.Dispatcher;
            BruTile.Extent extent = ToBrutileExtent(args.GeographicExtents);
            double pixelSize = extent.Width / args.ImageRectangle.Width;

            int level = Utilities.GetNearestLevel(TileSource.Schema.Resolutions, pixelSize);
            IList<TileInfo> tiles = TileSource.Schema.GetTilesInView(extent, level);

            IList<WaitHandle> waitHandles = new List<WaitHandle>();

            foreach (TileInfo info in tiles)
            {
                if (TileCache.Find(info.Index) != null) continue;
                AutoResetEvent waitHandle = new AutoResetEvent(false);
                waitHandles.Add(waitHandle);
                ThreadPool.QueueUserWorkItem(GetTileOnThread,
                                             new object[] { TileSource.Provider, info, TileCache, waitHandle });
            }

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

                foreach (TileInfo info in tiles)
                {
                    using (Image bitmap = Image.FromStream(new MemoryStream(TileCache.Find(info.Index))))
                    {
                        PointF min = args.ProjToPixel(new Coordinate(info.Extent.MinX, info.Extent.MinY));
                        PointF max = args.ProjToPixel(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));

                        args.Device.DrawImage(bitmap,
                                    new Rectangle((int)min.X, (int)max.Y, (int)(max.X - min.X), (int)(min.Y - max.Y)),
                                    0, 0, TileSource.Schema.Width, TileSource.Schema.Height,
                                    GraphicsUnit.Pixel);

                    }

                }
        }
Beispiel #9
0
        /// <summary>
        /// Draws the GraphicsPaths.  Before we were effectively "re-creating" the same geometric
        /// </summary>
        /// <param name="e"></param>
        /// <param name="paths"></param>
        private void DrawPaths(MapArgs e, IList<GraphicsPath> paths)
        {
            Graphics g = e.Device ?? Graphics.FromImage(BackBuffer);
            int numCategories = Symbology.Categories.Count;

            if (!DrawnStatesNeeded && !EditMode)
            {
                IPolygonSymbolizer ps = Symbolizer;

                g.SmoothingMode = ps.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None;
                Extent catBounds = DataSet.Extent;
                var bounds = new RectangleF
                {
                    X = Convert.ToSingle((catBounds.MinX - e.MinX) * e.Dx),
                    Y = Convert.ToSingle((e.MaxY - catBounds.MaxY) * e.Dy)
                };
                float r = Convert.ToSingle((catBounds.MaxX - e.MinX) * e.Dx);
                bounds.Width = r - bounds.X;
                float b = Convert.ToSingle((e.MaxY - catBounds.MinY) * e.Dy);
                bounds.Height = b - bounds.Y;

                foreach (IPattern pattern in ps.Patterns)
                {
                    IGradientPattern gp = pattern as IGradientPattern;
                    if (gp != null)
                    {
                        gp.Bounds = bounds;
                    }

                    pattern.FillPath(g, paths[0]);
                }

                double scale = 1;
                if (ps.ScaleMode == ScaleMode.Geographic)
                {
                    scale = e.ImageRectangle.Width / e.GeographicExtents.Width;
                }
                foreach (IPattern pattern in ps.Patterns)
                {
                    if (pattern.UseOutline)
                    {
                        pattern.DrawPath(g, paths[0], scale);
                    }
                }
            }
            else
            {
                for (int selectState = 0; selectState < 2; selectState++)
                {
                    int iCategory = 0;
                    foreach (IPolygonCategory category in Symbology.Categories)
                    {
                        Extent catBounds;
                        catBounds = CategoryExtents.Keys.Contains(category) ? CategoryExtents[category] : CalculateCategoryExtent(category);
                        if (catBounds == null) catBounds = Extent;
                        var bounds = new RectangleF
                        {
                            X = Convert.ToSingle((catBounds.MinX - e.MinX) * e.Dx),
                            Y = Convert.ToSingle((e.MaxY - catBounds.MaxY) * e.Dy)
                        };
                        float r = Convert.ToSingle((catBounds.MaxX - e.MinX) * e.Dx);
                        bounds.Width = r - bounds.X;
                        float b = Convert.ToSingle((e.MaxY - catBounds.MinY) * e.Dy);
                        bounds.Height = b - bounds.Y;

                        int index = selectState * numCategories + iCategory;
                        // Define the symbology based on the category and selection state
                        IPolygonSymbolizer ps = category.Symbolizer;
                        if (selectState == SELECTED) ps = category.SelectionSymbolizer;

                        g.SmoothingMode = ps.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None;

                        foreach (IPattern pattern in ps.Patterns)
                        {
                            IGradientPattern gp = pattern as IGradientPattern;
                            if (gp != null)
                            {
                                gp.Bounds = bounds;
                            }
                            if (paths[index] != null)
                            {
                                paths[index].FillMode = FillMode.Winding;
                                pattern.FillPath(g, paths[index]);
                            }
                        }

                        double scale = 1;
                        if (ps.ScaleMode == ScaleMode.Geographic)
                        {
                            scale = e.ImageRectangle.Width / e.GeographicExtents.Width;
                        }
                        foreach (IPattern pattern in ps.Patterns)
                        {
                            if (pattern.UseOutline)
                            {
                                pattern.DrawPath(g, paths[index], scale);
                            }
                        }
                        iCategory++;
                    } // category
                } // selectState
            }

            if (e.Device == null) g.Dispose();
        }
Beispiel #10
0
        // This draws the individual line features
        private void DrawFeatures(MapArgs e, IEnumerable <IFeature> features)
        {
            Graphics g = e.Device ?? Graphics.FromImage(_backBuffer);

            for (int selectState = 0; selectState < 2; selectState++)
            {
                foreach (ILineCategory category in Symbology.Categories)
                {
                    // Define the symbology based on the category and selection state
                    ILineSymbolizer ls = category.Symbolizer;
                    if (selectState == SELECTED)
                    {
                        ls = category.SelectionSymbolizer;
                    }
                    if (ls.Smoothing)
                    {
                        g.SmoothingMode = SmoothingMode.AntiAlias;
                    }
                    else
                    {
                        g.SmoothingMode = SmoothingMode.None;
                    }

                    Rectangle clipRect = ComputeClippingRectangle(e, ls);

                    // Determine the subset of the specified features that are visible and match the category
                    ILineCategory            lineCategory = category;
                    int                      i            = selectState;
                    Func <IDrawnState, bool> isMember     = state =>
                                                            state.SchemeCategory == lineCategory &&
                                                            state.IsVisible &&
                                                            state.IsSelected == (i == 1);

                    var drawnFeatures = from feature in features
                                        where isMember(DrawingFilter[feature])
                                        select feature;

                    GraphicsPath graphPath = new GraphicsPath();
                    foreach (IFeature f in drawnFeatures)
                    {
                        BuildLineString(graphPath, DataSet.Vertex, f.ShapeIndex, e, clipRect);
                    }
                    double scale = 1;
                    if (ls.ScaleMode == ScaleMode.Geographic)
                    {
                        scale = e.ImageRectangle.Width / e.GeographicExtents.Width;
                    }

                    foreach (IStroke stroke in ls.Strokes)
                    {
                        stroke.DrawPath(g, graphPath, scale);
                    }

                    graphPath.Dispose();
                }
            }
            if (e.Device == null)
            {
                g.Dispose();
            }
        }
Beispiel #11
0
        /// <summary>
        /// Draws the GraphicsPaths. Before we were effectively "re-creating" the same geometric.
        /// </summary>
        /// <param name="e">The map arguments.</param>
        /// <param name="paths">The graphics path.</param>
        /// <param name="selected">Indicates whether to draw the normal colored features or the selection colored features.</param>
        private void DrawPaths(MapArgs e, Dictionary <FastDrawnState, GraphicsPath> paths, bool selected)
        {
            Graphics g = e.Device ?? Graphics.FromImage(BackBuffer);

            foreach (var kvp in paths)
            {
                var category = kvp.Key.Category;

                if (kvp.Key.Category == null)
                {
                    continue;
                }

                Extent catBounds = (CategoryExtents.Keys.Contains(category) ? CategoryExtents[category] : CalculateCategoryExtent(category)) ?? Extent;
                var    bounds    = new RectangleF
                {
                    X = Convert.ToSingle((catBounds.MinX - e.MinX) * e.Dx),
                    Y = Convert.ToSingle((e.MaxY - catBounds.MaxY) * e.Dy)
                };
                float r = Convert.ToSingle((catBounds.MaxX - e.MinX) * e.Dx);
                bounds.Width = r - bounds.X;
                float b = Convert.ToSingle((e.MaxY - catBounds.MinY) * e.Dy);
                bounds.Height = b - bounds.Y;

                var ps = (selected && kvp.Key.Selected ? category.SelectionSymbolizer : category.Symbolizer) as PolygonSymbolizer;
                if (ps == null)
                {
                    continue;
                }

                g.SmoothingMode = ps.GetSmoothingMode();

                foreach (IPattern pattern in ps.Patterns)
                {
                    IGradientPattern gp = pattern as IGradientPattern;
                    if (gp != null)
                    {
                        gp.Bounds = bounds;
                    }

                    pattern.FillPath(g, kvp.Value);
                }

                double scale = ps.GetScale(e);
                // CGX
                if (MapFrame != null && (MapFrame as IMapFrame).ReferenceScale > 1.0 && (MapFrame as IMapFrame).CurrentScale > 0.0)
                {
                    double dReferenceScale = (MapFrame as IMapFrame).ReferenceScale;
                    double dCurrentScale   = (MapFrame as IMapFrame).CurrentScale;
                    scale = dReferenceScale / dCurrentScale;
                } // Fin CGX

                foreach (IPattern pattern in ps.Patterns)
                {
                    if (pattern.UseOutline)
                    {
                        pattern.DrawPath(g, kvp.Value, scale);
                    }
                }
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
        }
Beispiel #12
0
        private static RectangleF PlaceLineLabel(IBasicGeometry lineString, Func <SizeF> labelSize, MapArgs e, ILabelSymbolizer symb)
        {
            ILineString ls = Geometry.FromBasicGeometry(lineString) as ILineString;

            if (ls == null)
            {
                return(RectangleF.Empty);
            }
            Coordinate c;

            if (symb.LabelPlacementMethod == LabelPlacementMethod.Centroid)
            {
                c = ls.Centroid.Coordinate;
            }
            else if (symb.LabelPlacementMethod == LabelPlacementMethod.InteriorPoint)
            {
                c = ls.InteriorPoint.Coordinate;
            }
            else
            {
                c = ls.Envelope.Center();
            }

            var    lz         = labelSize();
            PointF adjustment = Position(symb, lz);
            float  x          = Convert.ToSingle((c.X - e.MinX) * e.Dx) + adjustment.X;
            float  y          = Convert.ToSingle((e.MaxY - c.Y) * e.Dy) + adjustment.Y;

            return(new RectangleF(x, y, lz.Width, lz.Height));
        }
Beispiel #13
0
        // This draws the individual point features
        private void DrawFeatures(MapArgs e, IEnumerable <int> indices, bool selected)
        {
            if (selected && (!DrawnStatesNeeded || !DrawnStates.Any(_ => _.Selected)))
            {
                return;                                                                        // there are no selected features
            }
            Graphics    g             = e.Device ?? Graphics.FromImage(BackBuffer);
            Matrix      origTransform = g.Transform;
            FeatureType featureType   = DataSet.FeatureType;

            if (!DrawnStatesNeeded)
            {
                if (Symbology == null || Symbology.Categories.Count == 0)
                {
                    return;
                }
                FastDrawnState   state = new FastDrawnState(false, Symbology.Categories[0]);
                IPointSymbolizer ps    = (state.Category as IPointCategory)?.Symbolizer;
                if (ps == null)
                {
                    return;
                }
                double[] vertices = DataSet.Vertex;

                foreach (int index in indices)
                {
                    if (featureType == FeatureType.Point)
                    {
                        DrawPoint(vertices[index * 2], vertices[(index * 2) + 1], e, ps, g, origTransform);
                    }
                    else
                    {
                        // multi-point
                        ShapeRange range = DataSet.ShapeIndices[index];
                        for (int i = range.StartIndex; i <= range.EndIndex(); i++)
                        {
                            DrawPoint(vertices[i * 2], vertices[(i * 2) + 1], e, ps, g, origTransform);
                        }
                    }
                }
            }
            else
            {
                FastDrawnState[] states = DrawnStates;

                var indexList = indices as IList <int> ?? indices.ToList();
                if (indexList.Max() >= states.Length)
                {
                    AssignFastDrawnStates();
                    states = DrawnStates;
                }

                double[] vertices = DataSet.Vertex;

                foreach (int index in indexList)
                {
                    if (index >= states.Length)
                    {
                        break;
                    }
                    FastDrawnState state = states[index];
                    if (!state.Visible || state.Category == null)
                    {
                        continue;
                    }
                    if (selected && !state.Selected)
                    {
                        continue;
                    }

                    IPointCategory pc = state.Category as IPointCategory;
                    if (pc == null)
                    {
                        continue;
                    }

                    IPointSymbolizer ps = selected ? pc.SelectionSymbolizer : pc.Symbolizer;
                    if (ps == null)
                    {
                        continue;
                    }

                    if (featureType == FeatureType.Point)
                    {
                        DrawPoint(vertices[index * 2], vertices[(index * 2) + 1], e, ps, g, origTransform);
                    }
                    else
                    {
                        ShapeRange range = DataSet.ShapeIndices[index];
                        for (int i = range.StartIndex; i <= range.EndIndex(); i++)
                        {
                            DrawPoint(vertices[i * 2], vertices[(i * 2) + 1], e, ps, g, origTransform);
                        }
                    }
                }
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
            else
            {
                g.Transform = origTransform;
            }
        }
Beispiel #14
0
        /// <summary>
        /// Draws a label on a line with various different methods
        /// </summary>
        public static void DrawLineFeature(MapArgs e, Graphics g, IFeature f, ILabelCategory category, bool selected, List <RectangleF> existingLabels)
        {
            if (f == null)
            {
                return;
            }
            ILabelSymbolizer symb = category.Symbolizer;

            if (selected)
            {
                symb = category.SelectionSymbolizer;
            }

            //Gets the features text and calculate the label size
            string txt = GetLabelText(f, category);

            if (txt == null)
            {
                return;
            }
            Func <SizeF> labelSize = () => g.MeasureString(txt, _caches.GetFont(symb));

            if (f.NumGeometries == 1)
            {
                RectangleF labelBounds = PlaceLineLabel(f.BasicGeometry, labelSize, e, symb);
                CollisionDraw(txt, g, symb, f, e, labelBounds, existingLabels);
            }
            else
            {
                //Depending on the labeling strategy we do diff things
                if (symb.PartsLabelingMethod == PartLabelingMethod.LabelAllParts)
                {
                    for (int n = 0; n < f.NumGeometries; n++)
                    {
                        RectangleF labelBounds = PlaceLineLabel(f.GetBasicGeometryN(n), labelSize, e, symb);
                        CollisionDraw(txt, g, symb, f, e, labelBounds, existingLabels);
                    }
                }
                else
                {
                    double longestLine  = 0;
                    int    longestIndex = 0;
                    for (int n = 0; n < f.NumGeometries; n++)
                    {
                        ILineString ls         = f.GetBasicGeometryN(n) as ILineString;
                        double      tempLength = 0;
                        if (ls != null)
                        {
                            tempLength = ls.Length;
                        }
                        if (longestLine < tempLength)
                        {
                            longestLine  = tempLength;
                            longestIndex = n;
                        }
                    }
                    RectangleF labelBounds = PlaceLineLabel(f.GetBasicGeometryN(longestIndex), labelSize, e, symb);
                    CollisionDraw(txt, g, symb, f, e, labelBounds, existingLabels);
                }
            }
        }
Beispiel #15
0
        // This draws the individual point features
        private void DrawFeatures(MapArgs e, IEnumerable <IFeature> features)
        {
            Graphics g             = e.Device ?? Graphics.FromImage(BackBuffer);
            Matrix   origTransform = g.Transform;
            double   minX          = e.MinX;
            double   maxY          = e.MaxY;
            double   dx            = e.Dx;
            double   dy            = e.Dy;
            IDictionary <IFeature, IDrawnState> states = DrawingFilter.DrawnStates;

            if (states == null)
            {
                return;
            }
            foreach (IPointCategory category in Symbology.Categories)
            {
                foreach (IFeature feature in features)
                {
                    if (states.ContainsKey(feature) == false)
                    {
                        continue;
                    }
                    IDrawnState ds = states[feature];
                    if (ds == null)
                    {
                        continue;
                    }
                    if (!ds.IsVisible)
                    {
                        continue;
                    }
                    if (ds.SchemeCategory == null)
                    {
                        continue;
                    }
                    IPointCategory pc = ds.SchemeCategory as IPointCategory;
                    if (pc == null)
                    {
                        continue;
                    }
                    if (pc != category)
                    {
                        continue;
                    }
                    IPointSymbolizer ps = pc.Symbolizer;
                    if (ds.IsSelected)
                    {
                        ps = pc.SelectionSymbolizer;
                    }
                    if (ps == null)
                    {
                        continue;
                    }
                    g.SmoothingMode = ps.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None;
                    foreach (Coordinate c in feature.Coordinates)
                    {
                        Point pt = new Point
                        {
                            X = Convert.ToInt32((c.X - minX) * dx),
                            Y = Convert.ToInt32((maxY - c.Y) * dy)
                        };
                        double scaleSize = 1;
                        if (ps.ScaleMode == ScaleMode.Geographic)
                        {
                            scaleSize = e.ImageRectangle.Width / e.GeographicExtents.Width;
                        }
                        Matrix shift = origTransform.Clone();
                        shift.Translate(pt.X, pt.Y);
                        g.Transform = shift;
                        ps.Draw(g, scaleSize);
                    }
                }
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
            else
            {
                g.Transform = origTransform;
            }
        }
Beispiel #16
0
        // This draws the individual point features
        private void DrawFeatures(MapArgs e, IEnumerable <int> indices)
        {
            Graphics    g             = e.Device ?? Graphics.FromImage(BackBuffer);
            Matrix      origTransform = g.Transform;
            FeatureType featureType   = DataSet.FeatureType;

            double minX = e.MinX;
            double maxY = e.MaxY;
            double dx   = e.Dx;
            double dy   = e.Dy;

            if (!DrawnStatesNeeded)
            {
                if (Symbology == null || Symbology.Categories.Count == 0)
                {
                    return;
                }
                FastDrawnState   state = new FastDrawnState(false, Symbology.Categories[0]);
                IPointCategory   pc    = state.Category as IPointCategory;
                IPointSymbolizer ps    = null;
                if (pc != null && pc.Symbolizer != null)
                {
                    ps = pc.Symbolizer;
                }
                if (ps == null)
                {
                    return;
                }
                g.SmoothingMode = ps.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None;
                double[] vertices = DataSet.Vertex;
                foreach (int index in indices)
                {
                    if (DrawnStates != null && DrawnStates.Length > index)
                    {
                        if (!DrawnStates[index].Visible)
                        {
                            continue;
                        }
                    }
                    if (featureType == FeatureType.Point)
                    {
                        var pt = new Point
                        {
                            X = Convert.ToInt32((vertices[index * 2] - minX) * dx),
                            Y = Convert.ToInt32((maxY - vertices[index * 2 + 1]) * dy)
                        };
                        double scaleSize = 1;
                        if (ps.ScaleMode == ScaleMode.Geographic)
                        {
                            scaleSize = e.ImageRectangle.Width / e.GeographicExtents.Width;
                        }
                        Matrix shift = origTransform.Clone();
                        shift.Translate(pt.X, pt.Y);
                        g.Transform = shift;
                        ps.Draw(g, scaleSize);
                    }
                    else
                    {
                        // multi-point
                        ShapeRange range = DataSet.ShapeIndices[index];
                        for (int i = range.StartIndex; i <= range.EndIndex(); i++)
                        {
                            var pt = new Point
                            {
                                X = Convert.ToInt32((vertices[i * 2] - minX) * dx),
                                Y = Convert.ToInt32((maxY - vertices[i * 2 + 1]) * dy)
                            };
                            double scaleSize = 1;
                            if (ps.ScaleMode == ScaleMode.Geographic)
                            {
                                scaleSize = e.ImageRectangle.Width / e.GeographicExtents.Width;
                            }
                            Matrix shift = origTransform.Clone();
                            shift.Translate(pt.X, pt.Y);
                            g.Transform = shift;
                            ps.Draw(g, scaleSize);
                        }
                    }
                }
            }
            else
            {
                FastDrawnState[] states   = DrawnStates;
                double[]         vertices = DataSet.Vertex;
                foreach (IPointCategory category in Symbology.Categories)
                {
                    if (category.Symbolizer == null)
                    {
                        continue;
                    }

                    double scaleSize = 1;
                    if (category.Symbolizer.ScaleMode == ScaleMode.Geographic)
                    {
                        scaleSize = e.ImageRectangle.Width / e.GeographicExtents.Width;
                    }
                    Size2D size = category.Symbolizer.GetSize();
                    if (size.Width * scaleSize < 1 || size.Height * scaleSize < 1)
                    {
                        continue;
                    }

                    Bitmap   normalSymbol = new Bitmap((int)(size.Width * scaleSize) + 1, (int)(size.Height * scaleSize) + 1);
                    Graphics bg           = Graphics.FromImage(normalSymbol);
                    bg.SmoothingMode = category.Symbolizer.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None;
                    Matrix trans = bg.Transform;

                    // keenedge:
                    // added ' * scaleSize ' to fix a problme when ploted using ScaleMode=Geographic.   however, it still
                    // appeared to be shifted up and left by 1 pixel so I also added the one pixel shift to the NW.
                    // trans.Translate((float)size.Width / 2, (float)size.Height / 2);
                    trans.Translate(((float)(size.Width * scaleSize) / 2 - 1), (float)(size.Height * scaleSize) / 2 - 1);
                    bg.Transform = trans;
                    category.Symbolizer.Draw(bg, 1);

                    Size2D selSize = category.SelectionSymbolizer.GetSize();
                    if (selSize.Width * scaleSize < 1 || selSize.Height * scaleSize < 1)
                    {
                        continue;
                    }

                    Bitmap   selectedSymbol = new Bitmap((int)(selSize.Width * scaleSize + 1), (int)(selSize.Height * scaleSize + 1));
                    Graphics sg             = Graphics.FromImage(selectedSymbol);
                    sg.SmoothingMode = category.SelectionSymbolizer.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None;
                    Matrix trans2 = sg.Transform;
                    trans2.Translate((float)selSize.Width / 2, (float)selSize.Height / 2);
                    sg.Transform = trans2;
                    category.SelectionSymbolizer.Draw(sg, 1);

                    foreach (int index in indices)
                    {
                        FastDrawnState state = states[index];
                        if (!state.Visible)
                        {
                            continue;
                        }
                        if (state.Category == null)
                        {
                            continue;
                        }
                        IPointCategory pc = state.Category as IPointCategory;
                        if (pc == null)
                        {
                            continue;
                        }
                        if (pc != category)
                        {
                            continue;
                        }
                        Bitmap bmp = normalSymbol;
                        if (state.Selected)
                        {
                            bmp = selectedSymbol;
                        }
                        if (featureType == FeatureType.Point)
                        {
                            var pt = new Point
                            {
                                X = Convert.ToInt32((vertices[index * 2] - minX) * dx),
                                Y = Convert.ToInt32((maxY - vertices[index * 2 + 1]) * dy)
                            };

                            Matrix shift = origTransform.Clone();
                            shift.Translate(pt.X, pt.Y);
                            g.Transform = shift;

                            g.DrawImageUnscaled(bmp, -bmp.Width / 2, -bmp.Height / 2);
                        }
                        else
                        {
                            ShapeRange range = DataSet.ShapeIndices[index];
                            for (int i = range.StartIndex; i <= range.EndIndex(); i++)
                            {
                                var pt = new Point
                                {
                                    X = Convert.ToInt32((vertices[i * 2] - minX) * dx),
                                    Y = Convert.ToInt32((maxY - vertices[i * 2 + 1]) * dy)
                                };

                                Matrix shift = origTransform.Clone();
                                shift.Translate(pt.X, pt.Y);
                                g.Transform = shift;
                                g.DrawImageUnscaled(bmp, -bmp.Width / 2, -bmp.Height / 2);
                            }
                        }
                    }
                }
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
            else
            {
                g.Transform = origTransform;
            }
        }
Beispiel #17
0
        // This draws the individual polygon features
        private void DrawFeatures(MapArgs e, IEnumerable<IFeature> features)
        {
            List<GraphicsPath> paths;
            Stopwatch sw = new Stopwatch();
            sw.Start();
            // First, use the coordinates to build the drawing paths
            BuildPaths(e, features, out paths);
            // Next draw all the paths using the various category symbols.
            DrawPaths(e, paths);
            sw.Stop();
            //Debug.WriteLine("Drawing time: " + sw.ElapsedMilliseconds);

            foreach (GraphicsPath path in paths)
            {
                path.Dispose();
            }
        }
Beispiel #18
0
        /// <summary>
        /// Adds the line string to the path.
        /// </summary>
        /// <param name="path">Path to add the line string to.</param>
        /// <param name="vertices">Vertices of the line string.</param>
        /// <param name="shpx">Shape range of the line string.</param>
        /// <param name="args">The map arguments.</param>
        /// <param name="clipRect">The clip rectangle.</param>
        internal static void BuildLineString(GraphicsPath path, double[] vertices, ShapeRange shpx, MapArgs args, Rectangle clipRect)
        {
            double minX = args.MinX;
            double maxY = args.MaxY;
            double dx   = args.Dx;
            double dy   = args.Dy;

            for (int prt = 0; prt < shpx.Parts.Count; prt++)
            {
                PartRange prtx   = shpx.Parts[prt];
                int       start  = prtx.StartIndex;
                int       end    = prtx.EndIndex;
                var       points = new List <double[]>(end - start + 1);

                for (int i = start; i <= end; i++)
                {
                    var pt = new[] { (vertices[i * 2] - minX) * dx, (maxY - vertices[(i * 2) + 1]) * dy };
                    points.Add(pt);
                }

                AddLineStringToPath(path, args, shpx.Extent, points, clipRect);
            }
        }
Beispiel #19
0
 /// <summary>
 /// This will draw any features that intersect this region.  To specify the features
 /// directly, use OnDrawFeatures.  This will not clear existing buffer content.
 /// For that call Initialize instead.
 /// </summary>
 /// <param name="args">A GeoArgs clarifying the transformation from geographic to image space</param>
 /// <param name="regions">The geographic regions to draw</param>
 public void DrawRegions(MapArgs args, List<Extent> regions)
 {
     List<Rectangle> clipRects = args.ProjToPixel(regions);
     DrawWindows(args, regions, clipRects);
 }
Beispiel #20
0
        // This draws the individual line features
        private void DrawFeatures(MapArgs e, IEnumerable <IFeature> features, bool selected)
        {
            if (selected && !DrawingFilter.DrawnStates.Any(_ => _.Value.IsSelected))
            {
                return;
            }

            Graphics g           = e.Device ?? Graphics.FromImage(BackBuffer);
            var      featureList = features as IList <IFeature> ?? features.ToList();

            Action <GraphicsPath, Rectangle, IEnumerable <IFeature> > drawFeature = (graphPath, clipRect, featList) =>
            {
                foreach (IFeature f in featList)
                {
                    var geo = f.Geometry as LineString;
                    if (geo != null)
                    {
                        BuildLineString(graphPath, geo, e, clipRect);
                    }
                    else
                    {
                        var col = f.Geometry as GeometryCollection;
                        if (col != null)
                        {
                            foreach (var c1 in col.Geometries.OfType <LineString>())
                            {
                                BuildLineString(graphPath, c1, e, clipRect);
                            }
                        }
                    }
                }
            };

            foreach (ILineCategory category in Symbology.Categories)
            {
                // Define the symbology based on the category and selection state
                ILineSymbolizer ls = selected ? category.SelectionSymbolizer : category.Symbolizer;

                // Determine the subset of the specified features that are visible and match the category
                ILineCategory            lineCategory = category;
                Func <IDrawnState, bool> isMember;

                if (selected)
                {
                    // get only selected features
                    isMember = state => state.SchemeCategory == lineCategory && state.IsVisible && state.IsSelected;
                }
                else
                {
                    // get all features
                    isMember = state => state.SchemeCategory == lineCategory && state.IsVisible;
                }

                var drawnFeatures = from feature in featureList where isMember(DrawingFilter[feature]) select feature;
                DrawPath(g, ls, e, drawFeature, drawnFeatures);
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
        }
Beispiel #21
0
        // This draws the individual polygon features
        private void DrawFeatures(MapArgs e, IEnumerable<IFeature> features)
        {
            List<GraphicsPath> paths;
            // First, use the coordinates to build the drawing paths
            BuildPaths(e, features, out paths);

            // Next draw all the paths using the various category symbols.
            DrawPaths(e, paths);

            foreach (var path in paths)
            {
                path.Dispose();
            }
        }
Beispiel #22
0
        internal static void BuildLineString(GraphicsPath path, double[] vertices, ShapeRange shpx, MapArgs args, Rectangle clipRect)
        {
            double minX = args.MinX;
            double maxY = args.MaxY;
            double dx = args.Dx;
            double dy = args.Dy;
            for (int prt = 0; prt < shpx.Parts.Count; prt++)
            {
                PartRange prtx = shpx.Parts[prt];
                int start = prtx.StartIndex;
                int end = prtx.EndIndex;
                List<double[]> points = new List<double[]>();

                for (int i = start; i <= end; i++)
                {
                    double[] pt = new double[2];
                    pt[X] = (vertices[i * 2] - minX) * dx;
                    pt[Y] = (maxY - vertices[i * 2 + 1]) * dy;
                    points.Add(pt);
                }

                List<List<double[]>> multiLinestrings;
                if (!shpx.Extent.Within(args.GeographicExtents))
                {
                    multiLinestrings = CohenSutherland.ClipLinestring(points, clipRect.Left, clipRect.Top,
                                                                      clipRect.Right, clipRect.Bottom);
                }
                else
                {
                    multiLinestrings = new List<List<double[]>>();
                    multiLinestrings.Add(points);
                }

                foreach (List<double[]> linestring in multiLinestrings)
                {
                    List<Point> intPoints = DuplicationPreventer.Clean(linestring);
                    if (intPoints.Count < 2)
                    {
                        points.Clear();
                        continue;
                    }
                    path.StartFigure();
                    Point[] pointArray = intPoints.ToArray();
                    path.AddLines(pointArray);
                }
            }
        }
Beispiel #23
0
        private void BuildPaths(MapArgs e, IEnumerable<IFeature> features, out List<GraphicsPath> borderPaths)
        {
            borderPaths = new List<GraphicsPath>();
            Rectangle clipRect = ComputeClippingRectangle(e);
            Extent drawExtents = e.PixelToProj(clipRect);
            SoutherlandHodgman shClip = new SoutherlandHodgman(clipRect);

            for (int selectState = 0; selectState < 2; selectState++)
            {
                foreach (IPolygonCategory category in Symbology.Categories)
                {
                    // Determine the subset of the specified features that are visible and match the category
                    IPolygonCategory polygonCategory = category;
                    int i = selectState;
                    Func<IDrawnState, bool> isMember = state =>
                                                       state.SchemeCategory == polygonCategory &&
                                                       state.IsVisible &&
                                                       state.IsSelected == (i == 1);

                    var drawnFeatures = from feature in features
                                        where isMember(DrawingFilter[feature])
                                        select feature;

                    GraphicsPath borderPath = new GraphicsPath();
                    foreach (IFeature f in drawnFeatures)
                    {
                        BuildPolygon(DataSet.Vertex, f.ShapeIndex, borderPath, e,
                                     drawExtents.Contains(f.Envelope) ? null : shClip);
                    }
                    borderPaths.Add(borderPath);
                }
            }
        }
        public void DrawRegions(MapArgs args, List<Extent> regions)
        {
            // Assert that the map has the same size as the DotSpatial map
            var size = args.ImageRectangle.Size;
            _map.Size = size;
            
            // Make sure the map is zoomed to the same extent
            var env = Topology.GeometryConverter.ToGeoAPI(args.GeographicExtents);
            _map.ZoomToBox(env);

            // Always render the whole map to the device
            _map.RenderMap(args.Device);

            /*
             * This is not suitable because we might draw to printer/plotter 
             * which will make for a huge Image
             */
            #region
            //using (var mapImage = _map.GetMap())
            //{
            //    foreach (var region in regions)
            //    {
            //        var loc = args.ProjToPixel(region);
            //        args.Device.DrawImage(mapImage, loc, 
            //                              loc.X, loc.Y, loc.Width, loc.Height, 
            //                              GraphicsUnit.Pixel);
            //    }
            //}
            #endregion
        }
Beispiel #25
0
 /// <summary>
 /// This will draw any features that intersect this region.  To specify the features
 /// directly, use OnDrawFeatures.  This will not clear existing buffer content.
 /// For that call Initialize instead.
 /// </summary>
 /// <param name="args">A GeoArgs clarifying the transformation from geographic to image space</param>
 /// <param name="regions">The geographic regions to draw</param>
 public virtual void DrawRegions(MapArgs args, List<Extent> regions)
 {
     // First determine the number of features we are talking about based on region.
     List<Rectangle> clipRects = args.ProjToPixel(regions);
     if (EditMode)
     {
         List<IFeature> drawList = new List<IFeature>();
         foreach (Extent region in regions)
         {
             if (region != null)
             {
                 // Use union to prevent duplicates.  No sense in drawing more than we have to.
                 drawList = drawList.Union(DataSet.Select(region)).ToList();
             }
         }
         DrawFeatures(args, drawList, clipRects, true);
     }
     else
     {
         List<int> drawList = new List<int>();
         List<ShapeRange> shapes = DataSet.ShapeIndices;
         for (int shp = 0; shp < shapes.Count; shp++)
         {
             foreach (Extent region in regions)
             {
                 if (!shapes[shp].Extent.Intersects(region)) continue;
                 drawList.Add(shp);
                 break;
             }
         }
         DrawFeatures(args, drawList, clipRects, true);
     }
 }
Beispiel #26
0
        // This draws the individual line features
        private void DrawFeatures(MapArgs e, IEnumerable <IFeature> features)
        {
            Graphics g = e.Device ?? Graphics.FromImage(_backBuffer);

            // Only draw features that are currently visible.

            if (DrawnStates == null || !DrawnStates.ContainsKey(features.First()))
            {
                CreateLabels();
            }
            Dictionary <IFeature, LabelDrawState> drawStates = DrawnStates;

            if (drawStates == null)
            {
                return;
            }
            //Sets the graphics objects smoothing modes
            g.TextRenderingHint = TextRenderingHint.AntiAlias;
            g.SmoothingMode     = SmoothingMode.AntiAlias;
            FeatureType type = features.First().FeatureType;

            foreach (ILabelCategory category in Symbology.Categories)
            {
                var cat = category; // prevent access to unmodified closure problems
                //List<IFeature> catFeatures = (from feature in features
                //                              where drawStates.ContainsKey(feature) && drawStates[feature].Category == cat
                //                             select feature).ToList();
                List <IFeature> catFeatures = new List <IFeature>();
                foreach (IFeature f in features)
                {
                    if (drawStates.ContainsKey(f))
                    {
                        if (drawStates[f].Category == cat)
                        {
                            catFeatures.Add(f);
                        }
                    }
                }
                // Now that we are restricted to a certain category, we can look at
                // priority
                if (category.Symbolizer.PriorityField != "FID")
                {
                    Feature.ComparisonField = cat.Symbolizer.PriorityField;
                    catFeatures.Sort();
                    // When preventing collisions, we want to do high priority first.
                    // otherwise, do high priority last.
                    if (cat.Symbolizer.PreventCollisions)
                    {
                        if (!cat.Symbolizer.PrioritizeLowValues)
                        {
                            catFeatures.Reverse();
                        }
                    }
                    else
                    {
                        if (cat.Symbolizer.PrioritizeLowValues)
                        {
                            catFeatures.Reverse();
                        }
                    }
                }
                foreach (IFeature feature in catFeatures)
                {
                    switch (type)
                    {
                    case FeatureType.Polygon:
                        DrawPolygonFeature(e, g, feature, drawStates[feature].Category, drawStates[feature].Selected, ExistingLabels);
                        break;

                    case FeatureType.Line:
                        DrawLineFeature(e, g, feature, drawStates[feature].Category, drawStates[feature].Selected, ExistingLabels);
                        break;

                    case FeatureType.Point:
                        DrawPointFeature(e, g, feature, drawStates[feature].Category, drawStates[feature].Selected, ExistingLabels);
                        break;
                    }
                }
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
        }
Beispiel #27
0
        // This draws the individual line features
        private void DrawFeatures(MapArgs e, IEnumerable<IFeature> features)
        {
            Graphics g = e.Device ?? Graphics.FromImage(_backBuffer);

            for (int selectState = 0; selectState < 2; selectState++)
            {
                foreach (ILineCategory category in Symbology.Categories)
                {
                    // Define the symbology based on the category and selection state
                    ILineSymbolizer ls = category.Symbolizer;
                    if (selectState == SELECTED) ls = category.SelectionSymbolizer;
                    if (ls.Smoothing)
                    {
                        g.SmoothingMode = SmoothingMode.AntiAlias;
                    }
                    else
                    {
                        g.SmoothingMode = SmoothingMode.None;
                    }

                    Rectangle clipRect = ComputeClippingRectangle(e, ls);

                    // Determine the subset of the specified features that are visible and match the category
                    ILineCategory lineCategory = category;
                    int i = selectState;
                    Func<IDrawnState, bool> isMember = state =>
                                                       state.SchemeCategory == lineCategory &&
                                                       state.IsVisible &&
                                                       state.IsSelected == (i == 1);

                    var drawnFeatures = from feature in features
                                        where isMember(DrawingFilter[feature])
                                        select feature;

                    GraphicsPath graphPath = new GraphicsPath();
                    foreach (IFeature f in drawnFeatures)
                    {
                        BuildLineString(graphPath, DataSet.Vertex, f.ShapeIndex, e, clipRect);
                    }
                    double scale = 1;
                    if (ls.ScaleMode == ScaleMode.Geographic)
                    {
                        scale = e.ImageRectangle.Width / e.GeographicExtents.Width;
                    }

                    foreach (IStroke stroke in ls.Strokes)
                    {
                        stroke.DrawPath(g, graphPath, scale);
                    }

                    graphPath.Dispose();
                }
            }
            if (e.Device == null) g.Dispose();
        }
Beispiel #28
0
        /// <summary>
        /// This draws to the back buffer.  If the Backbuffer doesn't exist, this will create one.
        /// This will not flip the back buffer to the front.
        /// </summary>
        /// <param name="args"></param>
        /// <param name="regions"></param>
        /// <param name="clipRectangles"></param>
        private void DrawWindows(MapArgs args, IList <Extent> regions, IList <Rectangle> clipRectangles)
        {
            Graphics g;

            if (args.Device != null)
            {
                g = args.Device; // A device on the MapArgs is optional, but overrides the normal buffering behaviors.
            }
            else
            {
                if (_backBuffer == null)
                {
                    _backBuffer = new Bitmap(_bufferRectangle.Width, _bufferRectangle.Height);
                }
                g = Graphics.FromImage(_backBuffer);
            }
            int numBounds = Math.Min(regions.Count, clipRectangles.Count);

            for (int i = 0; i < numBounds; i++)
            {
                // For panning tiles, the region needs to be expanded.
                // This is not always 1 pixel.  When very zoomed in, this could be many pixels,
                // but should correspond to 1 pixel in the source image.

                int       dx = (int)Math.Ceiling(DataSet.Bounds.AffineCoefficients[1] * clipRectangles[i].Width / regions[i].Width);
                Rectangle r  = RectangleExt.ExpandBy(clipRectangles[i], dx * 2);
                if (r.X < 0)
                {
                    r.X = 0;
                }
                if (r.Y < 0)
                {
                    r.Y = 0;
                }
                if (r.Width > 2 * clipRectangles[i].Width)
                {
                    r.Width = 2 * clipRectangles[i].Width;
                }
                if (r.Height > 2 * clipRectangles[i].Height)
                {
                    r.Height = 2 * clipRectangles[i].Height;
                }
                Extent env = regions[i].Reproportion(clipRectangles[i], r);
                Bitmap bmp;
                try
                {
                    bmp = DataSet.GetBitmap(env, r);
                }
                catch
                {
                    continue;
                }
                if (bmp == null)
                {
                    continue;
                }
                g.DrawImage(bmp, r);
                bmp.Dispose();
            }
            if (args.Device == null)
            {
                g.Dispose();
            }
        }
Beispiel #29
0
        /// <summary>
        /// This draws to the back buffer.  If the Backbuffer doesn't exist, this will create one.
        /// This will not flip the back buffer to the front.
        /// </summary>
        /// <param name="args"></param>
        /// <param name="regions"></param>
        /// <param name="clipRectangles"></param>
        private void DrawWindows(MapArgs args, IList<Extent> regions, IList<Rectangle> clipRectangles)
        {
            Graphics g;
            if (args.Device != null)
            {
                g = args.Device; // A device on the MapArgs is optional, but overrides the normal buffering behaviors.
            }
            else
            {
                if (_backBuffer == null) _backBuffer = new Bitmap(_bufferRectangle.Width, _bufferRectangle.Height);
                g = Graphics.FromImage(_backBuffer);
            }
            int numBounds = Math.Min(regions.Count, clipRectangles.Count);

            for (int i = 0; i < numBounds; i++)
            {
                // For panning tiles, the region needs to be expanded.
                // This is not always 1 pixel.  When very zoomed in, this could be many pixels,
                // but should correspond to 1 pixel in the source image.

                int dx = (int)Math.Ceiling(DataSet.Bounds.AffineCoefficients[1] * clipRectangles[i].Width / regions[i].Width);
                Rectangle r = RectangleExt.ExpandBy(clipRectangles[i], dx * 2);
                if (r.X < 0) r.X = 0;
                if (r.Y < 0) r.Y = 0;
                if (r.Width > 2 * clipRectangles[i].Width) r.Width = 2 * clipRectangles[i].Width;
                if (r.Height > 2 * clipRectangles[i].Height) r.Height = 2 * clipRectangles[i].Height;
                Extent env = regions[i].Reproportion(clipRectangles[i], r);
                Bitmap bmp;
                try
                {
                    bmp = DataSet.GetBitmap(env, r);
                }
                catch
                {
                    continue;
                }
                if (bmp == null) continue;
                g.DrawImage(bmp, r);
                bmp.Dispose();
            }
            if (args.Device == null) g.Dispose();
        }
Beispiel #30
0
 /// <inheritdoc/>
 public virtual void Print(MapArgs args, List <Extent> regions, bool selected)
 {
     DrawRegions(args, regions, selected);
 }
Beispiel #31
0
        /// <summary>
        /// This draws to the back buffer. If the Backbuffer doesn't exist, this will create one.
        /// This will not flip the back buffer to the front.
        /// </summary>
        /// <param name="args"></param>
        /// <param name="regions"></param>
        /// <param name="clipRectangles"></param>
        private void DrawWindows(MapArgs args, IList <Extent> regions, IList <Rectangle> clipRectangles)
        {
            Graphics g;

            if (args.Device != null)
            {
                g = args.Device; // A device on the MapArgs is optional, but overrides the normal buffering behaviors.
            }
            else
            {
                if (BackBuffer == null)
                {
                    BackBuffer = new Bitmap(BufferRectangle.Width, BufferRectangle.Height);
                }
                g = Graphics.FromImage(BackBuffer);
            }
            int numBounds = Math.Min(regions.Count, clipRectangles.Count);

            for (int i = 0; i < numBounds; i++)
            {
                // For panning tiles, the region needs to be expanded.
                // This is not always 1 pixel.  When very zoomed in, this could be many pixels,
                // but should correspond to 1 pixel in the source image.

                int       dx = (int)Math.Ceiling(DataSet.Bounds.AffineCoefficients[1] * clipRectangles[i].Width / regions[i].Width);
                Rectangle r  = clipRectangles[i].ExpandBy(dx * 2);
                if (r.X < 0)
                {
                    r.X = 0;
                }
                if (r.Y < 0)
                {
                    r.Y = 0;
                }
                if (r.Width > 2 * clipRectangles[i].Width)
                {
                    r.Width = 2 * clipRectangles[i].Width;
                }
                if (r.Height > 2 * clipRectangles[i].Height)
                {
                    r.Height = 2 * clipRectangles[i].Height;
                }
                Extent env = regions[i].Reproportion(clipRectangles[i], r);
                Bitmap bmp = null;
                try
                {
                    bmp = DataSet.GetBitmap(env, r);
                    if (!_transparent.Name.Equals("0"))
                    {
                        bmp.MakeTransparent(_transparent);
                    }
                }
                catch
                {
                    if (bmp != null)
                    {
                        bmp.Dispose();
                    }
                    continue;
                }
                if (bmp == null)
                {
                    continue;
                }

                if (this.Symbolizer != null && this.Symbolizer.Opacity < 1)
                {
                    ColorMatrix matrix = new ColorMatrix(); //draws the image not completely opaque
                    matrix.Matrix33 = Symbolizer.Opacity;
                    ImageAttributes attributes = new ImageAttributes();
                    attributes.SetColorMatrix(matrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
                    g.DrawImage(bmp, r, 0, 0, bmp.Width, bmp.Height, GraphicsUnit.Pixel, attributes);
                    attributes.Dispose();
                }
                else
                {
                    g.DrawImage(bmp, r);
                }
                bmp.Dispose();
            }
            if (args.Device == null)
            {
                g.Dispose();
            }
        }
        /// <summary>
        /// Draws the GraphicsPaths.  Before we were effectively "re-creating" the same geometric
        /// </summary>
        /// <param name="e"></param>
        /// <param name="paths"></param>
        private void DrawPaths(MapArgs e, IList <GraphicsPath> paths)
        {
            Graphics g             = e.Device ?? Graphics.FromImage(BackBuffer);
            int      numCategories = Symbology.Categories.Count;

            if (!DrawnStatesNeeded && !EditMode)
            {
                IPolygonSymbolizer ps = Symbolizer;

                g.SmoothingMode = ps.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None;
                Extent catBounds = DataSet.Extent;
                var    bounds    = new RectangleF
                {
                    X = Convert.ToSingle((catBounds.MinX - e.MinX) * e.Dx),
                    Y = Convert.ToSingle((e.MaxY - catBounds.MaxY) * e.Dy)
                };
                float r = Convert.ToSingle((catBounds.MaxX - e.MinX) * e.Dx);
                bounds.Width = r - bounds.X;
                float b = Convert.ToSingle((e.MaxY - catBounds.MinY) * e.Dy);
                bounds.Height = b - bounds.Y;

                foreach (IPattern pattern in ps.Patterns)
                {
                    IGradientPattern gp = pattern as IGradientPattern;
                    if (gp != null)
                    {
                        gp.Bounds = bounds;
                    }

                    pattern.FillPath(g, paths[0]);
                }

                double scale = 1;
                if (ps.ScaleMode == ScaleMode.Geographic)
                {
                    scale = e.ImageRectangle.Width / e.GeographicExtents.Width;
                }
                foreach (IPattern pattern in ps.Patterns)
                {
                    if (pattern.UseOutline)
                    {
                        pattern.DrawPath(g, paths[0], scale);
                    }
                }
            }
            else
            {
                for (int selectState = 0; selectState < 2; selectState++)
                {
                    int iCategory = 0;
                    foreach (IPolygonCategory category in Symbology.Categories)
                    {
                        Extent catBounds;
                        catBounds = CategoryExtents.Keys.Contains(category) ? CategoryExtents[category] : CalculateCategoryExtent(category);
                        if (catBounds == null)
                        {
                            catBounds = Extent;
                        }
                        var bounds = new RectangleF
                        {
                            X = Convert.ToSingle((catBounds.MinX - e.MinX) * e.Dx),
                            Y = Convert.ToSingle((e.MaxY - catBounds.MaxY) * e.Dy)
                        };
                        float r = Convert.ToSingle((catBounds.MaxX - e.MinX) * e.Dx);
                        bounds.Width = r - bounds.X;
                        float b = Convert.ToSingle((e.MaxY - catBounds.MinY) * e.Dy);
                        bounds.Height = b - bounds.Y;

                        int index = selectState * numCategories + iCategory;
                        // Define the symbology based on the category and selection state
                        IPolygonSymbolizer ps = category.Symbolizer;
                        if (selectState == SELECTED)
                        {
                            ps = category.SelectionSymbolizer;
                        }

                        g.SmoothingMode = ps.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None;

                        foreach (IPattern pattern in ps.Patterns)
                        {
                            IGradientPattern gp = pattern as IGradientPattern;
                            if (gp != null)
                            {
                                gp.Bounds = bounds;
                            }
                            if (paths[index] != null)
                            {
                                paths[index].FillMode = FillMode.Winding;
                                pattern.FillPath(g, paths[index]);
                            }
                        }

                        double scale = 1;
                        if (ps.ScaleMode == ScaleMode.Geographic)
                        {
                            scale = e.ImageRectangle.Width / e.GeographicExtents.Width;
                        }
                        foreach (IPattern pattern in ps.Patterns)
                        {
                            if (pattern.UseOutline)
                            {
                                pattern.DrawPath(g, paths[index], scale);
                            }
                        }
                        iCategory++;
                    } // category
                }     // selectState
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
        }
Beispiel #33
0
        /// <summary>
        /// This will draw any features that intersect this region.  To specify the features
        /// directly, use OnDrawFeatures.  This will not clear existing buffer content.
        /// For that call Initialize instead.
        /// </summary>
        /// <param name="args">A GeoArgs clarifying the transformation from geographic to image space</param>
        /// <param name="regions">The geographic regions to draw</param>
        public virtual void DrawRegions(MapArgs args, List<Extent> regions)
        {
            // First determine the number of features we are talking about based on region.
            var clipRects = args.ProjToPixel(regions);

            var drawList = new List<int>();
            for (var shp = 0; shp < DataSet.Count; shp++)
            {
                var pointExtent = DataSet.GetFeatureExtent(shp);
                if (regions.Any(pointExtent.Intersects))
                {
                    drawList.Add(shp);
                }
            }
            DrawFeatures(args, drawList, clipRects, true);
        }
        private void BuildPaths(MapArgs e, IEnumerable <int> indices, out List <GraphicsPath> paths)
        {
            paths = new List <GraphicsPath>();
            Extent             drawExtents = e.GeographicExtents;
            Rectangle          clipRect    = e.ProjToPixel(e.GeographicExtents);
            SoutherlandHodgman shClip      = new SoutherlandHodgman(clipRect);

            List <GraphicsPath> graphPaths = new List <GraphicsPath>();
            Dictionary <FastDrawnState, GraphicsPath> borders = new Dictionary <FastDrawnState, GraphicsPath>();

            for (int selectState = 0; selectState < 2; selectState++)
            {
                foreach (IPolygonCategory category in Symbology.Categories)
                {
                    FastDrawnState state = new FastDrawnState(selectState == 1, category);

                    GraphicsPath border = new GraphicsPath();
                    borders.Add(state, border);
                    graphPaths.Add(border);
                }
            }

            paths.AddRange(graphPaths);

            List <ShapeRange> shapes = DataSet.ShapeIndices;

            double[] vertices = DataSet.Vertex;

            if (ProgressReportingEnabled)
            {
                ProgressMeter = new ProgressMeter(ProgressHandler, "Building Paths", indices.Count());
            }

            if (!DrawnStatesNeeded)
            {
                FastDrawnState state = new FastDrawnState(false, Symbology.Categories[0]);

                foreach (int shp in indices)
                {
                    if (ProgressReportingEnabled)
                    {
                        ProgressMeter.Next();
                    }
                    ShapeRange shape = shapes[shp];
                    if (!shape.Extent.Intersects(e.GeographicExtents))
                    {
                        return;
                    }
                    if (shp >= shapes.Count)
                    {
                        return;
                    }
                    if (!borders.ContainsKey(state))
                    {
                        return;
                    }

                    BuildPolygon(vertices, shapes[shp], borders[state], e, drawExtents.Contains(shape.Extent) ? null : shClip);
                }
            }
            else
            {
                FastDrawnState[] states = DrawnStates;
                foreach (GraphicsPath borderPath in borders.Values)
                {
                    if (borderPath != null)
                    {
                        borderPath.FillMode = FillMode.Winding;
                    }
                }

                foreach (int shp in indices)
                {
                    if (ProgressReportingEnabled)
                    {
                        ProgressMeter.Next();
                    }
                    if (shp >= shapes.Count)
                    {
                        return;
                    }
                    if (shp >= states.Length)
                    {
                        AssignFastDrawnStates();
                        states = DrawnStates;
                    }
                    if (states[shp].Visible == false)
                    {
                        continue;
                    }
                    ShapeRange shape = shapes[shp];
                    if (!shape.Extent.Intersects(e.GeographicExtents))
                    {
                        continue;
                    }
                    if (drawExtents.Contains(shape.Extent))
                    {
                        FastDrawnState state = states[shp];
                        if (!borders.ContainsKey(state))
                        {
                            continue;
                        }
                        BuildPolygon(vertices, shapes[shp], borders[state], e, null);
                    }
                    else
                    {
                        FastDrawnState state = states[shp];
                        if (!borders.ContainsKey(state))
                        {
                            continue;
                        }
                        BuildPolygon(vertices, shapes[shp], borders[state], e, shClip);
                    }
                }
            }
            if (ProgressReportingEnabled)
            {
                ProgressMeter.Reset();
            }
        }
Beispiel #35
0
        private void DrawFeatures(MapArgs e, List<int> indices)
        {
            var g = e.Device ?? Graphics.FromImage(BackBuffer);
            var origTransform = g.Transform;

            var minX = e.MinX;
            var maxY = e.MaxY;
            var dx = e.Dx;
            var dy = e.Dy;

            var states = DrawnStates;
            foreach (var category in Symbology.Categories)
            {
                var normalSymbol = GetSymbolizerBitmap(category.Symbolizer, e);
                var selectedSymbol = GetSymbolizerBitmap(category.SelectionSymbolizer, e);
                foreach (var index in indices)
                {
                    var state = states[index];
                    if (!state.Visible) continue;
                    var pc = state.Category as IPointCategory;
                    if (pc == null) continue;
                    if (pc != category) continue;

                    var bmp = state.Selected? selectedSymbol : normalSymbol;
                    if (bmp == null) continue;
                    var shape = DataSet.GetShape(index, false);
                    foreach (var part in shape.Range.Parts)
                    {
                        foreach (var vertex in part)
                        {
                            var pt = new Point
                            {
                                X = Convert.ToInt32((vertex.X - minX)*dx),
                                Y = Convert.ToInt32((maxY - vertex.Y)*dy)
                            };

                            var shift = origTransform.Clone();
                            shift.Translate(pt.X, pt.Y);
                            g.Transform = shift;

                            g.DrawImageUnscaled(bmp, -bmp.Width/2, -bmp.Height/2);
                        }
                    }
                }
            }


            if (e.Device == null) g.Dispose();
            else g.Transform = origTransform;
        }
Beispiel #36
0
 /// <summary>
 /// Initializes a new instance of the <see cref="MapDrawArgs"/> class.
 /// </summary>
 /// <param name="inGraphics">The graphics object used for drawing.</param>
 /// <param name="clipRectangle">The clip rectangle.</param>
 /// <param name="inGeoGraphics">The map args.</param>
 public MapDrawArgs(Graphics inGraphics, Rectangle clipRectangle, MapArgs inGeoGraphics)
 {
     _graphics      = inGraphics;
     _clipRectangle = clipRectangle;
     _geoGraphics   = inGeoGraphics;
 }
Beispiel #37
0
        /// <summary>
        /// Appends the specified polygon to the graphics path.
        /// </summary>
        private static void BuildPolygon(double[] vertices, ShapeRange shpx, GraphicsPath borderPath, MapArgs args, SoutherlandHodgman shClip)
        {
            double minX = args.MinX;
            double maxY = args.MaxY;
            double dx = args.Dx;
            double dy = args.Dy;

            for (int prt = 0; prt < shpx.Parts.Count; prt++)
            {
                PartRange prtx = shpx.Parts[prt];
                int start = prtx.StartIndex;
                int end = prtx.EndIndex;
                List<double[]> points = new List<double[]>();

                for (int i = start; i <= end; i++)
                {
                    double[] pt = new double[2];
                    pt[X] = (vertices[i * 2] - minX) * dx;
                    pt[Y] = (maxY - vertices[i * 2 + 1]) * dy;
                    points.Add(pt);
                }
                if (null != shClip)
                {
                    points = shClip.Clip(points);
                }
                List<Point> intPoints = DuplicationPreventer.Clean(points);
                if (intPoints.Count < 2)
                {
                    points.Clear();
                    continue;
                }

                //Would be nice to figure out how to get rid of this lock
                lock (lock1)
                {
                    borderPath.StartFigure();
                    Point[] pointArray = intPoints.ToArray();
                    borderPath.AddLines(pointArray);
                }
                points.Clear();
            }
        }
Beispiel #38
0
        // This draws the individual point features
        private void DrawFeatures(MapArgs e, IEnumerable <int> indices)
        {
            Graphics    g             = e.Device ?? Graphics.FromImage(BackBuffer);
            Matrix      origTransform = g.Transform;
            FeatureType featureType   = DataSet.FeatureType;

            if (!DrawnStatesNeeded)
            {
                if (Symbology == null || Symbology.Categories.Count == 0)
                {
                    return;
                }
                FastDrawnState state = new FastDrawnState(false, Symbology.Categories[0]);
                IPointCategory pc    = state.Category as IPointCategory;
                if (pc == null)
                {
                    return;
                }
                IPointSymbolizer ps = pc.Symbolizer;
                if (ps == null)
                {
                    return;
                }
                double[] vertices = DataSet.Vertex;

                foreach (int index in indices)
                {
                    if (DrawnStates != null && DrawnStates.Length > index && !DrawnStates[index].Visible)
                    {
                        continue;
                    }
                    if (featureType == FeatureType.Point)
                    {
                        DrawPoint(vertices[index * 2], vertices[index * 2 + 1], e, ps, g, origTransform);
                    }
                    else
                    {
                        // multi-point
                        ShapeRange range = DataSet.ShapeIndices[index];
                        for (int i = range.StartIndex; i <= range.EndIndex(); i++)
                        {
                            DrawPoint(vertices[i * 2], vertices[i * 2 + 1], e, ps, g, origTransform);
                        }
                    }
                }
            }
            else
            {
                FastDrawnState[] states   = DrawnStates;
                double[]         vertices = DataSet.Vertex;

                foreach (int index in indices)
                {
                    if (index >= states.Length)
                    {
                        break;
                    }
                    FastDrawnState state = states[index];
                    if (!state.Visible || state.Category == null)
                    {
                        continue;
                    }
                    IPointCategory pc = state.Category as IPointCategory;
                    if (pc == null)
                    {
                        continue;
                    }

                    IPointSymbolizer ps = state.Selected ? pc.SelectionSymbolizer : pc.Symbolizer;
                    if (ps == null)
                    {
                        continue;
                    }

                    if (featureType == FeatureType.Point)
                    {
                        DrawPoint(vertices[index * 2], vertices[index * 2 + 1], e, ps, g, origTransform);
                    }
                    else
                    {
                        ShapeRange range = DataSet.ShapeIndices[index];
                        for (int i = range.StartIndex; i <= range.EndIndex(); i++)
                        {
                            DrawPoint(vertices[i * 2], vertices[i * 2 + 1], e, ps, g, origTransform);
                        }
                    }
                }
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
            else
            {
                g.Transform = origTransform;
            }
        }
Beispiel #39
0
        /// <summary>
        /// This draws to the back buffer.  If the back buffer doesn't exist, this will create one.
        /// This will not flip the back buffer to the front.
        /// </summary>
        /// <param name="args"></param>
        /// <param name="regions"></param>
        /// <param name="clipRectangles"></param>
        private void DrawWindows(MapArgs args, IList<Extent> regions, IList<Rectangle> clipRectangles)
        {
            Graphics g;
            if (args.Device != null)
            {
                g = args.Device; // A device on the MapArgs is optional, but overrides the normal buffering behaviors.
            }
            else
            {
                if (_backBuffer == null) _backBuffer = new Bitmap(_bufferRectangle.Width, _bufferRectangle.Height);
                g = Graphics.FromImage(_backBuffer);
            }

            int numBounds = Math.Min(regions.Count, clipRectangles.Count);

            for (int i = 0; i < numBounds; i++)
            {
                using (Bitmap bmp = BitmapGetter.GetBitmap(regions[i], clipRectangles[i]))
                {
                    if (bmp != null) g.DrawImage(bmp, clipRectangles[i]);
                }
            }
            if (args.Device == null) g.Dispose();
        }
Beispiel #40
0
        /// <summary>
        /// Adds the line string to the path.
        /// </summary>
        /// <param name="path">Path to add the line string to.</param>
        /// <param name="vertices">Vertices of the line string.</param>
        /// <param name="shpx">Shape range of the line string.</param>
        /// <param name="args">The map arguments.</param>
        /// <param name="clipRect">The clip rectangle.</param>
        internal static void BuildLineString(GraphicsPath path, double[] vertices, ShapeRange shpx, MapArgs args, Rectangle clipRect)
        {
            double minX = args.MinX;
            double maxY = args.MaxY;
            double dx   = args.Dx;
            double dy   = args.Dy;

            for (int prt = 0; prt < shpx.Parts.Count; prt++)
            {
                PartRange prtx   = shpx.Parts[prt];
                int       start  = prtx.StartIndex;
                int       end    = prtx.EndIndex;
                var       points = new List <double[]>(end - start + 1);

                for (int i = start; i <= end; i++)
                {
                    var pt = new[] { (vertices[i * 2] - minX) * dx, (maxY - vertices[(i * 2) + 1]) * dy };
                    points.Add(pt);
                }

                List <List <double[]> > multiLinestrings;
                if (!shpx.Extent.Within(args.GeographicExtents))
                {
                    multiLinestrings = CohenSutherland.ClipLinestring(points, clipRect.Left, clipRect.Top, clipRect.Right, clipRect.Bottom);
                }
                else
                {
                    multiLinestrings = new List <List <double[]> >
                    {
                        points
                    };
                }

                foreach (List <double[]> linestring in multiLinestrings)
                {
                    var intPoints = DuplicationPreventer.Clean(linestring).ToArray();
                    if (intPoints.Length < 2)
                    {
                        continue;
                    }

                    path.StartFigure();
                    path.AddLines(intPoints);
                }
            }
        }
Beispiel #41
0
 /// <summary>
 /// This will draw any features that intersect this region.  To specify the features
 /// directly, use OnDrawFeatures.  This will not clear existing buffer content.
 /// For that call Initialize instead.
 /// </summary>
 /// <param name="args">A GeoArgs clarifying the transformation from geographic to image space</param>
 /// <param name="regions">The geographic regions to draw</param>
 public virtual void DrawRegions(MapArgs args, List<Extent> regions)
 {
     List<Rectangle> clipRects = args.ProjToPixel(regions);
     if (EditMode)
     {
         List<IFeature> drawList = new List<IFeature>();
         drawList = regions.Where(region => region != null).Aggregate(drawList, (current, region) => current.Union(DataSet.Select(region)).ToList());
         DrawFeatures(args, drawList, clipRects, true);
     }
     else
     {
         List<int> drawList = new List<int>();
         List<ShapeRange> shapes = DataSet.ShapeIndices;
         for (int shp = 0; shp < shapes.Count; shp++)
         {
             foreach (Extent region in regions)
             {
                 if (!shapes[shp].Extent.Intersects(region)) continue;
                 drawList.Add(shp);
                 break;
             }
         }
         DrawFeatures(args, drawList, clipRects, true);
     }
 }
Beispiel #42
0
        private void DrawFeatures(MapArgs e, IEnumerable <int> indices)
        {
            Graphics g = e.Device ?? Graphics.FromImage(BackBuffer);

            if (DrawnStatesNeeded)
            {
                FastDrawnState[] states = DrawnStates;
                var indiceList          = indices as IList <int> ?? indices.ToList();
                int max = indiceList.Max();
                if (max >= states.Length)
                {
                    AssignFastDrawnStates();
                    states = DrawnStates;
                }

                for (int selectState = 0; selectState < 2; selectState++)
                {
                    foreach (ILineCategory category in Symbology.Categories)
                    {
                        // Define the symbology based on the category and selection state
                        ILineSymbolizer ls = category.Symbolizer;
                        if (selectState == Selected)
                        {
                            ls = category.SelectionSymbolizer;
                        }
                        g.SmoothingMode = ls.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None;

                        // Compute a clipping rectangle that accounts for symbology
                        Rectangle clipRect = ComputeClippingRectangle(e, ls);

                        // Determine the subset of the specified features that are visible and match the category
                        ILineCategory lineCategory = category;
                        int           i            = selectState;

                        List <int> drawnFeatures = new List <int>();

                        foreach (int index in indiceList)
                        {
                            if (index >= states.Length)
                            {
                                break;
                            }
                            FastDrawnState state = states[index];
                            if (state.Category == lineCategory && state.Selected == (i == 1) && state.Visible)
                            {
                                drawnFeatures.Add(index);
                            }
                        }

                        GraphicsPath graphPath = new GraphicsPath();
                        foreach (int shp in drawnFeatures)
                        {
                            ShapeRange shape = DataSet.ShapeIndices[shp];
                            BuildLineString(graphPath, DataSet.Vertex, shape, e, clipRect);
                        }

                        double scale = 1;
                        if (ls.ScaleMode == ScaleMode.Geographic)
                        {
                            scale = e.ImageRectangle.Width / e.GeographicExtents.Width;
                        }

                        foreach (IStroke stroke in ls.Strokes)
                        {
                            stroke.DrawPath(g, graphPath, scale);
                        }

                        graphPath.Dispose();
                    }
                }
            }
            else
            {
                // Selection state is disabled
                // Category is only the very first category
                ILineCategory   category = Symbology.Categories[0];
                ILineSymbolizer ls       = category.Symbolizer;

                g.SmoothingMode = ls.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None;

                Rectangle clipRect = ComputeClippingRectangle(e, ls);

                // Determine the subset of the specified features that are visible and match the category
                GraphicsPath graphPath = new GraphicsPath();
                foreach (int shp in indices)
                {
                    ShapeRange shape = DataSet.ShapeIndices[shp];
                    BuildLineString(graphPath, DataSet.Vertex, shape, e, clipRect);
                }

                double scale = 1;
                if (ls.ScaleMode == ScaleMode.Geographic)
                {
                    scale = e.ImageRectangle.Width / e.GeographicExtents.Width;
                }

                foreach (IStroke stroke in ls.Strokes)
                {
                    stroke.DrawPath(g, graphPath, scale);
                }

                graphPath.Dispose();
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
        }
Beispiel #43
0
        // This draws the individual line features
        private void DrawFeatures(MapArgs e, IEnumerable<int> indices)
        {
            if (DataSet.ShapeIndices == null) return;
            List<GraphicsPath> paths;

            // First, use the coordinates to build the drawing paths
            BuildPaths(e, indices, out paths);

            // Next draw all the paths using the various category symbols.
            DrawPaths(e, paths);

            foreach (var path in paths)
            {
                path.Dispose();
            }
        }
Beispiel #44
0
        /// <summary>
        /// Places the label according to the selected LabelPlacementMethode.
        /// </summary>
        /// <param name="lineString">LineString, whose label gets drawn.</param>
        /// <param name="labelSize">Function that calculates the size of the label.</param>
        /// <param name="e"></param>
        /// <param name="symb">Symbolizer to figure out the look of the label.</param>
        /// <param name="angle">Angle in degree the label gets rotated by.</param>
        /// <returns>The RectangleF that is needed to draw the label.</returns>
        private static RectangleF PlaceLineLabel(IGeometry lineString, Func <SizeF> labelSize, MapArgs e, ILabelSymbolizer symb, float angle)
        {
            LineString ls = lineString as LineString;

            if (ls == null)
            {
                return(Rectangle.Empty);
            }

            ls = GetSegment(ls, symb);
            if (ls == null)
            {
                return(Rectangle.Empty);
            }

            return(PlaceLabel(ls.Centroid.Coordinate, e, labelSize, symb, angle));
        }
Beispiel #45
0
        private void BuildPaths(MapArgs e, IEnumerable<int> indices, out List<GraphicsPath> paths)
        {
            paths = new List<GraphicsPath>();
            Extent drawExtents = e.GeographicExtents;
            Rectangle clipRect = e.ProjToPixel(e.GeographicExtents);
            SoutherlandHodgman shClip = new SoutherlandHodgman(clipRect);

            List<GraphicsPath> graphPaths = new List<GraphicsPath>();
            Dictionary<FastDrawnState, GraphicsPath> borders = new Dictionary<FastDrawnState, GraphicsPath>();
            for (int selectState = 0; selectState < 2; selectState++)
            {
                foreach (IPolygonCategory category in Symbology.Categories)
                {
                    FastDrawnState state = new FastDrawnState(selectState == 1, category);

                    GraphicsPath border = new GraphicsPath();
                    borders.Add(state, border);
                    graphPaths.Add(border);
                }
            }

            paths.AddRange(graphPaths);

            List<ShapeRange> shapes = DataSet.ShapeIndices;
            double[] vertices = DataSet.Vertex;

            if (ProgressReportingEnabled)
            {
                ProgressMeter = new ProgressMeter(ProgressHandler, "Building Paths", indices.Count());
            }

            if (!DrawnStatesNeeded)
            {
                FastDrawnState state = new FastDrawnState(false, Symbology.Categories[0]);

                foreach (int shp in indices)
                {
                    if (ProgressReportingEnabled) ProgressMeter.Next();
                    ShapeRange shape = shapes[shp];
                    if (!shape.Extent.Intersects(e.GeographicExtents)) return;
                    if (shp >= shapes.Count) return;
                    if (!borders.ContainsKey(state)) return;

                    BuildPolygon(vertices, shapes[shp], borders[state], e, drawExtents.Contains(shape.Extent) ? null : shClip);
                }
            }
            else
            {
                FastDrawnState[] states = DrawnStates;
                foreach (GraphicsPath borderPath in borders.Values)
                {
                    if (borderPath != null)
                    {
                        borderPath.FillMode = FillMode.Winding;
                    }
                }

                foreach (int shp in indices)
                {
                    if (ProgressReportingEnabled) ProgressMeter.Next();
                    if (shp >= shapes.Count) return;
                    if (shp >= states.Length)
                    {
                        AssignFastDrawnStates();
                        states = DrawnStates;
                    }
                    if (states[shp].Visible == false) continue;
                    ShapeRange shape = shapes[shp];
                    if (!shape.Extent.Intersects(e.GeographicExtents)) continue;
                    if (drawExtents.Contains(shape.Extent))
                    {
                        FastDrawnState state = states[shp];
                        if (!borders.ContainsKey(state)) continue;
                        BuildPolygon(vertices, shapes[shp], borders[state], e, null);
                    }
                    else
                    {
                        FastDrawnState state = states[shp];
                        if (!borders.ContainsKey(state)) continue;
                        BuildPolygon(vertices, shapes[shp], borders[state], e, shClip);
                    }
                }
            }
            if (ProgressReportingEnabled) ProgressMeter.Reset();
        }
Beispiel #46
0
        private static RectangleF PlacePointLabel(IGeometry f, MapArgs e, Func <SizeF> labelSize, ILabelSymbolizer symb, float angle)
        {
            Coordinate c = f.GetGeometryN(1).Coordinates[0];

            return(PlaceLabel(c, e, labelSize, symb, angle));
        }
Beispiel #47
0
 private static Rectangle ComputeClippingRectangle(MapArgs args)
 {
     const int maxSymbologyFuzz = 50;
     var clipRect = new Rectangle(args.ImageRectangle.Location.X, args.ImageRectangle.Location.Y, args.ImageRectangle.Width, args.ImageRectangle.Height);
     clipRect.Inflate(maxSymbologyFuzz, maxSymbologyFuzz);
     return clipRect;
 }
Beispiel #48
0
 /// <summary>
 /// Draws the given text if it is on screen. If PreventCollision is set only labels that don't collide with existingLables are drawn.
 /// </summary>
 /// <param name="txt">Text that should be drawn.</param>
 /// <param name="g">Graphics object that does the drawing.</param>
 /// <param name="symb">Symbolizer to figure out the look of the label.</param>
 /// <param name="f">Feature, the label belongs to.</param>
 /// <param name="e"></param>
 /// <param name="labelBounds"></param>
 /// <param name="existingLabels">List with labels that were already drawn.</param>
 /// <param name="angle">Angle in degree the label gets rotated by.</param>
 private static void CollisionDraw(string txt, Graphics g, ILabelSymbolizer symb, IFeature f, MapArgs e, RectangleF labelBounds, List <RectangleF> existingLabels, float angle)
 {
     if (labelBounds.IsEmpty || !e.ImageRectangle.IntersectsWith(labelBounds))
     {
         return;
     }
     if (symb.PreventCollisions)
     {
         if (!Collides(labelBounds, existingLabels))
         {
             DrawLabel(g, txt, labelBounds, symb, f, angle);
             existingLabels.Add(labelBounds);
         }
     }
     else
     {
         DrawLabel(g, txt, labelBounds, symb, f, angle);
     }
 }
Beispiel #49
0
 /// <summary>
 /// Draws the LiDAR data points in the currently visible map display
 /// </summary>
 /// <param name="args">Information about the map display</param>
 /// <param name="regions">Information about the visible regions</param>
 public void DrawRegions(MapArgs args, List<Extent> regions)
 {
     throw new NotImplementedException();
 }
Beispiel #50
0
        /// <summary>
        /// Draws the labels for the given features.
        /// </summary>
        /// <param name="e">MapArgs to get Graphics object from.</param>
        /// <param name="features">Indizes of the features whose labels get drawn.</param>
        private void DrawFeatures(MapArgs e, IEnumerable <int> features)
        {
            // Check that exists at least one category with Expression
            if (Symbology.Categories.All(_ => string.IsNullOrEmpty(_.Expression)))
            {
                return;
            }

            Graphics g             = e.Device ?? Graphics.FromImage(_backBuffer);
            Matrix   origTransform = g.Transform;

            // Only draw features that are currently visible.
            if (FastDrawnStates == null)
            {
                CreateIndexedLabels();
            }
            FastLabelDrawnState[] drawStates = FastDrawnStates;
            if (drawStates == null)
            {
                return;
            }
            //Sets the graphics objects smoothing modes
            g.TextRenderingHint = TextRenderingHint.AntiAlias;
            g.SmoothingMode     = SmoothingMode.AntiAlias;

            Action <int, IFeature> drawFeature;

            switch (FeatureSet.FeatureType)
            {
            case FeatureType.Polygon:
                drawFeature = (fid, feature) => DrawPolygonFeature(e, g, feature, drawStates[fid].Category, drawStates[fid].Selected, ExistingLabels);
                break;

            case FeatureType.Line:
                drawFeature = (fid, feature) => DrawLineFeature(e, g, feature, drawStates[fid].Category, drawStates[fid].Selected, ExistingLabels);
                break;

            case FeatureType.Point:
            case FeatureType.MultiPoint:
                drawFeature = (fid, feature) => DrawPointFeature(e, g, feature, drawStates[fid].Category, drawStates[fid].Selected, ExistingLabels);
                break;

            default:
                return;     // Can't draw something else
            }

            foreach (var category in Symbology.Categories)
            {
                category.UpdateExpressionColumns(FeatureSet.DataTable.Columns);
                var catFeatures = new List <int>();
                foreach (int fid in features)
                {
                    if (drawStates[fid] == null || drawStates[fid].Category == null)
                    {
                        continue;
                    }
                    if (drawStates[fid].Category == category)
                    {
                        catFeatures.Add(fid);
                    }
                }
                // Now that we are restricted to a certain category, we can look at priority
                if (category.Symbolizer.PriorityField != "FID")
                {
                    Feature.ComparisonField = category.Symbolizer.PriorityField;
                    catFeatures.Sort();
                    // When preventing collisions, we want to do high priority first.
                    // Otherwise, do high priority last.
                    if (category.Symbolizer.PreventCollisions)
                    {
                        if (!category.Symbolizer.PrioritizeLowValues)
                        {
                            catFeatures.Reverse();
                        }
                    }
                    else
                    {
                        if (category.Symbolizer.PrioritizeLowValues)
                        {
                            catFeatures.Reverse();
                        }
                    }
                }

                foreach (var fid in catFeatures)
                {
                    if (!FeatureLayer.DrawnStates[fid].Visible)
                    {
                        continue;
                    }
                    var feature = FeatureSet.GetFeature(fid);
                    drawFeature(fid, feature);
                }
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
            else
            {
                g.Transform = origTransform;
            }
        }
Beispiel #51
0
        /// <summary>
        /// If useChunks is true, then this method
        /// </summary>
        /// <param name="args">The GeoArgs that control how these features should be drawn.</param>
        /// <param name="indices">The features that should be drawn.</param>
        /// <param name="clipRectangles">If an entire chunk is drawn and an update is specified, this clarifies the changed rectangles.</param>
        /// <param name="useChunks">Boolean, if true, this will refresh the buffer in chunks.</param>
        public virtual void DrawFeatures(MapArgs args, List<int> indices, List<Rectangle> clipRectangles, bool useChunks)
        {
            if (useChunks == false)
            {
                DrawFeatures(args, indices);
                return;
            }

            int count = indices.Count;
            int numChunks = (int)Math.Ceiling(count / (double)ChunkSize);

            for (int chunk = 0; chunk < numChunks; chunk++)
            {
                int numFeatures = ChunkSize;
                if (chunk == numChunks - 1) numFeatures = indices.Count - (chunk * ChunkSize);
                DrawFeatures(args, indices.GetRange(chunk * ChunkSize, numFeatures));

                if (numChunks > 0 && chunk < numChunks - 1)
                {
                    // FinishDrawing();
                    OnBufferChanged(clipRectangles);
                    Application.DoEvents();
                    // this.StartDrawing();
                }
            }
        }
Beispiel #52
0
        /// <summary>
        /// Draws the labels for the given features.
        /// </summary>
        /// <param name="e">MapArgs to get Graphics object from.</param>
        /// <param name="features">Features, whose labels get drawn.</param>
        private void DrawFeatures(MapArgs e, IEnumerable <IFeature> features)
        {
            // Check that exists at least one category with Expression
            if (Symbology.Categories.All(_ => string.IsNullOrEmpty(_.Expression)))
            {
                return;
            }

            Graphics g             = e.Device ?? Graphics.FromImage(_backBuffer);
            Matrix   origTransform = g.Transform;

            // Only draw features that are currently visible.
            if (DrawnStates == null || !DrawnStates.ContainsKey(features.First()))
            {
                CreateLabels();
            }
            Dictionary <IFeature, LabelDrawState> drawStates = DrawnStates;

            if (drawStates == null)
            {
                return;
            }
            //Sets the graphics objects smoothing modes
            g.TextRenderingHint = TextRenderingHint.AntiAlias;
            g.SmoothingMode     = SmoothingMode.AntiAlias;

            Action <IFeature> drawFeature;

            switch (features.First().FeatureType)
            {
            case FeatureType.Polygon:
                drawFeature = f => DrawPolygonFeature(e, g, f, drawStates[f].Category, drawStates[f].Selected, ExistingLabels);
                break;

            case FeatureType.Line:
                drawFeature = f => DrawLineFeature(e, g, f, drawStates[f].Category, drawStates[f].Selected, ExistingLabels);
                break;

            case FeatureType.Point:
            case FeatureType.MultiPoint:
                drawFeature = f => DrawPointFeature(e, g, f, drawStates[f].Category, drawStates[f].Selected, ExistingLabels);
                break;

            default:
                return;     // Can't draw something else
            }


            foreach (ILabelCategory category in Symbology.Categories)
            {
                category.UpdateExpressionColumns(FeatureSet.DataTable.Columns);
                var             cat         = category; // prevent access to unmodified closure problems
                List <IFeature> catFeatures = new List <IFeature>();
                foreach (IFeature f in features)
                {
                    if (drawStates.ContainsKey(f) && drawStates[f].Category == cat)
                    {
                        catFeatures.Add(f);
                    }
                }
                // Now that we are restricted to a certain category, we can look at
                // priority
                if (category.Symbolizer.PriorityField != "FID")
                {
                    Feature.ComparisonField = cat.Symbolizer.PriorityField;
                    catFeatures.Sort();
                    // When preventing collisions, we want to do high priority first.
                    // otherwise, do high priority last.
                    if (cat.Symbolizer.PreventCollisions)
                    {
                        if (!cat.Symbolizer.PrioritizeLowValues)
                        {
                            catFeatures.Reverse();
                        }
                    }
                    else
                    {
                        if (cat.Symbolizer.PrioritizeLowValues)
                        {
                            catFeatures.Reverse();
                        }
                    }
                }
                for (int i = 0; i < catFeatures.Count; i++)
                {
                    if (!FeatureLayer.DrawnStates[i].Visible)
                    {
                        continue;
                    }
                    drawFeature(catFeatures[i]);
                }
            }

            if (e.Device == null)
            {
                g.Dispose();
            }
            else
            {
                g.Transform = origTransform;
            }
        }
Beispiel #53
0
        private void DrawFeatures(MapArgs e, IEnumerable<int> indices)
        {
            Graphics g = e.Device ?? Graphics.FromImage(_backBuffer);

            if (DrawnStatesNeeded)
            {
                FastDrawnState[] states = DrawnStates;
                int max = indices.Max();
                if (max >= states.Length)
                {
                    AssignFastDrawnStates();
                    states = DrawnStates;
                }
                for (int selectState = 0; selectState < 2; selectState++)
                {
                    foreach (ILineCategory category in Symbology.Categories)
                    {
                        // Define the symbology based on the category and selection state
                        ILineSymbolizer ls = category.Symbolizer;
                        if (selectState == SELECTED) ls = category.SelectionSymbolizer;
                        if (ls.Smoothing)
                        {
                            g.SmoothingMode = SmoothingMode.AntiAlias;
                        }
                        else
                        {
                            g.SmoothingMode = SmoothingMode.None;
                        }

                        // Compute a clipping rectangle that accounts for symbology
                        Rectangle clipRect = ComputeClippingRectangle(e, ls);

                        // Determine the subset of the specified features that are visible and match the category
                        ILineCategory lineCategory = category;
                        int i = selectState;

                        List<int> drawnFeatures = new List<int>();

                        foreach (int index in indices)
                        {
                            FastDrawnState state = states[index];
                            if (state.Category == lineCategory && state.Selected == (i == 1) && state.Visible)
                            {
                                drawnFeatures.Add(index);
                            }
                        }

                        GraphicsPath graphPath = new GraphicsPath();
                        foreach (int shp in drawnFeatures)
                        {
                            ShapeRange shape = DataSet.ShapeIndices[shp];
                            BuildLineString(graphPath, DataSet.Vertex, shape, e, clipRect);
                        }
                        double scale = 1;
                        if (ls.ScaleMode == ScaleMode.Geographic)
                        {
                            scale = e.ImageRectangle.Width / e.GeographicExtents.Width;
                        }

                        foreach (IStroke stroke in ls.Strokes)
                        {
                            stroke.DrawPath(g, graphPath, scale);
                        }

                        graphPath.Dispose();
                    }
                }
            }
            else
            {
                // Selection state is disabled
                // Category is only the very first category
                ILineCategory category = Symbology.Categories[0];
                ILineSymbolizer ls = category.Symbolizer;

                if (ls.Smoothing)
                {
                    g.SmoothingMode = SmoothingMode.AntiAlias;
                }
                else
                {
                    g.SmoothingMode = SmoothingMode.None;
                }

                Rectangle clipRect = ComputeClippingRectangle(e, ls);
                // Determine the subset of the specified features that are visible and match the category
                GraphicsPath graphPath = new GraphicsPath();
                foreach (int shp in indices)
                {
                    ShapeRange shape = DataSet.ShapeIndices[shp];
                    BuildLineString(graphPath, DataSet.Vertex, shape, e, clipRect);
                }
                double scale = 1;
                if (ls.ScaleMode == ScaleMode.Geographic)
                {
                    scale = e.ImageRectangle.Width / e.GeographicExtents.Width;
                }

                foreach (IStroke stroke in ls.Strokes)
                {
                    stroke.DrawPath(g, graphPath, scale);
                }

                graphPath.Dispose();
            }

            if (e.Device == null) g.Dispose();
        }
Beispiel #54
0
        /// <summary>
        /// Appends the specified polygon to the graphics path.
        /// </summary>
        /// <param name="vertices">The vertices.</param>
        /// <param name="shpx">The shape range.</param>
        /// <param name="borderPath">The border path.</param>
        /// <param name="args">The map arguments.</param>
        /// <param name="shClip">The southerland hodgmen polygon clipper.</param>
        private static void BuildPolygon(double[] vertices, ShapeRange shpx, GraphicsPath borderPath, MapArgs args, SoutherlandHodgman shClip)
        {
            double minX = args.MinX;
            double maxY = args.MaxY;
            double dx   = args.Dx;
            double dy   = args.Dy;

            for (int prt = 0; prt < shpx.Parts.Count; prt++)
            {
                PartRange prtx   = shpx.Parts[prt];
                int       start  = prtx.StartIndex;
                int       end    = prtx.EndIndex;
                var       points = new List <double[]>(end - start + 1);

                for (int i = start; i <= end; i++)
                {
                    var pt = new[] { (vertices[i * 2] - minX) * dx, (maxY - vertices[(i * 2) + 1]) * dy };
                    points.Add(pt);
                }

                if (shClip != null)
                {
                    points = shClip.Clip(points);
                }

                var intPoints = DuplicationPreventer.Clean(points).ToArray();
                if (intPoints.Length < 2)
                {
                    continue;
                }

                borderPath.StartFigure();
                borderPath.AddLines(intPoints);
            }
        }
Beispiel #55
0
 private static Rectangle ComputeClippingRectangle(MapArgs args, ILineSymbolizer ls)
 {
     // Compute a clipping rectangle that accounts for symbology
     int maxLineWidth = 2 * (int)Math.Ceiling(ls.GetWidth());
     Rectangle clipRect = new Rectangle(args.ImageRectangle.Location.X, args.ImageRectangle.Location.Y, args.ImageRectangle.Width, args.ImageRectangle.Height);
     clipRect.Inflate(maxLineWidth, maxLineWidth);
     return clipRect;
 }
Beispiel #56
0
        private void BuildPaths(MapArgs e, IEnumerable <int> indices, out Dictionary <FastDrawnState, GraphicsPath> paths, bool selected)
        {
            paths = new Dictionary <FastDrawnState, GraphicsPath>();

            var indiceList = indices as IList <int> ?? indices.ToList();

            FastDrawnState[] states = DrawnStatesNeeded ? DrawnStates : new FastDrawnState[0];
            if (DrawnStatesNeeded && indiceList.Max() >= states.Length)
            {
                AssignFastDrawnStates();
                states = DrawnStates;
            }

            if (selected && (!DrawnStatesNeeded || !DrawnStates.Any(_ => _.Selected)))
            {
                return;
            }

            if (ProgressReportingEnabled)
            {
                ProgressMeter = new ProgressMeter(ProgressHandler, "Building Paths", indiceList.Count);
            }

            FastDrawnState     state       = new FastDrawnState(selected, Symbology.Categories[0]);
            Extent             drawExtents = e.GeographicExtents;
            Rectangle          clipRect    = e.ProjToPixel(e.GeographicExtents);
            SoutherlandHodgman shClip      = new SoutherlandHodgman(clipRect);

            List <ShapeRange> shapes = DataSet.ShapeIndices;

            double[] vertices = DataSet.Vertex;

            foreach (int shp in indiceList)
            {
                if (ProgressReportingEnabled)
                {
                    ProgressMeter.Next();
                }
                if (shp >= shapes.Count)
                {
                    return;
                }
                ShapeRange shape = shapes[shp];
                if (!shape.Extent.Intersects(e.GeographicExtents))
                {
                    continue;
                }

                if (DrawnStatesNeeded)
                {
                    if (!states[shp].Visible || (selected && !states[shp].Selected))
                    {
                        continue;
                    }

                    state = new FastDrawnState(selected, states[shp].Category);
                }

                if (!paths.ContainsKey(state))
                {
                    paths.Add(state, new GraphicsPath(FillMode.Winding));
                }

                BuildPolygon(vertices, shapes[shp], paths[state], e, drawExtents.Contains(shape.Extent) ? null : shClip);
            }

            if (ProgressReportingEnabled)
            {
                ProgressMeter.Reset();
            }
        }
Beispiel #57
0
 /// <summary>
 /// This will draw any features that intersect this region.  To specify the features
 /// directly, use OnDrawFeatures.  This will not clear existing buffer content.
 /// For that call Initialize instead.
 /// </summary>
 /// <param name="args">A GeoArgs clarifying the transformation from geographic to image space</param>
 /// <param name="regions">The geographic regions to draw</param>
 public void DrawRegions(MapArgs args, List<Extent> regions)
 {
     List<Rectangle> clipRects = args.ProjToPixel(regions);
     for (int i = clipRects.Count - 1; i >= 0; i--)
     {
         if (clipRects[i].Width != 0 && clipRects[i].Height != 0) continue;
         regions.RemoveAt(i);
         clipRects.RemoveAt(i);
     }
     DrawWindows(args, regions, clipRects);
 }
Beispiel #58
0
        /// <summary>
        /// This will draw any features that intersect this region. To specify the features
        /// directly, use OnDrawFeatures. This will not clear existing buffer content.
        /// For that call Initialize instead.
        /// </summary>
        /// <param name="args">A GeoArgs clarifying the transformation from geographic to image space</param>
        /// <param name="regions">The geographic regions to draw</param>
        public void DrawRegions(MapArgs args, List <Extent> regions)
        {
            List <Rectangle> clipRects = args.ProjToPixel(regions);

            DrawWindows(args, regions, clipRects);
        }
Beispiel #59
0
        /// <summary>
        /// This will draw any features that intersect this region.  To specify the features
        /// directly, use OnDrawFeatures.  This will not clear existing buffer content.
        /// For that call Initialize instead.
        /// </summary>
        /// <param name="args">A GeoArgs clarifying the transformation from geographic to image space</param>
        /// <param name="regions">The geographic regions to draw</param>
        public virtual void DrawRegions(MapArgs args, List<Extent> regions)
        {
            double minX = args.MinX;
            double maxY = args.MaxY;
            double dx = args.Dx;
            double dy = args.Dy;
            if (Double.IsInfinity(dx) || Double.IsInfinity(dy)) return;

            foreach (Extent boundingBox in regions)
            {
                Graphics g = args.Device ?? Graphics.FromImage(_backBuffer);
                Matrix origTransform = g.Transform;
                FeatureType featureType = FeatureType.Point;

                //reads the point array from the data source
                //DataSet implements or uses IShapeSource to read the points that are within the bounding box
                double[] vertices = DataSet.GetPointArray(boundingBox);

                //setup the point symbol
                Color randomColor = CreateRandomColor();
                Bitmap normalSymbol = CreateDefaultSymbol(randomColor, 4);

                //run the drawing operation
                int numPoints = vertices.Length / 2;

                for (int index = 0; index < numPoints; index++)
                {
                    Bitmap bmp = normalSymbol;

                    if (featureType == FeatureType.Point)
                    {
                        Point pt = new Point();
                        pt.X = Convert.ToInt32((vertices[index * 2] - minX) * dx);
                        pt.Y = Convert.ToInt32((maxY - vertices[index * 2 + 1]) * dy);

                        Matrix shift = origTransform.Clone();
                        shift.Translate(pt.X, pt.Y);
                        g.Transform = shift;

                        g.DrawImageUnscaled(bmp, -bmp.Width / 2, -bmp.Height / 2);
                    }
                }

                if (args.Device == null) g.Dispose();
                else g.Transform = origTransform;
            }
        }
Beispiel #60
0
        /// <summary>
        /// This draws to the back buffer. If the back buffer doesn't exist, this will create one.
        /// This will not flip the back buffer to the front.
        /// </summary>
        /// <param name="args">The map arguments.</param>
        /// <param name="regions">The regions </param>
        /// <param name="clipRectangles">The clip rectangles.</param>
        private void DrawWindows(MapArgs args, IList <Extent> regions, IList <Rectangle> clipRectangles)
        {
            if (DataSet == null || regions.Count == 0 || regions.Count != clipRectangles.Count)
            {
                return;
            }
            Graphics g;

            if (args.Device != null)
            {
                g = args.Device; // A device on the MapArgs is optional, but overrides the normal buffering behaviors.
            }
            else
            {
                if (BackBuffer == null)
                {
                    BackBuffer = new Bitmap(BufferRectangle.Width, BufferRectangle.Height);
                }
                g = Graphics.FromImage(BackBuffer);
            }

            int numBounds = Math.Min(regions.Count, clipRectangles.Count);

            if (Symbolizer != null && Symbolizer.Opacity < 1)
            {
                ColorMatrix matrix = new ColorMatrix
                {
                    Matrix33 = Symbolizer.Opacity // draws the image not completely opaque
                };
                using (var attributes = new ImageAttributes())
                {
                    for (int i = 0; i < numBounds; i++)
                    {
                        using (Bitmap bmp = DataSet.GetBitmap(regions[i], clipRectangles[i]))
                        {
                            if (bmp != null)
                            {
                                attributes.SetColorMatrix(matrix, ColorMatrixFlag.Default, ColorAdjustType.Bitmap);
                                g.DrawImage(bmp, clipRectangles[i], 0, 0, bmp.Width, bmp.Height, GraphicsUnit.Pixel, attributes);
                            }
                        }
                    }
                }
            }
            else
            {
                for (int i = 0; i < numBounds; i++)
                {
                    using (Bitmap bmp = DataSet.GetBitmap(regions[i], clipRectangles[i]))
                    {
                        if (bmp != null)
                        {
                            g.DrawImage(bmp, clipRectangles[i]);
                        }
                    }
                }
            }

            if (args.Device == null)
            {
                g.Dispose();
            }
        }