def _import_geodata(self, model, model_mapping, geodata_path, unique=None):
"""Import geodata into model
:param model obj: model object
:param model_mapping dict: model fields mapping
:param geodata_path str: geodata layer path
"""
lm = LayerMapping(model=model,
data=str(geodata_path),
mapping=model_mapping,
transform=False)
lm.save(strict=True, verbose=False)
def run(verbose=True):
"""
This function used the LayerMapping import utility to
load a shapefile to the database
"""
# Takes model name, path to shapefile, mapping dict, encoding format
lm = LayerMapping(KenyaRoad,
river_shp,
kenyaroad_mapping,
transform=False,
encoding='iso-8859-1')
lm.save(strict=True, verbose=verbose)
def handle(self, *args, **options):
unit_shp = os.path.abspath(
os.path.join(
os.path.join(os.path.dirname(units.__file__),
'data/cogeol.kml')))
lm = LayerMapping(Unit,
unit_shp,
unit_mapping,
transform=False,
encoding='iso-8859-1')
lm.save(strict=True, verbose=True)
def save_file(filepath):
layer_map = LayerMapping(
model=models.Country,
data=filepath,
mapping={
"name": "ADMIN",
"country_code": "ADM0_A3",
'geom': "MULTIPOLYGON",
}
)
layer_map.save(progress=True, strict=True)
def handle(self, *args, **options):
model_name = options["model"]
filename = options["shapefile"]
model = import_string(f"{app_label}.models.{model_name}")
lm = LayerMapping(model,
filename,
model.mapping,
transform=False,
source_srs=4326)
lm.save(strict=True, verbose=True)
def handle(self, *args, **options):
unit_shp = os.path.abspath(
os.path.join(
os.path.join(os.path.dirname(watres.__file__),
'Export_Output_2.shp')))
lm = LayerMapping(TestGeo,
unit_shp,
testgeo_mapping,
transform=False,
encoding='iso-8859-1')
lm.save(strict=True, verbose=True)
def run(self):
if Departamento.objects.all().count() != 0:
return print("すでにインスタンスが生成されています")
lm = LayerMapping(Departamento,
self.shp_file,
self.departamento_mapping,
transform=True,
encoding='UTF-8')
#lm.save(strict=False, verbose=True)
lm.save(strict=True, verbose=True)
return print("Departamentoインスタンスの生成が完了しました。")
def run(verbose=True):
df = pd.read_csv(csv_file, converters=StringConverter())
mapping = {
row["original"]: row["new"]
for idx, row in pd.read_csv(column_mapping).iterrows()
}
df = df.rename(columns=mapping)
l = list(set(mapping.values()))
df = df[l]
print(df.head(n=5))
category = Category.objects.filter(text="小型工程").first()
DistrictMinorWorkMetaData.objects.all().delete()
for idx, row in df.iterrows():
row["document_date"] = datetime.strptime(row["document_date"],
"%d/%m/%Y")
try:
row["expected_start_date"] = datetime.strptime(
row["expected_start_date"], "%d/%m/%Y")
except:
row["expected_start_date"] = None
try:
row["expected_end_date"] = datetime.strptime(
row["expected_end_date"], "%d/%m/%Y")
except:
row["expected_end_date"] = None
audience = []
audience_labels = ["區內所有居民", "老人", "青少年", "傷殘人士", "兒童及家長"]
for x, word in zip(
["all_citizen", "elderly", "youth", "disabled", "kids"],
audience_labels):
if row["audience_" + x].lower() == "yes":
audience.append(word)
row["audience"] = ",".join(audience)
row["ballpark_text"] = row["ballpark"]
try:
row["ballpark"] = float(row["ballpark_text"].replace(",", ""))
except:
row["ballpark"] = 0
m = DistrictMinorWorkMetaData(**row)
m.category = category
m.save()
sr = SpatialReference('EPSG:2326')
DistrictMinorWork.objects.all().delete()
lm = LayerMapping(DistrictMinorWork,
world_shp,
dmw_mapping,
transform=True)
lm.save(strict=True, verbose=verbose)
for dmw in DistrictMinorWork.objects.all():
dmw.metadata = DistrictMinorWorkMetaData.objects.get(
identifier=dmw.identifier)
dmw.save()
def run(self):
if Prefectura.objects.all().count() != 0:
print("すでにインスタンスが生成されています")
return
lm = LayerMapping(Prefectura,
self.shp_file,
self.prefectura_mapping,
transform=True,
encoding='UTF-8')
lm.save(strict=False, verbose=True)
print("Prefecturaインスタンスの生成が完了しました。")
return
def run(verbose=True):
"""
This function used the LayerMapping import utility to
load a shapefile to the database
"""
# Takes model name, path to shapefile, mapping dict, encoding format
lm = LayerMapping(Region,
regions_shp,
region_mapping,
transform=False,
encoding="iso-8859-1")
lm.save(strict=True, verbose=verbose)
def state_import(state_shp, year):
state_mapping = {
'fips_code': 'STATEFP',
'usps_code': 'STUSPS',
'name': 'NAME',
'area_description_code': 'LSAD',
'feature_class_code': 'MTFCC',
'functional_status': 'FUNCSTAT',
'mpoly': 'POLYGON',
}
lm = LayerMapping(State, state_shp, state_mapping)
lm.save(verbose=True)
def handle(self, *args, **options):
if 'filename' not in options:
print 'Please supply a KML filename'
sys.exit
layer_mapping = {
'code': 'CCGcode',
'boundary': 'Unknown'
}
lm = LayerMapping(PCT, options['filename'],
layer_mapping, transform=True)
lm.save(strict=True)
def handle(self, *args, **options):
if 'filename' not in options:
print 'Please supply a KML filename'
sys.exit
ds = DataSource(options['filename'])
layer_mapping = {'code': 'Name', 'boundary': 'Unknown'}
lm = LayerMapping(PCT,
options['filename'],
layer_mapping,
transform=False) # , unique='code')
lm.save(strict=True)
def import_neighborhoods_shapefile(shapefile):
"""Import Zillow neighborhood boundaries from a shapefile"""
# Load the shapefile
ds = DataSource(shapefile)
# Import the neighborhoods
lm = LayerMapping(Neighborhood,
ds,
neighborhood_mapping,
transform=False,
encoding='iso-8859-1')
lm.save(strict=True, verbose=False)
def _parse_and_store_geojson(filename):
"""Parse source GeoJSON with travel times."""
ds = DataSource(filename)
_sanity_check_datasource(ds)
logger.info('Data file %s was opened', ds.name)
lm = LayerMapping(WegStuk, ds, MAPPING)
with transaction.atomic():
WegStuk.objects.all().delete()
lm.save(strict=True, verbose=False)
logger.info('Travel time dataset was updated.')
def handle(self, *args, **kw):
base_dir = os.path.join(os.path.dirname(__file__), '..', '..')
shp_file = os.path.join(base_dir, 'world/tz_world_mp.shp')
if not os.path.exists(shp_file):
print "download http://efele.net/maps/tz/world/tz_world_mp.zip and unzip in film20/geo dir"
print "also, due to some bug in gis code, set 'geo' database as default when this script is running"
return
lm=LayerMapping(
TimeZone,
'geo/world/tz_world_mp.shp',
timezone_mapping,
)
lm.save(verbose=True)
def import_from_layer(self, layer_name):
layer_mapping = LayerMapping(
model=Region,
data=self.filename,
mapping=self.field_mapping,
layer=self._get_layer_index(layer_name),
encoding=self.encoding)
silent = (self.output_stream is None)
layer_mapping.save(
strict=True,
stream=self.output_stream,
silent=silent,
verbose=(not silent and self.verbose))
def osm_country_import(self, verbose=True):
osm_model = models.Country
osm_filename = os.path.join(settings.STATIC_ROOT, "gdal", "countries",
"TM_WORLD_BORDERS-0.3.shp")
lm = LayerMapping(
osm_model,
osm_filename,
osm_model.mapping(),
transform=True,
transaction_mode="autocommit",
unique="name",
)
lm.save(strict=True, verbose=verbose)
def handle(self, *args, **options):
path_of_shp = './shapefiles/Aldeia.shp'
aldeia_mapping = {'name': 'Name', 'geom': 'POINT'}
try:
lm = LayerMapping(Aldeia,
path_of_shp,
aldeia_mapping,
transform=False)
lm.save(strict=True, verbose=True)
self.stdout.write(
self.style.SUCCESS('Successfully imported Aldeia'))
except:
raise CommandError('Error importing Aldeia')
def handle(self, *args, **options):
path_of_shp = './shapefiles/subdistricts.shp'
subdistrict_mapping = {'name': 'SUBDISTR', 'geom': 'POLYGON'}
try:
lm = LayerMapping(Subdistrict,
path_of_shp,
subdistrict_mapping,
transform=False)
lm.save(strict=True, verbose=True)
self.stdout.write(
self.style.SUCCESS('Successfully imported Subdistrict'))
except:
raise CommandError('Error importing Subdistrict')
def state_import(path='/root/tiger-line/'):
state_mapping = {
'fips_code': 'STATEFP10',
'usps_code': 'STUSPS10',
'name': 'NAME10',
'area_description_code': 'LSAD10',
'feature_class_code': 'MTFCC10',
'functional_status': 'FUNCSTAT10',
'mpoly': 'POLYGON',
}
state_shp = os.path.join(path, 'tl_2010_us_state10.shp')
lm = LayerMapping(State, state_shp, state_mapping)
lm.save(verbose=True)
def run(path, verbose=True):
if os.path.exists(path) and os.path.isdir(path):
for name in os.listdir(path):
if not name.endswith('.shp'):
continue
shp_file = os.path.join(path, name)
lm = LayerMapping(Town,
shp_file,
boundary_mapping,
transform=False)
lm.save(strict=True, verbose=verbose)
else:
print('指定されたフォルダーが存在しません。')
def import_dhm(dhm_filename: str, bounding_box: Polygon, srid=DEFAULT_DHM_SRID):
# delete all old data within the bounding box
if bounding_box:
logger.debug("delete all data from database within geometry {}".format(bounding_box))
DigitalHeightModel.objects.filter(point__within=bounding_box).delete()
# getting the type of dhm and check if we import a vector (*.shp) or raster file (anything else)
if dhm_filename.lower().endswith(".shp"):
# vector implementation
logger.debug("staring vector import")
mapping = {'height': 'float',
'point': 'POINT', }
lm = LayerMapping(DigitalHeightModel, dhm_filename, mapping)
lm.save(verbose=True) # save the data to the database
# raster implementation
else:
with rasterio.open(dhm_filename) as dhm_datasource:
crs = dhm_datasource.crs
np_heightmap = dhm_datasource.read(1) # we assume there is a single height band
rows, cols = np_heightmap.shape
logger.debug("starting raster import with {} points".format(rows * cols))
# add all valid points to a list
dhm_list = []
for x in range(0, rows):
for y in range(0, cols):
x_m, y_m = dhm_datasource.affine * (x, y)
point = Point(x_m, y_m, srid=crs) # convert x,y to meters in crs
# only import points within the bounding polygon
if bounding_box:
if not bounding_box.contains(point):
continue
dhm_point = DigitalHeightModel()
dhm_point.point = point
dhm_point.height = np_heightmap[x, y]
dhm_list.append(dhm_point)
# bulk insert the batch into the database
count = 0
while True:
batch = list(islice(dhm_list, BATCH_SIZE))
if not batch:
break
DigitalHeightModel.objects.bulk_create(batch, BATCH_SIZE)
count += BATCH_SIZE
logger.debug("inserted {} from {} entries ({} %)".format(count, len(dhm_list),
count * 100 / len(dhm_list)))
def set_gov_seats(self, path, filename):
ds = self.get_ds(path, filename)
mapping = LayerMapping(GeoRegion, ds, {'geom': 'POINT'})
layer = ds[0]
count = float(len(layer))
for i, feature in enumerate(layer):
self.stdout.write('%.2f%%\r' % (i / count * 100), ending='')
region_identifier = feature['RS'].as_string()
try:
gr = GeoRegion.objects.get(region_identifier=region_identifier)
gr.gov_seat = mapping.feature_kwargs(feature)['geom']
gr.save()
except GeoRegion.DoesNotExist:
pass
def load():
""" Creates a database representation of shapefile """
# To run this command type: 'python manage.py shell'
# 'from map.views import load; load()'
mapping = {"productivi": "productivi", "mpoly": "MULTIPOLYGON"}
map_path = os.path.abspath('gis_django/fields_test/test_fields.shp')
lm = LayerMapping(Map,
map_path,
mapping,
transform=False,
encoding="iso-8859-1")
lm.save(verbose=True)
def handle(self, *args, **options):
shapefile_path = options['shapefile_path'][0]
lm = LayerMapping(City,
shapefile_path,
cities_ibge_mapping,
transform=True)
lm.save(strict=True, verbose=True)
self.stdout.write(
'Camada de cidades importada com sucesso! Caminho do arquivo fornecido: "%s"'
% shapefile_path)
def handle(self, *args, **kwargs):
wc_count = Ward.objects.count()
if wc_count:
self.stdout.write(
self.style.WARNING('{} wards already exist'.format(wc_count)))
return
lm = LayerMapping(Ward,
ward_shp,
ward_mapping,
transform=False,
encoding='iso-8859-1')
lm.save(strict=True, verbose=False)
self.stdout.write(self.style.SUCCESS("Loaded wards shapefile"))
def from_shapefile(transaction_mode='autocommit', **kwargs):
"""
Load water parcel data into the database from the processed shapefile.
"""
# Using transaction_mode=autocommit because otherwise LayerMapping gets
# stuck on a feature and can't commit anything
filename = os.path.join('water_parcels', 'water_parcels.shp')
parcel_shp = get_processed_data_file(filename)
mapping = LayerMapping(WaterParcel,
parcel_shp,
waterparcel_mapping,
transform=True,
transaction_mode=transaction_mode)
mapping.save(**kwargs)
def load_world_data():
from vsi.tools.dir_util import TempDir
from voxel_globe.world import models
from zipfile import ZipFile
from glob import glob
with TempDir(cd=True, mkdtemp=True) as temp_dir:
with ZipFile(env['VIP_DJANGO_REGRESSION_SHAPEFILE'], 'r') as zip_file:
zip_file.extractall(temp_dir)
world_shp = glob(os.path.join(temp_dir, '*.shp'))[0]
#print world_shp, '\n'
ds = DataSource(world_shp)
geometryName = u'mpoly'
if 1: #Completely optional
from django.contrib.gis.utils.ogrinspect import _ogrinspect
print >> logStdOut, 'Your class model SHOULD look like this:\n'
print >> logStdOut, '\n'.join([
s for s in _ogrinspect(ds,
'WorldBorder',
geom_name=geometryName,
layer_key=0,
srid=4326,
multi_geom=True)
])
world_mapping = mapping(ds,
multi_geom=True,
geom_name=geometryName,
layer_key=0)
print >> logStdOut, 'Loading database using mapping:'
pprint(world_mapping, stream=logStdOut)
try:
lm = LayerMapping(models.WorldBorder,
world_shp,
world_mapping,
transform=False,
encoding='iso-8859-1')
lm.save(strict=True, verbose=True)
except:
print 'Failed to load mapping data. It probably already exists!'
#Cleanup so that TempDir can delete the dir
del (ds, world_mapping, lm)
def run(verbose=True):
richness = LayerMapping(
Richness,
richness_shp,
richness_mapping,
transform=False,
)
richness.save(strict=True, verbose=verbose)
spplist = LayerMapping(
Spplist,
spplist_shp,
spplist_mapping,
transform=False,
)
spplist.save(strict=True, verbose=verbose)
treelevel = LayerMapping(
TreeLevel,
treelevel_shp,
treelevel_mapping,
transform=False,
)
treelevel.save(strict=True, verbose=verbose)
