//private Map endpointMap; private Coordinate[] ComputeBoundaryCoordinates(MultiLineString mLine) { var bdyPts = new List <Coordinate>(); _endpointMap = new SortedDictionary <Coordinate, Counter>(); for (int i = 0; i < mLine.NumGeometries; i++) { var line = (LineString)mLine.GetGeometryN(i); if (line.NumPoints == 0) { continue; } AddEndpoint(line.GetCoordinateN(0)); AddEndpoint(line.GetCoordinateN(line.NumPoints - 1)); } foreach (var entry in _endpointMap) { var counter = entry.Value; int valence = counter.Count; if (_bnRule.IsInBoundary(valence)) { bdyPts.Add(entry.Key); } } return(CoordinateArrays.ToCoordinateArray((ICollection <Coordinate>)bdyPts)); }
/// <summary> /// Converts a MultiLineString to <MultiLineString Text> /// format, then Appends it to the writer. /// </summary> /// <param name="multiLineString">The MultiLineString to process.</param> /// <param name="level"></param> /// <param name="indentFirst"></param> /// <param name="writer">The output stream writer to Append to.</param> protected void AppendMultiLineStringText(MultiLineString multiLineString, int level, bool indentFirst, StringWriter writer) { if (multiLineString.IsEmpty()) { writer.Write("EMPTY"); } else { int level2 = level; bool doIndent = indentFirst; writer.Write("("); for (int i = 0; i < multiLineString.GetNumGeometries(); i++) { if (i > 0) { writer.Write(", "); level2 = level + 1; doIndent = true; } //AppendLineStringText((LineString) multiLineString.GetGeometryN(i), level2, doIndent, writer); AppendLineStringText((LineString)multiLineString.GetGeometryN(i), level2, doIndent, writer); } writer.Write(")"); } }
/// <summary> /// /// </summary> /// <param name="multiLineString"></param> /// <param name="writer"></param> public virtual void Write(MultiLineString multiLineString, BinaryWriter writer) { writer.Write((int)ShapeGeometryTypes.LineString); // Write BoundingBox WriteBoundingBox(multiLineString, writer); // Write NumParts and NumPoints writer.Write((int)multiLineString.NumGeometries); writer.Write((int)multiLineString.NumPoints); // Write IndexParts int count = 0; writer.Write((int)count); // Write linestrings index for (int i = 0; i < multiLineString.NumGeometries; i++) { // Write internal holes index count += multiLineString.GetGeometryN(i).NumPoints; if (count == multiLineString.NumPoints) { break; } writer.Write((int)count); } // Write Coordinates for (int i = 0; i < multiLineString.NumPoints; i++) { Write(multiLineString.Coordinates[i], writer); } }
/// <summary> /// Writes to the given stream the equilivent shape file record given a Geometry object. /// </summary> /// <param name="geometry">The geometry object to write.</param> /// <param name="file">The stream to write to.</param> /// <param name="geometryFactory">The geometry factory to use.</param> public override void Write(Geometry geometry, System.IO.BinaryWriter file, GeometryFactory geometryFactory) { MultiLineString multi = (MultiLineString)geometry; file.Write(int.Parse(Enum.Format(typeof(ShapeType), this.ShapeType, "d"))); Envelope box = multi.GetEnvelopeInternal(); file.Write(box.MinX); file.Write(box.MinY); file.Write(box.MaxX); file.Write(box.MaxY); int numParts = multi.GetNumGeometries(); int numPoints = multi.GetNumPoints(); file.Write(numParts); file.Write(numPoints); //LineString[] lines = new LineString[numParts]; // write the offsets int offset = 0; for (int i = 0; i < numParts; i++) { Geometry g = multi.GetGeometryN(i); file.Write(offset); offset = offset + g.GetNumPoints(); } Coordinate external; for (int part = 0; part < numParts; part++) { Coordinates points = multi.GetGeometryN(part).GetCoordinates(); for (int i = 0; i < points.Count; i++) { external = geometryFactory.PrecisionModel.ToExternal(points[i]); file.Write(external.X); file.Write(external.Y); } } }
/// <summary> /// Writes to the given stream the equilivent shape file record given a Geometry object. /// </summary> /// <param name="geometry">The geometry object to write.</param> /// <param name="file">The stream to write to.</param> /// <param name="geometryFactory">The geometry factory to use.</param> public override void Write(IGeometry geometry, System.IO.BinaryWriter file, IGeometryFactory geometryFactory) { MultiLineString multi = (MultiLineString)geometry; file.Write(int.Parse(Enum.Format(typeof(ShapeGeometryTypes), this.ShapeType, "d"))); IEnvelope box = multi.EnvelopeInternal; file.Write(box.MinX); file.Write(box.MinY); file.Write(box.MaxX); file.Write(box.MaxY); int numParts = multi.NumGeometries; int numPoints = multi.NumPoints; file.Write(numParts); file.Write(numPoints); // write the offsets int offset = 0; for (int i = 0; i < numParts; i++) { IGeometry g = multi.GetGeometryN(i); file.Write(offset); offset = offset + g.NumPoints; } Coordinate external; for (int part = 0; part < numParts; part++) { CoordinateList points = new CoordinateList(multi.GetGeometryN(part).Coordinates); for (int i = 0; i < points.Count; i++) { // external = geometryFactory.PrecisionModel.ToExternal((Coordinate)points[i]); external = (Coordinate)points[i]; file.Write(external.X); file.Write(external.Y); } } }
public static List <List <double[]> > MultiLineStringSerialize(MultiLineString multiLineString) { List <List <double[]> > serilizedLineStrings = new List <List <double[]> >(); for (int i = 0; i < multiLineString.Count; ++i) { LineString l = (LineString)multiLineString.GetGeometryN(i); serilizedLineStrings.Add(LineStringSerialize(l)); } return(serilizedLineStrings); }
/** erzeugt aus einem MultiLineString eine Collection von LineString's * wo die zusammengehörende Teile zu einem LineString zusammengefasst werden * @param geometry * @return */ public static List <ILineString> linesFromMultiLine(IGeometryFactory gf, MultiLineString geometry) { List <ILineString> lines = new List <ILineString>(); for (int i = 0; i < geometry.NumGeometries; i++) { lines.Add((LineString)geometry.GetGeometryN(i)); } return(mergeLines(gf, lines)); }
public void TestMultiLineString1() { string wkt = "MULTILINESTRING (( 10.05 10.28 , 20.95 20.89 ),( 20.95 20.89, 31.92 21.45)) "; GeometryFactory factory = new GeometryFactory(); IGeometry geometry = factory.CreateFromWKT(wkt); MultiLineString multilineString = (MultiLineString)geometry; Assertion.AssertEquals("Multilinestring 1", 2, multilineString.GetNumGeometries()); LineString linestring1 = (LineString)multilineString.GetGeometryN(0); LineString linestring2 = (LineString)multilineString.GetGeometryN(1); Assertion.AssertEquals("MLS 1", 10.05, linestring1.GetCoordinates()[0].X); Assertion.AssertEquals("MLS 2", 10.28, linestring1.GetCoordinates()[0].Y); Assertion.AssertEquals("MLS 3", 20.95, linestring1.GetCoordinates()[1].X); Assertion.AssertEquals("MLS 4", 20.89, linestring1.GetCoordinates()[1].Y); Assertion.AssertEquals("MLS 1", 20.95, linestring2.GetCoordinates()[0].X); Assertion.AssertEquals("MLS 2", 20.89, linestring2.GetCoordinates()[0].Y); Assertion.AssertEquals("MLS 3", 31.92, linestring2.GetCoordinates()[1].X); Assertion.AssertEquals("MLS 4", 21.45, linestring2.GetCoordinates()[1].Y); string wkt2 = ((MultiLineString)multilineString).ToText(); Assertion.AssertEquals("wkt", true, Compare.WktStrings(wkt, wkt2)); }
/// <summary> /// Tests whether a <see cref="Geometry" /> is sequenced correctly. /// <see cref="LineString" />s are trivially sequenced. /// <see cref="MultiLineString" />s are checked for correct sequencing. /// Otherwise, <c>IsSequenced</c> is defined /// to be <c>true</c> for geometries that are not lineal. /// </summary> /// <param name="geom">The <see cref="Geometry" /> to test.</param> /// <returns> /// <c>true</c> if the <see cref="Geometry" /> is sequenced or is not lineal. /// </returns> public static bool IsSequenced(Geometry geom) { if (!(geom is MultiLineString)) { return(true); } MultiLineString mls = geom as MultiLineString; // The nodes in all subgraphs which have been completely scanned ISet <ICoordinate> prevSubgraphNodes = new SortedSet <ICoordinate>(); ICoordinate lastNode = null; IList <ICoordinate> currNodes = new List <ICoordinate>(); for (int i = 0; i < mls.NumGeometries; i++) { LineString line = (LineString)mls.GetGeometryN(i); ICoordinate startNode = line.GetCoordinateN(0); ICoordinate endNode = line.GetCoordinateN(line.NumPoints - 1); /* * If this linestring is connected to a previous subgraph, geom is not sequenced */ if (prevSubgraphNodes.Contains(startNode)) { return(false); } if (prevSubgraphNodes.Contains(endNode)) { return(false); } if (lastNode != null && startNode != lastNode) { // start new connected sequence prevSubgraphNodes.AddAll(currNodes); currNodes.Clear(); } currNodes.Add(startNode); currNodes.Add(endNode); lastNode = endNode; } return(true); }
/// <summary> /// Clips a <see cref="MultiLineString"/> to the bounding box defined by <see cref="CohenSutherlandLineClipping(double,double,double,double)"/>. /// </summary> /// <param name="lineStrings">The multi-line string to clip</param> /// <returns>A (possibly multi) line string</returns> public MultiLineString ClipLineString(MultiLineString lineStrings) { var clippedLineStringList = new List <LineString>(); for (var i = 0; i < lineStrings.NumGeometries; i++) { var s = (LineString)lineStrings.GetGeometryN(i); var clippedLineStrings = ClipLineString(s); for (var j = 0; j < clippedLineStrings.NumGeometries; j++) { var clippedLineString = (LineString)clippedLineStrings.GetGeometryN(j); clippedLineStringList.Add(clippedLineString); } } return(lineStrings.Factory.CreateMultiLineString(clippedLineStringList.ToArray())); }
} // public int Locate( Coordinate p, Geometry geom ) private void ComputeLocation(Coordinate p, Geometry geom) { if (geom is LineString) { UpdateLocationInfo(Locate(p, (LineString)geom)); } if (geom is LinearRing) { UpdateLocationInfo(Locate(p, (LinearRing)geom)); } else if (geom is Polygon) { UpdateLocationInfo(Locate(p, (Polygon)geom)); } else if (geom is MultiLineString) { MultiLineString ml = (MultiLineString)geom; for (int i = 0; i < ml.GetNumGeometries(); i++) { LineString l = (LineString)ml.GetGeometryN(i); UpdateLocationInfo(Locate(p, l)); } // for ( int i = 0; i < ml.NumGeometries; i++ ) } else if (geom is MultiPolygon) { MultiPolygon mpoly = (MultiPolygon)geom; for (int i = 0; i < mpoly.GetNumGeometries(); i++) { Polygon poly = (Polygon)mpoly.GetGeometryN(i); UpdateLocationInfo(Locate(p, poly)); } // for (int i = 0; i < mpoly.NumGeometries; i++) } else if (geom is GeometryCollection) { GeometryCollection gc = geom as GeometryCollection; foreach (Geometry g2 in gc) { if (g2 != geom) { ComputeLocation(p, g2); } } // foreach( Geometry g2 in gc ) } // else if ( geom is GeometryCollection ) } // private void ComputeLocation(Coordinate p, Geometry geom)
private bool IsWithinToleranceOfBoundary(Coordinate pt) { for (int i = 0; i < _linework.NumGeometries; i++) { var line = (LineString)_linework.GetGeometryN(i); var seq = line.CoordinateSequence; for (int j = 0; j < seq.Count - 1; j++) { seq.GetCoordinate(j, _seg.P0); seq.GetCoordinate(j + 1, _seg.P1); double dist = _seg.Distance(pt); if (dist <= _boundaryDistanceTolerance) { return(true); } } } return(false); }
/// <summary> /// Transforms a <see cref="MultiLineString"/> geometry. /// </summary> /// <param name="geom">The <c>MultiLineString</c> to transform</param> /// <param name="parent">The parent geometry</param> /// <returns>A <c>MultiLineString</c></returns> protected virtual Geometry TransformMultiLineString(MultiLineString geom, Geometry parent) { var transGeomList = new List <Geometry>(); for (int i = 0; i < geom.NumGeometries; i++) { var transformGeom = TransformLineString((LineString)geom.GetGeometryN(i), geom); if (transformGeom == null) { continue; } if (transformGeom.IsEmpty) { continue; } transGeomList.Add(transformGeom); } return(Factory.BuildGeometry(transGeomList)); }
/// <summary> /// Writes a MultiLineString. /// </summary> /// <param name="mls">The MultiLineString to be written.</param> /// <param name="bWriter">Stream to write to.</param> /// <param name="byteorder">Byte order</param> private static void WriteMultiLineString(MultiLineString mls, BinaryWriter bWriter, WkbByteOrder byteorder) { //Write the number of linestrings. int num = mls.NumGeometries; WriteUInt32((uint)num, bWriter, byteorder); //Loop on the number of linestrings. //NOTE: by contract, the first item returned // from GetEnumerator (i.e. using foreach) is the MultiLineString itself! for (int i = 0; i < num; i++) { LineString ls = (LineString)mls.GetGeometryN(i); //Write LineString Header bWriter.Write((byte)byteorder); WriteUInt32((uint)WKBGeometryType.wkbLineString, bWriter, byteorder); //Write each linestring. WriteLineString(ls, bWriter, byteorder); } }
/// <summary> /// Converts a MultiLineString to <MultiLineString Text> /// format, then Appends it to the writer. /// </summary> /// <param name="MultiLineString">The MultiLineString to process.</param> /// <param name="writer">The output stream writer to Append to.</param> private static void AppendMultiLineStringText(MultiLineString MultiLineString, StringWriter writer) { if (MultiLineString == null || MultiLineString.IsEmpty) { writer.Write("EMPTY"); } else { writer.Write("("); for (var i = 0; i < MultiLineString.NumGeometries; i++) { if (i > 0) { writer.Write(", "); } AppendLineStringText((LineString)MultiLineString.GetGeometryN(i), writer); } writer.Write(")"); } }
/// <summary> /// Converts a MultiLineString to <MultiLineString Text> /// format, then Appends it to the writer. /// </summary> /// <param name="multiLineString">The MultiLineString to process.</param> /// <param name="writer">The output stream writer to Append to.</param> protected void AppendMultiLineStringText(MultiLineString multiLineString, TextWriter writer) { if (multiLineString.IsEmpty()) { writer.Write("EMPTY"); } else { for (int i = 0; i < multiLineString.GetNumGeometries(); i++) { if (i > 0) { writer.Write(", "); } //AppendLineStringText((LineString) multiLineString.GetGeometryN(i), level2, doIndent, writer); AppendLineStringText((LineString)multiLineString.GetGeometryN(i), writer); } //writer.Write(")"); } }
/// <summary> /// Writes <paramref name="multiLineString"/> to a stream using <paramref name="writer"/> /// </summary> /// <param name="multiLineString">The <c>MultiLineString</c> to write</param> /// <param name="writer">The writer to use</param> public void Write(MultiLineString multiLineString, BinaryWriter writer) { writer.Write((int)ShapeGeometryType.LineString); // Write BoundingBox WriteBoundingBox(multiLineString.EnvelopeInternal, writer); // Write NumParts and NumPoints writer.Write((int)multiLineString.NumGeometries); writer.Write((int)multiLineString.NumPoints); // Write IndexParts int count = 0; writer.Write((int)count); var seq = multiLineString.Factory.CoordinateSequenceFactory.Create(multiLineString.NumPoints, ((LineString)multiLineString[0]).CoordinateSequence.Ordinates); // Write LineString's index for (int i = 0; i < multiLineString.NumGeometries; i++) { // Write internal holes index var ls = ((LineString)multiLineString.GetGeometryN(i)).CoordinateSequence; Copy(ls, 0, seq, count, ls.Count); count += ls.Count; if (count == multiLineString.NumPoints) { break; } writer.Write((int)count); } // Write Coordinates WriteCoordinates(seq, writer, seq.Ordinates); }
public void test_Geometry() { LineString[] linestrings = new LineString[2]; Coordinates coords1 = new Coordinates(); Coordinate coord = new Coordinate(5, 3); coords1.Add(coord); coord = new Coordinate(4, 5); coords1.Add(coord); coord = new Coordinate(3, 4); coords1.Add(coord); GeometryFactory gf = new GeometryFactory(_precMod, _sRID); LineString ls = gf.CreateLineString(coords1); linestrings[0] = ls; Coordinates coords2 = new Coordinates(); coord = new Coordinate(2, 7); coords2.Add(coord); coord = new Coordinate(9, 2); coords2.Add(coord); coord = new Coordinate(7, 9); coords2.Add(coord); ls = gf.CreateLineString(coords2); linestrings[1] = ls; MultiLineString mls = gf.CreateMultiLineString(linestrings); Assertion.AssertEquals("Geometry-1: ", "LineString:(5, 3, NaN),(4, 5, NaN),(3, 4, NaN)", mls.GetGeometryN(0).ToString()); Assertion.AssertEquals("Geometry-2: ", "LineString:(2, 7, NaN),(9, 2, NaN),(7, 9, NaN)", mls.GetGeometryN(1).ToString()); }