137 lines
4.8 KiB
Python
137 lines
4.8 KiB
Python
"""
|
|
Rhino module parses rhino files and import the geometry into the city model structure
|
|
SPDX - License - Identifier: LGPL - 3.0 - or -later
|
|
Copyright © 2022 Concordia CERC group
|
|
Project Coder Guille Gutierrez guillermo.gutierrezmorote@concordia.capip
|
|
"""
|
|
import numpy as np
|
|
from rhino3dm import *
|
|
from rhino3dm._rhino3dm import Extrusion
|
|
from rhino3dm._rhino3dm import MeshType
|
|
|
|
from city_model_structure.attributes.point import Point
|
|
from city_model_structure.attributes.polygon import Polygon
|
|
from city_model_structure.building import Building
|
|
from city_model_structure.building_demand.surface import Surface as HubSurface
|
|
from city_model_structure.city import City
|
|
from helpers.configuration_helper import ConfigurationHelper
|
|
from imports.geometry.helpers.geometry_helper import GeometryHelper
|
|
|
|
|
|
class Rhino:
|
|
def __init__(self, path):
|
|
self._model = File3dm.Read(str(path))
|
|
max_float = float(ConfigurationHelper().max_coordinate)
|
|
min_float = float(ConfigurationHelper().min_coordinate)
|
|
self._min_x = self._min_y = self._min_z = max_float
|
|
self._max_x = self._max_y = self._max_z = min_float
|
|
|
|
@staticmethod
|
|
def _in_perimeter(wall, corner):
|
|
res = wall.contains_point(Point(corner))
|
|
return res
|
|
|
|
@staticmethod
|
|
def _add_hole(solid_polygon, hole):
|
|
first = solid_polygon.points[0]
|
|
points = first + hole.points + solid_polygon.points
|
|
return Polygon(points)
|
|
|
|
@staticmethod
|
|
def _solid_points(coordinates) -> np.ndarray:
|
|
solid_points = np.fromstring(coordinates, dtype=float, sep=' ')
|
|
solid_points = GeometryHelper.to_points_matrix(solid_points)
|
|
|
|
result = []
|
|
found = False
|
|
for row in solid_points:
|
|
for row2 in result:
|
|
if row[0] == row2[0] and row[1] == row2[1] and row[2] == row2[2]:
|
|
found = True
|
|
if not found:
|
|
result.append(row)
|
|
return solid_points
|
|
|
|
def _corners(self, point):
|
|
if point.X < self._min_x:
|
|
self._min_x = point.X
|
|
if point.Y < self._min_y:
|
|
self._min_y = point.Y
|
|
if point.Z < self._min_z:
|
|
self._min_z = point.Z
|
|
if point.X > self._max_x:
|
|
self._max_x = point.X
|
|
if point.Y > self._max_y:
|
|
self._max_y = point.Y
|
|
if point.Z > self._max_z:
|
|
self._max_z = point.Z
|
|
|
|
def _add_face(self, face):
|
|
hub_surfaces = []
|
|
_mesh = face.GetMesh(MeshType.Default)
|
|
for i in range(0, len(_mesh.Faces)):
|
|
mesh_faces = _mesh.Faces[i]
|
|
_points = ''
|
|
faces = []
|
|
for index in mesh_faces:
|
|
if index in faces:
|
|
continue
|
|
faces.append(index)
|
|
self._corners(_mesh.Vertices[index])
|
|
_points = _points + f'{_mesh.Vertices[index].X} {_mesh.Vertices[index].Y} {_mesh.Vertices[index].Z} '
|
|
polygon_points = Rhino._solid_points(_points.strip())
|
|
hub_surfaces.append(HubSurface(Polygon(polygon_points), Polygon(polygon_points)))
|
|
return hub_surfaces
|
|
|
|
@property
|
|
def city(self) -> City:
|
|
buildings = []
|
|
city_objects = [] # building and "windows"
|
|
windows = []
|
|
_prev_name = ''
|
|
|
|
for obj in self._model.Objects:
|
|
name = obj.Attributes.Id
|
|
hub_surfaces = []
|
|
if isinstance(obj.Geometry, Extrusion):
|
|
surface = obj.Geometry
|
|
hub_surfaces = hub_surfaces + self._add_face(surface)
|
|
else:
|
|
for face in obj.Geometry.Faces:
|
|
if face is None:
|
|
break
|
|
hub_surfaces = hub_surfaces + self._add_face(face)
|
|
building = Building(name, 3, hub_surfaces, 'unknown', 'unknown', [])
|
|
city_objects.append(building)
|
|
lower_corner = (self._min_x, self._min_y, self._min_z)
|
|
upper_corner = (self._max_x, self._max_y, self._max_z)
|
|
city = City(lower_corner, upper_corner, 'EPSG:26918')
|
|
for building in city_objects:
|
|
if len(building.surfaces) <= 2:
|
|
# is not a building but a window!
|
|
for surface in building.surfaces:
|
|
# add to windows the "hole" with the normal inverted
|
|
windows.append(Polygon(surface.perimeter_polygon.inverse))
|
|
else:
|
|
buildings.append(building)
|
|
|
|
# todo: this method will be pretty inefficient
|
|
for hole in windows:
|
|
corner = hole.coordinates[0]
|
|
for building in buildings:
|
|
for surface in building.surfaces:
|
|
plane = surface.perimeter_polygon.plane
|
|
# todo: this is a hack for dompark project it should not be done this way windows should be correctly modeled
|
|
# if the distance between the wall plane and the window is less than 2m
|
|
# and the window Z coordinate it's between the wall Z, it's a window of that wall
|
|
if plane.distance(corner) <= 2:
|
|
# check if the window is in the right high.
|
|
if surface.upper_corner[2] >= corner[2] >= surface.lower_corner[2]:
|
|
if surface.holes_polygons is None:
|
|
surface.holes_polygons = []
|
|
surface.holes_polygons.append(hole)
|
|
|
|
for building in buildings:
|
|
city.add_city_object(building)
|
|
return city
|