/// <summary>
/// Reads a projected coordinate system.
/// </summary>
private static IProjectedCoordinateSystem ReadProjectedCoordinateSystem(WktStreamTokenizer tokenizer)
{
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() == ",")
{
tokenizer.NextToken();
}
}
if (tokenizer.GetStringValue() == ",")
{
tokenizer.NextToken();
}
if (tokenizer.GetStringValue() == "AUTHORITY")
{
//tokenizer.ReadAuthority(ref authority, ref authorityCode);
ReadAuthority(tokenizer, 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);
}
private static List <ICoordinate> readPointCoordsList(WktStreamTokenizer tokenizer)
{
List <ICoordinate> points = new List <ICoordinate>();
bool comma = true;
while (comma)
{
points.Add(readPointCoords(tokenizer));
tokenizer.NextToken();
comma = tokenizer.GetStringValue() == ",";
}
return(points);
}
public void TestReadAuthority2()
{
StringReader reader = new StringReader("OPPS[\"EPSG\",\"9102\"]");
WktStreamTokenizer tokenizer = new WktStreamTokenizer(reader);
string authority = "";
string authorityCode = "";
try
{
tokenizer.ReadAuthority(ref authority, ref authorityCode);
}
catch (ParseException)
{
}
}
/// <summary>
/// Constructs a coordinate system object from well-known text.
/// </summary>
/// <param name="wkt">Well-known text representation of object</param>
/// <returns>An object constructed from well-known text</returns>
/// <exception cref="System.ArgumentException">Raises when parsing of string fails.</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 recognized.", objectName));
}
reader.Close();
return(returnObject);
}
private static Polyline readLineString(WktStreamTokenizer tokenizer)
{
tokenizer.ReadToken("(");
List <ICoordinate> points = readPointCoordsList(tokenizer);
if (tokenizer.GetStringValue() == ")")
{
Polyline polyline = new Polyline();
polyline.Paths.Add(new LinePath());
polyline.Paths[0].Vertices = points;
return(polyline);
}
else
{
throwMissingCloseBracket(tokenizer);
}
return(null);
}
/// <summary>
/// Reads a WGS84 conversion info.
/// </summary>
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>
/// Reads am authority and authority code.
/// </summary>
private static void ReadAuthority(WktStreamTokenizer tokenizer, ref string authority, ref long authorityCode)
{
if (tokenizer.GetStringValue() != "AUTHORITY")
{
tokenizer.ReadToken("AUTHORITY");
}
tokenizer.ReadToken("[");
authority = tokenizer.ReadDoubleQuotedWord();
tokenizer.ReadToken(",");
#if (!Silverlight)
long.TryParse(tokenizer.ReadDoubleQuotedWord(),
NumberStyles.Any,
CultureInfo.InvariantCulture.NumberFormat,
out authorityCode);
#else
try { authorityCode = long.Parse(tokenizer.ReadDoubleQuotedWord(), System.Globalization.NumberStyles.Any, System.Globalization.CultureInfo.InvariantCulture.NumberFormat); }
catch { }
#endif
tokenizer.ReadToken("]");
}
/// <summary>
/// Reads an anglular unit.
/// </summary>
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);
ReadAuthority(tokenizer, ref authority, ref authorityCode);
tokenizer.ReadToken("]");
}
return(new AngularUnit(unitsPerUnit, unitName, authority, authorityCode, String.Empty, String.Empty, String.Empty));
}
private static List <List <ICoordinate> > readPointsCoordLists(WktStreamTokenizer tokenizer)
{
List <List <ICoordinate> > result = new List <List <ICoordinate> >();
bool comma = true;
while (comma)
{
tokenizer.ReadToken("(");
result.Add(readPointCoordsList(tokenizer));
if (tokenizer.GetStringValue() == ")")
{
tokenizer.NextToken();
comma = tokenizer.GetStringValue() == ",";
}
else
{
throwMissingCloseBracket(tokenizer);
}
}
return(result);
}
private static Polyline readMultiLineString(WktStreamTokenizer tokenizer)
{
tokenizer.ReadToken("(");
List <List <ICoordinate> > lists = readPointsCoordLists(tokenizer);
if (tokenizer.GetStringValue() == ")")
{
Polyline polyline = new Polyline();
foreach (List <ICoordinate> list in lists)
{
LinePath path = new LinePath();
path.Vertices = list;
polyline.Paths.Add(path);
}
return(polyline);
}
else
{
throwMissingCloseBracket(tokenizer);
}
return(null);
}
/// <summary>
/// Constructs a geometry from its well-known text representation.
/// </summary>
/// <returns>A constructed geometry</returns>
public static IGeometry GeometryFromWKT(string wkt)
{
StringReader sr = new StringReader(wkt);
WktStreamTokenizer tokenizer = new WktStreamTokenizer(sr);
tokenizer.NextToken();
switch (tokenizer.GetStringValue().ToUpper())
{
case "POINT": return(readPoint(tokenizer));
case "LINESTRING": return(readLineString(tokenizer));
case "MULTILINESTRING": return(readMultiLineString(tokenizer));
case "POLYGON": return(readPolygon(tokenizer));
case "MULTIPOLYGON": return(readMultiPolygon(tokenizer));
case "MULTIPOINT": return(readMultiPoint(tokenizer));
}
throw new ArgumentException(string.Format("Unknown geometry \"{0}\"", tokenizer.GetStringValue()));
}
private static Polygon readPolygon(WktStreamTokenizer tokenizer)
{
tokenizer.ReadToken("(");
List <List <ICoordinate> > lists = readPointsCoordLists(tokenizer);
if (tokenizer.GetStringValue() == ")")
{
Polygon polygon = new Polygon();
foreach (List <ICoordinate> list in lists)
{
Contour contour = new Contour();
list.RemoveAt(list.Count - 1);
contour.Vertices = list;
polygon.Contours.Add(contour);
}
return(polygon);
}
else
{
throwMissingCloseBracket(tokenizer);
}
return(null);
}
/// <summary>
/// Reads a prime meridian.
/// </summary>
private static IPrimeMeridian ReadPrimeMeridian(WktStreamTokenizer tokenizer)
{
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() == ",")
{
ReadAuthority(tokenizer, ref authority, ref authorityCode);
tokenizer.ReadToken("]");
}
IPrimeMeridian primeMeridian = new PrimeMeridian(longitude, AngularUnit.Degrees, name, authority, authorityCode, String.Empty, String.Empty, String.Empty);
return(primeMeridian);
}
/// <summary>
/// Creates a <see cref="IMultiPolygon"/> 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="IPolygon"/>
/// shells and holes do not form closed linestrings.</returns>
private static IMultiPolygon ReadMultiPolygonText(WktStreamTokenizer tokenizer, IGeometryFactory factory)
{
var polygons = new List<IPolygon>();
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 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 IGeometry ReadGeometryTaggedText(WktStreamTokenizer tokenizer)
{
tokenizer.NextToken();
var type = tokenizer.GetStringValue().ToUpper();
IGeometry geometry;
IGeometryFactory 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>
/// 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);
if (type == TokenType.Word)
return token.ToUpper();
if (token == "(")
return "(";
if (token == ")")
return ")";
if (token == ",")
return ",";
throw new Exception("Not a valid symbol in WKT format.");
}
/// <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>
/// 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>
/// 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 IMultiPoint ReadMultiPointText(WktStreamTokenizer tokenizer, IGeometryFactory factory)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return factory.CreateMultiPoint((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.CreateMultiPoint(points.ToArray());
}
/// <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 ILineString ReadLineStringText(WktStreamTokenizer tokenizer, IGeometryFactory factory)
{
return factory.CreateLineString(GetCoordinates(tokenizer));
}
/// <summary>
/// Reads a coordinate system.
/// </summary>
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 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 IPolygon ReadPolygonText(WktStreamTokenizer tokenizer, IGeometryFactory 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<ILinearRing>();
while (nextToken == ",")
{
//Add holes
interiorRings.Add(factory.CreateLinearRing(GetCoordinates(tokenizer)));
nextToken = GetNextCloserOrComma(tokenizer);
}
return factory.CreatePolygon(exteriorRing, interiorRings.ToArray());
}
/// <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 IPoint ReadPointText(WktStreamTokenizer tokenizer, IGeometryFactory 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>
/// 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 <see cref="IMultiLineString"/> 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 IMultiLineString ReadMultiLineStringText(WktStreamTokenizer tokenizer, IGeometryFactory factory)
{
string nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken == "EMPTY")
return factory.CreateMultiLineString(null);
var lineStrings = new List<ILineString>();
lineStrings.Add(ReadLineStringText(tokenizer, factory));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken == ",")
{
lineStrings.Add(ReadLineStringText(tokenizer, factory));
nextToken = GetNextCloserOrComma(tokenizer);
}
return factory.CreateMultiLineString(lineStrings.ToArray());
}
/// <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="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 IGeometryCollection ReadGeometryCollectionText(WktStreamTokenizer tokenizer, IGeometryFactory factory)
{
var nextToken = GetNextEmptyOrOpener(tokenizer);
if (nextToken.Equals("EMPTY"))
return factory.CreateGeometryCollection(null);
var geometries = new List<IGeometry>();
geometries.Add(ReadGeometryTaggedText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
while (nextToken.Equals(","))
{
geometries.Add(ReadGeometryTaggedText(tokenizer));
nextToken = GetNextCloserOrComma(tokenizer);
}
return factory.CreateGeometryCollection(geometries.ToArray());
}
/// <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();
}
