def __init__(self, **kwargs): VGroup.__init__(self, **kwargs) for i in range(self.width): for j in range(self.height): pi = PiCreature().scale(0.3) pi.move_to(i * DOWN + j * RIGHT) self.add(pi)
def __init__(self, mobject, **kwargs): VGroup.__init__(self, Line(UP + LEFT, DOWN + RIGHT), Line(UP + RIGHT, DOWN + LEFT), ) self.replace(mobject, stretch=True) self.set_stroke(self.stroke_color, self.stroke_width)
def __init__(self, **kwargs): digest_config(self, kwargs) videos = [VideoIcon() for x in range(self.num_videos)] VGroup.__init__(self, *videos, **kwargs) self.arrange() self.set_width(FRAME_WIDTH - MED_LARGE_BUFF) self.set_color_by_gradient(*self.gradient_colors)
def __init__(self, values, **kwargs): VGroup.__init__(self, **kwargs) if self.max_value is None: self.max_value = max(values) self.add_axes() self.add_bars(values) self.center()
def __init__(self, **kwargs): possible_values = list(map(str, list(range(1, 11)))) + ["J", "Q", "K"] possible_suits = ["hearts", "diamonds", "spades", "clubs"] VGroup.__init__(self, *[ PlayingCard(value=value, suit=suit, **kwargs) for value in possible_values for suit in possible_suits ])
def __init__(self, stream_lines, **kwargs): VGroup.__init__(self, **kwargs) self.stream_lines = stream_lines for line in stream_lines: line.anim = self.line_anim_class(line, **self.line_anim_config) line.anim.begin() line.time = -self.lag_range * random.random() self.add(line.anim.mobject) self.add_updater(lambda m, dt: m.update(dt))
def __init__(self, *vertices, **kwargs): VGroup.__init__(self, **kwargs) self.lines, self.dots = VGroup(plot_depth=1), VGroup(plot_depth=1) self.poly=Polygon(*vertices, fill_color=self.fill_color, fill_opacity=self.fill_opacity, plot_depth=0).set_stroke(width=0) self.add(self.poly, self.lines, self.dots) n = len(vertices) for i in range(n): self.lines.add(Line(vertices[i], vertices[(i+1) % n], color=self.stroke_color, stroke_width=self.stroke_width)) self.dots.add(Dot(vertices[i], color=self.stroke_color).set_height(self.stroke_width/100)) for dot in self.dots: dot.add_updater(lambda d: d.set_height(self.stroke_width/100))
def __init__(self, **kwargs): circle = Circle() ticks = [] for x in range(12): alpha = x / 12. point = complex_to_R3(np.exp(2 * np.pi * alpha * complex(0, 1))) length = 0.2 if x % 3 == 0 else 0.1 ticks.append(Line(point, (1 - length) * point)) self.hour_hand = Line(ORIGIN, 0.3 * UP) self.minute_hand = Line(ORIGIN, 0.6 * UP) # for hand in self.hour_hand, self.minute_hand: # #Balance out where the center is # hand.add(VectorizedPoint(-hand.get_end())) VGroup.__init__(self, circle, self.hour_hand, self.minute_hand, *ticks)
def __init__(self, **kwargs): VGroup.__init__(self, **kwargs) self.x_axis = self.create_axis( self.x_min, self.x_max, self.x_axis_config ) self.y_axis = self.create_axis( self.y_min, self.y_max, self.y_axis_config ) self.y_axis.rotate(90 * DEGREES, about_point=ORIGIN) # Add as a separate group incase various other # mobjects are added to self, as for example in # NumberPlane below self.axes = VGroup(self.x_axis, self.y_axis) self.add(*self.axes) self.shift(self.center_point)
def __init__(self, func, **kwargs): VGroup.__init__(self, **kwargs) self.func = func self.rgb_gradient_function = get_rgb_gradient_function( self.min_magnitude, self.max_magnitude, self.colors, flip_alphas=False) x_range = np.arange(self.x_min, self.x_max + self.delta_x, self.delta_x) y_range = np.arange(self.y_min, self.y_max + self.delta_y, self.delta_y) for x, y in it.product(x_range, y_range): point = x * RIGHT + y * UP self.add(self.get_vector(point)) self.set_opacity(self.opacity)
def __init__(self, stream_lines, **kwargs): if not hasattr(self, "args"): self.args = serialize_args([stream_lines]) if not hasattr(self, "config"): self.config = serialize_config({ **kwargs, }) VGroup.__init__(self, **kwargs) self.stream_lines = stream_lines for line in stream_lines: line.anim = self.line_anim_class(line, **self.line_anim_config) line.anim.begin() line.time = -self.lag_range * random.random() self.add(line.anim.mobject) self.add_updater(lambda m, dt: m.update(dt))
def __init__(self, x_range=None, y_range=None, **kwargs): VGroup.__init__(self, **kwargs) self.x_axis = self.create_axis( x_range or self.x_range, self.x_axis_config, self.width, ) self.y_axis = self.create_axis(y_range or self.y_range, self.y_axis_config, self.height) self.y_axis.rotate(90 * DEGREES, about_point=ORIGIN) # Add as a separate group in case various other # mobjects are added to self, as for example in # NumberPlane below self.axes = VGroup(self.x_axis, self.y_axis) self.add(*self.axes) self.center()
def __init__(self, point, strs, offset=[0, 0, 0], height=None, color=None, mobj=1): VGroup.__init__(self) if isinstance(mobj, (int, float, bool)): if int(mobj) == 1: self.add(GeomPoint(point)) else: self.add(GeomMark(point)) self.add( TextMobject(strs, height=height).move_to(point, offset=offset).set_color(color))
def __init__(self, func, **kwargs): if not hasattr(self, "args"): self.args = serialize_args([func]) if not hasattr(self, "config"): self.config = serialize_config({ **kwargs, }) VGroup.__init__(self, **kwargs) self.func = func dt = self.dt start_points = self.get_start_points( **self.start_points_generator_config) for point in start_points: points = [point] for t in np.arange(0, self.virtual_time, dt): last_point = points[-1] points.append(last_point + dt * func(last_point)) if get_norm(last_point) > self.cutoff_norm: break line = VMobject() step = max(1, int(len(points) / self.n_anchors_per_line)) line.set_points_smoothly(points[::step]) self.add(line) self.set_stroke(self.stroke_color, self.stroke_width) if self.color_by_arc_length: len_to_rgb = get_rgb_gradient_function( self.min_arc_length, self.max_arc_length, colors=self.colors, ) for line in self: arc_length = line.get_arc_length() rgb = len_to_rgb([arc_length])[0] color = rgb_to_color(rgb) line.set_color(color) elif self.color_by_magnitude: image_file = get_color_field_image_file( lambda p: get_norm(func(p)), min_value=self.min_magnitude, max_value=self.max_magnitude, colors=self.colors, ) self.color_using_background_image(image_file)
def __init__(self, *text, **config): Container.__init__(self, **config) self.lines_list = list(text) self.lines = [] self.lines.append([]) for line_no in range(self.lines_list.__len__()): if "\n" in self.lines_list[line_no]: self.lines_list[line_no:line_no + 1] = self.lines_list[line_no].split("\n") for line_no in range(self.lines_list.__len__()): self.lines[0].append(TextWithFixHeight(self.lines_list[line_no], **config)) self.char_height = TextWithFixHeight("(", **config).get_height() self.lines.append([]) self.lines[1].extend([self.alignment for _ in range(self.lines_list.__len__())]) self.lines[0][0].move_to(np.array([0, 0, 0])) self.align_lines() VGroup.__init__(self, *[self.lines[0][i] for i in range(self.lines[0].__len__())], **config) self.move_to(np.array([0, 0, 0]))
def __init__(self, texmob, **kwargs): self.texmob = texmob self.anim_controller = ValueTracker(0.) VGroup.__init__( self, *[ self.texmob[i][j] for i in range(len(self.texmob)) for j in range(len(self.texmob[i])) ], **kwargs) self.submob_pos = [mob.get_center() for mob in self] self.submob_size = [mob.get_height() for mob in self] if self.change_opacity: self.submob_opacity = [self.init_opacity for mob in self] else: self.submob_opacity = [1 for mob in self] # self.get_new_ratefunc() self.activate_anim()
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, mob_or_points, **kwargs): VGroup.__init__(self, **kwargs) if type(mob_or_points) == list: self.shape = Polygon(*mob_or_points, stroke_width=0, plot_depth=-1) else: self.shape = mob_or_points.set_stroke(width=0) self.shape.set_fill(color=self.shadow_color, opacity=self.shadow_opacity * (1 if self.show_basic_shape else 0)).scale(self.scale_factor) self.blur_outline = VGroup() s = (self.shape.get_height() + self.shape.get_width())/2 if self.blur_width > 1e-4: for i in range(self.layer_num): layer_i = self.shape.copy().set_stroke(color=self.shadow_color, width=100 * self.blur_width/self.layer_num, opacity=self.shadow_opacity * (1-self.rate_func(i/self.layer_num))).\ set_fill(opacity=0).scale((s + (1 if self.shadow_out else -1) * self.blur_width/self.layer_num * (i+0.5))/ s).set_plot_depth(-2) self.blur_outline.add(layer_i) self.add(self.shape, self.blur_outline)
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 __init__(self, *functiongraphs, **kwargs): VGroup.__init__(self, **kwargs) functionsgraphs = [] # self.add(exec("FunctionGraph("+functiongraphs[0]+")")) [ exec( "functionsgraphs.append(FunctionGraph(" + functiongraph + "))", { "functionsgraphs": functionsgraphs, "FunctionGraph": FunctionGraph }) for functiongraph in functiongraphs ] vmobject = VMobject() [ vmobject.append_vectorized_mobject(functionsgraph) for functionsgraph in functionsgraphs ] self.add(vmobject)
def __init__(self, init_loc=ORIGIN, **kwargs): VGroup.__init__(self, **kwargs) self.point = Dot(init_loc, color=self.point_color).set_height(self.size) self.value_x = DecimalNumber( 0, color=self.coordinates_color, num_decimal_places=self.num_decimal_places).scale( self.coordinates_scale) self.value_y = DecimalNumber( 0, color=self.coordinates_color, num_decimal_places=self.num_decimal_places).scale( self.coordinates_scale) text = TexMobject('(', ',', ')').scale(self.coordinates_scale) self.coordinates_text = VGroup(text[0], self.value_x, text[1], self.value_y, text[2]) self.coordinates_text.add_updater(self.update_coordinates_text) self.add(self.point)
def __init__(self, func, **kwargs): VGroup.__init__(self, **kwargs) self.func = func dt = self.dt start_points = self.get_start_points( **self.start_points_generator_config ) for point in start_points: points = [point] for t in np.arange(0, self.virtual_time, dt): last_point = points[-1] points.append(last_point + dt * func(last_point)) if get_norm(last_point) > self.cutoff_norm: break line = VMobject() step = max(1, int(len(points) / self.n_anchors_per_line)) line.set_points_smoothly(points[::step]) self.add(line) self.set_stroke(self.stroke_color, self.stroke_width) if self.color_by_arc_length: len_to_rgb = get_rgb_gradient_function( self.min_arc_length, self.max_arc_length, colors=self.colors, ) for line in self: arc_length = line.get_arc_length() rgb = len_to_rgb([arc_length])[0] color = rgb_to_color(rgb) line.set_color(color) elif self.color_by_magnitude: image_file = get_color_field_image_file( lambda p: get_norm(func(p)), min_value=self.min_magnitude, max_value=self.max_magnitude, colors=self.colors, ) self.color_using_background_image(image_file)
def __init__(self, mobject, count=1, posratio=0.5, width=4, length=0.3, color=GOLD, opacity=1, space=0.07, *args, **kwargs): VGroup.__init__(self, **kwargs) if isinstance(mobject, VGroup): numofcurves = len(mobject.submobjects) def func(i): return mobject.submobjects[i] else: numofcurves = mobject.get_num_curves() def func(i): return CurveLine(mobject, i) if isinstance(count, int): def number(i): return count elif callable(count): def number(i): return count(i)+1 kwargs["dimhash"] = self.dimhash [self.add(Hash(func(i), number(i), posratio=posratio, length=length, space=space, *args, **kwargs)) for i in range(numofcurves)]
def __init__(self, **kwargs): if not hasattr(self, "args"): self.args = serialize_args([]) if not hasattr(self, "config"): self.config = serialize_config({ **kwargs, }) circle = Circle(color=WHITE) ticks = [] for x in range(12): alpha = x / 12. point = complex_to_R3(np.exp(2 * np.pi * alpha * complex(0, 1))) length = 0.2 if x % 3 == 0 else 0.1 ticks.append(Line(point, (1 - length) * point)) self.hour_hand = Line(ORIGIN, 0.3 * UP) self.minute_hand = Line(ORIGIN, 0.6 * UP) # for hand in self.hour_hand, self.minute_hand: # #Balance out where the center is # hand.add(VectorizedPoint(-hand.get_end())) VGroup.__init__(self, circle, self.hour_hand, self.minute_hand, *ticks)
def __init__(self, func, **kwargs): if not hasattr(self, "args"): self.args = serialize_args([func]) if not hasattr(self, "config"): self.config = serialize_config({ **kwargs, }) VGroup.__init__(self, **kwargs) self.func = func self.rgb_gradient_function = get_rgb_gradient_function( self.min_magnitude, self.max_magnitude, self.colors, flip_alphas=False) x_range = np.arange(self.x_min, self.x_max + self.delta_x, self.delta_x) y_range = np.arange(self.y_min, self.y_max + self.delta_y, self.delta_y) for x, y in it.product(x_range, y_range): point = x * RIGHT + y * UP self.add(self.get_vector(point)) self.set_opacity(self.opacity)
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 __init__(self, **kwargs): VGroup.__init__(self, **kwargs) x_axis_config = merge_config([ self.x_axis_config, { "x_min": self.x_min, "x_max": self.x_min }, self.number_line_config, ]) y_axis_config = merge_config([ self.y_axis_config, { "x_min": self.y_min, "x_max": self.y_min }, self.number_line_config, ]) self.x_axis = NumberLine(**x_axis_config) self.y_axis = NumberLine(**y_axis_config) self.y_axis.rotate(90 * DEGREES, about_point=ORIGIN) self.add(self.x_axis, self.y_axis)
def __init__(self, func, **kwargs): VGroup.__init__(self, **kwargs) self.func = func self.rgb_gradient_function = get_rgb_gradient_function( self.min_magnitude, self.max_magnitude, self.colors, flip_alphas=False ) x_range = np.arange( self.x_min, self.x_max + self.delta_x, self.delta_x ) y_range = np.arange( self.y_min, self.y_max + self.delta_y, self.delta_y ) for x, y in it.product(x_range, y_range): point = x * RIGHT + y * UP self.add(self.get_vector(point)) self.set_opacity(self.opacity)
def __init__(self, **kwargs): circle = Circle(color=WHITE) ticks = [] for x in range(12): alpha = x / 12. point = complex_to_R3( np.exp(2 * np.pi * alpha * complex(0, 1)) ) length = 0.2 if x % 3 == 0 else 0.1 ticks.append( Line(point, (1 - length) * point) ) self.hour_hand = Line(ORIGIN, 0.3 * UP) self.minute_hand = Line(ORIGIN, 0.6 * UP) # for hand in self.hour_hand, self.minute_hand: # #Balance out where the center is # hand.add(VectorizedPoint(-hand.get_end())) VGroup.__init__( self, circle, self.hour_hand, self.minute_hand, *ticks )
def __init__(self, **kwargs): #### EULERTOUR_INIT_START #### if not hasattr(self, "args"): self.args = serialize_args([]) if not hasattr(self, "config"): self.config = serialize_config({ **kwargs, }) #### EULERTOUR_INIT_START #### VGroup.__init__(self, **kwargs) self.x_axis = self.create_axis( self.x_min, self.x_max, self.x_axis_config ) self.y_axis = self.create_axis( self.y_min, self.y_max, self.y_axis_config ) self.y_axis.rotate(90 * DEGREES, about_point=ORIGIN) # Add as a separate group incase various other # mobjects are added to self, as for example in # NumberPlane below self.axes = VGroup(self.x_axis, self.y_axis) self.add(*self.axes) self.shift(self.center_point)
def __init__(self, mob, **kwargs): VGroup.__init__(self, **kwargs) if self.dashed == True: medicion = DashedLine( ORIGIN, mob.get_length() * RIGHT, dashed_segment_length=self.dashed_segment_length).set_color( self.color) else: medicion = Line(ORIGIN, mob.get_length() * RIGHT) medicion.set_stroke(None, self.stroke) pre_medicion = Line(ORIGIN, self.lateral * RIGHT).rotate(PI / 2).set_stroke( None, self.stroke) pos_medicion = pre_medicion.copy() pre_medicion.move_to(medicion.get_start()) pos_medicion.move_to(medicion.get_end()) angulo = mob.get_angle() matriz_rotacion = rotation_matrix(PI / 2, OUT) vector_unitario = mob.get_unit_vector() direccion = np.matmul(matriz_rotacion, vector_unitario) self.direccion = direccion self.add(medicion, pre_medicion, pos_medicion) self.rotate(angulo) self.move_to(mob) if self.invert == True: self.shift(-direccion * self.buff) else: self.shift(direccion * self.buff) self.set_color(self.color) self.tip_point_index = -np.argmin(self.get_all_points()[-1, :])
def __init__( self, reactants: List[ChemObject] = [], products: List[ChemObject] = [], **arrow_kwargs, ): digest_config(self, arrow_kwargs) arrow = ChemArrow( self._type, self.length, self.angle, self.style, self.text_up, self.text_down, ) r = self.get_side_of_equation(reactants) p = self.get_side_of_equation(products) self.set_same_height_for_all_mobjects(r) self.set_same_height_for_all_mobjects(p) self.set_same_height_for_all_mobjects([VGroup(*r), arrow, VGroup(*p)]) VGroup.__init__(*[*r, arrow, *p])
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)
def __init__(self, key=None, **kwargs): VGroup.__init__(self, key=key, **kwargs)
def __init__(self, func, **kwargs): VGroup.__init__(self, **kwargs) self.setup_in_uv_space() self.apply_function(lambda p: func(p[0], p[1])) if self.should_make_jagged: self.make_jagged()
def __init__(self, key=None, **kwargs): VGroup.__init__(self, key=key, **kwargs)
def __init__(self, **kwargs): VGroup.__init__(self, **kwargs) self.x_axis = self.get_axis(self.x_min, self.x_max, self.x_axis_config) self.y_axis = self.get_axis(self.y_min, self.y_max, self.y_axis_config) self.y_axis.rotate(np.pi / 2, about_point=ORIGIN) self.add(self.x_axis, self.y_axis)
def __init__(self, func, **kwargs): VGroup.__init__(self, **kwargs) self.setup_in_uv_space() self.apply_function(lambda p: func(p[0], p[1])) if self.should_make_jagged: self.make_jagged()
def __init__(self, vmobj,reverse=False, **kwargs): VGroup.__init__(self, reverse=False,**kwargs) [self.add(CurveLine(vmobj,i)) for i in range(vmobj.get_num_curves())]
def __init__(self, file_name=None, **kwargs): Container.__init__(self, **kwargs) self.file_name = file_name or self.file_name self.ensure_valid_file() self.style = self.style.lower() self.gen_html_string() strati = self.html_string.find("background:") self.background_color = self.html_string[strati + 12:strati + 19] self.gen_code_json() self.code = self.gen_colored_lines() if self.insert_line_no: self.line_numbers = self.gen_line_numbers() self.line_numbers.next_to(self.code, direction=LEFT, buff=self.line_no_buff) if self.background == "rectangle": if self.insert_line_no: forground = VGroup(self.code, self.line_numbers) else: forground = self.code self.background_mobject = SurroundingRectangle( forground, buff=self.margin, color=self.background_color, fill_color=self.background_color, stroke_width=0, fill_opacity=1, ) self.background_mobject.round_corners(self.corner_radius) else: if self.insert_line_no: forground = VGroup(self.code, self.line_numbers) else: forground = self.code height = forground.get_height() + 0.1 * 3 + 2 * self.margin width = forground.get_width() + 0.1 * 3 + 2 * self.margin rrect = RoundedRectangle(corner_radius=self.corner_radius, height=height, width=width, stroke_width=0, color=self.background_color, fill_opacity=1) red_button = Dot(radius=0.1, stroke_width=0, color='#ff5f56') red_button.shift(LEFT * 0.1 * 3) yellow_button = Dot(radius=0.1, stroke_width=0, color='#ffbd2e') green_button = Dot(radius=0.1, stroke_width=0, color='#27c93f') green_button.shift(RIGHT * 0.1 * 3) buttons = VGroup(red_button, yellow_button, green_button) buttons.shift( UP * (height / 2 - 0.1 * 2 - 0.05) + LEFT * (width / 2 - 0.1 * 5 - self.corner_radius / 2 - 0.05)) self.background_mobject = VGroup(rrect, buttons) x = (height - forground.get_height()) / 2 - 0.1 * 3 self.background_mobject.shift(forground.get_center()) self.background_mobject.shift(UP * x) if self.insert_line_no: VGroup.__init__(self, self.background_mobject, self.line_numbers, *self.code, **kwargs) else: VGroup.__init__(self, self.background_mobject, Dot(fill_opacity=0, stroke_opacity=0), *self.code, **kwargs) self.move_to(np.array([0, 0, 0]))
def __init__(self, **kwargs): VGroup.__init__(self, **kwargs) self.setup() self.setup_axes() self.center()