def add_door(door, points, vectors): """Add Door normals.""" points.append(from_point3d(door.center)) vectors.append(from_vector3d(door.normal)) for shd in door.shades: points.append(from_point3d(shd.center)) vectors.append(from_vector3d(shd.normal))
def add_aperture(aperture, points, vectors): """Add Aperture normals.""" points.append(from_point3d(aperture.center)) vectors.append(from_vector3d(aperture.normal)) for shd in aperture.shades: points.append(from_point3d(shd.center)) vectors.append(from_vector3d(shd.normal))
def add_face(face, points, vectors): """Add Face normals.""" points.append(from_point3d(face.center)) vectors.append(from_vector3d(face.normal)) for ap in face.apertures: add_aperture(ap, points, vectors) for dr in face.doors: add_door(ap, points, vectors) for shd in face.shades: points.append(from_point3d(shd.center)) vectors.append(from_vector3d(shd.normal))
def add_room(room, points, vectors): """Add Room normals.""" for face in room.faces: add_face(face, points, vectors) for shd in room.shades: points.append(from_point3d(shd.center)) vectors.append(from_vector3d(shd.normal))
def add_model(model, points, vectors): """Add Model normals.""" for room in model.rooms: add_room(room, points, vectors) for face in model.orphaned_faces: add_face(face, points, vectors) for ap in model.orphaned_apertures: add_aperture(ap, points, vectors) for dr in model.orphaned_doors: add_door(door, points, vectors) for shd in model.orphaned_shades: points.append(from_point3d(shd.center)) vectors.append(from_vector3d(shd.normal))
def draw_sun_positions(suns, radius, center_pt3d): """Draw Rhino points from a list of sun objects. Args: suns: A list of suns to be output as points radius: Number for the radius of the sun path. center_pt3d: Point3D for the center of the sun path. Returns: A list of Rhino points for sun positions """ # get points for sun positions if projection_ is None: return [from_point3d(sun.position_3d(center_pt3d, radius)) for sun in suns] else: return [from_point2d(sun.position_2d(projection_, center_pt3d, radius), z) for sun in suns]
def human_height_points(position, height, pt_count): """Get a list of points and a line representing the human geometry. Args: position: Rhino point for the position of the human. height: Number for the height of the human. pt_count: Integer for the number of points representing the human. Returns: A tuple with human points as first element and human line as second. Both geomtries are Rhino geometries. """ lb_feet_pt = to_point3d(position).move(Vector3D(0, 0, height / 100)) lb_hum_line = LineSegment3D(lb_feet_pt, Vector3D(0, 0, height)) lb_pts = [lb_hum_line.midpoint] if pt_count == 1 else \ lb_hum_line.subdivide_evenly(pt_count - 1) if len(lb_pts) == pt_count - 1: # sometimes tolerance kills the last point lb_pts.append(lb_feet_pt.move(Vector3D(0, 0, height))) h_points = [from_point3d(pt) for pt in lb_pts] return h_points, from_linesegment3d(lb_hum_line)
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
ghenv.Component.NickName = 'ASE' ghenv.Component.Message = 'VER 0.0.06\nJUL_07_2020' ghenv.Component.Category = "HoneybeePlus" ghenv.Component.SubCategory = '04 :: Daylight :: Daylight' ghenv.Component.AdditionalHelpFromDocStrings = "3" try: from ladybug_rhino.fromgeometry import from_point3d import ladybug.legend as lp import ladybug.color as color except ImportError as e: raise ImportError('\nFailed to import ladybug:\n\t{}'.format(e)) col = color.Colorset.original() legend_par = lp.LegendParameters(0, 250, colors=col) if _analysis_grid: states = _analysis_grid.parse_blind_states(blind_states_) success, ASE, per_area, prblm_pts, prblm_hrs = \ _analysis_grid.annual_sunlight_exposure( _threshold_, states, _occ_schedule_, _target_hrs_, _target_area_ ) prblm_pts = (from_point3d(s.location) for s in prblm_pts) # convert list of lists to data tree try: prblm_hrs = output.list_to_tree(prblm_hrs, ghenv.Component.RunCount - 1) except NameError: # dynamo pass
except ImportError as e: raise ImportError('\nFailed to import ladybug:\n\t{}'.format(e)) try: from ladybug_rhino.config import conversion_to_meters from ladybug_rhino.togeometry import to_joined_gridded_mesh3d, to_face3d, \ to_vector3d from ladybug_rhino.fromgeometry import from_mesh3d, from_point3d from ladybug_rhino.grasshopper import all_required_inputs, hide_output 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 _height_limit_ = _height_limit_ if _height_limit_ is not None \ else 100 / conversion_to_meters() # convert geometry, objstacles, and vectors to ladybug_geomtery study_mesh = to_joined_gridded_mesh3d(_geometry, _grid_size) obstacle_faces = [g for geo in _obstacles for g in to_face3d(geo)] sun_vectors = [to_vector3d(vec) for vec in _vectors] # compute the solar envelope solar_obj = SolarEnvelope( study_mesh, obstacle_faces, sun_vectors, _height_limit_, solar_rights_) lb_mesh = solar_obj.envelope_mesh() mesh = from_mesh3d(lb_mesh) points = [from_point3d(pt) for pt in lb_mesh.vertices] hide_output(ghenv.Component, 1)
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: # gather all of the intersection points all_pts = [pt] for i_pt in pl_pts: all_pts.append(to_point3d(i_pt)) # compute the last point if len(pl_pts) < _bounce_count_ + 2: int_norm = normal_at_point(rtrace_brep, pl_pts[-1]) int_norm = to_vector3d(int_norm) last_vec = all_pts[-2] - all_pts[-1] last_vec = last_vec.normalize() final_vec = last_vec.reflect(int_norm).reverse() final_pt = all_pts[-1] + (final_vec * _last_length_) all_pts.append(final_pt) # create a Polyline3D from the points lb_ray_line = Polyline3D(all_pts) rays.append(from_polyline3d(lb_ray_line)) int_pts.append([from_point3d(p) for p in all_pts]) # convert the intersection points to a data tree int_pts = list_to_data_tree(int_pts) hide_output(ghenv.Component, 1)
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 s_grid = SensorGrid.from_position_and_direction( room.identifier, base_poss, base_dirs) s_grid.display_name = clean_rad_string(room.display_name) s_grid.room_identifier = room.identifier s_grid.mesh = lb_mesh # append everything to the lists grid.append(s_grid) points.append(base_points) mesh.append(from_mesh3d(lb_mesh))
- Args: _analysis_grid: An analysis grid output from a Radiance analysis. _index_: An integer to pick the index of the sensor in the analysis_grid (default: 0). Returns: position: Position of the sensor sensor: Sensor object. Use this sensor to generate blind schedules for annual daylight analysis. """ ghenv.Component.Name = "HoneybeePlus_Sensor from analysis grid" ghenv.Component.NickName = 'sensor' ghenv.Component.Message = 'VER 0.0.05\nMAR_28_2020' ghenv.Component.Category = "HoneybeePlus" ghenv.Component.SubCategory = '04 :: Daylight :: Daylight' ghenv.Component.AdditionalHelpFromDocStrings = "2" try: from ladybug_rhino.fromgeometry import from_point3d except ImportError as e: raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e)) if _analysis_grid: if _analysis_grid.digit_sign == 1: _analysis_grid.load_values_from_files() id = _index_ if _index_ is not None else 0 sensor = _analysis_grid[id] position = from_point3d(sensor.location)
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] ] * len(total_sky_rad) all_rad = total_sky_rad + ground_rad
for dr in model.orphaned_doors: add_door(door, points, vectors) for shd in model.orphaned_shades: points.append(from_point3d(shd.center)) vectors.append(from_vector3d(shd.normal)) if all_required_inputs(ghenv.Component): # list of rhino geometry to be filled with content points = [] vectors = [] # loop through all objects and add them for hb_obj in _hb_objs: if isinstance(hb_obj, Room): add_room(hb_obj, points, vectors) elif isinstance(hb_obj, Face): add_face(hb_obj, points, vectors) elif isinstance(hb_obj, Aperture): add_aperture(hb_obj, points, vectors) elif isinstance(hb_obj, Door): add_door(hb_obj, points, vectors) elif isinstance(hb_obj, Shade): points.append(from_point3d(hb_obj.center)) vectors.append(from_vector3d(hb_obj.normal)) elif isinstance(hb_obj, Model): add_model(hb_obj, points, vectors) else: raise TypeError( 'Unrecognized honeybee object type: {}'.format(type(hb_obj)))
from ladybug_geometry.geometry3d.pointvector import Point3D except ImportError as e: raise ImportError('\nFailed to import ladybug_geometry:\n\t{}'.format(e)) try: # import core honeybee dependencies from honeybee.model import Model except ImportError as e: raise ImportError('\nFailed to import honeybee:\n\t{}'.format(e)) try: # import ladybug_rhino dependencies from ladybug_rhino.fromgeometry import from_point3d, from_mesh3d from ladybug_rhino.grasshopper import all_required_inputs, list_to_data_tree except ImportError as e: raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e)) if all_required_inputs(ghenv.Component): assert isinstance(_model, Model), \ 'Expected Honeybee Model. Got {}.'.format(type(_model)) # get the honeybee-radiance objects views = _model.properties.radiance.views grids = _model.properties.radiance.sensor_grids # get the visualizable attributes points = [[from_point3d(Point3D.from_array(s.pos)) for s in sg] for sg in grids] points = list_to_data_tree(points) meshes = [] for grid in grids: if grid.mesh is not None: meshes.append(from_mesh3d(grid.mesh))
direction, overhang_proj_, view_vecs) apply_mask_to_base_mask(strategy_pattern, over_pattern, orient_pattern) apply_mask_to_sky(sky_pattern, over_pattern) if left_fin_proj_ or right_fin_proj_: f_pattern = view_sphere.fin_pattern(direction, left_fin_proj_, right_fin_proj_, view_vecs) apply_mask_to_base_mask(strategy_pattern, f_pattern, orient_pattern) apply_mask_to_sky(sky_pattern, f_pattern) # account for any input context context_pattern = None if len(context_) != 0: shade_mesh = join_geometry_to_mesh(context_) # mesh the context points = [from_point3d(center_pt3d)] view_vecs = [from_vector3d(pt) for pt in view_vecs] int_matrix, angles = intersect_mesh_rays(shade_mesh, points, view_vecs) context_pattern = [val == 0 for val in int_matrix[0]] apply_mask_to_sky(sky_pattern, context_pattern) # get the weights for each patch to be used in view factor calculation weights = view_sphere.dome_radial_patch_weights(az_count, alt_count) if direction is not None: weights = [ wgt * abs(math.cos(ang)) * 2 for wgt, ang in zip(weights, dir_angles) ] # create meshes for the masks and compute any necessary view factors gray, black = Color(230, 230, 230), Color(0, 0, 0) context_view, orient_view, strategy_view = 0, 0, 0
'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_) else:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e)) if all_required_inputs(ghenv.Component) and _run: # set the default values _offset_dist_ = _offset_dist_ if _offset_dist_ is not None \ else 0.1 / conversion_to_meters() if pt_weights_: assert len(pt_weights_) == len(_view_points), \ 'The number of pt_weights_({}) must match the number of _view_points ' \ '({}).'.format(len(pt_weights_), len(_view_points)) 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_) if _geo_block_ \ or _geo_block_ is None else join_geometry_to_mesh(context_) # intersect the lines with the mesh int_matrix = intersect_mesh_lines( shade_mesh, points, _view_points, max_dist_, cpu_count=workers) # compute the results int_mtx = objectify_output('Visibility Intersection Matrix', int_matrix) vec_count = len(_view_points) if pt_weights_: # weight intersections by the input point weights