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