def _clean_buildings(self): """ Budovy mohou byt v KML zadany budto jako polygony, nebo jako jednoduche body (spendliky). Body se ale zde prevedenou na male kolecka (polygony), protoze veskery ostatni kod s tim pocita. """ # normalne rozparsujeme KML url, err = self._common_clean('buildings', ['polygon', 'point']) if not err: # no ale ted rozdelime vysledek na 2 hromadky: polygony a body points = [i for i in self.buildings_data if i['type'] == 'point'] polys = [i for i in self.buildings_data if i['type'] != 'point'] # hromadku bodu prevedeme na malinke polygony (male kolca) out = [] ct1 = CoordTransform(SpatialReference('WGS84'), SpatialReference(102065)) ct2 = CoordTransform(SpatialReference(102065), SpatialReference('WGS84')) for point in points: _point = Point(point['coordinates'][0]['lon'], point['coordinates'][0]['lat'], srid=4326) m_point = _point.transform(ct1, clone=True) m_point2 = m_point.buffer(3) m_point2.transform(ct2) point['coordinates'] = [dict(zip(['lon', 'lat'], i)) for i in m_point2.coords[0]] out.append(point) # no a vratime origos polygony a nase pretransformovane body na kolca self.buildings_data = polys + out return url, err
def calculate_zone(self, distance, ct1=None, ct2=None): """ Vypocita okoli budovy a ulozi jej do self.zone. """ # pokud uz nejake okoli vypocitane mame, odstranime je... if self.zone: self.zone.delete() # prepocteme WGS84 souradnice obrysu budovy do krovaka if ct1 is None: ct1 = CoordTransform(SpatialReference('WGS84'), SpatialReference(102065)) m_poly = self.poly.transform(ct1, clone=True) # vypocitame okoli/sousedstvi budovy zone = m_poly.buffer(distance) # prevedeme okoli zpet na WGS84 if ct2 is None: ct2 = CoordTransform(SpatialReference(102065), SpatialReference('WGS84')) zone.transform(ct2) # vytvorime v DB novy objekt self.zone = Zone.objects.create(poly=zone) self.save()
def __init__(self, options): super(Importer, self).__init__() self._images = {obj.url: obj for obj in Image.objects.all()} self.options = options self.verbosity = options['verbosity'] self.logger = logging.getLogger(__name__) importer_langs = set(self.supported_languages) configured_langs = set(l[0] for l in settings.LANGUAGES) # Intersection is all the languages possible for the importer to use. self.languages = {} for lang_code in importer_langs & configured_langs: # FIXME: get language name translations from Django lang_obj, _ = Language.objects.get_or_create(id=lang_code) self.languages[lang_code] = lang_obj self.target_srid = settings.PROJECTION_SRID gps_srs = SpatialReference(4326) target_srs = SpatialReference(self.target_srid) if getattr(settings, 'BOUNDING_BOX'): self.bounding_box = Polygon.from_bbox(settings.BOUNDING_BOX) self.bounding_box.set_srid(self.target_srid) target_to_gps_ct = CoordTransform(target_srs, gps_srs) self.bounding_box.transform(target_to_gps_ct) else: self.bounding_box = None self.gps_to_target_ct = CoordTransform(gps_srs, target_srs) self.setup()
def __init__(self, options): super(Importer, self).__init__() self.options = options importer_langs = set(self.supported_languages) configured_langs = set(l[0] for l in settings.LANGUAGES) # Intersection is all the languages possible for the importer to use. self.languages = {} for lang_code in importer_langs & configured_langs: # FIXME: get language name translations from Django lang_obj, _ = Language.objects.get_or_create(id=lang_code) self.languages[lang_code] = lang_obj self.target_srid = settings.PROJECTION_SRID gps_srs = SpatialReference(4326) target_srs = SpatialReference(self.target_srid) if getattr(settings, 'BOUNDING_BOX'): self.bounding_box = Polygon.from_bbox(settings.BOUNDING_BOX) self.bounding_box.srid = self.target_srid target_to_gps_ct = CoordTransform(target_srs, gps_srs) self.bounding_box.transform(target_to_gps_ct) else: self.bounding_box = None self.gps_to_target_ct = CoordTransform(gps_srs, target_srs) self.setup() # this has to be run after setup, as it relies on organization and data source being set self._images = { obj.url: obj for obj in Image.objects.filter(publisher=self.organization, data_source=self.data_source) }
def save_buildings(self, entry): """ Ulozi vyparsovane obrysy budov. Ke kazde budove vypocita jeji obrys. """ ct1 = CoordTransform(SpatialReference('WGS84'), SpatialReference(102065)) ct2 = CoordTransform(SpatialReference(102065), SpatialReference('WGS84')) for building in self.buildings_data: # vytvorime polygon coords = [(i['lon'], i['lat']) for i in building['coordinates']] if coords[0] != coords[-1]: coords.append(coords[0]) if not coords: logger.info('No coordinates information in KML data for %s record' % building['name']) continue poly = Polygon(coords, srid=4326) # ulozime zaznam o budove do DB b = Building.objects.create( title = building['name'], description = building['description'], slug = slugify(building['name'][:99]), entry = entry, poly = poly ) # vypocteme okoli budovy b.calculate_zone(M100, ct1, ct2)
def simplify(geom: GEOSGeometry, tolerance: float = 10.0) -> GEOSGeometry: wgs_proj = SpatialReference("+proj=longlat +datum=WGS84") # TODO: determine zone number from longitude utm_proj = SpatialReference("+proj=utm +zone=33 +ellps=WGS84") # Transform to planar coordinates for better simplify operation ct = CoordTransform(wgs_proj, utm_proj) simplified_geom = geom.transform(ct, clone=True).simplify(tolerance) # Transform back to geographical coordinates ct = CoordTransform(utm_proj, wgs_proj) simplified_geom.transform(ct) return simplified_geom
def next_row(self): datasource = DataSource(self.filename, encoding=self.encoding) layer = datasource[0] SpatialRefSys = connection.ops.spatial_ref_sys() target_srs = SpatialRefSys.objects.get(srid=settings.SRID).srs coord_transform = CoordTransform(layer.srs, target_srs) self.nb = len(layer) for i, feature in enumerate(layer): row = { self.normalize_field_name(field.name): field.value for field in feature } try: ogrgeom = feature.geom except GDALException: print(_("Invalid geometry pointer"), i) geom = None else: ogrgeom.coord_dim = 2 # Flatten to 2D ogrgeom.transform(coord_transform) geom = ogrgeom.geos if self.simplify_tolerance and geom is not None: geom = geom.simplify(self.simplify_tolerance) row[self.normalize_field_name('geom')] = geom yield row
def upload(request): ctoken = {} ctoken.update(csrf(request)) if request.method == 'POST': form = UploadForm(request.POST, request.FILES) if form.is_valid(): shp = form.handle(request.FILES['file_obj']) ds = gdal.DataSource(shp) ct = CoordTransform(SpatialReference('EPSG:4326'), SpatialReference('EPSG:900913')) dados = [] for layer in ds[0]: aux = layer.geom aux.transform(ct) dados.append(aux) form = UploadForm() return render_to_response( 'googlev3_upload.html', RequestContext(request, { 'form': form, 'dados': dados, 'token': ctoken })) else: form = UploadForm() return render_to_response('googlev3_upload.html', RequestContext(request, {'form': form}))
def loadFilesToDB(user_id): user_data_folder = getUserDataFolder(user_id) try: for file in os.listdir(user_data_folder): if not file.endswith(".shp"): continue filename = os.path.splitext(file)[0] if not hasMandatoryFiles(user_data_folder, filename): continue file_dir = os.path.join(user_data_folder, file) ds = DataSource(file_dir) layer = ds[0] # Shapefiles have only one layer srs = layer.srs coord_trans = CoordTransform(srs, SpatialReference(4326)) models_to_save = [] for feature in layer: try: name = feature.get('name') except: name = "" stripstring = name.strip() if not stripstring: name = ('%s_no_name') % filename geom = GEOSGeometry(feature.geom.geos) geom.transform(coord_trans) models_to_save.append(adrian(name = name, geom = geom,\ user_id = user_id, color = None, filename = filename)) adrian.objects.bulk_create(models_to_save, 100) shutil.rmtree(user_data_folder) return True except: shutil.rmtree(user_data_folder) print "Unexpected error:", sys.exc_info()[0] raise
def __load_geojson__(self, crs: int): # Load geojson fd = open(self.vectorlayer_file.path, 'r') geojson = json.load(fd) src_crs = 4326 for item in geojson['features']: # get data _properties = item['properties'] coords = item['geometry']['coordinates'] # create multipolygon polygons = [Polygon(coord[0]) for coord in coords] mpolygon = MultiPolygon(polygons) # Tranform geometry gcoord = SpatialReference(src_crs) mycoord = SpatialReference(crs) trans = CoordTransform(gcoord, mycoord) mpolygon.transform(trans) # Create vector geometry VectorGeometry.objects.create(vectorgeometry_layer=self, geom=mpolygon)
def clean(self): cleaned_data = super(NamedPlaceForm, self).clean() if (cleaned_data.get('verbatim_coordinates', None) and cleaned_data.get('verbatim_srid', None)): my_srid = cleaned_data['verbatim_srid'].srid srs_from = SpatialReference(my_srid) srs_to = SpatialReference(4326) ptransf = CoordTransform(srs_from, srs_to) value = cleaned_data['verbatim_coordinates'] x, y = parse_coordinate_string(value) point = Point(x=x, y=y, srid=my_srid) point.transform(ptransf) country = cleaned_data['adm0'] try: VALIDATE_COORDINATES = settings.VALIDATE_COORDINATES except AttributeError: VALIDATE_COORDINATES = True if VALIDATE_COORDINATES: try: g = AdmUnitBoundary.objects.get( geoname_id=country.geoname_id) if g.geom.intersects(point): pass else: raise ValidationError('Point does not fall within' ' selected country boundary.') except ObjectDoesNotExist: pass cleaned_data['point'] = point
def save(self, *args, **kwargs): if self.layer_path is None or self.layer_path == '': self.layer_path = unique_layer_directory(self) if os.path.isdir(self.image): info = get_image_dir_info(self.image, self.projection) else: info = get_image_file_info(self.image) polygon = Polygon.from_bbox(info['bbox']) polygon.srid = self.projection ct = CoordTransform(SpatialReference(self.projection), SpatialReference('WGS84')) polygon.transform(ct) self.extent = polygon super(Layer, self).save(*args, **kwargs) # mask mask_path = None if self.mask: target_path = extract_zipfile(self.mask.path) mask_path = find_shapefile(target_path) self.mask_path = mask_path super(Layer, self).save() # update layer preview info if any if hasattr(self, 'layerpreview'): self.layerpreview.save() # update services using this layer for serviceLayer in self.services.all(): serviceLayer.service.save()
def make_point(point, origin_coord_srid, destiny_coord_srid): origin_coord = SpatialReference(origin_coord_srid) destination_coord = SpatialReference(destiny_coord_srid) trans = CoordTransform(origin_coord, destination_coord) transformed_point = copy(point) transformed_point.transform(trans) return transformed_point
def import_voting_district_boundaries(self): path = os.path.join(self.data_path, 'aan/PKS_aanestysalueet_kkj2.TAB') ds = DataSource(path) kkj2 = SpatialReference( '+proj=tmerc +lat_0=0 +lon_0=24 +k=1 +x_0=2500000 +y_0=0 +ellps=intl +towgs84=-96.0617,-82.4278,-121.7535,4.80107,0.34543,-1.37646,1.4964 +units=m +no_defs' ) kkj2_to_wgs84 = CoordTransform(kkj2, SpatialReference('WGS84')) lyr = ds[0] election = Election.objects.get(type='muni', year=2012) count = 0 for feat in lyr: muni_id = int(feat.get('KUNTA')) muni = Municipality.objects.get(id=muni_id) name = feat.get('Nimi').decode('iso8859-1') feat.geom.srs = kkj2 geom = feat.geom geom.transform(kkj2_to_wgs84) origin_id = feat.get('TKTUNNUS') args = {'municipality': muni, 'origin_id': origin_id} ed, created = VotingDistrict.objects.get_or_create(**args) ed.name = name gm = GEOSGeometry(geom.wkb, srid=geom.srid) if not isinstance(gm, MultiPolygon): gm = MultiPolygon(gm) ed.borders = gm ed.save() ed.elections.add(election) if created: count += 1 print "%d voting districts added." % count
def photo_info(request): form = DelfiPhotoInfoRequestForm(request.query_params) if form.is_valid(): photo = form.cleaned_data['id'] our_ref = SpatialReference(4326) delfi_ref = SpatialReference(3301) trans = CoordTransform(our_ref, delfi_ref) location = Point(x=photo.lon, y=photo.lat, srid=4326) location.transform(trans) source_str = '' if photo.source and photo.source_key: source_str = photo.source.description + ' ' + photo.source_key return Response({ 'id': photo.id, 'author': photo.author, 'description': photo.get_display_text, 'latitude': location.y, 'longitude': location.x, 'source': source_str, 'url': request.build_absolute_uri( reverse('photo', args=(photo.id, photo.get_pseudo_slug())) ), 'thumbUrl': request.build_absolute_uri( reverse('image_thumb', args=(photo.id, 400, photo.get_pseudo_slug())) ) }) return Response({})
def formatNewData(location): ct = CoordTransform(SpatialReference('epsg:4326'), SpatialReference('epsg:3857')) for n in location: if n.name.isdigit(): temp = n.name if n.description == '': if n.addit_info == '': n.delete() continue else: n.name = n.addit_info.capitalize() + ", id: " + temp n.description = n.addit_info else: if n.addit_info == '' or n.addit_info == 'building': n.name = n.description + ", id: " + temp else: n.name = n.addit_info.capitalize( ) + ': ' + n.description + ", id: " + temp n.description = n.addit_info + " id: " + temp n.name = re.sub(r'[^\x00-\x7F]+', ' ', n.name) n.fence.transform(ct) try: n.update() except Exception as e: print(str(e)) print("\n updated " + temp)
def spatial_search(): geojson = [ u'POLYGON ((272268.6283144115 200270.16611863102,272618.35541865695 214073.16809610612,353647.5501633153 212672.1529419519,353520.31875525665 198867.7012925945,272268.6283144115 200270.16611863102))' ] ct = CoordTransform(SpatialReference('EPSG:27700'), SpatialReference('EPSG:4326')) # geom = GEOSGeometry(geojson[0], srid=27700).transform(ct) geom = GEOSGeometry(geojson[0], srid=27700) spatial_intersects = models.FeatureStore.objects.filter( geometry__intersects=geom) print spatial_intersects.count() response_data = {} response_data['data'] = list( spatial_intersects.values_list('name', flat=True)) print response_data['data'] print type(response_data['data']) f = models.FeatureStore.objects.filter(id=2)[0] print f.name print f.geometry.distance(geom)
def project_meter2degree(layer=None, num=1, offset=0, topo=True): ''' Function to reproject gdal layer(in meters) to degree, and output geojson file num is the amount of block to keep from the layer In: layer : a json layer with a meter or feet projection Out: json : a json reprojected to decimal degrees in order to be displayed on a background map ''' layer_json = [] for la in layer[offset * num:num + offset * num]: if topo: myjson = la.topo_json else: myjson = la.road_json #convert json to gdal object new_layer = DataSource(myjson)[0] #get the srs srs = la.srs #check if srs is not numerical if not isnumber(srs): #if not numerical assign default srs srs = default_srs new_proj = [] #reproject gdal layer coord_transform = CoordTransform(SpatialReference(srs), SpatialReference(4326)) for feat in new_layer: geom = feat.geom geom.transform(coord_transform) new_proj.append(json.loads(geom.json)) layer_json.extend(new_proj) #save new layer as a json layer_json = json.dumps(layer_json) return layer_json
def photos_bbox(request): form = DelfiBboxRequestForm(request.query_params) if form.is_valid(): qs = Photo.objects.filter( rephoto_of__isnull=True, lat__isnull=False, lon__isnull=False, confidence__gte=0.2, lat__gte=form.cleaned_data['top_left'].y, lon__gte=form.cleaned_data['top_left'].x, lat__lte=form.cleaned_data['bottom_right'].y, lon__lte=form.cleaned_data['bottom_right'].x).order_by('?')[:500] our_ref = SpatialReference(4326) delfi_ref = SpatialReference(3301) trans = CoordTransform(our_ref, delfi_ref) photos = [] for p in qs: location = Point(x=p.lon, y=p.lat, srid=4326) location.transform(trans) photos.append({ 'id': p.id, 'latitude': location.y, 'longitude': location.x, 'description': p.description, }) return Response(photos) return Response([])
def transform(self, srs): """ Transforms the geometry to EPSG:4326 and ensures it's a MultiPolygon. """ geometry = self.geometry_to_multipolygon(self.geometry) geometry.transform(CoordTransform(srs, SpatialReference(4326))) return Geometry(geometry)
def clean(self): cleaned_data = super(DelfiBboxRequestForm, self).clean() bbox_str = cleaned_data.get('bbox') if not bbox_str: raise forms.ValidationError(_('Bounding box must be set')) bbox_parts = bbox_str.split(',') if len(bbox_parts) != 4: raise forms.ValidationError( _('Bounding box must have 4 comma-separated members')) else: try: bbox_parts = [float(x) for x in bbox_parts] except: raise forms.ValidationError( _('Bounding box values must be numbers')) our_ref = SpatialReference(4326) delfi_ref = SpatialReference(3301) trans = CoordTransform(delfi_ref, our_ref) top_left = Point(y=bbox_parts[1], x=bbox_parts[0], srid=3301) bottom_right = Point(y=bbox_parts[3], x=bbox_parts[2], srid=3301) top_left.transform(trans) bottom_right.transform(trans) cleaned_data['top_left'] = top_left cleaned_data['bottom_right'] = bottom_right return cleaned_data
def handle(self, *args, **options): ''' Import practice eastings and northings, from HSCIC data. ''' if not options['filename']: print 'Please supply a filename' else: self.IS_VERBOSE = False if options['verbosity'] > 1: self.IS_VERBOSE = True gridall = csv.reader(open(options['filename'], 'rU')) postcodes = {} for row in gridall: postcode = row[1].replace(' ', '').strip() postcodes[postcode] = [row[36], row[37]] wgs84 = SpatialReference(4326) bng = SpatialReference(27700) trans = CoordTransform(bng, wgs84) practices = Practice.objects.all().reverse() for practice in practices: practice.location = None postcode = practice.postcode.replace(' ', '').strip() if postcode in postcodes: lng = postcodes[postcode][0] lat = postcodes[postcode][1] pnt = Point(int(lng), int(lat), srid=27700) pnt.transform(trans) practice.location = pnt practice.save()
def AbrirBeneficiario(request,id_beneficiario): if request.user.is_authenticated(): from geo_liberty.models import Municipio from models import Beneficiario,Familia,PoliticaPublica_Beneficiario,OrganizacaoSocial_Beneficiario ct = CoordTransform(SpatialReference('EPSG:4326'), SpatialReference('EPSG:900913')) taquarucu = Municipio.objects.filter(id = 4321329) for feat in taquarucu: municipio = feat.mpoly municipio.transform(ct) unidade = UnidadeProducao.objects.filter(beneficiario = id_beneficiario) for feat in unidade: feat.ponto.transform(ct) beneficiario = Beneficiario.objects.filter(id=id_beneficiario) familia = Familia.objects.filter(beneficiario=id_beneficiario) politicasPublicas = PoliticaPublica_Beneficiario.objects.filter(beneficiario=id_beneficiario) organizacoesSociais = OrganizacaoSocial_Beneficiario.objects.filter(beneficiario=id_beneficiario) return render_to_response('beneficiario.html', RequestContext(request,{'beneficiario': beneficiario, 'familia':familia, 'politicasPublicas':politicasPublicas, 'organizacoesSociais':organizacoesSociais, 'municipio':municipio, 'unidade':unidade})) else: return render_to_response('login.html', RequestContext(request,{}))
def planify_coords(lat, lon): """ See osmdata/geo_utils.py """ planification = CoordTransform(SpatialReference(4326), SpatialReference(3857)) point = Point(lon, lat, srid=4326) point.transform(planification) return point
def update_sedes_municipais(shapefilename, srid=4618): # dados de um shapefile de 2001 ds = DataSource(shapefilename) transform_coord = None if srid != SRID: transform_coord = CoordTransform(SpatialReference(srid), SpatialReference(SRID)) ct = 0 cta = 0 for f in ds[0]: ct +=1 cod = f.get('CODIGO') muns = Municipio.objects.extra(where=['CAST(id_ibge AS VARCHAR) ILIKE %s'], params=['%s%%' % cod]) if muns: if len(muns) > 1: print("Mais de 1 municipio para", cod) for m in muns: print(m.id_ibge, m) else: g = f.geom g.srs = SpatialReference(srid) g.srid = srid if transform_coord: g.transform(transform_coord) print(g.ewkt) muns[0].sede = g.ewkt muns[0].save() cta += 1 else: print(cod, "nao econtrado!") print("Atualizados", cta, "sedes") print("Total de", ct, "registros no shapefile")
def geom_to_json(geom, target_srs): srs = srs_cache.get(geom.srid, None) if not srs: srs = geom.srs srs_cache[geom.srid] = srs if target_srs: ct_id = '%s-%s' % (geom.srid, target_srs.srid) ct = coord_transforms.get(ct_id, None) if not ct: ct = CoordTransform(srs, target_srs) coord_transforms[ct_id] = ct else: ct = None if ct: wkb = geom.wkb geom = gdal.OGRGeometry(wkb, srs) geom.transform(ct) geom_name = geom.geom_name.lower() else: geom_name = geom.geom_type.lower() # Accelerated path for points if geom_name == 'point': if target_srs.projected: digits = 2 else: digits = 7 coords = [round(n, digits) for n in [geom.x, geom.y]] return {'type': 'Point', 'coordinates': coords} s = geom.geojson return json.loads(s)
def test_srs_transform(self): "Testing transform()." orig = OGRGeometry('POINT (-104.609 38.255)', 4326) trans = OGRGeometry('POINT (992385.4472045 481455.4944650)', 2774) # Using an srid, a SpatialReference object, and a CoordTransform object # or transformations. t1, t2, t3 = orig.clone(), orig.clone(), orig.clone() t1.transform(trans.srid) t2.transform(SpatialReference('EPSG:2774')) ct = CoordTransform(SpatialReference('WGS84'), SpatialReference(2774)) t3.transform(ct) # Testing use of the `clone` keyword. k1 = orig.clone() k2 = k1.transform(trans.srid, clone=True) self.assertEqual(k1, orig) self.assertNotEqual(k1, k2) # Different PROJ versions use different transformations, all are # correct as having a 1 meter accuracy. prec = -1 for p in (t1, t2, t3, k2): self.assertAlmostEqual(trans.x, p.x, prec) self.assertAlmostEqual(trans.y, p.y, prec)
def handle(self, *args, **options): """ Import practice eastings and northings, from HSCIC data. """ if not options["filename"]: print("Please supply a filename") else: self.IS_VERBOSE = False if options["verbosity"] > 1: self.IS_VERBOSE = True gridall = csv.reader(open(options["filename"], "rU")) postcodes = {} for row in gridall: postcode = row[1].replace(" ", "").strip() postcodes[postcode] = [row[36], row[37]] wgs84 = SpatialReference(4326) bng = SpatialReference(27700) trans = CoordTransform(bng, wgs84) practices = Practice.objects.filter( postcode__isnull=False).reverse() for practice in practices: practice.location = None postcode = practice.postcode.replace(" ", "").strip() if postcode in postcodes: lng = postcodes[postcode][0] lat = postcodes[postcode][1] if lng and lat: pnt = Point(int(lng), int(lat), srid=27700) pnt.transform(trans) practice.location = pnt practice.save()
def project_to_WGS84(self, ov_bbox, ov_crs, center=None): try: srid = int(ov_crs.split(':')[1]) srid = 3857 if srid == 900913 else srid poly = Polygon(((ov_bbox[0], ov_bbox[1]), (ov_bbox[0], ov_bbox[3]), (ov_bbox[2], ov_bbox[3]), (ov_bbox[2], ov_bbox[1]), (ov_bbox[0], ov_bbox[1])), srid=srid) if srid != 4326: gcoord = SpatialReference(4326) ycoord = SpatialReference(srid) trans = CoordTransform(ycoord, gcoord) poly.transform(trans) try: if not center: center = { "x": get_valid_number(poly.centroid.coords[0]), "y": get_valid_number(poly.centroid.coords[1]), "crs": "EPSG:4326" } zoom = GoogleZoom().get_zoom(poly) + 1 except Exception: center = (0, 0) zoom = 0 tb = traceback.format_exc() logger.debug(tb) except Exception: tb = traceback.format_exc() logger.debug(tb) return (center, zoom)
def handle_shapefile(filename, folderPath, user_id): print "okay so long" filepath = os.path.abspath(os.path.join(folderPath, filename)) category = os.path.basename(os.path.splitext(filename)[0]) folder = os.path.join(folderPath, category) ds = DataSource(filepath) layer = ds[0] srs = layer.srs coord_trans = CoordTransform( srs, SpatialReference(4326)) # if we get data in another ref sys geomtype = str(layer.geom_type) geometry = geometry_mapper[geomtype] models_to_save = [] for feature in layer: geom_geos = geometry(feature.geom.geos) try: name = feature.get("name") except: name = category if not name: name = category geom_geos.transform(coord_trans) models_to_save.append(LarshbjGeoModel(name = name, category = category,\ user_id = user_id, geom=geom_geos, geom_type = geomtype)) LarshbjGeoModel.objects.bulk_create(models_to_save, 100)