/// <summary>
/// Returns the next "EMPTY" or "(" in the stream as uppercase text.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next token must be "EMPTY" or "(".</param>
/// <returns>the next "EMPTY" or "(" in the stream as uppercase
/// text.</returns>
/// <remarks>
/// ParseException is thrown if the next token is not "EMPTY" or "(".
/// </remarks>
private static string GetNextEmptyOrOpener(WktStreamTokenizer tokenizer)
{
tokenizer.NextToken();
string nextWord = tokenizer.GetStringValue();
if (nextWord == "EMPTY" || nextWord == "(")
{
return(nextWord);
}
throw new Exception("Expected 'EMPTY' or '(' but encountered '" + nextWord + "'");
}
/// <summary>
/// Creates a Point using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Point Text>.</param>
/// <returns>Returns a Point specified by the next token in
/// the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static Point ReadPointText(WktStreamTokenizer tokenizer)
{
Point p = new Point();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(p);
}
p.X = GetNextNumber(tokenizer);
p.Y = GetNextNumber(tokenizer);
GetNextCloser(tokenizer);
return(p);
}
/// <summary>
/// Creates a Point using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Point Text>.</param>
/// <param name="factory">The factory to create the result geometry</param>
/// <returns>Returns a Point specified by the next token in
/// the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static Point ReadPointText(WktStreamTokenizer tokenizer, GeometryFactory factory)
{
var nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(factory.CreatePoint((Coordinate)null));
}
var c = new Coordinate(GetNextNumber(tokenizer), GetNextNumber(tokenizer));
GetNextCloser(tokenizer);
return(factory.CreatePoint(c));
}
/// <summary>
/// Reads and parses a WKT-formatted projection string.
/// </summary>
/// <param name="wkt">String containing WKT.</param>
/// <returns>Object representation of the WKT.</returns>
/// <exception cref="System.ArgumentException">If a token is not recognised.</exception>
public static IInfo Parse(string wkt)
{
IInfo returnObject = null;
StringReader reader = new StringReader(wkt);
WktStreamTokenizer tokenizer = new WktStreamTokenizer(reader);
tokenizer.NextToken();
string objectName = tokenizer.GetStringValue();
switch (objectName)
{
case "UNIT":
returnObject = ReadUnit(tokenizer);
break;
//case "VERT_DATUM":
// IVerticalDatum verticalDatum = ReadVerticalDatum(tokenizer);
// returnObject = verticalDatum;
// break;
case "SPHEROID":
returnObject = ReadEllipsoid(tokenizer);
break;
case "DATUM":
returnObject = ReadHorizontalDatum(tokenizer);;
break;
case "PRIMEM":
returnObject = ReadPrimeMeridian(tokenizer);
break;
case "VERT_CS":
case "GEOGCS":
case "PROJCS":
case "COMPD_CS":
case "GEOCCS":
case "FITTED_CS":
case "LOCAL_CS":
returnObject = ReadCoordinateSystem(wkt, tokenizer);
break;
default:
throw new ArgumentException(String.Format("{0} is not recongnized.", objectName));
}
reader.Close();
return(returnObject);
}
/// <summary>
/// Creates a Point using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Point Text>.</param>
/// <returns>Returns a Point specified by the next token in
/// the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static MultiPoint ReadMultiPointText(WktStreamTokenizer tokenizer)
{
MultiPoint mp = new MultiPoint();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(mp);
}
mp.Points.Add(new Point(GetNextNumber(tokenizer), GetNextNumber(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
mp.Points.Add(new Point(GetNextNumber(tokenizer), GetNextNumber(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
}
return(mp);
}
/// <summary>
/// Creates a <see cref="GeometryCollection"/> using the next token in the stream.
/// </summary>
/// <param name="tokenizer"> Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a GeometryCollection Text.</param>
/// <returns>
/// A <see cref="GeometryCollection"/> specified by the next token in the stream.</returns>
private static GeometryCollection ReadGeometryCollectionText(WktStreamTokenizer tokenizer)
{
GeometryCollection geometries = new GeometryCollection();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken.Equals("EMPTY"))
{
return(geometries);
}
geometries.Collection.Add(ReadGeometryTaggedText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken.Equals(","))
{
geometries.Collection.Add(ReadGeometryTaggedText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
}
return(geometries);
}
/// <summary>
/// Creates a <see cref="MultiLineString"/> using the next token in the stream.
/// </summary>
/// <param name="tokenizer">tokenizer over a stream of text in Well-known Text format. The next tokens must form a MultiLineString Text</param>
/// <returns>a <see cref="MultiLineString"/> specified by the next token in the stream</returns>
private static MultiLineString ReadMultiLineStringText(WktStreamTokenizer tokenizer)
{
MultiLineString lines = new MultiLineString();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(lines);
}
lines.LineStrings.Add(ReadLineStringText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
lines.LineStrings.Add(ReadLineStringText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
}
return(lines);
}
/// <summary>
/// Reads either 3, 6 or 7 parameter Bursa-Wolf values from TOWGS84 token
/// </summary>
/// <param name="tokenizer"></param>
/// <returns></returns>
private static Wgs84ConversionInfo ReadWGS84ConversionInfo(WktStreamTokenizer tokenizer)
{
//TOWGS84[0,0,0,0,0,0,0]
tokenizer.ReadToken("[");
Wgs84ConversionInfo info = new Wgs84ConversionInfo();
tokenizer.NextToken();
info.Dx = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Dy = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Dz = tokenizer.GetNumericValue();
tokenizer.NextToken();
if (tokenizer.GetStringValue() == ",")
{
tokenizer.NextToken();
info.Ex = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Ey = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Ez = tokenizer.GetNumericValue();
tokenizer.NextToken();
if (tokenizer.GetStringValue() == ",")
{
tokenizer.NextToken();
info.Ppm = tokenizer.GetNumericValue();
}
}
if (tokenizer.GetStringValue() != "]")
{
tokenizer.ReadToken("]");
}
return(info);
}
/// <summary>
/// Creates a Geometry using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Geometry Tagged Text>.</param>
/// <returns>Returns a Geometry specified by the next token in the stream.</returns>
/// <remarks>
/// Exception is thrown if the coordinates used to create a Polygon
/// shell and holes do not form closed linestrings, or if an unexpected
/// token is encountered.
/// </remarks>
private static Geometry ReadGeometryTaggedText(WktStreamTokenizer tokenizer)
{
tokenizer.NextToken();
var type = tokenizer.GetStringValue().ToUpper();
Geometry geometry;
GeometryFactory factory = new GeometryFactory();
switch (type)
{
case "POINT":
geometry = ReadPointText(tokenizer, factory);
break;
case "LINESTRING":
geometry = ReadLineStringText(tokenizer, factory);
break;
case "MultiPoint":
geometry = ReadMultiPointText(tokenizer, factory);
break;
case "MultiLineString":
geometry = ReadMultiLineStringText(tokenizer, factory);
break;
case "POLYGON":
geometry = ReadPolygonText(tokenizer, factory);
break;
case "MultiPolygon":
geometry = ReadMultiPolygonText(tokenizer, factory);
break;
case "GEOMETRYCOLLECTION":
geometry = ReadGeometryCollectionText(tokenizer, factory);
break;
default:
throw new Exception(String.Format(Map.NumberFormatEnUs, "Geometrytype '{0}' is not supported.",
type));
}
return(geometry);
}
/// <summary>
/// Creates a <see cref="GeometryCollection"/> using the next token in the stream.
/// </summary>
/// <param name="tokenizer"> Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a GeometryCollection Text.</param>
/// <param name="factory">The factory to create the result geometry</param>
/// <returns>
/// A <see cref="GeometryCollection"/> specified by the next token in the stream.</returns>
private static GeometryCollection ReadGeometryCollectionText(WktStreamTokenizer tokenizer, GeometryFactory factory)
{
var nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken.Equals("EMPTY"))
{
return(factory.CreateGeometryCollection(null));
}
var geometries = new List <Geometry>();
geometries.Add(ReadGeometryTaggedText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken.Equals(","))
{
geometries.Add(ReadGeometryTaggedText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
}
return(factory.CreateGeometryCollection(geometries.ToArray()));
}
/// <summary>
/// Returns a <see cref="AngularUnit"/> given a piece of WKT.
/// </summary>
/// <param name="tokenizer">WktStreamTokenizer that has the WKT.</param>
/// <returns>An object that implements the IUnit interface.</returns>
private static IAngularUnit ReadAngularUnit(WktStreamTokenizer tokenizer)
{
tokenizer.ReadToken("[");
string unitName = tokenizer.ReadDoubleQuotedWord();
tokenizer.ReadToken(",");
tokenizer.NextToken();
double unitsPerUnit = tokenizer.GetNumericValue();
string authority = String.Empty;
long authorityCode = -1;
tokenizer.NextToken();
if (tokenizer.GetStringValue() == ",")
{
tokenizer.ReadAuthority(ref authority, ref authorityCode);
tokenizer.ReadToken("]");
}
return(new AngularUnit(unitsPerUnit, unitName, authority, authorityCode, String.Empty, String.Empty, String.Empty));
}
/// <summary>
/// Creates a Polygon using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Polygon Text>.</param>
/// <returns>Returns a Polygon specified by the next token
/// in the stream</returns>
/// <remarks>
/// ParseException is thown if the coordinates used to create the Polygon
/// shell and holes do not form closed linestrings, or if an unexpected
/// token is encountered.
/// </remarks>
private static Polygon ReadPolygonText(WktStreamTokenizer tokenizer)
{
Polygon pol = new Polygon();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(pol);
}
pol.ExteriorRing = new LinearRing(GetCoordinates(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
//Add holes
pol.InteriorRings.Add(new LinearRing(GetCoordinates(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
}
return(pol);
}
/// <summary>
/// Creates a Point using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Point Text>.</param>
/// <param name="factory">The factory to create the result geometry</param>
/// <returns>Returns a Point specified by the next token in
/// the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static MultiPoint ReadMultiPointText(WktStreamTokenizer tokenizer, GeometryFactory factory)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(factory.CreateMultiPointFromCoords((Coordinate[])null));
}
var points = new List <Coordinate>();
points.Add(new Coordinate(GetNextNumber(tokenizer), GetNextNumber(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
points.Add(new Coordinate(GetNextNumber(tokenizer), GetNextNumber(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
}
return(factory.CreateMultiPointFromCoords(points.ToArray()));
}
/// <summary>
/// Creates a <see cref="MultiLineString"/> using the next token in the stream.
/// </summary>
/// <param name="tokenizer">tokenizer over a stream of text in Well-known Text format. The next tokens must form a MultiLineString Text</param>
/// <param name="factory">The factory to create the result geometry</param>
/// <returns>a <see cref="MultiLineString"/> specified by the next token in the stream</returns>
private static MultiLineString ReadMultiLineStringText(WktStreamTokenizer tokenizer, GeometryFactory factory)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(factory.CreateMultiLineString(null));
}
var lineStrings = new List <LineString>();
lineStrings.Add(ReadLineStringText(tokenizer, factory));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
lineStrings.Add(ReadLineStringText(tokenizer, factory));
nextToken = GetNextCloserOrComma(tokenizer);
}
return(factory.CreateMultiLineString(lineStrings.ToArray()));
}
/// <summary>
/// Creates a Geometry using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Geometry Tagged Text>.</param>
/// <returns>Returns a Geometry specified by the next token in the stream.</returns>
/// <remarks>
/// Exception is thrown if the coordinates used to create a Polygon
/// shell and holes do not form closed linestrings, or if an unexpected
/// token is encountered.
/// </remarks>
private static Geometry ReadGeometryTaggedText(WktStreamTokenizer tokenizer)
{
tokenizer.NextToken();
string type = tokenizer.GetStringValue().ToUpper();
Geometry geometry = null;
switch (type)
{
case "POINT":
geometry = ReadPointText(tokenizer);
break;
case "LINESTRING":
geometry = ReadLineStringText(tokenizer);
break;
case "MULTIPOINT":
geometry = ReadMultiPointText(tokenizer);
break;
case "MULTILINESTRING":
geometry = ReadMultiLineStringText(tokenizer);
break;
case "POLYGON":
geometry = ReadPolygonText(tokenizer);
break;
case "MULTIPOLYGON":
geometry = ReadMultiPolygonText(tokenizer);
break;
case "GEOMETRYCOLLECTION":
geometry = ReadGeometryCollectionText(tokenizer);
break;
default:
throw new Exception(String.Format(SharpMap.Map.numberFormat_EnUS, "Geometrytype '{0}' is not supported.", type));
}
return(geometry);
}
/// <summary>
/// Reads and parses a WKT-formatted projection string.
/// </summary>
/// <param name="wkt">String containing WKT.</param>
/// <returns>Object representation of the WKT.</returns>
/// <exception cref="System.ArgumentException">If a token is not recognised.</exception>
public static IInfo Parse(string wkt)
{
IInfo returnObject = null;
StringReader reader = new StringReader(wkt);
WktStreamTokenizer tokenizer = new WktStreamTokenizer(reader);
tokenizer.NextToken();
string objectName = tokenizer.GetStringValue();
switch (objectName)
{
case "UNIT":
returnObject = ReadUnit(tokenizer);
break;
//case "VERT_DATUM":
// IVerticalDatum verticalDatum = ReadVerticalDatum(tokenizer);
// returnObject = verticalDatum;
// break;
case "SPHEROID":
returnObject = ReadEllipsoid(tokenizer);
break;
case "DATUM":
returnObject = ReadHorizontalDatum(tokenizer); ;
break;
case "PRIMEM":
returnObject = ReadPrimeMeridian(tokenizer);
break;
case "VERT_CS":
case "GEOGCS":
case "PROJCS":
case "COMPD_CS":
case "GEOCCS":
case "FITTED_CS":
case "LOCAL_CS":
returnObject = ReadCoordinateSystem(wkt, tokenizer);
break;
default:
throw new ArgumentException(String.Format("'{0'} is not recongnized.", objectName));
}
reader.Close();
return returnObject;
}
/// <summary>
/// Creates a <see cref="MultiPolygon"/> using the next token in the stream.
/// </summary>
/// <param name="tokenizer">tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a MultiPolygon.</param>
/// <param name="factory">The factory to create the result geometry</param>
/// <returns>a <code>MultiPolygon</code> specified by the next token in the
/// stream, or if if the coordinates used to create the <see cref="Polygon"/>
/// shells and holes do not form closed linestrings.</returns>
private static MultiPolygon ReadMultiPolygonText(WktStreamTokenizer tokenizer, GeometryFactory factory)
{
var polygons = new List <Polygon>();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(factory.CreateMultiPolygon(polygons.ToArray()));
}
var polygon = ReadPolygonText(tokenizer, factory);
polygons.Add(polygon);
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
polygon = ReadPolygonText(tokenizer, factory);
polygons.Add(polygon);
nextToken = GetNextCloserOrComma(tokenizer);
}
return(factory.CreateMultiPolygon(polygons.ToArray()));
}
/// <summary>
/// Creates a Polygon using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Polygon Text>.</param>
/// <param name="factory">The factory to create the result geometry</param>
/// <returns>Returns a Polygon specified by the next token
/// in the stream</returns>
/// <remarks>
/// ParseException is thrown if the coordinates used to create the Polygon
/// shell and holes do not form closed linestrings, or if an unexpected
/// token is encountered.
/// </remarks>
private static Polygon ReadPolygonText(WktStreamTokenizer tokenizer, GeometryFactory factory)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(factory.CreatePolygon(null, null));
}
var exteriorRing = factory.CreateLinearRing(GetCoordinates(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
var interiorRings = new List <LinearRing>();
while (nextToken == ",")
{
//Add holes
interiorRings.Add(factory.CreateLinearRing(GetCoordinates(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
}
return(factory.CreatePolygon(exteriorRing, interiorRings.ToArray()));
}
/// <summary>
/// Creates a <see cref="MultiPolygon"/> using the next token in the stream.
/// </summary>
/// <param name="tokenizer">tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a MultiPolygon.</param>
/// <returns>a <code>MultiPolygon</code> specified by the next token in the
/// stream, or if if the coordinates used to create the <see cref="Polygon"/>
/// shells and holes do not form closed linestrings.</returns>
private static MultiPolygon ReadMultiPolygonText(WktStreamTokenizer tokenizer)
{
MultiPolygon polygons = new MultiPolygon();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(polygons);
}
Polygon polygon = ReadPolygonText(tokenizer);
polygons.Polygons.Add(polygon);
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
polygon = ReadPolygonText(tokenizer);
polygons.Polygons.Add(polygon);
nextToken = GetNextCloserOrComma(tokenizer);
}
return(polygons);
}
/// <summary>
/// Returns the next array of Coordinates in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text format. The
/// next element returned by the stream should be "(" (the beginning of "(x1 y1, x2 y2, ..., xn yn)" or
/// "EMPTY".</param>
/// <returns>The next array of Coordinates in the stream, or an empty array of "EMPTY" is the
/// next element returned by the stream.</returns>
private static Coordinate[] GetCoordinates(WktStreamTokenizer tokenizer)
{
var coordinates = new List <Coordinate>();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
{
return(coordinates.ToArray());
}
var externalCoordinate = new Coordinate();
externalCoordinate.X = GetNextNumber(tokenizer);
externalCoordinate.Y = GetNextNumber(tokenizer);
coordinates.Add(externalCoordinate);
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
var internalCoordinate = new Coordinate(GetNextNumber(tokenizer), GetNextNumber(tokenizer));
coordinates.Add(internalCoordinate);
nextToken = GetNextCloserOrComma(tokenizer);
}
return(coordinates.ToArray());
}
/// <summary>
///
/// </summary>
/// <param name="tokenizer"></param>
/// <returns></returns>
private static IPrimeMeridian ReadPrimeMeridian(WktStreamTokenizer tokenizer)
{
//PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]]
tokenizer.ReadToken("[");
string name = tokenizer.ReadDoubleQuotedWord();
tokenizer.ReadToken(",");
tokenizer.NextToken();
double longitude = tokenizer.GetNumericValue();
tokenizer.NextToken();
string authority = String.Empty;
long authorityCode = -1;
if (tokenizer.GetStringValue() == ",")
{
tokenizer.ReadAuthority(ref authority, ref authorityCode);
tokenizer.ReadToken("]");
}
// make an assumption about the Angular units - degrees.
IPrimeMeridian primeMeridian = new PrimeMeridian(longitude, AngularUnit.Degrees, name, authority, authorityCode, String.Empty, String.Empty, String.Empty);
return(primeMeridian);
}
/// <summary>
/// Returns the next array of Coordinates in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text format. The
/// next element returned by the stream should be "(" (the beginning of "(x1 y1, x2 y2, ..., xn yn)" or
/// "EMPTY".</param>
/// <returns>The next array of Coordinates in the stream, or an empty array of "EMPTY" is the
/// next element returned by the stream.</returns>
private static List<SharpMap.Geometries.Point> GetCoordinates(WktStreamTokenizer tokenizer)
{
List<SharpMap.Geometries.Point> coordinates = new List<SharpMap.Geometries.Point>();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken=="EMPTY")
return coordinates;
SharpMap.Geometries.Point externalCoordinate = new SharpMap.Geometries.Point();
SharpMap.Geometries.Point internalCoordinate = new SharpMap.Geometries.Point();
externalCoordinate.X = GetNextNumber(tokenizer);
externalCoordinate.Y = GetNextNumber(tokenizer);
coordinates.Add(externalCoordinate);
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken==",")
{
internalCoordinate = new SharpMap.Geometries.Point();
internalCoordinate.X = GetNextNumber(tokenizer);
internalCoordinate.Y = GetNextNumber(tokenizer);
coordinates.Add(internalCoordinate);
nextToken = GetNextCloserOrComma(tokenizer);
}
return coordinates;
}
/// <summary>
/// Creates a LineString using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text format. The next
/// tokens must form a LineString Text.</param>
/// <returns>Returns a LineString specified by the next token in the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static LineString ReadLineStringText(WktStreamTokenizer tokenizer)
{
return new LineString(GetCoordinates(tokenizer));
}
/// <summary>
/// Converts a Well-known Text representation to a <see cref="SharpMap.Geometries.Geometry"/>.
/// </summary>
/// <param name="reader">A Reader which will return a Geometry Tagged Text
/// string (see the OpenGIS Simple Features Specification)</param>
/// <returns>Returns a <see cref="SharpMap.Geometries.Geometry"/> read from StreamReader.
/// An exception will be thrown if there is a parsing problem.</returns>
public static Geometry Parse(TextReader reader)
{
WktStreamTokenizer tokenizer = new WktStreamTokenizer(reader);
return(ReadGeometryTaggedText(tokenizer));
}
/// <summary>
///
/// </summary>
/// <param name="tokenizer"></param>
/// <returns></returns>
private static IProjectedCoordinateSystem ReadProjectedCoordinateSystem(WktStreamTokenizer tokenizer)
{
/*PROJCS[
"OSGB 1936 / British National Grid",
GEOGCS[
"OSGB 1936",
DATUM[...]
PRIMEM[...]
AXIS["Geodetic latitude","NORTH"]
AXIS["Geodetic longitude","EAST"]
AUTHORITY["EPSG","4277"]
],
PROJECTION["Transverse Mercator"],
PARAMETER["latitude_of_natural_origin",49],
PARAMETER["longitude_of_natural_origin",-2],
PARAMETER["scale_factor_at_natural_origin",0.999601272],
PARAMETER["false_easting",400000],
PARAMETER["false_northing",-100000],
AXIS["Easting","EAST"],
AXIS["Northing","NORTH"],
AUTHORITY["EPSG","27700"]
]
*/
tokenizer.ReadToken("[");
string name = tokenizer.ReadDoubleQuotedWord();
tokenizer.ReadToken(",");
tokenizer.ReadToken("GEOGCS");
IGeographicCoordinateSystem geographicCS = ReadGeographicCoordinateSystem(tokenizer);
tokenizer.ReadToken(",");
IProjection projection = ReadProjection(tokenizer);
IUnit unit = ReadLinearUnit(tokenizer);
string authority = String.Empty;
long authorityCode = -1;
tokenizer.NextToken();
List<AxisInfo> axes = new List<AxisInfo>(2);
if (tokenizer.GetStringValue() == ",")
{
tokenizer.NextToken();
while (tokenizer.GetStringValue() == "AXIS")
{
axes.Add(ReadAxis(tokenizer));
tokenizer.NextToken();
}
if (tokenizer.GetStringValue() == "AUTHORITY")
{
tokenizer.ReadAuthority(ref authority, ref authorityCode);
tokenizer.ReadToken("]");
}
}
//This is default axis values if not specified.
if (axes.Count == 0)
{
axes.Add(new AxisInfo("X", AxisOrientationEnum.East));
axes.Add(new AxisInfo("Y", AxisOrientationEnum.North));
}
IProjectedCoordinateSystem projectedCS = new ProjectedCoordinateSystem(geographicCS.HorizontalDatum, geographicCS, unit as LinearUnit, projection, axes, name, authority, authorityCode, String.Empty, String.Empty, String.Empty);
return projectedCS;
}
/// <summary>
/// Reads either 3, 6 or 7 parameter Bursa-Wolf values from TOWGS84 token
/// </summary>
/// <param name="tokenizer"></param>
/// <returns></returns>
private static Wgs84ConversionInfo ReadWGS84ConversionInfo(WktStreamTokenizer tokenizer)
{
//TOWGS84[0,0,0,0,0,0,0]
tokenizer.ReadToken("[");
Wgs84ConversionInfo info = new Wgs84ConversionInfo();
tokenizer.NextToken();
info.Dx = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Dy = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Dz = tokenizer.GetNumericValue();
tokenizer.NextToken();
if (tokenizer.GetStringValue() == ",")
{
tokenizer.NextToken();
info.Ex = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Ey = tokenizer.GetNumericValue();
tokenizer.ReadToken(",");
tokenizer.NextToken();
info.Ez = tokenizer.GetNumericValue();
tokenizer.NextToken();
if (tokenizer.GetStringValue() == ",")
{
tokenizer.NextToken();
info.Ppm = tokenizer.GetNumericValue();
}
}
if (tokenizer.GetStringValue() != "]")
tokenizer.ReadToken("]");
return info;
}
/// <summary>
/// Creates a <see cref="MultiLineString"/> using the next token in the stream.
/// </summary>
/// <param name="tokenizer">tokenizer over a stream of text in Well-known Text format. The next tokens must form a MultiLineString Text</param>
/// <returns>a <see cref="MultiLineString"/> specified by the next token in the stream</returns>
private static MultiLineString ReadMultiLineStringText(WktStreamTokenizer tokenizer)
{
MultiLineString lines = new MultiLineString();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return lines;
lines.LineStrings.Add(ReadLineStringText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
lines.LineStrings.Add(ReadLineStringText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
}
return lines;
}
/// <summary>
/// Returns the next number in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known text format. The next token
/// must be a number.</param>
/// <returns>Returns the next number in the stream.</returns>
/// <remarks>
/// ParseException is thrown if the next token is not a number.
/// </remarks>
private static double GetNextNumber(WktStreamTokenizer tokenizer)
{
tokenizer.NextToken();
return tokenizer.GetNumericValue();
}
/// <summary>
/// Creates a Polygon using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Polygon Text>.</param>
/// <returns>Returns a Polygon specified by the next token
/// in the stream</returns>
/// <remarks>
/// ParseException is thown if the coordinates used to create the Polygon
/// shell and holes do not form closed linestrings, or if an unexpected
/// token is encountered.
/// </remarks>
private static Polygon ReadPolygonText(WktStreamTokenizer tokenizer)
{
Polygon pol = new Polygon();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return pol;
pol.ExteriorRing = new LinearRing(GetCoordinates(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
//Add holes
pol.InteriorRings.Add(new LinearRing(GetCoordinates(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
}
return pol;
}
/// <summary>
/// Creates a <see cref="MultiPolygon"/> using the next token in the stream.
/// </summary>
/// <param name="tokenizer">tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a MultiPolygon.</param>
/// <returns>a <code>MultiPolygon</code> specified by the next token in the
/// stream, or if if the coordinates used to create the <see cref="Polygon"/>
/// shells and holes do not form closed linestrings.</returns>
private static MultiPolygon ReadMultiPolygonText(WktStreamTokenizer tokenizer)
{
MultiPolygon polygons = new MultiPolygon();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return polygons;
Polygon polygon = ReadPolygonText(tokenizer);
polygons.Polygons.Add(polygon);
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
polygon = ReadPolygonText(tokenizer);
polygons.Polygons.Add(polygon);
nextToken = GetNextCloserOrComma(tokenizer);
}
return polygons;
}
/// <summary>
/// Returns the next number in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known text format. The next token
/// must be a number.</param>
/// <returns>Returns the next number in the stream.</returns>
/// <remarks>
/// ParseException is thrown if the next token is not a number.
/// </remarks>
private static double GetNextNumber(WktStreamTokenizer tokenizer)
{
tokenizer.NextToken();
return(tokenizer.GetNumericValue());
}
/// <summary>
///
/// </summary>
/// <param name="tokenizer"></param>
/// <returns></returns>
private static IProjection ReadProjection(WktStreamTokenizer tokenizer)
{
//tokenizer.NextToken();// PROJECTION
tokenizer.ReadToken("PROJECTION");
tokenizer.ReadToken("[");//[
string projectionName = tokenizer.ReadDoubleQuotedWord();
tokenizer.ReadToken("]");//]
tokenizer.ReadToken(",");//,
tokenizer.ReadToken("PARAMETER");
List<ProjectionParameter> paramList = new List<ProjectionParameter>();
while (tokenizer.GetStringValue() == "PARAMETER")
{
tokenizer.ReadToken("[");
string paramName = tokenizer.ReadDoubleQuotedWord();
tokenizer.ReadToken(",");
tokenizer.NextToken();
double paramValue = tokenizer.GetNumericValue();
tokenizer.ReadToken("]");
tokenizer.ReadToken(",");
paramList.Add(new ProjectionParameter(paramName, paramValue));
tokenizer.NextToken();
}
string authority = String.Empty;
long authorityCode = -1;
IProjection projection = new Projection(projectionName, paramList, projectionName, authority, authorityCode, String.Empty, String.Empty, string.Empty);
return projection;
}
/// <summary>
/// Creates a LineString using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text format. The next
/// tokens must form a LineString Text.</param>
/// <param name="factory">The factory to create the result geometry</param>
/// <returns>Returns a LineString specified by the next token in the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static LineString ReadLineStringText(WktStreamTokenizer tokenizer, GeometryFactory factory)
{
return(factory.CreateLineString(GetCoordinates(tokenizer)));
}
/// <summary>
/// Creates a <see cref="GeometryCollection"/> using the next token in the stream.
/// </summary>
/// <param name="tokenizer"> Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a GeometryCollection Text.</param>
/// <returns>
/// A <see cref="GeometryCollection"/> specified by the next token in the stream.</returns>
private static GeometryCollection ReadGeometryCollectionText(WktStreamTokenizer tokenizer)
{
GeometryCollection geometries = new GeometryCollection();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken.Equals("EMPTY"))
return geometries;
geometries.Collection.Add(ReadGeometryTaggedText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken.Equals(","))
{
geometries.Collection.Add(ReadGeometryTaggedText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
}
return geometries;
}
/// <summary>
/// Creates a LineString using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text format. The next
/// tokens must form a LineString Text.</param>
/// <returns>Returns a LineString specified by the next token in the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static LineString ReadLineStringText(WktStreamTokenizer tokenizer)
{
return(new SharpMap.Geometries.LineString(GetCoordinates(tokenizer)));
}
/// <summary>
/// Creates a LineString using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text format. The next
/// tokens must form a LineString Text.</param>
/// <returns>Returns a LineString specified by the next token in the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static LineString ReadLineStringText(WktStreamTokenizer tokenizer)
{
return new SharpMap.Geometries.LineString(GetCoordinates(tokenizer));
}
/// <summary>
/// Creates a Point using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Point Text>.</param>
/// <returns>Returns a Point specified by the next token in
/// the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static Point ReadPointText(WktStreamTokenizer tokenizer)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return new Point(0,0);
var X = GetNextNumber(tokenizer);
var Y = GetNextNumber(tokenizer);
Point p = new Point(X,Y);
GetNextCloser(tokenizer);
return p;
}
/// <summary>
/// Creates a Point using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Point Text>.</param>
/// <returns>Returns a Point specified by the next token in
/// the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static MultiPoint ReadMultiPointText(WktStreamTokenizer tokenizer)
{
SharpMap.Geometries.MultiPoint mp = new MultiPoint();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return mp;
mp.Points.Add(new SharpMap.Geometries.Point(GetNextNumber(tokenizer),GetNextNumber(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
mp.Points.Add(new SharpMap.Geometries.Point(GetNextNumber(tokenizer), GetNextNumber(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
}
return mp;
}
/// <summary>
/// Returns a IUnit given a piece of WKT.
/// </summary>
/// <param name="tokenizer">WktStreamTokenizer that has the WKT.</param>
/// <returns>An object that implements the IUnit interface.</returns>
private static IUnit ReadUnit(WktStreamTokenizer tokenizer)
{
tokenizer.ReadToken("[");
string unitName = tokenizer.ReadDoubleQuotedWord();
tokenizer.ReadToken(",");
tokenizer.NextToken();
double unitsPerUnit = tokenizer.GetNumericValue();
string authority = String.Empty;
long authorityCode = -1;
tokenizer.NextToken();
if (tokenizer.GetStringValue() == ",")
{
tokenizer.ReadAuthority(ref authority, ref authorityCode);
tokenizer.ReadToken("]");
}
return new Unit(unitsPerUnit, unitName, authority, authorityCode, String.Empty, String.Empty, String.Empty);
}
/// <summary>
/// Creates a Point using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Point Text>.</param>
/// <returns>Returns a Point specified by the next token in
/// the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static Point ReadPointText(WktStreamTokenizer tokenizer)
{
Point p = new Point();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return p;
p.X = GetNextNumber(tokenizer);
p.Y = GetNextNumber(tokenizer);
GetNextCloser(tokenizer);
return p;
}
/// <summary>
/// Returns the next ")" or "," in the stream.
/// </summary>
/// <param name="tokenizer">tokenizer over a stream of text in Well-known Text
/// format. The next token must be ")" or ",".</param>
/// <returns>Returns the next ")" or "," in the stream.</returns>
/// <remarks>
/// ParseException is thrown if the next token is not ")" or ",".
/// </remarks>
private static string GetNextCloserOrComma(WktStreamTokenizer tokenizer)
{
tokenizer.NextToken();
string nextWord = tokenizer.GetStringValue();
if (nextWord == "," || nextWord == ")")
{
return nextWord;
}
throw new Exception("Expected ')' or ',' but encountered '" + nextWord + "'");
}
/// <summary>
/// Returns the next array of Coordinates in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text format. The
/// next element returned by the stream should be "(" (the beginning of "(x1 y1, x2 y2, ..., xn yn)" or
/// "EMPTY".</param>
/// <returns>The next array of Coordinates in the stream, or an empty array of "EMPTY" is the
/// next element returned by the stream.</returns>
private static Collection<Point> GetCoordinates(WktStreamTokenizer tokenizer)
{
Collection<Point> coordinates = new Collection<Point>();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return coordinates;
double X = GetNextNumber(tokenizer);
double Y = GetNextNumber(tokenizer);
Point externalCoordinate = new Point(X,Y);
coordinates.Add(externalCoordinate);
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
var Xi = GetNextNumber(tokenizer);
var Yi = GetNextNumber(tokenizer);
var internalCoordinate = new Point(Xi,Yi);
coordinates.Add(internalCoordinate);
nextToken = GetNextCloserOrComma(tokenizer);
}
return coordinates;
}
/// <summary>
/// Returns the next word in the stream as uppercase text.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next token must be a word.</param>
/// <returns>Returns the next word in the stream as uppercase text.</returns>
/// <remarks>
/// Exception is thrown if the next token is not a word.
/// </remarks>
private static string GetNextWord(WktStreamTokenizer tokenizer)
{
TokenType type = tokenizer.NextToken();
string token = tokenizer.GetStringValue();
if (type == TokenType.Number)
throw new Exception("Expected a number but got " + token);
else if (type == TokenType.Word)
return token.ToUpper();
else if (token == "(")
return "(";
else if (token == ")")
return ")";
else if (token == ",")
return ",";
throw new Exception("Not a valid symbol in WKT format.");
}
/// <summary>
/// Returns the next "EMPTY" or "(" in the stream as uppercase text.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next token must be "EMPTY" or "(".</param>
/// <returns>the next "EMPTY" or "(" in the stream as uppercase
/// text.</returns>
/// <remarks>
/// ParseException is thrown if the next token is not "EMPTY" or "(".
/// </remarks>
private static string GetNextEmptyOrOpener(WktStreamTokenizer tokenizer)
{
tokenizer.NextToken();
string nextWord = tokenizer.GetStringValue();
if (nextWord == "EMPTY" || nextWord == "(")
return nextWord;
throw new Exception("Expected 'EMPTY' or '(' but encountered '" + nextWord + "'");
}
/// <summary>
/// Creates a <see cref="MultiPolygon"/> using the next token in the stream.
/// </summary>
/// <param name="tokenizer">tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a MultiPolygon.</param>
/// <returns>a <code>MultiPolygon</code> specified by the next token in the
/// stream, or if if the coordinates used to create the <see cref="Polygon"/>
/// shells and holes do not form closed linestrings.</returns>
private static MultiPolygon ReadMultiPolygonText(WktStreamTokenizer tokenizer)
{
var arrpolys = new List<IPolygon>();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return new MultiPolygon(arrpolys.ToArray());
Polygon polygon = ReadPolygonText(tokenizer);
arrpolys.Add(polygon);
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
polygon = ReadPolygonText(tokenizer);
arrpolys.Add(polygon);
nextToken = GetNextCloserOrComma(tokenizer);
}
MultiPolygon polygons = new MultiPolygon(arrpolys.ToArray());
return polygons;
}
/// <summary>
/// Returns the next ")" in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next token must be ")".</param>
/// <returns>Returns the next ")" in the stream.</returns>
/// <remarks>
/// ParseException is thrown if the next token is not ")".
/// </remarks>
private static string GetNextCloser(WktStreamTokenizer tokenizer)
{
string nextWord = GetNextWord(tokenizer);
if (nextWord == ")")
return nextWord;
throw new Exception("Expected ')' but encountered '" + nextWord + "'");
}
/// <summary>
///
/// </summary>
/// <param name="coordinateSystem"></param>
/// <param name="tokenizer"></param>
/// <returns></returns>
private static ICoordinateSystem ReadCoordinateSystem(string coordinateSystem, WktStreamTokenizer tokenizer)
{
switch (tokenizer.GetStringValue())
{
case "GEOGCS":
return(ReadGeographicCoordinateSystem(tokenizer));
case "PROJCS":
return(ReadProjectedCoordinateSystem(tokenizer));
case "COMPD_CS":
/* ICompoundCoordinateSystem compoundCS = ReadCompoundCoordinateSystem(tokenizer);
* returnCS = compoundCS;
* break;*/
case "VERT_CS":
/* IVerticalCoordinateSystem verticalCS = ReadVerticalCoordinateSystem(tokenizer);
* returnCS = verticalCS;
* break;*/
case "GEOCCS":
case "FITTED_CS":
case "LOCAL_CS":
throw new NotSupportedException(String.Format("{0} coordinate system is not supported.", coordinateSystem));
default:
throw new InvalidOperationException(String.Format("{0} coordinate system is not recognized.", coordinateSystem));
}
}
/// <summary>
/// Creates a Geometry using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Geometry Tagged Text>.</param>
/// <returns>Returns a Geometry specified by the next token in the stream.</returns>
/// <remarks>
/// Exception is thrown if the coordinates used to create a Polygon
/// shell and holes do not form closed linestrings, or if an unexpected
/// token is encountered.
/// </remarks>
private static Geometry ReadGeometryTaggedText(WktStreamTokenizer tokenizer)
{
tokenizer.NextToken();
string type = tokenizer.GetStringValue().ToUpper();
Geometry geometry = null;
switch (type)
{
case "POINT":
geometry = ReadPointText(tokenizer);
break;
case "LINESTRING":
geometry = ReadLineStringText(tokenizer);
break;
case "MULTIPOINT":
geometry = ReadMultiPointText(tokenizer);
break;
case "MULTILINESTRING":
geometry = ReadMultiLineStringText(tokenizer);
break;
case "POLYGON":
geometry = ReadPolygonText(tokenizer);
break;
case "MULTIPOLYGON":
geometry = ReadMultiPolygonText(tokenizer);
break;
case "GEOMETRYCOLLECTION":
geometry = ReadGeometryCollectionText(tokenizer);
break;
default:
throw new Exception(String.Format(CultureInfo.InvariantCulture, "Geometrytype '{0}' is not supported.",
type));
}
return geometry;
}
/// <summary>
/// Creates a <see cref="MultiLineString"/> using the next token in the stream.
/// </summary>
/// <param name="tokenizer">tokenizer over a stream of text in Well-known Text format. The next tokens must form a MultiLineString Text</param>
/// <returns>a <see cref="MultiLineString"/> specified by the next token in the stream</returns>
private static MultiLineString ReadMultiLineStringText(WktStreamTokenizer tokenizer)
{
var arrlines = new List<ILineString>();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return new MultiLineString(arrlines.ToArray());
arrlines.Add(ReadLineStringText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
arrlines.Add(ReadLineStringText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
}
MultiLineString lines = new MultiLineString(arrlines.ToArray());
return lines;
}
/// <summary>
/// Creates a Polygon using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Polygon Text>.</param>
/// <returns>Returns a Polygon specified by the next token
/// in the stream</returns>
/// <remarks>
/// ParseException is thown if the coordinates used to create the Polygon
/// shell and holes do not form closed linestrings, or if an unexpected
/// token is encountered.
/// </remarks>
private static Polygon ReadPolygonText(WktStreamTokenizer tokenizer)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return new Polygon(new LinearRing(new List<Coordinate>().ToArray()));
var points = GetCoordinates(tokenizer);
var arrexteriorring = new Coordinate[points.Count];
for (int i = 0; i < arrexteriorring.Length; i++)
arrexteriorring[i] = new Coordinate(points[i].X, points[i].Y);
var exteriorRing = new LinearRing(arrexteriorring);
nextToken = GetNextCloserOrComma(tokenizer);
var interiorRings = new List<ILinearRing>();
while (nextToken == ",")
{
var holes = GetCoordinates(tokenizer);
var arrholes = new Coordinate[holes.Count];
for (int i = 0; i < arrholes.Length; i++)
arrholes[i] = new Coordinate(holes[i].X, holes[i].Y);
//Add holes
interiorRings.Add(new LinearRing(arrholes));
nextToken = GetNextCloserOrComma(tokenizer);
}
Polygon pol = new Polygon(exteriorRing, interiorRings.ToArray());
return pol;
}
/// <summary>
/// Creates a <see cref="GeometryCollection"/> using the next token in the stream.
/// </summary>
/// <param name="tokenizer"> Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a GeometryCollection Text.</param>
/// <returns>
/// A <see cref="GeometryCollection"/> specified by the next token in the stream.</returns>
private static GeometryCollection ReadGeometryCollectionText(WktStreamTokenizer tokenizer)
{
var arrgeometries = new List<IGeometry>();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken.Equals("EMPTY"))
return new GeometryCollection(arrgeometries.ToArray());
arrgeometries.Add(ReadGeometryTaggedText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken.Equals(","))
{
arrgeometries.Add(ReadGeometryTaggedText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
}
GeometryCollection geometries = new GeometryCollection(arrgeometries.ToArray());
return geometries;
}
/// <summary>
/// Creates a Point using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text
/// format. The next tokens must form a <Point Text>.</param>
/// <returns>Returns a Point specified by the next token in
/// the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static MultiPoint ReadMultiPointText(WktStreamTokenizer tokenizer)
{
var arrpoints = new List<IPoint>();
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return new MultiPoint(arrpoints.ToArray());
arrpoints.Add(new Point(GetNextNumber(tokenizer), GetNextNumber(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
arrpoints.Add(new Point(GetNextNumber(tokenizer), GetNextNumber(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
}
MultiPoint mp = new MultiPoint(arrpoints.ToArray());
return mp;
}
/// <summary>
///
/// </summary>
/// <param name="tokenizer"></param>
/// <returns></returns>
private static IPrimeMeridian ReadPrimeMeridian(WktStreamTokenizer tokenizer)
{
//PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]]
tokenizer.ReadToken("[");
string name = tokenizer.ReadDoubleQuotedWord();
tokenizer.ReadToken(",");
tokenizer.NextToken();
double longitude = tokenizer.GetNumericValue();
tokenizer.NextToken();
string authority = String.Empty;
long authorityCode = -1;
if (tokenizer.GetStringValue() == ",")
{
tokenizer.ReadAuthority(ref authority, ref authorityCode);
tokenizer.ReadToken("]");
}
// make an assumption about the Angular units - degrees.
IPrimeMeridian primeMeridian = new PrimeMeridian(longitude, AngularUnit.Degrees, name, authority, authorityCode, String.Empty, String.Empty, String.Empty);
return primeMeridian;
}
/// <summary>
/// Creates a LineString using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text format. The next
/// tokens must form a LineString Text.</param>
/// <returns>Returns a LineString specified by the next token in the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static LineString ReadLineStringText(WktStreamTokenizer tokenizer)
{
var points = GetCoordinates(tokenizer);
var arrcoordinate = new Coordinate[points.Count];
for(int i=0; i<arrcoordinate.Length; i++)
{
arrcoordinate[i] = new Coordinate(points[i].X, points[i].Y);
}
return new LineString(arrcoordinate);
}
/// <summary>
/// Creates a LineString using the next token in the stream.
/// </summary>
/// <param name="tokenizer">Tokenizer over a stream of text in Well-known Text format. The next
/// tokens must form a LineString Text.</param>
/// <returns>Returns a LineString specified by the next token in the stream.</returns>
/// <remarks>
/// ParseException is thrown if an unexpected token is encountered.
/// </remarks>
private static LineString ReadLineStringText(WktStreamTokenizer tokenizer)
{
return(new LineString(GetCoordinates(tokenizer)));
}
/// <summary>
/// Converts a Well-known Text representation to a <see cref="SharpMap.Geometries.Geometry"/>.
/// </summary>
/// <param name="reader">A Reader which will return a Geometry Tagged Text
/// string (see the OpenGIS Simple Features Specification)</param>
/// <returns>Returns a <see cref="SharpMap.Geometries.Geometry"/> read from StreamReader.
/// An exception will be thrown if there is a parsing problem.</returns>
public static Geometry Parse(TextReader reader)
{
WktStreamTokenizer tokenizer = new WktStreamTokenizer(reader);
return ReadGeometryTaggedText(tokenizer);
}
/// <summary>
///
/// </summary>
/// <param name="tokenizer"></param>
/// <returns></returns>
private static IProjectedCoordinateSystem ReadProjectedCoordinateSystem(WktStreamTokenizer tokenizer)
{
/*PROJCS[
* "OSGB 1936 / British National Grid",
* GEOGCS[
* "OSGB 1936",
* DATUM[...]
* PRIMEM[...]
* AXIS["Geodetic latitude","NORTH"]
* AXIS["Geodetic longitude","EAST"]
* AUTHORITY["EPSG","4277"]
* ],
* PROJECTION["Transverse Mercator"],
* PARAMETER["latitude_of_natural_origin",49],
* PARAMETER["longitude_of_natural_origin",-2],
* PARAMETER["scale_factor_at_natural_origin",0.999601272],
* PARAMETER["false_easting",400000],
* PARAMETER["false_northing",-100000],
* AXIS["Easting","EAST"],
* AXIS["Northing","NORTH"],
* AUTHORITY["EPSG","27700"]
* ]
*/
tokenizer.ReadToken("[");
string name = tokenizer.ReadDoubleQuotedWord();
tokenizer.ReadToken(",");
tokenizer.ReadToken("GEOGCS");
IGeographicCoordinateSystem geographicCS = ReadGeographicCoordinateSystem(tokenizer);
tokenizer.ReadToken(",");
IProjection projection = ReadProjection(tokenizer);
IUnit unit = ReadLinearUnit(tokenizer);
string authority = String.Empty;
long authorityCode = -1;
tokenizer.NextToken();
List <AxisInfo> axes = new List <AxisInfo>(2);
if (tokenizer.GetStringValue() == ",")
{
tokenizer.NextToken();
while (tokenizer.GetStringValue() == "AXIS")
{
axes.Add(ReadAxis(tokenizer));
tokenizer.NextToken();
}
if (tokenizer.GetStringValue() == "AUTHORITY")
{
tokenizer.ReadAuthority(ref authority, ref authorityCode);
tokenizer.ReadToken("]");
}
}
//This is default axis values if not specified.
if (axes.Count == 0)
{
axes.Add(new AxisInfo("X", AxisOrientationEnum.East));
axes.Add(new AxisInfo("Y", AxisOrientationEnum.North));
}
IProjectedCoordinateSystem projectedCS = new ProjectedCoordinateSystem(geographicCS.HorizontalDatum, geographicCS, unit as LinearUnit, projection, axes, name, authority, authorityCode, String.Empty, String.Empty, String.Empty);
return(projectedCS);
}
