def add_asset_to_asset_list(asset_list, asset):
port_list = []
ports = asset.port
for p in ports:
conn_to_ids = [cp.id for cp in p.connectedTo]
profile = p.profile
profile_info_list = []
p_carr_id = None
if p.carrier:
p_carr_id = p.carrier.id
if profile:
profile_info_list = [] # generate_profile_info(profile)
port_list.append({
'name': p.name,
'id': p.id,
'type': type(p).__name__,
'conn_to': conn_to_ids,
'profile': profile_info_list,
'carrier': p_carr_id
})
state = asset_state_to_ui(asset)
geom = asset.geometry
if geom:
if isinstance(geom, esdl.Point):
lat = geom.lat
lon = geom.lon
capability_type = ESDLAsset.get_asset_capability_type(asset)
attrs = get_tooltip_asset_attrs(asset, 'marker')
add_spatial_attributes(asset, attrs)
asset_list.append([
'point', 'asset', asset.name, asset.id,
type(asset).__name__, [lat, lon], attrs, state, port_list,
capability_type
])
if isinstance(geom, esdl.Line):
coords = []
for point in geom.point:
coords.append([point.lat, point.lon])
attrs = get_tooltip_asset_attrs(asset, 'line')
add_spatial_attributes(asset, attrs)
asset_list.append([
'line', 'asset', asset.name, asset.id,
type(asset).__name__, coords, attrs, state, port_list
])
if isinstance(geom, esdl.Polygon):
coords = ESDLGeometry.parse_esdl_subpolygon(geom.exterior,
False) # [lon, lat]
coords = ESDLGeometry.exchange_coordinates(
coords) # --> [lat, lon]
capability_type = ESDLAsset.get_asset_capability_type(asset)
attrs = get_tooltip_asset_attrs(asset, 'polygon')
add_spatial_attributes(asset, attrs)
asset_list.append([
'polygon', 'asset', asset.name, asset.id,
type(asset).__name__, coords, attrs, state, port_list,
capability_type
])
def get_bag_contours(info):
with self.flask_app.app_context():
print("getting bag information")
esh = get_handler()
active_es_id = get_session('active_es_id')
area_id = info["id"]
area_polygon = { 'type': 'polygon', 'coordinates': info["polygon"] }
geometry = ESDLGeometry.create_ESDL_geometry(area_polygon)
boundary_wgs = ESDLGeometry.create_boundary_from_geometry(geometry)
# boundary_geojson = ESDLGeometry.create_geojson(area_id, '', [], boundary_wgs)
wkt_string = wkt.dumps(boundary_wgs)
# wkt_string = 'POLYGON ((4.359093904495239 52.012174264626445, 4.357388019561768 52.01154692445308, 4.357978105545044 52.01078750089633, 4.360188245773315 52.01160635705717, 4.362355470657349 52.012478026181434, 4.360767602920532 52.012847820073766, 4.359093904495239 52.012174264626445))'
# wkt_quoted = urllib.parse.quote(wkt_string)
es_edit = esh.get_energy_system(es_id=active_es_id)
instance = es_edit.instance
top_area = instance[0].area
target_area = ESDLEnergySystem.find_area(top_area, area_id)
if target_area:
try:
# url = 'http://' + settings.bag_config["host"] + ':' + settings.bag_config["port"] + \
# settings.bag_config["path_contour"] + '?wkt=' + wkt_quoted + '&format=xml'
# print(url)
# r = requests.get(url)
url = 'http://' + settings.bag_config["host"] + ':' + settings.bag_config["port"] + \
settings.bag_config["path_contour"] + '?format=xml'
print(url)
r = requests.post(url, json={"wkt": wkt_string})
if r.status_code == 201:
esdl_string = r.text
bag_es = ESDLAsset.load_asset_from_string(esdl_string)
if bag_es:
bag_inst = bag_es.instance[0]
if bag_inst:
bag_area = bag_inst.area
if bag_area:
bld_list = []
for bld in bag_area.asset:
if isinstance(bld, esdl.Building):
target_area.asset.append(bld.deepcopy())
geometry = bld.geometry
boundary_wgs = ESDLGeometry.create_boundary_from_geometry(geometry)
bld_list.append(ESDLGeometry.create_geojson(bld.id, bld.name, [], boundary_wgs))
if bld_list:
emit('geojson', {"layer": "bld_layer", "geojson": bld_list})
except Exception as e:
print('ERROR in accessing BAG service: '+str(e))
return None
# @EWOUD: Deze 'mogelijkheid' kunnen we ook gebruiken om geometries te renderen in de frontend
# self.emit_geometries_to_client(esh, active_es_id, bld_list)
else:
print("ERROR in finding area in ESDL for BAG service")
# self.flask_app.send_alert("ERROR in finding area in ESDL for BAG service")
return None
def energy_asset_to_ui(esh, es_id, asset): # , port_asset_mapping):
port_list = []
conn_list = []
ports = asset.port
for p in ports:
# p_asset = port_asset_mapping[p.id]
p_asset = get_asset_and_coord_from_port_id(esh, es_id, p.id)
p_asset_coord = p_asset['coord'] # get proper coordinate if asset is line
conn_to = [cp.id for cp in p.connectedTo]
profile = p.profile
profile_info_list = []
if profile:
profile_info_list = generate_profile_info(profile)
port_list.append \
({'name': p.name, 'id': p.id, 'type': type(p).__name__, 'conn_to': conn_to, 'profile': profile_info_list})
if conn_to:
# conn_to_list = conn_to.split(' ') # connectedTo attribute is list of port ID's separated by a space
for id in conn_to:
# pc_asset = port_asset_mapping[id]
pc_asset = get_asset_and_coord_from_port_id(esh, es_id, id)
pc_asset_coord = pc_asset['coord']
conn_list.append \
({'from-port-id': p.id, 'from-asset-id': p_asset['asset'].id, 'from-asset-coord': p_asset_coord,
'to-port-id': id, 'to-asset-id': pc_asset['asset'].id, 'to-asset-coord': pc_asset_coord})
geom = asset.geometry
if geom:
if isinstance(geom, esdl.Point):
lat = geom.lat
lon = geom.lon
capability_type = ESDLAsset.get_asset_capability_type(asset)
return ['point', 'asset', asset.name, asset.id, type(asset).__name__, [lat, lon], port_list, capability_type], conn_list
elif isinstance(geom, esdl.Line):
coords = []
for point in geom.point:
coords.append([point.lat, point.lon])
return ['line', 'asset', asset.name, asset.id, type(asset).__name__, coords, port_list], conn_list
elif isinstance(geom, esdl.Polygon):
if isinstance(asset, esdl.WindParc) or isinstance(asset, esdl.PVParc) or isinstance(asset, esdl.WindPark) \
or isinstance(asset, esdl.PVPark):
coords = ESDLGeometry.parse_esdl_subpolygon(geom.exterior, False) # [lon, lat]
coords = ESDLGeometry.exchange_coordinates(coords) # --> [lat, lon]
capability_type = ESDLAsset.get_asset_capability_type(asset)
# print(coords)
return ['polygon', 'asset', asset.name, asset.id, type(asset).__name__, coords, port_list, capability_type], conn_list
else:
return [], []
def get_port_coordinates(self, asset, index):
from_coords = ()
if isinstance(asset.geometry, Line):
if index == 0: # first port == first coordinate
point: Point = asset.geometry.point[0]
from_coords = (point.lat, point.lon)
elif index == len(asset.port) - 1:
point: Point = asset.geometry.point[-1]
from_coords = (point.lat, point.lon)
elif isinstance(asset.geometry, Point):
from_coords = (asset.geometry.lat, asset.geometry.lon)
if isinstance(asset.geometry, Polygon):
from_coords = ESDLGeometry.calculate_polygon_center(asset.geometry)
return from_coords
def get_asset_geom_info(asset):
geom = asset.geometry
if geom:
if isinstance(geom, esdl.Point):
lat = geom.lat
lon = geom.lon
return (lat, lon)
if isinstance(geom, esdl.Line):
points = geom.point
first = (points[0].lat, points[0].lon)
last = (points[len(points) - 1].lat, points[len(points) - 1].lon)
return [first, last]
if isinstance(geom, esdl.Polygon):
center = ESDLGeometry.calculate_polygon_center(geom)
return center
return ()
def add_geometries_to_esdl(self, esh, es_id, area_list):
with self.flask_app.app_context():
es_edit = esh.get_energy_system(es_id)
instance = es_edit.instance
area = instance[0].area
for ibis_area in area_list:
new_area = esdl.Area(id=str(uuid4()), name=ibis_area['name'])
new_area.scope = esdl.AreaScopeEnum.from_string("UNDEFINED")
boundary = ibis_area
if boundary:
geometry = ESDLGeometry.create_geometry_from_geom(
boundary['geom'])
new_area.geometry = geometry
area.area.append(new_area)
esh.add_object_to_dict(es_id, new_area)
def get_boundary_info(info):
print('get_boundary_info:')
print(info)
user = get_session('user-email')
user_settings = self.get_user_settings(user)
boundaries_year = user_settings['boundaries_year']
shape_dictionary = get_session('shape_dictionary')
if not shape_dictionary:
shape_dictionary = {}
identifier = info["identifier"]
toparea_name = info["toparea_name"]
scope = info["scope"]
subscope_enabled = info["subscope_enabled"]
subscope = info["subscope"]
select_subareas = info["select_subareas"]
selected_subareas = info["selected_subareas"]
initialize_ES = info["initialize_ES"]
add_boundary_to_ESDL = info["add_boundary_to_ESDL"]
if not is_valid_boundary_id(identifier):
send_alert(
"Not a valid identifier. Try identifiers like PV27 (Noord-Holland) or GM0060 (Ameland)"
)
return
active_es_id = get_session('active_es_id')
esh = get_handler()
es_edit = esh.get_energy_system(es_id=active_es_id)
instance = es_edit.instance
area = instance[0].area
area_list = []
boundary = None
if subscope_enabled:
self.__preload_subboundaries_in_cache(
boundaries_year,
esdl.AreaScopeEnum.from_string(str.upper(scope)),
esdl.AreaScopeEnum.from_string(str.upper(subscope)),
str.upper(identifier))
else:
boundary = self.get_boundary_from_service(
boundaries_year,
esdl.AreaScopeEnum.from_string(str.upper(scope)),
str.upper(identifier))
if boundary:
geom = boundary['geom']
# geometry = ESDLGeometry.create_geometry_from_geom()
shape = Shape.parse_geojson_geometry(boundary['geom'])
if shape:
shape_dictionary[identifier] = shape
for i in range(0, len(geom['coordinates'])):
if len(geom['coordinates']) > 1:
area_id_number = " ({} of {})".format(
i + 1, len(geom['coordinates']))
else:
area_id_number = ""
area_list.append({
"type": "Feature",
"geometry": {
"type": "Polygon",
"coordinates": geom['coordinates'][i]
},
"properties": {
"id": area.id + area_id_number,
"name": area.name,
"KPIs": []
}
})
if initialize_ES:
# change ID, name and scope of ES
if select_subareas:
area.id = "part of " + identifier
else:
area.id = identifier
# Area ID has changed, re-add to dictionairy
esh.add_object_to_dict(active_es_id, area)
area.scope = esdl.AreaScopeEnum.from_string(str.upper(scope))
area.name = toparea_name
if add_boundary_to_ESDL:
# returns boundary: { type: '', boundary: [[[[ ... ]]]] } (multipolygon in RD)
if not boundary: # check if already requested
boundary = self.get_boundary_from_service(
boundaries_year,
esdl.AreaScopeEnum.from_string(str.upper(scope)),
str.upper(identifier))
if boundary:
geometry = ESDLGeometry.create_geometry_from_geom(
boundary['geom'])
area.geometry = geometry
shape = Shape.parse_geojson_geometry(boundary['geom'])
if shape:
shape_dictionary[identifier] = shape
# boundary = get_boundary_from_service(area_scope, area_id)
# if boundary:
# emit('area_boundary', {'info-type': 'MP-RD', 'crs': 'RD', 'boundary': boundary})
if subscope_enabled:
boundaries = self.__get_subboundaries_from_service(
boundaries_year,
esdl.AreaScopeEnum.from_string(str.upper(scope)),
esdl.AreaScopeEnum.from_string(str.upper(subscope)),
str.upper(identifier))
# result (boundaries) is an ARRAY of:
# {'code': 'BU00140500', 'geom': '{"type":"MultiPolygon","bbox":[...],"coordinates":[[[[6.583651,53.209594],
# [6.58477,...,53.208816],[6.583651,53.209594]]]]}'}
if not boundaries:
send_alert(
'Error processing boundary information or no boundary information returned'
)
for boundary in boundaries:
geom = None
try:
# geom = json.loads(boundary["geom"])
geom = boundary["geom"]
shape = Shape.parse_geojson_geometry(boundary['geom'])
if shape:
shape_dictionary[boundary['code']] = shape
except Exception as e:
print(
'Error parsing JSON from GEIS boundary service: ' +
str(e))
if geom:
skip_subarea = False
if select_subareas and selected_subareas and boundary[
"code"] not in selected_subareas:
skip_subarea = True
if not skip_subarea:
sub_area_id = boundary["code"]
sub_area_name = boundary["name"]
if initialize_ES:
sub_area = esdl.Area()
sub_area.id = sub_area_id
sub_area.name = sub_area_name
sub_area.scope = esdl.AreaScopeEnum.from_string(
str.upper(subscope))
if add_boundary_to_ESDL:
geometry = ESDLGeometry.create_geometry_from_geom(
geom)
sub_area.geometry = geometry
area.area.append(sub_area)
esh.add_object_to_dict(active_es_id, sub_area)
for i in range(0, len(geom['coordinates'])):
if len(geom['coordinates']) > 1:
area_id_number = " ({} of {})".format(
i + 1, len(geom['coordinates']))
else:
area_id_number = ""
area_list.append({
"type": "Feature",
"geometry": {
"type": "Polygon",
"coordinates": geom['coordinates'][i]
},
"properties": {
"id": sub_area_id + area_id_number,
"name": sub_area_name,
"KPIs": []
}
})
set_session('shape_dictionary', shape_dictionary)
emit('geojson', {"layer": "area_layer", "geojson": area_list})
print('Ready processing boundary information')
def process_area(esh, es_id, asset_list, building_list, area_bld_list, conn_list, area, level):
area_bld_list.append(['Area', area.id, area.name, level])
# process subareas
for ar in area.area:
process_area(esh, es_id, asset_list, building_list, area_bld_list, conn_list, ar, level+1)
# process assets in area
for asset in area.asset:
if isinstance(asset, esdl.AbstractBuilding):
process_building(esh, es_id, asset_list, building_list, area_bld_list, conn_list, asset, False, level+1)
if isinstance(asset, esdl.EnergyAsset):
port_list = []
ports = asset.port
for p in ports:
p_asset = get_asset_and_coord_from_port_id(esh, es_id, p.id)
p_asset_coord = p_asset['coord'] # get proper coordinate if asset is line
conn_to_ids = [cp.id for cp in p.connectedTo]
profile = p.profile
profile_info_list = []
p_carr_id = None
if p.carrier:
p_carr_id = p.carrier.id
if profile:
profile_info_list = generate_profile_info(profile)
port_list.append({'name': p.name, 'id': p.id, 'type': type(p).__name__, 'conn_to': conn_to_ids, 'profile': profile_info_list, 'carrier': p_carr_id})
if conn_to_ids:
for pc in p.connectedTo:
pc_asset = get_asset_and_coord_from_port_id(esh, es_id, pc.id)
if pc_asset['asset'].containingBuilding:
bld_pc_asset = pc_asset['asset'].containingBuilding
if bld_pc_asset.geometry:
if isinstance(bld_pc_asset.geometry, esdl.Point):
pc_asset_coord = (bld_pc_asset.geometry.lat, bld_pc_asset.geometry.lon)
elif isinstance(bld_pc_asset.geometry, esdl.Polygon):
pc_asset_coord = ESDLGeometry.calculate_polygon_center(bld_pc_asset.geometry)
else:
pc_asset_coord = pc_asset['coord']
pc_carr_id = None
if pc.carrier:
pc_carr_id = pc.carrier.id
conn_list.append({'from-port-id': p.id, 'from-port-carrier': p_carr_id, 'from-asset-id': p_asset['asset'].id, 'from-asset-coord': p_asset_coord,
'to-port-id': pc.id, 'to-port-carrier': pc_carr_id, 'to-asset-id': pc_asset['asset'].id, 'to-asset-coord': pc_asset_coord})
geom = asset.geometry
if geom:
if isinstance(geom, esdl.Point):
lat = geom.lat
lon = geom.lon
capability_type = ESDLAsset.get_asset_capability_type(asset)
asset_list.append(['point', 'asset', asset.name, asset.id, type(asset).__name__, [lat, lon], port_list, capability_type])
if isinstance(geom, esdl.Line):
coords = []
for point in geom.point:
coords.append([point.lat, point.lon])
asset_list.append(['line', 'asset', asset.name, asset.id, type(asset).__name__, coords, port_list])
if isinstance(geom, esdl.Polygon):
# if isinstance(asset, esdl.WindParc) or isinstance(asset, esdl.PVParc) or isinstance(asset, esdl.WindPark) or isinstance(asset, esdl.PVPark):
coords = ESDLGeometry.parse_esdl_subpolygon(geom.exterior, False) # [lon, lat]
coords = ESDLGeometry.exchange_coordinates(coords) # --> [lat, lon]
capability_type = ESDLAsset.get_asset_capability_type(asset)
# print(coords)
asset_list.append(['polygon', 'asset', asset.name, asset.id, type(asset).__name__, coords, port_list, capability_type])
for potential in area.potential:
geom = potential.geometry
if geom:
if isinstance(geom, esdl.Point):
lat = geom.lat
lon = geom.lon
asset_list.append(
['point', 'potential', potential.name, potential.id, type(potential).__name__, [lat, lon]])
if isinstance(geom, esdl.Polygon):
coords = []
for point in geom.exterior.point:
coords.append([point.lat, point.lon])
asset_list.append(['polygon', 'potential', potential.name, potential.id, type(potential).__name__, coords])
def process_building(esh, es_id, asset_list, building_list, area_bld_list, conn_list, building, bld_editor, level):
# Add building to list that is shown in a dropdown at the top
area_bld_list.append(['Building', building.id, building.name, level])
# Determine if building has assets
building_has_assets = False
if building.asset:
for basset in building.asset:
if isinstance(basset, esdl.EnergyAsset):
building_has_assets = True
break
# Generate information for drawing building (as a point or a polygon)
if isinstance(building, esdl.Building) or isinstance(building, esdl.AggregatedBuilding):
geometry = building.geometry
bld_KPIs = create_building_KPIs(building)
if geometry:
if isinstance(geometry, esdl.Point):
building_list.append(
['point', building.name, building.id, type(building).__name__, [geometry.lat, geometry.lon], building_has_assets, bld_KPIs])
bld_coord = (geometry.lat, geometry.lon)
elif isinstance(geometry, esdl.Polygon):
coords = ESDLGeometry.parse_esdl_subpolygon(building.geometry.exterior, False) # [lon, lat]
coords = ESDLGeometry.exchange_coordinates(coords) # --> [lat, lon]
# building_list.append(['polygon', building.name, building.id, type(building).__name__, coords, building_has_assets])
boundary = ESDLGeometry.create_boundary_from_geometry(geometry)
building_list.append(['polygon', building.name, building.id, type(building).__name__, boundary['coordinates'], building_has_assets, bld_KPIs])
# bld_coord = coords
bld_coord = ESDLGeometry.calculate_polygon_center(geometry)
elif building.containingBuilding: # BuildingUnit
bld_geom = building.containingBuilding.geometry
if bld_geom:
if isinstance(bld_geom, esdl.Point):
bld_coord = (bld_geom.lat, bld_geom.lon)
elif isinstance(bld_geom, esdl.Polygon):
bld_coord = ESDLGeometry.calculate_polygon_center(bld_geom)
# Iterate over all assets in building to gather all required information
for basset in building.asset:
if isinstance(basset, esdl.AbstractBuilding):
process_building(esh, es_id, asset_list, building_list, area_bld_list, conn_list, basset, bld_editor, level + 1)
else:
# Create a list of ports for this asset
port_list = []
ports = basset.port
for p in ports:
conn_to = p.connectedTo
conn_to_id_list = [ct.id for ct in conn_to]
# TODO: add profile_info and carrier
port_list.append({'name': p.name, 'id': p.id, 'type': type(p).__name__, 'conn_to': conn_to_id_list})
geom = basset.geometry
coord = ()
if geom: # Individual asset in Building has its own geometry information
if isinstance(geom, esdl.Point):
lat = geom.lat
lon = geom.lon
coord = (lat, lon)
capability_type = ESDLAsset.get_asset_capability_type(basset)
if bld_editor:
asset_list.append(['point', 'asset', basset.name, basset.id, type(basset).__name__, [lat, lon], port_list, capability_type])
else:
send_alert("Assets within buildings with geometry other than esdl.Point are not supported")
# Inherit geometry from containing building
# if level > 0:
# coord = bld_coord
ports = basset.port
for p in ports:
p_carr_id = None
if p.carrier:
p_carr_id = p.carrier.id
conn_to = p.connectedTo
if conn_to:
for pc in conn_to:
in_different_buildings = False
pc_asset = get_asset_and_coord_from_port_id(esh, es_id, pc.id)
# If the asset the current asset connects to, is in a building...
if pc_asset['asset'].containingBuilding:
bld_pc_asset = pc_asset['asset'].containingBuilding
bld_basset = basset.containingBuilding
# If the asset is in a different building ...
if not bld_pc_asset == bld_basset:
in_different_buildings = True
if bld_pc_asset.geometry:
if bld_editor:
# ... connect to the left border
pc_asset_coord = (coord[0], 0)
else:
# ... use the building coordinate instead of the asset coordinate
if isinstance(bld_pc_asset.geometry, esdl.Point):
pc_asset_coord = (bld_pc_asset.geometry.lat, bld_pc_asset.geometry.lon)
elif isinstance(bld_pc_asset.geometry, esdl.Polygon):
pc_asset_coord = ESDLGeometry.calculate_polygon_center(bld_pc_asset.geometry)
# If connecting to a building outside of the current, replace current asset
# coordinates with building coordinates too
if not bld_editor:
coord = bld_coord
else:
# asset is in the same building, use asset's own coordinates
pc_asset_coord = pc_asset['coord']
else:
# other asset is not in a building
if bld_editor:
# ... connect to the left border
pc_asset_coord = (coord[0], 0)
else:
# ... just use asset's location
pc_asset_coord = pc_asset['coord']
pc_carr_id = None
if pc.carrier:
pc_carr_id = pc.carrier.id
# Add connections if we're editing a building or if the connection is between two different buildings
# ( The case of an asset in an area that is connected with an asset in a building is handled
# in process_area (now all connections are added twice, from both sides) )
if bld_editor or in_different_buildings:
conn_list.append({'from-port-id': p.id, 'from-port-carrier': p_carr_id, 'from-asset-id': basset.id, 'from-asset-coord': coord,
'to-port-id': pc.id, 'to-port-carrier': pc_carr_id, 'to-asset-id': pc_asset['asset'].id, 'to-asset-coord': pc_asset_coord})
if bld_editor:
for potential in building.potential:
geom = potential.geometry
if geom:
if isinstance(geom, esdl.Point):
lat = geom.lat
lon = geom.lon
asset_list.append(
['point', 'potential', potential.name, potential.id, type(potential).__name__, [lat, lon]])
def find_area_info_geojson(area_list, pot_list, this_area):
area_id = this_area.id
area_name = this_area.name
if not area_name: area_name = ""
area_scope = this_area.scope
area_geometry = this_area.geometry
user = get_session('user-email')
user_settings = BoundaryService.get_instance().get_user_settings(user)
boundaries_year = user_settings['boundaries_year']
geojson_KPIs = {}
area_KPIs = this_area.KPIs
if area_KPIs:
for kpi in area_KPIs.kpi:
if not isinstance(kpi, esdl.DistributionKPI):
geojson_KPIs[kpi.name] = kpi.value
area_shape = None
if area_geometry:
if isinstance(area_geometry, esdl.Polygon):
shape_polygon = Shape.create(area_geometry)
area_list.append(shape_polygon.get_geojson_feature({
"id": area_id,
"name": area_name,
"KPIs": geojson_KPIs
}))
area_shape = shape_polygon
if isinstance(area_geometry, esdl.MultiPolygon):
boundary_wgs = ESDLGeometry.create_boundary_from_geometry(area_geometry)
shape_multipolygon = Shape.parse_geojson_geometry(boundary_wgs)
num_sub_polygons = len(shape_multipolygon.shape.geoms)
for i, pol in enumerate(shape_multipolygon.shape.geoms):
if num_sub_polygons > 1:
area_id_number = " ({} of {})".format(i + 1, num_sub_polygons)
else:
area_id_number = ""
shape_polygon = Shape.create(pol)
area_list.append(shape_polygon.get_geojson_feature({
"id": str.upper(area_id) + area_id_number,
"name": area_name,
"KPIs": geojson_KPIs
}))
area_shape = shape_multipolygon
if isinstance(area_geometry, esdl.WKT):
shape_wkt = Shape.create(area_geometry)
area_list.append(shape_wkt.get_geojson_feature({
"id": area_id,
"name": area_name,
"KPIs": geojson_KPIs
}))
area_shape = shape_wkt
else:
if area_id and area_scope.name != 'UNDEFINED':
if is_valid_boundary_id(area_id):
# print('Retrieve boundary from boundary service')
boundary_wgs = BoundaryService.get_instance().get_boundary_from_service(boundaries_year, area_scope, str.upper(area_id))
if boundary_wgs:
sh = Shape.parse_geojson_geometry(boundary_wgs['geom'])
num_sub_polygons = len(sh.shape.geoms)
for i, pol in enumerate(sh.shape.geoms):
if num_sub_polygons > 1:
area_id_number = " ({} of {})".format(i + 1, num_sub_polygons)
else:
area_id_number = ""
shape_polygon = Shape.create(pol)
area_list.append(shape_polygon.get_geojson_feature({
"id": str.upper(area_id) + area_id_number,
"name": boundary_wgs['name'],
"KPIs": geojson_KPIs
}))
area_shape = sh
# assign random coordinates if boundary is given and area contains assets without coordinates
# and gives assets within buildings a proper coordinate
if area_shape:
update_asset_geometries_shape(this_area, area_shape)
potentials = this_area.potential
for potential in potentials:
potential_geometry = potential.geometry
potential_name = potential.name
if not potential_name:
potential_name = ""
if potential_geometry:
if isinstance(potential_geometry, esdl.WKT):
shape = Shape.create(potential_geometry)
pot_list.append(shape.get_geojson_feature({
"id": potential.id,
"name": potential_name,
}))
for area in this_area.area:
find_area_info_geojson(area_list, pot_list, area)
def process_area(esh, es_id, asset_list, building_list, area_bld_list,
conn_list, area, level):
area_bld_list.append(['Area', area.id, area.name, level])
# process subareas
for ar in area.area:
process_area(esh, es_id, asset_list, building_list, area_bld_list,
conn_list, ar, level + 1)
# process assets in area
for asset in area.asset:
if isinstance(asset, esdl.AbstractBuilding):
process_building(esh, es_id, asset_list, building_list,
area_bld_list, conn_list, asset, False, level + 1)
if isinstance(asset, esdl.EnergyAsset):
add_asset_to_asset_list(asset_list, asset)
for p in asset.port:
p_asset = get_asset_and_coord_from_port_id(esh, es_id, p.id)
p_asset_coord = p_asset[
'coord'] # get proper coordinate if asset is line
conn_to_ids = [cp.id for cp in p.connectedTo]
p_carr_id = None
if p.carrier:
p_carr_id = p.carrier.id
if conn_to_ids:
for pc in p.connectedTo:
pc_asset = get_asset_and_coord_from_port_id(
esh, es_id, pc.id)
pc_asset_coord = None
if pc_asset['asset'].containingBuilding:
bld_pc_asset = pc_asset['asset'].containingBuilding
if bld_pc_asset.geometry:
if isinstance(bld_pc_asset.geometry,
esdl.Point):
pc_asset_coord = (
bld_pc_asset.geometry.lat,
bld_pc_asset.geometry.lon)
elif isinstance(bld_pc_asset.geometry,
esdl.Polygon):
pc_asset_coord = ESDLGeometry.calculate_polygon_center(
bld_pc_asset.geometry)
else:
pc_asset_coord = pc_asset['coord']
pc_carr_id = None
if pc.carrier:
pc_carr_id = pc.carrier.id
conn_list.append({
'from-port-id': p.id,
'from-port-carrier': p_carr_id,
'from-asset-id': p_asset['asset'].id,
'from-asset-coord': p_asset_coord,
'to-port-id': pc.id,
'to-port-carrier': pc_carr_id,
'to-asset-id': pc_asset['asset'].id,
'to-asset-coord': pc_asset_coord
})
for potential in area.potential:
geom = potential.geometry
if geom:
if isinstance(geom, esdl.Point):
lat = geom.lat
lon = geom.lon
asset_list.append([
'point', 'potential', potential.name, potential.id,
type(potential).__name__, [lat, lon]
])
if isinstance(geom, esdl.Polygon):
coords = []
for point in geom.exterior.point:
coords.append([point.lat, point.lon])
asset_list.append([
'polygon', 'potential', potential.name, potential.id,
type(potential).__name__, coords
])
def find_area_info_geojson(area_list, pot_list, this_area, shape_dictionary):
area_id = this_area.id
area_name = this_area.name
if not area_name: area_name = ""
area_scope = this_area.scope
area_geometry = this_area.geometry
user = get_session('user-email')
user_settings = BoundaryService.get_instance().get_user_settings(user)
boundaries_year = user_settings['boundaries_year']
geojson_KPIs = {}
geojson_dist_kpis = {}
area_KPIs = this_area.KPIs
if area_KPIs:
for kpi in area_KPIs.kpi:
if not isinstance(kpi, esdl.DistributionKPI):
kpi_qau = kpi.quantityAndUnit
if kpi_qau:
if isinstance(kpi_qau, esdl.QuantityAndUnitReference):
kpi_qau = kpi_qau.reference
if not kpi_qau: # Reference field in the ESDL could be "" (but should never be)
unit = ''
else:
unit = ESDLQuantityAndUnits.unit_to_string(kpi_qau)
else:
unit = ''
geojson_KPIs[kpi.name] = {'value': kpi.value, 'unit': unit}
else:
geojson_dist_kpis[kpi.name] = {
"type": "distributionKPI",
"value": []
}
for str_val in kpi.distribution.stringItem:
geojson_dist_kpis[kpi.name]["value"].append({
"name":
str_val.label,
"value":
str_val.value
})
if area_geometry:
shape = Shape.create(area_geometry)
geojson_dist_kpis[kpi.name]["location"] = [
shape.shape.centroid.coords.xy[1][0],
shape.shape.centroid.coords.xy[0][0]
]
else:
geojson_dist_kpis[kpi.name]["location"] = None
area_shape = None
if area_geometry:
if isinstance(area_geometry, esdl.Polygon):
shape_polygon = Shape.create(area_geometry)
area_list.append(
shape_polygon.get_geojson_feature({
"id":
area_id,
"name":
area_name,
"KPIs":
geojson_KPIs,
"dist_KPIs":
geojson_dist_kpis
}))
area_shape = shape_polygon
if isinstance(area_geometry, esdl.MultiPolygon):
boundary_wgs = ESDLGeometry.create_boundary_from_geometry(
area_geometry)
shape_multipolygon = Shape.parse_geojson_geometry(boundary_wgs)
num_sub_polygons = len(shape_multipolygon.shape.geoms)
for i, pol in enumerate(shape_multipolygon.shape.geoms):
if num_sub_polygons > 1:
area_id_number = " ({} of {})".format(
i + 1, num_sub_polygons)
else:
area_id_number = ""
shape_polygon = Shape.create(pol)
area_list.append(
shape_polygon.get_geojson_feature({
"id":
area_id + area_id_number,
"name":
area_name,
"KPIs":
geojson_KPIs,
"dist_KPIs":
geojson_dist_kpis
}))
area_shape = shape_multipolygon
if isinstance(area_geometry, esdl.WKT):
shape_wkt = Shape.create(area_geometry)
area_list.append(
shape_wkt.get_geojson_feature({
"id": area_id,
"name": area_name,
"KPIs": geojson_KPIs
}))
area_shape = shape_wkt
else:
if area_id and area_scope.name != 'UNDEFINED':
if is_valid_boundary_id(area_id):
# print('Retrieve boundary from boundary service')
boundary_wgs = BoundaryService.get_instance(
).get_boundary_from_service(boundaries_year, area_scope,
str.upper(area_id))
if boundary_wgs:
sh = Shape.parse_geojson_geometry(boundary_wgs['geom'])
num_sub_polygons = len(sh.shape.geoms)
for i, pol in enumerate(sh.shape.geoms):
if num_sub_polygons > 1:
area_id_number = " ({} of {})".format(
i + 1, num_sub_polygons)
else:
area_id_number = ""
shape_polygon = Shape.create(pol)
# We still need to add the center of the area for the distribution KPI.
if area_KPIs:
for kpi in area_KPIs.kpi:
if isinstance(kpi, esdl.DistributionKPI):
shape = sh
geojson_dist_kpis[kpi.name]["location"] = [
shape.shape.centroid.coords.xy[1][0],
shape.shape.centroid.coords.xy[0][0]
]
area_list.append(
shape_polygon.get_geojson_feature({
"id":
area_id + area_id_number,
"name":
boundary_wgs['name'],
"KPIs":
geojson_KPIs,
"dist_KPIs":
geojson_dist_kpis
}))
area_shape = sh
# assign random coordinates if boundary is given and area contains assets without coordinates
# and gives assets within buildings a proper coordinate
if area_shape:
shape_dictionary[area_id] = area_shape
# call this function even with area_shape == None, to position building assets inside a building
update_asset_geometries_shape(this_area, area_shape)
potentials = this_area.potential
for potential in potentials:
potential_geometry = potential.geometry
potential_name = potential.name
if not potential_name:
potential_name = ""
if potential_geometry:
if isinstance(potential_geometry, esdl.WKT):
shape = Shape.create(potential_geometry)
pot_list.append(
shape.get_geojson_feature({
"id": potential.id,
"name": potential_name,
}))
shape_dictionary[potential.id] = shape
for area in this_area.area:
find_area_info_geojson(area_list, pot_list, area, shape_dictionary)