Esempio n. 1
0
def test_init_graphic_con():
    """Test the initialization of GraphicContainer objects."""
    mesh2d = Mesh2D.from_grid(num_x=2, num_y=2)
    mesh3d = Mesh3D.from_mesh2d(mesh2d)
    data = [0, 1, 2, 3]
    graphic_con = GraphicContainer(data, mesh3d.min, mesh3d.max)

    str(graphic_con)  # Test the GraphicContainer representation

    assert len(graphic_con) == 4
    assert graphic_con[0] == 0
    assert graphic_con[-1] == 3
    for item in graphic_con:
        assert isinstance(item, (float, int))

    assert len(graphic_con.values) == 4
    assert isinstance(graphic_con.legend, Legend)
    assert graphic_con.value_colors == graphic_con.legend.value_colors

    assert graphic_con.legend_parameters.is_base_plane_default is False
    assert graphic_con.legend_parameters.is_segment_height_default is False
    assert graphic_con.legend_parameters.is_segment_width_default is True
    assert graphic_con.legend_parameters.is_text_height_default is True
    assert graphic_con.legend_parameters.base_plane != Plane()

    assert isinstance(graphic_con.lower_title_location, Plane)
    assert isinstance(graphic_con.upper_title_location, Plane)
    assert graphic_con.lower_title_location != Plane()
    assert graphic_con.upper_title_location != Plane()
Esempio n. 2
0
def create_graphic_container(_season, _data, _study_mesh, _legend_par):
    """Creates the Ladybug 'Graphic' Object from the result data
    
    Copied from Ladybug 'IncidentRadiation' Component
    
    Arguments:
        _season: (str) 'Winter' or 'Summer'. Used in the title.
        _data: (list: float:) A list of the result data to use to color / style the output
        _study_mesh: (ladybug_geometry.geometry3d.Mesh3D) The joined Mesh used in the analysis
        _legend_par: Ladybug Legend Parameters
    Returns: (tuple)
        graphic: (ladybug.graphic.GraphicContainer) The Ladybug Graphic Object
        title: The text title
    """

    graphic = GraphicContainer(_data, _study_mesh.min, _study_mesh.max,
                               _legend_par)
    graphic.legend_parameters.title = 'kWh'

    title = text_objects('{} Incident Radiation'.format(_season),
                         graphic.lower_title_location,
                         graphic.legend_parameters.text_height * 1.5,
                         graphic.legend_parameters.font)

    return graphic, title
Esempio n. 3
0
    def test_init_graphic_con_invalid(self):
        """Test the initialization of GraphicContainer objects with invalid inputs."""
        mesh2d = Mesh2D.from_grid(num_x=2, num_y=2)
        mesh3d = Mesh3D.from_mesh2d(mesh2d)
        data = [0, 1, 2, 3, 4]

        with pytest.raises(Exception):
            GraphicContainer(data, mesh3d.min, mesh3d.max,
                             data_type=Temperature(), unit='NotAUnit')
Esempio n. 4
0
    def test_init_graphic_con_data_type(self):
        """Test the initialization of GraphicContainer objects with a DataType."""
        mesh2d = Mesh2D.from_grid(num_x=2, num_y=2)
        mesh3d = Mesh3D.from_mesh2d(mesh2d)
        data = [-1, 0, 1, 2]
        graphic_con = GraphicContainer(data, mesh3d.min, mesh3d.max,
                                       data_type=Temperature())

        assert graphic_con.legend_parameters.is_title_default is False
        assert graphic_con.legend_parameters.title == 'C'

        legend_par = LegendParameters()
        legend_par.vertical = False
        graphic_con = GraphicContainer(data, mesh3d.min, mesh3d.max,
                                       legend_par, data_type=Temperature())

        assert graphic_con.legend_parameters.is_title_default is False
        assert graphic_con.legend_parameters.title == 'Temperature (C)'
Esempio n. 5
0
def test_to_from_dict():
    """Test the to/from dict methods."""
    mesh2d = Mesh2D.from_grid(num_x=2, num_y=2)
    mesh3d = Mesh3D.from_mesh2d(mesh2d)
    data = [0, 1, 2, 3]
    graphic_con = GraphicContainer(data, mesh3d.min, mesh3d.max)

    graphic_con_dict = graphic_con.to_dict()
    new_graphic_con = GraphicContainer.from_dict(graphic_con_dict)
    assert new_graphic_con.to_dict() == graphic_con_dict
