//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());
}
