OpenSimula 0.5.1__py3-none-any.whl

opensimula/visual_3D/Polygon_3D.py

@@ -0,0 +1,262 @@
+import math
+import numpy as np
+from shapely.geometry import Polygon
+import vedo
+from triangle import triangulate
+
+class Polygon_3D():
+    def __init__(self, name, origin, azimuth, altitude, polygon2D, holes2D=[], color="white", opacity=1.0, visible=True,shading=True,calculate_shadows=True):
+        self.name = name
+        self.origin = np.array(origin)
+        self.azimuth = azimuth
+        self.altitude = altitude
+        self.polygon2D = polygon2D
+        self.azimuth_rad = math.radians(self.azimuth)
+        self.altitude_rad = math.radians(self.altitude)
+        self.normal_vector = np.array((math.cos(self.altitude_rad)*math.sin(self.azimuth_rad),
+                                       -math.cos(self.altitude_rad) *
+                                       math.cos(self.azimuth_rad),
+                                       math.sin(self.altitude_rad)))
+        self.x_axis = np.array((math.cos(self.azimuth_rad),
+                                math.sin(self.azimuth_rad),
+                                0))
+        self.y_axis = np.cross(self.normal_vector, self.x_axis)
+        self.polygon3D = self._convert_2D_to_3D_(self.polygon2D)
+        self.holes2D = holes2D
+        self.holes3D = []
+        for hole in self.holes2D:
+            self.holes3D.append(self._convert_2D_to_3D_(hole))
+        self.shapely_polygon = Polygon(self.polygon2D, self.holes2D)
+        self.area = self.shapely_polygon.area
+        # self.centroid2D = self.shapely_polygon.centroid.coords[0]
+        # self.centroid3D = self._convert_2D_to_3D_([self.centroid2D])[0]
+        self.equation_d = np.sum(self.normal_vector*self.origin)
+        self.color = color
+        self.opacity = opacity
+        self.visible = visible
+        self.shading = shading
+        self.calculate_shadows = calculate_shadows
+
+    def has_holes(self):
+        if (len(self.holes2D) > 0):
+            return True
+        else:
+            return False
+
+    def are_coplanar(self, polygon_3D):
+        if np.allclose(self.normal_vector, polygon_3D.normal_vector):  # same normal verctor
+            if np.isclose(np.sum(self.normal_vector*polygon_3D.origin), self.equation_d):  # in the plane
+                return True
+            else:
+                return False
+        else:
+            return False
+    
+    def _convert_2D_to_3D_(self, pol_2D):
+        pol_3D = []
+        for vertex in pol_2D:
+            v_loc = np.array([self.origin[0] + vertex[0] * math.cos(self.azimuth_rad)
+                     - vertex[1] * math.sin(self.altitude_rad) *
+                     math.sin(self.azimuth_rad),
+                     self.origin[1] + vertex[0] * math.sin(self.azimuth_rad)
+                     + vertex[1] * math.sin(self.altitude_rad) *
+                     math.cos(self.azimuth_rad),
+                     self.origin[2] + vertex[1] * math.cos(self.altitude_rad)])
+            pol_3D.append(v_loc)
+        return pol_3D
+        
+
+    # Functions for vedo
+    def get_vedo_mesh(self):
+        (points, faces) = self._triangulate_()
+        mesh = vedo.Mesh([points, faces])
+        mesh.c(self.color).alpha(self.opacity)
+        return mesh
+
+    def _triangulate_(self):
+        def edge_idxs(nv):
+            i = np.append(np.arange(nv), 0)
+            return np.stack([i[:-1], i[1:]], axis=1)
+
+        nv = 0
+        verts, edges = [], []
+        for loop in (self.polygon2D, *self.holes2D):
+            verts.append(loop)
+            edges.append(nv + edge_idxs(len(loop)))
+            nv += len(loop)
+
+        verts, edges = np.concatenate(verts), np.concatenate(edges)
+        # Triangulate needs to know a single interior point for each hole
+        holes = np.array([np.mean(h, axis=0) for h in self.holes2D])
+        # Because triangulate is a wrapper around a C library the syntax is a little weird, 'p' here means planar straight line graph
+        if self.has_holes():
+            d = triangulate(dict(vertices=verts, segments=edges, holes=holes), opts='p')
+        else:
+            d = triangulate(dict(vertices=verts, segments=edges), opts='p')
+        # Convert back 
+        v, f = d['vertices'], d['triangles']
+        nv, nf = len(v), len(f)
+        points = np.concatenate([v, np.zeros((nv, 1))], axis=1)
+        # Creo que lo tengo que hacer en 2D y luego pasarlo a 3D
+        #faces = np.concatenate([np.full((nf, 1), 3), f], axis=1).reshape(-1)
+        return (self._convert_2D_to_3D_(points), f)
+
+    def _are_vertices_counterclockwise_(self,puntos):
+        # Se suma el primer punto al final para cerrar el polígono.
+        if puntos[-1][0] != puntos[0][0] or puntos[-1][1] != puntos[0][1]:
+            puntos_cerrados = np.vstack([puntos, puntos[0]])
+        else:
+            puntos_cerrados = puntos
+        x = puntos_cerrados[:, 0]
+        y = puntos_cerrados[:, 1]
+        # La suma de los productos cruzados
+        suma_productos_cruzados = np.sum(x[:-1] * y[1:] - x[1:] * y[:-1])
+        return suma_productos_cruzados > 0
+
+    # Shadow calculations
+    def is_facing_sun(self, sun_position):
+        escalar_p = np.sum(self.normal_vector*sun_position)
+        if escalar_p >= 1e-10:
+            return True
+        else:
+            return False
+
+    def _get_sunny_shadow_shapely_polygon_(self, environment_3D, sun_position):
+        if not self.is_facing_sun(sun_position):
+            sunny_polygon = None
+            shadow_polygon = self.shapely_polygon
+        else:
+            # Calculate projected shadows
+            shadows_2D = []
+            for shadow_polygon in environment_3D.pol_3D:
+                if shadow_polygon != self and shadow_polygon.shading == True:
+                    if shadow_polygon.is_facing_sun(sun_position):
+                        if not self.are_coplanar(shadow_polygon):
+                            shadows_2D.append(self._calculate_shapely_projected_polygon_(shadow_polygon, sun_position))
+
+            # Calculate sunny polygon
+            sunny_polygon = self.shapely_polygon
+            for shadow_polygon in shadows_2D:
+                if shadow_polygon is not None:
+                    sunny_polygon = sunny_polygon.difference(shadow_polygon)
+            if sunny_polygon.is_empty:
+                sunny_polygon = None
+                shadow_polygon = self.shapely_polygon
+            else:
+                shadow_polygon = self.shapely_polygon.difference(sunny_polygon)
+                if shadow_polygon.is_empty:
+                    shadow_polygon = None
+        return sunny_polygon, shadow_polygon
+    
+    def _calculate_shapely_projected_polygon_(self, polygon_to_project, sun_position):
+        exterior_points = self._get_projected_points_(polygon_to_project, sun_position)
+        if exterior_points is not None:
+            if polygon_to_project.has_holes():
+                holes = []
+                for hole in polygon_to_project.holes2D:
+                    hole_points = self._get_projected_points_(
+                        Polygon_3D("holes", polygon_to_project.origin, polygon_to_project.azimuth, polygon_to_project.altitude, hole), sun_position)
+                    if hole_points is not None:
+                        holes.append(hole_points)
+                return Polygon(exterior_points, holes)
+            else:
+                return Polygon(exterior_points)
+        else:
+            return None
+
+    def _get_projected_points_(self,polygon_to_project, sun_position):
+        projected_points = []
+        point_0 = polygon_to_project.polygon3D[-1]
+        projected_point_0 = self._get_projected_point_(point_0, sun_position)
+        for point_1 in polygon_to_project.polygon3D:
+            projected_point_1 = self._get_projected_point_(point_1, sun_position)
+            if len(projected_point_1) > 0 and len(projected_point_0) > 0:
+                projected_points.append(projected_point_1)
+            elif len(projected_point_1) > 0 and len(projected_point_0)==0:
+                intersection_point = self._get_intersection_with_plane_(point_0, point_1)
+                if len(intersection_point) > 0:
+                    projected_intersection_point = self._get_projected_point_(intersection_point, sun_position)
+                    projected_points.append(projected_intersection_point)
+                projected_points.append(projected_point_1)
+            elif len(projected_point_1) == 0 and len(projected_point_0) > 0:
+                intersection_point = self._get_intersection_with_plane_(point_0, point_1)
+                if len(intersection_point) > 0:
+                    projected_intersection_point = self._get_projected_point_(intersection_point, sun_position)
+                    projected_points.append(projected_intersection_point)    
+            point_0 = np.array(point_1)
+            if len(projected_point_1) > 0:
+                projected_point_0 = np.array(projected_point_1)
+            else:
+                projected_point_0 = np.array([])
+        if len(projected_points) < 3:
+            return None
+        else:
+            return projected_points
+    
+    def _get_projected_point_(self, point, sun_position):
+        d = np.sum(self.normal_vector*point)-self.equation_d
+        k = d/np.sum(self.normal_vector*sun_position)
+        if (k > -1e-6):  # Por delante
+            projected_point_3D = point - k*sun_position
+            vector = projected_point_3D - self.origin
+            projected_point_2D = np.array([np.sum(self.x_axis*vector), np.sum(self.y_axis*vector)])
+            return projected_point_2D
+        else:
+            return np.array([])
+        
+    def _get_intersection_with_plane_(self, point_0,point_1):
+        d0 = np.sum(self.normal_vector*point_0)-self.equation_d
+        d1 = np.sum(self.normal_vector*point_1)-self.equation_d
+        if (d0*d1 < -1e-10):  # Si están en lados opuestos
+            t = d0/(d0-d1)
+            intersection_point = point_0 + t*(point_1-point_0)
+            return intersection_point
+        else:
+            return np.array([])
+
+    def get_sunny_shadow_polygon3D(self, environment_3D, sun_position):
+        sunny_polygons, shadow_polygons = self._get_sunny_shadow_shapely_polygon_(environment_3D, sun_position)
+        sunny_polygons_3D = self._shapely_multipolygon_to_polygons_3D_(sunny_polygons,"sunny")
+        shadow_polygons_3D = self._shapely_multipolygon_to_polygons_3D_(shadow_polygons,"shadow")
+        return sunny_polygons_3D, shadow_polygons_3D
+    
+    # Para dibujarlos en 3D
+    def _shapely_multipolygon_to_polygons_3D_(self, shapely_polygon, type="sunny"):
+        polygon_list = []
+        if shapely_polygon is not None:
+            if shapely_polygon.geom_type == 'MultiPolygon':
+                polygons = list(shapely_polygon.geoms)
+                for pol in polygons:
+                    polygon_list.append(self._shapely_to_polygon_3D_(pol,type))
+            elif shapely_polygon.geom_type == 'Polygon':
+                polygon_list.append(
+                    self._shapely_to_polygon_3D_(shapely_polygon,type))
+        return polygon_list
+
+    def _shapely_to_polygon_3D_(self, shapely_pol, type="sunny"):
+        exterior_pol = np.asarray(shapely_pol.exterior.coords)
+        if not self._are_vertices_counterclockwise_(exterior_pol):
+            exterior_pol = exterior_pol[::-1]
+        if exterior_pol[-1][0] == exterior_pol[0][0] and exterior_pol[-1][1] == exterior_pol[0][1]:
+            exterior_pol = exterior_pol[:-1]
+        holes = []
+        for interior in shapely_pol.interiors:
+            interior_pol = np.asarray(interior.coords)
+            if not self._are_vertices_counterclockwise_(interior_pol):
+                interior_pol = interior_pol[::-1]
+            if interior_pol[-1][0] == interior_pol[0][0] and interior_pol[-1][1] == interior_pol[0][1]:
+                interior_pol = interior_pol[:-1]
+            holes.append(interior_pol)
+        if type=="sunny":
+            pol_3D = Polygon_3D(self.name+"_sunny",self.origin, self.azimuth, self.altitude, exterior_pol, holes,color=self.color,opacity=self.opacity)
+        else:
+            pol_3D = Polygon_3D(self.name+"_shadow",self.origin, self.azimuth, self.altitude, exterior_pol, holes, color="gray3")
+        return pol_3D
+    
+    def get_angle_with_normal(self, sol_azimuth, sol_altitude):
+        azi_r = math.radians(sol_azimuth)
+        alt_r = math.radians(sol_altitude)
+        sol_vector = np.array([math.cos(alt_r)*math.cos(azi_r-math.pi/2),
+                              math.cos(alt_r)*math.sin(azi_r-math.pi/2), math.sin(alt_r)])
+        return np.arccos(np.clip(np.dot(self.normal_vector, sol_vector), -1.0, 1.0))
+

