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 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