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(City, shp_file, boundary_mapping, transform=True)
# lm.save(strict=True, verbose=verbose)
ds = DataSource(shp_file)
layer = ds[0]
for feature in layer:
mpoly = MultiPolygon.from_ewkt(feature.geom.ewkt)
if isinstance(mpoly, Polygon):
mpoly = MultiPolygon([mpoly])
City.objects.create(
pref_code=feature.get('JCODE')[:2],
pref_name=feature.get('KEN'),
city_code=feature.get('JCODE'),
city_name=feature.get('SIKUCHOSON'),
city_name_en=feature.get('CITY_ENG'),
gun_name=feature.get('GUN'),
people_count=feature.get('P_NUM'),
family_count=feature.get('H_NUM'),
mpoly=mpoly,
)
else:
print('指定されたフォルダーが存在しません。')
def handle(self, *args, **options):
verbosity = options.get('verbosity')
file_path = options.get('file_path')
area_type_name = options.get('area_type')
name_column = options.get('name')
encoding = options.get('encoding')
srid = options.get('srid')
do_intersect = options.get('intersect')
bbox = Polygon.from_bbox(settings.SPATIAL_EXTENT)
bbox.srid = settings.SRID
ds = DataSource(file_path, encoding=encoding)
count_error = 0
area_type, created = RestrictedAreaType.objects.get_or_create(
name=area_type_name)
if verbosity > 0:
self.stdout.write("RestrictedArea Type's %s created" %
area_type_name if created else "Get %s" %
area_type_name)
for layer in ds:
for feat in layer:
try:
geom = feat.geom.geos
if not isinstance(geom, Polygon) and not isinstance(
geom, MultiPolygon):
if verbosity > 0:
self.stdout.write(
"%s's geometry is not a polygon" %
feat.get(name_column))
break
elif isinstance(geom, Polygon):
geom = MultiPolygon(geom)
self.check_srid(srid, geom)
geom.dim = 2
if geom.valid:
if do_intersect and bbox.intersects(
geom) or not do_intersect and geom.within(
bbox):
instance, created = RestrictedArea.objects.update_or_create(
name=feat.get(name_column),
area_type=area_type,
defaults={'geom': geom})
if verbosity > 0:
self.stdout.write(
"%s %s" %
('Created' if created else 'Updated',
feat.get(name_column)))
else:
if verbosity > 0:
self.stdout.write("%s's geometry is not valid" %
feat.get(name_column))
except IndexError:
if count_error == 0:
self.stdout.write(
"Name's attribute do not correspond with options\n"
"Please, use --name to fix it.\n"
"Fields in your file are : %s" %
', '.join(layer.fields))
count_error += 1
def setupTreemapEnv():
def local_render_to_response(*args, **kwargs):
from django.template import loader
from django.http import HttpResponse
hr = HttpResponse(loader.render_to_string(*args, **kwargs))
if hasattr(args[1], 'dicts'):
hr.request_context = args[1].dicts
return hr
django.shortcuts.render_to_response = local_render_to_response
instance = make_instance(is_public=True)
create_stewardship_udfs(instance)
make_user_with_default_role(instance, 'jim')
commander = make_commander_user(instance, 'commander')
make_apprentice_user(instance, 'apprentice')
n1geom = MultiPolygon(Polygon(
((0, 0), (100, 0), (100, 100), (0, 100), (0, 0))))
n2geom = MultiPolygon(
Polygon(((0, 101), (101, 101), (101, 200), (0, 200), (0, 101))))
n1 = Boundary(name="n1", category='blah', sort_order=4, geom=n1geom)
n2 = Boundary(name="n2", category='blah', sort_order=4, geom=n2geom)
n1.save()
n2.save()
s1 = Species(otm_code="s1", genus="testus1", species="specieius1",
cultivar='', instance=instance)
s2 = Species(otm_code="s2", genus="testus2", species="specieius2",
cultivar='', instance=instance)
s3 = Species(otm_code="s3", genus="testus2", species="specieius3",
cultivar='', instance=instance)
s1.is_native = True
s1.fall_conspicuous = True
s1.flower_conspicuous = True
s1.palatable_human = True
s2.is_native = True
s2.fall_conspicuous = False
s2.flower_conspicuous = True
s2.palatable_human = False
s2.has_wildlife_value = True
s3.has_wildlife_value = True
s1.save_with_user(commander)
s2.save_with_user(commander)
s3.save_with_user(commander)
return instance
def wrap_geos_geometry(geometry):
if geometry.geom_type == "Polygon":
return MultiPolygon(geometry)
elif geometry.geom_type == "LineString":
return MultiLineString(geometry)
else:
return geometry
def load_data(self):
# First erase any existing Geocodes with the same value_name
print "Erasing Geocodes with value_name %s" % self.value_name
Geocode.objects.filter(value_name=self.value_name).delete()
print "Erasing any Geocodes with None as value_name"
Geocode.objects.filter(value_name=None).delete()
print "Loading new Geocodes"
shp_name = os.path.abspath(os.path.join('/tmp', self.shape_file_name))
lm = LayerMapping(Geocode,
shp_name,
self.shape_mappings,
transform=True,
encoding=self.shape_encoding)
# We load only the first 100 FIPS objects if it is a sample
if self.sample is True:
lm.save(strict=True, verbose=False, fid_range=[0, 100])
else:
lm.save(strict=True, verbose=False)
print "Post-processing Geocodes"
# We use this queryset_iterator function so not all objects are loaded in memory at the same time
result = queryset_iterator(Geocode.objects.filter(value_name=None))
z = 0 # Counter to print
# We need to do some post processing on the geocodes, e.g. convert to MultiPolygon and remove 0s
for i in result:
z += 1
try:
print "%s %s" % (z, i.name)
# this is to add just a little room between the lines
g = i.geom.buffer(-0.0000001)
# Simplify the polygons and convert to multipolygon
g = g.simplify(0.04, preserve_topology=True)
if g.geom_type != 'MultiPolygon':
i.geom = MultiPolygon(g)
else:
i.geom = g
# Remove leading zeros. Leading zeros pose problems when matching up with requests
i.code = i.code.lstrip("0")
# Set value_name, e.g. FIPS6
i.value_name = self.value_name
i.save()
sleep(
0.05
) # We do this to give the DB a second to catch its breath
except Exception, e:
print e
def handle(self, *args, **options):
verbosity = options.get('verbosity')
file_path = options.get('file_path')
area_type_name = options.get('area_type')
name_column = options.get('name')
encoding = options.get('encoding')
srid = options.get('srid')
do_intersect = options.get('intersect')
bbox = Polygon.from_bbox(settings.SPATIAL_EXTENT)
bbox.srid = settings.SRID
ds = DataSource(file_path, encoding=encoding)
count_error = 0
area_type, created = RestrictedAreaType.objects.get_or_create(name=area_type_name)
if verbosity > 0:
self.stdout.write("RestrictedArea Type's %s created" % area_type_name if created else "Get %s" % area_type_name)
for layer in ds:
for feat in layer:
try:
geom = feat.geom.geos
if not isinstance(geom, Polygon) and not isinstance(geom, MultiPolygon):
if verbosity > 0:
self.stdout.write("%s's geometry is not a polygon" % feat.get(name_column))
break
elif isinstance(geom, Polygon):
geom = MultiPolygon(geom)
self.check_srid(srid, geom)
geom.dim = 2
if do_intersect and bbox.intersects(geom) or not do_intersect and geom.within(bbox):
instance, created = RestrictedArea.objects.update_or_create(name=feat.get(name_column),
area_type=area_type,
defaults={
'geom': geom})
if verbosity > 0:
self.stdout.write("%s %s" % ('Created' if created else 'Updated', feat.get(name_column)))
except OGRIndexError:
if count_error == 0:
self.stdout.write(
"Name's attribute do not correspond with options\n"
"Please, use --name to fix it.\n"
"Fields in your file are : %s" % ', '.join(feat.fields))
count_error += 1
def handle(self, name, file, *args, **options):
name = name[0]
file = file[0]
if Region.objects.filter(name__iexact=name).exists():
message = (
"WARNING: This will replace an existing region with the same name: {}. Do you want to continue? [y/n]"
).format(name)
if input(message).lower() not in {"y", "yes"}:
return
temp_dir = None
try:
if file.endswith(".zip"):
temp_dir = mkdtemp()
with ZipFile(file) as zf:
zf.extractall(temp_dir)
try:
file = glob.glob(os.path.join(temp_dir, "*.shp"))[0]
except IndexError:
raise ValueError("No shapefile in zip archive")
polygons = []
with fiona.open(file, "r") as shp:
for feature in shp:
geometry = transform_geom(shp.crs, {"init": "EPSG:4326"},
feature["geometry"])
if geometry["type"] == "MultiPolygon":
coordinate_set = geometry["coordinates"]
else:
coordinate_set = [geometry["coordinates"]]
for coordinates in coordinate_set:
polygons.append(
Polygon(*[LinearRing(x) for x in coordinates]))
with transaction.atomic():
Region.objects.filter(name__iexact=name).delete()
# Buffer by 0 to make polygons valid
Region.objects.create(
name=name, polygons=MultiPolygon(polygons).buffer(0))
finally:
if temp_dir is not None:
try:
shutil.rmtree(temp_dir)
except OSError:
pass
def zones(self, request, pk=None):
rows = Zone.objects.filter(workplace_id=pk)
pols = [zone.poly for zone in rows]
mp = MultiPolygon(pols)
zones = [p.coords[0] for p in pols]
wp = Workplace.objects.get(pk=pk)
trs = Tracking
return Response({
"coords": self.reverse_coords(zones),
"center": [mp.centroid.coords[1], mp.centroid.coords[0]]
})
def wrapGEOSGeometry(geometry):
print geometry.GetGeometryName()
if geometry.GetGeometryName() == "POLYGON":
# return MultiPolygon (geometry.ExportToWkt () )
return MultiPolygon(
modGEOSGeometry.GEOSGeometry(geometry.ExportToWkt()))
if geometry.GetGeometryName() == "LINESTRING":
print "returning linestring"
return MultiLineString(
modGEOSGeometry.GEOSGeometry(geometry.ExportToWkt()))
# return MultiLineString (geometry.ExportToWkt () )
return modGEOSGeometry.GEOSGeometry(geometry.ExportToWkt())
def circleToMultiPolygon(self, circle):
# circle is usually of the form '-35.3888,147.0598 25.0', so the below should make sense
circle_split = circle.split(' ')
coords = circle_split[0].split(',')
p = Point(float(coords[1]), float(coords[0]))
circle_rad = float(circle_split[1])
if circle_rad < 3:
circle_rad = 3.0 # This is to allow some level of smoothing
rdn = circle_rad / 6371
x = p.buffer(rdn)
s = x.simplify(rdn / 3.5, preserve_topology=False)
geom = MultiPolygon(s)
return geom
def geocodeToMultiPolygon(self, geocode_list, value_name):
try:
result = Geocode.objects.filter(value_name=value_name,
code__in=geocode_list)
if len(result) > 0:
result = result.aggregate(Union('geom'))['geom__union']
try:
if result.geom_type != 'MultiPolygon':
geom = MultiPolygon(result)
else:
geom = result
except Exception, e:
logging.error('Error in geocodeToMultiPolygon')
geom = None
return geom
else:
def polygonToMultiPolygon(self, polygon):
poly_split = polygon.split(' ')
point_list = []
for coords in poly_split:
poly_pnts = coords.split(',')
pnt = Point(float(poly_pnts[1]), float(poly_pnts[0]))
point_list.append(pnt)
try:
p = Polygon(point_list
) # Can't convert directly from points to MultiPolygon
geom = MultiPolygon(p)
except GEOSException:
logging.error("Unable to format points into MultiPoligon")
geom = None
return geom
def update_from_childs(self):
if not self.update_auto or not self.child_rels.count():
return
geocollection = [
childrel.child.polygon for childrel in self.child_rels.all()
]
n_polygon = geocollection[0]
for polygon in geocollection[1:]:
n_polygon = n_polygon.union(polygon)
#TODO: simplify with unions
if type(n_polygon) != MultiPolygon:
n_polygon = MultiPolygon([n_polygon])
if n_polygon != self.polygon:
self.polygon = n_polygon
self.save()
return
def display_aoi_uploader(request):
if request.method == 'POST':
form = UploadAoiForm(request.POST, request.FILES)
if form.is_valid():
## write the file to disk and extract WKT
wkt_list = handle_uploaded_file(
request.FILES['filefld'],
form.cleaned_data['uid_field'],
)
## loop through the dictionary list and store the data. first, create
## the metadata object.
meta = models.UserGeometryMetadata(
code=form.cleaned_data['code'],
desc=form.cleaned_data['desc'],
uid_field=form.cleaned_data['uid_field'],
)
meta.save()
## next insert the geometries
for feat in wkt_list:
geom = GEOSGeometry(fromstr(feat['geom']).wkt, srid=4326)
if isinstance(geom, Polygon):
geom = MultiPolygon([geom])
## extract the user-provided unique identifier if passed
obj = models.UserGeometryData(
user_meta=meta,
gid=feat.get(form.cleaned_data['uid_field']),
geom=geom)
obj.save()
## return a success message to the user
# TODO: redirect to a page listing the AOIs
# return(HttpResponse((
# 'Upload successful. '
# 'Your geometry code is: <b>{0}</b>').format(obj.code)
# ))
return redirect('/api/aois/{0}.html'.format(meta.code))
else:
form = UploadAoiForm()
return (render_to_response('aoi_upload.html', {'form': form}))
def wrapGEOSGeometry(geometry):
""" Wrap the given GEOSGeometry object if required.
If the given geometry object is a Polygon, we wrap the polygon in a
MultiPolygon object. Similarly, if the geometry is a LineString, we
wrap it in a MultiLineString.
This is used to ensure that imported Polygon and LineString objects can
be stored into the appropriate field of the Feature database object.
See the definition of the calcGeometryField() function, above, to see
why this is necessary.
Upon completion, we return the wrapped object, or the object unchanged
if it does not need to be wrapped.
"""
if geometry.geom_type == "Polygon":
return MultiPolygon(geometry)
elif geometry.geom_type == "LineString":
return MultiLineString(geometry)
else:
return geometry
class Migration(migrations.Migration):
dependencies = [
('api', '0038_metadatacontact_is_validator'),
]
operations = [
migrations.RunSQL(
sql=
"ALTER TABLE product ADD COLUMN geom2 geometry(MultiPolygon,2056);",
reverse_sql="ALTER TABLE product DROP COLUMN geom2;"),
migrations.RunSQL(
sql=
"CREATE INDEX IF NOT EXISTS product_geom2_id ON product USING gist (geom2)",
reverse_sql="DROP INDEX product_geom2_id;"),
migrations.RunSQL(
sql="UPDATE product set geom2 = ST_Multi(geom);",
reverse_sql=
"UPDATE product set geom = (ST_DUMP(geom2)).geom::geometry(Polygon,2056);"
),
migrations.RunSQL(
sql="ALTER TABLE product DROP COLUMN geom;",
reverse_sql=
"ALTER TABLE product ADD COLUMN geom geometry(Polygon,2056);"),
migrations.RunSQL(
sql="ALTER TABLE product RENAME COLUMN geom2 TO geom;",
reverse_sql="ALTER TABLE product RENAME COLUMN geom TO geom2;",
state_operations=[
migrations.AlterField(
model_name='product',
name='geom',
field=MultiPolygonField(default=MultiPolygon(
Polygon.from_bbox(
(2519900, 1186430, 2578200, 1227030))),
srid=2056,
verbose_name='geom'),
),
],
),
]
def handle(self, *args, **options):
print args
try:
if len(args) != 5:
return
layer_path = args[0]
if not os.path.exists(layer_path):
print '%s does not exists' % layer_path
return
parent_field = args[1]
name_field = args[2]
osm_level = int(args[3])
osm_level_alias = args[4]
source = DataSource(layer_path)
layer = source[0]
except Exception as e:
raise e
try:
boundary_alias = BoundaryAlias.objects.get(
alias__iexact=osm_level_alias, osm_level=osm_level)
except BoundaryAlias.DoesNotExist:
boundary_alias = BoundaryAlias.objects.create(
alias=osm_level_alias, osm_level=osm_level)
new_boundary = 0
existing_boundary = 0
for feat in layer:
geometry = feat.geom
name = feat.get(name_field)
parent_name = None
if parent_field:
parent_name = feat.get(parent_field)
geos_geometry = GEOSGeometry(geometry.geojson)
# check parent boundary exists
parent_boundary = None
try:
if parent_name:
parent_boundary = Boundary.objects.get(
name__iexact=parent_name.strip(),
boundary_alias__osm_level=osm_level - 1)
except Boundary.DoesNotExist:
pass
if isinstance(geos_geometry, Polygon):
geos_geometry = MultiPolygon(geos_geometry)
try:
query = (Q(name__iexact=name.strip())
& Q(boundary_alias=boundary_alias))
if parent_boundary:
query = query & Q(parent=parent_boundary)
boundary = Boundary.objects.get(query)
if boundary:
existing_boundary += 1
except Boundary.DoesNotExist:
Boundary.objects.create(name=name.strip(),
parent=parent_boundary,
geometry=geos_geometry,
boundary_alias=boundary_alias)
new_boundary += 1
print 'New Boundary %s' % new_boundary
print 'Existing Boundary %s' % existing_boundary
LOGGER.info('Shapefile processed...')
def convert2pgsql(self) -> List[PlanetOsmPolygon]:
# https://wiki.openstreetmap.org/wiki/Relation:multipolygon/Algorithm
previous_timestamp: date = self.timestamp
rel: PlanetOsmRels
multipolygons: List[PlanetOsmPolygon] = []
for rel in self.rels:
if (not rel.visible or not rel.outer_members
or not rel.inner_members or not rel.tags):
if rel.timestamp:
previous_timestamp = rel.timestamp
continue
if rel.rel_type != "multipolygon" and rel.rel_type != "boundary":
continue
ways: Dict[int, PlanetOsmWays] = {}
way: PlanetOsmWays
for way in PlanetOsmWays.objects.filter(
osm_id__in=rel.outer_members,
visible=True).order_by("osm_id", "-version"):
if not way.way or not way.way.closed:
# todo combine not closed ways
continue
if way.osm_id in ways:
if way.timestamp <= ways[way.osm_id].timestamp:
ways[way.osm_id] = way
else:
ways[way.osm_id] = way
for way in PlanetOsmWays.objects.filter(
osm_id__in=rel.inner_members,
visible=True).order_by("osm_id", "-version"):
if not way.way or not way.way.closed:
# todo combine not closed ways
continue
if way.osm_id in ways:
if way.timestamp <= ways[way.osm_id].timestamp:
ways[way.osm_id] = way
else:
ways[way.osm_id] = way
polygons: List[Polygon] = []
for osm_id in rel.outer_members:
if osm_id in ways:
polygons.append(Polygon(ways[osm_id].way.coords))
for osm_id in rel.inner_members:
if osm_id in ways:
polygons.append(Polygon(ways[osm_id].way.coords))
multipolygon: MultiPolygon = MultiPolygon(polygons)
polygon: PlanetOsmPolygon = PlanetOsmPolygon(
osm_id=rel.osm_id,
version=rel.version,
way=GEOSGeometry(multipolygon.wkt),
valid_since=rel.timestamp,
valid_until=previous_timestamp,
tags=rel.tags,
)
polygon = fill_osm_object(osm_object=polygon)
multipolygons.append(polygon)
previous_timestamp = rel.timestamp
self.rels.clear()
self.osm_id = None
return multipolygons
def setupTreemapEnv():
settings.GEOSERVER_GEO_LAYER = ""
settings.GEOSERVER_GEO_STYLE = ""
settings.GEOSERVER_URL = ""
def local_render_to_response(*args, **kwargs):
from django.template import loader, RequestContext
from django.http import HttpResponse
httpresponse_kwargs = {'mimetype': kwargs.pop('mimetype', None)}
hr = HttpResponse(loader.render_to_string(*args, **kwargs),
**httpresponse_kwargs)
if hasattr(args[1], 'dicts'):
hr.request_context = args[1].dicts
return hr
django.shortcuts.render_to_response = local_render_to_response
r1 = ReputationAction(name="edit verified", description="blah")
r2 = ReputationAction(name="edit tree", description="blah")
r3 = ReputationAction(name="Administrative Action", description="blah")
r4 = ReputationAction(name="add tree", description="blah")
r5 = ReputationAction(name="edit plot", description="blah")
r6 = ReputationAction(name="add plot", description="blah")
r7 = ReputationAction(name="add stewardship", description="blah")
r8 = ReputationAction(name="remove stewardship", description="blah")
for r in [r1, r2, r3, r4, r5, r6, r7, r8]:
r.save()
bv = BenefitValues(co2=0.02,
pm10=9.41,
area="InlandValleys",
electricity=0.1166,
voc=4.69,
ozone=5.0032,
natural_gas=1.25278,
nox=12.79,
stormwater=0.0078,
sox=3.72,
bvoc=4.96)
bv.save()
dbh = "[1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]"
dbh2 = "[2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]"
rsrc1 = Resource(meta_species="BDM OTHER", region="NoEastXXX")
rsrc2 = Resource(meta_species="BDL OTHER", region="NoEastXXX")
rsrc1.save()
rsrc2.save()
u = User.objects.filter(username="******")
if u:
u = u[0]
else:
u = User.objects.create_user("jim", "*****@*****.**", "jim")
u.is_staff = True
u.is_superuser = True
u.save()
up = UserProfile(user=u)
up.save()
u.reputation = Reputation(user=u)
u.reputation.save()
amy_filter_result = User.objects.filter(username="******")
if not amy_filter_result:
amy = User.objects.create_user("amy", "*****@*****.**", "amy")
else:
amy = amy_filter_result[0]
amy.is_staff = False
amy.is_superuser = False
amy.save()
amy_profile = UserProfile(user=amy)
amy_profile.save()
amy.reputation = Reputation(user=amy)
amy.reputation.save()
olivia_filter_result = User.objects.filter(username="******")
if not amy_filter_result:
olivia = User.objects.create_user("olivia", "*****@*****.**",
"olivia")
else:
olivia = olivia_filter_result[0]
olivia.is_staff = False
olivia.is_superuser = False
olivia.save()
olivia_profile = UserProfile(user=olivia)
olivia_profile.save()
olivia.reputation = Reputation(user=olivia)
olivia.reputation.save()
n1geom = MultiPolygon(
Polygon(((0, 0), (100, 0), (100, 100), (0, 100), (0, 0))))
n2geom = MultiPolygon(
Polygon(((0, 101), (101, 101), (101, 200), (0, 200), (0, 101))))
n1 = Neighborhood(name="n1",
region_id=2,
city="c1",
state="PA",
county="PAC",
geometry=n1geom)
n2 = Neighborhood(name="n2",
region_id=2,
city="c2",
state="NY",
county="NYC",
geometry=n2geom)
n1.save()
n2.save()
z1geom = MultiPolygon(
Polygon(((0, 0), (100, 0), (100, 100), (0, 100), (0, 0))))
z2geom = MultiPolygon(
Polygon(((0, 100), (100, 100), (100, 200), (0, 200), (0, 100))))
z1 = ZipCode(zip="19107", geometry=z1geom)
z2 = ZipCode(zip="10001", geometry=z2geom)
z1.save()
z2.save()
exgeom1 = MultiPolygon(
Polygon(((0, 0), (25, 0), (25, 25), (0, 25), (0, 0))))
ex1 = ExclusionMask(geometry=exgeom1, type="building")
ex1.save()
agn1 = AggregateNeighborhood(annual_stormwater_management=0.0,
annual_electricity_conserved=0.0,
annual_energy_conserved=0.0,
annual_natural_gas_conserved=0.0,
annual_air_quality_improvement=0.0,
annual_co2_sequestered=0.0,
annual_co2_avoided=0.0,
annual_co2_reduced=0.0,
total_co2_stored=0.0,
annual_ozone=0.0,
annual_nox=0.0,
annual_pm10=0.0,
annual_sox=0.0,
annual_voc=0.0,
annual_bvoc=0.0,
total_trees=0,
total_plots=0,
location=n1)
agn2 = AggregateNeighborhood(annual_stormwater_management=0.0,
annual_electricity_conserved=0.0,
annual_energy_conserved=0.0,
annual_natural_gas_conserved=0.0,
annual_air_quality_improvement=0.0,
annual_co2_sequestered=0.0,
annual_co2_avoided=0.0,
annual_co2_reduced=0.0,
total_co2_stored=0.0,
annual_ozone=0.0,
annual_nox=0.0,
annual_pm10=0.0,
annual_sox=0.0,
annual_voc=0.0,
annual_bvoc=0.0,
total_trees=0,
total_plots=0,
location=n2)
agn1.save()
agn2.save()
s1 = Species(symbol="s1",
genus="testus1",
species="specieius1",
cultivar_name='',
family='',
alternate_symbol='a1')
s2 = Species(symbol="s2",
genus="testus2",
species="specieius2",
cultivar_name='',
family='',
alternate_symbol='a2')
s3 = Species(symbol="s3",
genus="testus2",
species="specieius3",
cultivar_name='',
family='',
alternate_symbol='a3')
s1.native_status = 'True'
s1.fall_conspicuous = True
s1.flower_conspicuous = True
s1.palatable_human = True
s2.native_status = 'True'
s2.fall_conspicuous = False
s2.flower_conspicuous = True
s2.palatable_human = False
s2.wildlife_value = True
s3.wildlife_value = True
s1.save()
s2.save()
s3.save()
s1.resource.add(rsrc1)
s2.resource.add(rsrc2)
s3.resource.add(rsrc2)
ie = ImportEvent(file_name='site_add')
ie.save()
def process_hazard_layer(flood):
"""Process zipped impact layer and import it to databse
:param flood: Event id of flood
:type flood: realtime.models.flood.Flood
"""
LOGGER.info('Processing hazard layer %s - %s' % (
flood.event_id,
flood.hazard_layer.name
))
# extract hazard layer zip file
if not flood.hazard_layer or not flood.hazard_layer.name:
LOGGER.info('No hazard layer')
return
zip_file_path = os.path.join(settings.MEDIA_ROOT, flood.hazard_layer.name)
if not os.path.exists(zip_file_path):
LOGGER.info('Hazard layer doesn\'t exists')
return
with ZipFile(zip_file_path) as zf:
tmpdir = tempfile.mkdtemp()
zf.extractall(path=tmpdir)
# process hazard layer
layer_filename = os.path.join(tmpdir, 'flood_data.shp')
source = DataSource(layer_filename)
layer = source[0]
FloodEventBoundary.objects.filter(flood=flood).delete()
kelurahan = BoundaryAlias.objects.get(alias=OSM_LEVEL_7_NAME)
rw = BoundaryAlias.objects.get(alias=OSM_LEVEL_8_NAME)
for feat in layer:
if not flood.data_source or flood.data_source == 'petajakarta':
upstream_id = feat.get('pkey')
level_name = feat.get('level_name')
parent_name = feat.get('parent_nam')
state = feat.get('state')
elif flood.data_source == 'petabencana':
upstream_id = feat.get('area_id')
level_name = feat.get('area_name')
parent_name = feat.get('parent_nam')
state = feat.get('state')
geometry = feat.geom
geos_geometry = GEOSGeometry(geometry.geojson)
if isinstance(geos_geometry, Polygon):
# convert to multi polygon
geos_geometry = MultiPolygon(geos_geometry)
# check parent exists
try:
boundary_kelurahan = Boundary.objects.get(
name__iexact=parent_name.strip(),
boundary_alias=kelurahan)
except Boundary.DoesNotExist:
boundary_kelurahan = Boundary.objects.create(
upstream_id=upstream_id,
geometry=geos_geometry,
name=parent_name,
boundary_alias=kelurahan)
boundary_kelurahan.save()
try:
boundary_rw = Boundary.objects.get(
upstream_id=upstream_id, boundary_alias=rw)
boundary_rw.geometry = geos_geometry
boundary_rw.name = level_name
boundary_rw.parent = boundary_kelurahan
except Boundary.DoesNotExist:
boundary_rw = Boundary.objects.create(
upstream_id=upstream_id,
geometry=geos_geometry,
name=level_name,
parent=boundary_kelurahan,
boundary_alias=rw)
boundary_rw.save()
if not state or int(state) == 0:
continue
FloodEventBoundary.objects.create(
flood=flood,
boundary=boundary_rw,
hazard_data=int(state))
shutil.rmtree(tmpdir)
LOGGER.info('Hazard layer processed...')
return True
def process_impact_layer(flood):
"""Process zipped impact layer and import it to databse
:param flood: Event id of flood
:type flood: realtime.models.flood.Flood
"""
LOGGER.info('Processing impact layer %s - %s' % (
flood.event_id,
flood.impact_layer.name
))
# extract hazard layer zip file
if not flood.impact_layer or not flood.impact_layer.name:
LOGGER.info('No impact layer')
return
zip_file_path = os.path.join(settings.MEDIA_ROOT,
flood.impact_layer.name)
if not os.path.exists(zip_file_path):
LOGGER.info('Impact layer doesn\'t exists')
return
with ZipFile(zip_file_path) as zf:
# Now process population impacted layer
tmpdir = tempfile.mkdtemp()
zf.extractall(path=tmpdir)
layer_filename = os.path.join(tmpdir, 'impact.shp')
source = DataSource(layer_filename)
layer = source[0]
ImpactEventBoundary.objects.filter(flood=flood).delete()
kelurahan = BoundaryAlias.objects.get(alias=OSM_LEVEL_7_NAME)
for feat in layer:
level_7_name = feat.get('NAMA_KELUR').strip()
try:
hazard_class = feat.get('affected')
except OGRIndexError:
hazard_class = feat.get('safe_ag')
population_affected = feat.get('Pop_Total')
geometry = feat.geom
geos_geometry = GEOSGeometry(geometry.geojson)
if isinstance(geos_geometry, Polygon):
# convert to multi polygon
geos_geometry = MultiPolygon(geos_geometry)
if hazard_class <= 1:
continue
try:
boundary_kelurahan = Boundary.objects.get(
name__iexact=level_7_name,
boundary_alias=kelurahan)
except Boundary.DoesNotExist:
LOGGER.debug('Boundary does not exists: %s' % level_7_name)
LOGGER.debug('Kelurahan Boundary should have been filled '
'already')
# Will try to create new one
boundary_kelurahan = Boundary.objects.create(
geometry=geos_geometry,
name=level_7_name,
boundary_alias=kelurahan)
boundary_kelurahan.save()
ImpactEventBoundary.objects.create(
flood=flood,
parent_boundary=boundary_kelurahan,
geometry=geos_geometry,
hazard_class=hazard_class,
population_affected=population_affected)
shutil.rmtree(tmpdir)
LOGGER.info('Impact layer processed...')
return True
