Partial correction citygml read

imports/geometry/citygml.py

@@ -9,7 +9,6 @@ import xmltodict
 from city_model_structure.city import City
 from city_model_structure.building import Building
 from helpers.geometry_helper import GeometryHelper
-from city_model_structure.attributes.polygon import Polygon
 from imports.geometry.citygml_lod2 import CityGmlLod2
 from imports.geometry.citygml_lod1 import CityGmlLod1
 
@@ -66,7 +65,25 @@ class CityGml:
     """
     return self._gml
 
-  def _create_building(self):
+  def _create_building(self, city_object):
+    name = city_object['@id']
+    function = None
+    year_of_construction = None
+    if 'yearOfConstruction' in city_object:
+      year_of_construction = city_object['yearOfConstruction']
+    if 'function' in city_object:
+      function = city_object['function']
+    if any(key in city_object for key in self._lod1_tags):
+      lod = 1
+      surfaces = CityGmlLod1(city_object).surfaces
+    elif any(key in city_object for key in self._lod2_tags):
+      lod = 2
+      surfaces = CityGmlLod2(city_object).surfaces
+    else:
+      raise NotImplementedError("Not supported level of detail")
+    return Building(name, lod, surfaces, year_of_construction, function, self._lower_corner,[])
+
+  def _create_parts_consisting_building(self):
     raise NotImplementedError
 
   @property
@@ -75,139 +92,13 @@ class CityGml:
     City model structure enriched with the geometry information
     :return: City
     """
+
     if self._city is None:
       self._city = City(self._lower_corner, self._upper_corner, self._srs_name)
-
       for o in self._gml['CityModel']['cityObjectMember']:
-        lod = 0
+        city_object = o['Building']
-        surfaces = []
+        if 'consistsOfBuildingPart' in city_object:
-        if any(key in o['Building'] for key in self._lod1_tags):
-          lod = 1
-          surfaces = CityGmlLod1(o).surfaces
-        elif any(key in o['Building'] for key in self._lod2_tags):
-          lod = 2
-          surfaces = CityGmlLod2(o).surfaces
-        elif 'consistsOfBuildingPart' in o['Building']:
           raise NotImplementedError("Building cluster")
-        '''
-        if 'lod1Solid' in o['Building']:
-          lod += 1
-          surfaces = CityGmlLod1.lod1_solid(o)
-        elif 'lod1MultiSurface' in o['Building']:
-          lod += 1
-          surfaces = CityGmlLod1.lod1_multi_surface(o)
-        
-        elif 'lod2Solid' in o['Building'] :
-          lod += 1
-          surfaces = CityGmlLod2.lod2_solid(o)
-        elif 'lod2MultiSurface' in o['Building']:
-          # todo: check if this is a real case or a miss-formed citygml
-          lod = 2
-          surfaces = surfaces + CityGmlLod2.lod2_solid_multi_surface(o)
         else:
-          for bound in o['Building']['boundedBy']:
+          self._city.add_city_object(self._create_building(city_object))
-            surface_type = next(iter(bound))
-            if 'lod2MultiSurface' in bound[surface_type]:
-              lod = 2
-              surfaces = surfaces + CityGmlLod2.lod2(bound)
-            if 'lod3Solid' in o['Building']:
-              lod += 4
-            if 'lod4Solid' in o['Building']:
-              lod += 8
-        '''
-        lod_terrain_str = 'lod' + str(lod) + 'TerrainIntersection'
-        terrains = []
-        if lod_terrain_str in o['Building']:
-          terrains = self._terrains(o, lod_terrain_str)
-
-        function = None
-        year_of_construction = None
-        name = o['Building']['@id']
-        if 'yearOfConstruction' in o['Building']:
-          year_of_construction = o['Building']['yearOfConstruction']
-        if 'function' in o['Building']:
-          function = o['Building']['function']
-        self._city.add_city_object(Building(name, lod, surfaces, year_of_construction, function, self._lower_corner,
-                                            terrains))
-
     return self._city