opensimula-0.5.1.dist-info/METADATA

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: opensimula
+Version: 0.5.1
+Summary: Component-based time simulation environment in Python
+Author-email: "Juan F. Coronel" <jfc@us.es>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: dash>=3.2.0
+Requires-Dist: dash-ag-grid>=32.3.2
+Requires-Dist: dash-bootstrap-components>=2.0.4
+Requires-Dist: nbformat>=5.10.4
+Requires-Dist: numpy>=2.3.3
+Requires-Dist: openpyxl>=3.1.5
+Requires-Dist: pandas>=2.3.2
+Requires-Dist: plotly>=6.3.0
+Requires-Dist: psychrolib>=2.5.0
+Requires-Dist: scipy>=1.16.2
+Requires-Dist: shapely>=2.1.1
+Requires-Dist: tqdm>=4.67.1
+Requires-Dist: triangle>=20250106
+Requires-Dist: vedo>=2025.5.4
+Dynamic: license-file
+
+![Logo](https://jfcoronel.github.io/opensimula/img/logo_opensimula.png)
+Component-based time simulation environment in Python
+
+[Documentation page](https://jfcoronel.github.io/opensimula/)
+
+## Main Developers
+
+* [Juan F. Coronel](http://jfc.us.es), Universidad de Sevilla
+
+## Package dependencies
+- numpy
+- pandas
+- scipy
+- shapely
+- psychrolib
+- plotly
+- dash
+- dash_bootstrap_components
+- dash_ag_grid
+- pyvista
+- trame
+- trame-vtk
+- trame-vuetify
+- ipywidgets
+

opensimula-0.5.1.dist-info/RECORD

@@ -0,0 +1,44 @@
+opensimula/Child.py,sha256=DEA6r-iIuH-cgV8mitnG3NyjSiIngOMmzf_JxwGRmGY,362
+opensimula/Component.py,sha256=9IVfGsuO1eqTY1pAyvjr-GtPhvMmIxrqC1P7BTv6YHA,9299
+opensimula/Iterative_process.py,sha256=nla1qrhi8zspGtXn-0181iAg4ksdzbrzsgpVnJfvzLk,1632
+opensimula/Message.py,sha256=eUEK0ZGRaa64Eej7Khmm3bgQG9onXr-VV70Ql0y5cw4,439
+opensimula/Parameter_container.py,sha256=G5lpMmbEo_LP7E3kfMyK14AnqAN_SzD5SarN3yxhV0s,2331
+opensimula/Parameters.py,sha256=LwPAwDHszer5VNeY4rl7ur3yZaDpakvT4SqtPQN53dY,22793
+opensimula/Project.py,sha256=OQFAEV_AD-cNmi-Icz6fxWOBQFH3eDCdw5gcPbwGLMc,25857
+opensimula/Simulation.py,sha256=8abWXnPA95Ig0NnzQdInke0esdiXog6vNE7J2RyqfzQ,7849
+opensimula/Variable.py,sha256=7r4XzxhJSsYSbpNFj_orX1a0d_LwJiagk5yQYE6RlWk,785
+opensimula/__init__.py,sha256=NucwfvbCx6BbJJf2zRQYp8xZn98RJyn-aZvXKrKOBIQ,210
+opensimula/components/Building.py,sha256=GsHCh31Uqt9g4C5NUFAfaztzf8zGu1tODuH6rxGVPSE,24507
+opensimula/components/Building_surface.py,sha256=nlNNETh43ZuF8HzriLvRPM1Pes51w-Y0-15ZMxrw3V8,15701
+opensimula/components/Calculator.py,sha256=BqSWDxsEk5AxfvKG9vEPcmyMLVzLsnoHsc2w8YHfOYk,2488
+opensimula/components/Construction.py,sha256=k1lmMtyML5H5O4NBRcu1_Tgvd5P0ebg59gtvZ3nHLuI,10674
+opensimula/components/Day_schedule.py,sha256=0YTmt4O6nKfHG_q_8Q2R_8xsTi0jYQHaycecpZEgIBM,2495
+opensimula/components/File_data.py,sha256=7L1Kxc_z7Ywlcz2H5M_f94IqKKdoLJbrN3G0TIEbBdM,4798
+opensimula/components/File_met.py,sha256=r3FySxCbPQOFKX410m7s8BOjMEn54xd7q8wrkkYWowM,52420
+opensimula/components/Frame.py,sha256=Ju2_OBn5o97viZ-rCrZpZZClpwsdCZb4w58ym9fCIqY,1488
+opensimula/components/Glazing.py,sha256=syaOCTuA-Qte1NAmNmcF9DI0Le-rHWA5-o2tbMHAdAE,5905
+opensimula/components/HVAC_DX_equipment.py,sha256=74wysP0a39WrwNDo7x41BD5UmQXgiYVRib7KOAhy1OE,11272
+opensimula/components/HVAC_DX_system.py,sha256=s9khWJG-O0tm5WBXLEAHxorMd_dSgfhXC53vFIWaBLM,13654
+opensimula/components/HVAC_MZW_system.py,sha256=aUONkbR_UXHM7NAWYP2YBiIKp5BcBe_RmHfUdaZX0G0,25986
+opensimula/components/HVAC_SZW_system.py,sha256=q99d1R5DpF4XOGYQVfYAVEbC4ENEUWRUALcvQ0tPIwc,19297
+opensimula/components/HVAC_coil_equipment.py,sha256=eCxWWbEOaSh7IiuLkLbBdDmk47F8gY8JYbnzdN5qFWA,11561
+opensimula/components/HVAC_fan_equipment.py,sha256=BRCwbx8VVAkZmXWa84iLZv3tNEzNSNOAI0RvuNDIqz8,1715
+opensimula/components/HVAC_perfect_system.py,sha256=fNaeaSKmBeW2iQ_-FwHTkyUcicHe3q8o8TH8pXW9WWw,7431
+opensimula/components/Material.py,sha256=SVDdHqPIGUYI3F5izSnLAw5pxxvBjt0uSG_Pp_iu1WY,768
+opensimula/components/Opening.py,sha256=oUVXYXF54JND9hKmMI9xr88uBYFgSKBM0QbPMqnhtPQ,17256
+opensimula/components/Opening_type.py,sha256=r_N0WyHX3HJx7K35H3V4YTgKM8b9RBSm1dOF1RrmIu0,3859
+opensimula/components/Solar_surface.py,sha256=-sRPuTPch1GMwcVSmdZEK1eQ4xPDmrceYPYwRKdIJcc,5259
+opensimula/components/Space.py,sha256=kNi9e-8LENGLG10aOih2-oDBf12OHeI74wdF7fMLFxM,18967
+opensimula/components/Space_type.py,sha256=pMTmuCDFUZaW7ubpDEW37grMGdJL8MhKKQCFeFB9j_w,4216
+opensimula/components/Surface.py,sha256=BOceDuL3BJiv6vK8RTa7fpJaORl_DuUQNQDgWSQKVpY,5611
+opensimula/components/Test_component.py,sha256=j9REKz-0nKgIpfjfi9re57tYruCmPoN9VWWyLh72Kl0,3018
+opensimula/components/Week_schedule.py,sha256=wBMt57u0BmpdxOZ2PCxMIoFNjjKbBCDFlgtfLOszrFA,1257
+opensimula/components/Year_schedule.py,sha256=YZgXYL97IbHxI7GH2yZ2qZK97b2wXBwpTNQEejtNzhQ,2793
+opensimula/components/__init__.py,sha256=_w0jRUsOWL2XGh8FJo1NLTHgAxm-3Ihi_g51UW6d0nw,1942
+opensimula/visual_3D/Environment_3D.py,sha256=7XUGUnRm3hwnjy1FTyGOny3eL_jmCPAPlkpuQVONrGY,10303
+opensimula/visual_3D/Polygon_3D.py,sha256=sZm5GERoZbq8e-1WMx-W4zs3lG_uQlNUYNk1UOZSFiE,12526
+opensimula-0.5.1.dist-info/licenses/LICENSE,sha256=FXVlDFAOal91ai0_JYik1x4GGMFQEaIg00xBG42hqdM,1072
+opensimula-0.5.1.dist-info/METADATA,sha256=G6_dg_gT5I7e3MuyOk5AKrZxpDVeTE_oRUpI392IbPo,1178
+opensimula-0.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+opensimula-0.5.1.dist-info/top_level.txt,sha256=r48_O7VMDoHQWGuns6DMssWqOuyDdMQFBMbrX05g2Os,11
+opensimula-0.5.1.dist-info/RECORD,,

opensimula-0.5.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

opensimula-0.5.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Juan F. Coronel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

opensimula-0.5.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+opensimula