def test_mesh2d_init_from_face_vertices(): """Test the initalization of Mesh2D from_face_vertices.""" face_1 = (Point2D(0, 0), Point2D(0, 2), Point2D(2, 2), Point2D(2, 0)) face_2 = (Point2D(2, 2), Point2D(2, 0), Point2D(4, 0)) mesh_1 = Mesh2D.from_face_vertices([face_1, face_2]) mesh_2 = Mesh2D.from_face_vertices([face_1, face_2], False) assert len(mesh_1.vertices) == 5 assert len(mesh_2.vertices) == 7 assert len(mesh_1.faces) == len(mesh_2.faces) == 2 assert mesh_1.area == mesh_2.area == 6 assert mesh_1.min == mesh_2.min == Point2D(0, 0) assert mesh_1.max == mesh_2.max == Point2D(4, 2) assert mesh_1.center == mesh_2.center == Point2D(2, 1) assert mesh_1.centroid.x == mesh_2.centroid.x == pytest.approx(1.56, rel=1e-2) assert mesh_1.centroid.y == mesh_2.centroid.y == pytest.approx(0.89, rel=1e-2) assert len(mesh_1.face_areas) == len(mesh_2.face_areas) == 2 assert mesh_1.face_areas[0] == mesh_2.face_areas[0] == 4 assert mesh_1.face_areas[1] == mesh_2.face_areas[1] == 2 assert len(mesh_1.face_centroids) == len(mesh_2.face_centroids) == 2 assert mesh_1.face_centroids[0] == mesh_2.face_centroids[0] == Point2D( 1, 1) assert mesh_1.face_centroids[1].x == mesh_2.face_centroids[ 1].x == pytest.approx(2.67, rel=1e-2) assert mesh_1.face_centroids[1].y == mesh_2.face_centroids[ 1].y == pytest.approx(0.67, rel=1e-2) assert mesh_1._is_color_by_face is mesh_1._is_color_by_face is False assert mesh_1.colors is mesh_1.colors is None
def colored_mesh(self): """Get the colored Mesh2D for this graphic. Returns: A Mesh2D of the wind rose plot. """ assert self._number_of_directions > 2, 'The number of directions must be ' \ 'greater then three to plot the wind rose. Currently the ' \ 'number_of_directions parameter is: {}'.format(self._number_of_directions) # Reset computed graphics to account for changes to cached viz properties self._compass = None self._container = None max_bar_radius = self.mesh_radius min_bar_radius = self._zero_mesh_radius zero_mesh_array, zero_color_array = [], [] if self.show_zeros: # Compute the array for calm rose zero_data = [[0] for _ in self.histogram_data] zero_data_stacked = [[0] for _ in self.histogram_data] zero_mesh_array, zero_color_array = WindRose._compute_colored_mesh_array( zero_data, zero_data_stacked, self.bin_vectors, 0, min_bar_radius, show_freq=False) # Calculate regular mesh if self.show_freq: histogram_data_stacked = WindRose._histogram_data_nested( self.histogram_data, self.frequency_hours) else: histogram_data_stacked = [[sum(h) / len(h)] if len(h) > 0 else [0] for h in self.histogram_data] # Don't round radius since there are no frequency intervals. max_bar_radius = self.real_freq_max / self.frequency_hours max_bar_radius *= self.frequency_spacing_distance max_bar_radius += self._zero_mesh_radius mesh_array, color_array = WindRose._compute_colored_mesh_array( self.histogram_data, histogram_data_stacked, self.bin_vectors, min_bar_radius, max_bar_radius, self.show_freq) mesh_array += zero_mesh_array color_array += zero_color_array mesh = Mesh2D.from_face_vertices(mesh_array, purge=True) # Assign colors _color_range = self.color_range mesh.colors = tuple(_color_range.color(val) for val in color_array) # Scale up unit circle to windrose radius (and other transforms) return self._transform(mesh)
def colored_mesh(self): """Get a colored Mesh2D for this graphic. """ max_bar_radius = 1.0 min_bar_radius = 0.0 zero_mesh_array, zero_color_array = [], [] # Calculate ytick nums for the wind mesh ytick_num = self.legend.legend_parameters.segment_count # total max_bar_num = self.real_freq_max ytick_num_mesh = ytick_num # default if self.show_zeros: # Calculate radius of zero rose max_bar_num += self.zeros_per_bin min_bar_radius = self.zeros_per_bin / max_bar_num * max_bar_radius ytick_num_mesh = max_bar_num / self.frequency_maximum * ytick_num # Update yticks zero_ytick_num_mesh = self._ytick_zero_inc() ytick_num_mesh -= zero_ytick_num_mesh # Compute the array for calm rose zero_data = [[0] for _ in self.histogram_data] zero_data_stacked = [[0] for _ in self.histogram_data] zero_mesh_array, zero_color_array = WindRose._compute_colored_mesh_array( zero_data, zero_data_stacked, self.bin_vectors, zero_ytick_num_mesh, 0, min_bar_radius, show_stack=False) # Calculate regular mesh if self.show_stack: histogram_data_stacked = WindRose._histogram_data_stacked( self.histogram_data, ytick_num) else: histogram_data_stacked = [[sum(h) / len(h)] if len(h) > 0 else [0] for h in self.histogram_data] mesh_array, color_array = WindRose._compute_colored_mesh_array( self.histogram_data, histogram_data_stacked, self.bin_vectors, ytick_num_mesh, min_bar_radius, max_bar_radius, self.show_stack) mesh_array += zero_mesh_array color_array += zero_color_array mesh = Mesh2D.from_face_vertices(mesh_array, purge=True) mesh.colors = color_array return mesh.scale(self.wind_radius).move(self.base_point)
def colored_mesh(self): """Get the colored Mesh2D for this graphic. Returns: A Mesh2D of the wind rose plot. """ assert self._number_of_directions > 2, 'The number of directions must be ' \ 'greater then three to plot the wind rose. Currently the ' \ 'number_of_directions parameter is: {}'.format(self._number_of_directions) # Reset computed graphics to account for changes to cached viz properties self._compass = None self._container = None zero_poly_array, zero_color_array = [], [] max_bar_radius = self.mesh_radius min_bar_radius = self._zero_mesh_radius if self.show_zeros and self.zero_count > 0: # Compute the array for calm rose zero_data = [[0] for _ in self.histogram_data] zero_data_stacked = [[[0]] for _ in self.histogram_data] zero_poly_array, zero_color_array = WindRose._compute_colored_mesh_array( zero_data, zero_data_stacked, self.bin_vectors, 0, min_bar_radius, show_freq=False) # Calculate stacked_data flat_data = [b for a in self.histogram_data for b in a] max_data = max(flat_data) min_data = min( self.analysis_values) if self.show_zeros else min(flat_data) bin_count = self.legend_parameters.segment_count data_range = (min_data, max_data) histogram_data_stacked, bin_range = WindRose._histogram_data_nested( self.histogram_data, data_range, bin_count) data_step = bin_range[1] - bin_range[0] if not self.show_freq: for i in range(self._number_of_directions): stack = histogram_data_stacked[i] vals = [b for a in stack for b in a] if len(vals) > 0: mean_val = sum(vals) / float(len(vals)) histogram_data_stacked[i] = [[mean_val for b in a] for a in stack] poly_array, color_array = WindRose._compute_colored_mesh_array( self.histogram_data, histogram_data_stacked, self.bin_vectors, min_bar_radius, max_bar_radius, self.show_freq) # Compute colors # If show_freq, assign colors to intervals. Else keep averages. if self.show_freq: for i, mean_val in enumerate(color_array): for j in range(len(bin_range) - 1): if bin_range[j] <= mean_val < bin_range[j + 1]: color_array[i] = j break if self.show_zeros: color_array = [c + 1 for c in color_array] # convert bin legend interval to the average interval (interval midpoint) color_array = [(c * data_step) + min_data for c in color_array] poly_array += zero_poly_array color_array += zero_color_array # Store colors and polygons before processing self._poly_array = poly_array self._color_array = color_array # for testing # Assign colors _color_range = self.color_range _color_range = [_color_range.color(val) for val in color_array] mesh = Mesh2D.from_face_vertices(poly_array, purge=True) mesh.colors = tuple(_color_range) # Scale up unit circle to windrose radius (and other transforms) return self._transform(mesh)