private static async Task <CoordinateCollection> ParseLinearRings(XElement rings, bool optimize, double tolerance)
{
CoordinateCollection rCoords = null;
foreach (var c in rings.Elements())
{
if (c.Name.Namespace == gmlNS && string.Compare(c.Name.LocalName, "linearring", StringComparison.OrdinalIgnoreCase) == 0)
{
foreach (var cc in c.Elements())
{
var coords = await ParsePosList(cc, optimize, tolerance);
if (coords != null && coords.Count >= 3)
{
rCoords = coords;
break;
}
}
}
}
if (optimize)
{
rCoords = await SpatialTools.VertexReductionAsync(rCoords, tolerance);
}
return(rCoords);
}
/// <summary>
/// Parses a string list of coordinates. Handles 2D and 3D coordinate sets.
/// </summary>
/// <param name="dim">Number of values to represent coordinate.</param>
/// <returns></returns>
private async Task <CoordinateCollection> ParseCoordinates(XElement node)
{
if (node != null)
{
var sCoord = XmlUtilities.GetString(node, false);
var vals = SplitCoordString(sCoord, CoordArtifactRx, SpaceSplitter);
var c = new CoordinateCollection();
double lon, lat;
if (vals.Length >= 2)
{
for (int i = 0; i < vals.Length; i = i + 2)
{
if (double.TryParse(vals[i], NumberStyles.Float, CultureInfo.InvariantCulture, out lat) &&
double.TryParse(vals[i + 1], NumberStyles.Float, CultureInfo.InvariantCulture, out lon))
{
c.Add(new Coordinate(lat, lon));
}
}
}
if (optimize)
{
c = await SpatialTools.VertexReductionAsync(c, tolerance);
}
return(c);
}
return(null);
}
private async Task <CoordinateCollection> ParseRing(string wkt, int minCoords, bool closed, bool optimize)
{
string[] coords = wkt.Split(_commonDelimiter, StringSplitOptions.RemoveEmptyEntries);
var locs = new CoordinateCollection();
foreach (var coord in coords)
{
var c = ParseCoord(coord);
if (c.HasValue)
{
locs.Add(c.Value);
}
}
if (optimize)
{
locs = await SpatialTools.VertexReductionAsync(locs, tolerance);
}
if (locs.Count > minCoords)
{
//Ensure the ring is closed
if (closed && !locs[0].Equals(locs[locs.Count - 1]))
{
locs.Add(locs[0]);
}
return(locs);
}
return(null);
}
private async Task <LineString> ParseTrackSegment(XElement node)
{
var points = XmlUtilities.GetChildNodes(node, "trkpt");
var coords = new CoordinateCollection();
foreach (var p in points)
{
var c = ParseWaypointAsCoordinate(p);
if (c.HasValue)
{
coords.Add(c.Value);
}
}
if (coords.Count >= 0)
{
if (optimize)
{
coords = await SpatialTools.VertexReductionAsync(coords, tolerance);
}
return(new LineString(coords));
}
return(null);
}
/// <summary>
/// Reads LineString shapefile
/// </summary>
/// <param name="reader">The shapefile stream</param>
/// <returns>A list of Geometry objects</returns>
private async Task <List <Geometry> > ReadLineStringData(BinaryReader reader)
{
var items = new List <Geometry>();
int numParts, numPoints;
while (reader.BaseStream.Position < reader.BaseStream.Length)
{
Geometry item;
// Read Record Header.
int id = ReadRecordHeader(reader);
var boundingBox = ReadBoundingBox(reader);
// Read the number of Parts and Points in the shape.
numParts = NumberReader.ReadIntLE(reader);
numPoints = NumberReader.ReadIntLE(reader);
int[] parts = ReadParts(reader, numParts, numPoints);
//First read all the rings
var rings = new List <CoordinateCollection>();
var multiline = new MultiLineString();
for (int ringID = 0; ringID < numParts; ringID++)
{
var line = new LineString();
for (int i = parts[ringID]; i < parts[ringID + 1]; i++)
{
line.Vertices.Add(ReadCoordinate(reader));
}
if (optimize)
{
line.Vertices = await SpatialTools.VertexReductionAsync(line.Vertices, tolerance);
}
multiline.Geometries.Add(line);
}
if (numParts == 1)
{
item = (Geometry)multiline.Geometries[0];
}
else
{
item = multiline;
}
item.Metadata.ID = id.ToString();
item.Metadata.Properties.Add("BoundingBox", boundingBox);
items.Add(item);
}
return(items);
}
private static async Task <CoordinateCollection> ParsePosList(XElement node, bool optimize, double tolerance)
{
if (node.Name.Namespace == gmlNS && (string.Compare(node.Name.LocalName, "poslist", StringComparison.OrdinalIgnoreCase) == 0 ||
string.Compare(node.Name.LocalName, "coordinates", StringComparison.OrdinalIgnoreCase) == 0))
{
var dimension = XmlUtilities.GetDoubleAttribute(node, "dimension");
int dim = 2;
if (!double.IsNaN(dimension) && dimension > 2)
{
dim = (int)dimension;
}
var sCoord = XmlUtilities.GetString(node, false);
var vals = CoordArtifactRx.Replace(sCoord, " ").Split(SpaceSplitter, StringSplitOptions.RemoveEmptyEntries);
var c = new CoordinateCollection();
double lat, lon, alt;
if (dim == 3 && vals.Length >= 3)
{
for (var i = 0; i < vals.Length; i = i + 3)
{
if (double.TryParse(vals[i], NumberStyles.Float, CultureInfo.InvariantCulture, out lat) &&
double.TryParse(vals[i + 1], NumberStyles.Float, CultureInfo.InvariantCulture, out lon) &&
double.TryParse(vals[i + 1], NumberStyles.Float, CultureInfo.InvariantCulture, out alt))
{
c.Add(new Coordinate(lat, lon, alt));
}
}
}
else if (dim == 2 && vals.Length >= 2)
{
for (var i = 0; i < vals.Length; i = i + 2)
{
if (double.TryParse(vals[i], NumberStyles.Float, CultureInfo.InvariantCulture, out lat) &&
double.TryParse(vals[i + 1], NumberStyles.Float, CultureInfo.InvariantCulture, out lon))
{
c.Add(new Coordinate(lat, lon));
}
}
}
if (optimize)
{
c = await SpatialTools.VertexReductionAsync(c, tolerance);
}
return(c);
}
return(null);
}
private async Task <CoordinateCollection> ParseCoordinates(JArray jsonArray)
{
var coords = new CoordinateCollection();
foreach (var c in jsonArray)
{
var coord = ParseCoordinate(c as JArray);
if (coord.HasValue)
{
coords.Add(coord.Value);
}
}
if (optimize)
{
coords = await SpatialTools.VertexReductionAsync(coords, tolerance);
}
return(coords);
}
private async Task <CoordinateCollection> ReadCoordinates(BinaryReader reader, ByteOrder wkbByteOrder, WKBShapeType type, bool includeAltitude, bool includeM)
{
// Get the number of points in this linestring.
int numPoints = (int)NumberReader.ReadUInt32(reader, wkbByteOrder);
// Create a new array of coordinates.
var coords = new CoordinateCollection();
// Loop on the number of points in the ring.
for (int i = 0; i < numPoints; i++)
{
coords.Add(ReadCoordinate(reader, wkbByteOrder, type, includeAltitude, includeM));
}
if (optimize)
{
coords = await SpatialTools.VertexReductionAsync(coords, tolerance);
}
return(coords);
}
private async Task <CoordinateCollection> ParseCoordinates(XElement node)
{
if (node != null)
{
var sCoord = XmlUtilities.GetString(node, false);
double lat, lon, alt;
var tuples = SplitCoordString(sCoord, CoordArtifactRx, SpaceSplitter);
var cc = new CoordinateCollection();
foreach (var t in tuples)
{
var vals = SplitCoordString(t, CoordArtifactRx, CommaSpaceSplitter);
if (vals.Length >= 2 &&
double.TryParse(vals[1], NumberStyles.Float, CultureInfo.InvariantCulture, out lat) &&
double.TryParse(vals[0], NumberStyles.Float, CultureInfo.InvariantCulture, out lon))
{
if (vals.Length > 3 && double.TryParse(vals[2], NumberStyles.Float, CultureInfo.InvariantCulture, out alt))
{
cc.Add(new Coordinate(lat, lon, alt));
}
else
{
cc.Add(new Coordinate(lat, lon));
}
}
}
if (optimize)
{
cc = await SpatialTools.VertexReductionAsync(cc, tolerance);
}
return(cc);
}
return(null);
}
private async Task <List <Geometry> > ParseRoute(XElement node, Dictionary <string, ShapeStyle> styles)
{
var geoms = new List <Geometry>();
var line = new LineString();
var metadata = new ShapeMetadata();
var coords = new CoordinateCollection();
var style = new ShapeStyle();
string nodeName;
foreach (var n in node.Elements())
{
nodeName = n.Name.LocalName;
switch (nodeName)
{
case "name":
metadata.Title = XmlUtilities.GetString(n, stripHtml);
break;
case "desc":
metadata.Description = XmlUtilities.GetString(n, stripHtml);
break;
case "cmt":
case "src":
case "type":
SetMetadataString(metadata, nodeName, n, stripHtml);
break;
case "number": //<number> xsd:nonNegativeInteger </number> [0..1] ?
var i = XmlUtilities.GetInt32(n, -1);
if (i >= 0 && !metadata.Properties.ContainsKey(nodeName))
{
metadata.Properties.Add(nodeName, i);
}
break;
case "link":
var href = XmlUtilities.GetStringAttribute(n, "href");
if (!string.IsNullOrWhiteSpace(href) && !metadata.Properties.ContainsKey(nodeName))
{
metadata.Properties.Add(nodeName, href);
}
break;
case "rtept":
if (readRouteWaypoints)
{
var wpt = ParseWaypoint(n, styles);
coords.Add(wpt.Coordinate);
geoms.Add(wpt);
}
else
{
var c = ParseWaypointAsCoordinate(n);
if (c.HasValue)
{
coords.Add(c.Value);
}
}
break;
case "extensions":
ParseExtensions(n, metadata, style);
break;
default:
break;
}
}
if (!string.IsNullOrEmpty(metadata.Title) || !string.IsNullOrEmpty(metadata.Description) || metadata.Properties.Count > 0)
{
line.Metadata = metadata;
}
if (style.StrokeColor.HasValue)
{
var styleKey = "embeddedStyle_" + embeddedStyleCnt;
embeddedStyleCnt++;
styles.Add(styleKey, style);
line.StyleKey = styleKey;
}
if (coords.Count >= 2)
{
if (optimize)
{
coords = await SpatialTools.VertexReductionAsync(coords, tolerance);
}
line.Vertices = coords;
geoms.Add(line);
}
return(geoms);
}
