def test_delete_extra_feature_not_editable(self):
feature = FeatureFactory(
layer=self.layer,
geom=GEOSGeometry(json.dumps(self.linestring)),
properties={
'number': 1,
'text': 'bar'
},
)
layer_extra_geom = LayerExtraGeom.objects.create(
layer=self.layer,
geom_type=GeometryTypes.Point,
title='Test',
editable=False)
extra_feature = FeatureExtraGeom.objects.create(
layer_extra_geom=layer_extra_geom,
feature=feature,
geom=GEOSGeometry(json.dumps(self.point)))
self.assertEqual(feature.extra_geometries.count(), 1)
response = self.client.delete(
reverse('feature-detail-extra-geometry',
kwargs={
'layer': str(self.layer.name),
'identifier': str(feature.identifier),
'id_extra_feature': extra_feature.pk
}))
self.assertEqual(response.status_code,
status.HTTP_405_METHOD_NOT_ALLOWED)
self.assertEqual(feature.extra_geometries.count(), 1)
def __init__(self,colinfos,row,srid):
'''
Convert a SQL result set row and a list of SQL result set colinfos
to a properties array and a geometry geojson string.
:param colinfos: A list of PEP-249 colinfo tuples.
:param row: An SQL result set row with as many members as ``colinfos``
:param srid: The target spatial reference ID to convert the geometry to.
'''
self.props = {}
self.id = None
self.geometry = None
for i,colinfo in enumerate(colinfos):
if _is_geom_column(colinfo):
geom = GEOSGeometry(row[i])
if srid is not None and srid != geom.srid:
geom.transform(srid)
self.geometry = geom
else:
if _is_id_column(colinfo):
self.id = row[i]
self.props[colinfo[0]] = row[i]
def fromfile(file_h):
"""
Given a string file name, returns a GEOSGeometry. The file may contain WKB,
WKT, or HEX.
"""
# If given a file name, get a real handle.
if isinstance(file_h, str):
with open(file_h, 'rb') as file_h:
buf = file_h.read()
else:
buf = file_h.read()
# If we get WKB need to wrap in memoryview(), so run through regexes.
if isinstance(buf, bytes):
try:
decoded = buf.decode()
except UnicodeDecodeError:
pass
else:
if wkt_regex.match(decoded) or hex_regex.match(decoded):
return GEOSGeometry(decoded)
else:
return GEOSGeometry(buf)
return GEOSGeometry(memoryview(buf))
def test_features_filter_by_properties_with_several_string_field(self):
layer = LayerFactory()
FeatureFactory(
layer=layer,
geom=GEOSGeometry(json.dumps(self.fake_geometry)),
properties={'text': 'foobar', 'sentence': 'foobar is here'},
)
FeatureFactory(
layer=layer,
geom=GEOSGeometry(json.dumps(self.fake_geometry)),
properties={'text': 'foo', 'sentence': 'foobar is missing'},
)
FeatureFactory(
layer=layer,
geom=GEOSGeometry(json.dumps(self.fake_geometry)),
properties={'text': 'foobar', 'sentence': 'foobar is here'},
)
response = self.client.get(
reverse('feature-list', kwargs={'layer': layer.pk}),
{
'properties__text': 'foobar',
'properties__sentence': 'foobar is here'
}
)
self.assertEqual(response.status_code, HTTP_200_OK)
json_response = response.json()
self.assertEqual(len(json_response), 2)
def test_get_extra_features(self):
feature = FeatureFactory(
layer=self.layer,
geom=GEOSGeometry(json.dumps(self.linestring)),
properties={
'number': 1,
'text': 'bar'
},
)
layer_extra_geom = LayerExtraGeom.objects.create(
layer=self.layer, geom_type=GeometryTypes.Point, title='Test')
extra_feature = FeatureExtraGeom.objects.create(
layer_extra_geom=layer_extra_geom,
feature=feature,
geom=GEOSGeometry(json.dumps(self.point)))
feature.extra_geometries.add(extra_feature)
response = self.client.get(
reverse('feature-detail-extra-geometry',
kwargs={
'layer': str(self.layer.name),
'identifier': str(feature.identifier),
'id_extra_feature': extra_feature.pk
}))
self.assertEqual(response.status_code, status.HTTP_200_OK)
json_response = response.json()
self.assertEqual(
json_response, {
'id': extra_feature.pk,
'geom': {
'type': 'Point',
'coordinates': [1.44, 43.6]
}
})
def test_edit_extra_features_bad_geom(self):
feature = FeatureFactory(
layer=self.layer,
geom=GEOSGeometry(json.dumps(self.linestring)),
properties={
'number': 1,
'text': 'bar'
},
)
layer_extra_geom = LayerExtraGeom.objects.create(
layer=self.layer, geom_type=GeometryTypes.Point, title='Test')
extra_feature = FeatureExtraGeom.objects.create(
layer_extra_geom=layer_extra_geom,
feature=feature,
geom=GEOSGeometry(json.dumps(self.point)))
feature.extra_geometries.add(extra_feature)
response = self.client.put(reverse('feature-detail-extra-geometry',
kwargs={
'layer':
str(self.layer.name),
'identifier':
str(feature.identifier),
'id_extra_feature':
extra_feature.pk
}),
data={'geom': "WRONG_GEOM"})
self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST)
json_response = response.json()
self.assertEqual(
json_response, {
'geom': [
'Unable to convert to python object: '
'String input unrecognized as WKT EWKT, and HEXEWKB.'
]
})
def __init__(self, colinfos, row, srid):
'''
Convert a SQL result set row and a list of SQL result set colinfos
to a properties array and a geometry geojson string.
:param colinfos: A list of PEP-249 colinfo tuples.
:param row: An SQL result set row with as many members as ``colinfos``
:param srid: The target spatial reference ID to convert the geometry to.
'''
self.props = {}
self.id = None
self.geometry = None
for i, colinfo in enumerate(colinfos):
if _is_geom_column(colinfo):
geom = GEOSGeometry(row[i])
if srid is not None and srid != geom.srid:
geom.transform(srid)
self.geometry = geom
else:
if _is_id_column(colinfo):
self.id = row[i]
self.props[colinfo[0]] = row[i]
def test_model_equals_with_geometry(self):
gmf_data_1 = models.GmfData(ground_motion=5.0,
location=GEOSGeometry("POINT (30.0 10.0)"))
gmf_data_2 = models.GmfData(ground_motion=5.0,
location=GEOSGeometry("POINT (30.0 10.0)"))
self.assertTrue(models.model_equals(gmf_data_1, gmf_data_2))
def bulk_geocode(self, codes, srid=None):
chunks = _chunk(codes)
for chunk in chunks:
features = self.code_store.find_features(spec={ "_id" : { "$in" : chunk }})
if srid:
for feature in features:
g = GEOSGeometry(json.dumps(feature['geometry']), srid=self.code_store.srid)
g.transform(srid)
feature['geometry'] = json.loads(g.json)
yield feature['_id'], feature
else:
for feature in features:
yield feature['_id'], feature
def __getitem__(self, code):
srid=None
if isinstance(code, tuple):
code, srid = code
val = self.code_store.coll.find_one(code)
if val:
if srid:
g = GEOSGeometry(json.dumps(val['geometry']), srid=self.code_store.srid)
g.transform(srid)
val['geometry'] = json.loads(g.json)
return val
else:
raise KeyError(code)
def _handle_geom(self, geometry):
""" Geometry processing (in place), depending on options """
# Optional force 2D
if self.options.get('force2d'):
wkb_w = WKBWriter()
wkb_w.outdim = 2
geometry = GEOSGeometry(wkb_w.write(geometry), srid=geometry.srid)
# Optional geometry simplification
simplify = self.options.get('simplify')
if simplify is not None:
geometry = geometry.simplify(tolerance=simplify, preserve_topology=True)
# Optional geometry reprojection
if self.srid != geometry.srid:
geometry.transform(self.srid)
return geometry
def handle_field(self, obj, field_name):
if isinstance(obj, Model):
value = getattr(obj, field_name)
elif isinstance(obj, dict):
value = obj[field_name]
else:
# Only supports dicts and models, not lists (e.g. values_list)
return
# ignore other geometries, only one geometry per feature
if field_name == self.geometry_field:
# this will handle GEOSGeometry objects and string representations (e.g. ewkt, bwkt)
try:
self._current['geometry'] = GEOSGeometry(value)
# if the geometry couldn't be parsed, we can't generate valid geojson
except ValueError:
raise SerializationError(
'The field ["%s", "%s"] could not be parsed as a valid geometry'
% (self.geometry_field, value))
elif self.properties and \
field_name in self.properties:
# set the field name to the key's value mapping in self.properties
if isinstance(self.properties, dict):
property_name = self.properties[field_name]
self._current['properties'][property_name] = value
else:
self._current['properties'][field_name] = value
elif not self.properties:
self._current['properties'][field_name] = value
def _handle_geom(self, geometry):
""" Geometry processing (in place), depending on options """
# Optional force 2D
if self.options.get('force2d'):
wkb_w = WKBWriter()
wkb_w.outdim = 2
geometry = GEOSGeometry(wkb_w.write(geometry), srid=geometry.srid)
# Optional geometry simplification
simplify = self.options.get('simplify')
if simplify is not None:
geometry = geometry.simplify(tolerance=simplify,
preserve_topology=True)
# Optional geometry reprojection
if self.srid != geometry.srid:
geometry.transform(self.srid)
return geometry
def area(self, area: Area):
"""
Import osmium area into database as polygon
Arguments:
area {Area} -- osmium area -> ways where are close & relation as multipolygon
"""
self.count_area()
if area.tags:
tags: dict = self.tags2dict(tags=area.tags)
clean_tags: dict = cleanup_tags(tags=tags)
poly: GEOSGeometry = GEOSGeometry(
self.wkt_fab.create_multipolygon(area), srid=self.wkt_fab.epsg)
polygon: PlanetOsmPolygon = PlanetOsmPolygon(
osm_id=area.id,
version=area.version,
way=poly,
valid_since=area.timestamp,
valid_until=self.valid_until,
tags=clean_tags,
)
polygon = fill_osm_object(osm_object=polygon)
polygon.z_order = get_z_order(tags=clean_tags)
polygon.way_area = poly.area
self.polygon_cache.append(polygon)
def convert_point(
self, ohdm_object: OhdmGeoobjectPoint) -> Optional[PlanetOsmPoint]:
try:
if GEOSGeometry(ohdm_object.way).geom_type != "Point":
return None
except TypeError:
return None
if not ohdm_object.tags:
ohdm_object.tags = {}
if ohdm_object.classification_class and ohdm_object.classification_subclassname:
ohdm_object.tags[
ohdm_object.
classification_class] = ohdm_object.classification_subclassname
clean_tags: dict = cleanup_tags(tags=ohdm_object.tags)
point: PlanetOsmPoint = PlanetOsmPoint(
way=ohdm_object.way,
geoobject=ohdm_object.geoobject_id,
name=ohdm_object.name,
valid_since=ohdm_object.valid_since,
valid_until=ohdm_object.valid_until,
tags=clean_tags,
)
return fill_osm_object(osm_object=point)
def cascaded_union(self):
"Returns a cascaded union of this MultiPolygon."
warnings.warn(
"`cascaded_union` is deprecated, use the `unary_union` property instead.",
RemovedInDjango20Warning, 2
)
return GEOSGeometry(capi.geos_cascaded_union(self.ptr), self.srid)
def way(self, way: Way):
"""
Import OSM way into database as way
Arguments:
way {Way} -- osmium way object
"""
modes: List[int] = []
for node in way.nodes:
modes.append(node.ref)
way_db: PlanetOsmWays = PlanetOsmWays(
osm_id=way.id,
version=way.version,
visible=way.visible,
timestamp=way.timestamp,
)
try:
way_db.way = GEOSGeometry(self.wkt_fab.create_linestring(way),
srid=self.wkt_fab.epsg)
way_db.tags = (self.tags2dict(tags=way.tags), )
except (RuntimeError, InvalidLocationError):
pass
self.way_cache.append(way_db)
self.count_way()
def convert_line(
self,
ohdm_object: OhdmGeoobjectLine,
) -> Tuple[Optional[PlanetOsmLine], Optional[PlanetOsmRoads]]:
try:
if GEOSGeometry(ohdm_object.way).geom_type != "LineString":
return None, None
except TypeError:
return None, None
if not ohdm_object.tags:
ohdm_object.tags = {}
if ohdm_object.classification_class and ohdm_object.classification_subclassname:
ohdm_object.tags[
ohdm_object.
classification_class] = ohdm_object.classification_subclassname
clean_tags: dict = cleanup_tags(tags=ohdm_object.tags)
line: PlanetOsmLine = PlanetOsmLine(
way=ohdm_object.way,
geoobject=ohdm_object.geoobject_id,
name=ohdm_object.name,
valid_since=ohdm_object.valid_since,
valid_until=ohdm_object.valid_until,
tags=clean_tags,
z_order=get_z_order(tags=clean_tags),
)
line = fill_osm_object(osm_object=line)
if is_road(tags=clean_tags):
return (line, line.to_road())
return (line, None)
def cascaded_union(self):
"Returns a cascaded union of this MultiPolygon."
if GEOS_PREPARE:
return GEOSGeometry(capi.geos_cascaded_union(self.ptr), self.srid)
else:
raise GEOSException(
'The cascaded union operation requires GEOS 3.1+.')
def way(self, way: Way):
"""
Import OSM way into database as line & polygon
Arguments:
way {Way} -- osmium way object
"""
self.count_way()
if way.tags:
tags: dict = self.tags2dict(tags=way.tags)
clean_tags: dict = cleanup_tags(tags=tags)
line: PlanetOsmLine = PlanetOsmLine(
osm_id=way.id,
version=way.version,
way=GEOSGeometry(self.wkt_fab.create_linestring(way),
srid=self.wkt_fab.epsg),
valid_since=way.timestamp,
valid_until=self.valid_until,
tags=clean_tags,
)
line = fill_osm_object(osm_object=line)
line.z_order = get_z_order(tags=clean_tags)
self.line_cache.append(line)
if is_road(tags=clean_tags):
self.roads_cache.append(line.to_road())
def handle(self, **options):
shape_file = options['shape'][0]
sensor = options['sensor'][0]
country = options['country'][0]
column = options['column'][0]
country_object = Country.objects.get(name=country)
with fiona.open(shape_file) as source:
print(source.crs)
for feat in source:
s1 = shape(feat['geometry'])
if source.crs['init'] != 'epsg:4326':
project = partial(
pyproj.transform,
pyproj.Proj(source.crs),
pyproj.Proj(init='EPSG:4326'))
s2 = transform(project, s1)
else:
s2 = s1
geom = GEOSGeometry(s2.wkt)
if country_object.the_geom.intersects(geom):
name = '%03d%03d' % (feat['properties']['PATH'], feat['properties']['ROW'])
if name:
try:
o = Footprint(the_geom = geom, sensor=sensor, name=name)
o.save()
except IntegrityError:
logger.error('Name %s already exists.' % name)
def fromfile(file_h):
"""
Given a string file name, returns a GEOSGeometry. The file may contain WKB,
WKT, or HEX.
"""
# If given a file name, get a real handle.
if isinstance(file_h, basestring):
with open(file_h, 'rb') as file_h:
buf = file_h.read()
else:
buf = file_h.read()
# If we get WKB need to wrap in buffer(), so run through regexes.
if wkt_regex.match(buf) or hex_regex.match(buf):
return GEOSGeometry(buf)
else:
return GEOSGeometry(buffer(buf))
def get_queryset(self):
wkt = self.request.query_params.get('polygon', None)
queryset = GenericAPIView.get_queryset(self)
if wkt is not None:
polygon = GEOSGeometry(wkt)
queryset = queryset.filter(
train_object__the_geom__intersects=polygon)
return queryset
def from_bbox(cls, bbox):
"Constructs a Polygon from a bounding box (4-tuple)."
x0, y0, x1, y1 = bbox
for z in bbox:
if not isinstance(z, six.integer_types + (float,)):
return GEOSGeometry('POLYGON((%s %s, %s %s, %s %s, %s %s, %s %s))' %
(x0, y0, x0, y1, x1, y1, x1, y0, x0, y0))
return Polygon(((x0, y0), (x0, y1), (x1, y1), (x1, y0), (x0, y0)))
def _check_stac_geometry(self, expected, current):
if isinstance(expected, dict):
expected = GEOSGeometry(json.dumps(expected))
elif isinstance(expected, str):
expected = GEOSGeometry(expected)
elif not isinstance(expected, GEOSGeometry):
self.fail(f"Invalid expected geometry type: {expected}: "
"should be dict, string or GEOSGeometry")
if isinstance(current, dict):
current = GEOSGeometry(json.dumps(current))
elif isinstance(current, str):
current = GEOSGeometry(current)
elif not isinstance(current, GEOSGeometry):
self.fail(f"Invalid current geometry type: {current}: "
"should be dict, string or GEOSGeometry")
self.assertEqual(expected, current, msg="Geometry are not equal")
def from_bbox(cls, bbox):
"Construct a Polygon from a bounding box (4-tuple)."
x0, y0, x1, y1 = bbox
for z in bbox:
if not isinstance(z, (float, int)):
return GEOSGeometry(
"POLYGON((%s %s, %s %s, %s %s, %s %s, %s %s))" %
(x0, y0, x0, y1, x1, y1, x1, y0, x0, y0))
return Polygon(((x0, y0), (x0, y1), (x1, y1), (x1, y0), (x0, y0)))
def filter_tripsearch_values(dct):
"""Filter request values.
"""
values = dict()
for key, value in dct.iteritems():
if key.encode() in __valid_search_keys__:
if key in (u'departure_point', u'arrival_point', u'offer_route', u'geometry'):
value = GEOSGeometry(value)
if key == u'date':
value = date(*[int(datevalue) for datevalue in value.encode().split('-')])
if key == u'geometry':
values['offer_route'] = value
else:
if key =='interval_min' or key == 'interval_max':
value = int(value)
values[key.encode()] = value
return values
def convert2pgsql(
self,
) -> Tuple[List[PlanetOsmLine], List[PlanetOsmRoads],
List[PlanetOsmPolygon]]:
previous_timestamp: date = self.timestamp
way: PlanetOsmWays
lines: List[PlanetOsmLine] = []
roads: List[PlanetOsmRoads] = []
polygons: List[PlanetOsmPolygon] = []
for way in self.ways:
if not way.visible and way.timestamp:
previous_timestamp = way.timestamp
continue
if way.tags and way.way:
if way.way.closed:
# create polygon with shapely & repair if needed
poly: ShapelyPolygon = ShapelyPolygon(way.way.coords)
if not poly.is_valid:
# fix polygon
poly = poly.buffer(distance=0)
delete_last_terminal_line()
polygon: PlanetOsmPolygon = PlanetOsmPolygon(
osm_id=way.osm_id,
version=way.version,
way=GEOSGeometry(poly.wkt),
valid_since=way.timestamp,
valid_until=previous_timestamp,
tags=way.tags,
)
polygon = fill_osm_object(osm_object=polygon)
polygon.z_order = get_z_order(tags=way.tags)
polygons.append(polygon)
# if not way.way.closed or way.way.closed and is_linestring(tags=way.tags):
line: PlanetOsmLine = PlanetOsmLine(
osm_id=way.osm_id,
version=way.version,
way=way.way,
valid_since=way.timestamp,
valid_until=previous_timestamp,
tags=way.tags,
)
line = fill_osm_object(osm_object=line)
line.z_order = get_z_order(tags=way.tags)
lines.append(line)
if is_road(tags=way.tags):
roads.append(line.to_road())
if way.timestamp:
previous_timestamp = way.timestamp
self.ways.clear()
self.osm_id = None
return (lines, roads, polygons)
def test_items_endpoint_bbox_valid_query(self):
# test bbox
ch_bbox = ','.join(map(str, GEOSGeometry(BBOX_CH).extent))
response = self.client.get(
f"/{STAC_BASE_V}/collections/{self.collection.name}/items"
f"?bbox={ch_bbox}&limit=100"
)
json_data = response.json()
self.assertStatusCode(200, response)
self.assertEqual(5, len(json_data['features']), msg="More than one item found")
def convert_extent(self, box):
"""
Convert the polygon data received from SpatiaLite to min/max values.
"""
if box is None:
return None
shell = GEOSGeometry(box).shell
xmin, ymin = shell[0][:2]
xmax, ymax = shell[2][:2]
return (xmin, ymin, xmax, ymax)
def filter_tripsearch_values(dct):
"""Filter request values.
"""
values = dict()
for key, value in dct.iteritems():
if key.encode() in __valid_search_keys__:
if key in (u'departure_point', u'arrival_point', u'offer_route', u'geometry'):
if value: # check not empty
value = GEOSGeometry(value)
else:
continue
if key == u'geometry':
key = 'offer_route'
if key == u'date':
value = date(*[int(datevalue) for datevalue in value.encode().split('-')])
if key =='interval_min' or key == 'interval_max':
value = int(value)
values[key.encode()] = value
return values
def test_features_filter_by_properties_with_wrong_field(self):
layer = LayerFactory()
FeatureFactory(
layer=layer,
geom=GEOSGeometry(json.dumps(self.fake_geometry)),
properties={'number': 1},
)
FeatureFactory(
layer=layer,
geom=GEOSGeometry(json.dumps(self.fake_geometry)),
properties={'number': 2},
)
response = self.client.get(
reverse('feature-list', kwargs={'layer': layer.pk}),
{'properties__wrongfield': 'wrong value'},
)
self.assertEqual(response.status_code, HTTP_200_OK)
json_response = response.json()
self.assertEqual(len(json_response), 0)
def get_queryset(self):
wkt = self.request.query_params.get('polygon', None)
if wkt is not None:
polygon = GEOSGeometry(wkt)
queryset = PredictClassification.objects.filter(
predict_object__the_geom__intersects=polygon,
predict_object__segmentation_information_id=26,
name='s2_001_jalisco_2017_bis_rf_0')
else:
queryset = PredictClassification.objects.all()
return queryset
def __init__(self, expression, geom, *expressions, **extra):
if not hasattr(geom, 'srid'):
# Try to interpret it as a geometry input
try:
geom = GEOSGeometry(geom)
except Exception:
raise ValueError("This function requires a geometric parameter.")
if not geom.srid:
raise ValueError("Please provide a geometry attribute with a defined SRID.")
geom = GeomValue(geom)
super(GeoFuncWithGeoParam, self).__init__(expression, geom, *expressions, **extra)
def import_location(loc_code, wkt):
""" Import the given outline for the given location code.
"""
outline = GEOSGeometry(wkt)
if outline.geom_type == "MultiPolygon":
mpoly = outline
elif outline.geom_type == "Polygon":
# Wrap the polygon into a MultiPolygon so we can save it into the
# database.
mpoly = MultiPolygon([outline])
try:
location = Location.objects.get(code=loc_code)
except Location.DoesNotExist:
print "...no such location!"
return
try:
outline = Outline.objects.get(location=location)
except Outline.DoesNotExist:
# We don't have an outline for this location -> add one.
outline = Outline()
outline.location = location
outline.outline = mpoly
outline.save()
class FeatureFactory(factory.DjangoModelFactory):
layer = factory.SubFactory(LayerFactory)
geom = GEOSGeometry('''{
"type": "Point",
"coordinates": [
2.4609375,
45.583289756006316
]
}''')
properties = {}
class Meta:
model = Feature
def _handle_geom(self, value):
""" Geometry processing (in place), depending on options """
if value is None:
geometry = None
elif isinstance(value, dict) and 'type' in value:
geometry = value
else:
if isinstance(value, GEOSGeometry):
geometry = value
else:
try:
# this will handle string representations (e.g. ewkt, bwkt)
geometry = GEOSGeometry(value)
except ValueError:
# if the geometry couldn't be parsed.
# we can't generate valid geojson
error_msg = 'The field ["%s", "%s"] could not be parsed as a valid geometry' % (
self.geometry_field, value
)
raise SerializationError(error_msg)
# Optional force 2D
if self.options.get('force2d'):
wkb_w = WKBWriter()
wkb_w.outdim = 2
geometry = GEOSGeometry(wkb_w.write(geometry), srid=geometry.srid)
# Optional geometry simplification
simplify = self.options.get('simplify')
if simplify is not None:
geometry = geometry.simplify(tolerance=simplify, preserve_topology=True)
# Optional geometry reprojection
if geometry.srid and geometry.srid != self.srid:
geometry.transform(self.srid)
# Optional bbox
if self.options.get('bbox_auto'):
self._current['bbox'] = geometry.extent
self._current['geometry'] = geometry
def __getitem__(self, code):
"""
Returns a feature if an exact match is found or a feature collection if an approximate match is found
:param code:
:return:
"""
srid=None
if isinstance(code, tuple):
code, srid = code
val = self.code_store.coll.find_one(code)
if val:
if srid:
g = GEOSGeometry(json.dumps(val['geometry']), srid=self.code_store.srid)
g.transform(srid)
val['geometry'] = json.loads(g.json)
return val
else:
val = { 'type' : "FeatureCollection" }
features = []
ngrams = self.parser(code)
scores = {}
for ngram in ngrams:
counts = self.ngram_store.find({'ngram' : ngram})
for count in counts:
if count['code'] not in scores:
scores[ count['code'] ] += count['count']
for code, ct in sorted(scores.items(), key=lambda x,y: y):
features.append(self.code_store.coll.find_one(code))
if len(features):
val['features'] = features
return val
else:
raise KeyError(code)
def importData(file, characterEncoding, format, user, folder):
cursor = connection.cursor()
start_time = time.time()
#manage zipfile
fd,fname = tempfile.mkstemp(suffix=fileExt_dic[format])
os.close(fd)
f = open(fname, "wb")
for chunk in file.chunks():
f.write(chunk)
f.close()
if not zipfile.is_zipfile(fname):
os.remove(fname)
return "Not a valid zip archive.", None
zip = zipfile.ZipFile(fname)
hasSuffix = {}
required_suffixes = suffixes_dic[format]
for suffix in required_suffixes:
hasSuffix[suffix] = False
for info in zip.infolist():
extension = os.path.splitext(info.filename)[1].lower()
if extension in required_suffixes:
hasSuffix[extension] = True
for suffix in required_suffixes:
if not hasSuffix[suffix]:
zip.close()
os.remove(fname)
return "Archive missing required %s file." % suffix, None
zip = zipfile.ZipFile(fname)
shapefileName = None
dirname = tempfile.mkdtemp()
for info in zip.infolist():
if info.filename.lower().endswith(filenameExt_dic[format]):
shapefileName = info.filename
dstFile = os.path.join(dirname, info.filename)
f = open(dstFile, "wb")
f.write(zip.read(info.filename))
f.close()
zip.close()
#verify if shapefile is valid
try:
srcPath = os.path.join(dirname,shapefileName)
srcLayers = fiona.listlayers(srcPath)
shapefileOK = True
except:
traceback.print_exc()
shapefileOK = False
if not shapefileOK:
os.remove(fname)
shutil.rmtree(dirname)
return "Not a valid vector file.", None
#add shapefile object to database
try:
for i in srcLayers:
with fiona.open(srcPath) as c:
srcSpatialRef = to_string(c.crs)
print srcSpatialRef
project = CoordTransform(SpatialReference(srcSpatialRef),SpatialReference(3857))
geometryType = c.schema['geometry']
shapefile = Shapefile.objects.create(filename=c.name, parent=folder, srs_wkt=srcSpatialRef, geom_type=geometryType, encoding=characterEncoding, created_by=user)
#define shapefile's attributes
for keys, values in c.schema['properties'].iteritems():
dict = {}
dict['name'] = keys
props = re.split('\W+', values)
dict['type'] = utils.fionaTypeToInt(props[0])
try:
dict['width'] = int(props[1])
except IndexError:
dict['width'] = 0
if dict['type'] == 2:
try:
dict['precision'] = int(props[2])
except IndexError:
dict['precision'] = 15
else:
dict['precision'] = 0
attr = Attribute.objects.create(shapefile=shapefile, **dict)
#store shapefile's features
for srcFeature in c:
try:
wkt = dumps(srcFeature['geometry'])
geosGeometry = GEOSGeometry(wkt)
geosGeometry.srid = SpatialReference(srcSpatialRef).srid
geosGeometry.transform(project)
except TypeError:
geosGeometry = None
geometryField = utils.calcGeometryField(geometryType)
args = {}
args['shapefile'] = shapefile
args[geometryField] = geosGeometry
args['attribute_value'] = srcFeature['properties']
args['id_relat'] = srcFeature['id']
feature = Feature.objects.create(**args)
print("Temps final: --- %s seconds ---" % str(time.time() - start_time))
return None, shapefile
except BaseException, e:
#cleaning up
os.remove(fname)
shutil.rmtree(dirname, ignore_errors=False, onerror=handleRemoveReadonly)
shapefile.delete()
return e, None