-
-  def _terrains(self, city_object, lod_terrain_str):
-    try:
-      curves = [c['LineString']['posList']['#text']
-                for c in city_object['Building'][lod_terrain_str]['MultiCurve']['curveMember']]
-    except TypeError:
-      curves = [c['LineString']['posList']
-                for c in city_object['Building'][lod_terrain_str]['MultiCurve']['curveMember']]
-    terrains = []
-    for curve in curves:
-      curve_points = np.fromstring(curve, dtype=float, sep=' ')
-      curve_points = self._geometry.to_points_matrix(curve_points)
-      terrains.append(curve_points)
-    return terrains
-
-
-  @staticmethod
-  def _holes_points(holes_coordinates) -> [np.ndarray]:
-    """
-    Holes surfaces point matrices [[[x, y, z],[x, y, z],...]]
-    :parameter holes_coordinates: strings from file
-    :return: [np.ndarray]
-    """
-    holes_points = []
-    for hole_coordinates in holes_coordinates:
-      hole_points = np.fromstring(hole_coordinates, dtype=float, sep=' ')
-      hole_points = GeometryHelper.to_points_matrix(hole_points)
-      holes_points.append(hole_points)
-    return holes_points
-
-  @staticmethod
-  def _perimeter_points(coordinates, solid_points, holes_points) -> np.ndarray:
-    """
-    Matrix of points of the perimeter in the same order as in coordinates [[x, y, z],[x, y, z],...]
-    :parameter coordinates: string from file
-    :parameter solid_points: np.ndarray points that define the solid part of a surface
-    :parameter holes_points: [np.ndarray] points that define each the holes in a surface
-    :return: np.ndarray
-    """
-    if holes_points is None:
-      perimeter_points = solid_points
-    else:
-      _perimeter_coordinates = coordinates
-      for hole_points in holes_points:
-        _hole = np.append(hole_points, hole_points[0])
-        _closed_hole = ' '.join(str(e) for e in [*_hole[:]])
-        # add a mark 'M' to ensure that the recombination of points does not provoke errors in finding holes
-        _perimeter_coordinates = _perimeter_coordinates.replace(_closed_hole, 'M')
-      _perimeter_coordinates = _perimeter_coordinates.replace('M', '')
-      perimeter_points = np.fromstring(_perimeter_coordinates, dtype=float, sep=' ')
-      perimeter_points = GeometryHelper.to_points_matrix(perimeter_points)
-      # remove duplicated points
-      pv = np.array([perimeter_points[0]])
-      for point in perimeter_points:
-        duplicated_point = False
-        for p in pv:
-          if GeometryHelper().almost_equal(0.0, p, point):
-            duplicated_point = True
-        if not duplicated_point:
-          pv = np.append(pv, [point], axis=0)
-      perimeter_points = pv
-    return perimeter_points
-
-  @staticmethod
-  def _holes_polygons(holes_points) -> [Polygon]:
-    """
-    hole surfaces, a list of hole polygons found in a surface
-    :parameter holes_points: [np.ndarray] that define each of the holes
-    :return: None, [] or [Polygon]
-      None -> not known whether holes exist in reality or not due to low level of detail of input data
-      [] -> no holes in the surface
-      [Polygon] -> one or more holes in the surface
-    """
-    if holes_points is None:
-      holes_polygons = None
-    else:
-      holes_polygons = []
-      for hole_points in holes_points:
-        holes_polygons.append(Polygon(hole_points))
-    return holes_polygons

imports/geometry/citygml_base.py

@@ -39,7 +39,3 @@ class CityGmlBase(ABC):
   @classmethod
   def _multi_curve(cls, o):
     raise NotImplementedError
-
-  @classmethod
-  def _building_parts(cls, o):
-    raise NotImplementedError

imports/geometry/citygml_lod2.py

@@ -1,11 +1,10 @@
-
 from imports.geometry.citygml_base import CityGmlBase
 from city_model_structure.attributes.surface import Surface
 from city_model_structure.attributes.polygon import Polygon
 from imports.geometry.helpers.geometry_helper import GeometryHelper
 
-class CityGmlLod2(CityGmlBase):
 
+class CityGmlLod2(CityGmlBase):
 
   def __init__(self, o):
     super().__init__()
@@ -14,38 +13,32 @@ class CityGmlLod2(CityGmlBase):
 
   @classmethod
   def _identify(cls, o):
-    if 'lod2Solid' in o['Building']:
+    if 'lod2Solid' in o:
       return cls._solid(o)
-    elif 'lod2MultiSurface' in o['Building']:
+    elif 'lod2MultiSurface' in o:
-      print('multi_surface')
       return cls._multi_surface(o)
-    elif 'lod2MultiCurve' in o['Building']:
+    elif 'lod2MultiCurve' in o:
-      print('multi_curve')
       return cls._multi_curve(o)
-    elif 'consistsOfBuildingPart' in o['Building']:
-      raise NotImplementedError
-
 
   @staticmethod
   def _surface_encoding(surfaces):
     if 'lod2MultiSurface' in surfaces:
       return 'lod2MultiSurface', 'MultiSurface'
-    return 'unknown'
+    raise NotImplementedError('unknown surface type')
 
   @classmethod
   def _solid(cls, o):
     surfaces = []
