Thuban/Model/wellknowntext.py

# Copyright (C) 2002, 2003 Intevation GmbH <[email protected]>
# Author: Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file GPL coming with the software for details.

"""Convert Well-Known Text format to python objects

Main entry point is the convert_well_known_text function which takes a
geometry in Well-Known Text format and returns a python object with the
geometry.
"""

__version__ = "$Revision$"
# $Source$
# $Id$

import re


_open_parens = r"[ \t]*(\([ \t]*)*"
_close_parens = r"[ \t]*(\)[ \t]*)+"
rx_point_list = re.compile(_open_parens + r"(?P<coords>[^\)]+)"
                           + _close_parens + ",?")


def parse_coordinate_lists(wkt):
    """Return the coordinates in wkt as a list of lists of coordinate pairs.

    The wkt parameter is the coordinate part of a geometry in well-known
    text format.
    """
    geometry = []
    while wkt:
        match = rx_point_list.match(wkt)
        if match:
            poly = []
            wktcoords = match.group("coords")
            for pair in wktcoords.split(","):
                # a pair may be a triple actually. For now we just
                # ignore any third value
                x, y = map(float, pair.split())[:2]
                poly.append((x, y))
            geometry.append(poly)
            wkt = wkt[match.end(0):].strip()
        else:
            raise ValueError("Invalid well-known-text (WKT) syntax")
    return geometry


def parse_multipolygon(wkt):
    """
    Return the MULTIPOLYGON geometry wkt as a list of lists of float pairs
    """
    return parse_coordinate_lists(wkt)

def parse_polygon(wkt):
    """Return the POLYGON geometry in wkt as a list of float pairs"""
    return parse_coordinate_lists(wkt)

def parse_multilinestring(wkt):
    """
    Return the MULTILINESTRING geometry wkt as a list of lists of float pairs
    """
    return parse_coordinate_lists(wkt)

def parse_linestring(wkt):
    """Return the LINESTRING geometry in wkt as a list of float pairs"""
    return parse_coordinate_lists(wkt)[0]

def parse_point(wkt):
    """Return the POINT geometry in wkt format as pair of floats"""
    return parse_coordinate_lists(wkt)[0][0]


# map geometry types to parser functions
_function_map = [
    ("MULTIPOLYGON", parse_multipolygon),
    ("POLYGON", parse_polygon),
    ("MULTILINESTRING", parse_multilinestring),
    ("LINESTRING", parse_linestring),
    ("POINT", parse_point),
    ]

def convert_well_known_text(wkt):
    """Return the geometry given in well-known text format as python objects

    The function accepts only 2D data and supports the POINT, POLYGON,
    MULTIPOLYGON, LINESTRING and MULTILINESTRING geometries.

    The structure of the return value depends on the geometry type. For
    MULTIPOLYGON and MULTILINESTRING return a list of lists of
    coordinate pairs. For POLYGON and LINESTRING return a list of
    coordinate pairs. For POINT return a coordinate pair. All
    coordinates are floats.

    The string wkt may contain an SRID specification in addition to the
    actual geometry. This SRID is ignored.
    """
    parts = wkt.split(";")
    for part in parts:
        part = part.strip()
        if part.startswith("SRID"):
            # ignore SRIDs
            continue
        else:
            for geotype, function in _function_map:
                if part.startswith(geotype):
                    return function(part[len(geotype):])
            else:
                raise ValueError("Unsupported WKT-part %s" % repr(part[:20]))
    else:
        # there were no recognized geometries in the WKT string
        raise ValueError("No recognized geometry in WKT string")

def parse_wkt_thuban(wkt):
    """Like convert_well_known_text, but return lists of lists of pairs"""
    parts = wkt.split(";")
    for part in parts:
        part = part.strip()
        if part.startswith("SRID"):
            # ignore SRIDs
            continue
        else:
            # split on "(" to separate the geometry type from the
            # coordinate values
            components = part.split("(", 1)
            if len(components) > 1:
                return parse_coordinate_lists(components[1])
            else:
                raise ValueError("WKT part %r doesn't contain opening"
                                 " parenthesis" % part)
    else:
        # there were no recognized geometries in the WKT string
        raise ValueError("No recognized geometry in WKT string")
