public void Linestring() { LineString l = new LineString(); Assert.IsTrue(l.IsEmpty()); Assert.IsNull(l.GetBoundingBox()); Assert.AreEqual(0, l.Length); Assert.IsFalse(l.Equals(null)); Assert.IsTrue(l.Equals(new LineString())); Collection<Point> vertices = new Collection<Point>(); vertices.Add(new Point(54, 23)); vertices.Add(new Point(93, 12)); vertices.Add(new Point(104, 32)); l.Vertices = vertices; Assert.IsFalse(l.IsEmpty()); Assert.IsFalse(l.IsClosed); Assert.AreEqual(3, l.NumPoints); Assert.AreEqual(new Point(54, 23), l.StartPoint); Assert.AreEqual(new Point(104,32), l.EndPoint); l.Vertices.Add(new Point(54, 23)); Assert.IsTrue(l.IsClosed); Assert.AreEqual(114.15056678325843, l.Length); Assert.AreNotSame(l.Clone(), l); Assert.AreNotSame(l.Clone().Vertices[0], l.Vertices[0]); Assert.AreEqual(l.Clone(), l); LineString l2 = l.Clone(); l2.Vertices[2] = l2.Vertices[2] + new Point(1, 1); Assert.AreNotEqual(l2, l); l2 = l.Clone(); l2.Vertices.Add(new Point(34, 23)); Assert.AreNotEqual(l2, l); }
private LineString CreateLineString() { LineString ls = new LineString(); ls.Vertices.Add(new Point(1, 2)); ls.Vertices.Add(new Point(10, 22)); ls.Vertices.Add(new Point(930, 123)); return ls; }
public void InOutInTest() { var lc = new SharpMap.Rendering.Symbolizer.CohenSutherlandLineClipping(0, 0, 10, 10); var l = new LineString(new[] { new Point(-5, 4), new Point(15, 4), new Point(15, 6), new Point(-5, 6), }); var res = lc.ClipLineString(l); Assert.IsNotNull(res); Assert.IsInstanceOfType(typeof (MultiLineString), res); Assert.AreEqual("MULTILINESTRING ((0 4, 10 4), (10 6, 0 6))", res.ToString()); }
private static LineString CreateWKBLineString(BinaryReader reader, WkbByteOrder byteOrder) { SharpMap.Geometries.LineString l = new SharpMap.Geometries.LineString(); //l.Vertices.AddRange(ReadCoordinates(reader, byteOrder)); Point[] arrPoint = ReadCoordinates(reader, byteOrder); for (int i = 0; i < arrPoint.Length; i++) { l.Vertices.Add(arrPoint[i]); } return(l); }
private Label CreateLabel(ILabelLayer layer, Geometry feature, string text, float rotation, ILabelStyle style, Map map, Graphics g) { System.Drawing.SizeF size = g.MeasureString(text, style.Font); System.Drawing.PointF position = map.WorldToImage(feature.GetBoundingBox().GetCentroid()); position.X = position.X - size.Width * (short)style.HorizontalAlignment * 0.5f; position.Y = position.Y - size.Height * (short)style.VerticalAlignment * 0.5f; if (position.X - size.Width > map.Size.Width || position.X + size.Width < 0 || position.Y - size.Height > map.Size.Height || position.Y + size.Height < 0) { return(null); } else { SharpMap.Rendering.Label lbl; if (!style.CollisionDetection) { lbl = new Label(text, position, rotation, layer.Priority, null, style); } else { //Collision detection is enabled so we need to measure the size of the string lbl = new Label(text, position, rotation, layer.Priority, new LabelBox(position.X - size.Width * 0.5f - style.CollisionBuffer.Width, position.Y + size.Height * 0.5f + style.CollisionBuffer.Height, size.Width + 2f * style.CollisionBuffer.Width, size.Height + style.CollisionBuffer.Height * 2f), style); } if (feature.GetType() == typeof(SharpMap.Geometries.LineString)) { SharpMap.Geometries.LineString line = feature as SharpMap.Geometries.LineString; if (line.Length / map.PixelSize > size.Width) //Only label feature if it is long enough { CalculateLabelOnLinestring(line, ref lbl, map); } else { return(null); } } return(lbl); } }
public void SimpleTest() { var lc = new SharpMap.Rendering.Symbolizer.CohenSutherlandLineClipping(0, 0, 10, 10); var l = new LineString(new[] { new Point(-5, 5), new Point(15, 5), }); var res = lc.ClipLineString(l); Assert.IsNotNull(res); Assert.IsInstanceOfType(typeof(MultiLineString), res); Assert.AreEqual("MULTILINESTRING ((0 5, 10 5))", res.ToString()); l = new LineString(new[] { new Point(5, -5), new Point(5, 15), }); res = lc.ClipLineString(l); Assert.IsNotNull(res); Assert.IsInstanceOfType(typeof(MultiLineString), res); Assert.AreEqual("MULTILINESTRING ((5 0, 5 10))", res.ToString()); l = new LineString(new[] { new Point(5, -5), new Point(5, 5), new Point(5, 15), }); res = lc.ClipLineString(l); Assert.IsNotNull(res); Assert.IsInstanceOfType(typeof(MultiLineString), res); Assert.AreEqual("MULTILINESTRING ((5 0, 5 5, 5 10))", res.ToString()); }
private void CalculateLabelOnLinestring(SharpMap.Geometries.LineString line, ref Label label, Map map) { double dx, dy; double tmpx, tmpy; double angle = 0.0; // first find the middle segment of the line int midPoint = (line.Vertices.Count - 1) / 2; if (line.Vertices.Count > 2) { dx = line.Vertices[midPoint + 1].X - line.Vertices[midPoint].X; dy = line.Vertices[midPoint + 1].Y - line.Vertices[midPoint].Y; } else { midPoint = 0; dx = line.Vertices[1].X - line.Vertices[0].X; dy = line.Vertices[1].Y - line.Vertices[0].Y; } if (dy == 0) { label.Rotation = 0; } else if (dx == 0) { label.Rotation = 90; } else { // calculate angle of line angle = -Math.Atan(dy / dx) + Math.PI * 0.5; angle *= (180d / Math.PI); // convert radians to degrees label.Rotation = (float)angle - 90; // -90 text orientation } tmpx = line.Vertices[midPoint].X + (dx * 0.5); tmpy = line.Vertices[midPoint].Y + (dy * 0.5); label.LabelPoint = map.WorldToImage(new SharpMap.Geometries.Point(tmpx, tmpy)); }
protected override void OnRenderInternal(Map map, LineString linestring, Graphics g) { var clonedPattern = (GraphicsPath) Pattern.Clone(); var graphicsPath = WarpPathToPath.Warp(LineStringToPath(linestring, map), clonedPattern, true, Interval); if (graphicsPath == null) return; // Fill? if (Fill != null) g.FillPath(Fill, graphicsPath); // Outline if (Line != null) g.DrawPath(Line, graphicsPath); }
/// <summary> /// Creates a deep copy of the LineString. /// </summary> /// <returns>A copy of the LineString instance.</returns> public override Geometry Clone() { LineString l = new LineString(); for (int i = 0; i < _vertices.Count; i++) { l.Vertices.Add(_vertices[i].Clone() as Point); } return l; }
private static void CalculateLabelAroundOnLineString(SharpMap.Geometries.LineString line, ref BaseLabel label, Map map, System.Drawing.Graphics g, System.Drawing.SizeF textSize) { IList <SharpMap.Geometries.Point> sPoints = line.Vertices; // only get point in enverlop of map Collection <System.Drawing.PointF> colPoint = new Collection <System.Drawing.PointF>(); bool bCheckStarted = false; for (int j = 0; j < sPoints.Count; j++) { if (map.Envelope.Grow(map.PixelSize * 10).Contains(sPoints[j])) { //points[j] = map.WorldToImage(sPoints[j]); colPoint.Add(map.WorldToImage(sPoints[j])); bCheckStarted = true; } else if (bCheckStarted == true) { // fix bug curved line out of map in center segment of line break; } } if (colPoint.Count > 1) { label.TextOnPathLabel = new SharpMap.Rendering.TextOnPath(); switch (label.Style.HorizontalAlignment) { case SharpMap.Styles.LabelStyle.HorizontalAlignmentEnum.Left: label.TextOnPathLabel.TextPathAlignTop = SharpMap.Rendering.TextPathAlign.Left; break; case SharpMap.Styles.LabelStyle.HorizontalAlignmentEnum.Right: label.TextOnPathLabel.TextPathAlignTop = SharpMap.Rendering.TextPathAlign.Right; break; case SharpMap.Styles.LabelStyle.HorizontalAlignmentEnum.Center: label.TextOnPathLabel.TextPathAlignTop = SharpMap.Rendering.TextPathAlign.Center; break; default: label.TextOnPathLabel.TextPathAlignTop = SharpMap.Rendering.TextPathAlign.Center; break; } switch (label.Style.VerticalAlignment) { case SharpMap.Styles.LabelStyle.VerticalAlignmentEnum.Bottom: label.TextOnPathLabel.TextPathPathPosition = SharpMap.Rendering.TextPathPosition.UnderPath; break; case SharpMap.Styles.LabelStyle.VerticalAlignmentEnum.Top: label.TextOnPathLabel.TextPathPathPosition = SharpMap.Rendering.TextPathPosition.OverPath; break; case SharpMap.Styles.LabelStyle.VerticalAlignmentEnum.Middle: label.TextOnPathLabel.TextPathPathPosition = SharpMap.Rendering.TextPathPosition.CenterPath; break; default: label.TextOnPathLabel.TextPathPathPosition = SharpMap.Rendering.TextPathPosition.CenterPath; break; } int idxStartPath = 0; int numberPoint = colPoint.Count; // start Optimzes Path points int step = 100; if (colPoint.Count >= step * 2) { numberPoint = step * 2;; switch (label.Style.HorizontalAlignment) { case SharpMap.Styles.LabelStyle.HorizontalAlignmentEnum.Left: //label.TextOnPathLabel.TextPathAlignTop = SharpMap.Rendering.TextPathAlign.Left; idxStartPath = 0; break; case SharpMap.Styles.LabelStyle.HorizontalAlignmentEnum.Right: //label.TextOnPathLabel.TextPathAlignTop = SharpMap.Rendering.TextPathAlign.Right; idxStartPath = colPoint.Count - step; break; case SharpMap.Styles.LabelStyle.HorizontalAlignmentEnum.Center: //label.TextOnPathLabel.TextPathAlignTop = SharpMap.Rendering.TextPathAlign.Center; idxStartPath = (int)colPoint.Count / 2 - step; break; default: //label.TextOnPathLabel.TextPathAlignTop = SharpMap.Rendering.TextPathAlign.Center; idxStartPath = (int)colPoint.Count / 2 - step; break; } } // end optimize path point System.Drawing.PointF[] points = new System.Drawing.PointF[numberPoint]; int count = 0; if (colPoint[0].X <= colPoint[colPoint.Count - 1].X) { for (int l = idxStartPath; l < numberPoint + idxStartPath; l++) { points[count] = colPoint[l]; count++; } } else { //reverse the path for (int k = numberPoint - 1 + idxStartPath; k >= idxStartPath; k--) { points[count] = colPoint[k]; count++; } } //get text size in page units ie pixels float textheight = label.Style.Font.Size; switch (label.Style.Font.Unit) { case System.Drawing.GraphicsUnit.Display: textheight = textheight * g.DpiY / 75; break; case System.Drawing.GraphicsUnit.Document: textheight = textheight * g.DpiY / 300; break; case System.Drawing.GraphicsUnit.Inch: textheight = textheight * g.DpiY; break; case System.Drawing.GraphicsUnit.Millimeter: textheight = (float)(textheight / 25.4 * g.DpiY); break; case System.Drawing.GraphicsUnit.Pixel: //do nothing break; case System.Drawing.GraphicsUnit.Point: textheight = textheight * g.DpiY / 72; break; } System.Drawing.Font topFont = new System.Drawing.Font(label.Style.Font.FontFamily, textheight, label.Style.Font.Style); // System.Drawing.Drawing2D.GraphicsPath path = new System.Drawing.Drawing2D.GraphicsPath(); path.AddLines(points); label.TextOnPathLabel.PathColorTop = System.Drawing.Color.Transparent; label.TextOnPathLabel.Text = label.Text; label.TextOnPathLabel.LetterSpacePercentage = 90; label.TextOnPathLabel.FillColorTop = new System.Drawing.SolidBrush(label.Style.ForeColor); label.TextOnPathLabel.Font = topFont; label.TextOnPathLabel.PathDataTop = path.PathData; label.TextOnPathLabel.Graphics = g; //label.TextOnPathLabel.ShowPath=true; //label.TextOnPathLabel.PathColorTop = System.Drawing.Color.YellowGreen; if (label.Style.Halo != null) { label.TextOnPathLabel.ColorHalo = label.Style.Halo; } else { label.TextOnPathLabel.ColorHalo = null;// new System.Drawing.Pen(label.Style.ForeColor, (float)0.5); } path.Dispose(); // MeasureString to get region label.TextOnPathLabel.MeasureString = true; label.TextOnPathLabel.DrawTextOnPath(); label.TextOnPathLabel.MeasureString = false; // Get Region label for CollissionDetection here. System.Drawing.Drawing2D.GraphicsPath pathRegion = new System.Drawing.Drawing2D.GraphicsPath(); if (label.TextOnPathLabel.RegionList.Count > 0) { //int idxCenter = (int)label.TextOnPathLabel.PointsText.Count / 2; //System.Drawing.Drawing2D.Matrix rotationMatrix = g.Transform.Clone();// new Matrix(); //rotationMatrix.RotateAt(label.TextOnPathLabel.Angles[idxCenter], label.TextOnPathLabel.PointsText[idxCenter]); //if (label.TextOnPathLabel.PointsTextUp.Count > 0) //{ // for (int up = label.TextOnPathLabel.PointsTextUp.Count - 1; up >= 0; up--) // { // label.TextOnPathLabel.PointsText.Add(label.TextOnPathLabel.PointsTextUp[up]); // } //} pathRegion.AddRectangles(label.TextOnPathLabel.RegionList.ToArray()); // get box for detect colission here label.Box = new LabelBox(pathRegion.GetBounds()); //g.FillRectangle(System.Drawing.Brushes.YellowGreen, label.Box); } pathRegion.Dispose(); } }
/// <summary> /// Converts a LineString to LineString tagged text format, /// </summary> /// <param name="lineString">The LineString to process.</param> /// <param name="writer">The output stream writer to Append to.</param> private static void AppendLineStringTaggedText(LineString lineString, StringWriter writer) { writer.Write("LINESTRING "); AppendLineStringText(lineString, writer); }
/// <summary> /// Convert WellKnownText to linestrings /// </summary> /// <param name="WKT"></param> /// <returns></returns> private LineString WktToLineString(string WKT) { LineString line = new LineString(); WKT = WKT.Substring(WKT.LastIndexOf('(') + 1).Split(')')[0]; string[] strPoints = WKT.Split(','); foreach (string strPoint in strPoints) { string[] coord = strPoint.Split(' '); line.Vertices.Add(new Point(double.Parse(coord[0], Map.NumberFormatEnUs), double.Parse(coord[1], Map.NumberFormatEnUs))); } return line; }
/// <summary> /// Function that actually renders the linestring /// </summary> /// <param name="map"></param> /// <param name="lineString"></param> /// <param name="g"></param> protected override void OnRenderInternal(Map map, LineString lineString, Graphics g) { var gp = new GraphicsPath(); gp.AddLines(/*LimitValues(*/lineString.TransformToImage(map)/*)*/); if (ImmediateMode) { var tmp = new List<GraphicsPath>(new[] {gp}); Symbolize(g, map, tmp); } else _graphicsPaths.Add(gp); }
/// <summary> /// Return a copy of this geometry /// </summary> /// <returns>Copy of Geometry</returns> public new LineString Clone() { LineString l = new LineString(); for (int i = 0; i < _Vertices.Count;i++ ) l.Vertices.Add(_Vertices[i].Clone()); return l; }
/// <summary> /// Renders a LineString to the map. /// </summary> /// <param name="g">Graphics reference</param> /// <param name="line">LineString to render</param> /// <param name="pen">Pen style used for rendering</param> /// <param name="map">Map reference</param> /// <param name="offset">Offset by which line will be moved to right</param> public static void DrawLineString(Graphics g, LineString line, Pen pen, Map map, float offset) { if (line.Vertices.Count > 1) { GraphicsPath gp = new GraphicsPath(); if (offset == 0) gp.AddLines(/*LimitValues(*/line.TransformToImage(map)/*, ExtremeValueLimit)*/); else gp.AddLines(OffsetRight(/*LimitValues(*/line.TransformToImage(map)/*, ExtremeValueLimit)*/, offset)); g.DrawPath(pen, gp); } }
/// <summary> /// Checks whether this instance is spatially equal to the LineString 'l' /// </summary> /// <param name="l">LineString to compare to</param> /// <returns>true of the objects are spatially equal</returns> public bool Equals(LineString l) { if (ReferenceEquals(l, null)) { return false; } if (l.Vertices.Count != Vertices.Count) { return false; } for (int i = 0; i < l.Vertices.Count; i++) { if (!l.Vertices[i].Equals(Vertices[i])) { return false; } } return true; }
/// <summary> /// Transforms a <see cref="SharpMap.Geometries.LineString"/>. /// </summary> /// <param name="l">LineString to transform</param> /// <param name="transform">MathTransform</param> /// <returns>Transformed LineString</returns> public static LineString TransformLineString(LineString l, IMathTransform transform) { try { List<double[]> points = new List<double[]>(); for (int i = 0; i < l.Vertices.Count; i++) points.Add(new double[2] {l.Vertices[i].X, l.Vertices[i].Y}); return new LineString(transform.TransformList(points)); } catch { return null; } }
/// <summary> /// Transforms a <see cref="SharpMap.Geometries.LineString"/>. /// </summary> /// <param name="l">LineString to transform</param> /// <param name="from">Source Projection</param> /// <param name="to">Target Projection</param> /// <returns>Transformed LineString</returns> public static LineString TransformLineString(LineString l, ProjectionInfo from, ProjectionInfo to) { try { List<double[]> points = new List<double[]>(); for (int i = 0; i < l.Vertices.Count; i++) points.Add(new double[] {l.Vertices[i].X, l.Vertices[i].Y}); return new LineString(TransformList(points, from, to)); } catch { return null; } }
/// <summary> /// Converts a LineString to GeoJSON LineString format, /// </summary> /// <param name="lineString">The LineString to process.</param> /// <param name="writer">The output stream writer to Append to.</param> private static void AppendLineStringTaggedText(LineString lineString, StringWriter writer) { writer.WriteLine("{"); writer.WriteLine("\"type\": \"LineString\","); writer.WriteLine("\"coordinates\": "); AppendLineStringText(lineString, writer); //writer.WriteLine("]"); writer.WriteLine("}"); }
/// <summary> /// Writes a linestring. /// </summary> /// <param name="ls">The linestring to be written.</param> /// <param name="bWriter">Stream to write to.</param> /// <param name="byteorder">Byte order</param> private static void WriteLineString(LineString ls, BinaryWriter bWriter, WkbByteOrder byteorder) { //Write the number of points in this linestring. WriteUInt32((uint)ls.Vertices.Count,bWriter,byteorder); //Loop on each vertices. foreach (Point p in ls.Vertices) WritePoint(p, bWriter, byteorder); }
/// <summary> /// Renders a LineString to the map. /// </summary> /// <param name="g">Graphics reference</param> /// <param name="line">LineString to render</param> /// <param name="pen">Pen style used for rendering</param> /// <param name="map">Map reference</param> public static void DrawLineString(Graphics g, LineString line, Pen pen, Map map) { if (line.Vertices.Count > 1) { GraphicsPath gp = new GraphicsPath(); gp.AddLines(LimitValues(line.TransformToImage(map), ExtremeValueLimit)); g.DrawPath(pen, gp); } }
private void generateLines(Collection<Geometry> geometry, Random rndGen) { int numLines = rndGen.Next(10, 100); for (int lineIndex = 0; lineIndex < numLines; lineIndex++) { LineString line = new LineString(); Collection<GeoPoint> verticies = new Collection<GeoPoint>(); int numVerticies = rndGen.Next(4, 15); GeoPoint lastPoint = new GeoPoint(rndGen.NextDouble()*1000, rndGen.NextDouble()*1000); verticies.Add(lastPoint); for (int vertexIndex = 0; vertexIndex < numVerticies; vertexIndex++) { GeoPoint nextPoint = new GeoPoint(lastPoint.X + rndGen.Next(-50, 50), lastPoint.Y + rndGen.Next(-50, 50)); verticies.Add(nextPoint); lastPoint = nextPoint; } line.Vertices = verticies; geometry.Add(line); } }
/// <summary> /// Function that actually renders the linestring /// </summary> /// <param name="map">The map</param> /// <param name="lineString">The line string to symbolize.</param> /// <param name="graphics">The graphics</param> protected abstract void OnRenderInternal(Map map, LineString lineString, Graphics graphics);
public static void DrawLineString(Graphics g, LineString line, Pen pen, Map map) { DrawLineString(g, line, pen, map, 0); }
/// <summary> /// Function to transform a linestring to a graphics path for further processing /// </summary> /// <param name="lineString">The Linestring</param> /// <param name="map">The map</param> ///// <param name="useClipping">A value indicating whether clipping should be applied or not</param> /// <returns>A GraphicsPath</returns> public static GraphicsPath LineStringToPath(LineString lineString, Map map) { var gp = new GraphicsPath(FillMode.Alternate); gp.AddLines(lineString.TransformToImage(map)); return gp; }
private static LineString CreateWKBLineString(BinaryReader reader, WkbByteOrder byteOrder) { SharpMap.Geometries.LineString l = new SharpMap.Geometries.LineString(); l.Vertices.AddRange(ReadCoordinates(reader, byteOrder)); return l; }
/// <summary> /// Very basic test to check for positve direction of Linestring /// </summary> /// <param name="line">The linestring to test</param> /// <param name="isRightToLeft">Value indicating whether labels are to be printed right to left</param> /// <returns>The positively directed linestring</returns> private static LineString PositiveLineString(LineString line, bool isRightToLeft) { var s = line.StartPoint; var e = line.EndPoint; var dx = e.X - s.X; if (isRightToLeft && dx < 0) return line; if (!isRightToLeft && dx >= 0) return line; var revCoord = new Stack<Point>(line.Vertices); return new LineString(revCoord.ToArray()); }
/// <summary> /// Checks whether this instance is spatially equal to the LineString 'l' /// </summary> /// <param name="l">LineString to compare to</param> /// <returns>true of the objects are spatially equal</returns> public bool Equals(LineString l) { if (l == null) return false; if (l.Vertices.Count != this.Vertices.Count) return false; for(int i = 0; i < l.Vertices.Count; i++) if (!l.Vertices[i].Equals(this.Vertices[i])) return false; return true; }
//private static void WarpedLabel(MultiLineString line, ref BaseLabel baseLabel, Map map) //{ // var path = MultiLineStringToPath(line, map, true); // var pathLabel = new PathLabel(baseLabel.Text, path, 0f, baseLabel.Priority, new LabelBox(path.GetBounds()), baseLabel.Style); // baseLabel = pathLabel; //} //private static void WarpedLabel(LineString line, ref BaseLabel baseLabel, Map map) //{ // var path = LineStringToPath(line, map, false); // var pathLabel = new PathLabel(baseLabel.Text, path, 0f, baseLabel.Priority, new LabelBox(path.GetBounds()), baseLabel.Style); // baseLabel = pathLabel; //} /// <summary> /// Function to transform a linestring to a graphics path for further processing /// </summary> /// <param name="lineString">The Linestring</param> /// <param name="map">The map</param> ///// <param name="useClipping">A value indicating whether clipping should be applied or not</param> /// <returns>A GraphicsPath</returns> public static GraphicsPath LineStringToPath(LineString lineString, Map map/*, bool useClipping*/) { var gp = new GraphicsPath(FillMode.Alternate); //if (!useClipping) gp.AddLines(lineString.TransformToImage(map)); //else //{ // var bb = map.Envelope; // var cohenSutherlandLineClipping = new CohenSutherlandLineClipping(bb.Left, bb.Bottom, bb.Right, bb.Top); // var clippedLineStrings = cohenSutherlandLineClipping.ClipLineString(lineString); // foreach (var clippedLineString in clippedLineStrings.LineStrings) // { // var s = clippedLineString.StartPoint; // var e = clippedLineString.EndPoint; // var dx = e.X - s.X; // //var dy = e.Y - s.Y; // LineString revcls = null; // if (dx < 0) // revcls = ReverseLineString(clippedLineString); // gp.StartFigure(); // gp.AddLines(revcls == null ? clippedLineString.TransformToImage(map) : revcls.TransformToImage(map)); // } //} return gp; }
/// <summary> /// Function that actually renders the linestring /// </summary> /// <param name="map"></param> /// <param name="lineString"></param> /// <param name="g"></param> protected override void OnRenderInternal(Map map, LineString lineString, Graphics g) { var gp = new GraphicsPath(); gp.AddLines(/*LimitValues(*/lineString.TransformToImage(map)/*)*/); _graphicsPaths.Add(gp); }
//private static LineString ReverseLineString(LineString clippedLineString) //{ // var coords = new Stack<Point>(clippedLineString.Vertices); // return new LineString(coords.ToArray()); //} ///// <summary> ///// Function to transform a linestring to a graphics path for further processing ///// </summary> ///// <param name="multiLineString">The Linestring</param> ///// <param name="map">The map</param> ///// <param name="useClipping">A value indicating whether clipping should be applied or not</param> ///// <returns>A GraphicsPath</returns> //public static GraphicsPath MultiLineStringToPath(MultiLineString multiLineString, Map map, bool useClipping) //{ // var gp = new GraphicsPath(FillMode.Alternate); // foreach (var lineString in multiLineString.LineStrings) // gp.AddPath(LineStringToPath(lineString, map, useClipping), false); // return gp; //} //private static GraphicsPath LineToGraphicsPath(LineString line, Map map) //{ // GraphicsPath path = new GraphicsPath(); // path.AddLines(line.TransformToImage(map)); // return path; //} private static void CalculateLabelOnLinestring(LineString line, ref BaseLabel baseLabel, Map map) { double dx, dy; var label = baseLabel as Label; // first find the middle segment of the line int midPoint = (line.Vertices.Count - 1)/2; if (line.Vertices.Count > 2) { dx = line.Vertices[midPoint + 1].X - line.Vertices[midPoint].X; dy = line.Vertices[midPoint + 1].Y - line.Vertices[midPoint].Y; } else { midPoint = 0; dx = line.Vertices[1].X - line.Vertices[0].X; dy = line.Vertices[1].Y - line.Vertices[0].Y; } if (dy == 0) label.Rotation = 0; else if (dx == 0) label.Rotation = 90; else { // calculate angle of line double angle = -Math.Atan(dy/dx) + Math.PI*0.5; angle *= (180d/Math.PI); // convert radians to degrees label.Rotation = (float) angle - 90; // -90 text orientation } double tmpx = line.Vertices[midPoint].X + (dx*0.5); double tmpy = line.Vertices[midPoint].Y + (dy*0.5); label.LabelPoint = map.WorldToImage(new Point(tmpx, tmpy)); }
private static LineString CreateWKBLineString(BinaryReader reader, WkbByteOrder byteOrder) { LineString l = new LineString(); //l.Vertices.AddRange(ReadCoordinates(reader, byteOrder)); Point[] arrPoint = ReadCoordinates(reader, byteOrder); for (int i = 0; i < arrPoint.Length; i++) l.Vertices.Add(arrPoint[i]); return l; }
/// <summary> /// Transforms a <see cref="SharpMap.Geometries.LineString"/>. /// </summary> /// <param name="l">LineString to transform</param> /// <param name="transform">MathTransform</param> /// <returns>Transformed LineString</returns> public static LineString TransformLineString(LineString l, IMathTransform transform) { try { return new LineString(transform.TransformList(l.Vertices)); } catch { return null; } }
/// <summary> /// Converts a LineString to <LineString Text> format, then /// Appends it to the writer. /// </summary> /// <param name="lineString">The LineString to process.</param> /// <param name="writer">The output stream to Append to.</param> private static void AppendLineStringText(LineString lineString, StringWriter writer) { if (lineString == null || lineString.IsEmpty()) writer.Write("EMPTY"); else { writer.Write("("); for (int i = 0; i < lineString.NumPoints; i++) { if (i > 0) writer.Write(", "); AppendCoordinate(lineString.Vertices[i], writer); } writer.Write(")"); } }
private static LineString CreateWKBLineString(BinaryReader reader, WkbByteOrder byteOrder) { SharpMap.Geometries.LineString l = new SharpMap.Geometries.LineString(); l.Vertices.AddRange(ReadCoordinates(reader, byteOrder)); return(l); }