//private Map endpointMap;
private Coordinate[] ComputeBoundaryCoordinates(IMultiLineString mLine)
{
IList<Coordinate> bdyPts = new List<Coordinate>();
_endpointMap = new OrderedDictionary<Coordinate, Counter>();
for (int i = 0; i < mLine.NumGeometries; i++)
{
ILineString line = (ILineString)mLine.GetGeometryN(i);
if (line.NumPoints == 0)
continue;
AddEndpoint(line.GetCoordinateN(0));
AddEndpoint(line.GetCoordinateN(line.NumPoints - 1));
}
foreach (KeyValuePair<Coordinate, Counter> entry in _endpointMap)
{
Counter counter = entry.Value;
int valence = counter.Count;
if (_bnRule.IsInBoundary(valence))
{
bdyPts.Add(entry.Key);
}
}
return CoordinateArrays.ToCoordinateArray(bdyPts);
}
public static void DrawMultiLineString(Graphics g, IMultiLineString lines, Pen pen, Map map, float offset)
{
for(var i = 0; i < lines.NumGeometries; i++)
{
var line = (ILineString) lines[i];
DrawLineString(g, line, pen, map, offset);
}
}
public static void DrawMultiLineString(D2D1.RenderTarget renderTarget, D2D1.Factory factory, IMultiLineString lines, D2D1.Brush pen, float penWidth, D2D1.StrokeStyle penStrokeStyle, Map map, float offset)
{
for (var i = 0; i < lines.NumGeometries; i++)
{
var line = (ILineString)lines[i];
DrawLineString(renderTarget, factory, line, pen, penWidth, penStrokeStyle, map, offset);
}
}
private static void GeometryToSqlGeometry(IMultiLineString geom, SqlGeometryBuilder bldr)
{
bldr.BeginGeometry(OpenGisGeometryType.MultiLineString);
for (int i = 0, c = geom.NumGeometries; i < c; i++)
GeometryToSqlGeometry(geom.Geometries[i] as ILineString, bldr);
bldr.EndGeometry();
}
/// <summary>
/// Converts the Geography Markup representation.
/// </summary>
/// <param name="geometry">The geometry.</param>
/// <returns>The GM representation of the <paramref name="geometry" /> in XElement.</returns>
private static XElement CreateGMXElement(IMultiLineString geometry)
{
XElement multiLineStringElement = new XElement(_nameSpace + "MultiLineString", new XAttribute(XNamespace.Xmlns + "gml", _nameSpace));
for (int i = 0; i < geometry.Count(); ++i)
{
XElement lineStringMemberElement = new XElement(_nameSpace + "LineStringMember");
lineStringMemberElement.Add(CreateGMXElement(geometry[i]));
multiLineStringElement.Add(lineStringMemberElement);
}
return(multiLineStringElement);
}
/// <summary>
/// Writes out a MultiLineString to TopoJSON file.
/// </summary>
/// <param name="mlstr">The MultiLineString.</param>
private void WriteMultiLineString(IMultiLineString mlstr)
{
bool is3D = mlstr.SpatialDimension == 3;
_jsonwriter.WriteStartArray();
foreach (ILineString l in mlstr)
{
WriteLineString(l);
}
_jsonwriter.WriteEndArray();
}
/// <summary>
///
/// </summary>
/// <param name="multiLineString"></param>
/// <param name="writer"></param>
protected void Write(IMultiLineString multiLineString, BinaryWriter writer)
{
//WriteByteOrder(writer); // LittleIndian
WriteHeader(writer, multiLineString);
//if (Double.IsNaN(multiLineString.Coordinate.Z))
// writer.Write((int)WKBGeometryTypes.WKBMultiLineString);
//else writer.Write((int)WKBGeometryTypes.WKBMultiLineStringZ);
writer.Write(multiLineString.NumGeometries);
for (var i = 0; i < multiLineString.NumGeometries; i++)
{
Write(multiLineString.Geometries[i] as ILineString, writer);
}
}
/// <summary>
/// Transforms a <see cref="MultiLineString" /> object.
/// </summary>
/// <param name="factory"></param>
/// <param name="lines"></param>
/// <param name="transform"></param>
/// <returns></returns>
public static IMultiLineString TransformMultiLineString(IGeometryFactory factory,
IMultiLineString lines, IMathTransform transform)
{
var geometries = lines.Geometries;
var strings = new List <ILineString>(geometries.Length);
foreach (var ls in lines.Geometries)
{
var item = TransformLineString(factory, (ILineString)ls, transform);
strings.Add(item);
}
return(factory.CreateMultiLineString(strings.ToArray()));
}
/// <summary>
/// Method to write a multi linestring geometry to the <paramref name="writer"/>
/// </summary>
/// <param name="lines">The multi linestring geometry</param>
/// <param name="writer">The JSON writer</param>
public static void Write(IMultiLineString lines, TextWriter writer)
{
if (lines == null)
{
return;
}
if (writer == null)
{
throw new ArgumentNullException("writer", "A valid text writer object is required");
}
Write(lines, CreateWriter(writer));
}
/// <summary>
/// Converts MultiLineString to WKT format and appends WKT representation to the output stream.
/// </summary>
/// <param name="mls">The MultiLineString to be converted.</param>
/// <param name="writer">The output Stream to Append WKT representation to.</param>
private static void AppendMultiLineStringTaggedText(IMultiLineString mls, TextWriter writer)
{
writer.Write("multilinestring ");
string dimension = WktWriter.GetDimensionText(mls);
if (string.IsNullOrEmpty(dimension) == false)
{
writer.Write(dimension);
writer.Write(" ");
}
WktWriter.AppendMultiLineStringText(mls, writer);
}
private static void WriteMultiLineStringCoordinates(StringBuilder sb, IMultiLineString multiLineString,
string coordinateFormatString)
{
sb.Append("[");
for (int i = 0; i < multiLineString.Count; i++)
{
WriteLineStringCoordinates(sb, multiLineString[i], coordinateFormatString);
if (i < multiLineString.Count - 1)
{
sb.Append(",");
}
}
sb.Append("]");
}
public Polyline WritePolyline(IMultiLineString lineString)
{
var polyline = new Polyline();
for (var i = 0; i < lineString.Coordinates.Length; i++)
{
var coordinate = lineString.Coordinates[i];
var point2D = new Point2d(coordinate.X, coordinate.Y);
polyline.AddVertexAt(i, point2D, 0.0, 0.0, 0.0);
}
//polyline.Closed = lineString.StartPoint.EqualsExact(lineString.EndPoint);
polyline.MinimizeMemory();
return(polyline);
}
private SdoGeometry Write(IMultiLineString multiLineString)
{
var elemInfoList = new List <decimal>();
var ordinateList = new List <decimal>();
ProcessMultiLineString(multiLineString, elemInfoList, ordinateList, 1);
return(new SdoGeometry
{
SdoGtype = GType(multiLineString),
Sdo_Srid = multiLineString.SRID,
ElemArray = elemInfoList.ToArray(),
OrdinatesArray = ordinateList.ToArray(),
});
}
private static DSMultiLineString FromMultiLineString(IMultiLineString geometry, DSGeometryFactory factory, bool setUserData)
{
var dsLineStrings = new DotSpatial.Topology.IBasicLineString[geometry.NumGeometries];
for (var i = 0; i < dsLineStrings.Length; i++)
{
dsLineStrings[i] = FromLineString((ILineString)geometry.GetGeometryN(i), factory, setUserData);
}
var result = factory.CreateMultiLineString(dsLineStrings);
if (setUserData)
{
result.UserData = geometry.UserData;
}
return(result);
}
private static GeoAPIMultiLineString FromMultiLineString(IMultiLineString geometry, GeoAPIGeometryFactory factory, bool copyUserData)
{
var dsLineStrings = new GeoAPILineString[geometry.NumGeometries];
for (var i = 0; i < dsLineStrings.Length; i++)
{
dsLineStrings[i] = FromLineString((ILineString)geometry.GetGeometryN(i), factory, copyUserData);
}
var result = factory.CreateMultiLineString(dsLineStrings);
if (copyUserData)
{
result.UserData = geometry.UserData;
}
return(result);
}
/// <summary>
///
/// </summary>
/// <param name="multiLineString"></param>
/// <param name="writer"></param>
protected void Write(IMultiLineString multiLineString, BinaryWriter writer)
{
WriteByteOrder(writer); // LittleIndian
if (Double.IsNaN(multiLineString.Coordinate.Z))
{
writer.Write((int)WKBGeometryTypes.WKBMultiLineString);
}
else
{
writer.Write((int)WKBGeometryTypes.WKBMultiLineStringZ);
}
writer.Write((int)multiLineString.NumGeometries);
for (int i = 0; i < multiLineString.NumGeometries; i++)
{
Write(multiLineString.Geometries[i] as ILineString, writer);
}
}
private IGeometry BoundaryMultiLineString(IMultiLineString mLine)
{
if (_geom.IsEmpty)
{
return GetEmptyMultiPoint();
}
Coordinate[] bdyPts = ComputeBoundaryCoordinates(mLine);
// return Point or MultiPoint
if (bdyPts.Length == 1)
{
return _geomFact.CreatePoint(bdyPts[0]);
}
// this handles 0 points case as well
return _geomFact.CreateMultiPoint(bdyPts);
}
private IGeometry BoundaryMultiLineString(IMultiLineString mLine)
{
if (_geom.IsEmpty)
{
return(GetEmptyMultiPoint());
}
Coordinate[] bdyPts = ComputeBoundaryCoordinates(mLine);
// return Point or MultiPoint
if (bdyPts.Length == 1)
{
return(_geomFact.CreatePoint(bdyPts[0]));
}
// this handles 0 points case as well
return(_geomFact.CreateMultiPoint(bdyPts));
}
/// <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(IGeometry geom)
{
if (!(geom is IMultiLineString))
{
return(true);
}
IMultiLineString mls = geom as IMultiLineString;
// 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++)
{
ILineString line = (ILineString)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>
/// Converts the multi line string to Geography Markup Language (GML) representation.
/// </summary>
/// <param name="multiLineString">The multi line string.</param>
/// <param name="partial">Indicates that the geometry is part of another.</param>
/// <param name="identifier">The geometry identifier.</param>
/// <returns>The converted multi line string.</returns>
private static XElement ToMarkupInternal(IMultiLineString multiLineString, Boolean partial, String identifier = null)
{
XElement element = new XElement(Namespace + "MultiLineString");
ConvertIdentifier(element, identifier);
if (!partial)
{
ConvertReferenceSystem(element, multiLineString.ReferenceSystem, multiLineString.CoordinateDimension);
}
foreach (ILineString lineString in multiLineString)
{
element.Add(new XElement(Namespace + "LineStringMember", ToMarkupInternal(lineString, true)));
}
return(element);
}
/// <summary>
/// Clips a <see cref="IMultiLineString"/> 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 IMultiLineString ClipLineString(IMultiLineString lineStrings)
{
var clippedLineStringList = new List <ILineString>();
for (var i = 0; i < lineStrings.NumGeometries; i++)
{
var s = (ILineString)lineStrings.GetGeometryN(i);
var clippedLineStrings = ClipLineString(s);
for (var j = 0; j < clippedLineStrings.NumGeometries; j++)
{
var clippedLineString = (ILineString)clippedLineStrings.GetGeometryN(j);
clippedLineStringList.Add(clippedLineString);
}
}
return(lineStrings.Factory.CreateMultiLineString(clippedLineStringList.ToArray()));
}
private IMultiLineString ReadMultiLine(int dim, int lrsDim,
SdoGeometry sdoGeom)
{
bool lrs = sdoGeom.LRS > 0;
decimal[] info = sdoGeom.ElemArray;
ILineString[] lines =
lrs
? new MLineString[sdoGeom.ElemArray.Length]
: new LineString[sdoGeom.ElemArray.Length];
int i = 0;
while (i < info.Length)
{
ICoordinateSequence cs = null;
//if (info.getElementType(i).isCompound())
//{
// int numCompounds = info.getNumCompounds(i);
// cs = Add(cs, GetCompoundCSeq(i + 1, i + numCompounds, sdoGeom));
// LineString line =
// lrs
// ? factory.CreateMultiLineString(cs)
// : factory.CreateLineString(cs);
// lines[i] = line;
// i += 1 + numCompounds;
//}
//else
//{
cs = Add(cs, GetElementCSeq(i, sdoGeom, false));
//LineString line = lrs ? (LineString)factory.CreateMultiLineString(cs) : factory.CreateLineString(cs);
ILineString line = factory.CreateLineString(cs);
lines[i] = line;
i++;
//}
}
IMultiLineString mls = lrs
? factory.CreateMultiLineString((MLineString[])lines)
: factory.CreateMultiLineString(lines);
mls.SRID = (int)sdoGeom.Sdo_Srid;
return(mls);
}
/// <summary>
///
/// </summary>
/// <param name="geom"></param>
/// <param name="parent"></param>
/// <returns></returns>
protected virtual IGeometry TransformMultiLineString(IMultiLineString geom, IGeometry parent)
{
ArrayList transGeomList = new ArrayList();
for (int i = 0; i < geom.NumGeometries; i++)
{
IGeometry transformGeom = TransformLineString((ILineString)geom.GetGeometryN(i), geom);
if (transformGeom == null)
{
continue;
}
if (transformGeom.IsEmpty)
{
continue;
}
transGeomList.Add(transformGeom);
}
return(factory.BuildGeometry(transGeomList));
}
/// <summary>
///
/// </summary>
/// <param name="p"></param>
/// <param name="geom"></param>
private void ComputeLocation(Coordinate p, IGeometry geom)
{
if (geom is IPoint)
{
UpdateLocationInfo(Locate(p, (IPoint)geom));
}
if (geom is ILineString)
{
UpdateLocationInfo(Locate(p, (ILineString)geom));
}
else if (geom is Polygon)
{
UpdateLocationInfo(Locate(p, (IPolygon)geom));
}
else if (geom is IMultiLineString)
{
IMultiLineString ml = (IMultiLineString)geom;
foreach (ILineString l in ml.Geometries)
{
UpdateLocationInfo(Locate(p, l));
}
}
else if (geom is IMultiPolygon)
{
IMultiPolygon mpoly = (IMultiPolygon)geom;
foreach (IPolygon poly in mpoly.Geometries)
{
UpdateLocationInfo(Locate(p, poly));
}
}
else if (geom is IGeometryCollection)
{
IEnumerator geomi = new GeometryCollectionEnumerator((IGeometryCollection)geom);
while (geomi.MoveNext())
{
IGeometry g2 = (IGeometry)geomi.Current;
if (g2 != geom)
{
ComputeLocation(p, g2);
}
}
}
}
/// <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)
{
IMultiLineString multi = (IMultiLineString)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;
}
ICoordinate 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 = points[i];
file.Write(external.X);
file.Write(external.Y);
}
}
}
/// <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(IMultiLineString 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((ILineString)multiLineString.GetGeometryN(i), writer);
}
writer.Write(")");
}
}
/// <summary>
/// Computes distance of a point from MultiLineString
/// </summary>
/// <param name="point">The point</param>
/// <param name="multilinestring">The MultiLineString</param>
/// <returns>The distance of the point from the MultiLineString</returns>
public double ComputeDistance(IPoint point, IMultiLineString multilinestring)
{
if (point.Position == Coordinate.Empty || multilinestring.Geometries.Count() == 0)
{
return(double.NaN);
}
double minDistance = double.PositiveInfinity;
foreach (var linestring in multilinestring.Geometries)
{
double distance = this.ComputeDistance(point, linestring);
if (distance < minDistance)
{
minDistance = distance;
}
}
return(minDistance);
}
/// <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(IMultiLineString 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 IMultiLineString itself!
for (int i = 0; i < num; i++)
{
ILineString ls = (ILineString)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 MultiLineString's content to WKT format and appends WKT representation to the output stream.
/// </summary>
/// <param name="mls">The MultiLIneString to be converted.</param>
/// <param name="writer">The output Stream to Append WKT representation to.</param>
private static void AppendMultiLineStringText(IMultiLineString mls, TextWriter writer)
{
if (mls.Geometries.Count() == 0)
{
writer.Write("empty");
}
else
{
writer.Write("(");
WktWriter.AppendLineStringText(mls.Geometries.First(), writer);
foreach (var linestring in mls.Geometries.Skip(1))
{
writer.Write(",");
WktWriter.AppendLineStringText(linestring, writer);
}
writer.Write(")");
}
}
// see https://code.google.com/p/nettopologysuite/issues/detail?id=146
public void Issue146_ShapeCreationWithInvalidAttributeName()
{
Coordinate[] points = new Coordinate[3];
points[0] = new Coordinate(0, 0);
points[1] = new Coordinate(1, 0);
points[2] = new Coordinate(1, 1);
LineString ls = new LineString(points);
IMultiLineString mls = GeometryFactory.Default.CreateMultiLineString(new ILineString[] { ls });
AttributesTable attrs = new AttributesTable();
attrs.AddAttribute("Simulation name", "FOO");
Feature[] features = new[] { new Feature(mls, attrs) };
ShapefileDataWriter shp_writer = new ShapefileDataWriter("invalid_line_string")
{
Header = ShapefileDataWriter.GetHeader(features[0], features.Length)
};
shp_writer.Write(features);
}
private static IMultiLineString ReadMultiLineString(JsonTextReader jreader)
{
if (jreader == null)
{
throw new ArgumentNullException("reader", "A valid JSON reader object is required.");
}
IMultiLineString lines = null;
if (jreader.TokenClass == JsonTokenClass.Array)
{
jreader.ReadToken(JsonTokenClass.Array);
List <ILineString> list = new List <ILineString>();
while (jreader.TokenClass == JsonTokenClass.Array)
{
list.Add(ReadLineString(jreader));
}
jreader.ReadToken(JsonTokenClass.EndArray);
lines = new GisSharpBlog.NetTopologySuite.Geometries.MultiLineString(list.ToArray());
}
return(lines);
}
public void TestIsClosed()
{
LineString l = (LineString)reader.Read("LINESTRING EMPTY");
Assert.IsTrue(l.IsEmpty);
Assert.IsTrue(!l.IsClosed);
ILinearRing r = geometryFactory.CreateLinearRing((ICoordinateSequence)null);
Assert.IsTrue(r.IsEmpty);
Assert.IsTrue(r.IsClosed);
IMultiLineString m = geometryFactory.CreateMultiLineString(
new ILineString[] { l, r });
Assert.IsTrue(!m.IsClosed);
IMultiLineString m2 = geometryFactory.CreateMultiLineString(
new ILineString[] { r });
Assert.IsTrue(!m2.IsClosed);
}
/// <summary>
///
/// </summary>
/// <param name="computer">
/// A function that computes the weight
/// of any <see cref="ILineString">edge</see> of the graph
/// </param>
/// <returns></returns>
public DijkstraShortestPathAlgorithm <IPoint, IEdge <IPoint> > PrepareAlgorithm(ComputeWeightDelegate computer)
{
if (strings.Count < 2)
{
throw new TopologyException("you must specify two or more geometries to build a graph");
}
IMultiLineString edges = BuildEdges();
Dictionary <IEdge <IPoint>, double> consts = new Dictionary <IEdge <IPoint>, double>(edges.NumGeometries);
AdjacencyGraph <IPoint, IEdge <IPoint> > graph = new AdjacencyGraph <IPoint, IEdge <IPoint> >(true);
foreach (ILineString str in edges.Geometries)
{
IPoint vertex1 = str.StartPoint;
Assert.IsTrue(vertex1 != null);
if (!graph.ContainsVertex(vertex1))
{
graph.AddVertex(vertex1);
}
IPoint vertex2 = str.EndPoint;
Assert.IsTrue(vertex2 != null);
if (!graph.ContainsVertex(vertex2))
{
graph.AddVertex(vertex2);
}
double weight = computer(str);
Edge <IPoint> edge = new Edge <IPoint>(vertex1, vertex2);
Assert.IsTrue(edge != null);
graph.AddEdge(edge);
consts.Add(edge, weight);
}
// Use Dijkstra
return(new DijkstraShortestPathAlgorithm <IPoint, IEdge <IPoint> >(graph, consts));
}
/// <summary>
/// Converts the Geography Markup representation.
/// </summary>
/// <param name="geometry">The geometry.</param>
/// <returns>The GM representation of the <paramref name="geometry" /> in string.</returns>
private static String CreateGMString(IMultiLineString geometry, Boolean isRoot = false)
{
StringBuilder builder = new StringBuilder();
if (isRoot)
{
builder.Append(@"<gml:MultiLineString xmlns:gml=""http://www.opengis.net/gml"">");
}
else
{
builder.Append("<gml:MultiLineString>");
}
for (int i = 0; i < geometry.Count(); ++i)
{
builder.Append("<gml:LineStringMember>");
builder.Append(CreateGMString(geometry[i] as ILineString));
builder.Append("</gml:LineStringMember>");
}
builder.Append("</gml:MultiLineString>");
return(builder.ToString());
}
public void MultiLinestring()
{
IMultiLineString mls = _geoFactory.CreateMultiLineString();
Assert.IsTrue(mls.IsEmpty);
mls.Add(_geoFactory.CreateLineString());
Assert.IsTrue(mls.IsEmpty);
mls[0].Coordinates.Add(_geoFactory.CreatePoint2D(45, 68));
mls[0].Coordinates.Add(_geoFactory.CreatePoint2D(82, 44));
mls.Add(createLineString());
foreach (ILineString ls in (IEnumerable <ILineString>)mls)
{
Assert.IsFalse(ls.IsEmpty);
}
Assert.IsFalse(mls.IsEmpty);
foreach (ILineString ls in (IEnumerable <ILineString>)mls)
{
Assert.IsFalse(ls.IsClosed);
}
Assert.IsFalse(mls.IsClosed);
//Close linestrings
foreach (ILineString ls in (IEnumerable <ILineString>)mls)
{
ls.Coordinates.Add((ls.StartPoint.Clone() as IPoint).Coordinate);
}
foreach (ILineString ls in (IEnumerable <ILineString>)mls)
{
Assert.IsTrue(ls.IsClosed);
}
Assert.IsTrue(mls.IsClosed);
Assert.AreEqual(_geoFactory.CreateExtents2D(1, 2, 930, 123), mls.Extents);
}
public bool IsSimple(IMultiLineString geom)
{
return IsSimpleLinearGeometry(geom);
}
/// <summary>
///
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
protected virtual int SetByteStream(IMultiLineString geometry)
{
int count = INIT_COUNT;
count += 4;
foreach (LineString geom in geometry.Geometries)
count += SetByteStream(geom);
return count;
}
/// <summary>
///
/// </summary>
/// <param name="multiLineString"></param>
/// <param name="writer"></param>
protected virtual void Write(IMultiLineString multiLineString, BinaryWriter writer)
{
WriteByteOrder(writer);
writer.Write((int)WkbGeometryType.MultiLineString);
writer.Write(multiLineString.NumGeometries);
for (int i = 0; i < multiLineString.NumGeometries; i++)
Write(multiLineString.Geometries[i] as LineString, writer);
}
/// <summary>
///
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
protected int SetByteStream(IMultiLineString geometry)
{
// 4-byte count + subgeometries
return 4 + SetByteStream(geometry.Geometries);
}
/// <summary>
///
/// </summary>
/// <param name="multiLineString"></param>
/// <returns></returns>
protected int SetByteStreamLength(IMultiLineString multiLineString)
{
int numParts = multiLineString.NumGeometries;
int numPoints = multiLineString.NumPoints;
return CalculateLength(numParts, numPoints);
}
/// <summary>
///
/// </summary>
/// <param name="multiLineString"></param>
/// <returns></returns>
protected int SetByteStreamLength(IMultiLineString multiLineString)
{
int count = InitValue;
foreach (ILineString ls in multiLineString.Geometries)
count += SetByteStreamLength(ls);
return count;
}
private static GeoAPIMultiLineString FromMultiLineString(IMultiLineString geometry, GeoAPIGeometryFactory factory, bool copyUserData)
{
var dsLineStrings = new GeoAPILineString[geometry.NumGeometries];
for (var i = 0; i < dsLineStrings.Length; i++)
dsLineStrings[i] = FromLineString((ILineString)geometry.GetGeometryN(i), factory, copyUserData);
var result = factory.CreateMultiLineString(dsLineStrings);
if (copyUserData)
result.UserData = geometry.UserData;
return result;
}
/// <summary>
/// Clips a <see cref="IMultiLineString"/> 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 IMultiLineString ClipLineString(IMultiLineString lineStrings)
{
var clippedLineStringList = new List<ILineString>();
for (var i = 0; i < lineStrings.NumGeometries; i++)
{
var s = (ILineString) lineStrings.GetGeometryN(i);
var clippedLineStrings = ClipLineString(s);
for (var j = 0; j < clippedLineStrings.NumGeometries; j++)
{
var clippedLineString = (ILineString)clippedLineStrings.GetGeometryN(j);
clippedLineStringList.Add(clippedLineString);
}
}
return lineStrings.Factory.CreateMultiLineString(clippedLineStringList.ToArray());
}
/// <summary>
/// Converts a <c>MultiLineString</c> to <MultiLineString Text
/// format, then appends it to the writer.
/// </summary>
/// <param name="multiLineString">The <c>MultiLineString</c> to process.</param>
/// <param name="level"></param>
/// <param name="indentFirst"></param>
/// <param name="writer">The output writer to append to.</param>
private void AppendMultiLineStringText(IMultiLineString multiLineString, int level, bool indentFirst, TextWriter writer)
{
if (multiLineString.IsEmpty)
writer.Write(" EMPTY");
else
{
int level2 = level;
bool doIndent = indentFirst;
writer.Write("(");
for (int i = 0; i < multiLineString.NumGeometries; i++)
{
if (i > 0)
{
writer.Write(",");
level2 = level + 1;
doIndent = true;
}
AppendLineStringText((ILineString) multiLineString.GetGeometryN(i), level2, doIndent, writer);
}
writer.Write(")");
}
}
/// <summary>
/// Converts a <c>MultiLineString</c> to MultiLineString Tagged
/// Text format, then appends it to the writer.
/// </summary>
/// <param name="multiLineString">The <c>MultiLineString</c> to process.</param>
/// <param name="level"></param>
/// <param name="writer">The output writer to append to.</param>
private void AppendMultiLineStringTaggedText(IMultiLineString multiLineString, int level, TextWriter writer)
{
writer.Write("MULTILINESTRING");
AppendMultiLineStringText(multiLineString, level, false, writer);
}
/// <summary>
///
/// </summary>
/// <param name="geom"></param>
/// <param name="parent"></param>
/// <returns></returns>
protected virtual IGeometry TransformMultiLineString(IMultiLineString geom, IGeometry parent)
{
ArrayList transGeomList = new ArrayList();
for (int i = 0; i < geom.NumGeometries; i++)
{
IGeometry transformGeom = TransformLineString((ILineString) geom.GetGeometryN(i), geom);
if (transformGeom == null) continue;
if (transformGeom.IsEmpty) continue;
transGeomList.Add(transformGeom);
}
return factory.BuildGeometry(transGeomList);
}
/// <summary>
///
/// </summary>
/// <param name="multiLineString"></param>
/// <param name="writer"></param>
protected void Write(IMultiLineString multiLineString, BinaryWriter writer)
{
WriteByteOrder(writer); // LittleIndian
writer.Write((int) WKBGeometryTypes.WKBMultiLineString);
writer.Write((int) multiLineString.NumGeometries);
for (int i = 0; i < multiLineString.NumGeometries; i++)
Write(multiLineString.Geometries[i] as ILineString, writer);
}
/// <summary>
/// Method to write a multi linestring geometry to the <paramref name="writer"/>
/// </summary>
/// <param name="lines">The multi linestring geometry</param>
/// <param name="writer">The JSON writer</param>
public static void Write(IMultiLineString lines, TextWriter writer)
{
if (lines == null)
return;
if (writer == null)
throw new ArgumentNullException("writer", "A valid text writer object is required");
Write(lines, CreateWriter(writer));
}
/// <summary>
/// Method to write a multi linestring geometry to the <paramref name="writer"/>
/// </summary>
/// <param name="lines">The multi linestring geometry</param>
/// <param name="writer">The JSON writer</param>
public static void Write(IMultiLineString lines, JsonTextWriter writer)
{
if (lines == null)
return;
if (writer == null)
throw new ArgumentNullException("writer", "A valid JSON writer object is required");
writer.WriteStartObject();
writer.WritePropertyName("type");
writer.WriteValue("MultiLineString");
writer.WritePropertyName("coordinates");
writer.WriteStartArray();
for (var i = 0; i < lines.Count; i++)
{
var line = (ILineString)lines[i];
WriteCoord(line.Coordinates, writer);
}
writer.WriteEndArray();
writer.WriteEndObject();
}
/// <summary>
///
/// </summary>
/// <param name="multiLineString"></param>
/// <param name="writer"></param>
protected void Write(IMultiLineString multiLineString, BinaryWriter writer)
{
WriteByteOrder(writer); // LittleIndian
if (Double.IsNaN(multiLineString.Coordinate.Z))
writer.Write((int)WKBGeometryTypes.WKBMultiLineString);
else writer.Write((int)WKBGeometryTypes.WKBMultiLineStringZ);
writer.Write((int) multiLineString.NumGeometries);
for (int i = 0; i < multiLineString.NumGeometries; i++)
Write(multiLineString.Geometries[i] as ILineString, writer);
}
/// <summary>
///
/// </summary>
/// <param name="multiLineString"></param>
/// <param name="writer"></param>
protected void Write(IMultiLineString multiLineString, XmlTextWriter writer)
{
writer.WriteStartElement("MultiLineString", GMLElements.gmlNS);
for (int i = 0; i < multiLineString.NumGeometries; i++)
{
writer.WriteStartElement("lineStringMember", GMLElements.gmlNS);
Write(multiLineString.Geometries[i] as ILineString, writer);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
/// <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(IMultiLineString 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 IMultiLineString itself!
for (int i = 0; i < num; i++)
{
ILineString ls = (ILineString) mls.GetGeometryN(i);
//Write LineString Header
bWriter.Write((byte)byteorder);
WriteUInt32((uint)WKBGeometryType.wkbLineString, bWriter, byteorder);
//Write each linestring.
WriteLineString(ls, bWriter, byteorder);
}
}
/// <summary>
///
/// </summary>
/// <param name="multiLineString"></param>
/// <param name="writer"></param>
public void Write(IMultiLineString 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>
/// Transforms a <see cref="GeoAPI.Geometries.IMultiLineString"/>.
/// </summary>
/// <param name="lines">MultiLineString to transform</param>
/// <param name="from">Source Projection</param>
/// <param name="to">Target Projection</param>
/// <param name="toFactory">The factory to create geometries for <paramref name="to"/></param>
/// <returns>Transformed MultiLineString</returns>
public static IMultiLineString TransformMultiLineString(IMultiLineString lines, ProjectionInfo from, ProjectionInfo to, IGeometryFactory toFactory)
{
var l = new ILineString[lines.Count];
for (var i = 0; i < lines.Count; i++)
l[i] = TransformLineString((ILineString)lines.GetGeometryN(i), from, to, toFactory);
return toFactory.CreateMultiLineString(l);
}
/// <summary>
///
/// </summary>
/// <param name="geometry"></param>
/// <returns></returns>
protected int SetByteStream(IMultiLineString geometry)
{
int count = InitCount;
count += 4;
foreach (ILineString geom in geometry.Geometries)
count += SetByteStream(geom);
return count;
}
/// <summary>
/// Converts the <c>ICollection</c> to an array.
/// </summary>
/// <param name="multiLineStrings">The <c>ICollection</c> of MultiLineStrings to convert.</param>
/// <returns>The <c>ICollection</c> in array format.</returns>
public static IMultiLineString[] ToMultiLineStringArray(ICollection multiLineStrings)
{
IMultiLineString[] list = new IMultiLineString[multiLineStrings.Count];
int i = 0;
foreach (IMultiLineString mls in multiLineStrings)
list[i++] = mls;
return list;
}
/// <summary>
///
/// </summary>
/// <param name="multiLineString"></param>
/// <param name="writer"></param>
protected void Write(IMultiLineString multiLineString, BinaryWriter writer)
{
WriteHeader(multiLineString, PostGisGeometryType.MultiLineString, writer);
writer.Write((int) multiLineString.NumGeometries);
Write(multiLineString.Geometries, writer);
}
private static DSMultiLineString FromMultiLineString(IMultiLineString geometry, DSGeometryFactory factory, bool setUserData)
{
var dsLineStrings = new DotSpatial.Topology.IBasicLineString[geometry.NumGeometries];
for (var i = 0; i < dsLineStrings.Length; i++)
dsLineStrings[i] = FromLineString((ILineString)geometry.GetGeometryN(i), factory, setUserData);
var result = factory.CreateMultiLineString(dsLineStrings);
if (setUserData)
result.UserData = geometry.UserData;
return result;
}
/// <summary>
/// Transforms a <see cref="MultiLineString" /> object.
/// </summary>
/// <param name="lines"></param>
/// <param name="transform"></param>
/// <returns></returns>
public static IMultiLineString TransformMultiLineString(IMultiLineString lines, IMathTransform transform)
{
List<ILineString> strings = new List<ILineString>(lines.Geometries.Length);
foreach (ILineString ls in lines.Geometries)
strings.Add(TransformLineString(ls, transform));
return new MultiLineString(strings.ToArray());
}
/// <summary>
/// Determines whether specific Coordinate in on the given multiline.
/// </summary>
/// <param name="c">The coordinate to check.</param>
/// <param name="multiline">The multiline to check coordinate against.</param>
/// <returns>true if coordinate lies on any line of the given multiline, otherwise false.</returns>
public bool IsOnLine(Coordinate c, IMultiLineString multiline)
{
foreach (var line in multiline.Geometries) {
if (this.IsOnLine(c, line)) {
return true;
}
}
return false;
}
