/// <summary>
///
/// </summary>
/// <param name="multiLineString"></param>
/// <param name="writer"></param>
public void Write(IMultiLineString multiLineString, BinaryWriter writer)
{
writer.Write((int)ShapeGeometryType.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);
}
}
//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));
}
/// <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((LineString)multiLineString.GetGeometryN(i), level2, doIndent, writer);
}
writer.Write(")");
}
}
/// <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);
}
}
}
private GraphicsPath ToShape(IMultiLineString mls)
{
var path = new GraphicsPath();
for (var i = 0; i < mls.NumGeometries; i++)
{
path.AddPath(ToShape((ILineString)mls.GetGeometryN(i)), false);
}
return(path);
}
/// <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));
}
private int ProcessMultiLineString(IMultiLineString multiLineString, List <decimal> elemInfoList, List <decimal> ordinateList, int pos)
{
int cnt = multiLineString.NumGeometries;
for (int i = 0; i < cnt; i++)
{
var line = (ILineString)multiLineString.GetGeometryN(i);
pos += ProcessLinear(line, elemInfoList, ordinateList, pos);
}
return(pos);
}
/// <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);
}
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);
}
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>
/// 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>
///
/// </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));
}
private bool IsWithinToleranceOfBoundary(Coordinate pt)
{
for (int i = 0; i < _linework.NumGeometries; i++)
{
var line = (ILineString)_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>
/// 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 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>
///
/// </summary>
/// <param name="g"></param>
/// <returns></returns>
public static IGeometry GetEndPoints(IGeometry g)
{
List <Coordinate> endPtList = new List <Coordinate>();
if (g is ILineString)
{
ILineString line = (ILineString)g;
endPtList.Add(line.GetCoordinateN(0));
endPtList.Add(line.GetCoordinateN(line.NumPoints - 1));
}
else if (g is IMultiLineString)
{
IMultiLineString mls = (IMultiLineString)g;
for (int i = 0; i < mls.NumGeometries; i++)
{
ILineString line = (ILineString)mls.GetGeometryN(i);
endPtList.Add(line.GetCoordinateN(0));
endPtList.Add(line.GetCoordinateN(line.NumPoints - 1));
}
}
Coordinate[] endPts = endPtList.ToArray();
return(GeometryFactory.Default.CreateMultiPoint(endPts));
}
/// <summary>
/// Writes <paramref name="multiLineString"/> to a stream using <paramref name="writer"/>
/// </summary>
/// <param name="multiLineString">The multi linestring to write</param>
/// <param name="writer">The writer to use</param>
public void Write(IMultiLineString 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,
((ILineString)multiLineString[0]).CoordinateSequence.Ordinates);
// Write linestrings index
for (int i = 0; i < multiLineString.NumGeometries; i++)
{
// Write internal holes index
var ls = ((ILineString)multiLineString.GetGeometryN(i)).CoordinateSequence;
CoordinateSequences.Copy(ls, 0, seq, count, ls.Count);
count += ls.Count;
if (count == multiLineString.NumPoints)
{
break;
}
writer.Write((int)count);
}
// Write Coordinates
Write(multiLineString.Coordinates, 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;
}
private SpatialLite.Core.API.IGeometry ToSLMultiLineString(IMultiLineString geometry)
{
var lines = new List <SpatialLite.Core.Geometries.LineString>(geometry.NumGeometries);
for (var i = 0; i < geometry.NumGeometries; i++)
{
lines.Add((SpatialLite.Core.Geometries.LineString)ToSLLineString((ILineString)geometry.GetGeometryN(i)));
}
return(new SpatialLite.Core.Geometries.MultiLineString(geometry.SRID, lines));
}
//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);
}
private GraphicsPath ToShape(IMultiLineString mls)
{
var path = new GraphicsPath();
for (var i = 0; i < mls.NumGeometries; i++)
{
path.AddPath(ToShape((ILineString)mls.GetGeometryN(i)), false);
}
return path;
}
/// <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>
/// 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>
/// 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>
///
/// </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);
}
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>
/// 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>
///
/// </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>
/// Writes <paramref name="multiLineString"/> to a stream using <paramref name="writer"/>
/// </summary>
/// <param name="multiLineString">The multi linestring to write</param>
/// <param name="writer">The writer to use</param>
public void Write(IMultiLineString 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,
((ILineString) multiLineString[0]).CoordinateSequence.Ordinates);
// Write linestrings index
for (int i = 0; i < multiLineString.NumGeometries; i++)
{
// Write internal holes index
var ls = ((ILineString) multiLineString.GetGeometryN(i)).CoordinateSequence;
CoordinateSequences.Copy(ls, 0, seq, count, ls.Count);
count += ls.Count;
if (count == multiLineString.NumPoints)
break;
writer.Write((int) count);
}
// Write Coordinates
Write(multiLineString.Coordinates, writer);
}