Esempio n. 6
0
    def graphic_container(self):
        """Get a ladybug GraphicContainer that relates to this object.

        The GraphicContainer possesses almost all things needed to visualize the
        ColorFace object including the legend, value_colors, lower_title_location,
        upper_title_location, etc.
        """
        return GraphicContainer(self.matched_values, self.min_point,
                                self._max_point, self.legend_parameters,
                                self.data_type, str(self.unit))
Esempio n. 7
0
def test_init_graphic_con_vertex_based():
    """Test the initialization of ResultMesh objects with vertex-based input."""
    mesh2d = Mesh2D.from_grid(num_x=2, num_y=2)
    mesh3d = Mesh3D.from_mesh2d(mesh2d)
    data = [0, 1, 2, 3, 4, 5, 6, 7, 8]
    graphic_con = GraphicContainer(data, mesh3d.min, mesh3d.max)

    assert len(graphic_con) == 9
    assert graphic_con[0] == 0
    assert graphic_con[-1] == 8

    assert len(graphic_con.values) == 9
    assert isinstance(graphic_con.legend_parameters, LegendParameters)
    assert isinstance(graphic_con.legend, Legend)
    assert graphic_con.value_colors == graphic_con.legend.value_colors
Esempio n. 8
0
    def test_init_graphic_con_data_type_ordinal(self):
        """Test the ResultMesh objects with a DataType with unit_descr."""
        mesh2d = Mesh2D.from_grid(num_x=2, num_y=2)
        mesh3d = Mesh3D.from_mesh2d(mesh2d)
        data = [-1, 0, 1, 2]
        graphic_con = GraphicContainer(data, mesh3d.min, mesh3d.max,
                                       data_type=PredictedMeanVote(), unit='PMV')

        assert graphic_con.legend_parameters.min == -3
        assert graphic_con.legend_parameters.max == 3
        assert graphic_con.legend_parameters.segment_count == 7
        assert graphic_con.legend_parameters.is_title_default is False
        assert graphic_con.legend_parameters.title == 'PMV'
        assert graphic_con.legend.segment_text == ['Cold', 'Cool', 'Slightly Cool',
                                                   'Neutral',
                                                   'Slightly Warm', 'Warm', 'Hot']
Esempio n. 9
0
    def graphic_container(self):
        """Get a ladybug GraphicContainer that relates to this object.

        The GraphicContainer possesses almost all things needed to visualize the
        ColorRooms object including the legend, value_colors, etc.
        """
        # produce a range of values from the collected attributes
        attr_dict = {i: val for i, val in enumerate(self._attributes_unique)}
        attr_dict_rev = {val: i for i, val in attr_dict.items()}
        values = tuple(attr_dict_rev[r_attr] for r_attr in self._attributes)

        # produce legend parameters with an ordinal dict for the attributes
        l_par = self.legend_parameters.duplicate()
        l_par.segment_count = len(self._attributes_unique)
        l_par.ordinal_dictionary = attr_dict
        if l_par.is_title_default:
            l_par.title = self.attr_name_end.replace('_', ' ').title()

        return GraphicContainer(values, self.min_point, self._max_point, l_par)
Esempio n. 10
0
def test_graphic_con_data_type_ordinal_all_same():
    """Test the GraphicContainer with a DataType with unit_descr and all equal values."""
    mesh2d = Mesh2D.from_grid(num_x=2, num_y=2)
    mesh3d = Mesh3D.from_mesh2d(mesh2d)
    data = [0] * 3
    graphic_con = GraphicContainer(data,
                                   mesh3d.min,
                                   mesh3d.max,
                                   data_type=PredictedMeanVote(),
                                   unit='PMV')

    assert graphic_con.legend_parameters.min == -3
    assert graphic_con.legend_parameters.max == 3
    assert graphic_con.legend_parameters.segment_count == 7
    assert not graphic_con.legend_parameters.is_title_default
    assert graphic_con.legend_parameters.title == 'PMV'
    assert graphic_con.legend.segment_text == [
        'Cold', 'Cool', 'Slightly Cool', 'Neutral', 'Slightly Warm', 'Warm',
        'Hot'
    ]
