def test_segment_text():
"""Test the segment_text property."""
legend = Legend(range(10), LegendParameters(segment_count=6))
assert len(legend.segment_text_location) == len(legend.segment_text) == 6
assert legend.segment_text == [
'0.00', '1.80', '3.60', '5.40', '7.20', '9.00'
]
for pl in legend.segment_text_location:
assert isinstance(pl, Plane)
for pt in legend.segment_text_location_2d:
assert isinstance(pt, Point2D)
seg_num = [0, 1.8, 3.6, 5.4, 7.2, 9]
for i, num in enumerate(legend.segment_numbers):
assert num == pytest.approx(seg_num[i], rel=1e-3)
legend = Legend(range(10), LegendParameters(segment_count=6))
legend.legend_parameters.vertical = False
assert len(legend.segment_text_location) == len(legend.segment_text) == 6
assert legend.segment_text == [
'0.00', '1.80', '3.60', '5.40', '7.20', '9.00'
]
for pl in legend.segment_text_location:
assert isinstance(pl, Plane)
def test_ordinal_dictionary():
"""Test the LegendParameter ordinal_dictionary property."""
leg_par = LegendParameters(min=0, max=1)
leg_par.ordinal_dictionary = {0: 'False', 1: 'True'}
assert leg_par.ordinal_dictionary == {0: 'False', 1: 'True'}
leg_par_copy = leg_par.duplicate()
assert leg_par_copy.ordinal_dictionary == {0: 'False', 1: 'True'}
leg_par.ordinal_dictionary = {0: 'No', 1: 'Yes'}
assert leg_par.ordinal_dictionary == {0: 'No', 1: 'Yes'}
with pytest.raises(Exception):
leg_par = LegendParameters(ordinal_dictionary=['False', 'True'])
with pytest.raises(Exception):
leg_par.ordinal_dictionary = ['False', 'True']
def test_decimal_count():
"""Test the LegendParameter decimal_count property."""
leg_par = LegendParameters()
leg_par.decimal_count = 3
assert leg_par.decimal_count == 3
leg_par_copy = leg_par.duplicate()
assert leg_par_copy.decimal_count == 3
leg_par.decimal_count = 0
assert leg_par.decimal_count == 0
with pytest.raises(Exception):
leg_par = LegendParameters(decimal_count='2')
with pytest.raises(Exception):
leg_par.decimal_count = '2'
def test_vertical(self):
"""Test the LegendParameter continuous_legend property."""
leg_par = LegendParameters()
leg_par.vertical = False
assert leg_par.vertical is False
leg_par_copy = leg_par.duplicate()
assert leg_par_copy.vertical is False
leg_par.vertical = True
assert leg_par.vertical is True
with pytest.raises(Exception):
leg_par = LegendParameters(vertical='yes')
with pytest.raises(Exception):
leg_par.vertical = 'yes'
def legend_parameters(self, value):
if value is not None:
assert isinstance(value, LegendParameters), \
'Expected LegendParameters. Got {}.'.format(type(value))
self._legend_parameters = value.duplicate()
else:
self._legend_parameters = LegendParameters()
def test_font():
"""Test the LegendParameter font property."""
leg_par = LegendParameters()
leg_par.font = 'Times'
assert leg_par.font == 'Times'
leg_par_copy = leg_par.duplicate()
assert leg_par_copy.font == 'Times'
leg_par.font = 'Courier'
assert leg_par.font == 'Courier'
with pytest.raises(Exception):
leg_par = LegendParameters(font=0)
with pytest.raises(Exception):
leg_par.font = 0
def test_continuous_legend():
"""Test the LegendParameter continuous_legend property."""
leg_par = LegendParameters()
leg_par.continuous_legend = True
assert leg_par.continuous_legend is True
leg_par_copy = leg_par.duplicate()
assert leg_par_copy.continuous_legend is True
leg_par.continuous_legend = False
assert leg_par.continuous_legend is False
with pytest.raises(Exception):
leg_par = LegendParameters(continuous_legend='yes')
with pytest.raises(Exception):
leg_par.continuous_legend = 'yes'
def test_title():
"""Test the LegendParameter title property."""
leg_par = LegendParameters(title='m2')
assert leg_par.title == 'm2'
assert leg_par.is_title_default is False
leg_par_copy = leg_par.duplicate()
assert leg_par_copy.title == 'm2'
leg_par.title = 'm2'
assert leg_par.title == 'm2'
with pytest.raises(Exception):
leg_par = LegendParameters(title=2)
with pytest.raises(Exception):
leg_par.title = 2
def test_continuous_colors():
"""Test the LegendParameter continuous_colors property."""
leg_par = LegendParameters()
leg_par.continuous_colors = False
assert not leg_par.continuous_colors
leg_par_copy = leg_par.duplicate()
assert not leg_par_copy.continuous_colors
leg_par.continuous_colors = True
assert leg_par.continuous_colors
with pytest.raises(Exception):
leg_par = LegendParameters(continuous_colors='yes')
with pytest.raises(Exception):
leg_par.continuous_colors = 'yes'
def legend_parameters(self, value):
if value is not None:
assert isinstance(value, LegendParameters) and not \
isinstance(value, LegendParametersCategorized), \
'Expected LegendParameters. Got {}.'.format(type(value))
self._legend_parameters = value
else:
self._legend_parameters = LegendParameters()
def test_segment_width():
"""Test the LegendParameter segment_width property."""
leg_par = LegendParameters()
leg_par.segment_width = 3
assert leg_par.segment_width == 3
assert leg_par.is_segment_width_default is False
leg_par_copy = leg_par.duplicate()
assert leg_par_copy.segment_width == 3
leg_par.segment_width = 2
assert leg_par.segment_width == 2
with pytest.raises(Exception):
leg_par = LegendParameters(segment_width=0)
with pytest.raises(Exception):
leg_par.segment_width = 0
def test_text_height():
"""Test the LegendParameter text_height property."""
leg_par = LegendParameters()
leg_par.text_height = 0.25
assert leg_par.text_height == 0.25
assert leg_par.is_text_height_default is False
leg_par_copy = leg_par.duplicate()
assert leg_par_copy.text_height == 0.25
leg_par.text_height = 2
assert leg_par.text_height == 2
with pytest.raises(Exception):
leg_par = LegendParameters(text_height=0)
with pytest.raises(Exception):
leg_par.text_height = 0
def test_segment_height():
"""Test the LegendParameter segment_height property."""
leg_par = LegendParameters()
leg_par.segment_height = 3
assert leg_par.segment_height == 3
assert not leg_par.is_segment_height_default
leg_par_copy = leg_par.duplicate()
assert leg_par_copy.segment_height == 3
leg_par.segment_height = 2
assert leg_par.segment_height == 2
with pytest.raises(Exception):
leg_par = LegendParameters(segment_height=0)
with pytest.raises(Exception):
leg_par.segment_height = 0
def test_base_plane():
"""Test the LegendParameter base_plane property."""
leg_par = LegendParameters(
base_plane=Plane(Vector3D(0, 0, 0), Point3D(10, 10, 0)))
assert leg_par.base_plane.o == Point3D(10, 10, 0)
assert leg_par.is_base_plane_default is False
leg_par_copy = leg_par.duplicate()
assert leg_par_copy.base_plane.o == Point3D(10, 10, 0)
leg_par.base_plane = Plane(Vector3D(0, 0, 0), Point3D(-10, -10, 0))
assert leg_par.base_plane.o == Point3D(-10, -10, 0)
with pytest.raises(Exception):
leg_par = LegendParameters(base_plane=Point3D(-10, -10, 0))
with pytest.raises(Exception):
leg_par.base_plane = Point3D(-10, -10, 0)
def test_init_legend_with_parameter():
"""Test the initialization of Legend with LegendParameter objects."""
legend = Legend([0, 10], LegendParameters(2, 8))
assert len(legend.values) == 2
assert legend.legend_parameters.min == 2
assert legend.legend_parameters.max == 8
assert legend.is_min_default is False
assert legend.is_max_default is False
def test_equality():
"""Test the equality of legend parameters."""
leg_par = LegendParameters(0, 1000)
leg_par_dup = leg_par.duplicate()
assert leg_par is not leg_par_dup
assert leg_par == leg_par_dup
leg_par_dup.segment_count = 3
assert leg_par != leg_par_dup
def test_segment_text_ordinal_dictionary(self):
"""Test the segment_text property with ordinal dictionary."""
results = list(range(3000))
ordinal_dict = {300: 'low', 1150: 'desired', 2000: 'too much'}
legend = Legend(results, LegendParameters(min=300, max=2000, segment_count=3))
legend.legend_parameters.ordinal_dictionary = ordinal_dict
assert len(legend.segment_text_location) == len(legend.segment_text) == 3
assert legend.segment_text == ['low', 'desired', 'too much']
assert len(set(legend.value_colors)) > 100
legend = Legend(results, LegendParameters(min=300, max=2000, segment_count=3))
legend.legend_parameters.ordinal_dictionary = ordinal_dict
legend.legend_parameters.continuous_colors = False
assert len(legend.segment_text_location) == len(legend.segment_text) == 3
assert legend.segment_text == ['low', 'desired', 'too much']
assert len(set(legend.value_colors)) == 3
def test_colors():
"""Test the LegendParameter colors property."""
leg_par = LegendParameters(colors=[Color(0, 0, 0), Color(255, 255, 255)])
assert len(leg_par.colors) == 2
assert leg_par.colors[0] == Color(0, 0, 0)
assert leg_par.colors[1] == Color(255, 255, 255)
leg_par_copy = leg_par.duplicate()
assert len(leg_par_copy.colors) == 2
assert leg_par_copy.colors[0] == Color(0, 0, 0)
assert leg_par_copy.colors[1] == Color(255, 255, 255)
leg_par.colors = [Color(0, 0, 0), Color(100, 100, 100)]
assert leg_par.colors[1] == Color(100, 100, 100)
with pytest.raises(Exception):
leg_par = LegendParameters(colors=[0, 1])
with pytest.raises(Exception):
leg_par.colors = [0, 1]
def test_legend_value_colors():
"""Test the color_range, value_colors, and segment_colors property."""
legend = Legend(range(5), LegendParameters(segment_count=10))
for i, color in enumerate(legend.color_range):
assert color == ColorRange()[i]
assert legend.color_range.domain == ColorRange(domain=(0, 4)).domain
assert len(legend.values) == 5
assert len(legend.value_colors) == 5
assert legend.value_colors[0] == Colorset.original()[0]
assert legend.segment_colors == Colorset.original()
def test_legend_title():
"""Test the title property."""
legend = Legend(range(5))
assert legend.title == ''
assert legend.legend_parameters.is_title_default is True
assert legend.title_location.o == Point3D(0, 11.25, 0)
assert legend.title_location_2d == Point2D(0, 11.25)
legend = Legend(range(5), LegendParameters(segment_count=5, title='C'))
assert legend.title == 'C'
assert legend.legend_parameters.is_title_default is False
assert legend.title_location.o == Point3D(0, 5.25, 0)
assert legend.title_location_2d == Point2D(0, 5.25)
def test_segment_text_ordinal_dictionary2(self):
"""Test the segment_text property with another ordinal dictionary."""
results = list(range(-4, 5))
ordinal_dict = PredictedMeanVote().unit_descr
legend = Legend(results, LegendParameters(min=-3, max=3, segment_count=7))
legend.legend_parameters.ordinal_dictionary = ordinal_dict
assert legend.segment_text == ['Cold', 'Cool', 'Slightly Cool', 'Neutral',
'Slightly Warm', 'Warm', 'Hot']
legend.legend_parameters.min = -2
legend.legend_parameters.max = 2
legend.legend_parameters.segment_count = 5
assert legend.segment_text == ['Cool', 'Slightly Cool', 'Neutral',
'Slightly Warm', 'Warm']
def test_segment_mesh_2d():
"""Test the segment_mesh_2d property."""
legend = Legend(range(10), LegendParameters(segment_count=6))
assert isinstance(legend.segment_mesh_2d, Mesh2D)
assert len(legend.segment_mesh_2d.faces) == 6
assert len(legend.segment_mesh_2d.vertices) == 14
legend.legend_parameters.vertical = False
assert len(legend.segment_mesh_2d.faces) == 6
assert len(legend.segment_mesh_2d.vertices) == 14
legend.legend_parameters.continuous_legend = True
assert len(legend.segment_mesh_2d.faces) == 5
assert len(legend.segment_mesh_2d.vertices) == 12
legend.legend_parameters.vertical = True
assert len(legend.segment_mesh_2d.faces) == 5
assert len(legend.segment_mesh_2d.vertices) == 12
def test_init_legend_parameters():
"""Test the initialization of LegendParameter objects."""
leg_par = LegendParameters(0, 1000)
str(leg_par) # Test the LegendParameters representation
assert leg_par.min == 0
assert leg_par.max == 1000
assert leg_par.is_segment_count_default is True
assert leg_par.is_title_default is True
assert leg_par.is_base_plane_default is True
assert leg_par.is_segment_height_default is True
assert leg_par.is_segment_width_default is True
assert leg_par.is_text_height_default is True
leg_par_copy = leg_par.duplicate()
assert leg_par_copy.min == leg_par.min
assert leg_par_copy.max == leg_par.max
assert leg_par_copy.segment_count == leg_par.segment_count
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)'
def test_hourlyplot_custom():
"""Test the initialization of HourlyPlot with custom properties."""
header = Header(Temperature(), 'C', AnalysisPeriod())
values = list(range(8760))
data_coll = HourlyContinuousCollection(header, values)
hour_plot = HourlyPlot(data_coll, LegendParameters(), Point3D(10, 10, 10),
2, 2, 100)
assert hour_plot.base_point == Point3D(10, 10, 10)
assert hour_plot.x_dim == 2
assert hour_plot.y_dim == 2
assert hour_plot.z_dim == 100
mesh = hour_plot.colored_mesh3d
assert isinstance(mesh, Mesh3D)
assert len(mesh.faces) == 8760
assert mesh.min == Point3D(10, 10, 10)
assert mesh.max == Point3D(2 * 365 + 10, 2 * 24 + 10, 110)
def test_monthlychart_set_min_max_by_index():
"""Test the set_minimum_by_index amd set_maximum_by_index methods."""
header = Header(Temperature(), 'C', AnalysisPeriod())
values = [i for i in range(12)]
date_t = list(range(1, 13))
data_coll = MonthlyCollection(header, values, date_t)
header2 = Header(RelativeHumidity(), '%', AnalysisPeriod())
values2 = [i for i in range(10, 70, 5)]
data_coll2 = MonthlyCollection(header2, values2, date_t)
l_par = LegendParameters(min=-20, max=40)
l_par.decimal_count = 0
month_chart = MonthlyChart([data_coll, data_coll2], legend_parameters=l_par)
assert month_chart.y_axis_labels1[0] == '-20'
assert month_chart.y_axis_labels1[-1] == '40'
month_chart.set_minimum_by_index(0, 1)
assert month_chart.y_axis_labels2[0] == '0'
month_chart.set_maximum_by_index(100, 1)
assert month_chart.y_axis_labels2[-1] == '100'
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
def test_wind_polygons():
"""Test colors for different windrose types."""
# Testing vals
dir_vals = [0, 0, 0, 0, 10, 10, 10, 85, 90, 90, 90, 95, 170, 285, 310]
spd_vals = [0, 0, 0, 0, 1, 145, 189, 15, 10, 150, 300, 259, 100, 5, 301]
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Bin values to divide into 6 intervals = 10 - 310 = 300 / 6 = 50 m/s
# intervals: [1-50, 51-100, 101-150, 151-200, 201-250, 251-300, 301-350]
#
# [[1], [], [145], [189], [], []], # 0-49, 100-149, 150-199
# [[10, 15], [], [150], [], [], [259, 300]], # 0-49, 150-199,, 250-299
# [[], [100], [], [], [], []], # 100-149
# [[5], [], [], [], [], [301]] # 0-49, 300-349
# Check freq=True, zeros=False
w = WindRose(dir_data, spd_data, 4)
w.show_freq, w.show_zeros = True, False
w.frequency_hours = 2
w.legend_parameters = LegendParameters(segment_count=6)
chk_poly_num = sum([3, 3, 1, 2])
assert chk_poly_num == len(w.windrose_lines)
# For averaged
w.show_freq = False
chk_poly_num = 4
w.colored_mesh
assert chk_poly_num == len(w.windrose_lines)
def test_windrose_set_legend_parameters():
"""Test setting legend params property"""
epw_path = os.path.join(os.getcwd(), 'tests/fixtures/epw/tokyo.epw')
epw = EPW(epw_path)
w = WindRose(epw.wind_direction, epw.wind_speed, 5)
# Default
assert w._legend_parameters is None
assert isinstance(w.legend_parameters, LegendParameters)
assert w.legend_parameters.segment_count == pytest.approx(11.0, abs=1e-10)
# Check setting wrong input
with pytest.raises(AssertionError):
w.legend_parameters = 'string'
# Check setting
w.legend_parameters = LegendParameters(segment_count=16)
assert w.legend_parameters.segment_count == pytest.approx(16, abs=1e-10)
# Check resetting
w.legend_parameters = None
assert isinstance(w.legend_parameters, LegendParameters)
assert w.legend_parameters.segment_count == pytest.approx(11.0, abs=1e-10)
def legend_parameters(self):
"""Legend parameters for grid based analysis."""
return LegendParameters(0, 3000)