/// <summary> /// Draws the point symbol in the view /// </summary> /// <param name="g"></param> /// <param name="clip"></param> protected virtual void OnDraw(Graphics g, Rectangle clip) { if (_borderStyle == BorderStyle.Fixed3D) { g.DrawLine(Pens.White, 0, Height - 1, Width - 1, Height - 1); g.DrawLine(Pens.White, Width - 1, 0, Width - 1, Height - 1); g.DrawLine(Pens.Gray, 0, 0, 0, Height - 1); g.DrawLine(Pens.Gray, 0, 0, Width - 1, 0); } if (_borderStyle == BorderStyle.FixedSingle) { g.DrawRectangle(Pens.Black, 0, 0, Width - 1, Height - 1); } if (_symbolizer == null) { return; } Size2D size = _symbolizer.GetSize(); int w = (int)size.Width; int h = (int)size.Height; if (w < 1 || h < 1) { return; } Rectangle symbolBounds = new Rectangle(Width / 2 - w / 2, Height / 2 - h / 2, w, h); if (!symbolBounds.IntersectsWith(clip)) { return; } _symbolizer.Draw(g, symbolBounds); }
/// <summary> /// Draws a point at the given location. /// </summary> /// <param name="ptX">X-Coordinate of the point, that should be drawn.</param> /// <param name="ptY">Y-Coordinate of the point, that should be drawn.</param> /// <param name="e">MapArgs for calculating the scaleSize.</param> /// <param name="ps">PointSymbolizer with which the point gets drawn.</param> /// <param name="g">Graphics-Object that should be used by the PointSymbolizer.</param> /// <param name="origTransform">The original transformation that is used to position the point.</param> private void DrawPoint(double ptX, double ptY, MapArgs e, IPointSymbolizer ps, Graphics g, Matrix origTransform) { var x = Convert.ToInt32((ptX - e.MinX) * e.Dx); var y = Convert.ToInt32((e.MaxY - ptY) * e.Dy); double scaleSize = ps.GetScale(e); Matrix shift = origTransform.Clone(); shift.Translate(x, y); g.Transform = shift; ps.Draw(g, scaleSize); }
/// <summary> /// Draws a point at the given location. /// </summary> /// <param name="ptX">X-Coordinate of the point, that should be drawn.</param> /// <param name="ptY">Y-Coordinate of the point, that should be drawn.</param> /// <param name="e">MapArgs for calculating the scaleSize.</param> /// <param name="ps">PointSymbolizer with which the point gets drawn.</param> /// <param name="g">Graphics-Object that should be used by the PointSymbolizer.</param> /// <param name="origTransform">The original transformation that is used to position the point.</param> private void DrawPoint(double ptX, double ptY, MapArgs e, IPointSymbolizer ps, Graphics g, Matrix origTransform) { var pt = new Point { X = Convert.ToInt32((ptX - e.MinX) * e.Dx), Y = Convert.ToInt32((e.MaxY - ptY) * e.Dy) }; double scaleSize = ps.ScaleMode == ScaleMode.Geographic ? e.ImageRectangle.Width / e.GeographicExtents.Width : 1; Matrix shift = origTransform.Clone(); shift.Translate(pt.X, pt.Y); g.Transform = shift; ps.Draw(g, scaleSize); }
/// <summary> /// Draws a point at the given location. /// </summary> /// <param name="ptX">X-Coordinate of the point, that should be drawn.</param> /// <param name="ptY">Y-Coordinate of the point, that should be drawn.</param> /// <param name="e">MapArgs for calculating the scaleSize.</param> /// <param name="ps">PointSymbolizer with which the point gets drawn.</param> /// <param name="g">Graphics-Object that should be used by the PointSymbolizer.</param> /// <param name="origTransform">The original transformation that is used to position the point.</param> /// <param name="clockwiseAngle">clockwiseAngle.</param> private void DrawPoint(double ptX, double ptY, MapArgs e, IPointSymbolizer ps, Graphics g, Matrix origTransform, float clockwiseAngle) { var pt = new PointF { X = Convert.ToSingle((ptX - e.MinX) * e.Dx), Y = Convert.ToSingle((e.MaxY - ptY) * e.Dy) }; double scaleSize = ps.GetScale(e); Matrix shift = origTransform.Clone(); shift.Translate(pt.X, pt.Y); shift.Rotate(clockwiseAngle); g.Transform = shift; ps.Draw(g, scaleSize); }
private void UpdatePreview(Graphics g) { if (_symbolizer == null) { return; } g.Clear(Color.White); Matrix shift = g.Transform; shift.Translate((float)lblPreview.Width / 2, (float)lblPreview.Height / 2); g.Transform = shift; double scale = 1; Size2D symbolSize = _symbolizer.GetSize(); if (_symbolizer.ScaleMode == ScaleMode.Geographic || symbolSize.Height > (lblPreview.Height - 6)) { scale = (lblPreview.Height - 6) / symbolSize.Height; } _symbolizer.Draw(g, scale); }
/// <summary> /// Draws a point at the given location. /// </summary> /// <param name="ptX">X-Coordinate of the point, that should be drawn.</param> /// <param name="ptY">Y-Coordinate of the point, that should be drawn.</param> /// <param name="e">MapArgs for calculating the scaleSize.</param> /// <param name="ps">PointSymbolizer with which the point gets drawn.</param> /// <param name="g">Graphics-Object that should be used by the PointSymbolizer.</param> /// <param name="origTransform">The original transformation that is used to position the point.</param> private void DrawPoint(double ptX, double ptY, MapArgs e, IPointSymbolizer ps, Graphics g, Matrix origTransform) { var pt = new Point { X = Convert.ToInt32((ptX - e.MinX) * e.Dx), Y = Convert.ToInt32((e.MaxY - ptY) * e.Dy) }; double scaleSize = 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; scaleSize = dReferenceScale / dCurrentScale; } // Fin CGX Matrix shift = origTransform.Clone(); shift.Translate(pt.X, pt.Y); g.Transform = shift; ps.Draw(g, scaleSize); }
private static Bitmap GetSymbolizerBitmap(IPointSymbolizer symbolizer, IProj e) { if (symbolizer == null) return null; var scaleSize = symbolizer.GetScale(e); var size = symbolizer.GetSize(); if (size.Width * scaleSize < 1 || size.Height * scaleSize < 1) return null; var bitmap = new Bitmap((int)(size.Width * scaleSize) + 1, (int)(size.Height * scaleSize) + 1); var bg = Graphics.FromImage(bitmap); bg.SmoothingMode = symbolizer.Smoothing ? SmoothingMode.AntiAlias : SmoothingMode.None; var 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 * scaleSize) / 2 - 1), (float)(size.Height * scaleSize) / 2 - 1); bg.Transform = trans; symbolizer.Draw(bg, 1); return bitmap; }
// 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; } }
// 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) { Point pt = new Point(); pt.X = Convert.ToInt32((vertices[index * 2] - minX) * dx); pt.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++) { Point pt = new Point(); pt.X = Convert.ToInt32((vertices[i * 2] - minX) * dx); pt.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) { 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); } else { ShapeRange range = DataSet.ShapeIndices[index]; for (int i = range.StartIndex; i <= range.EndIndex(); i++) { Point pt = new Point(); pt.X = Convert.ToInt32((vertices[i * 2] - minX) * dx); pt.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; } }
/// <summary> /// Given the points on this line decoration, this will cycle through and handle /// the drawing as dictated by this decoration. /// </summary> /// <param name="g"></param> /// <param name="path"></param> /// <param name="scaleWidth">The double scale width for controling markers</param> public void Draw(Graphics g, GraphicsPath path, double scaleWidth) { if (NumSymbols == 0) { return; } GraphicsPathIterator myIterator = new GraphicsPathIterator(path); myIterator.Rewind(); int start, end; bool isClosed; Size2D symbolSize = _symbol.GetSize(); Bitmap symbol = new Bitmap((int)symbolSize.Width, (int)symbolSize.Height); Graphics sg = Graphics.FromImage(symbol); _symbol.Draw(sg, new Rectangle(0, 0, (int)symbolSize.Width, (int)symbolSize.Height)); sg.Dispose(); Matrix oldMat = g.Transform; PointF[] points; if (path.PointCount == 0) { return; } try { points = path.PathPoints; } catch { return; } while (myIterator.NextSubpath(out start, out end, out isClosed) > 0) { if (NumSymbols == 1) //single decoration spot { if (_percentualPosition == 0) // at start of the line { DrawImage(g, points[start], points[start + 1], points[start], (FlipFirst ^ FlipAll), symbol, oldMat); } else if (_percentualPosition == 100) // at end of the line { DrawImage(g, points[end - 1], points[end], points[end], (FlipFirst ^ FlipAll), symbol, oldMat); } else //somewhere in between start and end { double totalLength = GetLength(points, start, end); double span = totalLength * (double)_percentualPosition / 100; List <DecorationSpot> spot = GetPosition(points, span, start, end); if (spot.Count > 1) { DrawImage(g, spot[1].Before, spot[1].After, spot[1].Position, (FlipFirst ^ FlipAll), symbol, oldMat); } } } else // more than one decoration spot { double totalLength = GetLength(points, start, end); double span = Math.Round(totalLength / (NumSymbols - 1), 4); List <DecorationSpot> spots = GetPosition(points, span, start, end); spots.Add(new DecorationSpot(points[end - 1], points[end], points[end])); //add the missing end point for (int i = 0; i < spots.Count; i++) { DrawImage(g, spots[i].Before, spots[i].After, spots[i].Position, i == 0 ? (FlipFirst ^ FlipAll) : FlipAll, symbol, oldMat); } } } }
/// <summary> /// Given the points on this line decoration, this will cycle through and handle /// the drawing as dictated by this decoration. /// </summary> /// <param name="g"></param> /// <param name="path"></param> /// <param name="scaleWidth">The double scale width for controling markers</param> public void Draw(Graphics g, GraphicsPath path, double scaleWidth) { if (NumSymbols == 0) { return; } GraphicsPathIterator myIterator = new GraphicsPathIterator(path); myIterator.Rewind(); int start, end; bool isClosed; Size2D symbolSize = _symbol.GetSize(); Bitmap symbol = new Bitmap((int)symbolSize.Width, (int)symbolSize.Height); Graphics sg = Graphics.FromImage(symbol); _symbol.Draw(sg, new Rectangle(0, 0, (int)symbolSize.Width, (int)symbolSize.Height)); sg.Dispose(); Matrix oldMat = g.Transform; PointF[] points; if (path.PointCount == 0) { return; } try { points = path.PathPoints; } catch { return; } PointF offset; int count = 0; while (myIterator.NextSubpath(out start, out end, out isClosed) > 0) { count = count + 1; // First marker PointF startPoint = points[start]; PointF stopPoint = points[start + 1]; float angle = 0F; if (_rotateWithLine) { angle = GetAngle(startPoint, stopPoint); } if (FlipFirst && !FlipAll) { FlipAngle(ref angle); } offset = GetOffset(startPoint, stopPoint); startPoint = new PointF(startPoint.X + offset.X, startPoint.Y + offset.Y); Matrix rotated = g.Transform; rotated.RotateAt(angle, startPoint); g.Transform = rotated; DrawImage(g, startPoint, symbol); g.Transform = oldMat; // Second marker if (NumSymbols > 1) { angle = 0F; if (_rotateWithLine) { angle = GetAngle(points[end - 1], points[end]); } if (FlipAll) { FlipAngle(ref angle); } offset = GetOffset(points[end - 1], points[end]); PointF endPoint = new PointF(points[end].X + offset.X, points[end].Y + offset.Y); rotated = g.Transform; rotated.RotateAt(angle, endPoint); g.Transform = rotated; DrawImage(g, endPoint, symbol); g.Transform = oldMat; } if (NumSymbols > 2) { double totalLength = GetLength(points, start, end); double span = totalLength / (NumSymbols - 1); for (int i = 1; i < NumSymbols - 1; i++) { DecorationSpot spot = GetPosition(points, span * i, start, end); angle = 0F; if (_rotateWithLine) { angle = GetAngle(spot.Before, spot.After); } offset = GetOffset(spot.Before, spot.After); PointF location = new PointF(spot.Position.X + offset.X, spot.Position.Y + offset.Y); if (FlipAll) { FlipAngle(ref angle); } rotated = g.Transform; rotated.RotateAt(angle, location); g.Transform = rotated; DrawImage(g, location, symbol); g.Transform = oldMat; } } } }