def update_submobject(self, submobject, starting_submobject, alpha): submobject.set_stroke( width=interpolate(0, starting_submobject.get_stroke_width(), alpha) ) submobject.set_fill( opacity=interpolate(0, starting_submobject.get_fill_opacity(), alpha) )
def update_submobject(self, submobject, starting_submobject, alpha): submobject.pointwise_become_partial( starting_submobject, 0, min(2 * alpha, 1) ) if alpha < 0.5: if self.stroke_color: color = self.stroke_color elif starting_submobject.stroke_width > 0: color = starting_submobject.get_stroke_color() else: color = starting_submobject.get_color() submobject.set_stroke(color, width=self.stroke_width) submobject.set_fill(opacity=0) else: if not self.reached_halfway_point_before: self.reached_halfway_point_before = True submobject.points = np.array(starting_submobject.points) width, opacity = [ interpolate(start, end, 2 * alpha - 1) for start, end in [ (self.stroke_width, starting_submobject.get_stroke_width()), (0, starting_submobject.get_fill_opacity()) ] ] submobject.set_stroke(width=width) submobject.set_fill(opacity=opacity)
def fade_to_no_recurse(self, color, alpha): if self.get_num_points() > 0: start = color_to_rgb(self.get_color()) end = color_to_rgb(color) new_rgb = interpolate(start, end, alpha) self.set_color(Color(rgb=new_rgb), family=False) return self
def random_bright_color(): color = random_color() curr_rgb = color_to_rgb(color) new_rgb = interpolate( curr_rgb, np.ones(len(curr_rgb)), 0.5 ) return Color(rgb=new_rgb)
def set_points_as_corners(self, points): if len(points) <= 1: return self points = np.array(points) self.set_anchors_and_handles(points, *[ interpolate(points[:-1], points[1:], alpha) for alpha in 1. / 3, 2. / 3 ]) return self
def update_submobject(self, submobject, starting_sumobject, alpha): submobject.points[:, :] = starting_sumobject.points submobject.scale( interpolate(1, self.scale_value, there_and_back(alpha)), about_point=self.scale_about_point ) submobject.rotate( wiggle(alpha, self.n_wiggles) * self.rotation_angle, about_point=self.rotate_about_point )
def set_colors_by_radial_gradient(self, center=None, radius=1, inner_color=WHITE, outer_color=BLACK): start_rgba, end_rgba = map(color_to_rgba, [start_color, end_color]) if center is None: center = self.get_center() for mob in self.family_members_with_points(): num_points = mob.get_num_points() t = min(1, np.abs(mob.get_center() - center) / radius) mob.rgbas = np.array( [interpolate(start_rgba, end_rgba, t)] * num_points ) return self
def add_line(self, start, end, color=None): start, end = map(np.array, [start, end]) length = np.linalg.norm(end - start) if length == 0: points = [start] else: epsilon = self.epsilon / length points = [ interpolate(start, end, t) for t in np.arange(0, 1, epsilon) ] self.add_points(points, color=color)
def generate_points(self): arc1 = Arc( angle=self.angle, start_angle=self.start_angle, radius=self.inner_radius, ) arc2 = Arc( angle=-1 * self.angle, start_angle=self.start_angle + self.angle, radius=self.outer_radius, ) a1_to_a2_points = np.array([ interpolate(arc1.points[-1], arc2.points[0], alpha) for alpha in np.linspace(0, 1, 4) ]) a2_to_a1_points = np.array([ interpolate(arc2.points[-1], arc1.points[0], alpha) for alpha in np.linspace(0, 1, 4) ]) self.points = np.array(arc1.points) self.add_control_points(a1_to_a2_points[1:]) self.add_control_points(arc2.points[1:]) self.add_control_points(a2_to_a1_points[1:])
def color_gradient(reference_colors, length_of_output): if length_of_output == 0: return reference_colors[0] rgbs = map(color_to_rgb, reference_colors) alphas = np.linspace(0, (len(rgbs) - 1), length_of_output) floors = alphas.astype('int') alphas_mod1 = alphas % 1 # End edge case alphas_mod1[-1] = 1 floors[-1] = len(rgbs) - 2 return [ rgb_to_color(interpolate(rgbs[i], rgbs[i + 1], alpha)) for i, alpha in zip(floors, alphas_mod1) ]
def set_color_by_gradient(self, *colors): self.rgbas = np.array(map( color_to_rgba, color_gradient(colors, len(self.points)) )) return self start_rgba, end_rgba = 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 interpolate_color(self, mobject1, mobject2, alpha): attrs = [ "stroke_rgb", "stroke_width", "fill_rgb", "fill_opacity", ] for attr in attrs: setattr(self, attr, interpolate( getattr(mobject1, attr), getattr(mobject2, attr), alpha )) if alpha == 1.0: # print getattr(mobject2, attr) setattr(self, attr, getattr(mobject2, attr))
def generate_points(self): length = np.linalg.norm(self.end - self.start) if length == 0: self.add(Line(self.start, self.end)) return self num_interp_points = int(length / self.dashed_segment_length) # Even number ensures that start and end points are hit if num_interp_points % 2 == 1: num_interp_points += 1 points = [ interpolate(self.start, self.end, alpha) for alpha in np.linspace(0, 1, num_interp_points) ] includes = it.cycle([True, False]) self.submobjects = [ Line(p1, p2, **self.init_kwargs) for p1, p2, include in zip(points, points[1:], includes) if include ] self.put_start_and_end_on_with_projection(self.start, self.end) return self
def fractalification_iteration(vmobject, dimension=1.05, num_inserted_anchors_range=range(1, 4)): num_points = vmobject.get_num_points() if num_points > 0: # original_anchors = vmobject.get_anchors() original_anchors = [ vmobject.point_from_proportion(x) for x in np.linspace(0, 1 - 1. / num_points, num_points) ] new_anchors = [] for p1, p2, in zip(original_anchors, original_anchors[1:]): num_inserts = random.choice(num_inserted_anchors_range) inserted_points = [ interpolate(p1, p2, alpha) for alpha in np.linspace(0, 1, num_inserts + 2)[1:-1] ] mass_scaling_factor = 1. / (num_inserts + 1) length_scaling_factor = mass_scaling_factor**(1. / dimension) target_length = np.linalg.norm(p1 - p2) * length_scaling_factor curr_length = np.linalg.norm(p1 - p2) * mass_scaling_factor # offset^2 + curr_length^2 = target_length^2 offset_len = np.sqrt(target_length**2 - curr_length**2) unit_vect = (p1 - p2) / np.linalg.norm(p1 - p2) offset_unit_vect = rotate_vector(unit_vect, np.pi / 2) inserted_points = [ point + u * offset_len * offset_unit_vect for u, point in zip(it.cycle([-1, 1]), inserted_points) ] new_anchors += [p1] + inserted_points new_anchors.append(original_anchors[-1]) vmobject.set_points_as_corners(new_anchors) vmobject.submobjects = [ fractalification_iteration( submob, dimension, num_inserted_anchors_range) for submob in vmobject.submobjects ] return vmobject
def func(alpha): return interpolate(start_number, target_number, alpha)
def parameterized_function(alpha): x = interpolate(x_min, x_max, alpha) y = func(x) if not np.isfinite(y): y = self.y_max return self.coords_to_point(x, y)
def __init__(self, decimal_number_mobject, target_number, **kwargs): start_number = decimal_number_mobject.number func = lambda alpha: interpolate(start_number, target_number, alpha) ChangingDecimal.__init__(self, decimal_number_mobject, func, **kwargs)
def interpolate_color(self, mobject1, mobject2, alpha): assert (mobject1.pixel_array.shape == mobject2.pixel_array.shape) self.pixel_array = interpolate(mobject1.pixel_array, mobject2.pixel_array, alpha).astype(self.pixel_array_dtype)
def random_bright_color(): color = random_color() curr_rgb = color_to_rgb(color) new_rgb = interpolate(curr_rgb, np.ones(len(curr_rgb)), 0.5) return Color(rgb=new_rgb)
def fade_to(self, color, alpha): self.rgbas = interpolate(self.rgbas, color_to_rgba(color), alpha) for mob in self.submobjects: mob.fade_to(color, alpha) return self
def update_submobject(self, submobject, starting_submobject, alpha): submobject.set_stroke(opacity=interpolate( 0, starting_submobject.get_stroke_opacity(), alpha)) submobject.set_fill(opacity=interpolate( 0, starting_submobject.get_fill_opacity(), alpha))
def interpolate_color(self, mobject1, mobject2, alpha): self.rgbas = interpolate( mobject1.rgbas, mobject2.rgbas, alpha )
def interpolate_color(color1, color2, alpha): rgb = interpolate(color_to_rgb(color1), color_to_rgb(color2), alpha) return rgb_to_color(rgb)
def number_to_point(self, number): alpha = float(number - self.x_min) / (self.x_max - self.x_min) return interpolate(self.main_line.get_start(), self.main_line.get_end(), alpha)
def interpolate_color(self, mobject1, mobject2, alpha): assert(mobject1.pixel_array.shape == mobject2.pixel_array.shape) self.pixel_array = interpolate( mobject1.pixel_array, mobject2.pixel_array, alpha ).astype(self.pixel_array_dtype)
def interpolate_color(self, mobject1, mobject2, alpha): self.rgbas = interpolate(mobject1.rgbas, mobject2.rgbas, alpha)
def place_labels(self, new_labels, **kwargs): dic = kwargs.get("dic", OrderedDict()) label_location = dic.get("label_location", 0.5) label_side = dic.get("label_side", Side.CLOCKWISE) start, end = self.mobject.get_start_and_end() vec = start - end vec = vec / numpy.linalg.norm(vec) if label_side == Side.CLOCKWISE: vec = rotate_vector(vec, numpy.pi / 2) else: vec = rotate_vector(vec, 3 * numpy.pi / 2) buff = const.MED_SMALL_BUFF \ if self.mobject.curved \ else const.SMALL_BUFF last_mobject = None old_label_copies = OrderedDict() # move initially existing labels for name, label in self.labels.items(): if name in new_labels: # move the new label into place if last_mobject: new_labels[name].next_to(last_mobject, const.RIGHT, buff=buff) else: new_labels[name].next_to(interpolate( start, end, label_location), vec, buff=buff) else: # move the old label into place if last_mobject: old_label_copies[name] = label.copy().next_to(last_mobject, const.RIGHT, buff=buff) else: old_label_copies[name] = label.copy().next_to(interpolate( start, end, label_location), vec, buff=buff) last_mobject = label # move newly added labels into place for name, label in new_labels.items(): if name in self.labels: pass else: if last_mobject: label.next_to(last_mobject, const.RIGHT, buff=buff) else: label.next_to(interpolate(start, end, label_location), vec, buff=buff) last_mobject = label ordered_labels = OrderedDict() for key in self.labels: if key in new_labels: ordered_labels[key] = new_labels[key] else: ordered_labels[key] = old_label_copies[key] for key in new_labels: if key not in self.labels: ordered_labels[key] = new_labels[key] new_labels = ordered_labels return new_labels
def add_spikes(self): layers = VGroup() radii = np.linspace( self.outer_radius, self.pupil_radius, self.n_spike_layers, endpoint=False, ) radii[:2] = radii[1::-1] # Swap first two radii[-1] = interpolate(radii[-1], self.pupil_radius, 0.25) for radius in radii: tip_angle = self.spike_angle half_base = radius * np.tan(tip_angle) triangle, right_half_triangle = [ Polygon( radius * UP, half_base * RIGHT, vertex3, fill_opacity=1, stroke_width=0, ) for vertex3 in ( half_base * LEFT, ORIGIN, ) ] left_half_triangle = right_half_triangle.copy() left_half_triangle.flip(UP, about_point=ORIGIN) n_spikes = self.n_spikes full_spikes = [ triangle.copy().rotate(-angle, about_point=ORIGIN) for angle in np.linspace(0, TAU, n_spikes, endpoint=False) ] index = (3 * n_spikes) // 4 if radius == radii[0]: layer = VGroup(*full_spikes) layer.rotate(-TAU / n_spikes / 2, about_point=ORIGIN) layer.brown_index = index else: half_spikes = [ right_half_triangle.copy(), left_half_triangle.copy().rotate( 90 * DEGREES, about_point=ORIGIN, ), right_half_triangle.copy().rotate( 90 * DEGREES, about_point=ORIGIN, ), left_half_triangle.copy() ] layer = VGroup(*it.chain( half_spikes[:1], full_spikes[1:index], half_spikes[1:3], full_spikes[index + 1:], half_spikes[3:], )) layer.brown_index = index + 1 layers.add(layer) # Color spikes blues = self.blue_spike_colors browns = self.brown_spike_colors for layer, blue, brown in zip(layers, blues, browns): index = layer.brown_index layer[:index].set_color(blue) layer[index:].set_color(brown) self.spike_layers = layers self.add(layers)