1	# Copyright (C) 2002, 2003 Intevation GmbH <[email protected]>
2	# Author: Bernhard Herzog <[email protected]>
3	#
4	# This program is free software under the GPL (>=v2)
5	# Read the file GPL coming with the software for details.
6
7	"""Convert Well-Known Text format to python objects
8
9	Main entry point is the convert_well_known_text function which takes a
10	geometry in Well-Known Text format and returns a python object with the
11	geometry.
12	"""
13
14	__version__ = "$Revision$"
15	# $Source$
16	# $Id$
17
18	import re
19
20
21	_open_parens = r"[ \t](\([ \t])*"
22	_close_parens = r"[ \t](\)[ \t])+"
23	rx_point_list = re.compile(_open_parens + r"(?P<coords>[^\)]+)"
24	+ _close_parens + ",?")
25
26
27	def parse_coordinate_lists(wkt):
28	"""Return the coordinates in wkt as a list of lists of coordinate pairs.
29
30	The wkt parameter is the coordinate part of a geometry in well-known
31	text format.
32	"""
33	geometry = []
34	while wkt:
35	match = rx_point_list.match(wkt)
36	if match:
37	poly = []
38	wktcoords = match.group("coords")
39	for pair in wktcoords.split(","):
40	# a pair may be a triple actually. For now we just
41	# ignore any third value
42	x, y = map(float, pair.split())[:2]
43	poly.append((x, y))
44	geometry.append(poly)
45	wkt = wkt[match.end(0):].strip()
46	else:
47	raise ValueError("Invalid well-known-text (WKT) syntax")
48	return geometry
49
50
51	def parse_multipolygon(wkt):
52	"""
53	Return the MULTIPOLYGON geometry wkt as a list of lists of float pairs
54	"""
55	return parse_coordinate_lists(wkt)
56
57	def parse_polygon(wkt):
58	"""Return the POLYGON geometry in wkt as a list of float pairs"""
59	return parse_coordinate_lists(wkt)
60
61	def parse_multilinestring(wkt):
62	"""
63	Return the MULTILINESTRING geometry wkt as a list of lists of float pairs
64	"""
65	return parse_coordinate_lists(wkt)
66
67	def parse_linestring(wkt):
68	"""Return the LINESTRING geometry in wkt as a list of float pairs"""
69	return parse_coordinate_lists(wkt)[0]
70
71	def parse_point(wkt):
72	"""Return the POINT geometry in wkt format as pair of floats"""
73	return parse_coordinate_lists(wkt)[0][0]
74
75
76	# map geometry types to parser functions
77	_function_map = [
78	("MULTIPOLYGON", parse_multipolygon),
79	("POLYGON", parse_polygon),
80	("MULTILINESTRING", parse_multilinestring),
81	("LINESTRING", parse_linestring),
82	("POINT", parse_point),
83	]
84
85	def convert_well_known_text(wkt):
86	"""Return the geometry given in well-known text format as python objects
87
88	The function accepts only 2D data and supports the POINT, POLYGON,
89	MULTIPOLYGON, LINESTRING and MULTILINESTRING geometries.
90
91	The structure of the return value depends on the geometry type. For
92	MULTIPOLYGON and MULTILINESTRING return a list of lists of
93	coordinate pairs. For POLYGON and LINESTRING return a list of
94	coordinate pairs. For POINT return a coordinate pair. All
95	coordinates are floats.
96
97	The string wkt may contain an SRID specification in addition to the
98	actual geometry. This SRID is ignored.
99	"""
100	parts = wkt.split(";")
101	for part in parts:
102	part = part.strip()
103	if part.startswith("SRID"):
104	# ignore SRIDs
105	continue
106	else:
107	for geotype, function in _function_map:
108	if part.startswith(geotype):
109	return function(part[len(geotype):])
110	else:
111	raise ValueError("Unsupported WKT-part %s" % repr(part[:20]))
112	else:
113	# there were no recognized geometries in the WKT string
114	raise ValueError("No recognized geometry in WKT string")
115
116	def parse_wkt_thuban(wkt):
117	"""Like convert_well_known_text, but return lists of lists of pairs"""
118	parts = wkt.split(";")
119	for part in parts:
120	part = part.strip()
121	if part.startswith("SRID"):
122	# ignore SRIDs
123	continue
124	else:
125	# split on "(" to separate the geometry type from the
126	# coordinate values
127	components = part.split("(", 1)
128	if len(components) > 1:
129	return parse_coordinate_lists(components[1])
130	else:
131	raise ValueError("WKT part %r doesn't contain opening"
132	" parenthesis" % part)
133	else:
134	# there were no recognized geometries in the WKT string
135	raise ValueError("No recognized geometry in WKT string")
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision