def _my_lb_line_constructor(_line): """Cus' the 'to_line_segment' method has an error (thinks second pt is a vector) """ p1 = to_point3d(_line.PointAtStart) p2 = to_point3d(_line.PointAtEnd) line = LineSegment3D.from_end_points(p1, p2) return line
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)
'plot the wind rose. Got: {}'.format(_dir_count_) if north_ is not None: # process the north_ try: north_ = math.degrees( to_vector2d(north_).angle_clockwise(Vector2D(0, 1))) except AttributeError: # north angle instead of vector north_ = float(north_) assert -360.0 <= north_ <= 360.0, 'The north orientation must be greater ' \ 'then -360 and less then 360 to plot the wind rose. ' \ 'Got: {}'.format(north_) else: north_ = 0.0 # set default values for the chart dimensions _center_pt_ = to_point3d( _center_pt_) if _center_pt_ is not None else Point3D() center_pt_2d = Point2D(_center_pt_.x, _center_pt_.y) # set defaults frequency hours and distance so chart is same scale as other LB plots if _freq_hours_ is None: _freq_hours_ = 50.0 if _freq_dist_ is None: _freq_dist_ = 5.0 / conversion_to_meters() # set default show_freq and _show_calmrose_ _show_calmrose_ = False if _show_calmrose_ is None else _show_calmrose_ _show_freq_ = True if _show_freq_ is None else _show_freq_ # set up empty lists of objects to be filled all_wind_avg_val = [] all_wind_frequency = []
title_array.append('{}: {}'.format(key, val)) return '\n'.join(title_array) if all_required_inputs(ghenv.Component): # process all of the global inputs for the sunpath if north_ is not None: # process the north_ try: north_ = math.degrees( to_vector2d(north_).angle_clockwise(Vector2D(0, 1))) except AttributeError: # north angle instead of vector north_ = float(north_) else: north_ = 0 if _center_pt_ is not None: # process the center point into a Point2D center_pt, center_pt3d = to_point2d(_center_pt_), to_point3d( _center_pt_) z = center_pt3d.z else: center_pt, center_pt3d = Point2D(), Point3D() z = 0 _scale_ = 1 if _scale_ is None else _scale_ # process the scale into a radius radius = (100 * _scale_) / conversion_to_meters() solar_time_ = False if solar_time_ is None else solar_time_ # process solar time projection_ = projection_.title() if projection_ is not None else None # create a intersection of the input hoys_ and the data hoys if len(data_) > 0 and len(hoys_) > 0: all_aligned = all(data_[0].is_collection_aligned(d) for d in data_[1:]) assert all_aligned, 'All collections input to data_ must be aligned for ' \ 'each Sunpath.\nGrafting the data_ and suplying multiple grafted ' \ '_center_pt_ can be used to view each data on its own path.'
if all_required_inputs(ghenv.Component): # check the _bounce_count_ _bounce_count_ = 0 if _bounce_count_ is None else _bounce_count_ - 1 assert _bounce_count_ >= 0, 'The input _bounce_count_ must be greater ' \ 'than zero. Got {}.'.format(_bounce_count_ + 1) # process the input sun vector lb_vec = to_vector3d(_vector).normalize() 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]
off_at_min_ = [False] if len(off_at_min_) == 0 else off_at_min_ # loop through the rooms and assign daylight sensors unassigned_rooms = [] if len(_sensor_points_) == 0: for i, room in enumerate(rooms): dl_control = room.properties.energy.add_daylight_control_to_center( dist_from_floor, longest_list(_ill_setpoint_, i), longest_list(_control_fract_, i), longest_list(_min_power_in_, i), longest_list(_min_light_out_, i), longest_list(off_at_min_, i)) if dl_control is None: unassigned_rooms.append(room.display_name) else: for i, room in enumerate(rooms): sensor_pt = to_point3d(_sensor_points_[i]) if room.geometry.is_point_inside(sensor_pt): dl_control = DaylightingControl( sensor_pt, longest_list(_ill_setpoint_, i), longest_list(_control_fract_, i), longest_list(_min_power_in_, i), longest_list(_min_light_out_, i), longest_list(off_at_min_, i)) room.properties.energy.daylighting_control = dl_control else: unassigned_rooms.append(room.display_name) # give a warning about any rooms to which a sensor could not be assinged for room in unassigned_rooms: msg = 'Sensor point for room "{}" does not lie within the room volume.\n' \ 'No daylight sensors have been added to this room.'.format(room)
result.append(from_arc2d(circle, z)) # generate the labels and tick marks for the azimuths for line in compass.major_azimuth_ticks: result.append(from_linesegment2d(line, z)) for txt, pt in zip(compass.MAJOR_TEXT, compass.major_azimuth_points): result.append( text_objects(txt, Plane(o=Point3D(pt.x, pt.y, z), x=xaxis), maj_txt, font, 1, 3)) return result # set defaults for all of the if _north_ is not None: # process the _north_ try: _north_ = math.degrees( to_vector2d(_north_).angle_clockwise(Vector2D(0, 1))) except AttributeError: # north angle instead of vector _north_ = float(_north_) else: _north_ = 0 if _center_ is not None: # process the center point into a Point2D center_pt, z = to_point2d(_center_), to_point3d(_center_).z else: center_pt, z = Point2D(), 0 _scale_ = 1 if _scale_ is None else _scale_ # process the scale into a radius radius = (10 * _scale_) / conversion_to_meters() # create the compass compass = translate_compass(Compass(radius, center_pt, _north_, 1), z)
time_str = '{} - {}'.format(st, end) if st != end else st title_txt = '{} Radiation\n{}\n{}'.format( dome_name, time_str, '\n'.join([dat for dat in metadata[4:]])) dome_title = text_objects(title_txt, graphic.lower_title_location, graphic.legend_parameters.text_height, graphic.legend_parameters.font) return dome_mesh, dome_compass, dome_legend, dome_title, values if all_required_inputs(ghenv.Component): # set defaults for global variables _scale_ = 1 if _scale_ is None else _scale_ radius = (100 * _scale_) / conversion_to_meters() if _center_pt_ is not None: # process the center point into a Point2D center_pt3d = to_point3d(_center_pt_) z = center_pt3d.z else: center_pt3d, z = Point3D(), 0 # deconstruct the sky matrix and derive key data from it metadata, direct, diffuse = de_objectify_output(_sky_mtx) north = metadata[0] # first item is the north angle sky_type = 1 if len(direct) == 145 else 2 # i for tregenza; 2 for reinhart total = [dirr + difr for dirr, difr in zip(direct, diffuse)] # total radiation # override the legend default min and max to make sense for domes l_par = legend_par_.duplicate( ) if legend_par_ is not None else LegendParameters() if l_par.min is None:
enth_wb_lines_i = enth_wb_lines_i + small_labels( psy_chart, psy_chart.enthalpy_labels, psy_chart.enthalpy_label_points, 2, 3) # add all of the objects to the bse list title.append(title_i) temp_lines.append(temp_lines_i) rh_lines.append(rh_lines_i) hr_lines.append(hr_lines_i) enth_wb_lines.append(enth_wb_lines_i) if all_required_inputs(ghenv.Component): # process the base point bp = to_point2d(_base_pt_) if _base_pt_ is not None else Point2D() z = to_point3d(_base_pt_).z if _base_pt_ is not None else 0 # create lists to be filled with objects title = [] temp_lines = [] rh_lines = [] hr_lines = [] enth_wb_lines = [] mesh = [] legend = [] points = [] data_colls = [] psych_chart = [] # loop through the input temperatures and humidity and plot psych charts for j, (temperature,
def mask_mesh_from_pattern(base_mask, mask_pattern, color): """Get a Rhino mesh of a mask from a pattern aligned to the faces of a base mesh.""" try: mask_mesh = base_mask.remove_faces_only(mask_pattern) except AssertionError: # all mesh faces have been removed return None mask_mesh.colors = [color] * len(mask_mesh.faces) return from_mesh3d(mask_mesh) # process the inputs and set defaults for global variables _scale_ = 1 if _scale_ is None else _scale_ radius = (100 * _scale_) / conversion_to_meters() if _center_ is not None: # process the center point into a Point2D try: # assume that it is a point center_pt3d, direction = to_point3d(_center_), None except AttributeError: plane, is_orient = to_plane(_center_), True center_pt3d, direction = plane.o, plane.n else: center_pt3d, direction = Point3D(), None az_count, alt_count = 72, 18 if _density_: az_count = az_count * _density_ alt_count = alt_count * _density_ if orientation_ is not None: # process the orientation to a number ori_dict = {'north': 0, 'east': 90, 'south': 180, 'west': 270} try: # first check if it's text for the direction orientation_ = ori_dict[orientation_.lower()] except KeyError: # it's a number for the orientation orientation_ = float(orientation_)
try: # import the ladybug_rhino dependencies from ladybug_rhino.togeometry import to_point3d from ladybug_rhino.grasshopper import all_required_inputs except ImportError as e: raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e)) if all_required_inputs(ghenv.Component): hb_objs = [obj.duplicate() for obj in _hb_objs] # duplicate the initial objects # check that the factor is positive assert _factor > 0, 'Input _factor must be greater than 0.' # set the default origin if _origin_ is not None: pt = to_point3d(_origin_) else: pt = [] for obj in hb_objs: origin = obj.center if not isinstance(obj, Model) else None pt.append(origin) # scale all of the objects if _origin_ is not None: for obj in hb_objs: obj.scale(_factor, pt) else: # unique origin point for each object for i, obj in enumerate(hb_objs): obj.scale(_factor, pt[i]) # add the prefix if specified
from ladybug_rhino.text import text_objects from ladybug_rhino.fromobjects import legend_objects 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): # apply any analysis periods and conditional statements to the input collections if period_ is not None: _data = [coll.filter_by_analysis_period(period_) for coll in _data] if statement_ is not None: _data = HourlyContinuousCollection.filter_collections_by_statement( _data, statement_) # set default values for the chart dimensions _base_pt_ = to_point3d(_base_pt_) if _base_pt_ is not None else Point3D() _x_dim_ = _x_dim_ if _x_dim_ is not None else 1.0 / conversion_to_meters() _y_dim_ = _y_dim_ if _y_dim_ is not None else 4.0 / conversion_to_meters() _z_dim_ = _z_dim_ if _z_dim_ is not None else 0 reverse_y_ = reverse_y_ if reverse_y_ is not None else False # set up empty lists of objects to be filled mesh = [] title = [] all_legends = [] all_borders = [] all_labels = [] for i, data_coll in enumerate(_data): try: # sense when several legend parameters are connected lpar = legend_par_[i]