def dumps(obj, decimals=16):
"""
Dump a GeoJSON-like `dict` to a WKT string.
"""
try:
geom_type = obj['type']
exporter = _dumps_registry.get(geom_type)
if exporter is None:
_unsupported_geom_type(geom_type)
# Check for empty cases
if geom_type == 'GeometryCollection':
if len(obj['geometries']) == 0:
return 'GEOMETRYCOLLECTION EMPTY'
else:
# Geom has no coordinate values at all, and must be empty.
if len(list(util.flatten_multi_dim(obj['coordinates']))) == 0:
return '%s EMPTY' % geom_type.upper()
except KeyError:
raise geomet.InvalidGeoJSONException('Invalid GeoJSON: %s' % obj)
result = exporter(obj, decimals)
# Try to get the SRID from `meta.srid`
meta_srid = obj.get('meta', {}).get('srid')
# Also try to get it from `crs.properties.name`:
crs_srid = obj.get('crs', {}).get('properties', {}).get('name')
if crs_srid is not None:
# Shave off the EPSG prefix to give us the SRID:
crs_srid = crs_srid.replace('EPSG', '')
if (meta_srid is not None and
crs_srid is not None and
str(meta_srid) != str(crs_srid)):
raise ValueError(
'Ambiguous CRS/SRID values: %s and %s' % (meta_srid, crs_srid)
)
srid = meta_srid or crs_srid
# TODO: add tests for CRS input
if srid is not None:
# Prepend the SRID
result = 'SRID=%s;%s' % (srid, result)
return result
def dumps(obj, decimals=16):
"""
Dump a GeoJSON-like `dict` to a WKT string.
"""
try:
geom_type = obj['type']
exporter = _dumps_registry.get(geom_type)
if exporter is None:
_unsupported_geom_type(geom_type)
# Check for empty cases
if geom_type == 'GeometryCollection':
if len(obj['geometries']) == 0:
return 'GEOMETRYCOLLECTION EMPTY'
else:
# Geom has no coordinate values at all, and must be empty.
if len(list(util.flatten_multi_dim(obj['coordinates']))) == 0:
return '%s EMPTY' % geom_type.upper()
except KeyError:
raise geomet.InvalidGeoJSONException('Invalid GeoJSON: %s' % obj)
result = exporter(obj, decimals)
# Try to get the SRID from `meta.srid`
meta_srid = obj.get('meta', {}).get('srid')
# Also try to get it from `crs.properties.name`:
crs_srid = obj.get('crs', {}).get('properties', {}).get('name')
if crs_srid is not None:
# Shave off the EPSG prefix to give us the SRID:
crs_srid = crs_srid.replace('EPSG', '')
if (meta_srid is not None and crs_srid is not None
and str(meta_srid) != str(crs_srid)):
raise ValueError('Ambiguous CRS/SRID values: %s and %s' %
(meta_srid, crs_srid))
srid = meta_srid or crs_srid
# TODO: add tests for CRS input
if srid is not None:
# Prepend the SRID
result = 'SRID=%s;%s' % (srid, result)
return result
def dumps(obj, decimals=16):
"""
Dump a GeoJSON-like `dict` to a WKT string.
"""
try:
geom_type = obj["type"]
exporter = _dumps_registry.get(geom_type)
if exporter is None:
_unsupported_geom_type(geom_type)
# Check for empty cases
if geom_type == "GeometryCollection":
if len(obj["geometries"]) == 0:
return "GEOMETRYCOLLECTION EMPTY"
else:
# Geom has no coordinate values at all, and must be empty.
if len(list(util.flatten_multi_dim(obj["coordinates"]))) == 0:
return "%s EMPTY" % geom_type.upper()
except KeyError:
raise geomet.InvalidGeoJSONException("Invalid GeoJSON: %s" % obj)
fmt = "%%.%df" % decimals
return exporter(obj, fmt)
def _dumps(obj, big_endian=True, include_meta=True):
"""
Basically perform the action of dumps, but with some extra flags for
behavior specifically needed by the geopackage...package.
"""
geom_type = obj['type']
if include_meta:
meta = obj.get('meta', {})
else:
meta = {}
exporter = _dumps_registry.get(geom_type)
if exporter is None:
_unsupported_geom_type(geom_type)
# Check for empty geometries. GeometryCollections have a slightly different
# JSON/dict structure, but that's handled.
coords_or_geoms = obj.get('coordinates', obj.get('geometries'))
if len(list(flatten_multi_dim(coords_or_geoms))) == 0:
raise ValueError(
'Empty geometries cannot be represented in WKB. Reason: The '
'dimensionality of the WKB would be ambiguous.')
return exporter(obj, big_endian, meta)
def dumps(obj, decimals=16):
"""
Dump a GeoJSON-like `dict` to a WKT string.
"""
try:
geom_type = obj['type']
exporter = _dumps_registry.get(geom_type)
if exporter is None:
_unsupported_geom_type(geom_type)
# Check for empty cases
if geom_type == 'GeometryCollection':
if len(obj['geometries']) == 0:
return 'GEOMETRYCOLLECTION EMPTY'
else:
# Geom has no coordinate values at all, and must be empty.
if len(list(util.flatten_multi_dim(obj['coordinates']))) == 0:
return '%s EMPTY' % geom_type.upper()
except KeyError:
raise geomet.InvalidGeoJSONException('Invalid GeoJSON: %s' % obj)
fmt = '%%.%df' % decimals
return exporter(obj, fmt)
def dumps(obj, big_endian=True):
"""
Dump a GeoJSON-like `dict` to a WKB string.
.. note::
The dimensions of the generated WKB will be inferred from the first
vertex in the GeoJSON `coordinates`. It will be assumed that all
vertices are uniform. There are 4 types:
- 2D (X, Y): 2-dimensional geometry
- Z (X, Y, Z): 3-dimensional geometry
- M (X, Y, M): 2-dimensional geometry with a "Measure"
- ZM (X, Y, Z, M): 3-dimensional geometry with a "Measure"
If the first vertex contains 2 values, we assume a 2D geometry.
If the first vertex contains 3 values, this is slightly ambiguous and
so the most common case is chosen: Z.
If the first vertex contains 4 values, we assume a ZM geometry.
The WKT/WKB standards provide a way of differentiating normal (2D), Z,
M, and ZM geometries (http://en.wikipedia.org/wiki/Well-known_text),
but the GeoJSON spec does not. Therefore, for the sake of interface
simplicity, we assume that geometry that looks 3D contains XYZ
components, instead of XYM.
If the coordinates list has no coordinate values (this includes nested
lists, for example, `[[[[],[]], []]]`, the geometry is considered to be
empty. Geometries, with the exception of points, have a reasonable
"empty" representation in WKB; however, without knowing the number of
coordinate values per vertex, the type is ambigious, and thus we don't
know if the geometry type is 2D, Z, M, or ZM. Therefore in this case
we expect a `ValueError` to be raised.
:param dict obj:
GeoJson-like `dict` object.
:param bool big_endian:
Defaults to `True`. If `True`, data values in the generated WKB will
be represented using big endian byte order. Else, little endian.
:param str dims:
Indicates to WKB representation desired from converting the given
GeoJSON `dict` ``obj``. The accepted values are:
* '2D': 2-dimensional geometry (X, Y)
* 'Z': 3-dimensional geometry (X, Y, Z)
* 'M': 3-dimensional geometry (X, Y, M)
* 'ZM': 4-dimensional geometry (X, Y, Z, M)
:returns:
A WKB binary string representing of the ``obj``.
"""
geom_type = obj['type']
exporter = _dumps_registry.get(geom_type)
if exporter is None:
_unsupported_geom_type(geom_type)
# Check for empty geometries. GeometryCollections have a slightly different
# JSON/dict structure, but that's handled.
coords_or_geoms = obj.get('coordinates', obj.get('geometries'))
if len(list(flatten_multi_dim(coords_or_geoms))) == 0:
raise ValueError(
'Empty geometries cannot be represented in WKB. Reason: The '
'dimensionality of the WKB would be ambiguous.'
)
return exporter(obj, big_endian)
def dumps(obj, big_endian=True):
"""
Dump a GeoJSON-like `dict` to a WKB string.
.. note::
The dimensions of the generated WKB will be inferred from the first
vertex in the GeoJSON `coordinates`. It will be assumed that all
vertices are uniform. There are 4 types:
- 2D (X, Y): 2-dimensional geometry
- Z (X, Y, Z): 3-dimensional geometry
- M (X, Y, M): 2-dimensional geometry with a "Measure"
- ZM (X, Y, Z, M): 3-dimensional geometry with a "Measure"
If the first vertex contains 2 values, we assume a 2D geometry.
If the first vertex contains 3 values, this is slightly ambiguous and
so the most common case is chosen: Z.
If the first vertex contains 4 values, we assume a ZM geometry.
The WKT/WKB standards provide a way of differentiating normal (2D), Z,
M, and ZM geometries (http://en.wikipedia.org/wiki/Well-known_text),
but the GeoJSON spec does not. Therefore, for the sake of interface
simplicity, we assume that geometry that looks 3D contains XYZ
components, instead of XYM.
If the coordinates list has no coordinate values (this includes nested
lists, for example, `[[[[],[]], []]]`, the geometry is considered to be
empty. Geometries, with the exception of points, have a reasonable
"empty" representation in WKB; however, without knowing the number of
coordinate values per vertex, the type is ambigious, and thus we don't
know if the geometry type is 2D, Z, M, or ZM. Therefore in this case
we expect a `ValueError` to be raised.
:param dict obj:
GeoJson-like `dict` object.
:param bool big_endian:
Defaults to `True`. If `True`, data values in the generated WKB will
be represented using big endian byte order. Else, little endian.
:param str dims:
Indicates to WKB representation desired from converting the given
GeoJSON `dict` ``obj``. The accepted values are:
* '2D': 2-dimensional geometry (X, Y)
* 'Z': 3-dimensional geometry (X, Y, Z)
* 'M': 3-dimensional geometry (X, Y, M)
* 'ZM': 4-dimensional geometry (X, Y, Z, M)
:returns:
A WKB binary string representing of the ``obj``.
"""
geom_type = obj['type']
exporter = _dumps_registry.get(geom_type)
if exporter is None:
_unsupported_geom_type(geom_type)
# Check for empty geometries. GeometryCollections have a slightly different
# JSON/dict structure, but that's handled.
coords_or_geoms = obj.get('coordinates', obj.get('geometries'))
if len(list(flatten_multi_dim(coords_or_geoms))) == 0:
raise ValueError(
'Empty geometries cannot be represented in WKB. Reason: The '
'dimensionality of the WKB would be ambiguous.')
return exporter(obj, big_endian)
def test_multid(self):
data = [[[1], [2, 3]], [4, 5, [6]]]
expected = [1, 2, 3, 4, 5, 6]
self.assertEqual(expected, list(util.flatten_multi_dim(data)))
def test_2d(self):
data = [[1, 2], [3, 4, 5]]
expected = [1, 2, 3, 4, 5]
self.assertEqual(expected, list(util.flatten_multi_dim(data)))
def test_1d(self):
data = [1, 2, 3]
self.assertEqual(data, list(util.flatten_multi_dim(data)))
def test_multid(self):
data = [[[1], [2, 3]], [4, 5, [6]]]
expected = [1, 2, 3, 4, 5, 6]
self.assertEqual(expected, list(util.flatten_multi_dim(data)))
def test_2d(self):
data = [[1, 2], [3, 4, 5]]
expected = [1, 2, 3, 4, 5]
self.assertEqual(expected, list(util.flatten_multi_dim(data)))
def test_1d(self):
data = [1, 2, 3]
self.assertEqual(data, list(util.flatten_multi_dim(data)))
