/// <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(); }