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 func(alpha):
return interpolate(start_number, target_number, alpha)
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 interpolate_color(color1, color2, alpha):
rgb = interpolate(color_to_rgb(color1), color_to_rgb(color2), alpha)
return rgb_to_color(rgb)
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)
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