Esempio n. 11
0
def test_init_graphic_con_legend_parameters():
    """Test the initialization of ResultMesh objects with a LegendParameters."""
    mesh2d = Mesh2D.from_grid(num_x=2, num_y=2)
    mesh3d = Mesh3D.from_mesh2d(mesh2d)
    data = [-1, 0, 1, 2]
    legend_par = LegendParameters(base_plane=Plane(o=Point3D(2, 2, 0)))
    legend_par.vertical = False
    legend_par.segment_height = 0.25
    legend_par.segment_width = 0.5
    legend_par.text_height = 0.15
    graphic_con = GraphicContainer(data, mesh3d.min, mesh3d.max, legend_par)

    assert graphic_con.legend_parameters.is_base_plane_default is False
    assert graphic_con.legend_parameters.is_segment_height_default is False
    assert graphic_con.legend_parameters.is_segment_width_default is False
    assert graphic_con.legend_parameters.is_text_height_default is False
    assert graphic_con.legend_parameters.vertical is False
    assert graphic_con.legend_parameters.base_plane.o == Point3D(2, 2, 0)
    assert graphic_con.legend_parameters.segment_height == 0.25
    assert graphic_con.legend_parameters.segment_width == 0.5
    assert graphic_con.legend_parameters.text_height == 0.15
Esempio n. 12
0
                     for ival, ang in zip(int_vals, angles))
            weight_result = sum(r * w for r, w in zip(w_res, patch_wghts))
            results.append(weight_result * 100 / vec_count)
    else:
        if patch_wghts:
            for int_list in int_matrix:
                weight_result = sum(r * w
                                    for r, w in zip(int_list, patch_wghts))
                results.append(weight_result * 100 / vec_count)
        else:
            results = [
                sum(int_list) * 100 / vec_count for int_list in int_matrix
            ]

    # create the mesh and legend outputs
    graphic = GraphicContainer(results, study_mesh.min, study_mesh.max,
                               legend_par_)
    graphic.legend_parameters.title = '%'
    if legend_par_ is None or legend_par_.are_colors_default:
        graphic.legend_parameters.colors = Colorset.view_study()
    title_txt = vt_str if vt_str in ('Sky Exposure', 'Sky View') else \
        '{} View'.format(vt_str)
    title = text_objects(title_txt, graphic.lower_title_location,
                         graphic.legend_parameters.text_height * 1.5,
                         graphic.legend_parameters.font)

    # create all of the visual outputs
    study_mesh.colors = graphic.value_colors
    mesh = from_mesh3d(study_mesh)
    legend = legend_objects(graphic.legend)
Esempio n. 13
0
    elif period_ is not None:
        new_data = [[
            data.filter_by_analysis_period(period_) for data in data_list
        ] for data_list in data_mtx]
        values = [data.average for data_list in new_data for data in data_list]
        time_text = period_
    else:
        values = [data.average for data_list in data_mtx for data in data_list]
        time_text = header.analysis_period

    # generate Ladybug objects for the graphic
    lb_meshes = [to_mesh3d(mesh) for mesh in _mesh]
    lb_mesh = Mesh3D.join_meshes(lb_meshes)
    graphic = GraphicContainer(values,
                               lb_mesh.min,
                               lb_mesh.max,
                               legend_par_,
                               data_type=header.data_type,
                               unit=header.unit)

    # set titles and set default colors and color ranges
    if graphic.legend_parameters.are_colors_default:
        graphic.legend_parameters.colors = colors_from_data_type(
            header.data_type)
    if isinstance(header.data_type, TemperatureDelta) and graphic.legend.is_min_default \
            and graphic.legend.is_max_default:
        graphic.legend_parameters.min = -5
        graphic.legend_parameters.max = 5
    graphic.legend_parameters.title = header.unit
    global_title = '{}\n{}'.format(header.data_type.name, time_text)
    title = text_objects(global_title, graphic.lower_title_location,
                         graphic.legend_parameters.text_height * 1.5,
Esempio n. 14
0
            # move the center point so sun paths are not on top of one another
            fac = i * radius * 3
            center_pt_i = Point2D(center_pt.x + fac, center_pt.y)
            center_pt3d_i = Point3D(center_pt3d.x + fac, center_pt3d.y,
                                    center_pt3d.z)

            # create the ladybug compass object
            lb_compass = Compass(radius, center_pt_i, north_)

            # create a graphic container to generate colors and legends
            n_data = data.filter_by_moys(
                moys)  # filter data collection by sun-up hours
            graphic = GraphicContainer(n_data.values,
                                       lb_compass.min_point3d(z),
                                       lb_compass.max_point3d(z), lpar,
                                       n_data.header.data_type,
                                       n_data.header.unit)
            all_legends.append(legend_objects(graphic.legend))
            title.append(
                text_objects(title_text(n_data), graphic.lower_title_location,
                             graphic.legend_parameters.text_height,
                             graphic.legend_parameters.font))

            # create points, analemmas, daily arcs, and compass geometry
            sun_pts_init = draw_sun_positions(suns, radius, center_pt3d_i)
            analemma_i, daily_i = draw_analemma_and_arcs(
                sp, datetimes, radius, center_pt3d_i)
            compass_i = compass_objects(lb_compass, z, None, projection_,
                                        graphic.legend_parameters.font)
            all_analemma.append(analemma_i)
    from ladybug_rhino.togeometry import to_mesh3d
    from ladybug_rhino.fromgeometry import from_mesh3d
    from ladybug_rhino.fromobjects import legend_objects
    from ladybug_rhino.text import text_objects
    from ladybug_rhino.color import color_to_color
    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):
    # generate Ladybug objects
    lb_mesh = to_mesh3d(_mesh)
    if offset_dom_:
        dom_st, dom_end = offset_dom_
        lb_mesh = lb_mesh.height_field_mesh(_values, (dom_st, dom_end))
    graphic = GraphicContainer(_values, lb_mesh.min, lb_mesh.max, legend_par_)

    # generate titles
    if legend_title_ is not None:
        graphic.legend_parameters.title = legend_title_
    if global_title_ is not None:
        title = text_objects(global_title_, graphic.lower_title_location,
                             graphic.legend_parameters.text_height * 1.5,
                             graphic.legend_parameters.font)

    # draw rhino objects
    lb_mesh.colors = graphic.value_colors
    mesh = from_mesh3d(lb_mesh)
    legend = legend_objects(graphic.legend)
    colors = [color_to_color(col) for col in lb_mesh.colors]
    legend_par = graphic.legend_parameters
