Exemplo n.º 1
0
        /// <summary>
        /// Parses a GeometryCollection text.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <param name="is3D">bool value indicating whether GeometryCollection being parsed has z-coordinate.</param>
        /// <param name="isMeasured">bool value indicating whether GeometryCollection being parsed has m-value.</param>
        /// <returns>A GeometryCollection specified by tokens.</returns>
        /// <remarks><![CDATA[<GeometryCollection text> ::= <empty set> | <left paren> <geometry tagged text> {<comma> <geometry tagged text>}* <right paren>]]></remarks>
        private static GeometryCollection <Geometry> ParseGeometryCollectionText(WktTokensBuffer tokens, bool is3D, bool isMeasured)
        {
            WktToken t = tokens.Peek(true);

            if (t.Type == TokenType.STRING && t.Value.ToUpperInvariant() == "EMPTY")
            {
                tokens.GetToken(true);
                return(new GeometryCollection <Geometry>());
            }

            WktReader.Expect(TokenType.LEFT_PARENTHESIS, tokens);

            GeometryCollection <Geometry> result = new GeometryCollection <Geometry>();

            result.Geometries.Add(WktReader.ParseGeometryTaggedText(tokens));

            t = tokens.Peek(true);
            while (t.Type == TokenType.COMMA)
            {
                tokens.GetToken(true);
                result.Geometries.Add(WktReader.ParseGeometryTaggedText(tokens));
                t = tokens.Peek(true);
            }

            WktReader.Expect(TokenType.RIGHT_PARENTHESIS, tokens);

            return(result);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Parses a coordinate.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <param name="is3D">bool value indicating whether coordinate being parsed had z-coordinate.</param>
        /// <param name="isMeasured">bool value indicating whether coordinate beeing parsed has m-value.</param>
        /// <returns>A coordinate specified by tokens.</returns>
        /// <remarks><![CDATA[<x> <y> {<z>} {<m>}]]></remarks>
        private static Coordinate ParseCoordinate(WktTokensBuffer tokens, bool is3D, bool isMeasured)
        {
            WktToken t = WktReader.Expect(TokenType.NUMBER, tokens);
            double   x = double.Parse(t.Value, _invarianCulture);

            WktReader.Expect(TokenType.WHITESPACE, tokens);

            t = WktReader.Expect(TokenType.NUMBER, tokens);
            double y = double.Parse(t.Value, _invarianCulture);

            double z = double.NaN;
            double m = double.NaN;

            if (is3D)
            {
                WktReader.Expect(TokenType.WHITESPACE, tokens);

                t = WktReader.Expect(TokenType.NUMBER, tokens);
                z = double.Parse(t.Value, _invarianCulture);
            }

            if (isMeasured)
            {
                WktReader.Expect(TokenType.WHITESPACE, tokens);

                t = WktReader.Expect(TokenType.NUMBER, tokens);
                m = double.Parse(t.Value, _invarianCulture);
            }

            return(new Coordinate(x, y, z, m));
        }
Exemplo n.º 3
0
        /// <summary>
        /// Parses a multipolygon text.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <param name="is3D">bool value indicating whether multipolygon being parsed has z-coordinate.</param>
        /// <param name="isMeasured">bool value indicating whether multipolygon being parsed has m-value.</param>
        /// <returns>A multipolygon specified by tokens.</returns>
        /// <remarks><![CDATA[<multipolygon text> ::= <empty set> | <left paren> <polygon text> {<comma> <polygon text>}* <right paren>]]></remarks>
        private static MultiPolygon ParseMultiPolygonText(WktTokensBuffer tokens, bool is3D, bool isMeasured)
        {
            WktToken t = tokens.Peek(true);

            if (t.Type == TokenType.STRING && t.Value.ToUpperInvariant() == "EMPTY")
            {
                tokens.GetToken(true);
                return(new MultiPolygon());
            }

            WktReader.Expect(TokenType.LEFT_PARENTHESIS, tokens);
            MultiPolygon result = new MultiPolygon(WktReader.ParsePolygons(tokens, is3D, isMeasured));

            WktReader.Expect(TokenType.RIGHT_PARENTHESIS, tokens);

            return(result);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Parses series of polygons.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <param name="is3D">bool value indicating whether polygon being parsed has z-coordinate.</param>
        /// <param name="isMeasured">bool value indicating whether polygon being parsed has m-value.</param>
        /// <returns>A list of polygons specified by tokens.</returns>
        private static IEnumerable <Polygon> ParsePolygons(WktTokensBuffer tokens, bool is3D, bool isMeasured)
        {
            List <Polygon> polygons = new List <Polygon>();

            polygons.Add(WktReader.ParsePolygonText(tokens, is3D, isMeasured));

            WktToken t = tokens.Peek(true);

            while (t.Type == TokenType.COMMA)
            {
                tokens.GetToken(true);
                polygons.Add(WktReader.ParsePolygonText(tokens, is3D, isMeasured));
                t = tokens.Peek(true);
            }

            return(polygons);
        }
Exemplo n.º 5
0
        /// <summary>
        /// Parses a linestring text.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <param name="is3D">bool value indicating whether linestring being parsed has z-coordinate.</param>
        /// <param name="isMeasured">bool value indicating whether linestring being parsed has m-value.</param>
        /// <returns>A linestring specified by tokens.</returns>
        /// <remarks><![CDATA[<empty set> | <left paren> <point> {<comma> <point>}* <right paren>]]></remarks>
        private static LineString ParseLineStringText(WktTokensBuffer tokens, bool is3D, bool isMeasured)
        {
            WktToken t = tokens.Peek(true);

            if (t.Type == TokenType.STRING && t.Value.ToUpperInvariant() == "EMPTY")
            {
                tokens.GetToken(true);
                return(new LineString());
            }

            WktReader.Expect(TokenType.LEFT_PARENTHESIS, tokens);
            IEnumerable <Coordinate> coords = WktReader.ParseCoordinates(tokens, is3D, isMeasured);

            WktReader.Expect(TokenType.RIGHT_PARENTHESIS, tokens);

            return(new LineString(coords));
        }
Exemplo n.º 6
0
        /// <summary>
        /// Parses multiple Points separated by comma.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <param name="is3D">bool value indicating whether point being parsed had z-coordinate.</param>
        /// <param name="isMeasured">bool value indicating whether point being parsed has m-value.</param>
        /// <returns>A list of point specified by tokens.</returns>
        private static List <Point> ParsePoints(WktTokensBuffer tokens, bool is3D, bool isMeasured)
        {
            List <Point> points = new List <Point>();

            points.Add(WktReader.ParsePointText(tokens, is3D, isMeasured));

            WktToken t = tokens.Peek(true);

            while (t.Type == TokenType.COMMA)
            {
                tokens.GetToken(true);
                points.Add(WktReader.ParsePointText(tokens, is3D, isMeasured));
                t = tokens.Peek(true);
            }

            return(points);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Parses multiple LineStrings separated by comma.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <param name="is3D">bool value indicating whether linestring being parsed had z-coordinate.</param>
        /// <param name="isMeasured">bool value indicating whether linestring being parsed has m-value.</param>
        /// <returns>A list of linestrings specified by tokens.</returns>
        private static List <LineString> ParseLineStrings(WktTokensBuffer tokens, bool is3D, bool isMeasured)
        {
            List <LineString> linestrigns = new List <LineString>();

            linestrigns.Add(WktReader.ParseLineStringText(tokens, is3D, isMeasured));

            WktToken t = tokens.Peek(true);

            while (t.Type == TokenType.COMMA)
            {
                tokens.GetToken(true);
                linestrigns.Add(WktReader.ParseLineStringText(tokens, is3D, isMeasured));
                t = tokens.Peek(true);
            }

            return(linestrigns);
        }
Exemplo n.º 8
0
        /// <summary>
        /// Parses a multipolyugon tagged text.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <returns>A multipolygon specified by tokens.</returns>
        /// <remarks><![CDATA[<multipolygon tagged text> ::=  multipolygon {z}{m} <multipolygon text>]]></remarks>
        private static MultiPolygon ParseMultiPolygonTaggedText(WktTokensBuffer tokens)
        {
            WktReader.Expect("multipolygon", tokens);
            WktReader.Expect(TokenType.WHITESPACE, tokens);

            bool is3D       = false;
            bool isMeasured = false;

            WktToken t = tokens.Peek(true);

            if (WktReader.TryParseDimensions(t, out is3D, out isMeasured))
            {
                tokens.GetToken(true);
                WktReader.Expect(TokenType.WHITESPACE, tokens);
            }

            return(WktReader.ParseMultiPolygonText(tokens, is3D, isMeasured));
        }
Exemplo n.º 9
0
        /// <summary>
        /// Parses a linestring tagged text.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <returns>A linestring specified by tokens.</returns>
        /// <remarks><![CDATA[<linestring tagged text> ::=  linestring {z}{m} <linestring text>]]></remarks>
        private static LineString ParseLineStringTaggedText(WktTokensBuffer tokens)
        {
            WktReader.Expect("linestring", tokens);
            WktReader.Expect(TokenType.WHITESPACE, tokens);

            bool is3D       = false;
            bool isMeasured = false;

            WktToken t = tokens.Peek(true);

            if (WktReader.TryParseDimensions(t, out is3D, out isMeasured))
            {
                tokens.GetToken(true);
                WktReader.Expect(TokenType.WHITESPACE, tokens);
            }

            return(WktReader.ParseLineStringText(tokens, is3D, isMeasured));
        }
Exemplo n.º 10
0
        /// <summary>
        /// Parses a series of coordinate.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <param name="is3D">bool value indicating whether coordinate being parsed had z-coordinate.</param>
        /// <param name="isMeasured">bool value indicating whether coordinate beeing parsed has m-value.</param>
        /// <returns>A list of coordinates specified by tokens.</returns>
        private static IEnumerable <Coordinate> ParseCoordinates(WktTokensBuffer tokens, bool is3D, bool isMeasured)
        {
            List <Coordinate> coordinates = new List <Coordinate>();

            coordinates.Add(WktReader.ParseCoordinate(tokens, is3D, isMeasured));

            WktToken t = tokens.Peek(true);

            while (t.Type == TokenType.COMMA)
            {
                tokens.GetToken(true);
                WktReader.Expect(TokenType.WHITESPACE, tokens);
                coordinates.Add(WktReader.ParseCoordinate(tokens, is3D, isMeasured));
                t = tokens.Peek(true);
            }

            return(coordinates);
        }
Exemplo n.º 11
0
        /// <summary>
        /// Parses a multipolyugon tagged text.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <returns>A GeometryCollection specified by tokens.</returns>
        /// <remarks><![CDATA[<GeometryCollection tagged text> ::=  GeometryCollection {z}{m} <GeometryCollection text>]]></remarks>
        private static GeometryCollection <Geometry> ParseGeometryCollectionTaggedText(WktTokensBuffer tokens)
        {
            WktReader.Expect("geometrycollection", tokens);
            WktReader.Expect(TokenType.WHITESPACE, tokens);

            bool is3D       = false;
            bool isMeasured = false;

            WktToken t = tokens.Peek(true);

            if (WktReader.TryParseDimensions(t, out is3D, out isMeasured))
            {
                tokens.GetToken(true);
                WktReader.Expect(TokenType.WHITESPACE, tokens);
            }

            return(WktReader.ParseGeometryCollectionText(tokens, is3D, isMeasured));
        }
Exemplo n.º 12
0
        /// <summary>
        /// Reads next geometry from the input.
        /// </summary>
        /// <typeparam name="T">The type of Geometry to be parsed.</typeparam>
        /// <returns>The geometry object of specific type read from the reader or null if no more geometries are available.</returns>
        public T Read <T>() where T : Geometry
        {
            Geometry parsed = WktReader.ParseGeometryTaggedText(_tokens);

            if (parsed != null)
            {
                T result = parsed as T;
                if (result == null)
                {
                    throw new WktParseException("Input doesn't contain valid WKB representation of the specified geometry type.");
                }

                return(result);
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 13
0
        /// <summary>
        /// Parses a geometry tagged text.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <returns>A geometry specified by tokens.</returns>
        private static Geometry ParseGeometryTaggedText(WktTokensBuffer tokens)
        {
            WktToken t = tokens.Peek(true);

            if (t.Type == TokenType.STRING)
            {
                if (t.Value.ToUpperInvariant() == "POINT")
                {
                    return(WktReader.ParsePointTaggedText(tokens));
                }
                else if (t.Value.ToUpperInvariant() == "LINESTRING")
                {
                    return(WktReader.ParseLineStringTaggedText(tokens));
                }
                else if (t.Value.ToUpperInvariant() == "POLYGON")
                {
                    return(WktReader.ParsePolygonTaggedText(tokens));
                }
                else if (t.Value.ToUpperInvariant() == "MULTIPOINT")
                {
                    return(WktReader.ParseMultiPointTaggedText(tokens));
                }
                else if (t.Value.ToUpperInvariant() == "MULTILINESTRING")
                {
                    return(WktReader.ParseMultiLineStringTaggedText(tokens));
                }
                else if (t.Value.ToUpperInvariant() == "MULTIPOLYGON")
                {
                    return(WktReader.ParseMultiPolygonTaggedText(tokens));
                }
                else if (t.Value.ToUpperInvariant() == "GEOMETRYCOLLECTION")
                {
                    return(WktReader.ParseGeometryCollectionTaggedText(tokens));
                }
            }

            if (t.Type == TokenType.END_OF_DATA)
            {
                return(null);
            }

            throw new WktParseException(string.Format("Invalid geometry type '{0}'", t.Value));
        }
Exemplo n.º 14
0
        /// <summary>
        /// Parses a Geometry of specific type from the WKT string.
        /// </summary>
        /// <typeparam name="T">The type of the Geometry to be parsed.</typeparam>
        /// <param name="wkt">The string with WKT representation of a Geometry.</param>
        /// <returns>The parsed Geometry of given type.</returns>
        public static T Parse <T>(string wkt) where T : Geometry
        {
            Geometry parsed = WktReader.Parse(wkt);

            if (parsed != null)
            {
                T result = parsed as T;
                if (result == null)
                {
                    throw new WktParseException("Input doesn't contain valid WKB representation of the specified geometry type.");
                }

                return(result);
            }
            else
            {
                return(null);
            }
        }
Exemplo n.º 15
0
        /// <summary>
        /// Parses a polygon text.
        /// </summary>
        /// <param name="tokens">The list of tokens.</param>
        /// <param name="is3D">bool value indicating whether polygon being parsed has z-coordinate.</param>
        /// <param name="isMeasured">bool value indicating whether polygon being parsed has m-value.</param>
        /// <returns>A polygon specified by tokens.</returns>
        /// <remarks><![CDATA[<empty set> | <left paren> <linestring text> {<comma> <linestring text>}* <right paren>]]></remarks>
        private static Polygon ParsePolygonText(WktTokensBuffer tokens, bool is3D, bool isMeasured)
        {
            WktToken t = tokens.Peek(true);

            if (t.Type == TokenType.STRING && t.Value.ToUpperInvariant() == "EMPTY")
            {
                tokens.GetToken(true);
                return(new Polygon());
            }

            WktReader.Expect(TokenType.LEFT_PARENTHESIS, tokens);

            IEnumerable <LineString> linestrings = WktReader.ParseLineStrings(tokens, is3D, isMeasured);
            Polygon result = new Polygon(linestrings.First().Coordinates);

            foreach (var inner in linestrings.Skip(1))
            {
                result.InteriorRings.Add(inner.Coordinates);
            }

            WktReader.Expect(TokenType.RIGHT_PARENTHESIS, tokens);

            return(result);
        }
Exemplo n.º 16
0
 /// <summary>
 /// Reads next geometry from the input.
 /// </summary>
 /// <returns>The geometry object read from the reader or null if no more geometries are available.</returns>
 public Geometry Read()
 {
     return(WktReader.ParseGeometryTaggedText(_tokens));
 }
Exemplo n.º 17
0
        /// <summary>
        /// Parses a Geometry from WKT string.
        /// </summary>
        /// <param name="wkt">The string with WKT representation of a Geometry.</param>
        /// <returns>The parsed Geometry.</returns>
        public static Geometry Parse(string wkt)
        {
            WktTokensBuffer tokens = new WktTokensBuffer(WktTokenizer.Tokenize(wkt));

            return(WktReader.ParseGeometryTaggedText(tokens));
        }