def __init__(self, **kwargs): VGroup.__init__(self, **kwargs) self.colors = color_gradient([ORANGE, RED, PINK, BLUE, GREEN, YELLOW], len(self.values)) self.sectors, self.labels_group = VGroup(), VGroup() self.sectors = self.create_sectors() if not self.labels == None: self.labels_group = self.create_label() self.add(self.sectors, self.labels_group)
def reset_color(self): colors = color_gradient([WHITE, self.get_color(), BLACK], 11) self[0].set_fill(color=colors[8]) self[1].set_fill(color=colors[3]) self[2].set_fill(color=colors[8]) self[3].set_fill(color=colors[2]) self[4].set_fill(color=colors[5]) self[5].set_fill(color=colors[7])
def __init__(self, mob, **kwargs): VGroup.__init__(self, **kwargs) self.add(mob) self.trail = VGroup() self.path_xyz = [] self.add(self.trail) self.pos_old = self[0].get_center() if type(self.trail_color) != str: self.colors = color_gradient(self.trail_color, self.nums)
def init_colors(self): SelfSimilarFractal.init_colors(self) internal_pis = [ pi for pi in self.get_family() if isinstance(pi, PiCreature) ] colors = color_gradient(self.colors, len(internal_pis)) for pi, color in zip(internal_pis, colors): pi.init_colors() pi.body.set_stroke(color, width=0.5) pi.set_color(color)
def __init__(self, mob, **kwargs): VGroup.__init__(self, **kwargs) if type(self.stroke_colors) == list: stroke_colors = color_gradient(self.stroke_colors, self.num) else: stroke_colors = color_gradient([self.stroke_colors, self.stroke_colors], self.num) for i in range(self.num): t = i/(self.num-1) shift_i = self.rate_func(t) * self.shift_vect # scale_i = min(self.scale_range) + self.rate_func(t) * (max(self.scale_range)-min(self.scale_range)) if self.scale_type == 0: scale_i = np.exp(np.log(self.scale_range[0]) + self.rate_func(t) * (np.log(self.scale_range[1])-np.log(self.scale_range[0]))) else: scale_i = self.scale_range[0] + self.rate_func(t) * (self.scale_range[1]-self.scale_range[0]) theta_i = self.rate_func(t) * self.rotate_angle mob_i = mob.copy().shift(shift_i) mob_i.scale(scale_i, about_point=mob_i.get_center_of_mass()).rotate(theta_i, about_point=mob_i.get_center_of_mass()).set_stroke(color=stroke_colors[i]) self.add(mob_i)
def set_submobject_colors_by_gradient(self, *colors): if len(colors) == 0: raise Exception("Need at least one color") elif len(colors) == 1: return self.set_color(*colors) mobs = self.family_members_with_points() new_colors = color_gradient(colors, len(mobs)) for mob, color in zip(mobs, new_colors): mob.set_color(color, family=False) return self
def __init__(self, **kwargs): VGroup.__init__(self, **kwargs) self.color_list = color_gradient(self.colors, self.layer_num) self.add(Dot(color=average_color(self.colors[0], WHITE), plot_depth=4).set_height(0.015 * self.radius)) for i in range(self.layer_num): # self.add(Arc(radius= self.radius/self.layer_num * (0.5 + i), angle=TAU, color=self.color_list[i], # stroke_width=100 * self.radius/self.layer_num, # stroke_opacity=self.opacity_func(i/self.layer_num), plot_depth=5)) self.add(Arc(radius= self.radius * self.rate_func((0.5 + i)/self.layer_num), angle=TAU, color=self.color_list[i], stroke_width=101 * (self.rate_func((i + 1)/self.layer_num) - self.rate_func(i/self.layer_num)) * self.radius, stroke_opacity=self.opacity_func(self.rate_func(i/self.layer_num)), plot_depth=5))
def create_arcs(self, **kwargs): angle = self.start_angle colors = color_gradient(self.colors, len(self.angle_list)) for i in range(len(self.angle_list)): self.add( Arc(radius=self.radius, start_angle=angle, angle=self.angle_list[i], color=colors[i], stroke_width=self.stroke_width, **kwargs)) angle += self.angle_list[i]
def get_riemann_rectangles( self, graph, x_min=None, x_max=None, dx=0.1, input_sample_type="left", stroke_width=1, stroke_color=BLACK, fill_opacity=1, start_color=None, end_color=None, show_signed_area=True, width_scale_factor=1.001 ): x_min = x_min if x_min is not None else self.x_min x_max = x_max if x_max is not None else self.x_max if start_color is None: start_color = self.default_riemann_start_color if end_color is None: end_color = self.default_riemann_end_color rectangles = VGroup() x_range = np.arange(x_min, x_max, dx) colors = color_gradient([start_color, end_color], len(x_range)) for x, color in zip(x_range, colors): if input_sample_type == "left": sample_input = x elif input_sample_type == "right": sample_input = x + dx elif input_sample_type == "center": sample_input = x + 0.5 * dx else: raise Exception("Invalid input sample type") graph_point = self.input_to_graph_point(sample_input, graph) points = VGroup(*list(map(VectorizedPoint, [ self.coords_to_point(x, 0), self.coords_to_point(x + width_scale_factor * dx, 0), graph_point ]))) rect = Rectangle() rect.replace(points, stretch=True) if graph_point[1] < self.graph_origin[1] and show_signed_area: fill_color = invert_color(color) else: fill_color = color rect.set_fill(fill_color, opacity=fill_opacity) rect.set_stroke(stroke_color, width=stroke_width) rectangles.add(rect) return rectangles
def set_color_by_gradient(self, *colors): self.rgbas = np.array( list(map(color_to_rgba, color_gradient(colors, len(self.points))))) return self start_rgba, end_rgba = list( map(color_to_rgba, [start_color, end_color])) for mob in self.family_members_with_points(): num_points = mob.get_num_points() mob.rgbas = np.array([ interpolate(start_rgba, end_rgba, alpha) for alpha in np.arange(num_points) / float(num_points) ]) return self
def get_division_along_dimension(self, p_list, dim, colors, vect): p_list = self.complete_p_list(p_list) colors = color_gradient(colors, len(p_list)) last_point = self.get_edge_center(-vect) parts = VGroup() for factor, color in zip(p_list, colors): part = SampleSpace() part.set_fill(color, 1) part.replace(self, stretch=True) part.stretch(factor, dim) part.move_to(last_point, -vect) last_point = part.get_edge_center(vect) parts.add(part) return parts
def set_color_by_gradient(self, *colors): self.rgbas = np.array(list(map( color_to_rgba, color_gradient(colors, len(self.points)) ))) return self start_rgba, end_rgba = list(map(color_to_rgba, [start_color, end_color])) for mob in self.family_members_with_points(): num_points = mob.get_num_points() mob.rgbas = np.array([ interpolate(start_rgba, end_rgba, alpha) for alpha in np.arange(num_points) / float(num_points) ]) return self
def __init__(self, **kwargs): VGroup.__init__(self, **kwargs) self.id_to_pos = [ 0, 144, 161, 126, 127, 138, 139, 140, 141, 142, 143, 108, 109, 120, 121, 122, 123, 124, 125, *list(range(90, 108)), *list(range(72, 90)), 54, 55, *list(range(20, 35)), *list(range(57, 72)), 36, 37, *list(range(2, 17)), *list(range(39, 54)) ] self.create_boxes() self.mask_array = np.zeros((9, 18)) self.colors = color_gradient([BLUE_D, YELLOW, RED, RED_D], 110)
def __init__( self, vmobject: VMobject, n_layers: int = 5, color_bounds: tuple[ManimColor] = (GREY_C, GREY_E), max_stroke_addition: float = 5.0, ): outline = vmobject.replicate(n_layers) outline.set_fill(opacity=0) added_widths = np.linspace(0, max_stroke_addition, n_layers + 1)[1:] colors = color_gradient(color_bounds, n_layers) for part, added_width, color in zip(reversed(outline), added_widths, colors): for sm in part.family_members_with_points(): sm.set_stroke( width=sm.get_stroke_width() + added_width, color=color, ) super().__init__(*outline)
def get_riemann_rectangles(self, graph, x_min=None, x_max=None, dx=0.1, input_sample_type="left", stroke_width=1, stroke_color=BLACK, fill_opacity=1, start_color=None, end_color=None, show_signed_area=True, width_scale_factor=1.001): """ This method returns the VGroup() of the Riemann Rectangles for a particular curve. Parameters ---------- graph (ParametricFunction) The graph whose area needs to be approximated by the Riemann Rectangles. x_min Union[int,float] The lower bound from which to start adding rectangles x_max Union[int,float] The upper bound where the rectangles stop. dx Union[int,float] The smallest change in x-values that is considered significant. input_sample_type str Can be any of "left", "right" or "center stroke_width : Union[int, float] The stroke_width of the border of the rectangles. stroke_color : str The string of hex colour of the rectangle's border. fill_opacity Union[int, float] The opacity of the rectangles. start_color : str, The hex starting colour for the rectangles, this will, if end_color is a different colour, make a nice gradient. end_color : str, The hex ending colour for the rectangles, this will, if start_color is a different colour, make a nice gradient. show_signed_area : bool (True) Whether or not to indicate -ve area if curve dips below x-axis. width_scale_factor : Union[int, float] How much the width of the rectangles are scaled by when transforming. Returns ------- VGroup A VGroup containing the Riemann Rectangles. """ x_min = x_min if x_min is not None else self.x_min x_max = x_max if x_max is not None else self.x_max if start_color is None: start_color = self.default_riemann_start_color if end_color is None: end_color = self.default_riemann_end_color rectangles = VGroup() x_range = np.arange(x_min, x_max, dx) colors = color_gradient([start_color, end_color], len(x_range)) for x, color in zip(x_range, colors): if input_sample_type == "left": sample_input = x elif input_sample_type == "right": sample_input = x + dx elif input_sample_type == "center": sample_input = x + 0.5 * dx else: raise Exception("Invalid input sample type") graph_point = self.input_to_graph_point(sample_input, graph) points = VGroup(*list( map(VectorizedPoint, [ self.coords_to_point(x, 0), self.coords_to_point(x + width_scale_factor * dx, 0), graph_point ]))) rect = Rectangle() rect.replace(points, stretch=True) if graph_point[1] < self.graph_origin[1] and show_signed_area: fill_color = invert_color(color) else: fill_color = color rect.set_fill(fill_color, opacity=fill_opacity) rect.set_stroke(stroke_color, width=stroke_width) rectangles.add(rect) return rectangles
def set_color_by_gradient(self, *colors): self.data["rgbas"] = np.array( list( map(color_to_rgba, color_gradient(colors, self.get_num_points())))) return self
def __init__(self, **kwargs): VGroup.__init__(self, **kwargs) self.create_boxes(self.resolution) self.mask_array = np.zeros(self.resolution) self.colors = color_gradient([BLUE_D, YELLOW, RED, RED_D], 110)