Esempio n. 16
0
def draw_dome(dome_data, center, dome_name, legend_par):
    """Draw the dome mesh, compass, legend, and title for a sky dome.

    Args:
        dome_data: List of radiation values for the dome data
        center: Point3D for the center of the sun path.
        dome_name: Text for the dome name, which will appear in the title.
        legend_par: Legend parameters to be used for the dome

    Returns:
        dome_mesh: A colored mesh for the dome based on dome_data.
        dome_compass: A compass for the dome.
        dome_legend: A leend for the colored dome mesh.
        dome_title: A title for the dome.
        values: A list of radiation values that align with the dome_mesh faces.
    """
    # create the dome mesh and ensure patch values align with mesh faces
    if len(dome_data) == 145:  # tregenza sky
        lb_mesh = view_sphere.tregenza_dome_mesh_high_res.scale(radius)
        values = []  # high res dome has 3 x 3 faces per patch; we must convert
        tot_i = 0  # track the total number of patches converted
        for patch_i in view_sphere.TREGENZA_PATCHES_PER_ROW:
            row_vals = []
            for val in dome_data[tot_i:tot_i + patch_i]:
                row_vals.extend([val] * 3)
            for i in range(3):
                values.extend(row_vals)
            tot_i += patch_i
        values = values + [dome_data[-1]
                           ] * 18  # last patch has triangular faces
    else:  #reinhart sky
        lb_mesh = view_sphere.reinhart_dome_mesh.scale(radius)
        values = dome_data + [dome_data[-1]
                              ] * 11  # last patch has triangular faces

    # move and/or rotate the mesh as needed
    if north != 0:
        lb_mesh = lb_mesh.rotate_xy(math.radians(north), Point3D())
    if center != Point3D():
        lb_mesh = lb_mesh.move(Vector3D(center.x, center.y, center.z))

    # project the mesh if requested
    if projection_ is not None:
        if projection_.title() == 'Orthographic':
            pts = (Compass.point3d_to_orthographic(pt)
                   for pt in lb_mesh.vertices)
        elif projection_.title() == 'Stereographic':
            pts = (Compass.point3d_to_stereographic(pt, radius, center)
                   for pt in lb_mesh.vertices)
        else:
            raise ValueError(
                'Projection type "{}" is not recognized.'.format(projection_))
        pts3d = tuple(Point3D(pt.x, pt.y, z) for pt in pts)
        lb_mesh = Mesh3D(pts3d, lb_mesh.faces)

    # output the dome visualization, including legend and compass
    move_fac = radius * 0.15
    min_pt = lb_mesh.min.move(Vector3D(-move_fac, -move_fac, 0))
    max_pt = lb_mesh.max.move(Vector3D(move_fac, move_fac, 0))
    graphic = GraphicContainer(values, min_pt, max_pt, legend_par)
    graphic.legend_parameters.title = 'kWh/m2'
    lb_mesh.colors = graphic.value_colors
    dome_mesh = from_mesh3d(lb_mesh)
    dome_legend = legend_objects(graphic.legend)
    dome_compass = compass_objects(
        Compass(radius, Point2D(center.x, center.y), north), z, None,
        projection_, graphic.legend_parameters.font)

    # construct a title from the metadata
    st, end = metadata[2], metadata[3]
    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