def build_window_meshes(_window_surface, _grid_size, _mesh_params):
"""Create the Ladybug Mesh3D grided mesh for the window being analysed
Arguments:
_window_surface: (Brep) A single window Brep from the scene
_grid_size: (float)
_mesh_params: (Rhino.Geometry.MeshingParameters)
Returns: (tuple)
points: (list: Ladybug Point3D) All the analysis points on the window
normals: (list: Ladybug Normal) All the normals for the analysis points
window_mesh: (ladybug_geometry.geometry3d.Mesh3D) The window
window_back_mesh: (ladybug_geometry.geometry3d.Mesh3D) A copy of the window shifted 'back'
just a little bit (0.1 units). Used when solving the 'unshaded' situation.
"""
# create the gridded mesh for the window surface
#---------------------------------------------------------------------------
offset_dist = 0.001
window_mesh = to_joined_gridded_mesh3d([_window_surface], _grid_size,
offset_dist)
window_rh_mesh = from_mesh3d(window_mesh)
points = [from_point3d(pt) for pt in window_mesh.face_centroids]
# Create a 'back' for the window
#---------------------------------------------------------------------------
# Mostly this is done so it can be passed to the ladybug_rhino.intersect.intersect_mesh_rays()
# solver as a surfce which is certain to *not* shade the window at all
window_back_mesh = None
for sr in _window_surface.Surfaces:
window_normal = sr.NormalAt(0.5, 0.5)
window_normal.Unitize()
window_normal = window_normal * -1 * 0.1
window_back = _window_surface.Duplicate()
window_back.Translate(window_normal)
window_back_mesh = Rhino.Geometry.Mesh.CreateFromBrep(
window_back, _mesh_params)[0]
normals = [from_vector3d(vec) for vec in window_mesh.face_normals]
return points, normals, window_mesh, window_back_mesh, window_rh_mesh
'2': 'Spherical',
'3': 'Sky Exposure',
'4': 'Sky View'
}
if all_required_inputs(ghenv.Component) and _run:
# process the view_type_ and set the default values
vt_str = VIEW_TYPES[_view_type]
_resolution_ = _resolution_ if _resolution_ is not None else 1
_offset_dist_ = _offset_dist_ if _offset_dist_ is not None \
else 0.1 / conversion_to_meters()
if _geo_block_ is None:
_geo_block_ = True if vt_str in ('Sky Exposure', 'Sky View') else False
# create the gridded mesh from the geometry
study_mesh = to_joined_gridded_mesh3d(_geometry, _grid_size, _offset_dist_)
points = [from_point3d(pt) for pt in study_mesh.face_centroids]
hide_output(ghenv.Component, 1)
# get the view vectors based on the view type
patch_wghts = None
if vt_str == 'Horizontal Radial':
lb_vecs = view_sphere.horizontal_radial_vectors(30 * _resolution_)
elif vt_str == 'Horizontal 30-Degree Offset':
patch_mesh, lb_vecs = view_sphere.horizontal_radial_patches(
30, _resolution_)
patch_wghts = view_sphere.horizontal_radial_patch_weights(
30, _resolution_)
elif vt_str == 'Spherical':
patch_mesh, lb_vecs = view_sphere.sphere_patches(_resolution_)
patch_wghts = view_sphere.sphere_patch_weights(_resolution_)
from ladybug_rhino.text import text_objects
from ladybug_rhino.intersect import join_geometry_to_mesh, intersect_mesh_rays
from ladybug_rhino.grasshopper import all_required_inputs, hide_output, \
show_output, objectify_output, de_objectify_output, recommended_processor_count
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component) and _run:
# set the default offset distance and _cpu_count
_offset_dist_ = _offset_dist_ if _offset_dist_ is not None \
else 0.1 / conversion_to_meters()
workers = _cpu_count_ if _cpu_count_ is not None else recommended_processor_count(
)
# create the gridded mesh from the geometry
study_mesh = to_joined_gridded_mesh3d(_geometry, _grid_size)
points = [
from_point3d(pt.move(vec * _offset_dist_))
for pt, vec in zip(study_mesh.face_centroids, study_mesh.face_normals)
]
hide_output(ghenv.Component, 1)
# mesh the geometry and context
shade_mesh = join_geometry_to_mesh(_geometry + context_)
# deconstruct the matrix and get the sky dome vectors
mtx = de_objectify_output(_sky_mtx)
total_sky_rad = [
dir_rad + dif_rad for dir_rad, dif_rad in zip(mtx[1], mtx[2])
]
ground_rad = [(sum(total_sky_rad) / len(total_sky_rad)) * mtx[0][1]
neg_lb_vec = -lb_vec
vec = from_vector3d(lb_vec)
# convert all of the _source_geo and contex into a single Brep for ray tracing
rtrace_brep = join_geometry_to_brep(_source_geo + context_)
# autocompute the first and last bounce length if it's unspecified
if _first_length_ is None or _last_length_ is None:
max_pt, min_pt = (to_point3d(p)
for p in bounding_box_extents(rtrace_brep))
diag_dist = max_pt.distance_to_point(min_pt)
_first_length_ = diag_dist if _first_length_ is None else _first_length_
_last_length_ = diag_dist if _last_length_ is None else _last_length_
# create the gridded mesh from the _source_geo and set up the starting rays
study_mesh = to_joined_gridded_mesh3d(_source_geo, _grid_size)
move_vec = neg_lb_vec * _first_length_
source_points = [pt + move_vec for pt in study_mesh.face_centroids]
lb_rays = [Ray3D(pt, lb_vec) for pt in source_points]
start_rays = [from_ray3d(ray) for ray in lb_rays]
# trace each ray through the geometry
cutoff_ang = math.pi / 2
rtrace_geo = [rtrace_brep]
rays, int_pts = [], []
for ray, pt, norm in zip(start_rays, source_points,
study_mesh.face_normals):
if norm.angle(neg_lb_vec) < cutoff_ang:
pl_pts = trace_ray(ray, rtrace_geo, _bounce_count_ + 1)
# if the intersection was successful, create a polyline represeting the ray
if pl_pts:
# create lists to be filled with content
grid = []
points = []
mesh = []
for room in _rooms:
# get all of the floor faces of the room as Breps
floor_faces = [
from_face3d(face.geometry.flip()) for face in room.faces
if isinstance(face.type, Floor)
]
if len(floor_faces) != 0:
# create the gridded ladybug Mesh3D
lb_mesh = to_joined_gridded_mesh3d(floor_faces, _grid_size,
_dist_floor_)
# remove points outside of the room volume if requested
if remove_out_:
pattern = [
room.geometry.is_point_inside(pt)
for pt in lb_mesh.face_centroids
]
lb_mesh, vertex_pattern = lb_mesh.remove_faces(pattern)
# extract positions and directions from the mesh
base_points = [from_point3d(pt) for pt in lb_mesh.face_centroids]
base_poss = [(pt.x, pt.y, pt.z) for pt in lb_mesh.face_centroids]
base_dirs = [(vec.x, vec.y, vec.z) for vec in lb_mesh.face_normals]
# create the sensor grid