forked from s_ranjbar/city_retrofit
406 lines
12 KiB
Python
406 lines
12 KiB
Python
"""
|
|
City module
|
|
SPDX - License - Identifier: LGPL - 3.0 - or -later
|
|
Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca
|
|
Contributor Peter Yefi peteryefi@gmail.com
|
|
"""
|
|
from __future__ import annotations
|
|
import sys
|
|
import pickle
|
|
import math
|
|
from typing import List, Union
|
|
import pyproj
|
|
from pyproj import Transformer
|
|
from pathlib import Path
|
|
|
|
from city_model_structure.building import Building
|
|
from city_model_structure.city_object import CityObject
|
|
from city_model_structure.city_objects_cluster import CityObjectsCluster
|
|
from city_model_structure.buildings_cluster import BuildingsCluster
|
|
from city_model_structure.parts_consisting_building import PartsConsistingBuilding
|
|
from city_model_structure.subway_entrance import SubwayEntrance
|
|
from city_model_structure.fuel import Fuel
|
|
from city_model_structure.machine import Machine
|
|
from helpers.geometry_helper import GeometryHelper
|
|
from helpers.location import Location
|
|
from city_model_structure.energy_system import EnergySystem
|
|
|
|
|
|
class City:
|
|
"""
|
|
City class
|
|
"""
|
|
|
|
def __init__(self, lower_corner, upper_corner, srs_name):
|
|
self._name = None
|
|
self._lower_corner = lower_corner
|
|
self._upper_corner = upper_corner
|
|
self._buildings = None
|
|
self._subway_entrances = None
|
|
self._srs_name = srs_name
|
|
self._geometry = GeometryHelper()
|
|
# todo: right now extracted at city level, in the future should be extracted also at building level if exist
|
|
self._location = None
|
|
self._country_code = None
|
|
self._climate_reference_city = None
|
|
self._climate_file = None
|
|
self._latitude = None
|
|
self._longitude = None
|
|
self._time_zone = None
|
|
self._buildings_clusters = None
|
|
self._parts_consisting_buildings = None
|
|
self._city_objects_clusters = None
|
|
self._city_objects = None
|
|
self._energy_systems = None
|
|
self._fuels = None
|
|
self._machines = None
|
|
self._stations = []
|
|
|
|
@property
|
|
def fuels(self) -> [Fuel]:
|
|
return self._fuels
|
|
|
|
@fuels.setter
|
|
def fuels(self, value):
|
|
self._fuels = value
|
|
|
|
@property
|
|
def machines(self) -> [Machine]:
|
|
return self._machines
|
|
|
|
@machines.setter
|
|
def machines(self, value):
|
|
self._machines = value
|
|
|
|
def _get_location(self) -> Location:
|
|
if self._location is None:
|
|
gps = pyproj.CRS('EPSG:4326') # LatLon with WGS84 datum used by GPS units and Google Earth
|
|
try:
|
|
input_reference = pyproj.CRS(self.srs_name) # Projected coordinate system from input data
|
|
except pyproj.exceptions.CRSError:
|
|
sys.stderr.write('Invalid projection reference system, please check the input data. '
|
|
'(e.g. in CityGML files: srs_name)\n')
|
|
sys.exit()
|
|
transformer = Transformer.from_crs(input_reference, gps)
|
|
coordinates = transformer.transform(self.lower_corner[0], self.lower_corner[1])
|
|
self._location = GeometryHelper.get_location(coordinates[0], coordinates[1])
|
|
return self._location
|
|
|
|
@property
|
|
def country_code(self):
|
|
"""
|
|
Get city country code
|
|
:return: str
|
|
"""
|
|
return self._get_location().country
|
|
|
|
@property
|
|
def name(self):
|
|
"""
|
|
Get city name
|
|
:return: str
|
|
"""
|
|
return self._get_location().city
|
|
|
|
@property
|
|
def climate_reference_city(self) -> Union[None, str]:
|
|
"""
|
|
Get the name for the climatic information reference city
|
|
:return: None or str
|
|
"""
|
|
return self._climate_reference_city
|
|
|
|
@climate_reference_city.setter
|
|
def climate_reference_city(self, value):
|
|
"""
|
|
Set the name for the climatic information reference city
|
|
:param value: str
|
|
"""
|
|
if value is not None:
|
|
self._climate_reference_city = str(value)
|
|
|
|
@property
|
|
def climate_file(self) -> Union[None, Path]:
|
|
"""
|
|
Get the climate file full path
|
|
:return: None or Path
|
|
"""
|
|
return self._climate_file
|
|
|
|
@climate_file.setter
|
|
def climate_file(self, value):
|
|
"""
|
|
Set the climate file full path
|
|
:param value: Path
|
|
"""
|
|
if value is not None:
|
|
self._climate_file = Path(value)
|
|
|
|
@property
|
|
def city_objects(self) -> Union[List[CityObject], None]:
|
|
"""
|
|
Get the city objects belonging to the city
|
|
:return: None or [CityObject]
|
|
"""
|
|
if self._city_objects is None:
|
|
if self.city_objects_clusters is None:
|
|
self._city_objects = []
|
|
else:
|
|
self._city_objects = self.city_objects_clusters
|
|
if self.buildings is not None:
|
|
for building in self.buildings:
|
|
self._city_objects.append(building)
|
|
if self.subway_entrances is not None:
|
|
for subway_entrance in self.subway_entrances:
|
|
self._city_objects.append(subway_entrance)
|
|
return self._city_objects
|
|
|
|
@property
|
|
def buildings(self) -> Union[List[Building], None]:
|
|
"""
|
|
Get the buildings belonging to the city
|
|
:return: None or [Building]
|
|
"""
|
|
return self._buildings
|
|
|
|
@property
|
|
def subway_entrances(self) -> Union[List[SubwayEntrance], None]:
|
|
"""
|
|
Get the subway entrances belonging to the city
|
|
:return: a list of subway entrances objects or none
|
|
"""
|
|
return self._subway_entrances
|
|
|
|
@property
|
|
def lower_corner(self) -> List[float]:
|
|
"""
|
|
Get city lower corner
|
|
:return: [x,y,z]
|
|
"""
|
|
return self._lower_corner
|
|
|
|
@property
|
|
def upper_corner(self) -> List[float]:
|
|
"""
|
|
Get city upper corner
|
|
:return: [x,y,z]
|
|
"""
|
|
return self._upper_corner
|
|
|
|
def city_object(self, name) -> Union[CityObject, None]:
|
|
"""
|
|
Retrieve the city CityObject with the given name
|
|
:param name:str
|
|
:return: None or CityObject
|
|
"""
|
|
for city_object in self.buildings:
|
|
if city_object.name == name:
|
|
return city_object
|
|
return None
|
|
|
|
def add_city_object(self, new_city_object):
|
|
"""
|
|
Add a CityObject to the city
|
|
:param new_city_object:CityObject
|
|
:return: None or not implemented error
|
|
"""
|
|
if new_city_object.type == 'building':
|
|
if self._buildings is None:
|
|
self._buildings = []
|
|
self._buildings.append(new_city_object)
|
|
elif new_city_object.type == 'subway_entrance':
|
|
if self._subway_entrances is None:
|
|
self._subway_entrances = []
|
|
self._subway_entrances.append(new_city_object)
|
|
elif new_city_object.type == 'energy_system':
|
|
if self._energy_systems is None:
|
|
self._energy_systems = []
|
|
self._energy_systems.append(new_city_object)
|
|
else:
|
|
raise NotImplementedError(new_city_object.type)
|
|
|
|
def remove_city_object(self, city_object):
|
|
"""
|
|
Remove a CityObject from the city
|
|
:param city_object:CityObject
|
|
:return: None
|
|
"""
|
|
if city_object.type != 'building':
|
|
raise NotImplementedError(city_object.type)
|
|
if self._buildings is None or self._buildings == []:
|
|
sys.stderr.write('Warning: impossible to remove city_object, the city is empty\n')
|
|
else:
|
|
if city_object in self._buildings:
|
|
self._buildings.remove(city_object)
|
|
|
|
@property
|
|
def srs_name(self) -> Union[None, str]:
|
|
"""
|
|
Get city srs name
|
|
:return: None or str
|
|
"""
|
|
return self._srs_name
|
|
|
|
@name.setter
|
|
def name(self, value):
|
|
"""
|
|
Set city name
|
|
:param value:str
|
|
"""
|
|
if value is not None:
|
|
self._name = str(value)
|
|
|
|
@staticmethod
|
|
def load(city_filename) -> City:
|
|
"""
|
|
Load a city saved with city.save(city_filename)
|
|
:param city_filename: city filename
|
|
:return: City
|
|
"""
|
|
with open(city_filename, 'rb') as file:
|
|
return pickle.load(file)
|
|
|
|
def save(self, city_filename):
|
|
"""
|
|
Save a city into the given filename
|
|
:param city_filename: destination city filename
|
|
:return: None
|
|
"""
|
|
with open(city_filename, 'wb') as file:
|
|
pickle.dump(self, file)
|
|
|
|
def region(self, center, radius) -> City:
|
|
"""
|
|
Get a region from the city
|
|
:param center: specific point in space [x, y, z]
|
|
:param radius: distance to center of the sphere selected in meters
|
|
:return: selected_region_city
|
|
"""
|
|
selected_region_lower_corner = [center[0] - radius, center[1] - radius, center[2] - radius]
|
|
selected_region_upper_corner = [center[0] + radius, center[1] + radius, center[2] + radius]
|
|
selected_region_city = City(selected_region_lower_corner, selected_region_upper_corner, srs_name=self.srs_name)
|
|
selected_region_city.climate_file = self.climate_file
|
|
# selected_region_city.climate_reference_city = self.climate_reference_city
|
|
for city_object in self.city_objects:
|
|
location = city_object.centroid
|
|
if location is not None:
|
|
distance = math.sqrt(math.pow(location[0]-center[0], 2) + math.pow(location[1]-center[1], 2)
|
|
+ math.pow(location[2]-center[2], 2))
|
|
if distance < radius:
|
|
selected_region_city.add_city_object(city_object)
|
|
return selected_region_city
|
|
|
|
@property
|
|
def latitude(self) -> Union[None, float]:
|
|
"""
|
|
Get city latitude in degrees
|
|
:return: None or float
|
|
"""
|
|
return self._latitude
|
|
|
|
@latitude.setter
|
|
def latitude(self, value):
|
|
"""
|
|
Set city latitude in degrees
|
|
:parameter value: float
|
|
"""
|
|
if value is not None:
|
|
self._latitude = float(value)
|
|
|
|
@property
|
|
def longitude(self) -> Union[None, float]:
|
|
"""
|
|
Get city longitude in degrees
|
|
:return: None or float
|
|
"""
|
|
return self._longitude
|
|
|
|
@longitude.setter
|
|
def longitude(self, value):
|
|
"""
|
|
Set city longitude in degrees
|
|
:parameter value: float
|
|
"""
|
|
if value is not None:
|
|
self._longitude = float(value)
|
|
|
|
@property
|
|
def time_zone(self) -> Union[None, float]:
|
|
"""
|
|
Get city time_zone
|
|
:return: None or float
|
|
"""
|
|
return self._time_zone
|
|
|
|
@time_zone.setter
|
|
def time_zone(self, value):
|
|
"""
|
|
Set city time_zone
|
|
:parameter value: float
|
|
"""
|
|
if value is not None:
|
|
self._time_zone = float(value)
|
|
|
|
@property
|
|
def buildings_clusters(self) -> Union[List[BuildingsCluster], None]:
|
|
"""
|
|
Get buildings clusters belonging to the city
|
|
:return: None or [BuildingsCluster]
|
|
"""
|
|
return self._buildings_clusters
|
|
|
|
@property
|
|
def parts_consisting_buildings(self) -> Union[List[PartsConsistingBuilding], None]:
|
|
"""
|
|
Get parts consisting buildings belonging to the city
|
|
:return: None or [PartsConsistingBuilding]
|
|
"""
|
|
return self._parts_consisting_buildings
|
|
|
|
@property
|
|
def energy_systems(self) -> Union[List[EnergySystem], None]:
|
|
"""
|
|
Get energy systems belonging to the city
|
|
:return: None or [EnergySystem]
|
|
"""
|
|
return self._energy_systems
|
|
|
|
@property
|
|
def stations(self) -> [Station]:
|
|
"""
|
|
Get the sensors stations belonging to the city
|
|
:return: [Station]
|
|
"""
|
|
return self._stations
|
|
|
|
@property
|
|
def city_objects_clusters(self) -> Union[List[CityObjectsCluster], None]:
|
|
"""
|
|
Get city objects clusters belonging to the city
|
|
:return: None or [CityObjectsCluster]
|
|
"""
|
|
if self.buildings_clusters is None:
|
|
self._city_objects_clusters = []
|
|
else:
|
|
self._city_objects_clusters = self.buildings_clusters
|
|
if self.parts_consisting_buildings is not None:
|
|
self._city_objects_clusters.append(self.parts_consisting_buildings)
|
|
return self._city_objects_clusters
|
|
|
|
def add_city_objects_cluster(self, new_city_objects_cluster):
|
|
"""
|
|
Add a CityObject to the city
|
|
:param new_city_objects_cluster:CityObjectsCluster
|
|
:return: None or NotImplementedError
|
|
"""
|
|
if new_city_objects_cluster.type == 'buildings':
|
|
if self._buildings_clusters is None:
|
|
self._buildings_clusters = []
|
|
self._buildings_clusters.append(new_city_objects_cluster)
|
|
elif new_city_objects_cluster.type == 'building_parts':
|
|
if self._parts_consisting_buildings is None:
|
|
self._parts_consisting_buildings = []
|
|
self._parts_consisting_buildings.append(new_city_objects_cluster)
|
|
else:
|
|
raise NotImplementedError
|