system_assignation/city_model_structure/city.py

"""
City module
SPDX - License - Identifier: LGPL - 3.0 - or -later
Copyright © 2020 Project Author Guille Gutierrez guillermo.gutierrezmorote@concordia.ca
"""
from __future__ import annotations
import sys
import pickle
import math
from typing import List, Union, TypeVar
import pyproj
from pyproj import Transformer


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 helpers.geometry_helper import GeometryHelper
from helpers.location import Location


Path = TypeVar('Path')


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._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

  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):
    """
    City country code
    :return: str
    """
    return self._get_location().country

  @property
  def name(self):
    """
    City name
    :return: str
    """
    return self._get_location().city

  @property
  def climate_reference_city(self):
    """
    Name of the city of reference for climatic information
    :return: str
    """
    return self._climate_reference_city

  @climate_reference_city.setter
  def climate_reference_city(self, value):
    """
    Name of the city of reference for climatic information
    :param value: str
    """
    self._climate_reference_city = value

  @property
  def climate_file(self) -> Path:
    """
    Full path of climate file
    :return: Path
    """
    return self._climate_file

  @climate_file.setter
  def climate_file(self, value):
    """
    Full path of climate file
    :param value: Path
    """
    self._climate_file = value

  @property
  def city_objects(self) -> Union[List[CityObject], None]:
    """
    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)
    return self._city_objects

  @property
  def buildings(self) -> Union[List[Building], None]:
    """
    Buildings belonging to the city
    :return: None or [Building]
    """
    return self._buildings

  @property
  def trees(self) -> NotImplementedError:
    """
    Trees belonging to the city
    :return: NotImplementedError
    """
    raise NotImplementedError

  @property
  def bixi_features(self) -> NotImplementedError:
    """
    Bixi features belonging to the city
    :return: NotImplementedError
    """
    raise NotImplementedError

  @property
  def composting_plants(self) -> NotImplementedError:
    """
    Composting plants belonging to the city
    :return: NotImplementedError
    """
    raise NotImplementedError

  @property
  def lower_corner(self):
    """
    City lower corner
    :return: [x,y,z]
    """
    return self._lower_corner

  @property
  def upper_corner(self):
    """
    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)
    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):
    """
    srs name
    :return: str
    """
    return self._srs_name

  @name.setter
  def name(self, value):
    """
    Set the city name
    :param value:str
    :return: None
    """
    self._name = 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:
    """
    with open(city_filename, 'wb') as file:
      pickle.dump(self, file)

  def region(self, center, radius) -> City:
    """
    Save a city into the given filename
    :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):
    """
    city latitude in degrees
    :return: float
    """
    return self._latitude

  @latitude.setter
  def latitude(self, value):
    """
    city latitude in degrees
    :parameter value: float
    """
    self._latitude = value

  @property
  def longitude(self):
    """
    city longitude in degrees
    :return: float
    """
    return self._longitude

  @longitude.setter
  def longitude(self, value):
    """
    city longitude in degrees
    :parameter value: float
    """
    self._longitude = value

  @property
  def time_zone(self):
    """
    city time_zone
    :return: float
    """
    return self._time_zone

  @time_zone.setter
  def time_zone(self, value):
    """
    city time_zone
    :parameter value: float
    """
    self._time_zone = value

  @property
  def buildings_clusters(self) -> Union[List[BuildingsCluster], None]:
    """
    buildings clusters belonging to the city
    :return: None or [BuildingsCluster]
    """
    return self._buildings_clusters

  @property
  def parts_consisting_buildings(self) -> Union[List[PartsConsistingBuilding], None]:
    """
    Parts consisting buildings belonging to the city
    :return: None or [PartsConsistingBuilding]
    """
    return self._parts_consisting_buildings

  @property
  def city_objects_clusters(self) -> Union[List[CityObjectsCluster], None]:
    """
    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