-    for b in o["Building"]["boundedBy"]:
+    for b in o["boundedBy"]:
       surface_type = next(iter(b))
       surface_encoding, surface_subtype = cls._surface_encoding(b[surface_type])
       for member in b[surface_type][surface_encoding][surface_subtype]['surfaceMember']:
         sp = cls._solid_points(cls._remove_last_point(member['Polygon']['exterior']['LinearRing']['posList']))
         p = Polygon(sp)
-        surface = Surface(p,p, surface_type=GeometryHelper.gml_surface_to_libs(surface_type))
+        surface = Surface(p, p, surface_type=GeometryHelper.gml_surface_to_libs(surface_type))
         surfaces.append(surface)
     return surfaces
 
-
   @classmethod
   def _multi_curve(cls, o):
     raise NotImplementedError
@@ -53,67 +46,3 @@ class CityGmlLod2(CityGmlBase):
   @classmethod
   def _multi_surface(cls, o):
     raise NotImplementedError
-
-
-  @classmethod
-  def _lod2(cls, bound):
-    surfaces = []
-    for surface_type in iter(bound):
-      for s in bound[surface_type]['lod2MultiSurface']['MultiSurface']['surfaceMember']:
-        if 'CompositeSurface' in s:
-          surfaces = surfaces + cls._lod2_composite_surface(s)
-        else:
-          surfaces = surfaces + cls._lod2_multi_surface(s, surface_type)
-    return surfaces
-
-  @classmethod
-  def _lod2_solid_multi_surface(cls, o):
-    polygons = None
-    if 'boundedBy' in o['Building']['consistsOfBuildingPart']['BuildingPart']:
-      if 'RoofSurface' in o['Building']['consistsOfBuildingPart']['BuildingPart']['boundedBy']:
-        if o['Building']['consistsOfBuildingPart']['BuildingPart']['boundedBy']['RoofSurface']['lod2MultiSurface'] != 'None':
-          polygons = [Polygon(cls._remove_last_point(s['Polygon']['exterior']['LinearRing']['posList']))
-                    for s in o['Building']['consistsOfBuildingPart']['BuildingPart']['boundedBy']['RoofSurface']
-                      ['lod2MultiSurface']['MultiSurface']['surfaceMember']]
-
-      elif 'WallSurface' in o['Building']['consistsOfBuildingPart']['BuildingPart']['boundedBy']:
-        if o['Building']['consistsOfBuildingPart']['BuildingPart']['boundedBy']['WallSurface']['lod2MultiSurface'] != 'None':
-          polygons = [Polygon(cls._remove_last_point(s['Polygon']['exterior']['LinearRing']['posList']))
-                    for s in o['Building']['consistsOfBuildingPart']['BuildingPart']['boundedBy']['WallSurface']['lod2MultiSurface']['MultiSurface']['surfaceMember']]
-    else:
-      polygons = [Polygon(cls._remove_last_point(s['Polygon']['exterior']['LinearRing']['posList']))
-                  for s in o['Building']['lod2MultiSurface']['MultiSurface']['surfaceMember']]
-    return [Surface(p,p) for p in polygons]
-
-
-  @classmethod
-  def _lod2_solid(cls, o):
-    for walls in o['Building']['boundedBy']['wallSurface']:
-      print(f'solid')
-
-  @classmethod
-  def _lod2_solid_composite_surface(cls, o):
-    try:
-      solid_points = [cls._solid_points(cls._remove_last_point(s['Polygon']['exterior']['LinearRing']['posList']['#text']))
-                  for s in o['Building']['lod2Solid']['Solid']['exterior']['CompositeSurface']['surfaceMember']]
-    except TypeError:
-      solid_points = [cls._solid_points(cls._remove_last_point(s['Polygon']['exterior']['LinearRing']['posList']))
-                  for s in o['Building']['lod2Solid']['Solid']['exterior']['CompositeSurface']['surfaceMember']]
-    return [Surface(Polygon(sp),Polygon(sp)) for sp in solid_points]
-
-  @classmethod
-  def _lod2_composite_surface(cls, s):
-    solid_points = [
-      cls._solid_points((cls._remove_last_point(sm['Polygon']['exterior']['LinearRing']['posList'])))
-      for sm in s['CompositeSurface']['surfaceMember']]
-    return [Surface(Polygon(sp), Polygon(sp)) for sp in solid_points]
-
-  @classmethod
-  def _lod2_multi_surface(cls, s, surface_type):
-    # todo: this need to be changed into surface bounded?
-    try:
-      solid_points = [cls._solid_points(cls._remove_last_point(
-        s['Polygon']['exterior']['LinearRing']['posList']['#text']))]
-    except TypeError:
-      solid_points = [cls._solid_points(cls._remove_last_point(s['Polygon']['exterior']['LinearRing']['posList']))]
-    return [Surface(Polygon(sp), Polygon(sp), surface_type=surface_type) for sp in solid_points]