A community-maintained Python framework for creating mathematical animations.
Changed all files to (mostly) conform to PEP8
Grant Sandersond4392de6000e
diff --git a/animation/animation.py b/animation/animation.pyindex 4625a7be8..8d2812198 100644--- a/animation/animation.py+++ b/animation/animation.py@@ -7,28 +7,30 @@ from utils.rate_functions import smoothfrom utils.config_ops import instantiatefrom utils.config_ops import digest_config+class Animation(object):CONFIG = {- "run_time" : DEFAULT_ANIMATION_RUN_TIME,- "rate_func" : smooth,- "name" : None,- #Does this animation add or remove a mobject form the screen- "remover" : False,- #Options are lagged_start, smoothed_lagged_start,- #one_at_a_time, all_at_once- "submobject_mode" : "all_at_once",- "lag_factor" : 2,+ "run_time": DEFAULT_ANIMATION_RUN_TIME,+ "rate_func": smooth,+ "name": None,+ # Does this animation add or remove a mobject form the screen+ "remover": False,+ # Options are lagged_start, smoothed_lagged_start,+ # one_at_a_time, all_at_once+ "submobject_mode": "all_at_once",+ "lag_factor": 2,# Used by EmptyAnimation to announce itself ignorable# in Successions and AnimationGroups- "empty" : False+ "empty": False}+def __init__(self, mobject, **kwargs):mobject = instantiate(mobject)assert(isinstance(mobject, Mobject))digest_config(self, kwargs, locals())self.starting_mobject = self.mobject.copy()if self.rate_func is None:- self.rate_func = (lambda x : x)+ self.rate_func = (lambda x: x)if self.name is None:self.name = self.__class__.__name__ + str(self.mobject)self.all_families_zipped = self.get_all_families_zipped()@@ -37,7 +39,7 @@ class Animation(object):def update_config(self, **kwargs):digest_config(self, kwargs)if "rate_func" in kwargs and kwargs["rate_func"] is None:- self.rate_func = (lambda x : x)+ self.rate_func = (lambda x: x)return selfdef __str__(self):@@ -58,13 +60,13 @@ class Animation(object):return selfdef update_submobject(self, submobject, starting_sumobject, alpha):- #Typically ipmlemented by subclass+ # Typically ipmlemented by subclasspassdef get_all_mobjects(self):"""Ordering must match the ording of arguments to update_submobject- """+ """return self.mobject, self.starting_mobjectdef get_all_families_zipped(self):@@ -75,15 +77,15 @@ class Animation(object):def get_sub_alpha(self, alpha, index, num_submobjects):if self.submobject_mode in ["lagged_start", "smoothed_lagged_start"]:- prop = float(index)/num_submobjects+ prop = float(index) / num_submobjectsif self.submobject_mode is "smoothed_lagged_start":prop = smooth(prop)lf = self.lag_factor- return np.clip(lf*alpha - (lf-1)*prop, 0, 1)+ return np.clip(lf * alpha - (lf - 1) * prop, 0, 1)elif self.submobject_mode == "one_at_a_time":- lower = float(index)/num_submobjects- upper = float(index+1)/num_submobjects- return np.clip((alpha-lower)/(upper-lower), 0, 1)+ lower = float(index) / num_submobjects+ upper = float(index + 1) / num_submobjects+ return np.clip((alpha - lower) / (upper - lower), 0, 1)elif self.submobject_mode == "all_at_once":return alpharaise Exception("Invalid submobject mode")@@ -101,7 +103,8 @@ class Animation(object):def set_rate_func(self, rate_func):if rate_func is None:- rate_func = lambda x : x+ def rate_func(x):+ return xself.rate_func = rate_funcreturn self@@ -115,7 +118,7 @@ class Animation(object):def is_remover(self):return self.remover- def clean_up(self, surrounding_scene = None):+ def clean_up(self, surrounding_scene=None):self.update(1)if surrounding_scene is not None:if self.is_remover():@@ -123,16 +126,3 @@ class Animation(object):else:surrounding_scene.add(self.mobject)return self-------------diff --git a/animation/composition.py b/animation/composition.pyindex f05aeb64e..f5d24d341 100644--- a/animation/composition.py+++ b/animation/composition.py@@ -14,25 +14,28 @@ from utils.bezier import inverse_interpolatefrom utils.config_ops import digest_configfrom utils.rate_functions import squish_rate_func+class EmptyAnimation(Animation):CONFIG = {- "run_time" : 0,- "empty" : True+ "run_time": 0,+ "empty": True}def __init__(self, *args, **kwargs):return Animation.__init__(self, Group(), *args, **kwargs)+class Succession(Animation):CONFIG = {- "rate_func" : None,+ "rate_func": None,}+def __init__(self, *args, **kwargs):"""- Each arg will either be an animation, or an animation class- followed by its arguments (and potentially a dict for+ Each arg will either be an animation, or an animation class+ followed by its arguments (and potentially a dict forconfiguration).- For example,+ For example,Succession(ShowCreation(circle),Transform, circle, square,@@ -42,16 +45,17 @@ class Succession(Animation):"""animations = []state = {- "animations" : animations,- "curr_class" : None,- "curr_class_args" : [],- "curr_class_config" : {},+ "animations": animations,+ "curr_class": None,+ "curr_class_args": [],+ "curr_class_config": {},}+def invoke_curr_class(state):if state["curr_class"] is None:returnanim = state["curr_class"](- *state["curr_class_args"],+ *state["curr_class_args"],**state["curr_class_config"])state["animations"].append(anim)@@ -76,43 +80,47 @@ class Succession(Animation):for anim in animations:anim.update(0)- animations = filter (lambda x : not(x.empty), animations)+ animations = filter(lambda x: not(x.empty), animations)self.run_times = [anim.run_time for anim in animations]if "run_time" in kwargs:run_time = kwargs.pop("run_time")- warnings.warn("Succession doesn't currently support explicit run_time.")+ warnings.warn(+ "Succession doesn't currently support explicit run_time.")run_time = sum(self.run_times)self.num_anims = len(animations)if self.num_anims == 0:self.empty = Trueself.animations = animations- #Have to keep track of this run_time, because Scene.play- #might very well mess with it.+ # Have to keep track of this run_time, because Scene.play+ # might very well mess with it.self.original_run_time = run_time# critical_alphas[i] is the start alpha of self.animations[i]# critical_alphas[i + 1] is the end alpha of self.animations[i]critical_times = np.concatenate(([0], np.cumsum(self.run_times)))- self.critical_alphas = map (lambda x : np.true_divide(x, run_time), critical_times) if self.num_anims > 0 else [0.0]+ self.critical_alphas = map(lambda x: np.true_divide(+ x, run_time), critical_times) if self.num_anims > 0 else [0.0]# self.scene_mobjects_at_time[i] is the scene's mobjects at start of self.animations[i]# self.scene_mobjects_at_time[i + 1] is the scene mobjects at end of self.animations[i]self.scene_mobjects_at_time = [None for i in range(self.num_anims + 1)]self.scene_mobjects_at_time[0] = Group()for i in range(self.num_anims):- self.scene_mobjects_at_time[i + 1] = self.scene_mobjects_at_time[i].copy()+ self.scene_mobjects_at_time[i ++ 1] = self.scene_mobjects_at_time[i].copy()self.animations[i].clean_up(self.scene_mobjects_at_time[i + 1])self.current_alpha = 0- self.current_anim_index = 0 # If self.num_anims == 0, this is an invalid index, but so it goes+ # If self.num_anims == 0, this is an invalid index, but so it goes+ self.current_anim_index = 0if self.num_anims > 0:self.mobject = self.scene_mobjects_at_time[0]self.mobject.add(self.animations[0].mobject)else:self.mobject = Group()- Animation.__init__(self, self.mobject, run_time = run_time, **kwargs)+ Animation.__init__(self, self.mobject, run_time=run_time, **kwargs)# Beware: This does NOT take care of calling update(0) on the subanimation.# This was important to avoid a pernicious possibility in which subanimations were called@@ -120,7 +128,8 @@ class Succession(Animation):# continuing exponentially.def jump_to_start_of_anim(self, index):if index != self.current_anim_index:- self.mobject.remove(*self.mobject.submobjects) # Should probably have a cleaner "remove_all" method...+ # Should probably have a cleaner "remove_all" method...+ self.mobject.remove(*self.mobject.submobjects)self.mobject.add(*self.scene_mobjects_at_time[index].submobjects)self.mobject.add(self.animations[index].mobject)@@ -138,18 +147,18 @@ class Succession(Animation):returngt_alpha_iter = it.ifilter(- lambda i : self.critical_alphas[i+1] >= alpha,+ lambda i: self.critical_alphas[i + 1] >= alpha,range(self.num_anims))i = next(gt_alpha_iter, None)- if i == None:- # In this case, we assume what is happening is that alpha is 1.0,+ if i is None:+ # In this case, we assume what is happening is that alpha is 1.0,# but that rounding error is causing us to overshoot the end of# self.critical_alphas (which is also 1.0)if not abs(alpha - 1) < 0.001:warnings.warn(- "Rounding error not near alpha=1 in Succession.update_mobject," + \- "instead alpha = %f"%alpha+ "Rounding error not near alpha=1 in Succession.update_mobject," ++ "instead alpha = %f" % alpha)print self.critical_alphas, alphai = self.num_anims - 1@@ -158,8 +167,8 @@ class Succession(Animation):self.jump_to_start_of_anim(i)sub_alpha = inverse_interpolate(- self.critical_alphas[i],- self.critical_alphas[i + 1],+ self.critical_alphas[i],+ self.critical_alphas[i + 1],alpha)self.animations[i].update(sub_alpha)@@ -171,14 +180,16 @@ class Succession(Animation):for anim in self.animations:anim.clean_up(*args, **kwargs)+class AnimationGroup(Animation):CONFIG = {- "rate_func" : None+ "rate_func": None}+def __init__(self, *sub_anims, **kwargs):- sub_anims = filter (lambda x : not(x.empty), sub_anims)+ sub_anims = filter(lambda x: not(x.empty), sub_anims)digest_config(self, locals())- self.update_config(**kwargs) # Handles propagation to self.sub_anims+ self.update_config(**kwargs) # Handles propagation to self.sub_animsif len(sub_anims) == 0:self.empty = True@@ -198,7 +209,7 @@ class AnimationGroup(Animation):def update_config(self, **kwargs):Animation.update_config(self, **kwargs)-+# If AnimationGroup is called with any configuration,# it is propagated to the sub_animationsfor anim in self.sub_anims:@@ -206,30 +217,33 @@ class AnimationGroup(Animation):# Variants on mappin an animation over submobjectsg+class LaggedStart(Animation):CONFIG = {- "run_time" : 2,- "lag_ratio" : 0.5,+ "run_time": 2,+ "lag_ratio": 0.5,}- def __init__(self, AnimationClass, mobject, arg_creator = None, **kwargs):++ def __init__(self, AnimationClass, mobject, arg_creator=None, **kwargs):digest_config(self, kwargs)for key in "rate_func", "run_time", "lag_ratio":if key in kwargs:kwargs.pop(key)if arg_creator is None:- arg_creator = lambda mobject : (mobject,)+ def arg_creator(mobject):+ return (mobject,)self.subanimations = [AnimationClass(*arg_creator(submob),- run_time = self.run_time,- rate_func = squish_rate_func(+ run_time=self.run_time,+ rate_func=squish_rate_func(self.rate_func, beta, beta + self.lag_ratio),**kwargs)for submob, beta in zip(- mobject,- np.linspace(0, 1-self.lag_ratio, len(mobject))+ mobject,+ np.linspace(0, 1 - self.lag_ratio, len(mobject)))]Animation.__init__(self, mobject, **kwargs)@@ -243,6 +257,7 @@ class LaggedStart(Animation):for anim in self.subanimations:anim.clean_up(*args, **kwargs)+class ApplyToCenters(Animation):def __init__(self, AnimationClass, mobjects, **kwargs):full_kwargs = AnimationClass.CONFIG@@ -259,9 +274,8 @@ class ApplyToCenters(Animation):def update_mobject(self, alpha):self.centers_container.update_mobject(alpha)center_mobs = self.centers_container.mobject.split()- mobjects = self.mobject.split()+ mobjects = self.mobject.split()for center_mob, mobject in zip(center_mobs, mobjects):mobject.shift(- center_mob.get_center()-mobject.get_center()+ center_mob.get_center() - mobject.get_center())-diff --git a/animation/indication.py b/animation/indication.pyindex 0a4ad0913..5a6f1d4e5 100644--- a/animation/indication.py+++ b/animation/indication.py@@ -8,9 +8,7 @@ from animation.animation import Animationfrom animation.movement import Homotopyfrom animation.creation import ShowPartialfrom animation.transform import Transform-from mobject.mobject import Groupfrom mobject.mobject import Mobject-from mobject.types.vectorized_mobject import VMobjectfrom mobject.geometry import Circlefrom mobject.geometry import Dotfrom utils.config_ops import digest_config@@ -20,31 +18,34 @@ from utils.rate_functions import there_and_backclass FocusOn(Transform):CONFIG = {- "opacity" : 0.2,- "color" : GREY,- "run_time" : 2,- "remover" : True,+ "opacity": 0.2,+ "color": GREY,+ "run_time": 2,+ "remover": True,}+def __init__(self, mobject_or_point, **kwargs):digest_config(self, kwargs)big_dot = Dot(- radius = FRAME_X_RADIUS+FRAME_Y_RADIUS,- stroke_width = 0,- fill_color = self.color,- fill_opacity = 0,+ radius=FRAME_X_RADIUS + FRAME_Y_RADIUS,+ stroke_width=0,+ fill_color=self.color,+ fill_opacity=0,)- little_dot = Dot(radius = 0)- little_dot.set_fill(self.color, opacity = self.opacity)+ little_dot = Dot(radius=0)+ little_dot.set_fill(self.color, opacity=self.opacity)little_dot.move_to(mobject_or_point)Transform.__init__(self, big_dot, little_dot, **kwargs)+class Indicate(Transform):CONFIG = {- "rate_func" : there_and_back,- "scale_factor" : 1.2,- "color" : YELLOW,+ "rate_func": there_and_back,+ "scale_factor": 1.2,+ "color": YELLOW,}+def __init__(self, mobject, **kwargs):digest_config(self, kwargs)target = mobject.copy()@@ -52,27 +53,31 @@ class Indicate(Transform):target.set_color(self.color)Transform.__init__(self, mobject, target, **kwargs)+class CircleIndicate(Indicate):CONFIG = {- "rate_func" : squish_rate_func(there_and_back, 0, 0.8),- "remover" : True+ "rate_func": squish_rate_func(there_and_back, 0, 0.8),+ "remover": True}+def __init__(self, mobject, **kwargs):digest_config(self, kwargs)- circle = Circle(color = self.color, **kwargs)+ circle = Circle(color=self.color, **kwargs)circle.surround(mobject)Indicate.__init__(self, circle, **kwargs)+class ShowPassingFlash(ShowPartial):CONFIG = {- "time_width" : 0.1,- "remover" : True,+ "time_width": 0.1,+ "remover": True,}+def get_bounds(self, alpha):- alpha *= (1+self.time_width)- alpha -= self.time_width/2.0- lower = max(0, alpha - self.time_width/2.0)- upper = min(1, alpha + self.time_width/2.0)+ alpha *= (1 + self.time_width)+ alpha -= self.time_width / 2.0+ lower = max(0, alpha - self.time_width / 2.0)+ upper = min(1, alpha + self.time_width / 2.0)return (lower, upper)def clean_up(self, *args, **kwargs):@@ -80,43 +85,49 @@ class ShowPassingFlash(ShowPartial):for submob, start_submob in self.get_all_families_zipped():submob.pointwise_become_partial(start_submob, 0, 1)+class ShowCreationThenDestruction(ShowPassingFlash):CONFIG = {- "time_width" : 2.0,- "run_time" : 1,+ "time_width": 2.0,+ "run_time": 1,}+class ApplyWave(Homotopy):CONFIG = {- "direction" : DOWN,- "amplitude" : 0.2,- "run_time" : 1,- "apply_function_kwargs" : {- "maintain_smoothness" : False,+ "direction": DOWN,+ "amplitude": 0.2,+ "run_time": 1,+ "apply_function_kwargs": {+ "maintain_smoothness": False,},}+def __init__(self, mobject, **kwargs):digest_config(self, kwargs, locals())left_x = mobject.get_left()[0]right_x = mobject.get_right()[0]- vect = self.amplitude*self.direction+ vect = self.amplitude * self.direction+def homotopy(x, y, z, t):start_point = np.array([x, y, z])- alpha = (x-left_x)/(right_x-left_x)- power = np.exp(2*(alpha-0.5))+ alpha = (x - left_x) / (right_x - left_x)+ power = np.exp(2 * (alpha - 0.5))nudge = there_and_back(t**power)- return np.array([x, y, z]) + nudge*vect+ return np.array([x, y, z]) + nudge * vectHomotopy.__init__(self, homotopy, mobject, **kwargs)+class WiggleOutThenIn(Animation):CONFIG = {- "scale_value" : 1.1,- "rotation_angle" : 0.01*TAU,- "n_wiggles" : 6,- "run_time" : 2,- "scale_about_point" : None,- "rotate_about_point" : None,+ "scale_value": 1.1,+ "rotation_angle": 0.01 * TAU,+ "n_wiggles": 6,+ "run_time": 2,+ "scale_about_point": None,+ "rotate_about_point": None,}+def __init__(self, mobject, **kwargs):digest_config(self, kwargs)if self.scale_about_point is None:@@ -126,62 +137,65 @@ class WiggleOutThenIn(Animation):Animation.__init__(self, mobject, **kwargs)def update_submobject(self, submobject, starting_sumobject, alpha):- submobject.points[:,:] = starting_sumobject.points+ submobject.points[:, :] = starting_sumobject.pointssubmobject.scale(interpolate(1, self.scale_value, there_and_back(alpha)),- about_point = self.scale_about_point+ about_point=self.scale_about_point)submobject.rotate(- wiggle(alpha, self.n_wiggles)*self.rotation_angle,- about_point = self.rotate_about_point+ wiggle(alpha, self.n_wiggles) * self.rotation_angle,+ about_point=self.rotate_about_point)+class Vibrate(Animation):CONFIG = {- "spatial_period" : 6,- "temporal_period" : 1,- "overtones" : 4,- "amplitude" : 0.5,- "radius" : FRAME_X_RADIUS/2,- "run_time" : 3.0,- "rate_func" : None+ "spatial_period": 6,+ "temporal_period": 1,+ "overtones": 4,+ "amplitude": 0.5,+ "radius": FRAME_X_RADIUS / 2,+ "run_time": 3.0,+ "rate_func": None}- def __init__(self, mobject = None, **kwargs):++ def __init__(self, mobject=None, **kwargs):if mobject is None:- mobject = Line(3*LEFT, 3*RIGHT)+ mobject = Line(3 * LEFT, 3 * RIGHT)Animation.__init__(self, mobject, **kwargs)def wave_function(self, x, t):return sum([reduce(op.mul, [- self.amplitude/(k**2), #Amplitude- np.sin(2*np.pi*(k**1.5)*t/self.temporal_period), #Frequency- np.sin(2*np.pi*k*x/self.spatial_period) #Number of waves+ self.amplitude / (k**2), # Amplitude+ np.sin(2 * np.pi * (k**1.5) * t / \+ self.temporal_period), # Frequency+ # Number of waves+ np.sin(2 * np.pi * k * x / self.spatial_period)])- for k in range(1, self.overtones+1)+ for k in range(1, self.overtones + 1)])-def update_mobject(self, alpha):- time = alpha*self.run_time+ time = alpha * self.run_timefamilies = map(Mobject.submobject_family,[self.mobject, self.starting_mobject])for mob, start in zip(*families):mob.points = np.apply_along_axis(- lambda (x, y, z) : (x, y + self.wave_function(x, time), z),+ lambda (x, y, z): (x, y + self.wave_function(x, time), z),1, start.points)+class TurnInsideOut(Transform):CONFIG = {- "path_arc" : TAU/4,+ "path_arc": TAU / 4,}+def __init__(self, mobject, **kwargs):mobject.sort_points(np.linalg.norm)mob_copy = mobject.copy()- mob_copy.sort_points(lambda p : -np.linalg.norm(p))+ mob_copy.sort_points(lambda p: -np.linalg.norm(p))Transform.__init__(self, mobject, mob_copy, **kwargs)--diff --git a/animation/movement.py b/animation/movement.pyindex 201ed7796..1045532a2 100644--- a/animation/movement.py+++ b/animation/movement.py@@ -2,22 +2,22 @@ from __future__ import absolute_importfrom constants import *-import warnings-from animation.animation import Animationfrom utils.config_ops import digest_config+class Homotopy(Animation):CONFIG = {- "run_time" : 3,- "apply_function_kwargs" : {},+ "run_time": 3,+ "apply_function_kwargs": {},}+def __init__(self, homotopy, mobject, **kwargs):"""Homotopy a function from (x, y, z, t) to (x', y', z')"""def function_at_time_t(t):- return lambda p : homotopy(p[0], p[1], p[2], t)+ return lambda p: homotopy(p[0], p[1], p[2], t)self.function_at_time_t = function_at_time_tdigest_config(self, kwargs)Animation.__init__(self, mobject, **kwargs)@@ -29,11 +29,13 @@ class Homotopy(Animation):**self.apply_function_kwargs)+class SmoothedVectorizedHomotopy(Homotopy):def update_submobject(self, submob, start, alpha):Homotopy.update_submobject(self, submob, start, alpha)submob.make_smooth()+class ComplexHomotopy(Homotopy):def __init__(self, complex_homotopy, mobject, **kwargs):"""@@ -48,21 +50,23 @@ class ComplexHomotopy(Homotopy):class PhaseFlow(Animation):CONFIG = {- "virtual_time" : 1,- "rate_func" : None,+ "virtual_time": 1,+ "rate_func": None,}+def __init__(self, function, mobject, **kwargs):- digest_config(self, kwargs, locals())+ digest_config(self, kwargs, locals())Animation.__init__(self, mobject, **kwargs)def update_mobject(self, alpha):if hasattr(self, "last_alpha"):- dt = self.virtual_time*(alpha-self.last_alpha)+ dt = self.virtual_time * (alpha - self.last_alpha)self.mobject.apply_function(- lambda p : p + dt*self.function(p)+ lambda p: p + dt * self.function(p))self.last_alpha = alpha+class MoveAlongPath(Animation):def __init__(self, mobject, path, **kwargs):digest_config(self, kwargs, locals())@@ -71,4 +75,3 @@ class MoveAlongPath(Animation):def update_mobject(self, alpha):point = self.path.point_from_proportion(alpha)self.mobject.move_to(point)-diff --git a/animation/numbers.py b/animation/numbers.pyindex 6fed7b26b..f7b8d250b 100644--- a/animation/numbers.py+++ b/animation/numbers.py@@ -7,13 +7,15 @@ from mobject.numbers import DecimalNumberfrom utils.bezier import interpolatefrom utils.config_ops import digest_config+class ChangingDecimal(Animation):CONFIG = {- "num_decimal_points" : None,- "show_ellipsis" : None,- "position_update_func" : None,- "tracked_mobject" : None,+ "num_decimal_points": None,+ "show_ellipsis": None,+ "position_update_func": None,+ "tracked_mobject": None,}+def __init__(self, decimal_number_mobject, number_update_func, **kwargs):digest_config(self, kwargs, locals())self.decimal_number_config = dict(@@ -52,10 +54,14 @@ class ChangingDecimal(Animation):if self.position_update_func is not None:self.position_update_func(self.decimal_number_mobject)elif self.tracked_mobject is not None:- self.decimal_number_mobject.move_to(self.tracked_mobject.get_center() + self.diff_from_tracked_mobject)+ self.decimal_number_mobject.move_to(+ self.tracked_mobject.get_center() + self.diff_from_tracked_mobject)+class ChangeDecimalToValue(ChangingDecimal):def __init__(self, decimal_number_mobject, target_number, **kwargs):start_number = decimal_number_mobject.number- func = lambda alpha : interpolate(start_number, target_number, alpha)++ def func(alpha):+ return interpolate(start_number, target_number, alpha)ChangingDecimal.__init__(self, decimal_number_mobject, func, **kwargs)diff --git a/animation/rotation.py b/animation/rotation.pyindex f21187414..6b92e5b64 100644--- a/animation/rotation.py+++ b/animation/rotation.py@@ -1,26 +1,25 @@from __future__ import absolute_import-import itertools as itimport numpy as npfrom constants import *-import warnings-from animation.animation import Animationfrom animation.transform import Transformfrom utils.config_ops import digest_config+class Rotating(Animation):CONFIG = {- "axis" : OUT,- "radians" : 2*np.pi,- "run_time" : 5,- "rate_func" : None,- "in_place" : True,- "about_point" : None,- "about_edge" : None,+ "axis": OUT,+ "radians": 2 * np.pi,+ "run_time": 5,+ "rate_func": None,+ "in_place": True,+ "about_point": None,+ "about_edge": None,}+def update_submobject(self, submobject, starting_submobject, alpha):submobject.points = np.array(starting_submobject.points)@@ -28,22 +27,24 @@ class Rotating(Animation):Animation.update_mobject(self, alpha)about_point = Noneif self.about_point is not None:- about_point = self.about_point- elif self.in_place: #This is superseeded+ self.about_point = about_point+ elif self.in_place: # This is superseededself.about_point = self.mobject.get_center()self.mobject.rotate(- alpha*self.radians,- axis = self.axis,- about_point = self.about_point,- about_edge = self.about_edge,+ alpha * self.radians,+ axis=self.axis,+ about_point=self.about_point,+ about_edge=self.about_edge,)+class Rotate(Transform):CONFIG = {- "in_place" : False,- "about_point" : None,+ "in_place": False,+ "about_point": None,}- def __init__(self, mobject, angle = np.pi, axis = OUT, **kwargs):++ def __init__(self, mobject, angle=np.pi, axis=OUT, **kwargs):if "path_arc" not in kwargs:kwargs["path_arc"] = angleif "path_arc_axis" not in kwargs:@@ -53,9 +54,8 @@ class Rotate(Transform):if self.in_place:self.about_point = mobject.get_center()target.rotate(- angle,- axis = axis,- about_point = self.about_point,+ angle,+ axis=axis,+ about_point=self.about_point,)Transform.__init__(self, mobject, target, **kwargs)-diff --git a/animation/specialized.py b/animation/specialized.pyindex c12f85ab2..31dc2fa5c 100644--- a/animation/specialized.py+++ b/animation/specialized.py@@ -11,57 +11,60 @@ from mobject.types.vectorized_mobject import VGroupfrom mobject.geometry import Circlefrom utils.config_ops import digest_config+class MoveCar(ApplyMethod):CONFIG = {- "moving_forward" : True,+ "moving_forward": True,}+def __init__(self, car, target_point, **kwargs):assert isinstance(car, Car)ApplyMethod.__init__(self, car.move_to, target_point, **kwargs)- displacement = self.target_mobject.get_right()-self.starting_mobject.get_right()+ displacement = self.target_mobject.get_right() - self.starting_mobject.get_right()distance = np.linalg.norm(displacement)if not self.moving_forward:distance *= -1- tire_radius = car.get_tires()[0].get_width()/2- self.total_tire_radians = -distance/tire_radius+ tire_radius = car.get_tires()[0].get_width() / 2+ self.total_tire_radians = -distance / tire_radiusdef update_mobject(self, alpha):ApplyMethod.update_mobject(self, alpha)if alpha == 0:return- radians = alpha*self.total_tire_radians+ radians = alpha * self.total_tire_radiansfor tire in self.mobject.get_tires():tire.rotate_in_place(radians)+class Broadcast(LaggedStart):CONFIG = {- "small_radius" : 0.0,- "big_radius" : 5,- "n_circles" : 5,- "start_stroke_width" : 8,- "color" : WHITE,- "remover" : True,- "lag_ratio" : 0.7,- "run_time" : 3,- "remover" : True,+ "small_radius": 0.0,+ "big_radius": 5,+ "n_circles": 5,+ "start_stroke_width": 8,+ "color": WHITE,+ "remover": True,+ "lag_ratio": 0.7,+ "run_time": 3,+ "remover": True,}+def __init__(self, focal_point, **kwargs):digest_config(self, kwargs)circles = VGroup()for x in range(self.n_circles):circle = Circle(- radius = self.big_radius,- stroke_color = BLACK,- stroke_width = 0,+ radius=self.big_radius,+ stroke_color=BLACK,+ stroke_width=0,)circle.move_to(focal_point)circle.save_state()- circle.scale_to_fit_width(self.small_radius*2)+ circle.scale_to_fit_width(self.small_radius * 2)circle.set_stroke(self.color, self.start_stroke_width)circles.add(circle)LaggedStart.__init__(self, ApplyMethod, circles,- lambda c : (c.restore,),+ lambda c: (c.restore,),**kwargs)-diff --git a/animation/transform.py b/animation/transform.pyindex c684e91e2..83e564624 100644--- a/animation/transform.py+++ b/animation/transform.py@@ -17,16 +17,18 @@ from utils.rate_functions import smoothfrom utils.rate_functions import squish_rate_funcfrom utils.space_ops import complex_to_R3+class Transform(Animation):CONFIG = {- "path_arc" : 0,- "path_arc_axis" : OUT,- "path_func" : None,- "submobject_mode" : "all_at_once",- "replace_mobject_with_target_in_scene" : False,+ "path_arc": 0,+ "path_arc_axis": OUT,+ "path_func": None,+ "submobject_mode": "all_at_once",+ "replace_mobject_with_target_in_scene": False,}+def __init__(self, mobject, target_mobject, **kwargs):- #Copy target_mobject so as to not mess with caller+ # Copy target_mobject so as to not mess with callerself.original_target_mobject = target_mobjecttarget_mobject = target_mobject.copy()mobject.align_data(target_mobject)@@ -35,7 +37,7 @@ class Transform(Animation):self.init_path_func()Animation.__init__(self, mobject, **kwargs)- self.name += "To" + str(target_mobject)+ self.name += "To" + str(target_mobject)def update_config(self, **kwargs):Animation.update_config(self, **kwargs)@@ -63,38 +65,45 @@ class Transform(Animation):submob.interpolate(start, end, alpha, self.path_func)return self- def clean_up(self, surrounding_scene = None):+ def clean_up(self, surrounding_scene=None):Animation.clean_up(self, surrounding_scene)if self.replace_mobject_with_target_in_scene and surrounding_scene is not None:surrounding_scene.remove(self.mobject)if not self.remover:surrounding_scene.add(self.original_target_mobject)+class ReplacementTransform(Transform):CONFIG = {- "replace_mobject_with_target_in_scene" : True,+ "replace_mobject_with_target_in_scene": True,}+class ClockwiseTransform(Transform):CONFIG = {- "path_arc" : -np.pi+ "path_arc": -np.pi}+class CounterclockwiseTransform(Transform):CONFIG = {- "path_arc" : np.pi+ "path_arc": np.pi}+class MoveToTarget(Transform):def __init__(self, mobject, **kwargs):if not hasattr(mobject, "target"):- raise Exception("MoveToTarget called on mobject without attribute 'target' ")+ raise Exception(+ "MoveToTarget called on mobject without attribute 'target' ")Transform.__init__(self, mobject, mobject.target, **kwargs)+class ApplyMethod(Transform):CONFIG = {- "submobject_mode" : "all_at_once"+ "submobject_mode": "all_at_once"}+def __init__(self, method, *args, **kwargs):"""Method is a method of Mobject. *args is for the method,@@ -104,11 +113,11 @@ class ApplyMethod(Transform):"""if not inspect.ismethod(method):raise Exception(- "Whoops, looks like you accidentally invoked " + \- "the method you want to animate"- )+ "Whoops, looks like you accidentally invoked " ++ "the method you want to animate"+ )assert(isinstance(method.im_self, Mobject))- args = list(args) #So that args.pop() works+ args = list(args) # So that args.pop() worksif "method_kwargs" in kwargs:method_kwargs = kwargs["method_kwargs"]elif len(args) > 0 and isinstance(args[-1], dict):@@ -119,38 +128,46 @@ class ApplyMethod(Transform):method.im_func(target, *args, **method_kwargs)Transform.__init__(self, method.im_self, target, **kwargs)+class ApplyPointwiseFunction(ApplyMethod):CONFIG = {- "run_time" : DEFAULT_POINTWISE_FUNCTION_RUN_TIME+ "run_time": DEFAULT_POINTWISE_FUNCTION_RUN_TIME}+def __init__(self, function, mobject, **kwargs):ApplyMethod.__init__(self, mobject.apply_function, function, **kwargs)+class FadeToColor(ApplyMethod):def __init__(self, mobject, color, **kwargs):ApplyMethod.__init__(self, mobject.set_color, color, **kwargs)+class ScaleInPlace(ApplyMethod):def __init__(self, mobject, scale_factor, **kwargs):- ApplyMethod.__init__(self, mobject.scale_in_place, scale_factor, **kwargs)+ ApplyMethod.__init__(self, mobject.scale_in_place,+ scale_factor, **kwargs)+class ApplyFunction(Transform):CONFIG = {- "submobject_mode" : "all_at_once",+ "submobject_mode": "all_at_once",}+def __init__(self, function, mobject, **kwargs):Transform.__init__(- self,- mobject,+ self,+ mobject,function(mobject.copy()),**kwargs)- self.name = "ApplyFunctionTo"+str(mobject)+ self.name = "ApplyFunctionTo" + str(mobject)+class ApplyMatrix(ApplyPointwiseFunction):- #Truth be told, I'm not sure if this is useful.+ # Truth be told, I'm not sure if this is useful.def __init__(self, matrix, mobject, **kwargs):matrix = np.array(matrix)if matrix.shape == (2, 2):@@ -160,10 +177,12 @@ class ApplyMatrix(ApplyPointwiseFunction):elif matrix.shape != (3, 3):raise "Matrix has bad dimensions"transpose = np.transpose(matrix)+def func(p):return np.dot(p, transpose)ApplyPointwiseFunction.__init__(self, func, mobject, **kwargs)+class ComplexFunction(ApplyPointwiseFunction):def __init__(self, function, mobject, **kwargs):if "path_func" not in kwargs:@@ -172,17 +191,19 @@ class ComplexFunction(ApplyPointwiseFunction):)ApplyPointwiseFunction.__init__(self,- lambda (x, y, z) : complex_to_R3(function(complex(x, y))),+ lambda (x, y, z): complex_to_R3(function(complex(x, y))),instantiate(mobject),**kwargs)###+class CyclicReplace(Transform):CONFIG = {- "path_arc" : np.pi/2+ "path_arc": np.pi / 2}+def __init__(self, *mobjects, **kwargs):start = Group(*mobjects)target = Group(*[@@ -191,14 +212,18 @@ class CyclicReplace(Transform):])Transform.__init__(self, start, target, **kwargs)+class Swap(CyclicReplace):- pass #Renaming, more understandable for two entries+ pass # Renaming, more understandable for two entries++# TODO: Um...does this work+-#TODO: Um...does this workclass TransformAnimations(Transform):CONFIG = {- "rate_func" : squish_rate_func(smooth)+ "rate_func": squish_rate_func(smooth)}+def __init__(self, start_anim, end_anim, **kwargs):digest_config(self, kwargs, locals())if "run_time" in kwargs:@@ -207,15 +232,16 @@ class TransformAnimations(Transform):self.run_time = max(start_anim.run_time, end_anim.run_time)for anim in start_anim, end_anim:anim.set_run_time(self.run_time)-+if start_anim.starting_mobject.get_num_points() != end_anim.starting_mobject.get_num_points():start_anim.starting_mobject.align_data(end_anim.starting_mobject)for anim in start_anim, end_anim:if hasattr(anim, "target_mobject"):anim.starting_mobject.align_data(anim.target_mobject)- Transform.__init__(self, start_anim.mobject, end_anim.mobject, **kwargs)- #Rewire starting and ending mobjects+ Transform.__init__(self, start_anim.mobject,+ end_anim.mobject, **kwargs)+ # Rewire starting and ending mobjectsstart_anim.mobject = self.starting_mobjectend_anim.mobject = self.target_mobject@@ -223,4 +249,3 @@ class TransformAnimations(Transform):self.start_anim.update(alpha)self.end_anim.update(alpha)Transform.update(self, alpha)-diff --git a/animation/update.py b/animation/update.pyindex ff3ec543a..fcef3e9b8 100644--- a/animation/update.py+++ b/animation/update.py@@ -12,6 +12,7 @@ class UpdateFromFunc(Animation):to be used when the state of one mobject is dependenton another simultaneously animated mobject"""+def __init__(self, mobject, update_function, **kwargs):digest_config(self, kwargs, locals())Animation.__init__(self, mobject, **kwargs)@@ -19,29 +20,27 @@ class UpdateFromFunc(Animation):def update_mobject(self, alpha):self.update_function(self.mobject)+class UpdateFromAlphaFunc(UpdateFromFunc):def update_mobject(self, alpha):self.update_function(self.mobject, alpha)+class MaintainPositionRelativeTo(Animation):CONFIG = {- "tracked_critical_point" : ORIGIN+ "tracked_critical_point": ORIGIN}+def __init__(self, mobject, tracked_mobject, **kwargs):digest_config(self, kwargs, locals())tcp = self.tracked_critical_pointself.diff = mobject.get_critical_point(tcp) - \- tracked_mobject.get_critical_point(tcp)+ tracked_mobject.get_critical_point(tcp)Animation.__init__(self, mobject, **kwargs)def update_mobject(self, alpha):self.mobject.shift(- self.tracked_mobject.get_critical_point(self.tracked_critical_point) - \- self.mobject.get_critical_point(self.tracked_critical_point) + \+ self.tracked_mobject.get_critical_point(self.tracked_critical_point) -+ self.mobject.get_critical_point(self.tracked_critical_point) +self.diff)-----diff --git a/big_ol_pile_of_manim_imports.py b/big_ol_pile_of_manim_imports.pyindex 58ead133b..9e941ec7d 100644--- a/big_ol_pile_of_manim_imports.py+++ b/big_ol_pile_of_manim_imports.py@@ -1,12 +1,12 @@"""I won't pretend like this is best practice, by in creating animations for a video,-it can be very nice to simply have all of the Mobjects, Animations, Scenes, etc.+it can be very nice to simply have all of the Mobjects, Animations, Scenes, etc.of manim available without having to worry about what namespace they come from.Rather than having a large pile of "from <module> import *" at the top of every such-script, the intent of this file is to make it so that one can just include+script, the intent of this file is to make it so that one can just include"from big_ol_pile_of_manim_imports import *". The effects of adding more modules-or refactoring the library on current or older scene scripts should be entirely+or refactoring the library on current or older scene scripts should be entirelyaddressible by changing this file.Note: One should NOT import from this file for main library code, it is meant onlydiff --git a/camera/camera.py b/camera/camera.pyindex c9f4dab01..e8ccb6bb3 100644--- a/camera/camera.py+++ b/camera/camera.py@@ -1,6 +1,5 @@import itertools as itimport numpy as np-import osimport aggdrawimport copy@@ -23,28 +22,29 @@ from utils.iterables import list_difference_updatefrom utils.iterables import remove_list_redundanciesfrom utils.simple_functions import fdiv+class Camera(object):CONFIG = {- "background_image" : None,- "pixel_shape" : (DEFAULT_PIXEL_HEIGHT, DEFAULT_PIXEL_WIDTH),+ "background_image": None,+ "pixel_shape": (DEFAULT_PIXEL_HEIGHT, DEFAULT_PIXEL_WIDTH),# Note: frame_shape will be resized to match pixel_shape- "frame_shape" : (FRAME_HEIGHT, FRAME_WIDTH),- "space_center" : ORIGIN,- "background_color" : BLACK,- #Points in vectorized mobjects with norm greater- #than this value will be rescaled.- "max_allowable_norm" : FRAME_WIDTH,- "image_mode" : "RGBA",- "n_rgb_coords" : 4,- "background_alpha" : 0, #Out of rgb_max_val- "pixel_array_dtype" : 'uint8',- "use_z_coordinate_for_display_order" : False,+ "frame_shape": (FRAME_HEIGHT, FRAME_WIDTH),+ "space_center": ORIGIN,+ "background_color": BLACK,+ # Points in vectorized mobjects with norm greater+ # than this value will be rescaled.+ "max_allowable_norm": FRAME_WIDTH,+ "image_mode": "RGBA",+ "n_rgb_coords": 4,+ "background_alpha": 0, # Out of rgb_max_val+ "pixel_array_dtype": 'uint8',+ "use_z_coordinate_for_display_order": False,# z_buff_func is only used if the flag above is set to True.# round z coordinate to nearest hundredth when comparring- "z_buff_func" : lambda m : np.round(m.get_center()[2], 2),+ "z_buff_func": lambda m: np.round(m.get_center()[2], 2),}- def __init__(self, background = None, **kwargs):+ def __init__(self, background=None, **kwargs):digest_config(self, kwargs, locals())self.rgb_max_val = np.iinfo(self.pixel_array_dtype).maxself.init_background()@@ -55,22 +55,22 @@ class Camera(object):# This is to address a strange bug where deepcopying# will result in a segfault, which is somehow related# to the aggdraw library- self.canvas = None+ self.canvas = Nonereturn copy.copy(self)- def resize_frame_shape(self, fixed_dimension = 0):+ def resize_frame_shape(self, fixed_dimension=0):"""- Changes frame_shape to match the aspect ratio+ Changes frame_shape to match the aspect ratioof pixel_shape, where fixed_dimension determineswhether frame_shape[0] (height) or frame_shape[1] (width)remains fixed while the other changes accordingly."""- aspect_ratio = float(self.pixel_shape[1])/self.pixel_shape[0]+ aspect_ratio = float(self.pixel_shape[1]) / self.pixel_shape[0]frame_width, frame_height = self.frame_shapeif fixed_dimension == 0:- frame_height = aspect_ratio*frame_width+ frame_height = aspect_ratio * frame_widthelse:- frame_width = frame_height/aspect_ratio+ frame_width = frame_height / aspect_ratioself.frame_shape = (frame_width, frame_height)def init_background(self):@@ -78,53 +78,56 @@ class Camera(object):path = get_full_raster_image_path(self.background_image)image = Image.open(path).convert(self.image_mode)height, width = self.pixel_shape- #TODO, how to gracefully handle backgrounds- #with different sizes?+ # TODO, how to gracefully handle backgrounds+ # with different sizes?self.background = np.array(image)[:height, :width]self.background = self.background.astype(self.pixel_array_dtype)else:background_rgba = color_to_int_rgba(- self.background_color, alpha = self.background_alpha+ self.background_color, alpha=self.background_alpha)self.background = np.zeros(- list(self.pixel_shape)+[self.n_rgb_coords],- dtype = self.pixel_array_dtype+ list(self.pixel_shape) + [self.n_rgb_coords],+ dtype=self.pixel_array_dtype)- self.background[:,:] = background_rgba+ self.background[:, :] = background_rgbadef get_image(self):return Image.fromarray(self.pixel_array,- mode = self.image_mode+ mode=self.image_mode)def get_pixel_array(self):return self.pixel_array- def convert_pixel_array(self, pixel_array, convert_from_floats = False):+ def convert_pixel_array(self, pixel_array, convert_from_floats=False):retval = np.array(pixel_array)if convert_from_floats:retval = np.apply_along_axis(- lambda f : (f * self.rgb_max_val).astype(self.pixel_array_dtype),+ lambda f: (+ f * self.rgb_max_val).astype(self.pixel_array_dtype),2,retval)return retval- def set_pixel_array(self, pixel_array, convert_from_floats = False):- converted_array = self.convert_pixel_array(pixel_array, convert_from_floats)- if not (hasattr(self, "pixel_array") and self.pixel_array.shape == converted_array.shape):+ def set_pixel_array(self, pixel_array, convert_from_floats=False):+ converted_array = self.convert_pixel_array(+ pixel_array, convert_from_floats)+ if not (hasattr(self, "pixel_array") and self.pixel_array.shape == converted_array.shape):self.pixel_array = converted_arrayelse:- #Set in place- self.pixel_array[:,:,:] = converted_array[:,:,:]+ # Set in place+ self.pixel_array[:, :, :] = converted_array[:, :, :]- def set_background(self, pixel_array, convert_from_floats = False):- self.background = self.convert_pixel_array(pixel_array, convert_from_floats)+ def set_background(self, pixel_array, convert_from_floats=False):+ self.background = self.convert_pixel_array(+ pixel_array, convert_from_floats)def make_background_from_func(self, coords_to_colors_func):"""- Sets background by using coords_to_colors_func to determine each pixel's color. Each input- to coords_to_colors_func is an (x, y) pair in space (in ordinary space coordinates; not+ Sets background by using coords_to_colors_func to determine each pixel's color. Each input+ to coords_to_colors_func is an (x, y) pair in space (in ordinary space coordinates; notpixel coordinates), and each output is expected to be an RGBA array of 4 floats."""@@ -137,17 +140,18 @@ class Camera(object):)print "Ending set_background; for reference, the current time is ", time.strftime("%H:%M:%S")- return self.convert_pixel_array(new_background, convert_from_floats = True)+ return self.convert_pixel_array(new_background, convert_from_floats=True)def set_background_from_func(self, coords_to_colors_func):- self.set_background(self.make_background_from_func(coords_to_colors_func))+ self.set_background(+ self.make_background_from_func(coords_to_colors_func))def reset(self):self.set_pixel_array(self.background)####- def extract_mobject_family_members(self, mobjects, only_those_with_points = False):+ def extract_mobject_family_members(self, mobjects, only_those_with_points=False):if only_those_with_points:method = Mobject.family_members_with_pointselse:@@ -161,13 +165,13 @@ class Camera(object):))def get_mobjects_to_display(- self, mobjects,- include_submobjects = True,- excluded_mobjects = None,- ):+ self, mobjects,+ include_submobjects=True,+ excluded_mobjects=None,+ ):if include_submobjects:mobjects = self.extract_mobject_family_members(- mobjects, only_those_with_points = True+ mobjects, only_those_with_points=True)if excluded_mobjects:all_excluded = self.extract_mobject_family_members(@@ -192,14 +196,15 @@ class Camera(object):def capture_mobjects(self, mobjects, **kwargs):mobjects = self.get_mobjects_to_display(mobjects, **kwargs)- # Organize this list into batches of the same type, and+ # Organize this list into batches of the same type, and# apply corresponding function to those batchestype_func_pairs = [(VMobject, self.display_multiple_vectorized_mobjects),- (PMobject, self.display_multiple_point_cloud_mobjects),- (ImageMobject, self.display_multiple_image_mobjects),- (Mobject, lambda batch : batch), #Do nothing+ (PMobject, self.display_multiple_point_cloud_mobjects),+ (ImageMobject, self.display_multiple_image_mobjects),+ (Mobject, lambda batch: batch), # Do nothing]+def get_mobject_type(mobject):for mobject_type, func in type_func_pairs:if isinstance(mobject, mobject_type):@@ -209,14 +214,14 @@ class Camera(object):)batch_type_pairs = batch_by_property(mobjects, get_mobject_type)- #Display in these batches+ # Display in these batchesfor batch, batch_type in batch_type_pairs:- #check what the type is, and call the appropriate function+ # check what the type is, and call the appropriate functionfor mobject_type, func in type_func_pairs:if batch_type == mobject_type:func(batch)- ## Methods associated with svg rendering+ # Methods associated with svg renderingdef get_aggdraw_canvas(self):if not hasattr(self, "canvas") or not self.canvas:@@ -224,15 +229,15 @@ class Camera(object):return self.canvasdef reset_aggdraw_canvas(self):- image = Image.fromarray(self.pixel_array, mode = self.image_mode)+ image = Image.fromarray(self.pixel_array, mode=self.image_mode)self.canvas = aggdraw.Draw(image)def display_multiple_vectorized_mobjects(self, vmobjects):if len(vmobjects) == 0:returnbatch_file_pairs = batch_by_property(- vmobjects,- lambda vm : vm.get_background_image_file()+ vmobjects,+ lambda vm: vm.get_background_image_file())for batch, file_name in batch_file_pairs:if file_name:@@ -247,10 +252,10 @@ class Camera(object):self.display_vectorized(vmobject, canvas)canvas.flush()- def display_vectorized(self, vmobject, canvas = None):+ def display_vectorized(self, vmobject, canvas=None):if vmobject.is_subpath:- #Subpath vectorized mobjects are taken care- #of by their parent+ # Subpath vectorized mobjects are taken care+ # of by their parentreturncanvas = canvas or self.get_aggdraw_canvas()pen, fill = self.get_pen_and_fill(vmobject)@@ -267,7 +272,7 @@ class Camera(object):stroke_hex = rgb_to_hex(stroke_rgb)pen = aggdraw.Pen(stroke_hex, stroke_width)- fill_opacity = int(self.rgb_max_val*vmobject.get_fill_opacity())+ fill_opacity = int(self.rgb_max_val * vmobject.get_fill_opacity())if fill_opacity == 0:fill = Noneelse:@@ -291,27 +296,28 @@ class Camera(object):def get_pathstring(self, vmobject):result = ""- for mob in [vmobject]+vmobject.get_subpath_mobjects():+ for mob in [vmobject] + vmobject.get_subpath_mobjects():points = mob.points- # points = self.adjust_out_of_range_points(points)+ # points = self.adjust_out_of_range_points(points)if len(points) == 0:continuealigned_points = self.align_points_to_camera(points)coords = self.points_to_pixel_coords(aligned_points)coord_strings = coords.flatten().astype(str)- #Start new path string with M+ # Start new path string with Mcoord_strings[0] = "M" + coord_strings[0]- #The C at the start of every 6th number communicates- #that the following 6 define a cubic Bezier- coord_strings[2::6] = map(lambda s : "C" + str(s), coord_strings[2::6])- #Possibly finish with "Z"+ # The C at the start of every 6th number communicates+ # that the following 6 define a cubic Bezier+ coord_strings[2::6] = map(+ lambda s: "C" + str(s), coord_strings[2::6])+ # Possibly finish with "Z"if vmobject.mark_paths_closed:coord_strings[-1] = coord_strings[-1] + " Z"result += " ".join(coord_strings)return resultdef get_background_colored_vmobject_displayer(self):- #Quite wordy to type out a bunch+ # Quite wordy to type out a bunchlong_name = "background_colored_vmobject_displayer"if not hasattr(self, long_name):setattr(self, long_name, BackgroundColoredVMobjectDisplayer(self))@@ -323,7 +329,7 @@ class Camera(object):self.overlay_rgba_array(cvmobject_pixel_array)return self- ## Methods for other rendering+ # Methods for other renderingdef display_multiple_point_cloud_mobjects(self, pmobjects):for pmobject in pmobjects:@@ -343,23 +349,23 @@ class Camera(object):)rgba_len = self.pixel_array.shape[2]- rgbas = (self.rgb_max_val*rgbas).astype(self.pixel_array_dtype)+ rgbas = (self.rgb_max_val * rgbas).astype(self.pixel_array_dtype)target_len = len(pixel_coords)- factor = target_len/len(rgbas)- rgbas = np.array([rgbas]*factor).reshape((target_len, rgba_len))+ factor = target_len / len(rgbas)+ rgbas = np.array([rgbas] * factor).reshape((target_len, rgba_len))- on_screen_indices = self.on_screen_pixels(pixel_coords)- pixel_coords = pixel_coords[on_screen_indices]+ on_screen_indices = self.on_screen_pixels(pixel_coords)+ pixel_coords = pixel_coords[on_screen_indices]rgbas = rgbas[on_screen_indices]ph, pw = self.pixel_shape- flattener = np.array([1, pw], dtype = 'int')+ flattener = np.array([1, pw], dtype='int')flattener = flattener.reshape((2, 1))- indices = np.dot(pixel_coords, flattener)[:,0]+ indices = np.dot(pixel_coords, flattener)[:, 0]indices = indices.astype('int')-- new_pa = self.pixel_array.reshape((ph*pw, rgba_len))++ new_pa = self.pixel_array.reshape((ph * pw, rgba_len))new_pa[indices] = rgbasself.pixel_array = new_pa.reshape((ph, pw, rgba_len))@@ -375,47 +381,46 @@ class Camera(object):impa = image_mobject.pixel_array- oh, ow = self.pixel_array.shape[:2] #Outer width and height- ih, iw = impa.shape[:2] #inner with and height+ oh, ow = self.pixel_array.shape[:2] # Outer width and height+ ih, iw = impa.shape[:2] # inner with and heightrgb_len = self.pixel_array.shape[2]- image = np.zeros((oh, ow, rgb_len), dtype = self.pixel_array_dtype)+ image = np.zeros((oh, ow, rgb_len), dtype=self.pixel_array_dtype)if right_vect[1] == 0 and down_vect[0] == 0:rv0 = right_vect[0]dv1 = down_vect[1]- x_indices = np.arange(rv0, dtype = 'int')*iw/rv0- y_indices = np.arange(dv1, dtype = 'int')*ih/dv1- stretched_impa = impa[y_indices][:,x_indices]+ x_indices = np.arange(rv0, dtype='int') * iw / rv0+ y_indices = np.arange(dv1, dtype='int') * ih / dv1+ stretched_impa = impa[y_indices][:, x_indices]- x0, x1 = ul_coords[0], ur_coords[0]+ x0, x1 = ul_coords[0], ur_coords[0]y0, y1 = ul_coords[1], dl_coords[1]if x0 >= ow or x1 < 0 or y0 >= oh or y1 < 0:return- siy0 = max(-y0, 0) #stretched_impa y0- siy1 = dv1 - max(y1-oh, 0)+ siy0 = max(-y0, 0) # stretched_impa y0+ siy1 = dv1 - max(y1 - oh, 0)six0 = max(-x0, 0)- six1 = rv0 - max(x1-ow, 0)+ six1 = rv0 - max(x1 - ow, 0)x0 = max(x0, 0)y0 = max(y0, 0)image[y0:y1, x0:x1] = stretched_impa[siy0:siy1, six0:six1]else:# Alternate (slower) tactic if image is tilted- # List of all coordinates of pixels, given as (x, y),+ # List of all coordinates of pixels, given as (x, y),# which matches the return type of points_to_pixel_coords,# even though np.array indexing naturally happens as (y, x)- all_pixel_coords = np.zeros((oh*ow, 2), dtype = 'int')- a = np.arange(oh*ow, dtype = 'int')- all_pixel_coords[:,0] = a%ow- all_pixel_coords[:,1] = a/ow+ all_pixel_coords = np.zeros((oh * ow, 2), dtype='int')+ a = np.arange(oh * ow, dtype='int')+ all_pixel_coords[:, 0] = a % ow+ all_pixel_coords[:, 1] = a / owrecentered_coords = all_pixel_coords - ul_coords- coord_norms = np.linalg.norm(recentered_coords, axis = 1)- with np.errstate(divide = 'ignore'):+ with np.errstate(divide='ignore'):ix_coords, iy_coords = [np.divide(- dim*np.dot(recentered_coords, vect),+ dim * np.dot(recentered_coords, vect),np.dot(vect, vect),)for vect, dim in (right_vect, iw), (down_vect, ih)@@ -424,12 +429,12 @@ class Camera(object):ix_coords >= 0, ix_coords < iw,iy_coords >= 0, iy_coords < ih,])- n_to_change = np.sum(to_change)- inner_flat_coords = iw*iy_coords[to_change] + ix_coords[to_change]- flat_impa = impa.reshape((iw*ih, rgb_len))+ inner_flat_coords = iw * \+ iy_coords[to_change] + ix_coords[to_change]+ flat_impa = impa.reshape((iw * ih, rgb_len))target_rgbas = flat_impa[inner_flat_coords, :]- image = image.reshape((ow*oh, rgb_len))+ image = image.reshape((ow * oh, rgb_len))image[to_change] = target_rgbasimage = image.reshape((oh, ow, rgb_len))self.overlay_rgba_array(image)@@ -439,27 +444,27 @@ class Camera(object):bg = self.pixel_array# rgba_max_val = self.rgb_max_valsrc_rgb, src_a, dst_rgb, dst_a = [- a.astype(np.float32)/self.rgb_max_val- for a in fg[...,:3], fg[...,3], bg[...,:3], bg[...,3]+ a.astype(np.float32) / self.rgb_max_val+ for a in fg[..., :3], fg[..., 3], bg[..., :3], bg[..., 3]]- out_a = src_a + dst_a*(1.0-src_a)+ out_a = src_a + dst_a * (1.0 - src_a)- # When the output alpha is 0 for full transparency,+ # When the output alpha is 0 for full transparency,# we have a choice over what RGB value to use in our# output representation. We choose 0 here.out_rgb = fdiv(- src_rgb*src_a[..., None] + \- dst_rgb*dst_a[..., None]*(1.0-src_a[..., None]),+ src_rgb * src_a[..., None] ++ dst_rgb * dst_a[..., None] * (1.0 - src_a[..., None]),out_a[..., None],- zero_over_zero_value = 0+ zero_over_zero_value=0)- self.pixel_array[..., :3] = out_rgb*self.rgb_max_val- self.pixel_array[..., 3] = out_a*self.rgb_max_val+ self.pixel_array[..., :3] = out_rgb * self.rgb_max_val+ self.pixel_array[..., 3] = out_a * self.rgb_max_valdef align_points_to_camera(self, points):- ## This is where projection should live+ # This is where projection should livereturn points - self.space_centerdef adjust_out_of_range_points(self, points):@@ -467,10 +472,10 @@ class Camera(object):return pointsnorms = np.apply_along_axis(np.linalg.norm, 1, points)violator_indices = norms > self.max_allowable_norm- violators = points[violator_indices,:]+ violators = points[violator_indices, :]violator_norms = norms[violator_indices]reshaped_norms = np.repeat(- violator_norms.reshape((len(violator_norms), 1)),+ violator_norms.reshape((len(violator_norms), 1)),points.shape[1], 1)rescaled = self.max_allowable_norm * violators / reshaped_norms@@ -481,32 +486,32 @@ class Camera(object):result = np.zeros((len(points), 2))ph, pw = self.pixel_shapesh, sw = self.frame_shape- width_mult = pw/sw- width_add = pw/2- height_mult = ph/sh- height_add = ph/2- #Flip on y-axis as you go+ width_mult = pw / sw+ width_add = pw / 2+ height_mult = ph / sh+ height_add = ph / 2+ # Flip on y-axis as you goheight_mult *= -1- result[:,0] = points[:,0]*width_mult + width_add- result[:,1] = points[:,1]*height_mult + height_add+ result[:, 0] = points[:, 0] * width_mult + width_add+ result[:, 1] = points[:, 1] * height_mult + height_addreturn result.astype('int')def on_screen_pixels(self, pixel_coords):return reduce(op.and_, [- pixel_coords[:,0] >= 0,- pixel_coords[:,0] < self.pixel_shape[1],- pixel_coords[:,1] >= 0,- pixel_coords[:,1] < self.pixel_shape[0],+ pixel_coords[:, 0] >= 0,+ pixel_coords[:, 0] < self.pixel_shape[1],+ pixel_coords[:, 1] >= 0,+ pixel_coords[:, 1] < self.pixel_shape[0],])def adjusted_thickness(self, thickness):big_shape = PRODUCTION_QUALITY_CAMERA_CONFIG["pixel_shape"]- factor = sum(big_shape)/sum(self.pixel_shape)- return 1 + (thickness-1)/factor+ factor = sum(big_shape) / sum(self.pixel_shape)+ return 1 + (thickness - 1) / factordef get_thickening_nudges(self, thickness):- _range = range(-thickness/2+1, thickness/2+1)+ _range = range(-thickness / 2 + 1, thickness / 2 + 1)return np.array(list(it.product(_range, _range)))def thickened_coordinates(self, pixel_coords, thickness):@@ -516,7 +521,7 @@ class Camera(object):for nudge in nudges])size = pixel_coords.size- return pixel_coords.reshape((size/2, 2))+ return pixel_coords.reshape((size / 2, 2))def get_coords_of_all_pixels(self):# These are in x, y order, to help me keep things straight@@ -525,23 +530,26 @@ class Camera(object):# These are addressed in the same y, x order as in pixel_array, but the values in them# are listed in x, y order- uncentered_pixel_coords = np.indices(self.pixel_shape)[::-1].transpose(1, 2, 0)+ uncentered_pixel_coords = np.indices(self.pixel_shape)[+ ::-1].transpose(1, 2, 0)uncentered_space_coords = fdiv(- uncentered_pixel_coords * full_space_dims,+ uncentered_pixel_coords * full_space_dims,full_pixel_dims)- # Could structure above line's computation slightly differently, but figured (without much- # thought) multiplying by frame_shape first, THEN dividing by pixel_shape, is probably- # better than the other order, for avoiding underflow quantization in the division (whereas+ # Could structure above line's computation slightly differently, but figured (without much+ # thought) multiplying by frame_shape first, THEN dividing by pixel_shape, is probably+ # better than the other order, for avoiding underflow quantization in the division (whereas# overflow is unlikely to be a problem)- centered_space_coords = (uncentered_space_coords - fdiv(full_space_dims, 2))+ centered_space_coords = (+ uncentered_space_coords - fdiv(full_space_dims, 2))- # Have to also flip the y coordinates to account for pixel array being listed in+ # Have to also flip the y coordinates to account for pixel array being listed in# top-to-bottom order, opposite of screen coordinate conventioncentered_space_coords = centered_space_coords * (1, -1)return centered_space_coords+class BackgroundColoredVMobjectDisplayer(object):def __init__(self, camera):self.camera = camera@@ -551,20 +559,20 @@ class BackgroundColoredVMobjectDisplayer(object):def init_canvas(self):self.pixel_array = np.zeros(self.camera.pixel_array.shape,- dtype = self.camera.pixel_array_dtype,+ dtype=self.camera.pixel_array_dtype,)self.reset_canvas()def reset_canvas(self):- image = Image.fromarray(self.pixel_array, mode = self.camera.image_mode)+ image = Image.fromarray(self.pixel_array, mode=self.camera.image_mode)self.canvas = aggdraw.Draw(image)def resize_background_array(- self, background_array,- new_width, new_height,- mode = "RGBA"- ):- image = Image.fromarray(background_array, mode = mode)+ self, background_array,+ new_width, new_height,+ mode="RGBA"+ ):+ image = Image.fromarray(background_array, mode=mode)resized_image = image.resize((new_width, new_height))return np.array(resized_image)@@ -582,14 +590,15 @@ class BackgroundColoredVMobjectDisplayer(object):camera = self.cameraif not np.all(camera.pixel_array.shape == array.shape):- array = self.resize_background_array_to_match(array, camera.pixel_array)+ array = self.resize_background_array_to_match(+ array, camera.pixel_array)self.file_name_to_pixel_array_map[file_name] = arrayreturn arraydef display(self, *cvmobjects):batch_image_file_pairs = batch_by_property(- cvmobjects, lambda cv : cv.get_background_image_file()+ cvmobjects, lambda cv: cv.get_background_image_file())curr_array = Nonefor batch, image_file in batch_image_file_pairs:@@ -598,14 +607,13 @@ class BackgroundColoredVMobjectDisplayer(object):self.camera.display_vectorized(cvmobject, self.canvas)self.canvas.flush()new_array = np.array(- (background_array*self.pixel_array.astype('float')/255),- dtype = self.camera.pixel_array_dtype+ (background_array * self.pixel_array.astype('float') / 255),+ dtype=self.camera.pixel_array_dtype)if curr_array is None:curr_array = new_arrayelse:curr_array = np.maximum(curr_array, new_array)- self.pixel_array[:,:] = 0+ self.pixel_array[:, :] = 0self.reset_canvas()return curr_array-diff --git a/camera/mapping_camera.py b/camera/mapping_camera.pyindex 66e38adb7..b55d4bc05 100644--- a/camera/mapping_camera.py+++ b/camera/mapping_camera.py@@ -1,21 +1,26 @@from __future__ import absolute_import+import numpy as np+from camera.camera import Camera+from mobject.types.vectorized_mobject import VMobjectfrom utils.config_ops import DictAsObjectfrom utils.config_ops import digest_config-# TODO: Add an attribute to mobjects under which they can specify that they should just+# TODO: Add an attribute to mobjects under which they can specify that they should just# map their centers but remain otherwise undistorted (useful for labels, etc.)++class MappingCamera(Camera):CONFIG = {- "mapping_func" : lambda p : p,- "min_anchor_points" : 50,- "allow_object_intrusion" : False+ "mapping_func": lambda p: p,+ "min_anchor_points": 50,+ "allow_object_intrusion": False}def points_to_pixel_coords(self, points):return Camera.points_to_pixel_coords(self, np.apply_along_axis(self.mapping_func, 1, points))-+def capture_mobjects(self, mobjects, **kwargs):mobjects = self.get_mobjects_to_display(mobjects, **kwargs)if self.allow_object_intrusion:@@ -24,30 +29,32 @@ class MappingCamera(Camera):mobject_copies = [mobject.copy() for mobject in mobjects]for mobject in mobject_copies:if isinstance(mobject, VMobject) and \- 0 < mobject.get_num_anchor_points() < self.min_anchor_points:+ 0 < mobject.get_num_anchor_points() < self.min_anchor_points:mobject.insert_n_anchor_points(self.min_anchor_points)Camera.capture_mobjects(- self, mobject_copies,- include_submobjects = False,- excluded_mobjects = None,+ self, mobject_copies,+ include_submobjects=False,+ excluded_mobjects=None,)# Note: This allows layering of multiple cameras onto the same portion of the pixel array,# the later cameras overwriting the former#-# TODO: Add optional separator borders between cameras (or perhaps peel this off into a+# TODO: Add optional separator borders between cameras (or perhaps peel this off into a# CameraPlusOverlay class)++class MultiCamera(Camera):def __init__(self, *cameras_with_start_positions, **kwargs):self.shifted_cameras = [DictAsObject(- {- "camera" : camera_with_start_positions[0],- "start_x" : camera_with_start_positions[1][1],- "start_y" : camera_with_start_positions[1][0],- "end_x" : camera_with_start_positions[1][1] + camera_with_start_positions[0].pixel_shape[1],- "end_y" : camera_with_start_positions[1][0] + camera_with_start_positions[0].pixel_shape[0],- })+ {+ "camera": camera_with_start_positions[0],+ "start_x": camera_with_start_positions[1][1],+ "start_y": camera_with_start_positions[1][0],+ "end_x": camera_with_start_positions[1][1] + camera_with_start_positions[0].pixel_shape[1],+ "end_y": camera_with_start_positions[1][0] + camera_with_start_positions[0].pixel_shape[0],+ })for camera_with_start_positions in cameras_with_start_positions]Camera.__init__(self, **kwargs)@@ -55,17 +62,17 @@ class MultiCamera(Camera):def capture_mobjects(self, mobjects, **kwargs):for shifted_camera in self.shifted_cameras:shifted_camera.camera.capture_mobjects(mobjects, **kwargs)-+self.pixel_array[- shifted_camera.start_y:shifted_camera.end_y,+ shifted_camera.start_y:shifted_camera.end_y,shifted_camera.start_x:shifted_camera.end_x] \- = shifted_camera.camera.pixel_array+ = shifted_camera.camera.pixel_arraydef set_background(self, pixel_array, **kwargs):for shifted_camera in self.shifted_cameras:shifted_camera.camera.set_background(pixel_array[- shifted_camera.start_y:shifted_camera.end_y,+ shifted_camera.start_y:shifted_camera.end_y,shifted_camera.start_x:shifted_camera.end_x],**kwargs)@@ -75,7 +82,7 @@ class MultiCamera(Camera):for shifted_camera in self.shifted_cameras:shifted_camera.camera.set_pixel_array(pixel_array[- shifted_camera.start_y:shifted_camera.end_y,+ shifted_camera.start_y:shifted_camera.end_y,shifted_camera.start_x:shifted_camera.end_x],**kwargs)@@ -87,18 +94,21 @@ class MultiCamera(Camera):# A MultiCamera which, when called with two full-size cameras, initializes itself# as a splitscreen, also taking care to resize each individual camera within it++class SplitScreenCamera(MultiCamera):def __init__(self, left_camera, right_camera, **kwargs):digest_config(self, kwargs)self.left_camera = left_cameraself.right_camera = right_camera-+half_width = self.pixel_shape[1] / 2for camera in [self.left_camera, self.right_camera]:- camera.pixel_shape = (self.pixel_shape[0], half_width) # TODO: Round up on one if width is odd+ # TODO: Round up on one if width is odd+ camera.pixel_shape = (self.pixel_shape[0], half_width)camera.init_background()camera.resize_frame_shape()camera.reset()- MultiCamera.__init__(self, (left_camera, (0, 0)), (right_camera, (0, half_width)))-+ MultiCamera.__init__(self, (left_camera, (0, 0)),+ (right_camera, (0, half_width)))diff --git a/camera/moving_camera.py b/camera/moving_camera.pyindex f02c40123..eb68fdde3 100644--- a/camera/moving_camera.py+++ b/camera/moving_camera.py@@ -2,17 +2,19 @@ from __future__ import absolute_importfrom camera.camera import Camera+class MovingCamera(Camera):"""Stays in line with the height, width and positionof a given mobject"""CONFIG = {- "aligned_dimension" : "width" #or height+ "aligned_dimension": "width" # or height}+def __init__(self, frame, **kwargs):"""- frame is a Mobject, (should be a rectangle) determining+ frame is a Mobject, (should be a rectangle) determiningwhich region of space the camera displys"""self.frame = framediff --git a/camera/three_d_camera.py b/camera/three_d_camera.pyindex 8054bef9a..84ddece8a 100644--- a/camera/three_d_camera.py+++ b/camera/three_d_camera.py@@ -12,39 +12,43 @@ from utils.bezier import interpolatefrom utils.space_ops import rotation_about_zfrom utils.space_ops import rotation_matrix+class CameraWithPerspective(Camera):CONFIG = {- "camera_distance" : 20,+ "camera_distance": 20,}+def points_to_pixel_coords(self, points):distance_ratios = np.divide(self.camera_distance,- self.camera_distance - points[:,2]+ self.camera_distance - points[:, 2])scale_factors = interpolate(0, 1, distance_ratios)adjusted_points = np.array(points)for i in 0, 1:- adjusted_points[:,i] *= scale_factors+ adjusted_points[:, i] *= scale_factorsreturn Camera.points_to_pixel_coords(self, adjusted_points)+class ThreeDCamera(CameraWithPerspective):CONFIG = {- "sun_vect" : 5*UP+LEFT,- "shading_factor" : 0.2,- "distance" : 5.,- "default_distance" : 5.,- "phi" : 0, #Angle off z axis- "theta" : -TAU/4, #Rotation about z axis+ "sun_vect": 5 * UP + LEFT,+ "shading_factor": 0.2,+ "distance": 5.,+ "default_distance": 5.,+ "phi": 0, # Angle off z axis+ "theta": -TAU / 4, # Rotation about z axis}+def __init__(self, *args, **kwargs):Camera.__init__(self, *args, **kwargs)- self.unit_sun_vect = self.sun_vect/np.linalg.norm(self.sun_vect)- ## rotation_mobject lives in the phi-theta-distance space- ## TODO, use ValueTracker for this instead+ self.unit_sun_vect = self.sun_vect / np.linalg.norm(self.sun_vect)+ # rotation_mobject lives in the phi-theta-distance space+ # TODO, use ValueTracker for this insteadself.rotation_mobject = VectorizedPoint()- ## moving_center lives in the x-y-z space- ## It representes the center of rotation+ # moving_center lives in the x-y-z space+ # It representes the center of rotationself.moving_center = VectorizedPoint(self.space_center)self.set_position(self.phi, self.theta, self.distance)@@ -63,30 +67,31 @@ class ThreeDCamera(CameraWithPerspective):def get_shaded_rgb(self, rgb, normal_vect):brightness = np.dot(normal_vect, self.unit_sun_vect)**2if brightness > 0:- alpha = self.shading_factor*brightness+ alpha = self.shading_factor * brightnessreturn interpolate(rgb, np.ones(3), alpha)else:- alpha = -self.shading_factor*brightness+ alpha = -self.shading_factor * brightnessreturn interpolate(rgb, np.zeros(3), alpha)def get_unit_normal_vect(self, vmobject):anchors = vmobject.get_anchors()if len(anchors) < 3:return OUT- normal = np.cross(anchors[1]-anchors[0], anchors[2]-anchors[1])+ normal = np.cross(anchors[1] - anchors[0], anchors[2] - anchors[1])if normal[2] < 0:normal = -normallength = np.linalg.norm(normal)if length == 0:return OUT- return normal/length+ return normal / lengthdef display_multiple_vectorized_mobjects(self, vmobjects):camera_point = self.spherical_coords_to_point(*self.get_spherical_coords())+def z_cmp(*vmobs):- # Compare to three dimensional mobjects based on+ # Compare to three dimensional mobjects based on# how close they are to the camera# return cmp(*[# -np.linalg.norm(vm.get_center()-camera_point)@@ -103,22 +108,26 @@ class ThreeDCamera(CameraWithPerspective):else:return 0Camera.display_multiple_vectorized_mobjects(- self, sorted(vmobjects, cmp = z_cmp)+ self, sorted(vmobjects, cmp=z_cmp))- def get_spherical_coords(self, phi = None, theta = None, distance = None):+ def get_spherical_coords(self, phi=None, theta=None, distance=None):curr_phi, curr_theta, curr_d = self.rotation_mobject.points[0]- if phi is None: phi = curr_phi- if theta is None: theta = curr_theta- if distance is None: distance = curr_d+ if phi is None:+ phi = curr_phi+ if theta is None:+ theta = curr_theta+ if distance is None:+ distance = curr_dreturn np.array([phi, theta, distance])- def get_cartesian_coords(self, phi = None, theta = None, distance = None):- spherical_coords_array = self.get_spherical_coords(phi,theta,distance)+ def get_cartesian_coords(self, phi=None, theta=None, distance=None):+ spherical_coords_array = self.get_spherical_coords(+ phi, theta, distance)phi2 = spherical_coords_array[0]theta2 = spherical_coords_array[1]d2 = spherical_coords_array[2]- return self.spherical_coords_to_point(phi2,theta2,d2)+ return self.spherical_coords_to_point(phi2, theta2, d2)def get_phi(self):return self.get_spherical_coords()[0]@@ -130,13 +139,13 @@ class ThreeDCamera(CameraWithPerspective):return self.get_spherical_coords()[2]def spherical_coords_to_point(self, phi, theta, distance):- return distance*np.array([- np.sin(phi)*np.cos(theta),- np.sin(phi)*np.sin(theta),+ return distance * np.array([+ np.sin(phi) * np.cos(theta),+ np.sin(phi) * np.sin(theta),np.cos(phi)])- def get_center_of_rotation(self, x = None, y = None, z = None):+ def get_center_of_rotation(self, x=None, y=None, z=None):curr_x, curr_y, curr_z = self.moving_center.points[0]if x is None:x = curr_x@@ -146,19 +155,20 @@ class ThreeDCamera(CameraWithPerspective):z = curr_zreturn np.array([x, y, z])- def set_position(self, phi = None, theta = None, distance = None,- center_x = None, center_y = None, center_z = None):+ def set_position(self, phi=None, theta=None, distance=None,+ center_x=None, center_y=None, center_z=None):point = self.get_spherical_coords(phi, theta, distance)self.rotation_mobject.move_to(point)self.phi, self.theta, self.distance = point- center_of_rotation = self.get_center_of_rotation(center_x, center_y, center_z)+ center_of_rotation = self.get_center_of_rotation(+ center_x, center_y, center_z)self.moving_center.move_to(center_of_rotation)self.space_center = self.moving_center.points[0]def get_view_transformation_matrix(self):return (self.default_distance / self.get_distance()) * np.dot(rotation_matrix(self.get_phi(), LEFT),- rotation_about_z(-self.get_theta() - np.pi/2),+ rotation_about_z(-self.get_theta() - np.pi / 2),)def points_to_pixel_coords(self, points):diff --git a/constants.py b/constants.pyindex 3105f1cb7..af068348f 100644--- a/constants.py+++ b/constants.py@@ -3,31 +3,34 @@ import numpy as np# Things anyone wishing to use this repository for their# own use will want to change this-MEDIA_DIR = os.path.join(os.path.expanduser('~'), "Dropbox (3Blue1Brown)/3Blue1Brown Team Folder")+MEDIA_DIR = os.path.join(+ os.path.expanduser('~'),+ "Dropbox (3Blue1Brown)/3Blue1Brown Team Folder"+)#DEFAULT_PIXEL_HEIGHT = 1080-DEFAULT_PIXEL_WIDTH = 1920+DEFAULT_PIXEL_WIDTH = 1920-LOW_QUALITY_FRAME_DURATION = 1./15-MEDIUM_QUALITY_FRAME_DURATION = 1./30-PRODUCTION_QUALITY_FRAME_DURATION = 1./60+LOW_QUALITY_FRAME_DURATION = 1. / 15+MEDIUM_QUALITY_FRAME_DURATION = 1. / 30+PRODUCTION_QUALITY_FRAME_DURATION = 1. / 60-#There might be other configuration than pixel_shape later...+# There might be other configuration than pixel_shape later...PRODUCTION_QUALITY_CAMERA_CONFIG = {- "pixel_shape" : (DEFAULT_PIXEL_HEIGHT, DEFAULT_PIXEL_WIDTH),+ "pixel_shape": (DEFAULT_PIXEL_HEIGHT, DEFAULT_PIXEL_WIDTH),}MEDIUM_QUALITY_CAMERA_CONFIG = {- "pixel_shape" : (720, 1280),+ "pixel_shape": (720, 1280),}LOW_QUALITY_CAMERA_CONFIG = {- "pixel_shape" : (480, 854),+ "pixel_shape": (480, 854),}-DEFAULT_POINT_DENSITY_2D = 25+DEFAULT_POINT_DENSITY_2D = 25DEFAULT_POINT_DENSITY_1D = 250DEFAULT_POINT_THICKNESS = 4@@ -35,8 +38,8 @@ DEFAULT_POINT_THICKNESS = 4FRAME_HEIGHT = 8.0FRAME_WIDTH = FRAME_HEIGHT * DEFAULT_PIXEL_WIDTH / DEFAULT_PIXEL_HEIGHT-FRAME_Y_RADIUS = FRAME_HEIGHT/2-FRAME_X_RADIUS = FRAME_WIDTH/2+FRAME_Y_RADIUS = FRAME_HEIGHT / 2+FRAME_X_RADIUS = FRAME_WIDTH / 2SMALL_BUFF = 0.1MED_SMALL_BUFF = 0.25@@ -47,49 +50,49 @@ DEFAULT_MOBJECT_TO_EDGE_BUFFER = MED_LARGE_BUFFDEFAULT_MOBJECT_TO_MOBJECT_BUFFER = MED_SMALL_BUFF-#All in seconds+# All in secondsDEFAULT_ANIMATION_RUN_TIME = 1.0DEFAULT_POINTWISE_FUNCTION_RUN_TIME = 3.0DEFAULT_WAIT_TIME = 1.0-ORIGIN = np.array(( 0., 0., 0.))-UP = np.array(( 0., 1., 0.))-DOWN = np.array(( 0.,-1., 0.))-RIGHT = np.array(( 1., 0., 0.))-LEFT = np.array((-1., 0., 0.))-IN = np.array(( 0., 0.,-1.))-OUT = np.array(( 0., 0., 1.))-X_AXIS = np.array(( 1., 0., 0.))-Y_AXIS = np.array(( 0., 1., 0.))-Z_AXIS = np.array(( 0., 0., 1.))+ORIGIN = np.array((0., 0., 0.))+UP = np.array((0., 1., 0.))+DOWN = np.array((0., -1., 0.))+RIGHT = np.array((1., 0., 0.))+LEFT = np.array((-1., 0., 0.))+IN = np.array((0., 0., -1.))+OUT = np.array((0., 0., 1.))+X_AXIS = np.array((1., 0., 0.))+Y_AXIS = np.array((0., 1., 0.))+Z_AXIS = np.array((0., 0., 1.))-TOP = FRAME_Y_RADIUS*UP-BOTTOM = FRAME_Y_RADIUS*DOWN-LEFT_SIDE = FRAME_X_RADIUS*LEFT-RIGHT_SIDE = FRAME_X_RADIUS*RIGHT+TOP = FRAME_Y_RADIUS * UP+BOTTOM = FRAME_Y_RADIUS * DOWN+LEFT_SIDE = FRAME_X_RADIUS * LEFT+RIGHT_SIDE = FRAME_X_RADIUS * RIGHT-TAU = 2*np.pi-DEGREES = TAU/360+TAU = 2 * np.pi+DEGREES = TAU / 360ANIMATIONS_DIR = os.path.join(MEDIA_DIR, "animations")RASTER_IMAGE_DIR = os.path.join(MEDIA_DIR, "designs", "raster_images")SVG_IMAGE_DIR = os.path.join(MEDIA_DIR, "designs", "svg_images")-#TODO, staged scenes should really go into a subdirectory of a given scenes directory-STAGED_SCENES_DIR = os.path.join(ANIMATIONS_DIR, "staged_scenes")+# TODO, staged scenes should really go into a subdirectory of a given scenes directory+STAGED_SCENES_DIR = os.path.join(ANIMATIONS_DIR, "staged_scenes")###-THIS_DIR = os.path.dirname(os.path.realpath(__file__))-FILE_DIR = os.path.join(THIS_DIR, "files")-TEX_DIR = os.path.join(FILE_DIR, "Tex")-TEX_IMAGE_DIR = TEX_DIR #TODO, What is this doing?-#These two may be depricated now.-MOBJECT_DIR = os.path.join(FILE_DIR, "mobjects")+THIS_DIR = os.path.dirname(os.path.realpath(__file__))+FILE_DIR = os.path.join(THIS_DIR, "files")+TEX_DIR = os.path.join(FILE_DIR, "Tex")+TEX_IMAGE_DIR = TEX_DIR # TODO, What is this doing?+# These two may be depricated now.+MOBJECT_DIR = os.path.join(FILE_DIR, "mobjects")IMAGE_MOBJECT_DIR = os.path.join(MOBJECT_DIR, "image")if not os.path.exists(MEDIA_DIR):raise Exception("""- Redefine MEDIA_DIR in constants.py to point to- a valid directory where movies and images will+ Redefine MEDIA_DIR in constants.py to point to+ a valid directory where movies and images willbe written""")for folder in [FILE_DIR, RASTER_IMAGE_DIR, SVG_IMAGE_DIR, ANIMATIONS_DIR, TEX_DIR,@@ -99,82 +102,72 @@ for folder in [FILE_DIR, RASTER_IMAGE_DIR, SVG_IMAGE_DIR, ANIMATIONS_DIR, TEX_DIos.makedirs(folder)TEX_TEXT_TO_REPLACE = "YourTextHere"-TEMPLATE_TEX_FILE = os.path.join(THIS_DIR, "template.tex")+TEMPLATE_TEX_FILE = os.path.join(THIS_DIR, "template.tex")TEMPLATE_TEXT_FILE = os.path.join(THIS_DIR, "text_template.tex")FFMPEG_BIN = "ffmpeg"-### Colors ###+# ColorsCOLOR_MAP = {- "DARK_BLUE" : "#236B8E",- "DARK_BROWN" : "#8B4513",- "LIGHT_BROWN" : "#CD853F",- "BLUE_E" : "#1C758A",- "BLUE_D" : "#29ABCA",- "BLUE_C" : "#58C4DD",- "BLUE_B" : "#9CDCEB",- "BLUE_A" : "#C7E9F1",- "TEAL_E" : "#49A88F",- "TEAL_D" : "#55C1A7",- "TEAL_C" : "#5CD0B3",- "TEAL_B" : "#76DDC0",- "TEAL_A" : "#ACEAD7",- "GREEN_E" : "#699C52",- "GREEN_D" : "#77B05D",- "GREEN_C" : "#83C167",- "GREEN_B" : "#A6CF8C",- "GREEN_A" : "#C9E2AE",- "YELLOW_E" : "#E8C11C",- "YELLOW_D" : "#F4D345",- "YELLOW_C" : "#FFFF00",- "YELLOW_B" : "#FFEA94",- "YELLOW_A" : "#FFF1B6",- "GOLD_E" : "#C78D46",- "GOLD_D" : "#E1A158",- "GOLD_C" : "#F0AC5F",- "GOLD_B" : "#F9B775",- "GOLD_A" : "#F7C797",- "RED_E" : "#CF5044",- "RED_D" : "#E65A4C",- "RED_C" : "#FC6255",- "RED_B" : "#FF8080",- "RED_A" : "#F7A1A3",- "MAROON_E" : "#94424F",- "MAROON_D" : "#A24D61",- "MAROON_C" : "#C55F73",- "MAROON_B" : "#EC92AB",- "MAROON_A" : "#ECABC1",- "PURPLE_E" : "#644172",- "PURPLE_D" : "#715582",- "PURPLE_C" : "#9A72AC",- "PURPLE_B" : "#B189C6",- "PURPLE_A" : "#CAA3E8",- "WHITE" : "#FFFFFF",- "BLACK" : "#000000",- "LIGHT_GRAY" : "#BBBBBB",- "LIGHT_GREY" : "#BBBBBB",- "GRAY" : "#888888",- "GREY" : "#888888",- "DARK_GREY" : "#444444",- "DARK_GRAY" : "#444444",- "GREY_BROWN" : "#736357",- "PINK" : "#D147BD",+ "DARK_BLUE": "#236B8E",+ "DARK_BROWN": "#8B4513",+ "LIGHT_BROWN": "#CD853F",+ "BLUE_E": "#1C758A",+ "BLUE_D": "#29ABCA",+ "BLUE_C": "#58C4DD",+ "BLUE_B": "#9CDCEB",+ "BLUE_A": "#C7E9F1",+ "TEAL_E": "#49A88F",+ "TEAL_D": "#55C1A7",+ "TEAL_C": "#5CD0B3",+ "TEAL_B": "#76DDC0",+ "TEAL_A": "#ACEAD7",+ "GREEN_E": "#699C52",+ "GREEN_D": "#77B05D",+ "GREEN_C": "#83C167",+ "GREEN_B": "#A6CF8C",+ "GREEN_A": "#C9E2AE",+ "YELLOW_E": "#E8C11C",+ "YELLOW_D": "#F4D345",+ "YELLOW_C": "#FFFF00",+ "YELLOW_B": "#FFEA94",+ "YELLOW_A": "#FFF1B6",+ "GOLD_E": "#C78D46",+ "GOLD_D": "#E1A158",+ "GOLD_C": "#F0AC5F",+ "GOLD_B": "#F9B775",+ "GOLD_A": "#F7C797",+ "RED_E": "#CF5044",+ "RED_D": "#E65A4C",+ "RED_C": "#FC6255",+ "RED_B": "#FF8080",+ "RED_A": "#F7A1A3",+ "MAROON_E": "#94424F",+ "MAROON_D": "#A24D61",+ "MAROON_C": "#C55F73",+ "MAROON_B": "#EC92AB",+ "MAROON_A": "#ECABC1",+ "PURPLE_E": "#644172",+ "PURPLE_D": "#715582",+ "PURPLE_C": "#9A72AC",+ "PURPLE_B": "#B189C6",+ "PURPLE_A": "#CAA3E8",+ "WHITE": "#FFFFFF",+ "BLACK": "#000000",+ "LIGHT_GRAY": "#BBBBBB",+ "LIGHT_GREY": "#BBBBBB",+ "GRAY": "#888888",+ "GREY": "#888888",+ "DARK_GREY": "#444444",+ "DARK_GRAY": "#444444",+ "GREY_BROWN": "#736357",+ "PINK": "#D147BD","GREEN_SCREEN": "#00FF00",- "ORANGE" : "#FF862F",+ "ORANGE": "#FF862F",}PALETTE = COLOR_MAP.values()locals().update(COLOR_MAP)-for name in filter(lambda s : s.endswith("_C"), COLOR_MAP.keys()):+for name in filter(lambda s: s.endswith("_C"), COLOR_MAP.keys()):locals()[name.replace("_C", "")] = locals()[name]----------diff --git a/container/container.py b/container/container.pyindex 51a2b3a20..b3e9b6a10 100644--- a/container/container.py+++ b/container/container.py@@ -1,22 +1,24 @@-from constants import *from utils.config_ops import digest_config# Currently, this is only used by both Scene and MOBject.# Still, we abstract its functionality here, albeit purely nominally.# All actual implementation has to be handled by derived classes for now.#-# Note that although the prototypical instances add and remove MObjects,-# there is also the possibility to add ContinualAnimations to Scenes. Thus,-# in the Container class in general, we do not make any presumptions about+# Note that although the prototypical instances add and remove MObjects,+# there is also the possibility to add ContinualAnimations to Scenes. Thus,+# in the Container class in general, we do not make any presumptions about# what types of objects may be added; this is again dependent on the specific# derived instance.+class Container(object):def __init__(self, *submobjects, **kwargs):digest_config(self, kwargs)def add(self, *items):- raise Exception("Container.add is not implemented; it is up to derived classes to implement")+ raise Exception(+ "Container.add is not implemented; it is up to derived classes to implement")def remove(self, *items):- raise Exception("Container.remove is not implemented; it is up to derived classes to implement")\ No newline at end of file+ raise Exception(+ "Container.remove is not implemented; it is up to derived classes to implement")diff --git a/continual_animation/continual_animation.py b/continual_animation/continual_animation.pyindex 814b00c15..5ecee74ce 100644--- a/continual_animation/continual_animation.py+++ b/continual_animation/continual_animation.py@@ -6,12 +6,14 @@ from mobject.mobject import Mobjectfrom utils.config_ops import digest_configfrom utils.config_ops import instantiate+class ContinualAnimation(object):CONFIG = {- "start_up_time" : 1,- "wind_down_time" : 1,- "end_time" : np.inf,+ "start_up_time": 1,+ "wind_down_time": 1,+ "end_time": np.inf,}+def __init__(self, mobject, **kwargs):mobject = instantiate(mobject)assert(isinstance(mobject, Mobject))@@ -22,42 +24,45 @@ class ContinualAnimation(object):self.update(0)def setup(self):- #To implement in subclass+ # To implement in subclasspass- def begin_wind_down(self, wind_down_time = None):+ def begin_wind_down(self, wind_down_time=None):if wind_down_time is not None:self.wind_down_time = wind_down_timeself.end_time = self.external_time + self.wind_down_timedef update(self, dt):- #TODO, currenty time moves slower for a- #continual animation during its start up- #to help smooth things out. Does this have- #unwanted consequences?+ # TODO, currenty time moves slower for a+ # continual animation during its start up+ # to help smooth things out. Does this have+ # unwanted consequences?self.external_time += dtif self.external_time < self.start_up_time:- dt *= float(self.external_time)/self.start_up_time+ dt *= float(self.external_time) / self.start_up_timeelif self.external_time > self.end_time - self.wind_down_time:dt *= np.clip(- float(self.end_time - self.external_time)/self.wind_down_time,+ float(self.end_time - self.external_time) /+ self.wind_down_time,0, 1)self.internal_time += dtself.update_mobject(dt)def update_mobject(self, dt):- #To implement in subclass+ # To implement in subclasspassdef copy(self):return copy.deepcopy(self)+class ContinualAnimationGroup(ContinualAnimation):CONFIG = {- "start_up_time" : 0,- "wind_down_time" : 0,+ "start_up_time": 0,+ "wind_down_time": 0,}+def __init__(self, *continual_animations, **kwargs):digest_config(self, kwargs, locals())self.group = Group(*[ca.mobject for ca in continual_animations])@@ -67,12 +72,13 @@ class ContinualAnimationGroup(ContinualAnimation):for continual_animation in self.continual_animations:continual_animation.update(dt)+class ContinualRotation(ContinualAnimation):CONFIG = {- "axis" : OUT,- "rate" : np.pi/12, #Radians per second- "in_place" : True,- "about_point" : None,+ "axis": OUT,+ "rate": np.pi / 12, # Radians per second+ "in_place": True,+ "about_point": None,}def update_mobject(self, dt):@@ -83,23 +89,16 @@ class ContinualRotation(ContinualAnimation):else:about_point = ORIGINself.mobject.rotate(- dt*self.rate, axis = self.axis,- about_point = about_point+ dt * self.rate, axis=self.axis,+ about_point=about_point)+class ContinualMovement(ContinualAnimation):CONFIG = {- "direction" : RIGHT,- "rate" : 0.05, #Units per second+ "direction": RIGHT,+ "rate": 0.05, # Units per second}def update_mobject(self, dt):- self.mobject.shift(dt*self.rate*self.direction)--------+ self.mobject.shift(dt * self.rate * self.direction)diff --git a/continual_animation/from_animation.py b/continual_animation/from_animation.pyindex bcbdc0a24..d0bc9e818 100644--- a/continual_animation/from_animation.py+++ b/continual_animation/from_animation.py@@ -2,20 +2,23 @@ from __future__ import absolute_importfrom continual_animation.continual_animation import ContinualAnimation+class NormalAnimationAsContinualAnimation(ContinualAnimation):CONFIG = {- "start_up_time" : 0,- "wind_down_time" : 0,+ "start_up_time": 0,+ "wind_down_time": 0,}+def __init__(self, animation, **kwargs):self.animation = animationContinualAnimation.__init__(self, animation.mobject, **kwargs)def update_mobject(self, dt):self.animation.update(- min(float(self.internal_time)/self.animation.run_time, 1)+ min(float(self.internal_time) / self.animation.run_time, 1))+class CycleAnimation(ContinualAnimation):def __init__(self, animation, **kwargs):self.animation = animation@@ -23,6 +26,5 @@ class CycleAnimation(ContinualAnimation):def update_mobject(self, dt):mod_value = self.internal_time % self.animation.run_time- alpha = mod_value/float(self.animation.run_time)+ alpha = mod_value / float(self.animation.run_time)self.animation.update(alpha)-diff --git a/continual_animation/numbers.py b/continual_animation/numbers.pyindex 42679af67..8c618ace2 100644--- a/continual_animation/numbers.py+++ b/continual_animation/numbers.py@@ -3,6 +3,7 @@ from __future__ import absolute_importfrom continual_animation.from_animation import NormalAnimationAsContinualAnimationfrom animation.numbers import ChangingDecimal+class ContinualChangingDecimal(NormalAnimationAsContinualAnimation):def __init__(self, *args, **kwargs):NormalAnimationAsContinualAnimation.__init__(diff --git a/continual_animation/update.py b/continual_animation/update.pyindex d891c11c7..bdc93e982 100644--- a/continual_animation/update.py+++ b/continual_animation/update.py@@ -6,8 +6,9 @@ from animation.update import MaintainPositionRelativeToclass ContinualUpdateFromFunc(ContinualAnimation):CONFIG = {- "function_depends_on_dt" : False+ "function_depends_on_dt": False}+def __init__(self, mobject, func, **kwargs):self.func = funcContinualAnimation.__init__(self, mobject, **kwargs)@@ -18,16 +19,19 @@ class ContinualUpdateFromFunc(ContinualAnimation):else:self.func(self.mobject)+class ContinualUpdateFromTimeFunc(ContinualUpdateFromFunc):CONFIG = {- "function_depends_on_dt" : True+ "function_depends_on_dt": True}+class ContinualMaintainPositionRelativeTo(ContinualAnimation):# TODO: Possibly reimplement using CycleAnimation?def __init__(self, mobject, tracked_mobject, **kwargs):- self.anim = MaintainPositionRelativeTo(mobject, tracked_mobject, **kwargs)+ self.anim = MaintainPositionRelativeTo(+ mobject, tracked_mobject, **kwargs)ContinualAnimation.__init__(self, mobject, **kwargs)def update_mobject(self, dt):- self.anim.update(0) # 0 is arbitrary+ self.anim.update(0) # 0 is arbitrarydiff --git a/example_scenes.py b/example_scenes.pyindex fb465d92b..7c543064e 100644--- a/example_scenes.py+++ b/example_scenes.py@@ -4,8 +4,8 @@ from big_ol_pile_of_manim_imports import *# To watch one of these scenes, run the following:# python extract_scene.py file_name <SceneName> -p-#-# Use the flat -l for a faster rendering at a lower+#+# Use the flat -l for a faster rendering at a lower# quality, use -s to skip to the end and just show# the final frame, and use -n <number> to skip ahead# to the n'th animation of a scene.@@ -16,17 +16,18 @@ class SquareToCircle(Scene):circle = Circle()square = Square()square.flip(RIGHT)- square.rotate(-3*TAU/8)+ square.rotate(-3 * TAU / 8)self.play(ShowCreation(square))self.play(Transform(square, circle))self.play(FadeOut(square))+class WarpSquare(Scene):def construct(self):square = Square()self.play(ApplyPointwiseFunction(- lambda (x, y, z) : complex_to_R3(np.exp(complex(x, y))),+ lambda (x, y, z): complex_to_R3(np.exp(complex(x, y))),square))self.wait()@@ -42,8 +43,8 @@ class Rotation3d(ThreeDScene):# STEP 1# Build two cube in the 3D scene, one for around the origin,# the other shifted along the vector RIGHT + UP + OUT- cube_origin = Cube(fill_opacity = 0.8, stroke_width = 1.,- side_length = 1., fill_color = WHITE)+ cube_origin = Cube(fill_opacity=0.8, stroke_width=1.,+ side_length=1., fill_color=WHITE)# RIGHT side: Red# UP side: Green@@ -51,15 +52,15 @@ class Rotation3d(ThreeDScene):orientations = [IN, OUT, LEFT, RIGHT, UP, DOWN]for face, orient in zip(cube_origin.family_members_with_points(), orientations):if np.array_equal(orient, RIGHT):- face.set_style_data(fill_color = RED)+ face.set_style_data(fill_color=RED)elif np.array_equal(orient, UP):- face.set_style_data(fill_color = GREEN)+ face.set_style_data(fill_color=GREEN)elif np.array_equal(orient, OUT):- face.set_style_data(fill_color = BLUE)+ face.set_style_data(fill_color=BLUE)- cube_shifted = Cube(fill_opacity = 0.8, stroke_width = 1.,- side_length = 1., fill_color = BLUE)- shift_vec = 2*(RIGHT + UP + OUT)+ cube_shifted = Cube(fill_opacity=0.8, stroke_width=1.,+ side_length=1., fill_color=BLUE)+ shift_vec = 2 * (RIGHT + UP + OUT)cube_shifted.shift(shift_vec)# STEP 2@@ -71,8 +72,8 @@ class Rotation3d(ThreeDScene):# Setup the camera positionphi, theta, distance = ThreeDCamera().get_spherical_coords()angle_factor = 0.9- phi += 2*np.pi/4*angle_factor- theta += 3*2*np.pi/8+ phi += 2 * np.pi / 4 * angle_factor+ theta += 3 * 2 * np.pi / 8self.set_camera_position(phi, theta, distance)self.wait()@@ -80,23 +81,23 @@ class Rotation3d(ThreeDScene):# Animation# Animation 1: rotation around the Z-axis with the ORIGIN of the space# as center of rotation- theta += 2*np.pi+ theta += 2 * np.piself.move_camera(phi, theta, distance,- run_time = 5)+ run_time=5)# Animation 2: shift the space in order of to get the center of the shifted cube# as the next center of rotationcube_center = cube_shifted.get_center()- self.move_camera(center_x = cube_center[0],- center_y = cube_center[1],- center_z = cube_center[2],- run_time = 2)+ self.move_camera(center_x=cube_center[0],+ center_y=cube_center[1],+ center_z=cube_center[2],+ run_time=2)- # Animation 3: rotation around the Z-axis with the center of the shifted cube+ # Animation 3: rotation around the Z-axis with the center of the shifted cube# as center of rotation- theta += 2*np.pi+ theta += 2 * np.piself.move_camera(phi, theta, distance,- run_time = 5)+ run_time=5)class SpinAroundCube(ThreeDScene):@@ -112,28 +113,28 @@ class SpinAroundCube(ThreeDScene):def construct(self):axes = ThreeDAxes()cube = Cube(- fill_opacity = 1,- stroke_color = LIGHT_GREY,- stroke_width = 1,+ fill_opacity=1,+ stroke_color=LIGHT_GREY,+ stroke_width=1,)# The constant OUT is np.array([0, 0, 1])- cube.next_to(ORIGIN, UP+RIGHT+OUT)+ cube.next_to(ORIGIN, UP + RIGHT + OUT)self.add(axes, cube)# The camera starts positioned with phi=0, meaning it- # is directly above the xy-plane, and theta = -TAU/4,+ # is directly above the xy-plane, and theta = -TAU/4,# which makes the "down" direction of the screen point# in the negative y direction.# This animates a camera movementself.move_camera(# Tilted 20 degrees off xy plane (70 degrees off the vertical)- phi = (70./360.)*TAU,+ phi=(70. / 360.) * TAU,# Positioned above the third quadrant of# the xy-plane- theta = (-110./360.)*TAU,+ theta=(-110. / 360.) * TAU,# pass in animation config just like a .play call- run_time = 3+ run_time=3)self.wait()# If you want the camera to slowly rotate about@@ -142,33 +143,17 @@ class SpinAroundCube(ThreeDScene):self.wait(4)self.play(FadeOut(cube))--text = TextMobject("Your ad here")- text.rotate(TAU/4, axis = RIGHT)+ text.rotate(TAU / 4, axis=RIGHT)text.next_to(cube, OUT)self.play(Write(text))# If you want to play animations while moving the camera,# include them in an "added_anims" list to move_cameraself.move_camera(- theta = -0.2*TAU,- added_anims = [- text.shift, 3*OUT,- text.set_fill, {"opacity" : 1},+ theta=-0.2 * TAU,+ added_anims=[+ text.shift, 3 * OUT,+ text.set_fill, {"opacity": 1},])self.wait(4)--------------diff --git a/extract_scene.py b/extract_scene.pyindex b129b4ae6..f35d3564c 100644--- a/extract_scene.py+++ b/extract_scene.py@@ -3,7 +3,6 @@import sysimport argparseimport imp-import impimport inspectimport itertools as itimport os@@ -12,7 +11,6 @@ import tracebackfrom constants import *-from camera.camera import Camerafrom scene.scene import Scenefrom utils.sounds import play_error_soundfrom utils.sounds import play_finish_sound@@ -45,169 +43,178 @@ NO_SCENE_MESSAGE = """def get_configuration():- try:- parser = argparse.ArgumentParser()- parser.add_argument(- "file", help = "path to file holding the python code for the scene"- )- parser.add_argument(- "scene_name", help = "Name of the Scene class you want to see"- )- optional_args = [- ("-p", "--preview"),- ("-w", "--write_to_movie"),- ("-s", "--show_last_frame"),- ("-l", "--low_quality"),- ("-m", "--medium_quality"),- ("-g", "--save_pngs"),- ("-f", "--show_file_in_finder"),- ("-t", "--transparent"),- ("-q", "--quiet"),- ("-a", "--write_all")- ]- for short_arg, long_arg in optional_args:- parser.add_argument(short_arg, long_arg, action = "store_true")- parser.add_argument("-o", "--output_name")- parser.add_argument("-n", "--start_at_animation_number")- args = parser.parse_args()- if args.output_name != None:- output_name_root, output_name_ext = os.path.splitext(args.output_name)- expected_ext = '.png' if args.show_last_frame else '.mp4'- if not output_name_ext in ['', expected_ext]:- print "WARNING: The output will be to (doubly-dotted) %s%s"%output_name_root%expected_ext+ try:+ parser = argparse.ArgumentParser()+ parser.add_argument(+ "file", help="path to file holding the python code for the scene"+ )+ parser.add_argument(+ "scene_name", help="Name of the Scene class you want to see"+ )+ optional_args = [+ ("-p", "--preview"),+ ("-w", "--write_to_movie"),+ ("-s", "--show_last_frame"),+ ("-l", "--low_quality"),+ ("-m", "--medium_quality"),+ ("-g", "--save_pngs"),+ ("-f", "--show_file_in_finder"),+ ("-t", "--transparent"),+ ("-q", "--quiet"),+ ("-a", "--write_all")+ ]+ for short_arg, long_arg in optional_args:+ parser.add_argument(short_arg, long_arg, action="store_true")+ parser.add_argument("-o", "--output_name")+ parser.add_argument("-n", "--start_at_animation_number")+ args = parser.parse_args()+ if args.output_name is not None:+ output_name_root, output_name_ext = os.path.splitext(+ args.output_name)+ expected_ext = '.png' if args.show_last_frame else '.mp4'+ if output_name_ext not in ['', expected_ext]:+ print "WARNING: The output will be to (doubly-dotted) %s%s" % output_name_root % expected_ext+ output_name = args.output_name+ else:+ # If anyone wants .mp4.mp4 and is surprised to only get .mp4, or such... Well, too bad.+ output_name = output_name_root+ else:output_name = args.output_name- else:- # If anyone wants .mp4.mp4 and is surprised to only get .mp4, or such... Well, too bad.- output_name = output_name_root- else:- output_name = args.output_name- except argparse.ArgumentError as err:- print(str(err))- sys.exit(2)- config = {- "file" : args.file,- "scene_name" : args.scene_name,- "open_video_upon_completion" : args.preview,- "show_file_in_finder" : args.show_file_in_finder,- #By default, write to file- "write_to_movie" : args.write_to_movie or not args.show_last_frame,- "show_last_frame" : args.show_last_frame,- "save_pngs" : args.save_pngs,- #If -t is passed in (for transparent), this will be RGBA- "saved_image_mode": "RGBA" if args.transparent else "RGB",- "movie_file_extension" : ".mov" if args.transparent else ".mp4",- "quiet" : args.quiet or args.write_all,- "ignore_waits" : args.preview,- "write_all" : args.write_all,- "output_name" : output_name,- "start_at_animation_number" : args.start_at_animation_number,- "end_at_animation_number" : None,- }- if args.low_quality:- config["camera_config"] = LOW_QUALITY_CAMERA_CONFIG- config["frame_duration"] = LOW_QUALITY_FRAME_DURATION- elif args.medium_quality:- config["camera_config"] = MEDIUM_QUALITY_CAMERA_CONFIG- config["frame_duration"] = MEDIUM_QUALITY_FRAME_DURATION- else:- config["camera_config"] = PRODUCTION_QUALITY_CAMERA_CONFIG- config["frame_duration"] = PRODUCTION_QUALITY_FRAME_DURATION-- stan = config["start_at_animation_number"]- if stan is not None:- if "," in stan:- start, end = stan.split(",")- config["start_at_animation_number"] = int(start)- config["end_at_animation_number"] = int(end)- else:- config["start_at_animation_number"] = int(stan)-- config["skip_animations"] = any([- config["show_last_frame"] and not config["write_to_movie"],- config["start_at_animation_number"],- ])- return config+ except argparse.ArgumentError as err:+ print(str(err))+ sys.exit(2)+ config = {+ "file": args.file,+ "scene_name": args.scene_name,+ "open_video_upon_completion": args.preview,+ "show_file_in_finder": args.show_file_in_finder,+ # By default, write to file+ "write_to_movie": args.write_to_movie or not args.show_last_frame,+ "show_last_frame": args.show_last_frame,+ "save_pngs": args.save_pngs,+ # If -t is passed in (for transparent), this will be RGBA+ "saved_image_mode": "RGBA" if args.transparent else "RGB",+ "movie_file_extension": ".mov" if args.transparent else ".mp4",+ "quiet": args.quiet or args.write_all,+ "ignore_waits": args.preview,+ "write_all": args.write_all,+ "output_name": output_name,+ "start_at_animation_number": args.start_at_animation_number,+ "end_at_animation_number": None,+ }+ if args.low_quality:+ config["camera_config"] = LOW_QUALITY_CAMERA_CONFIG+ config["frame_duration"] = LOW_QUALITY_FRAME_DURATION+ elif args.medium_quality:+ config["camera_config"] = MEDIUM_QUALITY_CAMERA_CONFIG+ config["frame_duration"] = MEDIUM_QUALITY_FRAME_DURATION+ else:+ config["camera_config"] = PRODUCTION_QUALITY_CAMERA_CONFIG+ config["frame_duration"] = PRODUCTION_QUALITY_FRAME_DURATION++ stan = config["start_at_animation_number"]+ if stan is not None:+ if "," in stan:+ start, end = stan.split(",")+ config["start_at_animation_number"] = int(start)+ config["end_at_animation_number"] = int(end)+ else:+ config["start_at_animation_number"] = int(stan)++ config["skip_animations"] = any([+ config["show_last_frame"] and not config["write_to_movie"],+ config["start_at_animation_number"],+ ])+ return config+def handle_scene(scene, **config):- import platform- if config["quiet"]:- curr_stdout = sys.stdout- sys.stdout = open(os.devnull, "w")-- if config["show_last_frame"]:- scene.save_image(mode = config["saved_image_mode"])- open_file = any([- config["show_last_frame"],- config["open_video_upon_completion"],- config["show_file_in_finder"]- ])- if open_file:- commands = ["open"]- if (platform.system() == "Linux"):- commands = ["xdg-open"]-- if config["show_file_in_finder"]:- commands.append("-R")- #- if config["show_last_frame"]:- commands.append(scene.get_image_file_path())- else:- commands.append(scene.get_movie_file_path())- FNULL = open(os.devnull, 'w')- sp.call(commands, stdout=FNULL, stderr=sp.STDOUT)- FNULL.close()-- if config["quiet"]:- sys.stdout.close()- sys.stdout = curr_stdout+ import platform+ if config["quiet"]:+ curr_stdout = sys.stdout+ sys.stdout = open(os.devnull, "w")++ if config["show_last_frame"]:+ scene.save_image(mode=config["saved_image_mode"])+ open_file = any([+ config["show_last_frame"],+ config["open_video_upon_completion"],+ config["show_file_in_finder"]+ ])+ if open_file:+ commands = ["open"]+ if (platform.system() == "Linux"):+ commands = ["xdg-open"]++ if config["show_file_in_finder"]:+ commands.append("-R")+ #+ if config["show_last_frame"]:+ commands.append(scene.get_image_file_path())+ else:+ commands.append(scene.get_movie_file_path())+ FNULL = open(os.devnull, 'w')+ sp.call(commands, stdout=FNULL, stderr=sp.STDOUT)+ FNULL.close()++ if config["quiet"]:+ sys.stdout.close()+ sys.stdout = curr_stdout+def is_scene(obj):- if not inspect.isclass(obj):- return False- if not issubclass(obj, Scene):- return False- if obj == Scene:- return False- return True+ if not inspect.isclass(obj):+ return False+ if not issubclass(obj, Scene):+ return False+ if obj == Scene:+ return False+ return True+def prompt_user_for_choice(name_to_obj):- num_to_name = {}- names = sorted(name_to_obj.keys())- for count, name in zip(it.count(1), names):- print("%d: %s"%(count, name))- num_to_name[count] = name- try:- user_input = raw_input(CHOOSE_NUMBER_MESSAGE)- return [- name_to_obj[num_to_name[int(num_str)]]- for num_str in user_input.split(",")- ]- except:- print(INVALID_NUMBER_MESSAGE)- sys.exit()+ num_to_name = {}+ names = sorted(name_to_obj.keys())+ for count, name in zip(it.count(1), names):+ print("%d: %s" % (count, name))+ num_to_name[count] = name+ try:+ user_input = raw_input(CHOOSE_NUMBER_MESSAGE)+ return [+ name_to_obj[num_to_name[int(num_str)]]+ for num_str in user_input.split(",")+ ]+ except:+ print(INVALID_NUMBER_MESSAGE)+ sys.exit()+def get_scene_classes(scene_names_to_classes, config):- if len(scene_names_to_classes) == 0:- print(NO_SCENE_MESSAGE)- return []- if len(scene_names_to_classes) == 1:- return scene_names_to_classes.values()- if config["scene_name"] in scene_names_to_classes:- return [scene_names_to_classes[config["scene_name"]] ]- if config["scene_name"] != "":- print(SCENE_NOT_FOUND_MESSAGE)- return []- if config["write_all"]:- return scene_names_to_classes.values()- return prompt_user_for_choice(scene_names_to_classes)+ if len(scene_names_to_classes) == 0:+ print(NO_SCENE_MESSAGE)+ return []+ if len(scene_names_to_classes) == 1:+ return scene_names_to_classes.values()+ if config["scene_name"] in scene_names_to_classes:+ return [scene_names_to_classes[config["scene_name"]]]+ if config["scene_name"] != "":+ print(SCENE_NOT_FOUND_MESSAGE)+ return []+ if config["write_all"]:+ return scene_names_to_classes.values()+ return prompt_user_for_choice(scene_names_to_classes)+def get_module_windows(file_name):- module_name = file_name.replace(".py", "")- last_module = imp.load_module("__init__", *imp.find_module("__init__", ['.']))- for part in module_name.split(os.sep):- load_args = imp.find_module(part, [os.path.dirname(last_module.__file__)])- last_module = imp.load_module(part, *load_args)- return last_module+ module_name = file_name.replace(".py", "")+ last_module = imp.load_module(+ "__init__", *imp.find_module("__init__", ['.']))+ for part in module_name.split(os.sep):+ load_args = imp.find_module(+ part, [os.path.dirname(last_module.__file__)])+ last_module = imp.load_module(part, *load_args)+ return last_module+def get_module_posix(file_name):module_name = file_name.replace(".py", "")@@ -217,54 +224,54 @@ def get_module_posix(file_name):last_module = imp.load_module(part, *load_args)return last_module+def get_module(file_name):if os.name == 'nt':return get_module_windows(file_name)return get_module_posix(file_name)+def main():- config = get_configuration()- module = get_module(config["file"])- scene_names_to_classes = dict(- inspect.getmembers(module, is_scene)- )-- config["output_directory"] = os.path.join(- ANIMATIONS_DIR,- config["file"].replace(".py", "")- )-- scene_kwargs = dict([- (key, config[key])- for key in [- "camera_config",- "frame_duration",- "skip_animations",- "write_to_movie",- "output_directory",- "save_pngs",- "movie_file_extension",- "start_at_animation_number",- "end_at_animation_number",- ]- ])-- scene_kwargs["name"] = config["output_name"]- if config["save_pngs"]:- print "We are going to save a PNG sequence as well..."- scene_kwargs["save_pngs"] = True- scene_kwargs["pngs_mode"] = config["saved_image_mode"]-- for SceneClass in get_scene_classes(scene_names_to_classes, config):- try:- handle_scene(SceneClass(**scene_kwargs), **config)- play_finish_sound()- except:- print("\n\n")- traceback.print_exc()- print("\n\n")- play_error_sound()+ config = get_configuration()+ module = get_module(config["file"])+ scene_names_to_classes = dict(inspect.getmembers(module, is_scene))++ config["output_directory"] = os.path.join(+ ANIMATIONS_DIR,+ config["file"].replace(".py", "")+ )++ scene_kwargs = dict([+ (key, config[key])+ for key in [+ "camera_config",+ "frame_duration",+ "skip_animations",+ "write_to_movie",+ "output_directory",+ "save_pngs",+ "movie_file_extension",+ "start_at_animation_number",+ "end_at_animation_number",+ ]+ ])++ scene_kwargs["name"] = config["output_name"]+ if config["save_pngs"]:+ print "We are going to save a PNG sequence as well..."+ scene_kwargs["save_pngs"] = True+ scene_kwargs["pngs_mode"] = config["saved_image_mode"]++ for SceneClass in get_scene_classes(scene_names_to_classes, config):+ try:+ handle_scene(SceneClass(**scene_kwargs), **config)+ play_finish_sound()+ except:+ print("\n\n")+ traceback.print_exc()+ print("\n\n")+ play_error_sound()if __name__ == "__main__":- main()+ main()diff --git a/for_3b1b_videos/common_scenes.py b/for_3b1b_videos/common_scenes.pyindex f66468552..e25cd68b1 100644--- a/for_3b1b_videos/common_scenes.py+++ b/for_3b1b_videos/common_scenes.py@@ -8,10 +8,8 @@ from animation.animation import Animationfrom animation.composition import LaggedStartfrom animation.creation import DrawBorderThenFillfrom animation.creation import Write-from animation.transform import ApplyMethodfrom animation.creation import FadeInfrom animation.creation import FadeOut-from mobject.svg.tex_mobject import TexMobjectfrom mobject.svg.tex_mobject import TextMobjectfrom mobject.types.vectorized_mobject import VGroupfrom scene.scene import Scene@@ -23,42 +21,45 @@ from mobject.geometry import Rectanglefrom mobject.geometry import Squarefrom mobject.svg.drawings import PatreonLogo+class OpeningQuote(Scene):CONFIG = {- "quote" : [],- "quote_arg_separator" : " ",- "highlighted_quote_terms" : {},- "author" : "",- "fade_in_kwargs" : {- "submobject_mode" : "lagged_start",- "rate_func" : None,- "lag_factor" : 4,- "run_time" : 5,+ "quote": [],+ "quote_arg_separator": " ",+ "highlighted_quote_terms": {},+ "author": "",+ "fade_in_kwargs": {+ "submobject_mode": "lagged_start",+ "rate_func": None,+ "lag_factor": 4,+ "run_time": 5,},}+def construct(self):self.quote = self.get_quote()self.author = self.get_author(self.quote)self.play(FadeIn(self.quote, **self.fade_in_kwargs))self.wait(2)- self.play(Write(self.author, run_time = 3))+ self.play(Write(self.author, run_time=3))self.wait()- def get_quote(self, max_width = FRAME_WIDTH-1):+ def get_quote(self, max_width=FRAME_WIDTH - 1):text_mobject_kwargs = {- "alignment" : "",- "arg_separator" : self.quote_arg_separator,+ "alignment": "",+ "arg_separator": self.quote_arg_separator,}if isinstance(self.quote, str):- quote = TextMobject("``%s''"%self.quote.strip(), **text_mobject_kwargs)+ quote = TextMobject("``%s''" %+ self.quote.strip(), **text_mobject_kwargs)else:words = ["\\Large ``"] + list(self.quote) + ["''"]quote = TextMobject(*words, **text_mobject_kwargs)- ##TODO, make less hacky+ # TODO, make less hackyif self.quote_arg_separator == " ":- quote[0].shift(0.2*RIGHT)- quote[-1].shift(0.2*LEFT)+ quote[0].shift(0.2 * RIGHT)+ quote[-1].shift(0.2 * LEFT)for term, color in self.set_colored_quote_terms.items():quote.set_color_by_tex(term, color)quote.to_edge(UP)@@ -72,12 +73,14 @@ class OpeningQuote(Scene):author.set_color(YELLOW)return author+class PatreonThanks(Scene):CONFIG = {- "specific_patrons" : [],- "max_patron_group_size" : 20,- "patron_scale_val" : 0.8,+ "specific_patrons": [],+ "max_patron_group_size": 20,+ "patron_scale_val": 0.8,}+def construct(self):morty = Mortimer()morty.next_to(ORIGIN, DOWN)@@ -89,17 +92,17 @@ class PatreonThanks(Scene):patrons = map(TextMobject, self.specific_patrons)num_groups = float(len(patrons)) / self.max_patron_group_sizeproportion_range = np.linspace(0, 1, num_groups + 1)- indices = (len(patrons)*proportion_range).astype('int')+ indices = (len(patrons) * proportion_range).astype('int')patron_groups = [VGroup(*patrons[i:j])for i, j in zip(indices, indices[1:])- ]+ ]for i, group in enumerate(patron_groups):- left_group = VGroup(*group[:len(group)/2])- right_group = VGroup(*group[len(group)/2:])+ left_group = VGroup(*group[:len(group) / 2])+ right_group = VGroup(*group[len(group) / 2:])for subgroup, vect in (left_group, LEFT), (right_group, RIGHT):- subgroup.arrange_submobjects(DOWN, aligned_edge = LEFT)+ subgroup.arrange_submobjects(DOWN, aligned_edge=LEFT)subgroup.scale(self.patron_scale_val)subgroup.to_edge(vect)@@ -109,7 +112,7 @@ class PatreonThanks(Scene):if last_group is not None:self.play(FadeOut(last_group),- morty.look, UP+LEFT+ morty.look, UP + LEFT)else:anims += [@@ -117,25 +120,27 @@ class PatreonThanks(Scene):]self.play(LaggedStart(- FadeIn, group,- run_time = 2,+ FadeIn, group,+ run_time=2,),- morty.change, "gracious", group.get_corner(UP+LEFT),+ morty.change, "gracious", group.get_corner(UP + LEFT),*anims)- self.play(morty.look_at, group.get_corner(DOWN+LEFT))- self.play(morty.look_at, group.get_corner(UP+RIGHT))- self.play(morty.look_at, group.get_corner(DOWN+RIGHT))+ self.play(morty.look_at, group.get_corner(DOWN + LEFT))+ self.play(morty.look_at, group.get_corner(UP + RIGHT))+ self.play(morty.look_at, group.get_corner(DOWN + RIGHT))self.play(Blink(morty))last_group = group+class PatreonEndScreen(PatreonThanks):CONFIG = {- "n_patron_columns" : 3,- "max_patron_width" : 3,- "run_time" : 20,- "randomize_order" : True,+ "n_patron_columns": 3,+ "max_patron_width": 3,+ "run_time": 20,+ "randomize_order": True,}+def construct(self):if self.randomize_order:random.shuffle(self.specific_patrons)@@ -145,32 +150,32 @@ class PatreonEndScreen(PatreonThanks):def add_title(self):title = self.title = TextMobject("Clicky Stuffs")title.scale(1.5)- title.to_edge(UP, buff = MED_SMALL_BUFF)+ title.to_edge(UP, buff=MED_SMALL_BUFF)randy, morty = self.pi_creatures = VGroup(Randolph(), Mortimer())for pi, vect in (randy, LEFT), (morty, RIGHT):pi.scale_to_fit_height(title.get_height())pi.change_mode("thinking")pi.look(DOWN)- pi.next_to(title, vect, buff = MED_LARGE_BUFF)+ pi.next_to(title, vect, buff=MED_LARGE_BUFF)self.add_foreground_mobjects(title, randy, morty)def scroll_through_patrons(self):- logo_box = Square(side_length = 2.5)- logo_box.to_corner(DOWN+LEFT, buff = MED_LARGE_BUFF)+ logo_box = Square(side_length=2.5)+ logo_box.to_corner(DOWN + LEFT, buff=MED_LARGE_BUFF)total_width = FRAME_X_RADIUS - logo_box.get_right()[0]black_rect = Rectangle(- fill_color = BLACK,- fill_opacity = 1,- stroke_width = 0,- width = FRAME_WIDTH,- height = 1.1*FRAME_Y_RADIUS+ fill_color=BLACK,+ fill_opacity=1,+ stroke_width=0,+ width=FRAME_WIDTH,+ height=1.1 * FRAME_Y_RADIUS)- black_rect.to_edge(UP, buff = 0)- line = DashedLine(FRAME_X_RADIUS*LEFT, FRAME_X_RADIUS*RIGHT)+ black_rect.to_edge(UP, buff=0)+ line = DashedLine(FRAME_X_RADIUS * LEFT, FRAME_X_RADIUS * RIGHT)line.move_to(black_rect, DOWN)- line.shift(SMALL_BUFF*SMALL_BUFF*DOWN)+ line.shift(SMALL_BUFF * SMALL_BUFF * DOWN)self.add(line)patrons = VGroup(*map(TextMobject, self.specific_patrons))@@ -181,34 +186,36 @@ class PatreonEndScreen(PatreonThanks):columns = VGroup(*[VGroup(*patrons[i::self.n_patron_columns]- ).arrange_submobjects(DOWN, buff = MED_SMALL_BUFF)+ ).arrange_submobjects(DOWN, buff=MED_SMALL_BUFF)for i in range(self.n_patron_columns)])columns.arrange_submobjects(- RIGHT, buff = LARGE_BUFF,- aligned_edge = UP,+ RIGHT, buff=LARGE_BUFF,+ aligned_edge=UP,)columns.scale_to_fit_width(total_width - 1)- columns.next_to(black_rect, DOWN, 3*LARGE_BUFF)+ columns.next_to(black_rect, DOWN, 3 * LARGE_BUFF)columns.to_edge(RIGHT)self.play(- columns.next_to, FRAME_Y_RADIUS*DOWN, UP, LARGE_BUFF,- columns.to_edge, RIGHT,+ columns.next_to, FRAME_Y_RADIUS * DOWN, UP, LARGE_BUFF,+ columns.to_edge, RIGHT,Animation(black_rect),- rate_func = None,- run_time = self.run_time,+ rate_func=None,+ run_time=self.run_time,)+class ExternallyAnimatedScene(Scene):def construct(self):raise Exception("Don't actually run this class.")+class TODOStub(Scene):CONFIG = {- "message" : ""+ "message": ""}+def construct(self):- self.add(TextMobject("TODO: %s"%self.message))+ self.add(TextMobject("TODO: %s" % self.message))self.wait()-diff --git a/for_3b1b_videos/pi_creature.py b/for_3b1b_videos/pi_creature.pyindex ea688c467..b80a0e2a8 100644--- a/for_3b1b_videos/pi_creature.py+++ b/for_3b1b_videos/pi_creature.py@@ -18,46 +18,49 @@ from utils.rate_functions import there_and_backPI_CREATURE_DIR = os.path.join(MEDIA_DIR, "designs", "PiCreature")PI_CREATURE_SCALE_FACTOR = 0.5-LEFT_EYE_INDEX = 0-RIGHT_EYE_INDEX = 1-LEFT_PUPIL_INDEX = 2+LEFT_EYE_INDEX = 0+RIGHT_EYE_INDEX = 1+LEFT_PUPIL_INDEX = 2RIGHT_PUPIL_INDEX = 3-BODY_INDEX = 4-MOUTH_INDEX = 5+BODY_INDEX = 4+MOUTH_INDEX = 5+class PiCreature(SVGMobject):CONFIG = {- "color" : BLUE_E,- "file_name_prefix" : "PiCreatures",- "stroke_width" : 0,- "stroke_color" : BLACK,- "fill_opacity" : 1.0,- "propagate_style_to_family" : True,- "height" : 3,- "corner_scale_factor" : 0.75,- "flip_at_start" : False,- "is_looking_direction_purposeful" : False,- "start_corner" : None,- #Range of proportions along body where arms are- "right_arm_range" : [0.55, 0.7],- "left_arm_range" : [.34, .462],+ "color": BLUE_E,+ "file_name_prefix": "PiCreatures",+ "stroke_width": 0,+ "stroke_color": BLACK,+ "fill_opacity": 1.0,+ "propagate_style_to_family": True,+ "height": 3,+ "corner_scale_factor": 0.75,+ "flip_at_start": False,+ "is_looking_direction_purposeful": False,+ "start_corner": None,+ # Range of proportions along body where arms are+ "right_arm_range": [0.55, 0.7],+ "left_arm_range": [.34, .462],}- def __init__(self, mode = "plain", **kwargs):++ def __init__(self, mode="plain", **kwargs):digest_config(self, kwargs)self.parts_named = Falsetry:svg_file = os.path.join(- PI_CREATURE_DIR,- "%s_%s.svg"%(self.file_name_prefix, mode)+ PI_CREATURE_DIR,+ "%s_%s.svg" % (self.file_name_prefix, mode))- SVGMobject.__init__(self, file_name = svg_file, **kwargs)+ SVGMobject.__init__(self, file_name=svg_file, **kwargs)except:- warnings.warn("No %s design with mode %s"%(self.file_name_prefix, mode))+ warnings.warn("No %s design with mode %s" %+ (self.file_name_prefix, mode))svg_file = os.path.join(- FILE_DIR,+ FILE_DIR,"PiCreatures_plain.svg",)- SVGMobject.__init__(self, file_name = svg_file, **kwargs)+ SVGMobject.__init__(self, file_name=svg_file, **kwargs)if self.flip_at_start:self.flip()@@ -82,10 +85,10 @@ class PiCreature(SVGMobject):SVGMobject.init_colors(self)if not self.parts_named:self.name_parts()- self.mouth.set_fill(BLACK, opacity = 1)- self.body.set_fill(self.color, opacity = 1)- self.pupils.set_fill(BLACK, opacity = 1)- self.eyes.set_fill(WHITE, opacity = 1)+ self.mouth.set_fill(BLACK, opacity=1)+ self.body.set_fill(self.color, opacity=1)+ self.pupils.set_fill(BLACK, opacity=1)+ self.eyes.set_fill(WHITE, opacity=1)return selfdef copy(self):@@ -99,8 +102,8 @@ class PiCreature(SVGMobject):def change_mode(self, mode):new_self = self.__class__(- mode = mode,- color = self.color+ mode=mode,+ color=self.color)new_self.scale_to_fit_height(self.get_height())if self.is_flipped() ^ new_self.is_flipped():@@ -118,16 +121,16 @@ class PiCreature(SVGMobject):direction /= normself.purposeful_looking_direction = directionfor pupil, eye in zip(self.pupils.split(), self.eyes.split()):- pupil_radius = pupil.get_width()/2.- eye_radius = eye.get_width()/2.+ pupil_radius = pupil.get_width() / 2.+ eye_radius = eye.get_width() / 2.pupil.move_to(eye)if direction[1] < 0:- pupil.shift(pupil_radius*DOWN/3)- pupil.shift(direction*(eye_radius-pupil_radius))+ pupil.shift(pupil_radius * DOWN / 3)+ pupil.shift(direction * (eye_radius - pupil_radius))bottom_diff = eye.get_bottom()[1] - pupil.get_bottom()[1]if bottom_diff > 0:- pupil.shift(bottom_diff*UP)- #TODO, how to handle looking up...+ pupil.shift(bottom_diff * UP)+ # TODO, how to handle looking up...# top_diff = eye.get_top()[1]-pupil.get_top()[1]# if top_diff < 0:# pupil.shift(top_diff*UP)@@ -141,7 +144,7 @@ class PiCreature(SVGMobject):self.look(point - self.eyes.get_center())return self- def change(self, new_mode, look_at_arg = None):+ def change(self, new_mode, look_at_arg=None):self.change_mode(new_mode)if look_at_arg is not None:self.look_at(look_at_arg)@@ -150,27 +153,27 @@ class PiCreature(SVGMobject):def get_looking_direction(self):return np.sign(np.round(self.pupils.get_center() - self.eyes.get_center(),- decimals = 2+ decimals=2))def is_flipped(self):return self.eyes.submobjects[0].get_center()[0] > \- self.eyes.submobjects[1].get_center()[0]+ self.eyes.submobjects[1].get_center()[0]def blink(self):eye_parts = self.eye_partseye_bottom_y = eye_parts.get_bottom()[1]eye_parts.apply_function(- lambda p : [p[0], eye_bottom_y, p[2]]+ lambda p: [p[0], eye_bottom_y, p[2]])return self- def to_corner(self, vect = None, **kwargs):+ def to_corner(self, vect=None, **kwargs):if vect is not None:SVGMobject.to_corner(self, vect, **kwargs)else:self.scale(self.corner_scale_factor)- self.to_corner(DOWN+LEFT, **kwargs)+ self.to_corner(DOWN + LEFT, **kwargs)return selfdef get_bubble(self, *content, **kwargs):@@ -196,8 +199,8 @@ class PiCreature(SVGMobject):def shrug(self):self.change_mode("shruggie")top_mouth_point, bottom_mouth_point = [- self.mouth.points[np.argmax(self.mouth.points[:,1])],- self.mouth.points[np.argmin(self.mouth.points[:,1])]+ self.mouth.points[np.argmax(self.mouth.points[:, 1])],+ self.mouth.points[np.argmin(self.mouth.points[:, 1])]]self.look(top_mouth_point - bottom_mouth_point)return self@@ -209,9 +212,10 @@ class PiCreature(SVGMobject):for alpha_range in self.right_arm_range, self.left_arm_range])+def get_all_pi_creature_modes():result = []- prefix = "%s_"%PiCreature.CONFIG["file_name_prefix"]+ prefix = "%s_" % PiCreature.CONFIG["file_name_prefix"]suffix = ".svg"for file in os.listdir(PI_CREATURE_DIR):if file.startswith(prefix) and file.endswith(suffix):@@ -220,69 +224,78 @@ def get_all_pi_creature_modes():)return result+class Randolph(PiCreature):- pass #Nothing more than an alternative name+ pass # Nothing more than an alternative name+class Mortimer(PiCreature):CONFIG = {- "color" : GREY_BROWN,- "flip_at_start" : True,+ "color": GREY_BROWN,+ "flip_at_start": True,}+class Mathematician(PiCreature):CONFIG = {- "color" : GREY,+ "color": GREY,}+class BabyPiCreature(PiCreature):CONFIG = {- "scale_factor" : 0.5,- "eye_scale_factor" : 1.2,- "pupil_scale_factor" : 1.3+ "scale_factor": 0.5,+ "eye_scale_factor": 1.2,+ "pupil_scale_factor": 1.3}+def __init__(self, *args, **kwargs):PiCreature.__init__(self, *args, **kwargs)self.scale(self.scale_factor)self.shift(LEFT)- self.to_edge(DOWN, buff = LARGE_BUFF)+ self.to_edge(DOWN, buff=LARGE_BUFF)eyes = VGroup(self.eyes, self.pupils)eyes_bottom = eyes.get_bottom()eyes.scale(self.eye_scale_factor)- eyes.move_to(eyes_bottom, aligned_edge = DOWN)+ eyes.move_to(eyes_bottom, aligned_edge=DOWN)looking_direction = self.get_looking_direction()for pupil in self.pupils:pupil.scale_in_place(self.pupil_scale_factor)self.look(looking_direction)+class TauCreature(PiCreature):CONFIG = {- "file_name_prefix" : "TauCreatures"+ "file_name_prefix": "TauCreatures"}+class ThreeLeggedPiCreature(PiCreature):CONFIG = {- "file_name_prefix" : "ThreeLeggedPiCreatures"+ "file_name_prefix": "ThreeLeggedPiCreatures"}+class Eyes(VMobject):CONFIG = {- "height" : 0.3,- "thing_looked_at" : None,- "mode" : "plain",+ "height": 0.3,+ "thing_looked_at": None,+ "mode": "plain",}+def __init__(self, mobject, **kwargs):VMobject.__init__(self, **kwargs)self.mobject = mobjectself.submobjects = self.get_eyes().submobjects- def get_eyes(self, mode = None, thing_to_look_at = None):+ def get_eyes(self, mode=None, thing_to_look_at=None):mode = mode or self.modeif thing_to_look_at is None:thing_to_look_at = self.thing_looked_at- pi = Randolph(mode = mode)+ pi = Randolph(mode=mode)eyes = VGroup(pi.eyes, pi.pupils)- pi.scale(self.height/eyes.get_height())+ pi.scale(self.height / eyes.get_height())if self.submobjects:eyes.move_to(self, DOWN)else:@@ -293,12 +306,12 @@ class Eyes(VMobject):def change_mode_anim(self, mode, **kwargs):self.mode = mode- return Transform(self, self.get_eyes(mode = mode), **kwargs)+ return Transform(self, self.get_eyes(mode=mode), **kwargs)def look_at_anim(self, point_or_mobject, **kwargs):self.thing_looked_at = point_or_mobjectreturn Transform(- self, self.get_eyes(thing_to_look_at = point_or_mobject),+ self, self.get_eyes(thing_to_look_at=point_or_mobject),**kwargs)@@ -307,10 +320,8 @@ class Eyes(VMobject):bottom_y = self.get_bottom()[1]for submob in target:submob.apply_function(- lambda p : [p[0], bottom_y, p[2]]+ lambda p: [p[0], bottom_y, p[2]])if "rate_func" not in kwargs:kwargs["rate_func"] = squish_rate_func(there_and_back)return Transform(self, target, **kwargs)--diff --git a/for_3b1b_videos/pi_creature_animations.py b/for_3b1b_videos/pi_creature_animations.pyindex 8ee4753b7..352ae5ce8 100644--- a/for_3b1b_videos/pi_creature_animations.py+++ b/for_3b1b_videos/pi_creature_animations.py@@ -16,30 +16,34 @@ from utils.config_ops import digest_configfrom utils.rate_functions import squish_rate_funcfrom utils.rate_functions import there_and_back+class Blink(ApplyMethod):CONFIG = {- "rate_func" : squish_rate_func(there_and_back)+ "rate_func": squish_rate_func(there_and_back)}+def __init__(self, pi_creature, **kwargs):ApplyMethod.__init__(self, pi_creature.blink, **kwargs)+class PiCreatureBubbleIntroduction(AnimationGroup):CONFIG = {- "target_mode" : "speaking",- "bubble_class" : SpeechBubble,- "change_mode_kwargs" : {},- "bubble_creation_class" : ShowCreation,- "bubble_creation_kwargs" : {},- "bubble_kwargs" : {},- "content_introduction_class" : Write,- "content_introduction_kwargs" : {},- "look_at_arg" : None,+ "target_mode": "speaking",+ "bubble_class": SpeechBubble,+ "change_mode_kwargs": {},+ "bubble_creation_class": ShowCreation,+ "bubble_creation_kwargs": {},+ "bubble_kwargs": {},+ "content_introduction_class": Write,+ "content_introduction_kwargs": {},+ "look_at_arg": None,}+def __init__(self, pi_creature, *content, **kwargs):digest_config(self, kwargs)bubble = pi_creature.get_bubble(*content,- bubble_class = self.bubble_class,+ bubble_class=self.bubble_class,**self.bubble_kwargs)Group(bubble, bubble.content).shift_onto_screen()@@ -61,18 +65,21 @@ class PiCreatureBubbleIntroduction(AnimationGroup):**kwargs)+class PiCreatureSays(PiCreatureBubbleIntroduction):CONFIG = {- "target_mode" : "speaking",- "bubble_class" : SpeechBubble,+ "target_mode": "speaking",+ "bubble_class": SpeechBubble,}+class RemovePiCreatureBubble(AnimationGroup):CONFIG = {- "target_mode" : "plain",- "look_at_arg" : None,- "remover" : True,+ "target_mode": "plain",+ "look_at_arg": None,+ "remover": True,}+def __init__(self, pi_creature, **kwargs):assert hasattr(pi_creature, "bubble")digest_config(self, kwargs, locals())@@ -89,7 +96,7 @@ class RemovePiCreatureBubble(AnimationGroup):FadeOut(pi_creature.bubble.content),)- def clean_up(self, surrounding_scene = None):+ def clean_up(self, surrounding_scene=None):AnimationGroup.clean_up(self, surrounding_scene)self.pi_creature.bubble = Noneif surrounding_scene is not None:diff --git a/mobject/coordinate_systems.py b/mobject/coordinate_systems.pyindex ece9e3d45..bb6f49efb 100644--- a/mobject/coordinate_systems.py+++ b/mobject/coordinate_systems.py@@ -12,51 +12,52 @@ from mobject.svg.tex_mobject import TexMobjectfrom mobject.types.vectorized_mobject import VGroupfrom mobject.types.vectorized_mobject import VMobjectfrom utils.config_ops import digest_config-from utils.space_ops import R3_to_complexfrom utils.space_ops import angle_of_vector-from utils.space_ops import complex_to_R3-#TODO: There should be much more code reuse between Axes, NumberPlane and GraphScene+# TODO: There should be much more code reuse between Axes, NumberPlane and GraphScene+class Axes(VGroup):CONFIG = {- "propagate_style_to_family" : True,- "three_d" : False,- "number_line_config" : {- "color" : LIGHT_GREY,- "include_tip" : True,+ "propagate_style_to_family": True,+ "three_d": False,+ "number_line_config": {+ "color": LIGHT_GREY,+ "include_tip": True,},- "x_axis_config" : {},- "y_axis_config" : {},- "z_axis_config" : {},- "x_min" : -FRAME_X_RADIUS,- "x_max" : FRAME_X_RADIUS,- "y_min" : -FRAME_Y_RADIUS,- "y_max" : FRAME_Y_RADIUS,- "z_min" : -3.5,- "z_max" : 3.5,- "z_normal" : DOWN,- "default_num_graph_points" : 100,+ "x_axis_config": {},+ "y_axis_config": {},+ "z_axis_config": {},+ "x_min": -FRAME_X_RADIUS,+ "x_max": FRAME_X_RADIUS,+ "y_min": -FRAME_Y_RADIUS,+ "y_max": FRAME_Y_RADIUS,+ "z_min": -3.5,+ "z_max": 3.5,+ "z_normal": DOWN,+ "default_num_graph_points": 100,}+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.y_axis.rotate(np.pi / 2, about_point=ORIGIN)self.add(self.x_axis, self.y_axis)if self.three_d:- self.z_axis = self.get_axis(self.z_min, self.z_max, self.z_axis_config)- self.z_axis.rotate(-np.pi/2, UP, about_point = ORIGIN)+ self.z_axis = self.get_axis(+ self.z_min, self.z_max, self.z_axis_config)+ self.z_axis.rotate(-np.pi / 2, UP, about_point=ORIGIN)self.z_axis.rotate(angle_of_vector(self.z_normal), OUT,- about_point = ORIGIN+ about_point=ORIGIN)self.add(self.z_axis)def get_axis(self, min_val, max_val, extra_config):config = dict(self.number_line_config)config.update(extra_config)- return NumberLine(x_min = min_val, x_max = max_val, **config)+ return NumberLine(x_min=min_val, x_max=max_val, **config)def coords_to_point(self, x, y):origin = self.x_axis.number_to_point(0)@@ -66,25 +67,25 @@ class Axes(VGroup):def point_to_coords(self, point):return (- self.x_axis.point_to_number(point),+ self.x_axis.point_to_number(point),self.y_axis.point_to_number(point),)def get_graph(- self, function, num_graph_points = None,- x_min = None,- x_max = None,+ self, function, num_graph_points=None,+ x_min=None,+ x_max=None,**kwargs- ):+ ):kwargs["fill_opacity"] = kwargs.get("fill_opacity", 0)kwargs["num_anchor_points"] = \num_graph_points or self.default_num_graph_pointsx_min = x_min or self.x_minx_max = x_max or self.x_maxgraph = ParametricFunction(- lambda t : self.coords_to_point(t, function(t)),- t_min = x_min,- t_max = x_max,+ lambda t: self.coords_to_point(t, function(t)),+ t_min=x_min,+ t_max=x_max,**kwargs)graph.underlying_function = function@@ -94,7 +95,7 @@ class Axes(VGroup):if hasattr(graph, "underlying_function"):return self.coords_to_point(x, graph.underlying_function(x))else:- #binary search+ # binary searchlh, rh = 0, 1while abs(lh - rh) > 0.001:mh = np.mean([lh, rh])@@ -115,66 +116,69 @@ class Axes(VGroup):return points[1]return self.coords_to_point(x, graph.underlying_function(x))+class ThreeDAxes(Axes):CONFIG = {- "x_min" : -5.5,- "x_max" : 5.5,- "y_min" : -4.5,- "y_max" : 4.5,- "three_d" : True,+ "x_min": -5.5,+ "x_max": 5.5,+ "y_min": -4.5,+ "y_max": 4.5,+ "three_d": True,}+class NumberPlane(VMobject):CONFIG = {- "color" : BLUE_D,- "secondary_color" : BLUE_E,- "axes_color" : WHITE,- "secondary_stroke_width" : 1,+ "color": BLUE_D,+ "secondary_color": BLUE_E,+ "axes_color": WHITE,+ "secondary_stroke_width": 1,# TODO: Allow coordinate center of NumberPlane to not be at (0, 0)"x_radius": None,"y_radius": None,- "x_unit_size" : 1,- "y_unit_size" : 1,- "center_point" : ORIGIN,- "x_line_frequency" : 1,- "y_line_frequency" : 1,- "secondary_line_ratio" : 1,- "written_coordinate_height" : 0.2,- "propagate_style_to_family" : False,- "make_smooth_after_applying_functions" : True,+ "x_unit_size": 1,+ "y_unit_size": 1,+ "center_point": ORIGIN,+ "x_line_frequency": 1,+ "y_line_frequency": 1,+ "secondary_line_ratio": 1,+ "written_coordinate_height": 0.2,+ "propagate_style_to_family": False,+ "make_smooth_after_applying_functions": True,}+def generate_points(self):if self.x_radius is None:- center_to_edge = (FRAME_X_RADIUS + abs(self.center_point[0]))+ center_to_edge = (FRAME_X_RADIUS + abs(self.center_point[0]))self.x_radius = center_to_edge / self.x_unit_sizeif self.y_radius is None:- center_to_edge = (FRAME_Y_RADIUS + abs(self.center_point[1]))+ center_to_edge = (FRAME_Y_RADIUS + abs(self.center_point[1]))self.y_radius = center_to_edge / self.y_unit_sizeself.axes = VMobject()self.main_lines = VMobject()self.secondary_lines = VMobject()tuples = [(- self.x_radius,- self.x_line_frequency,- self.y_radius*DOWN,- self.y_radius*UP,+ self.x_radius,+ self.x_line_frequency,+ self.y_radius * DOWN,+ self.y_radius * UP,RIGHT),(- self.y_radius,- self.y_line_frequency,- self.x_radius*LEFT,- self.x_radius*RIGHT,+ self.y_radius,+ self.y_line_frequency,+ self.x_radius * LEFT,+ self.x_radius * RIGHT,UP,),]for radius, freq, start, end, unit in tuples:main_range = np.arange(0, radius, freq)- step = freq/float(freq + self.secondary_line_ratio)+ step = freq / float(freq + self.secondary_line_ratio)for v in np.arange(0, radius, step):- line1 = Line(start+v*unit, end+v*unit)- line2 = Line(start-v*unit, end-v*unit)+ line1 = Line(start + v * unit, end + v * unit)+ line2 = Line(start - v * unit, end - v * unit)if v == 0:self.axes.add(line1)elif v in main_range:@@ -185,7 +189,7 @@ class NumberPlane(VMobject):self.stretch(self.x_unit_size, 0)self.stretch(self.y_unit_size, 1)self.shift(self.center_point)- #Put x_axis before y_axis+ # Put x_axis before y_axisy_axis, x_axis = self.axes.split()self.axes = VMobject(x_axis, y_axis)@@ -204,39 +208,39 @@ class NumberPlane(VMobject):def coords_to_point(self, x, y):x, y = np.array([x, y])result = self.axes.get_center()- result += x*self.get_x_unit_size()*RIGHT- result += y*self.get_y_unit_size()*UP+ result += x * self.get_x_unit_size() * RIGHT+ result += y * self.get_y_unit_size() * UPreturn resultdef point_to_coords(self, point):new_point = point - self.axes.get_center()- x = new_point[0]/self.get_x_unit_size()- y = new_point[1]/self.get_y_unit_size()+ x = new_point[0] / self.get_x_unit_size()+ y = new_point[1] / self.get_y_unit_size()return x, y# Does not recompute center, unit_sizes for each call; useful for- # iterating over large lists of points, but does assume these+ # iterating over large lists of points, but does assume these# attributes are kept accurate. (Could alternatively have a method- # which returns a function dynamically created after a single+ # which returns a function dynamically created after a single# call to each of get_center(), get_x_unit_size(), etc.)def point_to_coords_cheap(self, point):new_point = point - self.center_point- x = new_point[0]/self.x_unit_size- y = new_point[1]/self.y_unit_size+ x = new_point[0] / self.x_unit_size+ y = new_point[1] / self.y_unit_sizereturn x, ydef get_x_unit_size(self):- return self.axes.get_width() / (2.0*self.x_radius)+ return self.axes.get_width() / (2.0 * self.x_radius)def get_y_unit_size(self):- return self.axes.get_height() / (2.0*self.y_radius)+ return self.axes.get_height() / (2.0 * self.y_radius)- def get_coordinate_labels(self, x_vals = None, y_vals = None):+ def get_coordinate_labels(self, x_vals=None, y_vals=None):coordinate_labels = VGroup()- if x_vals == None:- x_vals = range(-int(self.x_radius), int(self.x_radius)+1)- if y_vals == None:- y_vals = range(-int(self.y_radius), int(self.y_radius)+1)+ if x_vals is None:+ x_vals = range(-int(self.x_radius), int(self.x_radius) + 1)+ if y_vals is None:+ y_vals = range(-int(self.y_radius), int(self.y_radius) + 1)for index, vals in enumerate([x_vals, y_vals]):num_pair = [0, 0]for val in vals:@@ -249,7 +253,7 @@ class NumberPlane(VMobject):num.scale_to_fit_height(self.written_coordinate_height)- num.next_to(point, DOWN+LEFT, buff = SMALL_BUFF)+ num.next_to(point, DOWN + LEFT, buff=SMALL_BUFF)coordinate_labels.add(num)self.coordinate_labels = coordinate_labelsreturn coordinate_labels@@ -257,7 +261,7 @@ class NumberPlane(VMobject):def get_axes(self):return self.axes- def get_axis_labels(self, x_label = "x", y_label = "y"):+ def get_axis_labels(self, x_label="x", y_label="y"):x_axis, y_axis = self.get_axes().split()quads = [(x_axis, x_label, UP, RIGHT),@@ -273,39 +277,42 @@ class NumberPlane(VMobject):self.axis_labels = labelsreturn labels- def add_coordinates(self, x_vals = None, y_vals = None):+ def add_coordinates(self, x_vals=None, y_vals=None):self.add(*self.get_coordinate_labels(x_vals, y_vals))return selfdef get_vector(self, coords, **kwargs):- point = coords[0]*RIGHT + coords[1]*UP- arrow = Arrow(ORIGIN, coords, **kwargs)+ point = coords[0] * RIGHT + coords[1] * UP+ arrow = Arrow(ORIGIN, point, **kwargs)return arrow- def prepare_for_nonlinear_transform(self, num_inserted_anchor_points = 50):+ def prepare_for_nonlinear_transform(self, num_inserted_anchor_points=50):for mob in self.family_members_with_points():num_anchors = mob.get_num_anchor_points()if num_inserted_anchor_points > num_anchors:- mob.insert_n_anchor_points(num_inserted_anchor_points-num_anchors)+ mob.insert_n_anchor_points(+ num_inserted_anchor_points - num_anchors)mob.make_smooth()return self+class ComplexPlane(NumberPlane):CONFIG = {- "color" : BLUE,- "unit_size" : 1,- "line_frequency" : 1,- "faded_line_frequency" : 0.5,+ "color": BLUE,+ "unit_size": 1,+ "line_frequency": 1,+ "faded_line_frequency": 0.5,}+def __init__(self, **kwargs):digest_config(self, kwargs)kwargs.update({- "x_unit_size" : self.unit_size,- "y_unit_size" : self.unit_size,- "x_line_frequency" : self.line_frequency,- "x_faded_line_frequency" : self.faded_line_frequency,- "y_line_frequency" : self.line_frequency,- "y_faded_line_frequency" : self.faded_line_frequency,+ "x_unit_size": self.unit_size,+ "y_unit_size": self.unit_size,+ "x_line_frequency": self.line_frequency,+ "x_faded_line_frequency": self.faded_line_frequency,+ "y_line_frequency": self.line_frequency,+ "y_faded_line_frequency": self.faded_line_frequency,})NumberPlane.__init__(self, **kwargs)@@ -321,12 +328,11 @@ class ComplexPlane(NumberPlane):# TODO: Should merge this with the code from NumberPlane.get_coordinate_labelsresult = VGroup()- nudge = 0.1*(DOWN+RIGHT)if len(numbers) == 0:- numbers = range(-int(self.x_radius), int(self.x_radius)+1)+ numbers = range(-int(self.x_radius), int(self.x_radius) + 1)numbers += [complex(0, y)- for y in range(-int(self.y_radius), int(self.y_radius)+1)+ for y in range(-int(self.y_radius), int(self.y_radius) + 1)]for number in numbers:if number == complex(0, 0):@@ -340,7 +346,7 @@ class ComplexPlane(NumberPlane):num_mob = TexMobject(num_str)num_mob.add_background_rectangle()num_mob.scale_to_fit_height(self.written_coordinate_height)- num_mob.next_to(point, DOWN+LEFT, SMALL_BUFF)+ num_mob.next_to(point, DOWN + LEFT, SMALL_BUFF)result.add(num_mob)self.coordinate_labels = resultreturn result@@ -348,4 +354,3 @@ class ComplexPlane(NumberPlane):def add_coordinates(self, *numbers):self.add(*self.get_coordinate_labels(*numbers))return self-diff --git a/mobject/frame.py b/mobject/frame.pyindex 0ca977a68..cd51dcf6c 100644--- a/mobject/frame.py+++ b/mobject/frame.py@@ -4,32 +4,38 @@ from constants import *from mobject.geometry import Rectanglefrom utils.config_ops import digest_config+class ScreenRectangle(Rectangle):CONFIG = {- "width_to_height_ratio" : 16.0/9.0,- "height" : 4,+ "width_to_height_ratio": 16.0 / 9.0,+ "height": 4,}+def generate_points(self):self.width = self.width_to_height_ratio * self.heightRectangle.generate_points(self)+class FullScreenRectangle(ScreenRectangle):CONFIG = {- "height" : FRAME_HEIGHT,+ "height": FRAME_HEIGHT,}+class FullScreenFadeRectangle(FullScreenRectangle):CONFIG = {- "stroke_width" : 0,- "fill_color" : BLACK,- "fill_opacity" : 0.7,+ "stroke_width": 0,+ "fill_color": BLACK,+ "fill_opacity": 0.7,}+class PictureInPictureFrame(Rectangle):CONFIG = {- "height" : 3,- "aspect_ratio" : (16, 9)+ "height": 3,+ "aspect_ratio": (16, 9)}+def __init__(self, **kwargs):digest_config(self, kwargs)height = self.height@@ -37,8 +43,8 @@ class PictureInPictureFrame(Rectangle):kwargs.pop("height")Rectangle.__init__(self,- width = self.aspect_ratio[0],- height = self.aspect_ratio[1],+ width=self.aspect_ratio[0],+ height=self.aspect_ratio[1],**kwargs)self.scale_to_fit_height(height)diff --git a/mobject/functions.py b/mobject/functions.pyindex 0d421e665..e65605808 100644--- a/mobject/functions.py+++ b/mobject/functions.py@@ -8,57 +8,46 @@ from utils.config_ops import digest_configclass ParametricFunction(VMobject):CONFIG = {- "t_min" : 0,- "t_max" : 1,- "num_anchor_points" : 100,+ "t_min": 0,+ "t_max": 1,+ "num_anchor_points": 100,}+def __init__(self, function, **kwargs):self.function = functionVMobject.__init__(self, **kwargs)def generate_points(self):- n_points = 3*self.num_anchor_points - 2+ n_points = 3 * self.num_anchor_points - 2self.points = np.zeros((n_points, self.dim))- self.points[:,0] = np.linspace(+ self.points[:, 0] = np.linspace(self.t_min, self.t_max, n_points)- #VMobject.apply_function takes care of preserving- #desirable tangent line properties at anchor points- self.apply_function(lambda p : self.function(p[0]))+ # VMobject.apply_function takes care of preserving+ # desirable tangent line properties at anchor points+ self.apply_function(lambda p: self.function(p[0]))+class FunctionGraph(ParametricFunction):CONFIG = {- "color" : YELLOW,- "x_min" : -FRAME_X_RADIUS,- "x_max" : FRAME_X_RADIUS,+ "color": YELLOW,+ "x_min": -FRAME_X_RADIUS,+ "x_max": FRAME_X_RADIUS,}+def __init__(self, function, **kwargs):digest_config(self, kwargs)- parametric_function = lambda t : t*RIGHT + function(t)*UP++ def parametric_function(t):+ return t * RIGHT + function(t) * UPParametricFunction.__init__(- self,+ self,parametric_function,- t_min = self.x_min,- t_max = self.x_max,+ t_min=self.x_min,+ t_max=self.x_max,**kwargs)self.function = functiondef get_function(self):return self.function----------------diff --git a/mobject/geometry.py b/mobject/geometry.pyindex e3fee62b0..79896fa49 100644--- a/mobject/geometry.py+++ b/mobject/geometry.py@@ -17,156 +17,159 @@ from utils.space_ops import center_of_massfrom utils.space_ops import compass_directionsfrom utils.space_ops import rotate_vector+class Arc(VMobject):CONFIG = {- "radius" : 1.0,- "start_angle" : 0,- "num_anchors" : 9,- "anchors_span_full_range" : True,+ "radius": 1.0,+ "start_angle": 0,+ "num_anchors": 9,+ "anchors_span_full_range": True,}+def __init__(self, angle, **kwargs):self.angle = angleVMobject.__init__(self, **kwargs)def generate_points(self):anchors = np.array([- np.cos(a)*RIGHT+np.sin(a)*UP+ np.cos(a) * RIGHT + np.sin(a) * UPfor a in np.linspace(- self.start_angle,- self.start_angle + self.angle,+ self.start_angle,+ self.start_angle + self.angle,self.num_anchors)])- #Figure out which control points will give the- #Appropriate tangent lines to the circle- d_theta = self.angle/(self.num_anchors-1.0)+ # Figure out which control points will give the+ # Appropriate tangent lines to the circle+ d_theta = self.angle / (self.num_anchors - 1.0)tangent_vectors = np.zeros(anchors.shape)- tangent_vectors[:,1] = anchors[:,0]- tangent_vectors[:,0] = -anchors[:,1]- handles1 = anchors[:-1] + (d_theta/3)*tangent_vectors[:-1]- handles2 = anchors[1:] - (d_theta/3)*tangent_vectors[1:]+ tangent_vectors[:, 1] = anchors[:, 0]+ tangent_vectors[:, 0] = -anchors[:, 1]+ handles1 = anchors[:-1] + (d_theta / 3) * tangent_vectors[:-1]+ handles2 = anchors[1:] - (d_theta / 3) * tangent_vectors[1:]self.set_anchors_and_handles(anchors, handles1, handles2)- self.scale(self.radius, about_point = ORIGIN)+ self.scale(self.radius, about_point=ORIGIN)- def add_tip(self, tip_length = 0.25, at_start = False, at_end = True):+ def add_tip(self, tip_length=0.25, at_start=False, at_end=True):# clear out any old tipsfor submob in self.submobjects:- if submob.mark_paths_closed == True: # is a tip+ if submob.mark_paths_closed:self.remove(submob)- #TODO, do this a better way+ # TODO, do this a better wayp1 = p2 = p3 = p4 = Nonestart_arrow = end_arrow = Noneif at_end:p1, p2 = self.points[-3:-1]# self.points[-2:] did overshootstart_arrow = Arrow(- p1, 2*p2 - p1,- tip_length = tip_length,- max_tip_length_to_length_ratio = 2.0+ p1, 2 * p2 - p1,+ tip_length=tip_length,+ max_tip_length_to_length_ratio=2.0)- self.add(start_arrow.split()[-1]) # just the tip+ self.add(start_arrow.split()[-1]) # just the tipif at_start:p4, p3 = self.points[1:3]# self.points[:2] did overshootend_arrow = Arrow(- p3, 2*p4 - p3,- tip_length = tip_length,- max_tip_length_to_length_ratio = 2.0+ p3, 2 * p4 - p3,+ tip_length=tip_length,+ max_tip_length_to_length_ratio=2.0)self.add(end_arrow.split()[-1])----self.set_color(self.get_color())return self--def get_arc_center(self):first_point = self.points[0]- radial_unit_vector = np.array([np.cos(self.start_angle),np.sin(self.start_angle),0])+ radial_unit_vector = np.array(+ [np.cos(self.start_angle), np.sin(self.start_angle), 0])arc_center = first_point - self.radius * radial_unit_vectorreturn arc_center-- def move_arc_center_to(self,point):+ def move_arc_center_to(self, point):v = point - self.get_arc_center()self.shift(v)return self-def stop_angle(self):return self.start_angle + self.angle- def set_bound_angles(self,start=0,stop=np.pi):+ def set_bound_angles(self, start=0, stop=np.pi):self.start_angle = startself.angle = stop - start-+return self+class ArcBetweenPoints(Arc):- def __init__(self, start_point, end_point, angle = TAU/4, **kwargs):+ def __init__(self, start_point, end_point, angle=TAU / 4, **kwargs):if angle == 0:raise Exception("Arc with zero curve angle: use Line instead.")midpoint = 0.5 * (start_point + end_point)distance_vector = end_point - start_point- normal_vector = np.array([-distance_vector[1], distance_vector[0],0])+ normal_vector = np.array([-distance_vector[1], distance_vector[0], 0])distance = np.linalg.norm(normal_vector)normal_vector /= distanceif angle < 0:normal_vector *= -1- radius = distance/2 / np.sin(0.5 * np.abs(angle))- l = distance/2 / np.tan(0.5 * np.abs(angle))- arc_center = midpoint + l * normal_vector+ radius = distance / 2 / np.sin(0.5 * np.abs(angle))+ length = distance / 2 / np.tan(0.5 * np.abs(angle))+ arc_center = midpoint + length * normal_vectorw = start_point - arc_centerif w[0] != 0:- start_angle = np.arctan2(w[1],w[0])+ start_angle = np.arctan2(w[1], w[0])else:- start_angle = np.pi/2+ start_angle = np.pi / 2Arc.__init__(self, angle,- radius = radius,- start_angle = start_angle,- **kwargs)-+ radius=radius,+ start_angle=start_angle,+ **kwargs)+self.move_arc_center_to(arc_center)+class CurvedArrow(ArcBetweenPoints):- def __init__(self, start_point, end_point, angle = TAU/4, **kwargs):+ def __init__(self, start_point, end_point, angle=TAU / 4, **kwargs):# I know this is in reverse, but it worksif angle >= 0:- ArcBetweenPoints.__init__(self, start_point, end_point, angle = angle, **kwargs)- self.add_tip(at_start = True, at_end = False)+ ArcBetweenPoints.__init__(+ self, start_point, end_point, angle=angle, **kwargs)+ self.add_tip(at_start=True, at_end=False)else:- ArcBetweenPoints.__init__(self, end_point, start_point, angle = -angle, **kwargs)- self.add_tip(at_start = False, at_end = True)+ ArcBetweenPoints.__init__(+ self, end_point, start_point, angle=-angle, **kwargs)+ self.add_tip(at_start=False, at_end=True)+class CurvedDoubleArrow(ArcBetweenPoints):- def __init__(self, start_point, end_point, angle = TAU/4, **kwargs):- ArcBetweenPoints.__init__(self, start_point, end_point, angle = angle, **kwargs)- self.add_tip(at_start = True, at_end = True)+ def __init__(self, start_point, end_point, angle=TAU / 4, **kwargs):+ ArcBetweenPoints.__init__(+ self, start_point, end_point, angle=angle, **kwargs)+ self.add_tip(at_start=True, at_end=True)+class Circle(Arc):CONFIG = {- "color" : RED,- "close_new_points" : True,- "anchors_span_full_range" : False+ "color": RED,+ "close_new_points": True,+ "anchors_span_full_range": False}+def __init__(self, **kwargs):- Arc.__init__(self, 2*np.pi, **kwargs)+ Arc.__init__(self, 2 * np.pi, **kwargs)- def surround(self, mobject, dim_to_match = 0, stretch = False, buffer_factor = 1.2):+ def surround(self, mobject, dim_to_match=0, stretch=False, buffer_factor=1.2):# Ignores dim_to_match and stretch; result will always be a circle# TODO: Perhaps create an ellipse class to handle singele-dimension stretching@@ -174,54 +177,60 @@ class Circle(Arc):# TODO: Figure out and fixself.replace(mobject, dim_to_match, stretch)- self.scale_to_fit_width(np.sqrt(mobject.get_width()**2 + mobject.get_height()**2))+ self.scale_to_fit_width(+ np.sqrt(mobject.get_width()**2 + mobject.get_height()**2))self.scale(buffer_factor)+class Dot(Circle):CONFIG = {- "radius" : 0.08,- "stroke_width" : 0,- "fill_opacity" : 1.0,- "color" : WHITE+ "radius": 0.08,+ "stroke_width": 0,+ "fill_opacity": 1.0,+ "color": WHITE}- def __init__(self, point = ORIGIN, **kwargs):++ def __init__(self, point=ORIGIN, **kwargs):Circle.__init__(self, **kwargs)self.shift(point)self.init_colors()+class Ellipse(VMobject):CONFIG = {- "width" : 2,- "height" : 1+ "width": 2,+ "height": 1}def generate_points(self):- circle = Circle(radius = 1)+ circle = Circle(radius=1)circle = circle.stretch_to_fit_width(self.width)circle = circle.stretch_to_fit_height(self.height)self.points = circle.points+class AnnularSector(VMobject):CONFIG = {- "inner_radius" : 1,- "outer_radius" : 2,- "angle" : TAU/4,- "start_angle" : 0,- "fill_opacity" : 1,- "stroke_width" : 0,- "color" : WHITE,- "mark_paths_closed" : True,+ "inner_radius": 1,+ "outer_radius": 2,+ "angle": TAU / 4,+ "start_angle": 0,+ "fill_opacity": 1,+ "stroke_width": 0,+ "color": WHITE,+ "mark_paths_closed": True,}+def generate_points(self):arc1 = Arc(- angle = self.angle,- start_angle = self.start_angle,- radius = self.inner_radius,+ 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,+ 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)@@ -236,24 +245,24 @@ class AnnularSector(VMobject):self.add_control_points(arc2.points[1:])self.add_control_points(a2_to_a1_points[1:])-def get_arc_center(self):first_point = self.points[0]last_point = self.points[-2]v = last_point - first_point- radial_unit_vector = v/np.linalg.norm(v)+ radial_unit_vector = v / np.linalg.norm(v)arc_center = first_point - self.inner_radius * radial_unit_vectorreturn arc_center- def move_arc_center_to(self,point):+ def move_arc_center_to(self, point):v = point - self.get_arc_center()self.shift(v)return self+class Sector(AnnularSector):CONFIG = {- "outer_radius" : 1,- "inner_radius" : 0+ "outer_radius": 1,+ "inner_radius": 0}@property@@ -261,35 +270,38 @@ class Sector(AnnularSector):return self.outer_radius@radius.setter- def radius(self,new_radius):+ def radius(self, new_radius):self.outer_radius = new_radius+class Annulus(Circle):CONFIG = {"inner_radius": 1,"outer_radius": 2,- "fill_opacity" : 1,- "stroke_width" : 0,- "color" : WHITE,- "mark_paths_closed" : False,- "propagate_style_to_family" : True+ "fill_opacity": 1,+ "stroke_width": 0,+ "color": WHITE,+ "mark_paths_closed": False,+ "propagate_style_to_family": True}def generate_points(self):self.points = []self.radius = self.outer_radius- outer_circle = Circle(radius = self.outer_radius)+ outer_circle = Circle(radius=self.outer_radius)inner_circle = Circle(radius=self.inner_radius)inner_circle.flip()self.points = outer_circle.pointsself.add_subpath(inner_circle.points)+class Line(VMobject):CONFIG = {- "buff" : 0,- "path_arc" : None, # angle of arc specified here- "n_arc_anchors" : 10, #Only used if path_arc is not None+ "buff": 0,+ "path_arc": None, # angle of arc specified here+ "n_arc_anchors": 10, # Only used if path_arc is not None}+def __init__(self, start, end, **kwargs):digest_config(self, kwargs)self.set_start_and_end(start, end)@@ -306,13 +318,13 @@ class Line(VMobject):])self.account_for_buff()- def set_path_arc(self,new_value):+ def set_path_arc(self, new_value):self.path_arc = new_valueself.generate_points()def account_for_buff(self):length = self.get_arc_length()- if length < 2*self.buff or self.buff == 0:+ if length < 2 * self.buff or self.buff == 0:returnbuff_proportion = self.buff / lengthself.pointwise_become_partial(@@ -325,7 +337,7 @@ class Line(VMobject):longer_dim = np.argmax(map(abs, start_to_end))vect[longer_dim] = start_to_end[longer_dim]self.start, self.end = [- arg.get_edge_center(unit*vect)+ arg.get_edge_center(unit * vect)if isinstance(arg, Mobject)else np.array(arg)for arg, unit in zip([start, end], [1, -1])@@ -344,7 +356,7 @@ class Line(VMobject):if self.path_arc:anchors = self.get_anchors()return sum([- np.linalg.norm(a2-a1)+ np.linalg.norm(a2 - a1)for a1, a2 in zip(anchors, anchors[1:])])else:@@ -368,11 +380,11 @@ class Line(VMobject):float(end[i] - start[i])for i in [1, 0]]- return np.inf if run == 0 else rise/run+ return np.inf if run == 0 else rise / rundef get_angle(self):start, end = self.get_start_and_end()- return angle_of_vector(end-start)+ return angle_of_vector(end - start)# def put_start_and_end_on(self, new_start, new_end):# self.set_start_and_end(new_start, new_end)@@ -396,7 +408,7 @@ class Line(VMobject):target_norm = np.linalg.norm(target_vect)if target_norm == 0:epsilon = 0.001- self.scale(epsilon/curr_norm)+ self.scale(epsilon / curr_norm)self.move_to(new_start)returnunit_target = target_vect / target_norm@@ -410,7 +422,7 @@ class Line(VMobject):angle_diff = np.arccos(np.clip(np.dot(unit_target, unit_curr), -1, 1))- self.scale(target_norm/curr_norm)+ self.scale(target_norm / curr_norm)self.rotate(-angle_diff, normal)self.shift(new_start - self.get_start())return self@@ -418,7 +430,7 @@ class Line(VMobject):def insert_n_anchor_points(self, n):if not self.path_arc:n_anchors = self.get_num_anchor_points()- new_num_points = 3*(n_anchors + n)-2+ new_num_points = 3 * (n_anchors + n) - 2self.points = np.array([self.point_from_proportion(alpha)for alpha in np.linspace(0, 1, new_num_points)@@ -426,17 +438,19 @@ class Line(VMobject):else:VMobject.insert_n_anchor_points(self, n)+class DashedLine(Line):CONFIG = {- "dashed_segment_length" : 0.05+ "dashed_segment_length": 0.05}+def __init__(self, *args, **kwargs):self.init_kwargs = kwargsLine.__init__(self, *args, **kwargs)def generate_points(self):- length = np.linalg.norm(self.end-self.start)- num_interp_points = int(length/self.dashed_segment_length)+ length = np.linalg.norm(self.end - self.start)+ num_interp_points = int(length / self.dashed_segment_length)points = [interpolate(self.start, self.end, alpha)for alpha in np.linspace(0, 1, num_interp_points)@@ -462,23 +476,25 @@ class DashedLine(Line):else:return self.end+class Arrow(Line):CONFIG = {- "tip_length" : 0.25,- "tip_width_to_length_ratio" : 1,- "max_tip_length_to_length_ratio" : 0.35,- "max_stem_width_to_tip_width_ratio" : 0.3,- "buff" : MED_SMALL_BUFF,- "propagate_style_to_family" : False,- "preserve_tip_size_when_scaling" : True,- "normal_vector" : OUT,- "use_rectangular_stem" : True,- "rectangular_stem_width" : 0.05,+ "tip_length": 0.25,+ "tip_width_to_length_ratio": 1,+ "max_tip_length_to_length_ratio": 0.35,+ "max_stem_width_to_tip_width_ratio": 0.3,+ "buff": MED_SMALL_BUFF,+ "propagate_style_to_family": False,+ "preserve_tip_size_when_scaling": True,+ "normal_vector": OUT,+ "use_rectangular_stem": True,+ "rectangular_stem_width": 0.05,}+def __init__(self, *args, **kwargs):points = map(self.pointify, args)if len(args) == 1:- args = (points[0]+UP+LEFT, points[0])+ args = (points[0] + UP + LEFT, points[0])Line.__init__(self, *args, **kwargs)self.init_tip()if self.use_rectangular_stem and not hasattr(self, "rect"):@@ -488,17 +504,17 @@ class Arrow(Line):def init_tip(self):self.add_tip()- def add_tip(self, add_at_end = True):+ def add_tip(self, add_at_end=True):tip = VMobject(- close_new_points = True,- mark_paths_closed = True,- fill_color = self.color,- fill_opacity = 1,- stroke_color = self.color,- stroke_width = 0,+ close_new_points=True,+ mark_paths_closed=True,+ fill_color=self.color,+ fill_opacity=1,+ stroke_color=self.color,+ stroke_width=0,)tip.add_at_end = add_at_end- self.set_tip_points(tip, add_at_end, preserve_normal = False)+ self.set_tip_points(tip, add_at_end, preserve_normal=False)self.add(tip)if not hasattr(self, 'tip'):self.tip = VGroup()@@ -508,17 +524,16 @@ class Arrow(Line):def add_rectangular_stem(self):self.rect = Rectangle(- stroke_width = 0,- fill_color = self.tip.get_fill_color(),- fill_opacity = self.tip.get_fill_opacity()+ stroke_width=0,+ fill_color=self.tip.get_fill_color(),+ fill_opacity=self.tip.get_fill_opacity())self.add_to_back(self.rect)- self.set_stroke(width = 0)+ self.set_stroke(width=0)self.set_rectangular_stem_points()def set_rectangular_stem_points(self):start, end = self.get_start_and_end()- vect = end - starttip_base_points = self.tip[0].get_anchors()[1:]tip_base = center_of_mass(tip_base_points)tbp1, tbp2 = tip_base_points@@ -528,35 +543,35 @@ class Arrow(Line):perp_vect /= tip_base_widthwidth = min(self.rectangular_stem_width,- self.max_stem_width_to_tip_width_ratio*tip_base_width,+ self.max_stem_width_to_tip_width_ratio * tip_base_width,)if hasattr(self, "second_tip"):start = center_of_mass(self.second_tip.get_anchors()[1:])self.rect.set_points_as_corners([- tip_base + perp_vect*width/2,- start + perp_vect*width/2,- start - perp_vect*width/2,- tip_base - perp_vect*width/2,+ tip_base + perp_vect * width / 2,+ start + perp_vect * width / 2,+ start - perp_vect * width / 2,+ tip_base - perp_vect * width / 2,])return selfdef set_tip_points(self, tip,- add_at_end = True,- tip_length = None,- preserve_normal = True,- ):+ add_at_end=True,+ tip_length=None,+ preserve_normal=True,+ ):if tip_length is None:tip_length = self.tip_lengthif preserve_normal:normal_vector = self.get_normal_vector()else:normal_vector = self.normal_vector- line_length = np.linalg.norm(self.points[-1]-self.points[0])+ line_length = np.linalg.norm(self.points[-1] - self.points[0])tip_length = min(- tip_length, self.max_tip_length_to_length_ratio*line_length+ tip_length, self.max_tip_length_to_length_ratio * line_length)indices = (-2, -1) if add_at_end else (1, 0)@@ -569,12 +584,12 @@ class Arrow(Line):for v in vect, perp_vect:if np.linalg.norm(v) == 0:v[0] = 1- v *= tip_length/np.linalg.norm(v)+ v *= tip_length / np.linalg.norm(v)ratio = self.tip_width_to_length_ratiotip.set_points_as_corners([end_point,- end_point-vect+perp_vect*ratio/2,- end_point-vect-perp_vect*ratio/2,+ end_point - vect + perp_vect * ratio / 2,+ end_point - vect - perp_vect * ratio / 2,])return self@@ -586,7 +601,7 @@ class Arrow(Line):if norm == 0:return self.normal_vectorelse:- return result/norm+ return result / normdef reset_normal_vector(self):self.normal_vector = self.get_normal_vector()@@ -603,7 +618,7 @@ class Arrow(Line):def put_start_and_end_on(self, *args, **kwargs):Line.put_start_and_end_on(self, *args, **kwargs)- self.set_tip_points(self.tip[0], preserve_normal = False)+ self.set_tip_points(self.tip[0], preserve_normal=False)self.set_rectangular_stem_points()return self@@ -619,92 +634,106 @@ class Arrow(Line):def copy(self):return self.deepcopy()+class Vector(Arrow):CONFIG = {- "color" : YELLOW,- "buff" : 0,+ "color": YELLOW,+ "buff": 0,}+def __init__(self, direction, **kwargs):if len(direction) == 2:direction = np.append(np.array(direction), 0)Arrow.__init__(self, ORIGIN, direction, **kwargs)+class DoubleArrow(Arrow):def init_tip(self):self.tip = VGroup()for b in True, False:- t = self.add_tip(add_at_end = b)+ t = self.add_tip(add_at_end=b)t.add_at_end = bself.tip.add(t)self.tip.match_style(self.tip[0])+class CubicBezier(VMobject):def __init__(self, points, **kwargs):VMobject.__init__(self, **kwargs)self.set_points(points)+class Polygon(VMobject):CONFIG = {- "color" : GREEN_D,- "mark_paths_closed" : True,- "close_new_points" : True,+ "color": GREEN_D,+ "mark_paths_closed": True,+ "close_new_points": True,}+def __init__(self, *vertices, **kwargs):assert len(vertices) > 1digest_locals(self)VMobject.__init__(self, **kwargs)def generate_points(self):- self.set_anchor_points(self.vertices, mode = "corners")+ self.set_anchor_points(self.vertices, mode="corners")def get_vertices(self):return self.get_anchors_and_handles()[0]+class RegularPolygon(Polygon):CONFIG = {- "start_angle" : 0+ "start_angle": 0}- def __init__(self, n = 3, **kwargs):++ def __init__(self, n=3, **kwargs):digest_config(self, kwargs, locals())start_vect = rotate_vector(RIGHT, self.start_angle)vertices = compass_directions(n, start_vect)Polygon.__init__(self, *vertices, **kwargs)+class Rectangle(VMobject):CONFIG = {- "color" : WHITE,- "height" : 2.0,- "width" : 4.0,- "mark_paths_closed" : True,- "close_new_points" : True,+ "color": WHITE,+ "height": 2.0,+ "width": 4.0,+ "mark_paths_closed": True,+ "close_new_points": True,}+def generate_points(self):- y, x = self.height/2., self.width/2.+ y, x = self.height / 2., self.width / 2.self.set_anchor_points([- x*LEFT+y*UP,- x*RIGHT+y*UP,- x*RIGHT+y*DOWN,- x*LEFT+y*DOWN- ], mode = "corners")+ x * LEFT + y * UP,+ x * RIGHT + y * UP,+ x * RIGHT + y * DOWN,+ x * LEFT + y * DOWN+ ], mode="corners")+class Square(Rectangle):CONFIG = {- "side_length" : 2.0,+ "side_length": 2.0,}+def __init__(self, **kwargs):digest_config(self, kwargs)Rectangle.__init__(- self,- height = self.side_length,- width = self.side_length,+ self,+ height=self.side_length,+ width=self.side_length,**kwargs)+class Grid(VMobject):CONFIG = {- "height" : 6.0,- "width" : 6.0,+ "height": 6.0,+ "width": 6.0,}+def __init__(self, rows, columns, **kwargs):digest_config(self, kwargs, locals())VMobject.__init__(self, **kwargs)@@ -713,15 +742,13 @@ class Grid(VMobject):x_step = self.width / self.columnsy_step = self.height / self.rows- for x in np.arange(0, self.width+x_step, x_step):+ for x in np.arange(0, self.width + x_step, x_step):self.add(Line(- [x-self.width/2., -self.height/2., 0],- [x-self.width/2., self.height/2., 0],+ [x - self.width / 2., -self.height / 2., 0],+ [x - self.width / 2., self.height / 2., 0],))- for y in np.arange(0, self.height+y_step, y_step):+ for y in np.arange(0, self.height + y_step, y_step):self.add(Line(- [-self.width/2., y-self.height/2., 0],- [self.width/2., y-self.height/2., 0]+ [-self.width / 2., y - self.height / 2., 0],+ [self.width / 2., y - self.height / 2., 0]))--diff --git a/mobject/mobject.py b/mobject/mobject.pyindex 1e67793b4..c7cb4bc1c 100644--- a/mobject/mobject.py+++ b/mobject/mobject.py@@ -4,7 +4,6 @@ import numpy as npimport operator as opimport os-from PIL import Imagefrom colour import Colorfrom constants import *@@ -16,28 +15,28 @@ from utils.color import interpolate_colorfrom utils.iterables import list_updatefrom utils.iterables import remove_list_redundanciesfrom utils.paths import straight_path-from utils.space_ops import R3_to_complexfrom utils.space_ops import angle_of_vectorfrom utils.space_ops import complex_to_R3from utils.space_ops import rotation_matrix-#TODO: Explain array_attrs+# TODO: Explain array_attrsclass Mobject(Container):"""Mathematical Object"""CONFIG = {- "color" : WHITE,- "stroke_width" : DEFAULT_POINT_THICKNESS,- "name" : None,- "dim" : 3,- "target" : None,+ "color": WHITE,+ "stroke_width": DEFAULT_POINT_THICKNESS,+ "name": None,+ "dim": 3,+ "target": None,}+def __init__(self, *submobjects, **kwargs):Container.__init__(self, *submobjects, **kwargs)- if not all(map(lambda m : isinstance(m, Mobject), submobjects)):+ if not all(map(lambda m: isinstance(m, Mobject), submobjects)):raise Exception("All submobjects must be of type Mobject")self.submobjects = list(submobjects)self.color = Color(self.color)@@ -54,11 +53,11 @@ class Mobject(Container):self.points = np.zeros((0, self.dim))def init_colors(self):- #For subclasses+ # For subclassespassdef generate_points(self):- #Typically implemented in subclass, unless purposefully left blank+ # Typically implemented in subclass, unless purposefully left blankpassdef add(self, *mobjects):@@ -87,7 +86,7 @@ class Mobject(Container):in the submobjects list."""mobject_attrs = filter(- lambda x : isinstance(x, Mobject),+ lambda x: isinstance(x, Mobject),self.__dict__.values())self.submobjects = list_update(self.submobjects, mobject_attrs)@@ -98,24 +97,24 @@ class Mobject(Container):setattr(self, attr, func(getattr(self, attr)))return self- def get_image(self, camera = None):+ def get_image(self, camera=None):if camera is None:from camera.camera import Cameracamera = Camera()camera.capture_mobject(self)return camera.get_image()- def show(self, camera = None):- self.get_image(camera = camera).show()+ def show(self, camera=None):+ self.get_image(camera=camera).show()- def save_image(self, name = None):+ def save_image(self, name=None):self.get_image().save(os.path.join(ANIMATIONS_DIR, (name or str(self)) + ".png"))def copy(self):- #TODO, either justify reason for shallow copy, or- #remove this redundancy everywhere+ # TODO, either justify reason for shallow copy, or+ # remove this redundancy everywherereturn self.deepcopy()copy_mobject = copy.copy(self)@@ -132,8 +131,8 @@ class Mobject(Container):def deepcopy(self):return copy.deepcopy(self)- def generate_target(self, use_deepcopy = False):- self.target = None #Prevent exponential explosion+ def generate_target(self, use_deepcopy=False):+ self.target = None # Prevent exponential explosionif use_deepcopy:self.target = self.deepcopy()else:@@ -149,8 +148,8 @@ class Mobject(Container):def shift(self, *vectors):total_vector = reduce(op.add, vectors)for mob in self.family_members_with_points():- mob.points = mob.points.astype('float')- mob.points += total_vector+ mob.points = mob.points.astype('float')+ mob.points += total_vectorreturn selfdef scale(self, scale_factor, **kwargs):@@ -164,61 +163,61 @@ class Mobject(Container):respect to that point."""self.apply_points_function_about_point(- lambda points : scale_factor*points, **kwargs+ lambda points: scale_factor * points, **kwargs)return self- def rotate_about_origin(self, angle, axis = OUT, axes = []):- return self.rotate(angle, axis, about_point = ORIGIN)+ def rotate_about_origin(self, angle, axis=OUT, axes=[]):+ return self.rotate(angle, axis, about_point=ORIGIN)- def rotate(self, angle, axis = OUT, **kwargs):+ def rotate(self, angle, axis=OUT, **kwargs):rot_matrix = rotation_matrix(angle, axis)self.apply_points_function_about_point(- lambda points : np.dot(points, rot_matrix.T),+ lambda points: np.dot(points, rot_matrix.T),**kwargs)return self- def flip(self, axis = UP, **kwargs):- return self.rotate(TAU/2, axis, **kwargs)+ def flip(self, axis=UP, **kwargs):+ return self.rotate(TAU / 2, axis, **kwargs)def stretch(self, factor, dim, **kwargs):def func(points):- points[:,dim] *= factor+ points[:, dim] *= factorreturn pointsself.apply_points_function_about_point(func, **kwargs)return selfdef apply_function(self, function, **kwargs):- #Default to applying matrix about the origin, not mobjects center+ # Default to applying matrix about the origin, not mobjects centerif len(kwargs) == 0:kwargs["about_point"] = ORIGINself.apply_points_function_about_point(- lambda points : np.apply_along_axis(function, 1, points),+ lambda points: np.apply_along_axis(function, 1, points),**kwargs)return selfdef apply_matrix(self, matrix, **kwargs):- #Default to applying matrix about the origin, not mobjects center+ # Default to applying matrix about the origin, not mobjects centerif len(kwargs) == 0:kwargs["about_point"] = ORIGINfull_matrix = np.identity(self.dim)matrix = np.array(matrix)- full_matrix[:matrix.shape[0],:matrix.shape[1]] = matrix+ full_matrix[:matrix.shape[0], :matrix.shape[1]] = matrixself.apply_points_function_about_point(- lambda points : np.dot(points, full_matrix.T),+ lambda points: np.dot(points, full_matrix.T),**kwargs)return selfdef apply_complex_function(self, function, **kwargs):return self.apply_function(- lambda (x, y, z) : complex_to_R3(function(complex(x, y))),+ lambda (x, y, z): complex_to_R3(function(complex(x, y))),**kwargs)- def wag(self, direction = RIGHT, axis = DOWN, wag_factor = 1.0):+ def wag(self, direction=RIGHT, axis=DOWN, wag_factor=1.0):for mob in self.family_members_with_points():alphas = np.dot(mob.points, np.transpose(axis))alphas -= min(alphas)@@ -233,7 +232,7 @@ class Mobject(Container):def reverse_points(self):for mob in self.family_members_with_points():mob.apply_over_attr_arrays(- lambda arr : np.array(list(reversed(arr)))+ lambda arr: np.array(list(reversed(arr))))return self@@ -243,18 +242,18 @@ class Mobject(Container):"""def repeat_array(array):return reduce(- lambda a1, a2 : np.append(a1, a2, axis = 0),- [array]*count+ lambda a1, a2: np.append(a1, a2, axis=0),+ [array] * count)for mob in self.family_members_with_points():mob.apply_over_attr_arrays(repeat_array)return self#### In place operations ######- #Note, much of these are now redundant with default behavior of- #above methods+ # Note, much of these are now redundant with default behavior of+ # above methods- def apply_points_function_about_point(self, func, about_point = None, about_edge = ORIGIN):+ def apply_points_function_about_point(self, func, about_point=None, about_edge=ORIGIN):if about_point is None:about_point = self.get_critical_point(about_edge)for mob in self.family_members_with_points():@@ -263,20 +262,20 @@ class Mobject(Container):mob.points += about_pointreturn self- def rotate_in_place(self, angle, axis = OUT):+ def rotate_in_place(self, angle, axis=OUT):# redundant with default behavior of rotate now.- return self.rotate(angle, axis = axis)+ return self.rotate(angle, axis=axis)def scale_in_place(self, scale_factor, **kwargs):- #Redundant with default behavior of scale now.+ # Redundant with default behavior of scale now.return self.scale(scale_factor, **kwargs)def scale_about_point(self, scale_factor, point):- #Redundant with default behavior of scale now.- return self.scale(scale_factor, about_point = point)+ # Redundant with default behavior of scale now.+ return self.scale(scale_factor, about_point=point)def pose_at_angle(self, **kwargs):- self.rotate(TAU/14, RIGHT+UP, **kwargs)+ self.rotate(TAU / 14, RIGHT + UP, **kwargs)return self#### Positioning methods ####@@ -285,7 +284,7 @@ class Mobject(Container):self.shift(-self.get_center())return self- def align_on_border(self, direction, buff = DEFAULT_MOBJECT_TO_EDGE_BUFFER):+ def align_on_border(self, direction, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):"""Direction just needs to be a vector pointing towards side orcorner in the 2d plane.@@ -297,19 +296,19 @@ class Mobject(Container):self.shift(shift_val)return self- def to_corner(self, corner = LEFT+DOWN, buff = DEFAULT_MOBJECT_TO_EDGE_BUFFER):+ def to_corner(self, corner=LEFT + DOWN, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):return self.align_on_border(corner, buff)- def to_edge(self, edge = LEFT, buff = DEFAULT_MOBJECT_TO_EDGE_BUFFER):+ def to_edge(self, edge=LEFT, buff=DEFAULT_MOBJECT_TO_EDGE_BUFFER):return self.align_on_border(edge, buff)def next_to(self, mobject_or_point,- direction = RIGHT,- buff = DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,- aligned_edge = ORIGIN,- submobject_to_align = None,- index_of_submobject_to_align = None,- coor_mask = np.array([1,1,1]),+ direction=RIGHT,+ buff=DEFAULT_MOBJECT_TO_MOBJECT_BUFFER,+ aligned_edge=ORIGIN,+ submobject_to_align=None,+ index_of_submobject_to_align=None,+ coor_mask=np.array([1, 1, 1]),):if isinstance(mobject_or_point, Mobject):mob = mobject_or_point@@ -329,10 +328,11 @@ class Mobject(Container):else:aligner = selfpoint_to_align = aligner.get_critical_point(aligned_edge - direction)- self.shift((target_point - point_to_align + buff*direction)*coor_mask)+ self.shift((target_point - point_to_align ++ buff * direction) * coor_mask)return self- def align_to(self, mobject_or_point, direction = ORIGIN, alignment_vect = UP):+ def align_to(self, mobject_or_point, direction=ORIGIN, alignment_vect=UP):"""Examples:mob1.align_to(mob2, UP) moves mob1 vertically so that its@@ -349,12 +349,12 @@ class Mobject(Container):target_point = mobject_or_pointdirection_norm = np.linalg.norm(direction)if direction_norm > 0:- alignment_vect = np.array(direction)/direction_norm+ alignment_vect = np.array(direction) / direction_normreference_point = self.get_critical_point(direction)else:reference_point = self.get_center()diff = target_point - reference_point- self.shift(alignment_vect*np.dot(diff, alignment_vect))+ self.shift(alignment_vect * np.dot(diff, alignment_vect))return selfdef shift_onto_screen(self, **kwargs):@@ -380,57 +380,57 @@ class Mobject(Container):return Falsedef stretch_about_point(self, factor, dim, point):- return self.stretch(factor, dim, about_point = point)+ return self.stretch(factor, dim, about_point=point)def stretch_in_place(self, factor, dim):- #Now redundant with stretch+ # Now redundant with stretchreturn self.stretch(factor, dim)- def rescale_to_fit(self, length, dim, stretch = False, **kwargs):+ def rescale_to_fit(self, length, dim, stretch=False, **kwargs):old_length = self.length_over_dim(dim)if old_length == 0:return selfif stretch:- self.stretch(length/old_length, dim, **kwargs)+ self.stretch(length / old_length, dim, **kwargs)else:- self.scale(length/old_length, **kwargs)+ self.scale(length / old_length, **kwargs)return selfdef stretch_to_fit_width(self, width, **kwargs):- return self.rescale_to_fit(width, 0, stretch = True, **kwargs)+ return self.rescale_to_fit(width, 0, stretch=True, **kwargs)def stretch_to_fit_height(self, height, **kwargs):- return self.rescale_to_fit(height, 1, stretch = True, **kwargs)+ return self.rescale_to_fit(height, 1, stretch=True, **kwargs)def stretch_to_fit_depth(self, depth, **kwargs):- return self.rescale_to_fit(depth, 1, stretch = True, **kwargs)+ return self.rescale_to_fit(depth, 1, stretch=True, **kwargs)def scale_to_fit_width(self, width, **kwargs):- return self.rescale_to_fit(width, 0, stretch = False, **kwargs)+ return self.rescale_to_fit(width, 0, stretch=False, **kwargs)def scale_to_fit_height(self, height, **kwargs):- return self.rescale_to_fit(height, 1, stretch = False, **kwargs)+ return self.rescale_to_fit(height, 1, stretch=False, **kwargs)def scale_to_fit_depth(self, depth, **kwargs):- return self.rescale_to_fit(depth, 2, stretch = False, **kwargs)+ return self.rescale_to_fit(depth, 2, stretch=False, **kwargs)- def space_out_submobjects(self, factor = 1.5, **kwargs):+ def space_out_submobjects(self, factor=1.5, **kwargs):self.scale(factor, **kwargs)for submob in self.submobjects:- submob.scale(1./factor)+ submob.scale(1. / factor)return self- def move_to(self, point_or_mobject, aligned_edge = ORIGIN,- coor_mask = np.array([1,1,1])):+ def move_to(self, point_or_mobject, aligned_edge=ORIGIN,+ coor_mask=np.array([1, 1, 1])):if isinstance(point_or_mobject, Mobject):target = point_or_mobject.get_critical_point(aligned_edge)else:target = point_or_mobjectpoint_to_align = self.get_critical_point(aligned_edge)- self.shift((target - point_to_align)*coor_mask)+ self.shift((target - point_to_align) * coor_mask)return self- def replace(self, mobject, dim_to_match = 0, stretch = False):+ def replace(self, mobject, dim_to_match=0, stretch=False):if not mobject.get_num_points() and not mobject.submobjects:raise Warning("Attempting to replace mobject with no points")return self@@ -441,12 +441,12 @@ class Mobject(Container):self.rescale_to_fit(mobject.length_over_dim(dim_to_match),dim_to_match,- stretch = False+ stretch=False)self.shift(mobject.get_center() - self.get_center())return self- def surround(self, mobject, dim_to_match = 0, stretch = False, buffer_factor = 1.2):+ def surround(self, mobject, dim_to_match=0, stretch=False, buffer_factor=1.2):self.replace(mobject, dim_to_match, stretch)self.scale_in_place(buffer_factor)@@ -455,15 +455,15 @@ class Mobject(Container):if np.all(curr_vect == 0):raise Exception("Cannot position endpoints of closed loop")target_vect = end - start- self.scale(np.linalg.norm(target_vect)/np.linalg.norm(curr_vect))+ self.scale(np.linalg.norm(target_vect) / np.linalg.norm(curr_vect))self.rotate(- angle_of_vector(target_vect) - \+ angle_of_vector(target_vect) -angle_of_vector(curr_vect))- self.shift(start-self.points[0])+ self.shift(start - self.points[0])return self- ## Match other mobvject properties+ # Match other mobvject propertiesdef match_color(self, mobject):return self.set_color(mobject.get_color())@@ -483,9 +483,9 @@ class Mobject(Container):def match_depth(self, mobject, **kwargs):return self.match_dim(mobject, 2, **kwargs)- ## Color functions+ # Color functions- def set_color(self, color = YELLOW_C, family = True):+ def set_color(self, color=YELLOW_C, family=True):"""Condition is function which takes in one arguments, (x, y, z).Here it just recurses to submobjects, but in subclasses this@@ -494,7 +494,7 @@ class Mobject(Container):"""if family:for submob in self.submobjects:- submob.set_color(color, family = family)+ submob.set_color(color, family=family)self.color = colorreturn self@@ -502,8 +502,9 @@ class Mobject(Container):self.set_submobject_colors_by_gradient(*colors)return self- def set_colors_by_radial_gradient(self, center = None, radius = 1, inner_color = WHITE, outer_color = BLACK):- self.set_submobject_colors_by_radial_gradient(center, radius, inner_color, outer_color)+ def set_colors_by_radial_gradient(self, center=None, radius=1, inner_color=WHITE, outer_color=BLACK):+ self.set_submobject_colors_by_radial_gradient(+ center, radius, inner_color, outer_color)return selfdef set_submobject_colors_by_gradient(self, *colors):@@ -516,19 +517,19 @@ class Mobject(Container):new_colors = color_gradient(colors, len(mobs))for mob, color in zip(mobs, new_colors):- mob.set_color(color, family = False)+ mob.set_color(color, family=False)return self- def set_submobject_colors_by_radial_gradient(self, center = None, radius = 1, inner_color = WHITE, outer_color = BLACK):+ def set_submobject_colors_by_radial_gradient(self, center=None, radius=1, inner_color=WHITE, outer_color=BLACK):mobs = self.family_members_with_points()if center == None:center = self.get_center()for mob in self.family_members_with_points():- t = np.linalg.norm(mob.get_center() - center)/radius- t = min(t,1)+ t = np.linalg.norm(mob.get_center() - center) / radius+ t = min(t, 1)mob_color = interpolate_color(inner_color, outer_color, t)- mob.set_color(mob_color, family = False)+ mob.set_color(mob_color, family=False)return self@@ -538,7 +539,7 @@ class Mobject(Container):# Some objects (e.g., VMobjects) have special fading# behavior. We let every object handle its individual- # fading via fade_no_recurse (notionally a purely internal method),+ # fading via fade_no_recurse (notionally a purely internal method),# and then have fade() itself call this recursively on each submobject## Similarly for fade_to_no_recurse and fade_to, the underlying functions@@ -549,7 +550,7 @@ class Mobject(Container):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)+ self.set_color(Color(rgb=new_rgb), family=False)return selfdef fade_to(self, color, alpha):@@ -561,7 +562,7 @@ class Mobject(Container):self.fade_to_no_recurse(BLACK, darkness)return self- def fade(self, darkness = 0.5):+ def fade(self, darkness=0.5):for submob in self.submobject_family():submob.fade_no_recurse(darkness)return self@@ -570,9 +571,9 @@ class Mobject(Container):return self.color##- def save_state(self, use_deepcopy = False):+ def save_state(self, use_deepcopy=False):if hasattr(self, "saved_state"):- #Prevent exponential growth of data+ # Prevent exponential growth of dataself.saved_state = Noneif use_deepcopy:self.saved_state = self.deepcopy()@@ -634,7 +635,7 @@ class Mobject(Container):max_point = self.reduce_across_dimension(np.max, np.max, dim)if direction[dim] == 0:- result[dim] = (max_point+min_point)/2+ result[dim] = (max_point + min_point) / 2elif direction[dim] < 0:result[dim] = min_pointelse:@@ -694,8 +695,7 @@ class Mobject(Container):def point_from_proportion(self, alpha):raise Exception("Not implemented")-- ## Family matters+ # Family mattersdef __getitem__(self, value):self_list = self.split()@@ -724,22 +724,22 @@ class Mobject(Container):def family_members_with_points(self):return filter(- lambda m : m.get_num_points() > 0,+ lambda m: m.get_num_points() > 0,self.submobject_family())- def arrange_submobjects(self, direction = RIGHT, center = True, **kwargs):+ def arrange_submobjects(self, direction=RIGHT, center=True, **kwargs):for m1, m2 in zip(self.submobjects, self.submobjects[1:]):m2.next_to(m1, direction, **kwargs)if center:self.center()return self- def arrange_submobjects_in_grid(self, n_rows = None, n_cols = None, **kwargs):+ def arrange_submobjects_in_grid(self, n_rows=None, n_cols=None, **kwargs):submobs = self.submobjectsif n_rows is None and n_cols is None:n_cols = int(np.sqrt(len(submobs)))-+if n_rows is not None:v1 = RIGHTv2 = DOWN@@ -749,35 +749,35 @@ class Mobject(Container):v2 = RIGHTn = len(submobs) / n_colsGroup(*[- Group(*submobs[i:i+n]).arrange_submobjects(v1, **kwargs)+ Group(*submobs[i:i + n]).arrange_submobjects(v1, **kwargs)for i in range(0, len(submobs), n)]).arrange_submobjects(v2, **kwargs)return self- def sort_submobjects(self, point_to_num_func = lambda p : p[0]):+ def sort_submobjects(self, point_to_num_func=lambda p: p[0]):self.submobjects.sort(- lambda *mobs : cmp(*[+ lambda *mobs: cmp(*[point_to_num_func(mob.get_center())for mob in mobs]))return self- def print_submobject_family(self, n_tabs = 0):+ def print_submobject_family(self, n_tabs=0):"""For debugging purposes"""- print "\t"*n_tabs, self, id(self)+ print "\t" * n_tabs, self, id(self)for submob in self.submobjects:submob.print_mobject_family(n_tabs + 1)- ## Alignment+ # Alignmentdef align_data(self, mobject):self.align_submobjects(mobject)self.align_points(mobject)- #Recurse+ # Recursefor m1, m2 in zip(self.submobjects, mobject.submobjects):m1.align_data(m2)- def get_point_mobject(self, center = None):+ def get_point_mobject(self, center=None):"""The simplest mobject to be transformed to or from self.Should by a point of the appropriate type@@ -797,8 +797,8 @@ class Mobject(Container):raise Exception("Not implemented")def align_submobjects(self, mobject):- #If one is empty, and the other is not,- #push it into its submobject list+ # If one is empty, and the other is not,+ # push it into its submobject listself_has_points, mob_has_points = [mob.get_num_points() > 0for mob in self, mobject@@ -809,7 +809,7 @@ class Mobject(Container):self.null_point_align(mobject)self_count = len(self.submobjects)mob_count = len(mobject.submobjects)- diff = self_count-mob_count+ diff = self_count - mob_countif diff < 0:self.add_n_more_submobjects(-diff)elif diff > 0:@@ -840,7 +840,7 @@ class Mobject(Container):self.add(self.copy())n -= 1curr += 1- indices = curr*np.arange(curr+n)/(curr+n)+ indices = curr * np.arange(curr + n) / (curr + n)new_submobjects = []for index in indices:submob = self.submobjects[index]@@ -854,7 +854,7 @@ class Mobject(Container):return submob.copy()def interpolate(self, mobject1, mobject2,- alpha, path_func = straight_path):+ alpha, path_func=straight_path):"""Turns self into an interpolation between mobject1and mobject2.@@ -865,7 +865,7 @@ class Mobject(Container):self.interpolate_color(mobject1, mobject2, alpha)def interpolate_color(self, mobject1, mobject2, alpha):- pass #To implement in subclass+ pass # To implement in subclassdef become_partial(self, mobject, a, b):"""@@ -874,15 +874,16 @@ class Mobject(Container):Inputs 0 <= a < b <= 1 determine what portionof mobject to become."""- pass #To implement in subclasses+ pass # To implement in subclasses- #TODO, color?+ # TODO, color?def pointwise_become_partial(self, mobject, a, b):- pass #To implement in subclass+ pass # To implement in subclass+class Group(Mobject):- #Alternate name to improve readibility in cases where- #the mobject is used primarily for its submobject housing- #functionality.+ # Alternate name to improve readibility in cases where+ # the mobject is used primarily for its submobject housing+ # functionality.passdiff --git a/mobject/number_line.py b/mobject/number_line.pyindex ba332f510..e581075cd 100644--- a/mobject/number_line.py+++ b/mobject/number_line.py@@ -10,49 +10,50 @@ from mobject.geometry import Linefrom utils.bezier import interpolatefrom utils.config_ops import digest_config+class NumberLine(VMobject):CONFIG = {- "color" : BLUE,- "x_min" : -FRAME_X_RADIUS,- "x_max" : FRAME_X_RADIUS,- "unit_size" : 1,- "tick_size" : 0.1,- "tick_frequency" : 1,- "leftmost_tick" : None, #Defaults to value near x_min s.t. 0 is a tick- "numbers_with_elongated_ticks" : [0],- "numbers_to_show" : None,- "longer_tick_multiple" : 2,- "number_at_center" : 0,- "number_scale_val" : 0.75,- "label_direction" : DOWN,- "line_to_number_buff" : MED_SMALL_BUFF,- "include_tip" : False,- "propagate_style_to_family" : True,+ "color": BLUE,+ "x_min": -FRAME_X_RADIUS,+ "x_max": FRAME_X_RADIUS,+ "unit_size": 1,+ "tick_size": 0.1,+ "tick_frequency": 1,+ "leftmost_tick": None, # Defaults to value near x_min s.t. 0 is a tick+ "numbers_with_elongated_ticks": [0],+ "numbers_to_show": None,+ "longer_tick_multiple": 2,+ "number_at_center": 0,+ "number_scale_val": 0.75,+ "label_direction": DOWN,+ "line_to_number_buff": MED_SMALL_BUFF,+ "include_tip": False,+ "propagate_style_to_family": True,}def __init__(self, **kwargs):digest_config(self, kwargs)if self.leftmost_tick is None:tf = self.tick_frequency- self.leftmost_tick = tf*np.ceil(self.x_min/tf)+ self.leftmost_tick = tf * np.ceil(self.x_min / tf)VMobject.__init__(self, **kwargs)if self.include_tip:self.add_tip()def generate_points(self):- self.main_line = Line(self.x_min*RIGHT, self.x_max*RIGHT)+ self.main_line = Line(self.x_min * RIGHT, self.x_max * RIGHT)self.tick_marks = VGroup()self.add(self.main_line, self.tick_marks)- rounding_value = int(-np.log10(0.1*self.tick_frequency))+ rounding_value = int(-np.log10(0.1 * self.tick_frequency))rounded_numbers_with_elongated_ticks = np.round(- self.numbers_with_elongated_ticks,+ self.numbers_with_elongated_ticks,rounding_value)for x in self.get_tick_numbers():rounded_x = np.round(x, rounding_value)if rounded_x in rounded_numbers_with_elongated_ticks:- tick_size_used = self.longer_tick_multiple*self.tick_size+ tick_size_used = self.longer_tick_multiple * self.tick_sizeelse:tick_size_used = self.tick_sizeself.add_tick(x, tick_size_used)@@ -60,13 +61,14 @@ class NumberLine(VMobject):self.stretch(self.unit_size, 0)self.shift(-self.number_to_point(self.number_at_center))- def add_tick(self, x, size = None):+ def add_tick(self, x, size=None):self.tick_marks.add(self.get_tick(x, size))return self- def get_tick(self, x, size = None):- if size is None: size = self.tick_size- result = Line(size*DOWN, size*UP)+ def get_tick(self, x, size=None):+ if size is None:+ size = self.tick_size+ result = Line(size * DOWN, size * UP)result.rotate(self.main_line.get_angle())result.move_to(self.number_to_point(x))return result@@ -77,12 +79,12 @@ class NumberLine(VMobject):def get_tick_numbers(self):epsilon = 0.001return np.arange(- self.leftmost_tick, self.x_max+epsilon,+ self.leftmost_tick, self.x_max + epsilon,self.tick_frequency)def number_to_point(self, number):- alpha = float(number-self.x_min)/(self.x_max - self.x_min)+ alpha = float(number - self.x_min) / (self.x_max - self.x_min)return interpolate(self.main_line.get_start(),self.main_line.get_end(),@@ -91,22 +93,23 @@ class NumberLine(VMobject):def point_to_number(self, point):left_point, right_point = self.main_line.get_start_and_end()- full_vect = right_point-left_point+ full_vect = right_point - left_point+def distance_from_left(p):- return np.dot(p-left_point, full_vect)/np.linalg.norm(full_vect)+ return np.dot(p - left_point, full_vect) / np.linalg.norm(full_vect)return interpolate(- self.x_min, self.x_max,- distance_from_left(point)/distance_from_left(right_point)+ self.x_min, self.x_max,+ distance_from_left(point) / distance_from_left(right_point))def default_numbers_to_display(self):if self.numbers_to_show is not None:return self.numbers_to_show- return np.arange(int(self.leftmost_tick), int(self.x_max)+1)+ return np.arange(int(self.leftmost_tick), int(self.x_max) + 1)def get_number_mobjects(self, *numbers, **kwargs):- #TODO, handle decimals+ # TODO, handle decimalsif len(numbers) == 0:numbers = self.default_numbers_to_display()if "force_integers" in kwargs and kwargs["force_integers"]:@@ -135,20 +138,20 @@ class NumberLine(VMobject):def add_tip(self):start, end = self.main_line.get_start_and_end()- vect = (end - start)/np.linalg.norm(end-start)- arrow = Arrow(start, end + MED_SMALL_BUFF*vect, buff = 0)+ vect = (end - start) / np.linalg.norm(end - start)+ arrow = Arrow(start, end + MED_SMALL_BUFF * vect, buff=0)tip = arrow.tiptip.set_color(self.color)self.tip = tipself.add(tip)+class UnitInterval(NumberLine):CONFIG = {- "x_min" : 0,- "x_max" : 1,- "unit_size" : 6,- "tick_frequency" : 0.1,- "numbers_with_elongated_ticks" : [0, 1],- "number_at_center" : 0.5,+ "x_min": 0,+ "x_max": 1,+ "unit_size": 6,+ "tick_frequency": 0.1,+ "numbers_with_elongated_ticks": [0, 1],+ "number_at_center": 0.5,}-diff --git a/mobject/numbers.py b/mobject/numbers.pyindex bb50c0700..1e8d84f20 100644--- a/mobject/numbers.py+++ b/mobject/numbers.py@@ -7,29 +7,31 @@ from mobject.types.vectorized_mobject import VGroupfrom mobject.types.vectorized_mobject import VMobjectfrom mobject.shape_matchers import BackgroundRectangle+class DecimalNumber(VMobject):CONFIG = {- "num_decimal_points" : 2,- "digit_to_digit_buff" : 0.05,- "show_ellipsis" : False,- "unit" : None, #Aligned to bottom unless it starts with "^"- "include_background_rectangle" : False,+ "num_decimal_points": 2,+ "digit_to_digit_buff": 0.05,+ "show_ellipsis": False,+ "unit": None, # Aligned to bottom unless it starts with "^"+ "include_background_rectangle": False,}+def __init__(self, number, **kwargs):VMobject.__init__(self, **kwargs)self.number = numberndp = self.num_decimal_points- #Build number string+ # Build number stringif isinstance(number, complex):- num_string = '%.*f%s%.*fi'%(- ndp, number.real,+ num_string = '%.*f%s%.*fi' % (+ ndp, number.real,"-" if number.imag < 0 else "+",ndp, abs(number.imag))else:- num_string = '%.*f'%(ndp, number)- negative_zero_string = "-%.*f"%(ndp, 0.)+ num_string = '%.*f' % (ndp, number)+ negative_zero_string = "-%.*f" % (ndp, 0.)if num_string == negative_zero_string:num_string = num_string[1:]self.add(*[@@ -37,32 +39,31 @@ class DecimalNumber(VMobject):for char in num_string])- #Add non-numerical bits+ # Add non-numerical bitsif self.show_ellipsis:self.add(TexMobject("\\dots"))-if num_string.startswith("-"):minus = self.submobjects[0]minus.next_to(self.submobjects[1], LEFT,- buff = self.digit_to_digit_buff+ buff=self.digit_to_digit_buff)- if self.unit != None:+ if self.unit is not None:self.unit_sign = TexMobject(self.unit)self.add(self.unit_sign)self.arrange_submobjects(- buff = self.digit_to_digit_buff,- aligned_edge = DOWN+ buff=self.digit_to_digit_buff,+ aligned_edge=DOWN)- #Handle alignment of parts that should be aligned- #to the bottom+ # Handle alignment of parts that should be aligned+ # to the bottomfor i, c in enumerate(num_string):- if c == "-" and len(num_string) > i+1:- self[i].align_to(self[i+1], alignment_vect = UP)+ if c == "-" and len(num_string) > i + 1:+ self[i].align_to(self[i + 1], alignment_vect=UP)if self.unit and self.unit.startswith("^"):self.unit_sign.align_to(self, UP)#@@ -70,8 +71,8 @@ class DecimalNumber(VMobject):self.add_background_rectangle()def add_background_rectangle(self):- #TODO, is this the best way to handle- #background rectangles?+ # TODO, is this the best way to handle+ # background rectangles?self.background_rectangle = BackgroundRectangle(self)self.submobjects = [self.background_rectangle,@@ -79,7 +80,8 @@ class DecimalNumber(VMobject):]return self+class Integer(DecimalNumber):CONFIG = {- "num_decimal_points" : 0,+ "num_decimal_points": 0,}diff --git a/mobject/probability.py b/mobject/probability.pyindex d4a1ef937..9f7b923bc 100644--- a/mobject/probability.py+++ b/mobject/probability.py@@ -15,29 +15,31 @@ from utils.iterables import tuplifyEPSILON = 0.0001+class SampleSpace(Rectangle):CONFIG = {- "height" : 3,- "width" : 3,- "fill_color" : DARK_GREY,- "fill_opacity" : 1,- "stroke_width" : 0.5,- "stroke_color" : LIGHT_GREY,+ "height": 3,+ "width": 3,+ "fill_color": DARK_GREY,+ "fill_opacity": 1,+ "stroke_width": 0.5,+ "stroke_color": LIGHT_GREY,##- "default_label_scale_val" : 1,+ "default_label_scale_val": 1,}- def add_title(self, title = "Sample space", buff = MED_SMALL_BUFF):- ##TODO, should this really exist in SampleSpaceScene++ def add_title(self, title="Sample space", buff=MED_SMALL_BUFF):+ # TODO, should this really exist in SampleSpaceScenetitle_mob = TextMobject(title)if title_mob.get_width() > self.get_width():title_mob.scale_to_fit_width(self.get_width())- title_mob.next_to(self, UP, buff = buff)+ title_mob.next_to(self, UP, buff=buff)self.title = title_mobself.add(title_mob)def add_label(self, label):self.label = label-+def complete_p_list(self, p_list):new_p_list = list(tuplify(p_list))remainder = 1.0 - sum(new_p_list)@@ -54,7 +56,7 @@ class SampleSpace(Rectangle):for factor, color in zip(p_list, colors):part = SampleSpace()part.set_fill(color, 1)- part.replace(self, stretch = True)+ part.replace(self, stretch=True)part.stretch(factor, dim)part.move_to(last_point, -vect)last_point = part.get_edge_center(vect)@@ -62,17 +64,17 @@ class SampleSpace(Rectangle):return partsdef get_horizontal_division(- self, p_list,- colors = [GREEN_E, BLUE_E],- vect = DOWN- ):+ self, p_list,+ colors=[GREEN_E, BLUE_E],+ vect=DOWN+ ):return self.get_division_along_dimension(p_list, 1, colors, vect)def get_vertical_division(- self, p_list,- colors = [MAROON_B, YELLOW],- vect = RIGHT- ):+ self, p_list,+ colors=[MAROON_B, YELLOW],+ vect=RIGHT+ ):return self.get_division_along_dimension(p_list, 0, colors, vect)def divide_horizontally(self, *args, **kwargs):@@ -85,16 +87,16 @@ class SampleSpace(Rectangle):def get_subdivision_braces_and_labels(self, parts, labels, direction,- buff = SMALL_BUFF,- min_num_quads = 1- ):+ buff=SMALL_BUFF,+ min_num_quads=1+ ):label_mobs = VGroup()braces = VGroup()for label, part in zip(labels, parts):brace = Brace(- part, direction,- min_num_quads = min_num_quads,- buff = buff+ part, direction,+ min_num_quads=min_num_quads,+ buff=buff)if isinstance(label, Mobject):label_mob = label@@ -108,13 +110,13 @@ class SampleSpace(Rectangle):parts.braces = bracesparts.labels = label_mobsparts.label_kwargs = {- "labels" : label_mobs.copy(),- "direction" : direction,- "buff" : buff,+ "labels": label_mobs.copy(),+ "direction": direction,+ "buff": buff,}return VGroup(parts.braces, parts.labels)- def get_side_braces_and_labels(self, labels, direction = LEFT, **kwargs):+ def get_side_braces_and_labels(self, labels, direction=LEFT, **kwargs):assert(hasattr(self, "horizontal_parts"))parts = self.horizontal_partsreturn self.get_subdivision_braces_and_labels(parts, labels, direction, **kwargs)@@ -145,21 +147,23 @@ class SampleSpace(Rectangle):return self.vertical_parts[index]return self.split()[index]+class BarChart(VGroup):CONFIG = {- "height" : 4,- "width" : 6,- "n_ticks" : 4,- "tick_width" : 0.2,- "label_y_axis" : True,- "y_axis_label_height" : 0.25,- "max_value" : 1,- "bar_colors" : [BLUE, YELLOW],- "bar_fill_opacity" : 0.8,- "bar_stroke_width" : 3,- "bar_names" : [],- "bar_label_scale_val" : 0.75,+ "height": 4,+ "width": 6,+ "n_ticks": 4,+ "tick_width": 0.2,+ "label_y_axis": True,+ "y_axis_label_height": 0.25,+ "max_value": 1,+ "bar_colors": [BLUE, YELLOW],+ "bar_fill_opacity": 0.8,+ "bar_stroke_width": 3,+ "bar_names": [],+ "bar_label_scale_val": 0.75,}+def __init__(self, values, **kwargs):VGroup.__init__(self, **kwargs)if self.max_value is None:@@ -170,15 +174,15 @@ class BarChart(VGroup):self.center()def add_axes(self):- x_axis = Line(self.tick_width*LEFT/2, self.width*RIGHT)- y_axis = Line(MED_LARGE_BUFF*DOWN, self.height*UP)+ x_axis = Line(self.tick_width * LEFT / 2, self.width * RIGHT)+ y_axis = Line(MED_LARGE_BUFF * DOWN, self.height * UP)ticks = VGroup()- heights = np.linspace(0, self.height, self.n_ticks+1)- values = np.linspace(0, self.max_value, self.n_ticks+1)+ heights = np.linspace(0, self.height, self.n_ticks + 1)+ values = np.linspace(0, self.max_value, self.n_ticks + 1)for y, value in zip(heights, values):tick = Line(LEFT, RIGHT)tick.scale_to_fit_width(self.tick_width)- tick.move_to(y*UP)+ tick.move_to(y * UP)ticks.add(tick)y_axis.add(ticks)@@ -195,18 +199,17 @@ class BarChart(VGroup):self.y_axis_labels = labelsself.add(labels)-def add_bars(self, values):- buff = float(self.width) / (2*len(values) + 1)+ buff = float(self.width) / (2 * len(values) + 1)bars = VGroup()for i, value in enumerate(values):bar = Rectangle(- height = (value/self.max_value)*self.height,- width = buff,- stroke_width = self.bar_stroke_width,- fill_opacity = self.bar_fill_opacity,+ height=(value / self.max_value) * self.height,+ width=buff,+ stroke_width=self.bar_stroke_width,+ fill_opacity=self.bar_fill_opacity,)- bar.move_to((2*i+1)*buff*RIGHT, DOWN+LEFT)+ bar.move_to((2 * i + 1) * buff * RIGHT, DOWN + LEFT)bars.add(bar)bars.set_color_by_gradient(*self.bar_colors)@@ -225,27 +228,9 @@ class BarChart(VGroup):for bar, value in zip(self.bars, values):bar_bottom = bar.get_bottom()bar.stretch_to_fit_height(- (value/self.max_value)*self.height+ (value / self.max_value) * self.height)bar.move_to(bar_bottom, DOWN)def copy(self):return self.deepcopy()------------------diff --git a/mobject/shape_matchers.py b/mobject/shape_matchers.pyindex b2e1199aa..7ecbb4575 100644--- a/mobject/shape_matchers.py+++ b/mobject/shape_matchers.py@@ -8,31 +8,35 @@ from mobject.types.vectorized_mobject import VGroupfrom utils.config_ops import digest_configfrom utils.color import Color+class SurroundingRectangle(Rectangle):CONFIG = {- "color" : YELLOW,- "buff" : SMALL_BUFF,+ "color": YELLOW,+ "buff": SMALL_BUFF,}+def __init__(self, mobject, **kwargs):digest_config(self, kwargs)- kwargs["width"] = mobject.get_width() + 2*self.buff- kwargs["height"] = mobject.get_height() + 2*self.buff+ kwargs["width"] = mobject.get_width() + 2 * self.buff+ kwargs["height"] = mobject.get_height() + 2 * self.buffRectangle.__init__(self, **kwargs)self.move_to(mobject)+class BackgroundRectangle(SurroundingRectangle):CONFIG = {- "color" : BLACK,- "stroke_width" : 0,- "fill_opacity" : 0.75,- "buff" : 0+ "color": BLACK,+ "stroke_width": 0,+ "fill_opacity": 0.75,+ "buff": 0}+def __init__(self, mobject, **kwargs):SurroundingRectangle.__init__(self, mobject, **kwargs)self.original_fill_opacity = self.fill_opacitydef pointwise_become_partial(self, mobject, a, b):- self.set_fill(opacity = b*self.original_fill_opacity)+ self.set_fill(opacity=b * self.original_fill_opacity)return selfdef set_color(self):@@ -42,15 +46,17 @@ class BackgroundRectangle(SurroundingRectangle):def get_fill_color(self):return Color(self.color)+class Cross(VGroup):CONFIG = {- "stroke_color" : RED,- "stroke_width" : 6,+ "stroke_color": RED,+ "stroke_width": 6,}+def __init__(self, mobject, **kwargs):- VGroup.__init__(self,- Line(UP+LEFT, DOWN+RIGHT),- Line(UP+RIGHT, DOWN+LEFT),- )- self.replace(mobject, stretch = True)+ 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)diff --git a/mobject/svg/brace.py b/mobject/svg/brace.pyindex c56d882d6..4ef048dad 100644--- a/mobject/svg/brace.py+++ b/mobject/svg/brace.py@@ -12,35 +12,37 @@ from mobject.svg.tex_mobject import TextMobjectfrom mobject.types.vectorized_mobject import VMobjectfrom utils.config_ops import digest_config+class Brace(TexMobject):CONFIG = {- "buff" : 0.2,- "width_multiplier" : 2,- "max_num_quads" : 15,- "min_num_quads" : 0,+ "buff": 0.2,+ "width_multiplier": 2,+ "max_num_quads": 15,+ "min_num_quads": 0,}- def __init__(self, mobject, direction = DOWN, **kwargs):++ def __init__(self, mobject, direction=DOWN, **kwargs):digest_config(self, kwargs, locals())angle = -np.arctan2(*direction[:2]) + np.pi- mobject.rotate(-angle, about_point = ORIGIN)- left = mobject.get_corner(DOWN+LEFT)- right = mobject.get_corner(DOWN+RIGHT)- target_width = right[0]-left[0]+ mobject.rotate(-angle, about_point=ORIGIN)+ left = mobject.get_corner(DOWN + LEFT)+ right = mobject.get_corner(DOWN + RIGHT)+ target_width = right[0] - left[0]- ## Adding int(target_width) qquads gives approximately the right width+ # Adding int(target_width) qquads gives approximately the right widthnum_quads = np.clip(- int(self.width_multiplier*target_width),+ int(self.width_multiplier * target_width),self.min_num_quads, self.max_num_quads)- tex_string = "\\underbrace{%s}"%(num_quads*"\\qquad")+ tex_string = "\\underbrace{%s}" % (num_quads * "\\qquad")TexMobject.__init__(self, tex_string, **kwargs)- self.tip_point_index = np.argmin(self.get_all_points()[:,1])+ self.tip_point_index = np.argmin(self.get_all_points()[:, 1])self.stretch_to_fit_width(target_width)- self.shift(left - self.get_corner(UP+LEFT) + self.buff*DOWN)+ self.shift(left - self.get_corner(UP + LEFT) + self.buff * DOWN)for mob in mobject, self:- mob.rotate(angle, about_point = ORIGIN)+ mob.rotate(angle, about_point=ORIGIN)- def put_at_tip(self, mob, use_next_to = True, **kwargs):+ def put_at_tip(self, mob, use_next_to=True, **kwargs):if use_next_to:mob.next_to(self.get_tip(),@@ -50,8 +52,8 @@ class Brace(TexMobject):else:mob.move_to(self.get_tip())buff = kwargs.get("buff", DEFAULT_MOBJECT_TO_MOBJECT_BUFFER)- shift_distance = mob.get_width()/2.0+buff- mob.shift(self.get_direction()*shift_distance)+ shift_distance = mob.get_width() / 2.0 + buff+ mob.shift(self.get_direction() * shift_distance)return selfdef get_text(self, *text, **kwargs):@@ -72,32 +74,38 @@ class Brace(TexMobject):def get_direction(self):vect = self.get_tip() - self.get_center()- return vect/np.linalg.norm(vect)+ return vect / np.linalg.norm(vect)+class BraceLabel(VMobject):CONFIG = {- "label_constructor" : TexMobject,- "label_scale" : 1,+ "label_constructor": TexMobject,+ "label_scale": 1,}- def __init__(self, obj, text, brace_direction = DOWN, **kwargs):++ def __init__(self, obj, text, brace_direction=DOWN, **kwargs):VMobject.__init__(self, **kwargs)self.brace_direction = brace_direction- if isinstance(obj, list): obj = VMobject(*obj)+ if isinstance(obj, list):+ obj = VMobject(*obj)self.brace = Brace(obj, brace_direction, **kwargs)if isinstance(text, tuple) or isinstance(text, list):self.label = self.label_constructor(*text, **kwargs)- else: self.label = self.label_constructor(str(text))- if self.label_scale != 1: self.label.scale(self.label_scale)+ else:+ self.label = self.label_constructor(str(text))+ if self.label_scale != 1:+ self.label.scale(self.label_scale)self.brace.put_at_tip(self.label)self.submobjects = [self.brace, self.label]- def creation_anim(self, label_anim = FadeIn, brace_anim = GrowFromCenter):+ def creation_anim(self, label_anim=FadeIn, brace_anim=GrowFromCenter):return AnimationGroup(brace_anim(self.brace), label_anim(self.label))def shift_brace(self, obj, **kwargs):- if isinstance(obj, list): obj = VMobject(*obj)+ if isinstance(obj, list):+ obj = VMobject(*obj)self.brace = Brace(obj, self.brace_direction, **kwargs)self.brace.put_at_tip(self.label)self.submobjects[0] = self.brace@@ -105,7 +113,8 @@ class BraceLabel(VMobject):def change_label(self, *text, **kwargs):self.label = self.label_constructor(*text, **kwargs)- if self.label_scale != 1: self.label.scale(self.label_scale)+ if self.label_scale != 1:+ self.label.scale(self.label_scale)self.brace.put_at_tip(self.label)self.submobjects[1] = self.label@@ -124,7 +133,8 @@ class BraceLabel(VMobject):return copy_mobject+class BraceText(BraceLabel):CONFIG = {- "label_constructor" : TextMobject+ "label_constructor": TextMobject}diff --git a/mobject/svg/drawings.py b/mobject/svg/drawings.pyindex 9b4ac6ca9..6206c33cd 100644--- a/mobject/svg/drawings.py+++ b/mobject/svg/drawings.py@@ -4,7 +4,6 @@ from constants import *from mobject.mobject import Mobjectfrom mobject.svg.svg_mobject import SVGMobject-from mobject.svg.brace import Bracefrom mobject.svg.tex_mobject import TexMobjectfrom mobject.svg.tex_mobject import TextMobjectfrom mobject.types.vectorized_mobject import VGroup@@ -12,12 +11,7 @@ from mobject.types.vectorized_mobject import VMobjectfrom mobject.types.vectorized_mobject import VectorizedPointfrom animation.animation import Animation-from animation.composition import AnimationGroup-from animation.composition import LaggedStartfrom animation.rotation import Rotating-from animation.transform import ApplyMethod-from animation.creation import FadeIn-from animation.creation import GrowFromCenterfrom mobject.geometry import Arcfrom mobject.geometry import Circle@@ -25,97 +19,102 @@ from mobject.geometry import Linefrom mobject.geometry import Polygonfrom mobject.geometry import Rectanglefrom mobject.geometry import Square-from mobject.shape_matchers import SurroundingRectanglefrom mobject.three_dimensions import Cubefrom utils.config_ops import digest_config-from utils.config_ops import digest_locals-from utils.space_ops import R3_to_complexfrom utils.space_ops import angle_of_vectorfrom utils.space_ops import complex_to_R3from utils.space_ops import rotate_vector+class Lightbulb(SVGMobject):CONFIG = {- "file_name" : "lightbulb",- "height" : 1,- "stroke_color" : YELLOW,- "stroke_width" : 3,- "fill_color" : YELLOW,- "fill_opacity" : 0,+ "file_name": "lightbulb",+ "height": 1,+ "stroke_color": YELLOW,+ "stroke_width": 3,+ "fill_color": YELLOW,+ "fill_opacity": 0,}+class BitcoinLogo(SVGMobject):CONFIG = {- "file_name" : "Bitcoin_logo",- "height" : 1,- "fill_color" : "#f7931a",- "inner_color" : WHITE,- "fill_opacity" : 1,- "stroke_width" : 0,+ "file_name": "Bitcoin_logo",+ "height": 1,+ "fill_color": "#f7931a",+ "inner_color": WHITE,+ "fill_opacity": 1,+ "stroke_width": 0,}+def __init__(self, **kwargs):SVGMobject.__init__(self, **kwargs)self[0].set_fill(self.fill_color, self.fill_opacity)self[1].set_fill(self.inner_color, 1)+class Guitar(SVGMobject):CONFIG = {- "file_name" : "guitar",- "height" : 2.5,- "fill_color" : DARK_GREY,- "fill_opacity" : 1,- "stroke_color" : WHITE,- "stroke_width" : 0.5,+ "file_name": "guitar",+ "height": 2.5,+ "fill_color": DARK_GREY,+ "fill_opacity": 1,+ "stroke_color": WHITE,+ "stroke_width": 0.5,}+class SunGlasses(SVGMobject):CONFIG = {- "file_name" : "sunglasses",- "glasses_width_to_eyes_width" : 1.1,+ "file_name": "sunglasses",+ "glasses_width_to_eyes_width": 1.1,}+def __init__(self, pi_creature, **kwargs):SVGMobject.__init__(self, **kwargs)- self.set_stroke(WHITE, width = 0)+ self.set_stroke(WHITE, width=0)self.set_fill(GREY, 1)self.scale_to_fit_width(- self.glasses_width_to_eyes_width*pi_creature.eyes.get_width()+ self.glasses_width_to_eyes_width * pi_creature.eyes.get_width())self.move_to(pi_creature.eyes, UP)+class Speedometer(VMobject):CONFIG = {- "arc_angle" : 4*np.pi/3,- "num_ticks" : 8,- "tick_length" : 0.2,- "needle_width" : 0.1,- "needle_height" : 0.8,- "needle_color" : YELLOW,+ "arc_angle": 4 * np.pi / 3,+ "num_ticks": 8,+ "tick_length": 0.2,+ "needle_width": 0.1,+ "needle_height": 0.8,+ "needle_color": YELLOW,}+def generate_points(self):- start_angle = np.pi/2 + self.arc_angle/2- end_angle = np.pi/2 - self.arc_angle/2+ start_angle = np.pi / 2 + self.arc_angle / 2+ end_angle = np.pi / 2 - self.arc_angle / 2self.add(Arc(- start_angle = start_angle,- angle = -self.arc_angle+ start_angle=start_angle,+ angle=-self.arc_angle))tick_angle_range = np.linspace(start_angle, end_angle, self.num_ticks)for index, angle in enumerate(tick_angle_range):vect = rotate_vector(RIGHT, angle)- tick = Line((1-self.tick_length)*vect, vect)- label = TexMobject(str(10*index))+ tick = Line((1 - self.tick_length) * vect, vect)+ label = TexMobject(str(10 * index))label.scale_to_fit_height(self.tick_length)- label.shift((1+self.tick_length)*vect)+ label.shift((1 + self.tick_length) * vect)self.add(tick, label)needle = Polygon(LEFT, UP, RIGHT,- stroke_width = 0,- fill_opacity = 1,- fill_color = self.needle_color+ stroke_width=0,+ fill_opacity=1,+ fill_color=self.needle_color)needle.stretch_to_fit_width(self.needle_width)needle.stretch_to_fit_height(self.needle_height)- needle.rotate(start_angle - np.pi/2, about_point = ORIGIN)+ needle.rotate(start_angle - np.pi / 2, about_point=ORIGIN)self.add(needle)self.needle = needle@@ -136,25 +135,27 @@ class Speedometer(VMobject):)def rotate_needle(self, angle):- self.needle.rotate(angle, about_point = self.get_center())+ self.needle.rotate(angle, about_point=self.get_center())return selfdef move_needle_to_velocity(self, velocity):- max_velocity = 10*(self.num_ticks-1)+ max_velocity = 10 * (self.num_ticks - 1)proportion = float(velocity) / max_velocity- start_angle = np.pi/2 + self.arc_angle/2+ start_angle = np.pi / 2 + self.arc_angle / 2target_angle = start_angle - self.arc_angle * proportionself.rotate_needle(target_angle - self.get_needle_angle())return self+class AoPSLogo(SVGMobject):CONFIG = {- "file_name" : "aops_logo",- "height" : 1.5,+ "file_name": "aops_logo",+ "height": 1.5,}+def __init__(self, **kwargs):SVGMobject.__init__(self, **kwargs)- self.set_stroke(WHITE, width = 0)+ self.set_stroke(WHITE, width=0)colors = [BLUE_E, "#008445", GREEN_B]index_lists = [(10, 11, 12, 13, 14, 21, 22, 23, 24, 27, 28, 29, 30),@@ -163,222 +164,239 @@ class AoPSLogo(SVGMobject):]for color, index_list in zip(colors, index_lists):for i in index_list:- self.submobjects[i].set_fill(color, opacity = 1)+ self.submobjects[i].set_fill(color, opacity=1)self.scale_to_fit_height(self.height)self.center()+class PartyHat(SVGMobject):CONFIG = {- "file_name" : "party_hat",- "height" : 1.5,- "pi_creature" : None,- "stroke_width" : 0,- "fill_opacity" : 1,- "propagate_style_to_family" : True,- "frills_colors" : [MAROON_B, PURPLE],- "cone_color" : GREEN,- "dots_colors" : [YELLOW],+ "file_name": "party_hat",+ "height": 1.5,+ "pi_creature": None,+ "stroke_width": 0,+ "fill_opacity": 1,+ "propagate_style_to_family": True,+ "frills_colors": [MAROON_B, PURPLE],+ "cone_color": GREEN,+ "dots_colors": [YELLOW],}NUM_FRILLS = 7NUM_DOTS = 6+def __init__(self, **kwargs):SVGMobject.__init__(self, **kwargs)self.scale_to_fit_height(self.height)if self.pi_creature is not None:- self.next_to(self.pi_creature.eyes, UP, buff = 0)+ self.next_to(self.pi_creature.eyes, UP, buff=0)self.frills = VGroup(*self[:self.NUM_FRILLS])self.cone = self[self.NUM_FRILLS]- self.dots = VGroup(*self[self.NUM_FRILLS+1:])+ self.dots = VGroup(*self[self.NUM_FRILLS + 1:])self.frills.set_color_by_gradient(*self.frills_colors)self.cone.set_color(self.cone_color)self.dots.set_color_by_gradient(*self.dots_colors)+class Laptop(VGroup):CONFIG = {- "width" : 3,- "body_dimensions" : [4, 3, 0.05],- "screen_thickness" : 0.01,- "keyboard_width_to_body_width" : 0.9,- "keyboard_height_to_body_height" : 0.5,- "screen_width_to_screen_plate_width" : 0.9,- "key_color_kwargs" : {- "stroke_width" : 0,- "fill_color" : BLACK,- "fill_opacity" : 1,+ "width": 3,+ "body_dimensions": [4, 3, 0.05],+ "screen_thickness": 0.01,+ "keyboard_width_to_body_width": 0.9,+ "keyboard_height_to_body_height": 0.5,+ "screen_width_to_screen_plate_width": 0.9,+ "key_color_kwargs": {+ "stroke_width": 0,+ "fill_color": BLACK,+ "fill_opacity": 1,},- "body_color" : LIGHT_GREY,- "shaded_body_color" : GREY,- "open_angle" : np.pi/4,+ "body_color": LIGHT_GREY,+ "shaded_body_color": GREY,+ "open_angle": np.pi / 4,}+def generate_points(self):- body = Cube(side_length = 1)+ body = Cube(side_length=1)for dim, scale_factor in enumerate(self.body_dimensions):- body.stretch(scale_factor, dim = dim)+ body.stretch(scale_factor, dim=dim)body.scale_to_fit_width(self.width)- body.set_fill(self.shaded_body_color, opacity = 1)- body.sort_submobjects(lambda p : p[2])+ body.set_fill(self.shaded_body_color, opacity=1)+ body.sort_submobjects(lambda p: p[2])body[-1].set_fill(self.body_color)keyboard = VGroup(*[VGroup(*[Square(**self.key_color_kwargs)- for x in range(12-y%2)- ]).arrange_submobjects(RIGHT, buff = SMALL_BUFF)+ for x in range(12 - y % 2)+ ]).arrange_submobjects(RIGHT, buff=SMALL_BUFF)for y in range(4)- ]).arrange_submobjects(DOWN, buff = MED_SMALL_BUFF)+ ]).arrange_submobjects(DOWN, buff=MED_SMALL_BUFF)keyboard.stretch_to_fit_width(- self.keyboard_width_to_body_width*body.get_width(),+ self.keyboard_width_to_body_width * body.get_width(),)keyboard.stretch_to_fit_height(- self.keyboard_height_to_body_height*body.get_height(),+ self.keyboard_height_to_body_height * body.get_height(),)- keyboard.next_to(body, OUT, buff = 0.1*SMALL_BUFF)- keyboard.shift(MED_SMALL_BUFF*UP)+ keyboard.next_to(body, OUT, buff=0.1 * SMALL_BUFF)+ keyboard.shift(MED_SMALL_BUFF * UP)body.add(keyboard)screen_plate = body.copy()- screen_plate.stretch(self.screen_thickness/self.body_dimensions[2], dim = 2)+ screen_plate.stretch(self.screen_thickness /+ self.body_dimensions[2], dim=2)screen = Rectangle(- stroke_width = 0,- fill_color = BLACK,- fill_opacity = 1,+ stroke_width=0,+ fill_color=BLACK,+ fill_opacity=1,)- screen.replace(screen_plate, stretch = True)+ screen.replace(screen_plate, stretch=True)screen.scale_in_place(self.screen_width_to_screen_plate_width)- screen.next_to(screen_plate, OUT, buff = 0.1*SMALL_BUFF)+ screen.next_to(screen_plate, OUT, buff=0.1 * SMALL_BUFF)screen_plate.add(screen)- screen_plate.next_to(body, UP, buff = 0)+ screen_plate.next_to(body, UP, buff=0)screen_plate.rotate(- self.open_angle, RIGHT,- about_point = screen_plate.get_bottom()+ self.open_angle, RIGHT,+ about_point=screen_plate.get_bottom())self.screen_plate = screen_plateself.screen = screenaxis = Line(- body.get_corner(UP+LEFT+OUT),- body.get_corner(UP+RIGHT+OUT),- color = BLACK,- stroke_width = 2+ body.get_corner(UP + LEFT + OUT),+ body.get_corner(UP + RIGHT + OUT),+ color=BLACK,+ stroke_width=2)self.axis = axisself.add(body, screen_plate, axis)- self.rotate(5*np.pi/12, LEFT, about_point = ORIGIN)- self.rotate(np.pi/6, DOWN, about_point = ORIGIN)+ self.rotate(5 * np.pi / 12, LEFT, about_point=ORIGIN)+ self.rotate(np.pi / 6, DOWN, about_point=ORIGIN)+class PatreonLogo(SVGMobject):CONFIG = {- "file_name" : "patreon_logo",- "fill_color" : "#F96854",+ "file_name": "patreon_logo",+ "fill_color": "#F96854",# "fill_color" : WHITE,- "fill_opacity" : 1,- "stroke_width" : 0,- "width" : 4,- "propagate_style_to_family" : True+ "fill_opacity": 1,+ "stroke_width": 0,+ "width": 4,+ "propagate_style_to_family": True}+def __init__(self, **kwargs):SVGMobject.__init__(self, **kwargs)self.scale_to_fit_width(self.width)self.center()+class VideoIcon(SVGMobject):CONFIG = {- "file_name" : "video_icon",- "width" : FRAME_WIDTH/12.,+ "file_name": "video_icon",+ "width": FRAME_WIDTH / 12.,}+def __init__(self, **kwargs):SVGMobject.__init__(self, **kwargs)self.center()self.scale_to_fit_width(self.width)- self.set_stroke(color = WHITE, width = 0)- self.set_fill(color = WHITE, opacity = 1)+ self.set_stroke(color=WHITE, width=0)+ self.set_fill(color=WHITE, opacity=1)+class VideoSeries(VGroup):CONFIG = {- "num_videos" : 11,- "gradient_colors" : [BLUE_B, BLUE_D],+ "num_videos": 11,+ "gradient_colors": [BLUE_B, BLUE_D],}+def __init__(self, **kwargs):digest_config(self, kwargs)videos = [VideoIcon() for x in range(self.num_videos)]VGroup.__init__(self, *videos, **kwargs)self.arrange_submobjects()- self.scale_to_fit_width(FRAME_WIDTH-MED_LARGE_BUFF)+ self.scale_to_fit_width(FRAME_WIDTH - MED_LARGE_BUFF)self.set_color_by_gradient(*self.gradient_colors)+class Headphones(SVGMobject):CONFIG = {- "file_name" : "headphones",- "height" : 2,- "y_stretch_factor" : 0.5,- "color" : GREY,+ "file_name": "headphones",+ "height": 2,+ "y_stretch_factor": 0.5,+ "color": GREY,}- def __init__(self, pi_creature = None, **kwargs):++ def __init__(self, pi_creature=None, **kwargs):digest_config(self, kwargs)- SVGMobject.__init__(self, file_name = self.file_name, **kwargs)- self.stretch(self.y_stretch_factor, 1)+ SVGMobject.__init__(self, file_name=self.file_name, **kwargs)+ self.stretch(self.y_stretch_factor, 1)self.scale_to_fit_height(self.height)- self.set_stroke(width = 0)- self.set_fill(color = self.color)+ self.set_stroke(width=0)+ self.set_fill(color=self.color)if pi_creature is not None:eyes = pi_creature.eyes- self.scale_to_fit_height(3*eyes.get_height())+ self.scale_to_fit_height(3 * eyes.get_height())self.move_to(eyes, DOWN)- self.shift(DOWN*eyes.get_height()/4)+ self.shift(DOWN * eyes.get_height() / 4)+class Clock(VGroup):CONFIG = {- "propagate_style_to_family" : True,+ "propagate_style_to_family": True,}+def __init__(self, **kwargs):circle = Circle()ticks = []for x in range(12):- alpha = x/12.+ alpha = x / 12.point = complex_to_R3(- np.exp(2*np.pi*alpha*complex(0, 1))+ np.exp(2 * np.pi * alpha * complex(0, 1)))- length = 0.2 if x%3 == 0 else 0.1+ length = 0.2 if x % 3 == 0 else 0.1ticks.append(- Line(point, (1-length)*point)+ Line(point, (1 - length) * point))- self.hour_hand = Line(ORIGIN, 0.3*UP)- self.minute_hand = Line(ORIGIN, 0.6*UP)+ 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, circle,self.hour_hand, self.minute_hand,*ticks)+class ClockPassesTime(Animation):CONFIG = {- "run_time" : 5,- "hours_passed" : 12,- "rate_func" : None,+ "run_time": 5,+ "hours_passed": 12,+ "rate_func": None,}+def __init__(self, clock, **kwargs):digest_config(self, kwargs)assert(isinstance(clock, Clock))rot_kwargs = {- "axis" : OUT,- "about_point" : clock.get_center()+ "axis": OUT,+ "about_point": clock.get_center()}- hour_radians = -self.hours_passed*2*np.pi/12+ hour_radians = -self.hours_passed * 2 * np.pi / 12self.hour_rotation = Rotating(- clock.hour_hand,- radians = hour_radians,+ clock.hour_hand,+ radians=hour_radians,**rot_kwargs)self.minute_rotation = Rotating(- clock.minute_hand,- radians = 12*hour_radians,+ clock.minute_hand,+ radians=12 * hour_radians,**rot_kwargs)Animation.__init__(self, clock, **kwargs)@@ -387,21 +405,23 @@ class ClockPassesTime(Animation):for rotation in self.hour_rotation, self.minute_rotation:rotation.update_mobject(alpha)+class Bubble(SVGMobject):CONFIG = {- "direction" : LEFT,- "center_point" : ORIGIN,- "content_scale_factor" : 0.75,- "height" : 5,- "width" : 8,- "bubble_center_adjustment_factor" : 1./8,- "file_name" : None,- "propagate_style_to_family" : True,- "fill_color" : BLACK,- "fill_opacity" : 0.8,- "stroke_color" : WHITE,- "stroke_width" : 3,+ "direction": LEFT,+ "center_point": ORIGIN,+ "content_scale_factor": 0.75,+ "height": 5,+ "width": 8,+ "bubble_center_adjustment_factor": 1. / 8,+ "file_name": None,+ "propagate_style_to_family": True,+ "fill_color": BLACK,+ "fill_opacity": 0.8,+ "stroke_color": WHITE,+ "stroke_width": 3,}+def __init__(self, **kwargs):digest_config(self, kwargs, locals())if self.file_name is None:@@ -420,19 +440,19 @@ class Bubble(SVGMobject):self.content = Mobject()def get_tip(self):- #TODO, find a better way- return self.get_corner(DOWN+self.direction)-0.6*self.direction+ # TODO, find a better way+ return self.get_corner(DOWN + self.direction) - 0.6 * self.directiondef get_bubble_center(self):factor = self.bubble_center_adjustment_factor- return self.get_center() + factor*self.get_height()*UP+ return self.get_center() + factor * self.get_height() * UPdef move_tip_to(self, point):VGroup(self, self.content).shift(point - self.get_tip())return selfdef flip(self):- Mobject.flip(self)+ Mobject.flip(self)self.direction = -np.array(self.direction)return self@@ -442,13 +462,13 @@ class Bubble(SVGMobject):can_flip = not self.direction_was_specifiedif want_to_filp and can_flip:self.flip()- boundary_point = mobject.get_critical_point(UP-self.direction)- vector_from_center = 1.0*(boundary_point-mob_center)- self.move_tip_to(mob_center+vector_from_center)+ boundary_point = mobject.get_critical_point(UP - self.direction)+ vector_from_center = 1.0 * (boundary_point - mob_center)+ self.move_tip_to(mob_center + vector_from_center)return selfdef position_mobject_inside(self, mobject):- scaled_width = self.content_scale_factor*self.get_width()+ scaled_width = self.content_scale_factor * self.get_width()if mobject.get_width() > scaled_width:mobject.scale_to_fit_width(scaled_width)mobject.shift(@@ -469,7 +489,7 @@ class Bubble(SVGMobject):target_width = self.content.get_width()target_width += max(MED_LARGE_BUFF, 2)target_height = self.content.get_height()- target_height += 2.5*LARGE_BUFF+ target_height += 2.5 * LARGE_BUFFtip_point = self.get_tip()self.stretch_to_fit_width(target_width)self.stretch_to_fit_height(target_height)@@ -480,58 +500,63 @@ class Bubble(SVGMobject):self.add_content(VMobject())return self+class SpeechBubble(Bubble):CONFIG = {- "file_name" : "Bubbles_speech.svg",- "height" : 4+ "file_name": "Bubbles_speech.svg",+ "height": 4}+class DoubleSpeechBubble(Bubble):CONFIG = {- "file_name" : "Bubbles_double_speech.svg",- "height" : 4+ "file_name": "Bubbles_double_speech.svg",+ "height": 4}+class ThoughtBubble(Bubble):CONFIG = {- "file_name" : "Bubbles_thought.svg",+ "file_name": "Bubbles_thought.svg",}def __init__(self, **kwargs):Bubble.__init__(self, **kwargs)self.submobjects.sort(- lambda m1, m2 : int((m1.get_bottom()-m2.get_bottom())[1])+ lambda m1, m2: int((m1.get_bottom() - m2.get_bottom())[1]))def make_green_screen(self):- self.submobjects[-1].set_fill(GREEN_SCREEN, opacity = 1)+ self.submobjects[-1].set_fill(GREEN_SCREEN, opacity=1)return self+class Car(SVGMobject):CONFIG = {- "file_name" : "Car",- "height" : 1,- "color" : LIGHT_GREY,- "light_colors" : [BLACK, BLACK],+ "file_name": "Car",+ "height": 1,+ "color": LIGHT_GREY,+ "light_colors": [BLACK, BLACK],}+def __init__(self, **kwargs):SVGMobject.__init__(self, **kwargs)self.scale_to_fit_height(self.height)- self.set_stroke(color = WHITE, width = 0)- self.set_fill(self.color, opacity = 1)+ self.set_stroke(color=WHITE, width=0)+ self.set_fill(self.color, opacity=1)from for_3b1b_videos.pi_creature import Randolph- randy = Randolph(mode = "happy")- randy.scale_to_fit_height(0.6*self.get_height())+ randy = Randolph(mode="happy")+ randy.scale_to_fit_height(0.6 * self.get_height())randy.stretch(0.8, 0)randy.look(RIGHT)randy.move_to(self)- randy.shift(0.07*self.height*(RIGHT+UP))+ randy.shift(0.07 * self.height * (RIGHT + UP))self.randy = self.pi_creature = randyself.add_to_back(randy)orientation_line = Line(self.get_left(), self.get_right())- orientation_line.set_stroke(width = 0)+ orientation_line.set_stroke(width=0)self.add(orientation_line)self.orientation_line = orientation_line@@ -543,32 +568,32 @@ class Car(SVGMobject):def move_to(self, point_or_mobject):vect = rotate_vector(- UP+LEFT, self.orientation_line.get_angle()+ UP + LEFT, self.orientation_line.get_angle())- self.next_to(point_or_mobject, vect, buff = 0)+ self.next_to(point_or_mobject, vect, buff=0)return selfdef get_front_line(self):return DashedLine(- self.get_corner(UP+RIGHT),- self.get_corner(DOWN+RIGHT),- color = DISTANCE_COLOR,- dashed_segment_length = 0.05,+ self.get_corner(UP + RIGHT),+ self.get_corner(DOWN + RIGHT),+ color=DISTANCE_COLOR,+ dashed_segment_length=0.05,)def add_treds_to_tires(self):for tire in self.get_tires():- radius = tire.get_width()/2+ radius = tire.get_width() / 2center = tire.get_center()tred = Line(- 0.9*radius*RIGHT, 1.4*radius*RIGHT,- stroke_width = 2,- color = BLACK+ 0.9 * radius * RIGHT, 1.4 * radius * RIGHT,+ stroke_width=2,+ color=BLACK)- tred.rotate_in_place(np.pi/4)- for theta in np.arange(0, 2*np.pi, np.pi/4):+ tred.rotate_in_place(np.pi / 4)+ for theta in np.arange(0, 2 * np.pi, np.pi / 4):new_tred = tred.copy()- new_tred.rotate(theta, about_point = ORIGIN)+ new_tred.rotate(theta, about_point=ORIGIN)new_tred.shift(center)tire.add(new_tred)return self@@ -587,43 +612,45 @@ class Car(SVGMobject):### Cards ###+class DeckOfCards(VGroup):def __init__(self, **kwargs):possible_values = map(str, range(1, 11)) + ["J", "Q", "K"]possible_suits = ["hearts", "diamonds", "spades", "clubs"]VGroup.__init__(self, *[- PlayingCard(value = value, suit = suit, **kwargs)+ PlayingCard(value=value, suit=suit, **kwargs)for value in possible_valuesfor suit in possible_suits])+class PlayingCard(VGroup):CONFIG = {- "value" : None,- "suit" : None,- "key" : None, ##String like "8H" or "KS"- "height" : 2,- "height_to_width" : 3.5/2.5,- "card_height_to_symbol_height" : 7,- "card_width_to_corner_num_width" : 10,- "card_height_to_corner_num_height" : 10,- "color" : LIGHT_GREY,- "turned_over" : False,- "possible_suits" : ["hearts", "diamonds", "spades", "clubs"],- "possible_values" : map(str, range(2, 11)) + ["J", "Q", "K", "A"],+ "value": None,+ "suit": None,+ "key": None, # String like "8H" or "KS"+ "height": 2,+ "height_to_width": 3.5 / 2.5,+ "card_height_to_symbol_height": 7,+ "card_width_to_corner_num_width": 10,+ "card_height_to_corner_num_height": 10,+ "color": LIGHT_GREY,+ "turned_over": False,+ "possible_suits": ["hearts", "diamonds", "spades", "clubs"],+ "possible_values": map(str, range(2, 11)) + ["J", "Q", "K", "A"],}- def __init__(self, key = None, **kwargs):- VGroup.__init__(self, key = key, **kwargs)+ def __init__(self, key=None, **kwargs):+ VGroup.__init__(self, key=key, **kwargs)def generate_points(self):self.add(Rectangle(- height = self.height,- width = self.height/self.height_to_width,- stroke_color = WHITE,- stroke_width = 2,- fill_color = self.color,- fill_opacity = 1,+ height=self.height,+ width=self.height / self.height_to_width,+ stroke_color=WHITE,+ stroke_width=2,+ fill_color=self.color,+ fill_opacity=1,))if self.turned_over:self.set_fill(DARK_GREY)@@ -653,10 +680,10 @@ class PlayingCard(VGroup):raise Exception("Invalid card value")face_card_to_value = {- "J" : 11,- "Q" : 12,- "K" : 13,- "A" : 14,+ "J": 11,+ "Q": 12,+ "K": 13,+ "A": 14,}try:self.numerical_value = int(value)@@ -678,7 +705,7 @@ class PlayingCard(VGroup):raise Exception("Invalud suit value")self.suit = suitsymbol_height = float(self.height) / self.card_height_to_symbol_height- symbol = SuitSymbol(suit, height = symbol_height)+ symbol = SuitSymbol(suit, height=symbol_height)return symboldef get_design(self, value, symbol):@@ -697,27 +724,27 @@ class PlayingCard(VGroup):def get_number_design(self, value, symbol):num = int(value)n_rows = {- 2 : 2,- 3 : 3,- 4 : 2,- 5 : 2,- 6 : 3,- 7 : 3,- 8 : 3,- 9 : 4,- 10 : 4,+ 2: 2,+ 3: 3,+ 4: 2,+ 5: 2,+ 6: 3,+ 7: 3,+ 8: 3,+ 9: 4,+ 10: 4,}[num]n_cols = 1 if num in [2, 3] else 2insertion_indices = {- 5 : [0],- 7 : [0],- 8 : [0, 1],- 9 : [1],- 10 : [0, 2],+ 5: [0],+ 7: [0],+ 8: [0, 1],+ 9: [1],+ 10: [0, 2],}.get(num, [])- top = self.get_top() + symbol.get_height()*DOWN- bottom = self.get_bottom() + symbol.get_height()*UP+ top = self.get_top() + symbol.get_height() * DOWN+ bottom = self.get_bottom() + symbol.get_height() * UPcolumn_points = [interpolate(top, bottom, alpha)for alpha in np.linspace(0, 1, n_rows)@@ -728,13 +755,13 @@ class PlayingCard(VGroup):for point in column_points])if n_cols == 2:- space = 0.2*self.get_width()- column_copy = design.copy().shift(space*RIGHT)- design.shift(space*LEFT)+ space = 0.2 * self.get_width()+ column_copy = design.copy().shift(space * RIGHT)+ design.shift(space * LEFT)design.add(*column_copy)design.add(*[symbol.copy().move_to(- center_of_mass(column_points[i:i+2])+ center_of_mass(column_points[i:i + 2]))for i in insertion_indices])@@ -746,120 +773,93 @@ class PlayingCard(VGroup):def get_face_card_design(self, value, symbol):from for_3b1b_videos.pi_creature import PiCreaturesub_rect = Rectangle(- stroke_color = BLACK,- fill_opacity = 0,- height = 0.9*self.get_height(),- width = 0.6*self.get_width(),+ stroke_color=BLACK,+ fill_opacity=0,+ height=0.9 * self.get_height(),+ width=0.6 * self.get_width(),)sub_rect.move_to(self)# pi_color = average_color(symbol.get_color(), GREY)pi_color = symbol.get_color()pi_mode = {- "J" : "plain",- "Q" : "thinking",- "K" : "hooray"+ "J": "plain",+ "Q": "thinking",+ "K": "hooray"}[value]pi_creature = PiCreature(- mode = pi_mode,- color = pi_color,+ mode=pi_mode,+ color=pi_color,)- pi_creature.scale_to_fit_width(0.8*sub_rect.get_width())+ pi_creature.scale_to_fit_width(0.8 * sub_rect.get_width())if value in ["Q", "K"]:prefix = "king" if value == "K" else "queen"- crown = SVGMobject(file_name = prefix + "_crown")- crown.set_stroke(width = 0)+ crown = SVGMobject(file_name=prefix + "_crown")+ crown.set_stroke(width=0)crown.set_fill(YELLOW, 1)- crown.stretch_to_fit_width(0.5*sub_rect.get_width())- crown.stretch_to_fit_height(0.17*sub_rect.get_height())+ crown.stretch_to_fit_width(0.5 * sub_rect.get_width())+ crown.stretch_to_fit_height(0.17 * sub_rect.get_height())crown.move_to(pi_creature.eyes.get_center(), DOWN)pi_creature.add_to_back(crown)to_top_buff = 0else:- to_top_buff = SMALL_BUFF*sub_rect.get_height()+ to_top_buff = SMALL_BUFF * sub_rect.get_height()pi_creature.next_to(sub_rect.get_top(), DOWN, to_top_buff)# pi_creature.shift(0.05*sub_rect.get_width()*RIGHT)pi_copy = pi_creature.copy()- pi_copy.rotate(np.pi, about_point = sub_rect.get_center())+ pi_copy.rotate(np.pi, about_point=sub_rect.get_center())return VGroup(sub_rect, pi_creature, pi_copy)def get_corner_numbers(self, value, symbol):value_mob = TextMobject(value)- width = self.get_width()/self.card_width_to_corner_num_width- height = self.get_height()/self.card_height_to_corner_num_height+ width = self.get_width() / self.card_width_to_corner_num_width+ height = self.get_height() / self.card_height_to_corner_num_heightvalue_mob.scale_to_fit_width(width)value_mob.stretch_to_fit_height(height)value_mob.next_to(- self.get_corner(UP+LEFT), DOWN+RIGHT,- buff = MED_LARGE_BUFF*width+ self.get_corner(UP + LEFT), DOWN + RIGHT,+ buff=MED_LARGE_BUFF * width)value_mob.set_color(symbol.get_color())corner_symbol = symbol.copy()corner_symbol.scale_to_fit_width(width)corner_symbol.next_to(- value_mob, DOWN,- buff = MED_SMALL_BUFF*width+ value_mob, DOWN,+ buff=MED_SMALL_BUFF * width)corner_group = VGroup(value_mob, corner_symbol)opposite_corner_group = corner_group.copy()opposite_corner_group.rotate(- np.pi, about_point = self.get_center()+ np.pi, about_point=self.get_center())return VGroup(corner_group, opposite_corner_group)+class SuitSymbol(SVGMobject):CONFIG = {- "height" : 0.5,- "fill_opacity" : 1,- "stroke_width" : 0,- "red" : "#D02028",- "black" : BLACK,+ "height": 0.5,+ "fill_opacity": 1,+ "stroke_width": 0,+ "red": "#D02028",+ "black": BLACK,}+def __init__(self, suit_name, **kwargs):digest_config(self, kwargs)suits_to_colors = {- "hearts" : self.red,- "diamonds" : self.red,- "spades" : self.black,- "clubs" : self.black,+ "hearts": self.red,+ "diamonds": self.red,+ "spades": self.black,+ "clubs": self.black,}if suit_name not in suits_to_colors:raise Exception("Invalid suit name")- SVGMobject.__init__(self, file_name = suit_name, **kwargs)+ SVGMobject.__init__(self, file_name=suit_name, **kwargs)color = suits_to_colors[suit_name]- self.set_stroke(width = 0)+ self.set_stroke(width=0)self.set_fill(color, 1)self.scale_to_fit_height(self.height)-----------------------------diff --git a/mobject/svg/svg_mobject.py b/mobject/svg/svg_mobject.pyindex 23907ce69..ebfbde3d2 100644--- a/mobject/svg/svg_mobject.py+++ b/mobject/svg/svg_mobject.py@@ -14,28 +14,31 @@ from utils.config_ops import digest_localsfrom mobject.types.vectorized_mobject import VGroupfrom mobject.types.vectorized_mobject import VMobject+def string_to_numbers(num_string):- num_string = num_string.replace("-",",-")- num_string = num_string.replace("e,-","e-")+ num_string = num_string.replace("-", ",-")+ num_string = num_string.replace("e,-", "e-")return [float(s)for s in re.split("[ ,]", num_string)if s != ""]+class SVGMobject(VMobject):CONFIG = {- "should_center" : True,- "height" : 2,- "width" : None,- #Must be filled in in a subclass, or when called- "file_name" : None,- "unpack_groups" : True, # if False, creates a hierarchy of VGroups- "stroke_width" : 0,- "fill_opacity" : 1,+ "should_center": True,+ "height": 2,+ "width": None,+ # Must be filled in in a subclass, or when called+ "file_name": None,+ "unpack_groups": True, # if False, creates a hierarchy of VGroups+ "stroke_width": 0,+ "fill_opacity": 1,# "fill_color" : LIGHT_GREY,- "propagate_style_to_family" : True,+ "propagate_style_to_family": True,}+def __init__(self, **kwargs):digest_config(self, kwargs, locals())self.ensure_valid_file()@@ -54,15 +57,18 @@ class SVGMobject(VMobject):if os.path.exists(path):self.file_path = pathreturn- raise IOError("No file matching %s in image directory"%self.file_name)+ raise IOError("No file matching %s in image directory" %+ self.file_name)def generate_points(self):doc = minidom.parse(self.file_path)self.ref_to_element = {}for svg in doc.getElementsByTagName("svg"):mobjects = self.get_mobjects_from(svg)- if self.unpack_groups: self.add(*mobjects)- else: self.add(*mobjects[0].submobjects)+ if self.unpack_groups:+ self.add(*mobjects)+ else:+ self.add(*mobjects[0].submobjects)doc.unlink()def get_mobjects_from(self, element):@@ -72,7 +78,7 @@ class SVGMobject(VMobject):if element.tagName == 'defs':self.update_ref_to_element(element)elif element.tagName == 'style':- pass #TODO, handle style+ pass # TODO, handle styleelif element.tagName in ['g', 'svg']:result += it.chain(*[self.get_mobjects_from(child)@@ -93,9 +99,9 @@ class SVGMobject(VMobject):elif element.tagName in ['polygon', 'polyline']:result.append(self.polygon_to_mobject(element))else:- pass ##TODO+ pass # TODO# warnings.warn("Unknown element type: " + element.tagName)- result = filter(lambda m : m is not None, result)+ result = filter(lambda m: m is not None, result)self.handle_transforms(element, VMobject(*result))if len(result) > 1 and not self.unpack_groups:result = [VGroup(*result)]@@ -111,17 +117,17 @@ class SVGMobject(VMobject):return VMobjectFromSVGPathstring(path_string)def use_to_mobjects(self, use_element):- #Remove initial "#" character+ # Remove initial "#" characterref = use_element.getAttribute("xlink:href")[1:]if ref not in self.ref_to_element:- warnings.warn("%s not recognized"%ref)+ warnings.warn("%s not recognized" % ref)return VMobject()return self.get_mobjects_from(self.ref_to_element[ref])def polygon_to_mobject(self, polygon_element):- #TODO, This seems hacky...+ # TODO, This seems hacky...path_string = polygon_element.getAttribute("points")for digit in string.digits:path_string = path_string.replace(" " + digit, " L" + digit)@@ -137,7 +143,7 @@ class SVGMobject(VMobject):else 0.0for key in "cx", "cy", "r"]- return Circle(radius = r).shift(x*RIGHT+y*DOWN)+ return Circle(radius=r).shift(x * RIGHT + y * DOWN)def ellipse_to_mobject(self, circle_element):x, y, rx, ry = [@@ -146,74 +152,77 @@ class SVGMobject(VMobject):else 0.0for key in "cx", "cy", "rx", "ry"]- return Circle().scale(rx*RIGHT + ry*UP).shift(x*RIGHT+y*DOWN)+ return Circle().scale(rx * RIGHT + ry * UP).shift(x * RIGHT + y * DOWN)def rect_to_mobject(self, rect_element):if rect_element.hasAttribute("fill"):if Color(str(rect_element.getAttribute("fill"))) == Color(WHITE):returnmob = Rectangle(- width = float(rect_element.getAttribute("width")),- height = float(rect_element.getAttribute("height")),- stroke_width = 0,- fill_color = WHITE,- fill_opacity = 1.0+ width=float(rect_element.getAttribute("width")),+ height=float(rect_element.getAttribute("height")),+ stroke_width=0,+ fill_color=WHITE,+ fill_opacity=1.0)- mob.shift(mob.get_center()-mob.get_corner(UP+LEFT))+ mob.shift(mob.get_center() - mob.get_corner(UP + LEFT))return mobdef handle_transforms(self, element, mobject):x, y = 0, 0try:x = float(element.getAttribute('x'))- #Flip y+ # Flip yy = -float(element.getAttribute('y'))- mobject.shift(x*RIGHT+y*UP)+ mobject.shift(x * RIGHT + y * UP)except:passtransform = element.getAttribute('transform')- try: # transform matrix+ try: # transform matrixprefix = "matrix("suffix = ")"- if not transform.startswith(prefix) or not transform.endswith(suffix): raise Exception()+ if not transform.startswith(prefix) or not transform.endswith(suffix):+ raise Exception()transform = transform[len(prefix):-len(suffix)]transform = string_to_numbers(transform)- transform = np.array(transform).reshape([3,2])+ transform = np.array(transform).reshape([3, 2])x = transform[2][0]y = -transform[2][1]matrix = np.identity(self.dim)- matrix[:2,:2] = transform[:2,:]+ matrix[:2, :2] = transform[:2, :]matrix[1] *= -1- matrix[:,1] *= -1+ matrix[:, 1] *= -1for mob in mobject.family_members_with_points():mob.points = np.dot(mob.points, matrix)- mobject.shift(x*RIGHT+y*UP)+ mobject.shift(x * RIGHT + y * UP)except:pass- try: # transform scale+ try: # transform scaleprefix = "scale("suffix = ")"- if not transform.startswith(prefix) or not transform.endswith(suffix): raise Exception()+ if not transform.startswith(prefix) or not transform.endswith(suffix):+ raise Exception()transform = transform[len(prefix):-len(suffix)]scale_x, scale_y = string_to_numbers(transform)mobject.scale(np.array([scale_x, scale_y, 1]))except:pass- try: # transform translate+ try: # transform translateprefix = "translate("suffix = ")"- if not transform.startswith(prefix) or not transform.endswith(suffix): raise Exception()+ if not transform.startswith(prefix) or not transform.endswith(suffix):+ raise Exception()transform = transform[len(prefix):-len(suffix)]x, y = string_to_numbers(transform)- mobject.shift(x*RIGHT + y*DOWN)+ mobject.shift(x * RIGHT + y * DOWN)except:pass- #TODO, ...+ # TODO, ...def update_ref_to_element(self, defs):new_refs = dict([@@ -231,6 +240,7 @@ class SVGMobject(VMobject):if self.width is not None:self.scale_to_fit_width(self.width)+class VMobjectFromSVGPathstring(VMobject):def __init__(self, path_string, **kwargs):digest_locals(self)@@ -238,42 +248,42 @@ class VMobjectFromSVGPathstring(VMobject):def get_path_commands(self):result = [- "M", #moveto- "L", #lineto- "H", #horizontal lineto- "V", #vertical lineto- "C", #curveto- "S", #smooth curveto- "Q", #quadratic Bezier curve- "T", #smooth quadratic Bezier curveto- "A", #elliptical Arc- "Z", #closepath+ "M", # moveto+ "L", # lineto+ "H", # horizontal lineto+ "V", # vertical lineto+ "C", # curveto+ "S", # smooth curveto+ "Q", # quadratic Bezier curve+ "T", # smooth quadratic Bezier curveto+ "A", # elliptical Arc+ "Z", # closepath]- result += map(lambda s : s.lower(), result)+ result += map(lambda s: s.lower(), result)return resultdef generate_points(self):- pattern = "[%s]"%("".join(self.get_path_commands()))+ pattern = "[%s]" % ("".join(self.get_path_commands()))pairs = zip(re.findall(pattern, self.path_string),re.split(pattern, self.path_string)[1:])- #Which mobject should new points be added to+ # Which mobject should new points be added toself.growing_path = selffor command, coord_string in pairs:self.handle_command(command, coord_string)- #people treat y-coordinate differently- self.rotate(np.pi, RIGHT, about_point = ORIGIN)+ # people treat y-coordinate differently+ self.rotate(np.pi, RIGHT, about_point=ORIGIN)def handle_command(self, command, coord_string):isLower = command.islower()command = command.upper()- #new_points are the points that will be added to the curr_points- #list. This variable may get modified in the conditionals below.+ # new_points are the points that will be added to the curr_points+ # list. This variable may get modified in the conditionals below.points = self.growing_path.pointsnew_points = self.string_to_points(coord_string)- if command == "M": #moveto+ if command == "M": # movetoif isLower and len(points) > 0:new_points[0] += points[-1]if len(points) > 0:@@ -281,7 +291,8 @@ class VMobjectFromSVGPathstring(VMobject):else:self.growing_path.start_at(new_points[0])- if len(new_points) <= 1: return+ if len(new_points) <= 1:+ returnpoints = self.growing_path.pointsnew_points = new_points[1:]@@ -290,47 +301,47 @@ class VMobjectFromSVGPathstring(VMobject):if isLower and len(points) > 0:new_points += points[-1]- if command in ["L", "H", "V"]: #lineto+ if command in ["L", "H", "V"]: # linetoif command == "H":- new_points[0,1] = points[-1,1]+ new_points[0, 1] = points[-1, 1]elif command == "V":if isLower:- new_points[0,0] -= points[-1,0]- new_points[0,0] += points[-1,1]- new_points[0,1] = new_points[0,0]- new_points[0,0] = points[-1,0]- new_points = new_points.repeat(3, axis = 0)- elif command == "C": #curveto- pass #Yay! No action required- elif command in ["S", "T"]: #smooth curveto- handle1 = points[-1]+(points[-1]-points[-2])- new_points = np.append([handle1], new_points, axis = 0)- if command in ["Q", "T"]: #quadratic Bezier curve- #TODO, this is a suboptimal approximation- new_points = np.append([new_points[0]], new_points, axis = 0)- elif command == "A": #elliptical Arc+ new_points[0, 0] -= points[-1, 0]+ new_points[0, 0] += points[-1, 1]+ new_points[0, 1] = new_points[0, 0]+ new_points[0, 0] = points[-1, 0]+ new_points = new_points.repeat(3, axis=0)+ elif command == "C": # curveto+ pass # Yay! No action required+ elif command in ["S", "T"]: # smooth curveto+ handle1 = points[-1] + (points[-1] - points[-2])+ new_points = np.append([handle1], new_points, axis=0)+ if command in ["Q", "T"]: # quadratic Bezier curve+ # TODO, this is a suboptimal approximation+ new_points = np.append([new_points[0]], new_points, axis=0)+ elif command == "A": # elliptical Arcraise Exception("Not implemented")- elif command == "Z": #closepath+ elif command == "Z": # closepathif not is_closed(points):- #Both handles and new anchor are the start+ # Both handles and new anchor are the startnew_points = points[[0, 0, 0]]# self.mark_paths_closed = True- #Handle situations where there's multiple relative control points+ # Handle situations where there's multiple relative control pointsif isLower and len(new_points) > 3:for i in range(3, len(new_points), 3):- new_points[i:i+3] -= points[-1]- new_points[i:i+3] += new_points[i-1]+ new_points[i:i + 3] -= points[-1]+ new_points[i:i + 3] += new_points[i - 1]self.growing_path.add_control_points(new_points)def string_to_points(self, coord_string):numbers = string_to_numbers(coord_string)- if len(numbers)%2 == 1:+ if len(numbers) % 2 == 1:numbers.append(0)- num_points = len(numbers)/2+ num_points = len(numbers) / 2result = np.zeros((num_points, self.dim))- result[:,:2] = np.array(numbers).reshape((num_points, 2))+ result[:, :2] = np.array(numbers).reshape((num_points, 2))return resultdef get_original_path_string(self):diff --git a/mobject/svg/tex_mobject.py b/mobject/svg/tex_mobject.pyindex bdc48d433..b28e7c9bc 100644--- a/mobject/svg/tex_mobject.py+++ b/mobject/svg/tex_mobject.py@@ -8,49 +8,50 @@ from mobject.types.vectorized_mobject import VGroupfrom mobject.types.vectorized_mobject import VMobjectfrom mobject.types.vectorized_mobject import VectorizedPoint-import collectionsimport operator as op-import sysTEX_MOB_SCALE_FACTOR = 0.05+class TexSymbol(VMobjectFromSVGPathstring):def pointwise_become_partial(self, mobject, a, b):- #TODO, this assumes a = 0+ # TODO, this assumes a = 0if b < 0.5:- b = 2*b+ b = 2 * badded_width = 1opacity = 0else:- added_width = 2 - 2*b- opacity = 2*b - 1+ added_width = 2 - 2 * b+ opacity = 2 * b - 1b = 1VMobjectFromSVGPathstring.pointwise_become_partial(self, mobject, 0, b)- self.set_stroke(width = added_width + mobject.get_stroke_width())- self.set_fill(opacity = opacity)+ self.set_stroke(width=added_width + mobject.get_stroke_width())+ self.set_fill(opacity=opacity)+class TexMobject(SVGMobject):CONFIG = {- "template_tex_file" : TEMPLATE_TEX_FILE,- "stroke_width" : 0,- "fill_opacity" : 1.0,- "fill_color" : WHITE,- "should_center" : True,- "arg_separator" : " ",- "height" : None,- "organize_left_to_right" : False,- "propagate_style_to_family" : True,- "alignment" : "",+ "template_tex_file": TEMPLATE_TEX_FILE,+ "stroke_width": 0,+ "fill_opacity": 1.0,+ "fill_color": WHITE,+ "should_center": True,+ "arg_separator": " ",+ "height": None,+ "organize_left_to_right": False,+ "propagate_style_to_family": True,+ "alignment": "",}+def __init__(self, *args, **kwargs):digest_config(self, kwargs, locals())-- if "color" in kwargs.keys() and not "fill_color" in kwargs.keys():++ if "color" in kwargs.keys() and "fill_color" not in kwargs.keys():self.fill_color = kwargs["color"]- ##TODO, Eventually remove this+ # TODO, Eventually remove thisif len(args) == 1 and isinstance(args[0], list):self.args = args[0]##@@ -60,14 +61,14 @@ class TexMobject(SVGMobject):self.tex_string,self.template_tex_file)- SVGMobject.__init__(self, file_name = file_name, **kwargs)+ SVGMobject.__init__(self, file_name=file_name, **kwargs)self.scale(TEX_MOB_SCALE_FACTOR)if self.organize_left_to_right:self.organize_submobjects_left_to_right()def path_string_to_mobject(self, path_string):- #Overwrite superclass default to use- #specialized path_string mobject+ # Overwrite superclass default to use+ # specialized path_string mobjectreturn TexSymbol(path_string)def generate_points(self):@@ -86,7 +87,7 @@ class TexMobject(SVGMobject):def modify_special_strings(self, tex):tex = self.remove_stray_braces(tex)if tex in ["\\over", "\\overline"]:- #fraction line needs something to be over+ # fraction line needs something to be overtex += "\\,"if tex == "\\sqrt":tex += "{\\quad}"@@ -132,7 +133,7 @@ class TexMobject(SVGMobject):self.expression_parts = list(self.args)for expr in self.args:sub_tex_mob = TexMobject(expr, **self.CONFIG)- sub_tex_mob.tex_string = expr ##Want it unmodified+ sub_tex_mob.tex_string = expr # Want it unmodifiednum_submobs = len(sub_tex_mob.submobjects)new_index = curr_index + num_submobsif num_submobs == 0:@@ -150,7 +151,7 @@ class TexMobject(SVGMobject):self.submobjects = new_submobjectsreturn self- def get_parts_by_tex(self, tex, substring = True, case_sensitive = True):+ def get_parts_by_tex(self, tex, substring=True, case_sensitive=True):def test(tex1, tex2):if not case_sensitive:tex1 = tex1.lower()@@ -161,13 +162,13 @@ class TexMobject(SVGMobject):return tex1 == tex2tex_submobjects = filter(- lambda m : isinstance(m, TexMobject),+ lambda m: isinstance(m, TexMobject),self.submobject_family())if hasattr(self, "expression_parts"):tex_submobjects.remove(self)return VGroup(*filter(- lambda m : test(tex, m.get_tex_string()),+ lambda m: test(tex, m.get_tex_string()),tex_submobjects))@@ -204,7 +205,7 @@ class TexMobject(SVGMobject):return self.index_of_part(part)def organize_submobjects_left_to_right(self):- self.sort_submobjects(lambda p : p[0])+ self.sort_submobjects(lambda p: p[0])return selfdef sort_submobjects_alphabetically(self):@@ -215,30 +216,33 @@ class TexMobject(SVGMobject):self.submobjects.sort(alphabetical_cmp)return self- def add_background_rectangle(self, color = BLACK, opacity = 0.75, **kwargs):+ def add_background_rectangle(self, color=BLACK, opacity=0.75, **kwargs):self.background_rectangle = BackgroundRectangle(- self, color = color,- fill_opacity = opacity,+ self, color=color,+ fill_opacity=opacity,**kwargs)letters = VMobject(*self.submobjects)self.submobjects = [self.background_rectangle, letters]return self+class TextMobject(TexMobject):CONFIG = {- "template_tex_file" : TEMPLATE_TEXT_FILE,- "alignment" : "\\centering",+ "template_tex_file": TEMPLATE_TEXT_FILE,+ "alignment": "\\centering",}+class BulletedList(TextMobject):CONFIG = {- "buff" : MED_LARGE_BUFF,- "dot_scale_factor" : 2,- #Have to include because of handle_multiple_args implementation- "template_tex_file" : TEMPLATE_TEXT_FILE,- "alignment" : "",+ "buff": MED_LARGE_BUFF,+ "dot_scale_factor": 2,+ # Have to include because of handle_multiple_args implementation+ "template_tex_file": TEMPLATE_TEXT_FILE,+ "alignment": "",}+def __init__(self, *items, **kwargs):line_separated_items = [s + "\\\\" for s in items]TextMobject.__init__(self, *line_separated_items, **kwargs)@@ -247,12 +251,12 @@ class BulletedList(TextMobject):dot.next_to(part[0], LEFT, SMALL_BUFF)part.add_to_back(dot)self.arrange_submobjects(- DOWN,- aligned_edge = LEFT,- buff = self.buff+ DOWN,+ aligned_edge=LEFT,+ buff=self.buff)- def fade_all_but(self, index_or_string, opacity = 0.5):+ def fade_all_but(self, index_or_string, opacity=0.5):arg = index_or_stringif isinstance(arg, str):part = self.get_part_by_tex(arg)@@ -262,15 +266,17 @@ class BulletedList(TextMobject):raise Exception("Expected int or string, got {0}".format(arg))for other_part in self.submobjects:if other_part is part:- other_part.set_fill(opacity = 1)+ other_part.set_fill(opacity=1)else:- other_part.set_fill(opacity = opacity)+ other_part.set_fill(opacity=opacity)##########+def tex_hash(expression, template_tex_file):return str(hash(expression + template_tex_file))+def tex_to_svg_file(expression, template_tex_file):image_dir = os.path.join(TEX_IMAGE_DIR,@@ -282,13 +288,14 @@ def tex_to_svg_file(expression, template_tex_file):dvi_file = tex_to_dvi(tex_file)return dvi_to_svg(dvi_file)+def generate_tex_file(expression, template_tex_file):result = os.path.join(TEX_DIR,tex_hash(expression, template_tex_file)) + ".tex"if not os.path.exists(result):- print("Writing \"%s\" to %s"%(+ print("Writing \"%s\" to %s" % ("".join(expression), result))with open(template_tex_file, "r") as infile:@@ -298,11 +305,13 @@ def generate_tex_file(expression, template_tex_file):outfile.write(body)return result+def get_null():if os.name == "nt":return "NUL"return "/dev/null"+def tex_to_dvi(tex_file):result = tex_file.replace(".tex", ".dvi")if not os.path.exists(result):@@ -327,7 +336,8 @@ def tex_to_dvi(tex_file):"See log output above or the log file: %s" % log_file)return result-def dvi_to_svg(dvi_file, regen_if_exists = False):++def dvi_to_svg(dvi_file, regen_if_exists=False):"""Converts a dvi, which potentially has multiple slides, into adirectory full of enumerated pngs corresponding with these slides.diff --git a/mobject/three_dimensions.py b/mobject/three_dimensions.pyindex 29b13716f..0a183d303 100644--- a/mobject/three_dimensions.py+++ b/mobject/three_dimensions.py@@ -9,67 +9,51 @@ from utils.space_ops import z_to_vector##############+def should_shade_in_3d(mobject):return hasattr(mobject, "shade_in_3d") and mobject.shade_in_3d+def shade_in_3d(mobject):for submob in mobject.submobject_family():submob.shade_in_3d = True+def turn_off_3d_shading(mobject):for submob in mobject.submobject_family():submob.shade_in_3d = False+class ThreeDMobject(VMobject):def __init__(self, *args, **kwargs):VMobject.__init__(self, *args, **kwargs)shade_in_3d(self)+class Cube(ThreeDMobject):CONFIG = {- "fill_opacity" : 0.75,- "fill_color" : BLUE,- "stroke_width" : 0,- "propagate_style_to_family" : True,- "side_length" : 2,+ "fill_opacity": 0.75,+ "fill_color": BLUE,+ "stroke_width": 0,+ "propagate_style_to_family": True,+ "side_length": 2,}+def generate_points(self):for vect in IN, OUT, LEFT, RIGHT, UP, DOWN:- face = Square(side_length = self.side_length)- face.shift(self.side_length*OUT/2.0)- face.apply_function(lambda p : np.dot(p, z_to_vector(vect).T))+ face = Square(side_length=self.side_length)+ face.shift(self.side_length * OUT / 2.0)+ face.apply_function(lambda p: np.dot(p, z_to_vector(vect).T))self.add(face)+class Prism(Cube):CONFIG = {- "dimensions" : [3, 2, 1]+ "dimensions": [3, 2, 1]}+def generate_points(self):Cube.generate_points(self)for dim, value in enumerate(self.dimensions):- self.rescale_to_fit(value, dim, stretch = True)------------------------+ self.rescale_to_fit(value, dim, stretch=True)diff --git a/mobject/types/image_mobject.py b/mobject/types/image_mobject.pyindex 17ca11215..55c94e186 100644--- a/mobject/types/image_mobject.py+++ b/mobject/types/image_mobject.py@@ -1,33 +1,31 @@from __future__ import absolute_import-import itertools as itimport numpy as np-import osfrom PIL import Image-from random import randomfrom constants import *from mobject.mobject import Mobjectfrom utils.bezier import interpolatefrom utils.color import color_to_int_rgb-from utils.color import interpolate_colorfrom utils.config_ops import digest_configfrom utils.images import get_full_raster_image_path+class ImageMobject(Mobject):"""Automatically filters out black pixels"""CONFIG = {- "filter_color" : "black",- "invert" : False,+ "filter_color": "black",+ "invert": False,# "use_cache" : True,"height": 2.0,- "image_mode" : "RGBA",- "pixel_array_dtype" : "uint8",+ "image_mode": "RGBA",+ "pixel_array_dtype": "uint8",}+def __init__(self, filename_or_array, **kwargs):digest_config(self, kwargs)if isinstance(filename_or_array, str):@@ -38,7 +36,7 @@ class ImageMobject(Mobject):self.pixel_array = np.array(filename_or_array)self.change_to_rgba_array()if self.invert:- self.pixel_array[:,:,:3] = 255-self.pixel_array[:,:,:3]+ self.pixel_array[:, :, :3] = 255 - self.pixel_array[:, :, :3]Mobject.__init__(self, **kwargs)def change_to_rgba_array(self):@@ -46,43 +44,43 @@ class ImageMobject(Mobject):if len(pa.shape) == 2:pa = pa.reshape(list(pa.shape) + [1])if pa.shape[2] == 1:- pa = pa.repeat(3, axis = 2)+ pa = pa.repeat(3, axis=2)if pa.shape[2] == 3:- alphas = 255*np.ones(- list(pa.shape[:2])+[1],- dtype = self.pixel_array_dtype+ alphas = 255 * np.ones(+ list(pa.shape[:2]) + [1],+ dtype=self.pixel_array_dtype)- pa = np.append(pa, alphas, axis = 2)+ pa = np.append(pa, alphas, axis=2)self.pixel_array = pa- def set_color(self, color, alpha = None, family = True):+ def set_color(self, color, alpha=None, family=True):rgb = color_to_int_rgb(color)- self.pixel_array[:,:,:3] = rgb+ self.pixel_array[:, :, :3] = rgbif alpha is not None:- self.pixel_array[:,:,3] = int(255*alpha)+ self.pixel_array[:, :, 3] = int(255 * alpha)for submob in self.submobjects:submob.set_color(color, alpha, family)self.color = colorreturn selfdef init_points(self):- #Corresponding corners of image are fixed to these- #Three points+ # Corresponding corners of image are fixed to these+ # Three pointsself.points = np.array([- UP+LEFT,- UP+RIGHT,- DOWN+LEFT,+ UP + LEFT,+ UP + RIGHT,+ DOWN + LEFT,])self.center()self.scale_to_fit_height(self.height)h, w = self.pixel_array.shape[:2]- self.stretch_to_fit_width(self.height*w/h)+ self.stretch_to_fit_width(self.height * w / h)def set_opacity(self, alpha):- self.pixel_array[:,:,3] = int(255*alpha)+ self.pixel_array[:, :, 3] = int(255 * alpha)return self- def fade(self, darkness = 0.5):+ def fade(self, darkness=0.5):self.set_opacity(1 - darkness)return self@@ -94,5 +92,3 @@ class ImageMobject(Mobject):def copy(self):return self.deepcopy()--diff --git a/mobject/types/point_cloud_mobject.py b/mobject/types/point_cloud_mobject.pyindex d1cb528e6..b2b9863a0 100644--- a/mobject/types/point_cloud_mobject.py+++ b/mobject/types/point_cloud_mobject.py@@ -1,16 +1,16 @@from __future__ import absolute_import-from mobject.mobject import Mobjectfrom constants import *++from mobject.mobject import Mobjectfrom utils.bezier import interpolatefrom utils.color import color_gradient-from utils.color import color_to_rgbfrom utils.color import color_to_rgba-from utils.color import interpolate_colorfrom utils.color import rgba_to_colorfrom utils.config_ops import digest_configfrom utils.iterables import stretch_array_to_length+class PMobject(Mobject):def init_points(self):self.rgbas = np.zeros((0, 4))@@ -20,38 +20,38 @@ class PMobject(Mobject):def get_array_attrs(self):return Mobject.get_array_attrs(self) + ["rgbas"]- def add_points(self, points, rgbas = None, color = None, alpha = 1):+ def add_points(self, points, rgbas=None, color=None, alpha=1):"""points must be a Nx3 numpy array, as must rgbas if it is not None"""if not isinstance(points, np.ndarray):points = np.array(points)num_new_points = len(points)- self.points = np.append(self.points, points, axis = 0)+ self.points = np.append(self.points, points, axis=0)if rgbas is None:color = Color(color) if color else self.colorrgbas = np.repeat([color_to_rgba(color, alpha)],num_new_points,- axis = 0+ axis=0)elif len(rgbas) != len(points):raise Exception("points and rgbas must have same shape")- self.rgbas = np.append(self.rgbas, rgbas, axis = 0)+ self.rgbas = np.append(self.rgbas, rgbas, axis=0)return self- def set_color(self, color = YELLOW_C, family = True):+ def set_color(self, color=YELLOW_C, family=True):rgba = color_to_rgba(color)mobs = self.family_members_with_points() if family else [self]for mob in mobs:- mob.rgbas[:,:] = rgba+ mob.rgbas[:, :] = rgbaself.color = colorreturn self# def set_color_by_gradient(self, start_color, end_color):def set_color_by_gradient(self, *colors):self.rgbas = np.array(map(- color_to_rgba,+ color_to_rgba,color_gradient(colors, len(self.points))))return self@@ -61,21 +61,21 @@ class PMobject(Mobject):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)+ for alpha in np.arange(num_points) / float(num_points)])return self- def set_colors_by_radial_gradient(self, center = None, radius = 1, inner_color = WHITE, outer_color = BLACK):+ 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 == None:+ 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)+ t = min(1, np.abs(mob.get_center() - center) / radius)mob.rgbas = np.array(- [ interpolate(start_rgba, end_rgba, t) ] * num_points- )+ [interpolate(start_rgba, end_rgba, t)] * num_points+ )return selfdef match_colors(self, mobject):@@ -90,20 +90,20 @@ class PMobject(Mobject):mob.rgbas = mob.rgbas[to_eliminate]return self- def thin_out(self, factor = 5):+ def thin_out(self, factor=5):"""Removes all but every nth point for n = factor"""for mob in self.family_members_with_points():num_points = self.get_num_points()mob.apply_over_attr_arrays(- lambda arr : arr[+ lambda arr: arr[np.arange(0, num_points, factor)])return self- def sort_points(self, function = lambda p : p[0]):+ def sort_points(self, function=lambda p: p[0]):"""function is any map from R^3 to R"""@@ -111,7 +111,7 @@ class PMobject(Mobject):indices = np.argsort(np.apply_along_axis(function, 1, mob.points))- mob.apply_over_attr_arrays(lambda arr : arr[indices])+ mob.apply_over_attr_arrays(lambda arr: arr[indices])return selfdef fade_to(self, color, alpha):@@ -135,19 +135,19 @@ class PMobject(Mobject):return rgba_to_color(self.rgbas[0, :])def point_from_proportion(self, alpha):- index = alpha*(self.get_num_points()-1)+ index = alpha * (self.get_num_points() - 1)return self.points[index]# Alignmentdef align_points_with_larger(self, larger_mobject):assert(isinstance(larger_mobject, PMobject))self.apply_over_attr_arrays(- lambda a : stretch_array_to_length(+ lambda a: stretch_array_to_length(a, larger_mobject.get_num_points()))- def get_point_mobject(self, center = None):+ def get_point_mobject(self, center=None):if center is None:center = self.get_center()return Point(center)@@ -165,65 +165,70 @@ class PMobject(Mobject):for attr in self.get_array_attrs():full_array = getattr(mobject, attr)partial_array = full_array[lower_index:upper_index]- setattr(self, attr, partial_array)+ setattr(self, attr, partial_array)-#TODO, Make the two implementations bellow non-redundant+# TODO, Make the two implementations bellow non-redundantclass Mobject1D(PMobject):CONFIG = {- "density" : DEFAULT_POINT_DENSITY_1D,+ "density": DEFAULT_POINT_DENSITY_1D,}+def __init__(self, **kwargs):digest_config(self, kwargs)- self.epsilon = 1.0 / self.density+ self.epsilon = 1.0 / self.densityMobject.__init__(self, **kwargs)- def add_line(self, start, end, color = None):+ 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+ epsilon = self.epsilon / lengthpoints = [interpolate(start, end, t)for t in np.arange(0, 1, epsilon)]- self.add_points(points, color = color)+ self.add_points(points, color=color)+class Mobject2D(PMobject):CONFIG = {- "density" : DEFAULT_POINT_DENSITY_2D,+ "density": DEFAULT_POINT_DENSITY_2D,}+def __init__(self, **kwargs):digest_config(self, kwargs)- self.epsilon = 1.0 / self.density+ self.epsilon = 1.0 / self.densityMobject.__init__(self, **kwargs)class PointCloudDot(Mobject1D):CONFIG = {- "radius" : 0.075,- "stroke_width" : 2,- "density" : DEFAULT_POINT_DENSITY_1D,- "color" : YELLOW,+ "radius": 0.075,+ "stroke_width": 2,+ "density": DEFAULT_POINT_DENSITY_1D,+ "color": YELLOW,}- def __init__(self, center = ORIGIN, **kwargs):++ def __init__(self, center=ORIGIN, **kwargs):Mobject1D.__init__(self, **kwargs)self.shift(center)def generate_points(self):self.add_points([- r*(np.cos(theta)*RIGHT + np.sin(theta)*UP)+ r * (np.cos(theta) * RIGHT + np.sin(theta) * UP)for r in np.arange(0, self.radius, self.epsilon)- for theta in np.arange(0, 2*np.pi, self.epsilon/r)+ for theta in np.arange(0, 2 * np.pi, self.epsilon / r)])+class Point(PMobject):CONFIG = {- "color" : BLACK,+ "color": BLACK,}- def __init__(self, location = ORIGIN, **kwargs):++ def __init__(self, location=ORIGIN, **kwargs):PMobject.__init__(self, **kwargs)self.add_points([location])-diff --git a/mobject/types/vectorized_mobject.py b/mobject/types/vectorized_mobject.pyindex 280f732a4..92ddf402a 100644--- a/mobject/types/vectorized_mobject.py+++ b/mobject/types/vectorized_mobject.py@@ -1,7 +1,5 @@from __future__ import absolute_import-import re-from colour import Colorfrom mobject.mobject import Mobject@@ -12,38 +10,36 @@ from utils.bezier import interpolatefrom utils.bezier import is_closedfrom utils.bezier import partial_bezier_pointsfrom utils.color import color_to_rgb-from utils.color import interpolate_colorfrom utils.iterables import make_even-class VMobject(Mobject):CONFIG = {- "fill_color" : None,- "fill_opacity" : 0.0,- "stroke_color" : None,- #Indicates that it will not be displayed, but- #that it should count in parent mobject's path- "is_subpath" : False,- "close_new_points" : False,- "mark_paths_closed" : False,- "propagate_style_to_family" : False,- "pre_function_handle_to_anchor_scale_factor" : 0.01,- "make_smooth_after_applying_functions" : False,- "background_image_file" : None,+ "fill_color": None,+ "fill_opacity": 0.0,+ "stroke_color": None,+ # Indicates that it will not be displayed, but+ # that it should count in parent mobject's path+ "is_subpath": False,+ "close_new_points": False,+ "mark_paths_closed": False,+ "propagate_style_to_family": False,+ "pre_function_handle_to_anchor_scale_factor": 0.01,+ "make_smooth_after_applying_functions": False,+ "background_image_file": None,}def get_group_class(self):return VGroup- ## Colors+ # Colorsdef init_colors(self):self.set_style_data(- stroke_color = self.stroke_color or self.color,- stroke_width = self.stroke_width,- fill_color = self.fill_color or self.color,- fill_opacity = self.fill_opacity,- family = self.propagate_style_to_family+ stroke_color=self.stroke_color or self.color,+ stroke_width=self.stroke_width,+ fill_color=self.fill_color or self.color,+ fill_opacity=self.fill_opacity,+ family=self.propagate_style_to_family)return self@@ -51,12 +47,12 @@ class VMobject(Mobject):for mob in self.submobject_family():setattr(mob, attr, value)- def set_style_data(self,- stroke_color = None,- stroke_width = None,- fill_color = None,- fill_opacity = None,- family = True+ def set_style_data(self,+ stroke_color=None,+ stroke_width=None,+ fill_color=None,+ fill_opacity=None,+ family=True):if stroke_color is not None:self.stroke_rgb = color_to_rgb(stroke_color)@@ -69,48 +65,48 @@ class VMobject(Mobject):if family:for mob in self.submobjects:mob.set_style_data(- stroke_color = stroke_color,- stroke_width = stroke_width,- fill_color = fill_color,- fill_opacity = fill_opacity,- family = family+ stroke_color=stroke_color,+ stroke_width=stroke_width,+ fill_color=fill_color,+ fill_opacity=fill_opacity,+ family=family)return self- def set_fill(self, color = None, opacity = None, family = True):+ def set_fill(self, color=None, opacity=None, family=True):return self.set_style_data(- fill_color = color,- fill_opacity = opacity,- family = family+ fill_color=color,+ fill_opacity=opacity,+ family=family)- def set_stroke(self, color = None, width = None, family = True):+ def set_stroke(self, color=None, width=None, family=True):return self.set_style_data(- stroke_color = color,- stroke_width = width,- family = family+ stroke_color=color,+ stroke_width=width,+ family=family)- def set_color(self, color, family = True):+ def set_color(self, color, family=True):self.set_style_data(- stroke_color = color,- fill_color = color,- family = family+ stroke_color=color,+ fill_color=color,+ family=family)self.color = colorreturn selfdef match_style(self, vmobject):self.set_style_data(- stroke_color = vmobject.get_stroke_color(),- stroke_width = vmobject.get_stroke_width(),- fill_color = vmobject.get_fill_color(),- fill_opacity = vmobject.get_fill_opacity(),- family = False+ stroke_color=vmobject.get_stroke_color(),+ stroke_width=vmobject.get_stroke_width(),+ fill_color=vmobject.get_fill_color(),+ fill_opacity=vmobject.get_fill_opacity(),+ family=False)- #Does its best to match up submobject lists, and- #match styles accordingly+ # Does its best to match up submobject lists, and+ # match styles accordinglysubmobs1, submobs2 = self.submobjects, vmobject.submobjectsif len(submobs1) == 0:return self@@ -122,12 +118,12 @@ class VMobject(Mobject):def fade_no_recurse(self, darkness):self.set_stroke(- width = (1-darkness)*self.get_stroke_width(),- family = False+ width=(1 - darkness) * self.get_stroke_width(),+ family=False)self.set_fill(- opacity = (1-darkness)*self.get_fill_opacity(),- family = False+ opacity=(1 - darkness) * self.get_fill_opacity(),+ family=False)return self@@ -137,7 +133,7 @@ class VMobject(Mobject):def get_fill_color(self):try:self.fill_rgb = np.clip(self.fill_rgb, 0.0, 1.0)- return Color(rgb = self.fill_rgb)+ return Color(rgb=self.fill_rgb)except:return Color(WHITE)@@ -150,7 +146,7 @@ class VMobject(Mobject):def get_stroke_color(self):try:self.stroke_rgb = np.clip(self.stroke_rgb, 0, 1)- return Color(rgb = self.stroke_rgb)+ return Color(rgb=self.stroke_rgb)except:return Color(WHITE)@@ -176,7 +172,7 @@ class VMobject(Mobject):self.color_using_background_image(vmobject.get_background_image_file())return self- ## Drawing+ # Drawingdef start_at(self, point):if len(self.points) == 0:self.points = np.zeros((1, 3))@@ -188,7 +184,7 @@ class VMobject(Mobject):self.points = np.append(self.points,control_points,- axis = 0+ axis=0)return self@@ -196,14 +192,14 @@ class VMobject(Mobject):return is_closed(self.points)def set_anchors_and_handles(self, anchors, handles1, handles2):- assert(len(anchors) == len(handles1)+1)- assert(len(anchors) == len(handles2)+1)- total_len = 3*(len(anchors)-1) + 1+ assert(len(anchors) == len(handles1) + 1)+ assert(len(anchors) == len(handles2) + 1)+ total_len = 3 * (len(anchors) - 1) + 1self.points = np.zeros((total_len, self.dim))self.points[0] = anchors[0]arrays = [handles1, handles2, anchors[1:]]for index, array in enumerate(arrays):- self.points[index+1::3] = array+ self.points[index + 1::3] = arrayreturn self.pointsdef set_points_as_corners(self, points):@@ -212,7 +208,7 @@ class VMobject(Mobject):points = np.array(points)self.set_anchors_and_handles(points, *[interpolate(points[:-1], points[1:], alpha)- for alpha in 1./3, 2./3+ for alpha in 1. / 3, 2. / 3])return self@@ -227,11 +223,11 @@ class VMobject(Mobject):self.points = np.array(points)return self- def set_anchor_points(self, points, mode = "smooth"):+ def set_anchor_points(self, points, mode="smooth"):if not isinstance(points, np.ndarray):points = np.array(points)if self.close_new_points and not is_closed(points):- points = np.append(points, [points[0]], axis = 0)+ points = np.append(points, [points[0]], axis=0)if mode == "smooth":self.set_points_smoothly(points)elif mode == "corners":@@ -243,7 +239,7 @@ class VMobject(Mobject):def change_anchor_mode(self, mode):for submob in self.family_members_with_points():anchors, h1, h2 = submob.get_anchors_and_handles()- submob.set_anchor_points(anchors, mode = mode)+ submob.set_anchor_points(anchors, mode=mode)return selfdef make_smooth(self):@@ -262,7 +258,7 @@ class VMobject(Mobject):but will be tracked in a separate special list for whenit comes time to display."""- subpath_mobject = self.copy() ##Really helps to be of the same class+ subpath_mobject = self.copy() # Really helps to be of the same classsubpath_mobject.submobjects = []subpath_mobject.is_subpath = Truesubpath_mobject.set_points(points)@@ -277,12 +273,12 @@ class VMobject(Mobject):self.start_at(new_points[0])self.add_control_points(new_points[1:])else:- self.add_control_points(2*[new_points[0]] + new_points)+ self.add_control_points(2 * [new_points[0]] + new_points)return selfdef get_subpath_mobjects(self):return filter(- lambda m : hasattr(m, 'is_subpath') and m.is_subpath,+ lambda m: hasattr(m, 'is_subpath') and m.is_subpath,self.submobjects)@@ -290,7 +286,7 @@ class VMobject(Mobject):factor = self.pre_function_handle_to_anchor_scale_factorself.scale_handle_to_anchor_distances(factor)Mobject.apply_function(self, function)- self.scale_handle_to_anchor_distances(1./factor)+ self.scale_handle_to_anchor_distances(1. / factor)if self.make_smooth_after_applying_functions:self.make_smooth()return self@@ -300,8 +296,8 @@ class VMobject(Mobject):If the distance between a given handle point H and its associatedanchor point A is d, then it changes H to be a distances factor*daway from A, but so that the line from A to H doesn't change.- This is mostly useful in the context of applying a (differentiable)- function, to preserve tangency properties. One would pull all the+ This is mostly useful in the context of applying a (differentiable)+ function, to preserve tangency properties. One would pull all thehandles closer to their anchors, apply the function then push them outagain."""@@ -311,27 +307,27 @@ class VMobject(Mobject):# print len(anchors), len(handles1), len(handles2)a_to_h1 = handles1 - anchors[:-1]a_to_h2 = handles2 - anchors[1:]- handles1 = anchors[:-1] + factor*a_to_h1- handles2 = anchors[1:] + factor*a_to_h2+ handles1 = anchors[:-1] + factor * a_to_h1+ handles2 = anchors[1:] + factor * a_to_h2self.set_anchors_and_handles(anchors, handles1, handles2)- ## Information about line+ # Information about linedef component_curves(self):- for n in range(self.get_num_anchor_points()-1):+ for n in range(self.get_num_anchor_points() - 1):yield self.get_nth_curve(n)def get_nth_curve(self, n):- return bezier(self.points[3*n:3*n+4])+ return bezier(self.points[3 * n:3 * n + 4])def get_num_anchor_points(self):- return (len(self.points) - 1)/3 + 1+ return (len(self.points) - 1) / 3 + 1def point_from_proportion(self, alpha):- num_cubics = self.get_num_anchor_points()-1- interpoint_alpha = num_cubics*(alpha % (1./num_cubics))- index = min(3*int(alpha*num_cubics), 3*num_cubics)- cubic = bezier(self.points[index:index+4])+ num_cubics = self.get_num_anchor_points() - 1+ interpoint_alpha = num_cubics * (alpha % (1. / num_cubics))+ index = min(3 * int(alpha * num_cubics), 3 * num_cubics)+ cubic = bezier(self.points[index:index + 4])return cubic(interpoint_alpha)def get_anchors_and_handles(self):@@ -346,8 +342,7 @@ class VMobject(Mobject):def get_points_defining_boundary(self):return self.get_anchors()-- ## Alignment+ # Alignmentdef align_points(self, mobject):Mobject.align_points(self, mobject)is_subpath = self.is_subpath or mobject.is_subpath@@ -355,61 +350,62 @@ class VMobject(Mobject):mark_closed = self.mark_paths_closed and mobject.mark_paths_closedself.mark_paths_closed = mobject.mark_paths_closed = mark_closedreturn self-+def align_points_with_larger(self, larger_mobject):assert(isinstance(larger_mobject, VMobject))self.insert_n_anchor_points(- larger_mobject.get_num_anchor_points()-\+ larger_mobject.get_num_anchor_points() -self.get_num_anchor_points())return self-+def insert_n_anchor_points(self, n):curr = self.get_num_anchor_points()if curr == 0:self.points = np.zeros((1, 3))- n = n-1+ n = n - 1if curr == 1:- self.points = np.repeat(self.points, 3*n+1, axis = 0)+ self.points = np.repeat(self.points, 3 * n + 1, axis=0)return selfpoints = np.array([self.points[0]])- num_curves = curr-1- #Curves in self are buckets, and we need to know- #how many new anchor points to put into each one.- #Each element of index_allocation is like a bucket,- #and its value tells you the appropriate index of- #the smaller curve.- index_allocation = (np.arange(curr+n-1) * num_curves)/(curr+n-1)+ num_curves = curr - 1+ # Curves in self are buckets, and we need to know+ # how many new anchor points to put into each one.+ # Each element of index_allocation is like a bucket,+ # and its value tells you the appropriate index of+ # the smaller curve.+ index_allocation = (np.arange(curr + n - 1) *+ num_curves) / (curr + n - 1)for index in range(num_curves):- curr_bezier_points = self.points[3*index:3*index+4]+ curr_bezier_points = self.points[3 * index:3 * index + 4]num_inter_curves = sum(index_allocation == index)- alphas = np.linspace(0, 1, num_inter_curves+1)+ alphas = np.linspace(0, 1, num_inter_curves + 1)# alphas = np.arange(0, num_inter_curves+1)/float(num_inter_curves)for a, b in zip(alphas, alphas[1:]):new_points = partial_bezier_points(curr_bezier_points, a, b)points = np.append(- points, new_points[1:], axis = 0+ points, new_points[1:], axis=0)self.set_points(points)return self-- def get_point_mobject(self, center = None):++ def get_point_mobject(self, center=None):if center is None:center = self.get_center()return VectorizedPoint(center)-+def repeat_submobject(self, submobject):if submobject.is_subpath:return VectorizedPoint(submobject.points[0])return submobject.copy()-+def interpolate_color(self, mobject1, mobject2, alpha):attrs = [- "stroke_rgb",- "stroke_width",- "fill_rgb",+ "stroke_rgb",+ "stroke_width",+ "fill_rgb","fill_opacity",]for attr in attrs:@@ -421,31 +417,31 @@ class VMobject(Mobject):if alpha == 1.0:# print getattr(mobject2, attr)setattr(self, attr, getattr(mobject2, attr))-+def pointwise_become_partial(self, mobject, a, b):assert(isinstance(mobject, VMobject))- #Partial curve includes three portions:- #- A middle section, which matches the curve exactly- #- A start, which is some ending portion of an inner cubic- #- An end, which is the starting portion of a later inner cubic+ # Partial curve includes three portions:+ # - A middle section, which matches the curve exactly+ # - A start, which is some ending portion of an inner cubic+ # - An end, which is the starting portion of a later inner cubicif a <= 0 and b >= 1:self.set_points(mobject.points)self.mark_paths_closed = mobject.mark_paths_closedreturn selfself.mark_paths_closed = False- num_cubics = mobject.get_num_anchor_points()-1- lower_index = int(a*num_cubics)- upper_index = int(b*num_cubics)+ num_cubics = mobject.get_num_anchor_points() - 1+ lower_index = int(a * num_cubics)+ upper_index = int(b * num_cubics)points = np.array(- mobject.points[3*lower_index:3*upper_index+4]+ mobject.points[3 * lower_index:3 * upper_index + 4])if len(points) > 1:- a_residue = (num_cubics*a)%1- b_residue = (num_cubics*b)%1+ a_residue = (num_cubics * a) % 1+ b_residue = (num_cubics * b) % 1if b == 1:b_residue = 1elif lower_index == upper_index:- b_residue = (b_residue - a_residue)/(1-a_residue)+ b_residue = (b_residue - a_residue) / (1 - a_residue)points[:4] = partial_bezier_points(points[:4], a_residue, 1@@ -456,6 +452,7 @@ class VMobject(Mobject):self.set_points(points)return self+class VGroup(VMobject):def __init__(self, *args, **kwargs):if len(args) == 1 and isinstance(args[0], (tuple, list)):@@ -465,19 +462,22 @@ class VGroup(VMobject):for arg in args:if isinstance(arg, (tuple, list)):packed_args.append(VGroup(arg))- else: packed_args.append(arg)+ else:+ packed_args.append(arg)VMobject.__init__(self, *packed_args, **kwargs)+class VectorizedPoint(VMobject):CONFIG = {- "color" : BLACK,- "fill_opacity" : 0,- "stroke_width" : 0,- "artificial_width" : 0.01,- "artificial_height" : 0.01,+ "color": BLACK,+ "fill_opacity": 0,+ "stroke_width": 0,+ "artificial_width": 0.01,+ "artificial_height": 0.01,}- def __init__(self, location = ORIGIN, **kwargs):++ def __init__(self, location=ORIGIN, **kwargs):VMobject.__init__(self, **kwargs)self.set_points(np.array([location]))@@ -490,24 +490,25 @@ class VectorizedPoint(VMobject):def get_location(self):return self.get_anchors()[0]- def set_location(self,new_loc):+ def set_location(self, new_loc):self.set_points(np.array([new_loc]))+class DashedMobject(VMobject):CONFIG = {- "dashes_num" : 15,- "spacing" : 0.5,- "color" : WHITE+ "dashes_num": 15,+ "spacing": 0.5,+ "color": WHITE}+def __init__(self, mobject, **kwargs):VMobject.__init__(self, **kwargs)buff = float(self.spacing) / self.dashes_numfor i in range(self.dashes_num):- a = ((1+buff) * i)/self.dashes_num- b = 1-((1+buff) * (self.dashes_num-1-i)) / self.dashes_num- dash = VMobject(color = self.color)+ a = ((1 + buff) * i) / self.dashes_num+ b = 1 - ((1 + buff) * (self.dashes_num - 1 - i)) / self.dashes_num+ dash = VMobject(color=self.color)dash.pointwise_become_partial(mobject, a, b)self.submobjects.append(dash)-diff --git a/mobject/value_tracker.py b/mobject/value_tracker.pyindex 48f8ba596..0af4d9488 100644--- a/mobject/value_tracker.py+++ b/mobject/value_tracker.py@@ -8,14 +8,16 @@ from mobject.types.vectorized_mobject import VectorizedPoint# TODO: Rather than using VectorizedPoint, there should be some UndisplayedPointSet type+class ValueTracker(VectorizedPoint):"""- Note meant to be displayed. Instead the position encodes some+ Note meant to be displayed. Instead the position encodes somenumber, often one which another animation or continual_animationuses for its update function, and by treating it as a mobject it canstill be animated and manipulated just like anything else."""- def __init__(self, value = 0, **kwargs):++ def __init__(self, value=0, **kwargs):VectorizedPoint.__init__(self, **kwargs)self.set_value(value)@@ -23,21 +25,23 @@ class ValueTracker(VectorizedPoint):return self.get_center()[0]def set_value(self, value):- self.move_to(value*RIGHT)+ self.move_to(value * RIGHT)return selfdef increment_value(self, d_value):self.set_value(self.get_value() + d_value)+class ExponentialValueTracker(ValueTracker):"""Operates just like ValueTracker, except it encodes the value as the- exponential of a position coordinate, which changes how interpolation+ exponential of a position coordinate, which changes how interpolationbehaves"""+def get_value(self):return np.exp(self.get_center()[0])def set_value(self, value):- self.move_to(np.log(value)*RIGHT)+ self.move_to(np.log(value) * RIGHT)return selfdiff --git a/once_useful_constructs/arithmetic.py b/once_useful_constructs/arithmetic.pyindex 173ecc73f..d61b655a9 100644--- a/once_useful_constructs/arithmetic.py+++ b/once_useful_constructs/arithmetic.py@@ -1,4 +1,3 @@-import itertools as itimport numpy as npfrom animation.animation import Animation@@ -6,18 +5,19 @@ from constants import *from mobject.svg.tex_mobject import TexMobjectfrom scene.scene import Scene+class RearrangeEquation(Scene):def construct(- self,- start_terms,- end_terms,+ self,+ start_terms,+ end_terms,index_map,- path_arc = np.pi,- start_transform = None,- end_transform = None,- leave_start_terms = False,- transform_kwargs = {},- ):+ path_arc=np.pi,+ start_transform=None,+ end_transform=None,+ leave_start_terms=False,+ transform_kwargs={},+ ):transform_kwargs["path_func"] = pathstart_mobs, end_mobs = self.get_mobs_from_terms(start_terms, end_terms@@ -27,17 +27,17 @@ class RearrangeEquation(Scene):if end_transform:end_mobs = end_transform(Mobject(*end_mobs)).split()unmatched_start_indices = set(range(len(start_mobs)))- unmatched_end_indices = set(range(len(end_mobs)))+ unmatched_end_indices = set(range(len(end_mobs)))unmatched_start_indices.difference_update(- [n%len(start_mobs) for n in index_map]+ [n % len(start_mobs) for n in index_map])unmatched_end_indices.difference_update(- [n%len(end_mobs) for n in index_map.values()]+ [n % len(end_mobs) for n in index_map.values()])mobject_pairs = [(start_mobs[a], end_mobs[b])for a, b in index_map.iteritems()- ]+ [+ ] + [(Point(end_mobs[b].get_center()), end_mobs[b])for b in unmatched_end_indices]@@ -45,7 +45,7 @@ class RearrangeEquation(Scene):mobject_pairs += [(start_mobs[a], Point(start_mobs[a].get_center()))for a in unmatched_start_indices- ]+ ]self.add(*start_mobs)if leave_start_terms:@@ -57,7 +57,6 @@ class RearrangeEquation(Scene):])self.wait()-def get_mobs_from_terms(self, start_terms, end_terms):"""Need to ensure that all image mobjects for a tex expression@@ -67,10 +66,10 @@ class RearrangeEquation(Scene):"""num_start_terms = len(start_terms)all_mobs = np.array(- TexMobject(start_terms).split() + \+ TexMobject(start_terms).split() +TexMobject(end_terms).split())- all_terms = np.array(start_terms+end_terms)+ all_terms = np.array(start_terms + end_terms)for term in set(all_terms):matches = all_terms == termif sum(matches) > 1:@@ -84,23 +83,21 @@ class RearrangeEquation(Scene):class FlipThroughSymbols(Animation):CONFIG = {- "start_center" : ORIGIN,- "end_center" : ORIGIN,+ "start_center": ORIGIN,+ "end_center": ORIGIN,}+def __init__(self, tex_list, **kwargs):mobject = TexMobject(self.curr_tex).shift(start_center)Animation.__init__(self, mobject, **kwargs)def update_mobject(self, alpha):- new_tex = self.tex_list[np.ceil(alpha*len(self.tex_list))-1]+ new_tex = self.tex_list[np.ceil(alpha * len(self.tex_list)) - 1]if new_tex != self.curr_tex:self.curr_tex = new_texself.mobject = TexMobject(new_tex).shift(self.start_center)if not all(self.start_center == self.end_center):self.mobject.center().shift(- (1-alpha)*self.start_center + alpha*self.end_center+ (1 - alpha) * self.start_center + alpha * self.end_center)---diff --git a/once_useful_constructs/complex_transformation_scene.py b/once_useful_constructs/complex_transformation_scene.pyindex efbbe21b7..e5d6c9ff1 100644--- a/once_useful_constructs/complex_transformation_scene.py+++ b/once_useful_constructs/complex_transformation_scene.py@@ -2,29 +2,30 @@ from constants import *from animation.animation import Animationfrom animation.movement import SmoothedVectorizedHomotopy-from animation.transform import ApplyPointwiseFunctionfrom animation.transform import MoveToTargetfrom mobject.coordinate_systems import ComplexPlanefrom mobject.types.vectorized_mobject import VGroupfrom scene.scene import Scene+class ComplexTransformationScene(Scene):CONFIG = {- "plane_config" : {},- "background_fade_factor" : 0.5,- "use_multicolored_plane" : False,- "vert_start_color" : BLUE, ##TODO- "vert_end_color" : BLUE,- "horiz_start_color" : BLUE,- "horiz_end_color" : BLUE,- "num_anchors_to_add_per_line" : 50,- "post_transformation_stroke_width" : None,- "default_apply_complex_function_kwargs" : {- "run_time" : 5,+ "plane_config": {},+ "background_fade_factor": 0.5,+ "use_multicolored_plane": False,+ "vert_start_color": BLUE, # TODO+ "vert_end_color": BLUE,+ "horiz_start_color": BLUE,+ "horiz_end_color": BLUE,+ "num_anchors_to_add_per_line": 50,+ "post_transformation_stroke_width": None,+ "default_apply_complex_function_kwargs": {+ "run_time": 5,},- "background_label_scale_val" : 0.5,- "include_coordinate_labels" : True,+ "background_label_scale_val": 0.5,+ "include_coordinate_labels": True,}+def setup(self):self.foreground_mobjects = []self.transformable_mobjects = []@@ -44,12 +45,12 @@ class ComplexTransformationScene(Scene):Scene.add(self, *mobjects)def add(self, *mobjects):- Scene.add(self, *list(mobjects)+self.foreground_mobjects)+ Scene.add(self, *list(mobjects) + self.foreground_mobjects)def play(self, *animations, **kwargs):Scene.play(self,- *list(animations)+map(Animation, self.foreground_mobjects),+ *list(animations) + map(Animation, self.foreground_mobjects),**kwargs)@@ -67,7 +68,7 @@ class ComplexTransformationScene(Scene):self.plane = self.get_transformable_plane()self.add(self.plane)- def get_transformable_plane(self, x_range = None, y_range = None):+ def get_transformable_plane(self, x_range=None, y_range=None):"""x_range and y_range would be tuples (min, max)"""@@ -76,11 +77,11 @@ class ComplexTransformationScene(Scene):if x_range is not None:x_min, x_max = x_rangeplane_config["x_radius"] = x_max - x_min- shift_val += (x_max+x_min)*RIGHT/2.+ shift_val += (x_max + x_min) * RIGHT / 2.if y_range is not None:y_min, y_max = y_rangeplane_config["y_radius"] = y_max - y_min- shift_val += (y_max+y_min)*UP/2.+ shift_val += (y_max + y_min) * UP / 2.plane = ComplexPlane(**plane_config)plane.shift(shift_val)if self.use_multicolored_plane:@@ -92,7 +93,7 @@ class ComplexTransformationScene(Scene):mob.prepare_for_nonlinear_transform(self.num_anchors_to_add_per_line)- #TODO...+ # TODO...def paint_plane(self, plane):for lines in plane.main_lines, plane.secondary_lines:@@ -109,7 +110,7 @@ class ComplexTransformationScene(Scene):def z_to_point(self, z):return self.background.number_to_point(z)-+def get_transformer(self, **kwargs):transform_kwargs = dict(self.default_apply_complex_function_kwargs)transform_kwargs.update(kwargs)@@ -117,16 +118,15 @@ class ComplexTransformationScene(Scene):self.prepare_for_transformation(plane)transformer = VGroup(plane, *self.transformable_mobjects- )+ )return transformer, transform_kwargs-- def apply_complex_function(self, func, added_anims = [], **kwargs):+ def apply_complex_function(self, func, added_anims=[], **kwargs):transformer, transform_kwargs = self.get_transformer(**kwargs)transformer.generate_target()- #Rescale, apply function, scale back+ # Rescale, apply function, scale backtransformer.target.shift(-self.background.get_center_point())- transformer.target.scale(1./self.background.unit_size)+ transformer.target.scale(1. / self.background.unit_size)transformer.target.apply_complex_function(func)transformer.target.scale(self.background.unit_size)transformer.target.shift(self.background.get_center_point())@@ -135,14 +135,16 @@ class ComplexTransformationScene(Scene):for mob in transformer.target[0].family_members_with_points():mob.make_smooth()if self.post_transformation_stroke_width is not None:- transformer.target.set_stroke(width = self.post_transformation_stroke_width)+ transformer.target.set_stroke(+ width=self.post_transformation_stroke_width)self.play(MoveToTarget(transformer, **transform_kwargs),*added_anims)- def apply_complex_homotopy(self, complex_homotopy, added_anims = [], **kwargs):+ def apply_complex_homotopy(self, complex_homotopy, added_anims=[], **kwargs):transformer, transform_kwargs = self.get_transformer(**kwargs)+def homotopy(x, y, z, t):output = complex_homotopy(complex(x, y), t)rescaled_output = self.z_to_point(output)@@ -155,24 +157,3 @@ class ComplexTransformationScene(Scene):),*added_anims)---------------------diff --git a/once_useful_constructs/counting.py b/once_useful_constructs/counting.pyindex 8b8edeb07..87a852578 100644--- a/once_useful_constructs/counting.py+++ b/once_useful_constructs/counting.py@@ -1,10 +1,7 @@from constants import *-from mobject.mobject import Mobjectfrom mobject.svg.tex_mobject import TexMobject-from mobject.svg.tex_mobject import TextMobjectfrom mobject.types.vectorized_mobject import VGroup-from mobject.types.vectorized_mobject import VMobjectfrom animation.creation import ShowCreationfrom animation.creation import FadeIn@@ -18,17 +15,18 @@ from scene.scene import Sceneclass CountingScene(Scene):CONFIG = {- "digit_place_colors" : [YELLOW, MAROON_B, RED, GREEN, BLUE, PURPLE_D],- "counting_dot_starting_position" : (FRAME_X_RADIUS-1)*RIGHT + (FRAME_Y_RADIUS-1)*UP,- "count_dot_starting_radius" : 0.5,- "dot_configuration_height" : 2,- "ones_configuration_location" : UP+2*RIGHT,- "num_scale_factor" : 2,- "num_start_location" : 2*DOWN,+ "digit_place_colors": [YELLOW, MAROON_B, RED, GREEN, BLUE, PURPLE_D],+ "counting_dot_starting_position": (FRAME_X_RADIUS - 1) * RIGHT + (FRAME_Y_RADIUS - 1) * UP,+ "count_dot_starting_radius": 0.5,+ "dot_configuration_height": 2,+ "ones_configuration_location": UP + 2 * RIGHT,+ "num_scale_factor": 2,+ "num_start_location": 2 * DOWN,}+def setup(self):self.dots = VGroup()- self.number = 0+ self.number = 0self.max_place = 0self.number_mob = VGroup(TexMobject(str(self.number)))self.number_mob.scale(self.num_scale_factor)@@ -43,26 +41,25 @@ class CountingScene(Scene):self.add(self.number_mob)def get_template_configuration(self, place):- #This should probably be replaced for non-base-10 counting scenes- down_right = (0.5)*RIGHT + (np.sqrt(3)/2)*DOWN+ # This should probably be replaced for non-base-10 counting scenes+ down_right = (0.5) * RIGHT + (np.sqrt(3) / 2) * DOWNresult = []for down_right_steps in range(5):for left_steps in range(down_right_steps):result.append(- down_right_steps*down_right + left_steps*LEFT+ down_right_steps * down_right + left_steps * LEFT)return reversed(result[:self.get_place_max(place)])def get_dot_template(self, place):- #This should be replaced for non-base-10 counting scenes- down_right = (0.5)*RIGHT + (np.sqrt(3)/2)*DOWN+ # This should be replaced for non-base-10 counting scenesdots = VGroup(*[Dot(- point,- radius = 0.25,- fill_opacity = 0,- stroke_width = 2,- stroke_color = WHITE,+ point,+ radius=0.25,+ fill_opacity=0,+ stroke_width=2,+ stroke_color=WHITE,)for point in self.get_template_configuration(place)])@@ -72,9 +69,9 @@ class CountingScene(Scene):def add_configuration(self):new_template = self.get_dot_template(len(self.dot_templates))new_template.move_to(self.ones_configuration_location)- left_vect = (new_template.get_width()+LARGE_BUFF)*LEFT+ left_vect = (new_template.get_width() + LARGE_BUFF) * LEFTnew_template.shift(- left_vect*len(self.dot_templates)+ left_vect * len(self.dot_templates))self.dot_templates.append(new_template)self.dot_template_iterators.append(@@ -82,27 +79,27 @@ class CountingScene(Scene):)self.curr_configurations.append(VGroup())- def count(self, max_val, run_time_per_anim = 1):+ def count(self, max_val, run_time_per_anim=1):for x in range(max_val):self.increment(run_time_per_anim)- def increment(self, run_time_per_anim = 1):+ def increment(self, run_time_per_anim=1):moving_dot = Dot(self.counting_dot_starting_position,- radius = self.count_dot_starting_radius,- color = self.digit_place_colors[0],+ radius=self.count_dot_starting_radius,+ color=self.digit_place_colors[0],)moving_dot.generate_target()- moving_dot.set_fill(opacity = 0)+ moving_dot.set_fill(opacity=0)kwargs = {- "run_time" : run_time_per_anim+ "run_time": run_time_per_anim}continue_rolling_over = Truefirst_move = Trueplace = 0while continue_rolling_over:- added_anims = []+ added_anims = []if first_move:added_anims += self.get_digit_increment_animations()first_move = False@@ -112,26 +109,25 @@ class CountingScene(Scene):self.play(MoveToTarget(moving_dot), *added_anims, **kwargs)self.curr_configurations[place].add(moving_dot)-if len(self.curr_configurations[place].split()) == self.get_place_max(place):full_configuration = self.curr_configurations[place]self.curr_configurations[place] = VGroup()place += 1center = full_configuration.get_center_of_mass()- radius = 0.6*max(+ radius = 0.6 * max(full_configuration.get_width(),full_configuration.get_height(),)circle = Circle(- radius = radius,- stroke_width = 0,- fill_color = self.digit_place_colors[place],- fill_opacity = 0.5,+ radius=radius,+ stroke_width=0,+ fill_color=self.digit_place_colors[place],+ fill_opacity=0.5,)circle.move_to(center)moving_dot = VGroup(circle, full_configuration)moving_dot.generate_target()- moving_dot[0].set_fill(opacity = 0)+ moving_dot[0].set_fill(opacity=0)else:continue_rolling_over = False@@ -139,23 +135,24 @@ class CountingScene(Scene):result = []self.number += 1is_next_digit = self.is_next_digit()- if is_next_digit: self.max_place += 1+ if is_next_digit:+ self.max_place += 1new_number_mob = self.get_number_mob(self.number)new_number_mob.move_to(self.number_mob, RIGHT)if is_next_digit:self.add_configuration()- place = len(new_number_mob.split())-1+ place = len(new_number_mob.split()) - 1result.append(FadeIn(self.dot_templates[place]))arrow = Arrow(new_number_mob[place].get_top(),self.dot_templates[place].get_bottom(),- color = self.digit_place_colors[place]+ color=self.digit_place_colors[place])self.arrows.add(arrow)result.append(ShowCreation(arrow))result.append(Transform(self.number_mob, new_number_mob,- submobject_mode = "lagged_start"+ submobject_mode="lagged_start"))return result@@ -169,35 +166,42 @@ class CountingScene(Scene):self.digit_place_colors += self.digit_place_colorsdigit.set_color(self.digit_place_colors[place])digit.scale(self.num_scale_factor)- digit.next_to(result, LEFT, buff = SMALL_BUFF, aligned_edge = DOWN)+ digit.next_to(result, LEFT, buff=SMALL_BUFF, aligned_edge=DOWN)result.add(digit)place += 1return resultdef is_next_digit(self):return False+def get_place_num(self, num, place):return 0+def get_place_max(self, place):return 0+class PowerCounter(CountingScene):def is_next_digit(self):number = self.numberwhile number > 1:- if number%self.base != 0:+ if number % self.base != 0:return Falsenumber /= self.basereturn True+def get_place_max(self, place):return self.base+def get_place_num(self, num, place):return (num / (self.base ** place)) % self.base+class CountInDecimal(PowerCounter):CONFIG = {- "base" : 10,+ "base": 10,}+def construct(self):for x in range(11):self.increment()@@ -206,35 +210,41 @@ class CountInDecimal(PowerCounter):for x in range(20):self.increment()+class CountInTernary(PowerCounter):CONFIG = {- "base" : 3,- "dot_configuration_height" : 1,- "ones_configuration_location" : UP+4*RIGHT+ "base": 3,+ "dot_configuration_height": 1,+ "ones_configuration_location": UP + 4 * RIGHT}+def construct(self):self.count(27)# def get_template_configuration(self):# return [ORIGIN, UP]+class CountInBinaryTo256(PowerCounter):CONFIG = {- "base" : 2,- "dot_configuration_height" : 1,- "ones_configuration_location" : UP+5*RIGHT+ "base": 2,+ "dot_configuration_height": 1,+ "ones_configuration_location": UP + 5 * RIGHT}+def construct(self):self.count(128, 0.3)def get_template_configuration(self):return [ORIGIN, UP]+class FactorialBase(CountingScene):CONFIG = {- "dot_configuration_height" : 1,- "ones_configuration_location" : UP+4*RIGHT+ "dot_configuration_height": 1,+ "ones_configuration_location": UP + 4 * RIGHT}+def construct(self):self.count(30, 0.4)@@ -248,15 +258,7 @@ class FactorialBase(CountingScene):return (num / self.factorial(place + 1)) % self.get_place_max(place)def factorial(self, n):- if (n == 1): return 1- else: return n * self.factorial(n - 1)----------\ No newline at end of file+ if (n == 1):+ return 1+ else:+ return n * self.factorial(n - 1)diff --git a/once_useful_constructs/fractals.py b/once_useful_constructs/fractals.pyindex 68283db80..51241563e 100644--- a/once_useful_constructs/fractals.py+++ b/once_useful_constructs/fractals.py@@ -1,17 +1,11 @@-from animation.creation import ShowCreation-from animation.transform import Transformfrom for_3b1b_videos.pi_creature import PiCreaturefrom for_3b1b_videos.pi_creature import Randolphfrom for_3b1b_videos.pi_creature import get_all_pi_creature_modesfrom mobject.types.vectorized_mobject import VGroupfrom mobject.types.vectorized_mobject import VMobject-from mobject.types.vectorized_mobject import VectorizedPoint-from scene.scene import Scenefrom mobject.geometry import Circle-from mobject.geometry import Linefrom mobject.geometry import Polygonfrom mobject.geometry import RegularPolygon-from mobject.geometry import Squarefrom utils.bezier import interpolatefrom utils.color import color_gradientfrom utils.config_ops import digest_config@@ -22,64 +16,70 @@ from utils.space_ops import rotation_matrixfrom constants import *-def rotate(points, angle = np.pi, axis = OUT):++def rotate(points, angle=np.pi, axis=OUT):if axis is None:return pointsmatrix = rotation_matrix(angle, axis)points = np.dot(points, np.transpose(matrix))return points-def fractalify(vmobject, order = 3, *args, **kwargs):++def fractalify(vmobject, order=3, *args, **kwargs):for x in range(order):fractalification_iteration(vmobject)return vmobject-def fractalification_iteration(vmobject, dimension = 1.05, num_inserted_anchors_range = range(1, 4)):++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)+ 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]+ 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+ 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^2offset_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)+ 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+ point + u * offset_len * offset_unit_vectfor u, point in zip(it.cycle([-1, 1]), inserted_points)]new_anchors += [p1] + inserted_pointsnew_anchors.append(original_anchors[-1])vmobject.set_points_as_corners(new_anchors)vmobject.submobjects = [- fractalification_iteration(submob, dimension, num_inserted_anchors_range)+ fractalification_iteration(+ submob, dimension, num_inserted_anchors_range)for submob in vmobject.submobjects]return vmobject+class SelfSimilarFractal(VMobject):CONFIG = {- "order" : 5,- "num_subparts" : 3,- "height" : 4,- "colors" : [RED, WHITE],- "stroke_width" : 1,- "fill_opacity" : 1,- "propagate_style_to_family" : True,+ "order": 5,+ "num_subparts": 3,+ "height": 4,+ "colors": [RED, WHITE],+ "stroke_width": 1,+ "fill_opacity": 1,+ "propagate_style_to_family": True,}+def init_colors(self):VMobject.init_colors(self)self.set_color_by_gradient(*self.colors)@@ -114,45 +114,51 @@ class SelfSimilarFractal(VMobject):def arrange_subparts(self, *subparts):raise Exception("Not implemented")+class Sierpinski(SelfSimilarFractal):def get_seed_shape(self):return Polygon(- RIGHT, np.sqrt(3)*UP, LEFT,+ RIGHT, np.sqrt(3) * UP, LEFT,)def arrange_subparts(self, *subparts):tri1, tri2, tri3 = subparts- tri1.move_to(tri2.get_corner(DOWN+LEFT), UP)- tri3.move_to(tri2.get_corner(DOWN+RIGHT), UP)+ tri1.move_to(tri2.get_corner(DOWN + LEFT), UP)+ tri3.move_to(tri2.get_corner(DOWN + RIGHT), UP)+class DiamondFractal(SelfSimilarFractal):CONFIG = {- "num_subparts" : 4,- "height" : 4,- "colors" : [GREEN_E, YELLOW],+ "num_subparts": 4,+ "height": 4,+ "colors": [GREEN_E, YELLOW],}+def get_seed_shape(self):- return RegularPolygon(n = 4)+ return RegularPolygon(n=4)def arrange_subparts(self, *subparts):# VGroup(*subparts).rotate(np.pi/4)- for part, vect in zip(subparts, compass_directions(start_vect = UP+RIGHT)):- part.next_to(ORIGIN, vect, buff = 0)- VGroup(*subparts).rotate(np.pi/4, about_point = ORIGIN)+ for part, vect in zip(subparts, compass_directions(start_vect=UP + RIGHT)):+ part.next_to(ORIGIN, vect, buff=0)+ VGroup(*subparts).rotate(np.pi / 4, about_point=ORIGIN)+class PentagonalFractal(SelfSimilarFractal):CONFIG = {- "num_subparts" : 5,- "colors" : [MAROON_B, YELLOW, RED],- "height" : 6,+ "num_subparts": 5,+ "colors": [MAROON_B, YELLOW, RED],+ "height": 6,}+def get_seed_shape(self):- return RegularPolygon(n = 5, start_angle = np.pi/2)+ return RegularPolygon(n=5, start_angle=np.pi / 2)def arrange_subparts(self, *subparts):for x, part in enumerate(subparts):- part.shift(0.95*part.get_height()*UP)- part.rotate(2*np.pi*x/5, about_point = ORIGIN)+ part.shift(0.95 * part.get_height() * UP)+ part.rotate(2 * np.pi * x / 5, about_point=ORIGIN)+class PentagonalPiCreatureFractal(PentagonalFractal):def init_colors(self):@@ -165,30 +171,32 @@ class PentagonalPiCreatureFractal(PentagonalFractal):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.body.set_stroke(color, width=0.5)pi.set_color(color)def get_seed_shape(self):- return Randolph(mode = "shruggie")+ return Randolph(mode="shruggie")def arrange_subparts(self, *subparts):for part in subparts:- part.rotate(2*np.pi/5, about_point = ORIGIN)+ part.rotate(2 * np.pi / 5, about_point=ORIGIN)PentagonalFractal.arrange_subparts(self, *subparts)+class PiCreatureFractal(VMobject):CONFIG = {- "order" : 7,- "scale_val" : 2.5,- "start_mode" : "hooray",- "height" : 6,- "colors" : [+ "order": 7,+ "scale_val": 2.5,+ "start_mode": "hooray",+ "height": 6,+ "colors": [BLUE_D, BLUE_B, MAROON_B, MAROON_D, GREY,YELLOW, RED, GREY_BROWN, RED, RED_E,],- "random_seed" : 0,- "stroke_width" : 0,+ "random_seed": 0,+ "stroke_width": 0,}+def init_colors(self):VMobject.init_colors(self)internal_pis = [@@ -200,13 +208,12 @@ class PiCreatureFractal(VMobject):for pi in reversed(internal_pis):color = random.choice(self.colors)pi.set_color(color)- pi.set_stroke(color, width = 0)-+ pi.set_stroke(color, width=0)def generate_points(self):random.seed(self.random_seed)modes = get_all_pi_creature_modes()- seed = PiCreature(mode = self.start_mode)+ seed = PiCreature(mode=self.start_mode)seed.scale_to_fit_height(self.height)seed.to_edge(DOWN)creatures = [seed]@@ -216,15 +223,15 @@ class PiCreatureFractal(VMobject):for creature in creatures:for eye, vect in zip(creature.eyes, [LEFT, RIGHT]):new_creature = PiCreature(- mode = random.choice(modes)+ mode=random.choice(modes))new_creature.scale_to_fit_height(- self.scale_val*eye.get_height()+ self.scale_val * eye.get_height())new_creature.next_to(- eye, vect,- buff = 0,- aligned_edge = DOWN+ eye, vect,+ buff=0,+ aligned_edge=DOWN)new_creatures.append(new_creature)creature.look_at(random.choice(new_creatures))@@ -235,70 +242,77 @@ class PiCreatureFractal(VMobject):# VMobject.init_colors(self)# self.set_color_by_gradient(*self.colors)+class WonkyHexagonFractal(SelfSimilarFractal):CONFIG = {- "num_subparts" : 7+ "num_subparts": 7}+def get_seed_shape(self):return RegularPolygon(n=6)def arrange_subparts(self, *subparts):for i, piece in enumerate(subparts):- piece.rotate(i*np.pi/12, about_point = ORIGIN)+ piece.rotate(i * np.pi / 12, about_point=ORIGIN)p1, p2, p3, p4, p5, p6, p7 = subpartscenter_row = VGroup(p1, p4, p7)- center_row.arrange_submobjects(RIGHT, buff = 0)+ center_row.arrange_submobjects(RIGHT, buff=0)for p in p2, p3, p5, p6:p.scale_to_fit_width(p1.get_width())- p2.move_to(p1.get_top(), DOWN+LEFT)- p3.move_to(p1.get_bottom(), UP+LEFT)- p5.move_to(p4.get_top(), DOWN+LEFT)- p6.move_to(p4.get_bottom(), UP+LEFT)+ p2.move_to(p1.get_top(), DOWN + LEFT)+ p3.move_to(p1.get_bottom(), UP + LEFT)+ p5.move_to(p4.get_top(), DOWN + LEFT)+ p6.move_to(p4.get_bottom(), UP + LEFT)+class CircularFractal(SelfSimilarFractal):CONFIG = {- "num_subparts" : 3,- "colors" : [GREEN, BLUE, GREY]+ "num_subparts": 3,+ "colors": [GREEN, BLUE, GREY]}+def get_seed_shape(self):return Circle()def arrange_subparts(self, *subparts):if not hasattr(self, "been_here"):- self.num_subparts = 3+self.order+ self.num_subparts = 3 + self.orderself.been_here = Truefor i, part in enumerate(subparts):- theta = np.pi/self.num_subparts+ theta = np.pi / self.num_subpartspart.next_to(ORIGIN, UP,- buff = self.height/(2*np.tan(theta))+ buff=self.height / (2 * np.tan(theta)))- part.rotate(i*2*np.pi/self.num_subparts, about_point = ORIGIN)+ part.rotate(i * 2 * np.pi / self.num_subparts, about_point=ORIGIN)self.num_subparts -= 1######## Space filling curves ############+class JaggedCurvePiece(VMobject):def insert_n_anchor_points(self, n):if self.get_num_anchor_points() == 0:self.points = np.zeros((1, 3))anchors = self.get_anchors()- indices = np.linspace(0, len(anchors)-1, n+len(anchors)).astype('int')+ indices = np.linspace(0, len(anchors) - 1, n ++ len(anchors)).astype('int')self.set_points_as_corners(anchors[indices])+class FractalCurve(VMobject):CONFIG = {- "radius" : 3,- "order" : 5,- "colors" : [RED, GREEN],- "num_submobjects" : 20,- "monochromatic" : False,- "order_to_stroke_width_map" : {- 3 : 3,- 4 : 2,- 5 : 1,+ "radius": 3,+ "order": 5,+ "colors": [RED, GREEN],+ "num_submobjects": 20,+ "monochromatic": False,+ "order_to_stroke_width_map": {+ 3: 3,+ 4: 2,+ 5: 1,},- "propagate_style_to_family" : True,+ "propagate_style_to_family": True,}def generate_points(self):@@ -319,19 +333,20 @@ class FractalCurve(VMobject):self.set_color_by_gradient(*self.colors)for order in sorted(self.order_to_stroke_width_map.keys()):if self.order >= order:- self.set_stroke(width = self.order_to_stroke_width_map[order])+ self.set_stroke(width=self.order_to_stroke_width_map[order])def get_anchor_points(self):raise Exception("Not implemented")+class LindenmayerCurve(FractalCurve):CONFIG = {- "axiom" : "A",- "rule" : {},- "scale_factor" : 2,- "radius" : 3,- "start_step" : RIGHT,- "angle" : np.pi/2,+ "axiom": "A",+ "rule": {},+ "scale_factor": 2,+ "radius": 3,+ "start_step": RIGHT,+ "angle": np.pi / 2,}def expand_command_string(self, command):@@ -350,7 +365,7 @@ class LindenmayerCurve(FractalCurve):return resultdef get_anchor_points(self):- step = float(self.radius) * self.start_step+ step = float(self.radius) * self.start_stepstep /= (self.scale_factor**self.order)curr = np.zeros(3)result = [curr]@@ -364,14 +379,16 @@ class LindenmayerCurve(FractalCurve):result.append(curr)return np.array(result) - center_of_mass(result)+class SelfSimilarSpaceFillingCurve(FractalCurve):CONFIG = {- "offsets" : [],- #keys must awkwardly be in string form...- "offset_to_rotation_axis" : {},- "scale_factor" : 2,- "radius_scale_factor" : 0.5,+ "offsets": [],+ # keys must awkwardly be in string form...+ "offset_to_rotation_axis": {},+ "scale_factor": 2,+ "radius_scale_factor": 0.5,}+def transform(self, points, offset):"""How to transform the copy of points shifted by@@ -380,11 +397,11 @@ class SelfSimilarSpaceFillingCurve(FractalCurve):copy = np.array(points)if str(offset) in self.offset_to_rotation_axis:copy = rotate(- copy,- axis = self.offset_to_rotation_axis[str(offset)]+ copy,+ axis=self.offset_to_rotation_axis[str(offset)])copy /= self.scale_factor,- copy += offset*self.radius*self.radius_scale_factor+ copy += offset * self.radius * self.radius_scale_factorreturn copydef refine_into_subparts(self, points):@@ -393,11 +410,10 @@ class SelfSimilarSpaceFillingCurve(FractalCurve):for offset in self.offsets]return reduce(- lambda a, b : np.append(a, b, axis = 0),+ lambda a, b: np.append(a, b, axis=0),transformed_copies)-def get_anchor_points(self):points = np.zeros((1, 3))for count in range(self.order):@@ -407,95 +423,100 @@ class SelfSimilarSpaceFillingCurve(FractalCurve):def generate_grid(self):raise Exception("Not implemented")+class HilbertCurve(SelfSimilarSpaceFillingCurve):CONFIG = {- "offsets" : [- LEFT+DOWN,- LEFT+UP,- RIGHT+UP,- RIGHT+DOWN,+ "offsets": [+ LEFT + DOWN,+ LEFT + UP,+ RIGHT + UP,+ RIGHT + DOWN,],- "offset_to_rotation_axis" : {- str(LEFT+DOWN) : RIGHT+UP,- str(RIGHT+DOWN) : RIGHT+DOWN,+ "offset_to_rotation_axis": {+ str(LEFT + DOWN): RIGHT + UP,+ str(RIGHT + DOWN): RIGHT + DOWN,},- }+ }+class HilbertCurve3D(SelfSimilarSpaceFillingCurve):CONFIG = {- "offsets" : [- RIGHT+DOWN+IN,- LEFT+DOWN+IN,- LEFT+DOWN+OUT,- RIGHT+DOWN+OUT,- RIGHT+UP+OUT,- LEFT+UP+OUT,- LEFT+UP+IN,- RIGHT+UP+IN,+ "offsets": [+ RIGHT + DOWN + IN,+ LEFT + DOWN + IN,+ LEFT + DOWN + OUT,+ RIGHT + DOWN + OUT,+ RIGHT + UP + OUT,+ LEFT + UP + OUT,+ LEFT + UP + IN,+ RIGHT + UP + IN,],- "offset_to_rotation_axis_and_angle" : {- str(RIGHT+DOWN+IN) : (LEFT+UP+OUT , 2*np.pi/3),- str(LEFT+DOWN+IN) : (RIGHT+DOWN+IN, 2*np.pi/3),- str(LEFT+DOWN+OUT) : (RIGHT+DOWN+IN, 2*np.pi/3),- str(RIGHT+DOWN+OUT) : (UP , np.pi ),- str(RIGHT+UP+OUT) : (UP , np.pi ),- str(LEFT+UP+OUT) : (LEFT+DOWN+OUT, 2*np.pi/3),- str(LEFT+UP+IN) : (LEFT+DOWN+OUT, 2*np.pi/3),- str(RIGHT+UP+IN) : (RIGHT+UP+IN , 2*np.pi/3),+ "offset_to_rotation_axis_and_angle": {+ str(RIGHT + DOWN + IN): (LEFT + UP + OUT, 2 * np.pi / 3),+ str(LEFT + DOWN + IN): (RIGHT + DOWN + IN, 2 * np.pi / 3),+ str(LEFT + DOWN + OUT): (RIGHT + DOWN + IN, 2 * np.pi / 3),+ str(RIGHT + DOWN + OUT): (UP, np.pi),+ str(RIGHT + UP + OUT): (UP, np.pi),+ str(LEFT + UP + OUT): (LEFT + DOWN + OUT, 2 * np.pi / 3),+ str(LEFT + UP + IN): (LEFT + DOWN + OUT, 2 * np.pi / 3),+ str(RIGHT + UP + IN): (RIGHT + UP + IN, 2 * np.pi / 3),},}# Rewrote transform method to include the rotation angle+def transform(self, points, offset):copy = np.array(points)copy = rotate(- copy,- axis = self.offset_to_rotation_axis_and_angle[str(offset)][0],- angle = self.offset_to_rotation_axis_and_angle[str(offset)][1],+ copy,+ axis=self.offset_to_rotation_axis_and_angle[str(offset)][0],+ angle=self.offset_to_rotation_axis_and_angle[str(offset)][1],)copy /= self.scale_factor,- copy += offset*self.radius*self.radius_scale_factor+ copy += offset * self.radius * self.radius_scale_factorreturn copy+class PeanoCurve(SelfSimilarSpaceFillingCurve):CONFIG = {- "colors" : [PURPLE, TEAL],- "offsets" : [- LEFT+DOWN,+ "colors": [PURPLE, TEAL],+ "offsets": [+ LEFT + DOWN,LEFT,- LEFT+UP,+ LEFT + UP,UP,ORIGIN,DOWN,- RIGHT+DOWN,+ RIGHT + DOWN,RIGHT,- RIGHT+UP,+ RIGHT + UP,],- "offset_to_rotation_axis" : {- str(LEFT) : UP,- str(UP) : RIGHT,- str(ORIGIN) : LEFT+UP,- str(DOWN) : RIGHT,- str(RIGHT) : UP,+ "offset_to_rotation_axis": {+ str(LEFT): UP,+ str(UP): RIGHT,+ str(ORIGIN): LEFT + UP,+ str(DOWN): RIGHT,+ str(RIGHT): UP,},- "scale_factor" : 3,- "radius_scale_factor" : 2.0/3,+ "scale_factor": 3,+ "radius_scale_factor": 2.0 / 3,}+class TriangleFillingCurve(SelfSimilarSpaceFillingCurve):CONFIG = {- "colors" : [MAROON, YELLOW],- "offsets" : [- LEFT/4.+DOWN/6.,+ "colors": [MAROON, YELLOW],+ "offsets": [+ LEFT / 4. + DOWN / 6.,ORIGIN,- RIGHT/4.+DOWN/6.,- UP/3.,+ RIGHT / 4. + DOWN / 6.,+ UP / 3.,],- "offset_to_rotation_axis" : {+ "offset_to_rotation_axis": {str(ORIGIN): RIGHT,- str(UP/3.) : UP,+ str(UP / 3.): UP,},- "scale_factor" : 2,- "radius_scale_factor" : 1.5,+ "scale_factor": 2,+ "radius_scale_factor": 1.5,}# class HexagonFillingCurve(SelfSimilarSpaceFillingCurve):@@ -505,7 +526,7 @@ class TriangleFillingCurve(SelfSimilarSpaceFillingCurve):# "axis_offset_pairs" : [# (None, 1.5*DOWN + 0.5*np.sqrt(3)*LEFT),# (UP+np.sqrt(3)*RIGHT, 1.5*DOWN + 0.5*np.sqrt(3)*RIGHT),-# (np.sqrt(3)*UP+RIGHT, ORIGIN),+# (np.sqrt(3)*UP+RIGHT, ORIGIN),# ((UP, RIGHT), np.sqrt(3)*LEFT),# (None, 1.5*UP + 0.5*np.sqrt(3)*LEFT),# (None, 1.5*UP + 0.5*np.sqrt(3)*RIGHT),@@ -524,135 +545,132 @@ class TriangleFillingCurve(SelfSimilarSpaceFillingCurve):class UtahFillingCurve(SelfSimilarSpaceFillingCurve):CONFIG = {- "colors" : [WHITE, BLUE_D],- "axis_offset_pairs" : [+ "colors": [WHITE, BLUE_D],+ "axis_offset_pairs": [],- "scale_factor" : 3,- "radius_scale_factor" : 2/(3*np.sqrt(3)),+ "scale_factor": 3,+ "radius_scale_factor": 2 / (3 * np.sqrt(3)),}+class FlowSnake(LindenmayerCurve):CONFIG = {- "colors" : [YELLOW, GREEN],- "axiom" : "A",- "rule" : {- "A" : "A-B--B+A++AA+B-",- "B" : "+A-BB--B-A++A+B",+ "colors": [YELLOW, GREEN],+ "axiom": "A",+ "rule": {+ "A": "A-B--B+A++AA+B-",+ "B": "+A-BB--B-A++A+B",},- "radius" : 6, #TODO, this is innaccurate- "scale_factor" : np.sqrt(7),- "start_step" : RIGHT,- "angle" : -np.pi/3,+ "radius": 6, # TODO, this is innaccurate+ "scale_factor": np.sqrt(7),+ "start_step": RIGHT,+ "angle": -np.pi / 3,}+def __init__(self, **kwargs):LindenmayerCurve.__init__(self, **kwargs)- self.rotate(-self.order*np.pi/9, about_point = ORIGIN)+ self.rotate(-self.order * np.pi / 9, about_point=ORIGIN)+class SierpinskiCurve(LindenmayerCurve):CONFIG = {- "colors" : [RED, WHITE],- "axiom" : "B",- "rule" : {- "A" : "+B-A-B+",- "B" : "-A+B+A-",+ "colors": [RED, WHITE],+ "axiom": "B",+ "rule": {+ "A": "+B-A-B+",+ "B": "-A+B+A-",},- "radius" : 6, #TODO, this is innaccurate- "scale_factor" : 2,- "start_step" : RIGHT,- "angle" : -np.pi/3,+ "radius": 6, # TODO, this is innaccurate+ "scale_factor": 2,+ "start_step": RIGHT,+ "angle": -np.pi / 3,}+class KochSnowFlake(LindenmayerCurve):CONFIG = {- "colors" : [BLUE_D, WHITE, BLUE_D],- "axiom" : "A--A--A--",- "rule" : {- "A" : "A+A--A+A"+ "colors": [BLUE_D, WHITE, BLUE_D],+ "axiom": "A--A--A--",+ "rule": {+ "A": "A+A--A+A"},- "radius" : 4,- "scale_factor" : 3,- "start_step" : RIGHT,- "angle" : np.pi/3,- "order_to_stroke_width_map" : {- 3 : 3,- 5 : 2,- 6 : 1,+ "radius": 4,+ "scale_factor": 3,+ "start_step": RIGHT,+ "angle": np.pi / 3,+ "order_to_stroke_width_map": {+ 3: 3,+ 5: 2,+ 6: 1,},}def __init__(self, **kwargs):digest_config(self, kwargs)- self.scale_factor = 2*(1+np.cos(self.angle))+ self.scale_factor = 2 * (1 + np.cos(self.angle))LindenmayerCurve.__init__(self, **kwargs)+class KochCurve(KochSnowFlake):CONFIG = {- "axiom" : "A--"+ "axiom": "A--"}+class QuadraticKoch(LindenmayerCurve):CONFIG = {- "colors" : [YELLOW, WHITE, MAROON_B],- "axiom" : "A",- "rule" : {- "A" : "A+A-A-AA+A+A-A"+ "colors": [YELLOW, WHITE, MAROON_B],+ "axiom": "A",+ "rule": {+ "A": "A+A-A-AA+A+A-A"},- "radius" : 4,- "scale_factor" : 4,- "start_step" : RIGHT,- "angle" : np.pi/2+ "radius": 4,+ "scale_factor": 4,+ "start_step": RIGHT,+ "angle": np.pi / 2}+class QuadraticKochIsland(QuadraticKoch):CONFIG = {- "axiom" : "A+A+A+A"+ "axiom": "A+A+A+A"}+class StellarCurve(LindenmayerCurve):CONFIG = {- "start_color" : RED,- "end_color" : BLUE_E,- "rule" : {- "A" : "+B-A-B+A-B+",- "B" : "-A+B+A-B+A-",+ "start_color": RED,+ "end_color": BLUE_E,+ "rule": {+ "A": "+B-A-B+A-B+",+ "B": "-A+B+A-B+A-",},- "scale_factor" : 3,- "angle" : 2*np.pi/5,+ "scale_factor": 3,+ "angle": 2 * np.pi / 5,}+class SnakeCurve(FractalCurve):CONFIG = {- "start_color" : BLUE,- "end_color" : YELLOW,+ "start_color": BLUE,+ "end_color": YELLOW,}+def get_anchor_points(self):result = []resolution = 2**self.order- step = 2.0*self.radius / resolution+ step = 2.0 * self.radius / resolutionlower_left = ORIGIN + \- LEFT*(self.radius - step/2) + \- DOWN*(self.radius - step/2)+ LEFT * (self.radius - step / 2) + \+ DOWN * (self.radius - step / 2)for y in range(resolution):x_range = range(resolution)- if y%2 == 0:+ if y % 2 == 0:x_range.reverse()for x in x_range:result.append(- lower_left + x*step*RIGHT + y*step*UP+ lower_left + x * step * RIGHT + y * step * UP)return result-------------diff --git a/once_useful_constructs/graph_theory.py b/once_useful_constructs/graph_theory.pyindex 0e9ae25d3..8be6cf3c9 100644--- a/once_useful_constructs/graph_theory.py+++ b/once_useful_constructs/graph_theory.py@@ -2,8 +2,6 @@ import itertools as itimport numpy as npimport operator as op-from random import random-from constants import *from scene.scene import Scene@@ -13,14 +11,14 @@ from utils.space_ops import center_of_massclass Graph():def __init__(self):- #List of points in R^3- vertices = []- #List of pairs of indices of vertices- edges = []- #List of tuples of indices of vertices. The last should- #be a cycle whose interior is the entire graph, and when- #regions are computed its complement will be taken.- region_cycles = []+ # List of points in R^3+ vertices = []+ # List of pairs of indices of vertices+ edges = []+ # List of tuples of indices of vertices. The last should+ # be a cycle whose interior is the entire graph, and when+ # regions are computed its complement will be taken.+ region_cycles = []self.construct()@@ -30,18 +28,20 @@ class Graph():def __str__(self):return self.__class__.__name__+class CubeGraph(Graph):"""5 7- 12- 03+ 12+ 034 6"""+def construct(self):self.vertices = [(x, y, 0)for r in (1, 2)- for x, y in it.product([-r,r], [-r, r])+ for x, y in it.product([-r, r], [-r, r])]self.edges = [(0, 1),@@ -63,9 +63,10 @@ class CubeGraph(Graph):[4, 6, 2, 0],[6, 7, 3, 2],[7, 5, 1, 3],- [4, 6, 7, 5],#By convention, last region will be "outside"+ [4, 6, 7, 5], # By convention, last region will be "outside"]+class SampleGraph(Graph):"""4 2 3 8@@ -73,17 +74,18 @@ class SampleGraph(Graph):75 6"""+def construct(self):self.vertices = [- ( 0, 0, 0),- ( 2, 0, 0),- ( 1, 2, 0),- ( 3, 2, 0),+ (0, 0, 0),+ (2, 0, 0),+ (1, 2, 0),+ (3, 2, 0),(-1, 2, 0),- (-2,-2, 0),- ( 2,-2, 0),- ( 4,-1, 0),- ( 6, 2, 0),+ (-2, -2, 0),+ (2, -2, 0),+ (4, -1, 0),+ (6, 2, 0),]self.edges = [(0, 1),@@ -113,19 +115,21 @@ class SampleGraph(Graph):(4, 5, 6, 7, 8, 3, 2),]+class OctohedronGraph(Graph):"""3-+1 024 5"""+def construct(self):self.vertices = [- (r*np.cos(angle), r*np.sin(angle)-1, 0)+ (r * np.cos(angle), r * np.sin(angle) - 1, 0)for r, s in [(1, 0), (3, 3)]- for angle in (np.pi/6) * np.array([s, 4 + s, 8 + s])+ for angle in (np.pi / 6) * np.array([s, 4 + s, 8 + s])]self.edges = [(0, 1),@@ -152,35 +156,38 @@ class OctohedronGraph(Graph):(3, 4, 5),]+class CompleteGraph(Graph):- def __init__(self, num_vertices, radius = 3):+ def __init__(self, num_vertices, radius=3):self.num_vertices = num_verticesself.radius = radiusGraph.__init__(self)def construct(self):self.vertices = [- (self.radius*np.cos(theta), self.radius*np.sin(theta), 0)+ (self.radius * np.cos(theta), self.radius * np.sin(theta), 0)for x in range(self.num_vertices)- for theta in [2*np.pi*x / self.num_vertices]+ for theta in [2 * np.pi * x / self.num_vertices]]self.edges = it.combinations(range(self.num_vertices), 2)def __str__(self):return Graph.__str__(self) + str(self.num_vertices)+class GraphScene(Scene):args_list = [(CubeGraph(),),(SampleGraph(),),(OctohedronGraph(),),]+@staticmethoddef args_to_string(*args):return str(args[0])def __init__(self, graph, *args, **kwargs):- #See CubeGraph() above for format of graph+ # See CubeGraph() above for format of graphself.graph = graphScene.__init__(self, *args, **kwargs)@@ -198,19 +205,19 @@ class GraphScene(Scene):self.region_from_cycle(cycle)for cycle in self.graph.region_cycles]- regions[-1].complement()#Outer region painted outwardly...+ regions[-1].complement() # Outer region painted outwardly...self.regions = regionsdef region_from_cycle(self, cycle):point_pairs = [[- self.points[cycle[i]],- self.points[cycle[(i+1)%len(cycle)]]+ self.points[cycle[i]],+ self.points[cycle[(i + 1) % len(cycle)]]]for i in range(len(cycle))]return region_from_line_boundary(- *point_pairs, shape = self.shape+ *point_pairs, shape=self.shape)def draw_vertices(self, **kwargs):@@ -219,7 +226,7 @@ class GraphScene(Scene):def draw_edges(self):self.play(*[- ShowCreation(edge, run_time = 1.0)+ ShowCreation(edge, run_time=1.0)for edge in self.edges])@@ -227,17 +234,16 @@ class GraphScene(Scene):self.remove(*self.vertices)start = Mobject(*self.vertices)end = Mobject(*[- Dot(point, radius = 3*Dot.DEFAULT_RADIUS, color = "lightgreen")+ Dot(point, radius=3 * Dot.DEFAULT_RADIUS, color="lightgreen")for point in self.points])self.play(Transform(- start, end, rate_func = there_and_back,+ start, end, rate_func=there_and_back,**kwargs))self.remove(start)self.add(*self.vertices)-def replace_vertices_with(self, mobject):mobject.center()diameter = max(mobject.get_height(), mobject.get_width())@@ -255,7 +261,7 @@ class GraphScene(Scene):for edge in self.edges])- def annotate_edges(self, mobject, fade_in = True, **kwargs):+ def annotate_edges(self, mobject, fade_in=True, **kwargs):angles = map(np.arctan, map(Line.get_slope, self.edges))self.edge_annotations = [mobject.copy().rotate(angle).move_to(edge.get_center())@@ -267,22 +273,22 @@ class GraphScene(Scene):for ann in self.edge_annotations])- def trace_cycle(self, cycle = None, color = "yellow", run_time = 2.0):+ def trace_cycle(self, cycle=None, color="yellow", run_time=2.0):if cycle == None:cycle = self.graph.region_cycles[0]time_per_edge = run_time / len(cycle)next_in_cycle = it.cycle(cycle)- next_in_cycle.next()#jump one ahead+ next_in_cycle.next() # jump one aheadself.traced_cycle = Mobject(*[Line(self.points[i], self.points[j]).set_color(color)for i, j in zip(cycle, next_in_cycle)])self.play(- ShowCreation(self.traced_cycle),- run_time = run_time+ ShowCreation(self.traced_cycle),+ run_time=run_time)- def generate_spanning_tree(self, root = 0, color = "yellow"):+ def generate_spanning_tree(self, root=0, color="yellow"):self.spanning_tree_root = 0pairs = deepcopy(self.graph.edges)pairs += [tuple(reversed(pair)) for pair in pairs]@@ -311,10 +317,10 @@ class GraphScene(Scene):y_sep = 2if not hasattr(self, "spanning_tree"):self.generate_spanning_tree()- root = self.spanning_tree_root+ root = self.spanning_tree_rootcolor = self.spanning_tree.get_color()indices = range(len(self.points))- #Build dicts+ # Build dictsparent_of = dict([tuple(reversed(pair))for pair in self.spanning_tree_index_pairs@@ -323,12 +329,12 @@ class GraphScene(Scene):for child in parent_of:children_of[parent_of[child]].append(child)- x_coord_of = {root : 0}- y_coord_of = {root : bottom}- #width to allocate to a given node, computed as- #the maxium number of decendents in a single generation,- #minus 1, multiplied by x_sep- width_of = {}+ x_coord_of = {root: 0}+ y_coord_of = {root: bottom}+ # width to allocate to a given node, computed as+ # the maxium number of decendents in a single generation,+ # minus 1, multiplied by x_sep+ width_of = {}for index in indices:next_generation = children_of[index]curr_max = max(1, len(next_generation))@@ -345,9 +351,9 @@ class GraphScene(Scene):if index not in y_coord_of:y_coord_of[index] = y_sep + y_coord_of[parent_of[index]]children = children_of[index]- left_hand = x_coord_of[index]-width_of[index]/2.0+ left_hand = x_coord_of[index] - width_of[index] / 2.0for child in children:- x_coord_of[child] = left_hand + width_of[child]/2.0+ x_coord_of[child] = left_hand + width_of[child] / 2.0left_hand += width_of[child] + x_septo_process += children@@ -365,7 +371,7 @@ class GraphScene(Scene):])def generate_dual_graph(self):- point_at_infinity = np.array([np.inf]*3)+ point_at_infinity = np.array([np.inf] * 3)cycles = self.graph.region_cyclesself.dual_points = [center_of_mass([@@ -378,7 +384,8 @@ class GraphScene(Scene):Dot(point).set_color("green")for point in self.dual_points]- self.dual_vertices[-1] = Circle().scale(FRAME_X_RADIUS + FRAME_Y_RADIUS)+ self.dual_vertices[-1] = Circle().scale(FRAME_X_RADIUS ++ FRAME_Y_RADIUS)self.dual_points[-1] = point_at_infinityself.dual_edges = []@@ -388,43 +395,20 @@ class GraphScene(Scene):if not (pair[0] in cycle and pair[1] in cycle):continueindex1, index2 = cycle.index(pair[0]), cycle.index(pair[1])- if abs(index1 - index2) in [1, len(cycle)-1]:+ if abs(index1 - index2) in [1, len(cycle) - 1]:dual_point_pair.append(self.dual_points[cycles.index(cycle)])assert(len(dual_point_pair) == 2)for i in 0, 1:if all(dual_point_pair[i] == point_at_infinity):- new_point = np.array(dual_point_pair[1-i])+ new_point = np.array(dual_point_pair[1 - i])vect = center_of_mass([self.points[pair[0]],self.points[pair[1]]]) - new_point- new_point += FRAME_X_RADIUS*vect/np.linalg.norm(vect)+ new_point += FRAME_X_RADIUS * vect / np.linalg.norm(vect)dual_point_pair[i] = new_pointself.dual_edges.append(Line(*dual_point_pair).set_color())-----------------------diff --git a/once_useful_constructs/light.py b/once_useful_constructs/light.pyindex b54626303..841dd7bfe 100644--- a/once_useful_constructs/light.py+++ b/once_useful_constructs/light.py@@ -1,34 +1,22 @@from constants import *from mobject.geometry import AnnularSector-from mobject.geometry import Arcfrom mobject.geometry import Annulusfrom mobject.mobject import Mobjectfrom mobject.svg.svg_mobject import SVGMobject-from mobject.svg.tex_mobject import TexMobject-from mobject.types.vectorized_mobject import VGroupfrom mobject.types.vectorized_mobject import VMobjectfrom mobject.types.vectorized_mobject import VectorizedPointfrom continual_animation.continual_animation import ContinualAnimation-from animation.animation import Animationfrom animation.composition import LaggedStart-from animation.transform import ApplyMethodfrom animation.transform import Transformfrom animation.creation import FadeInfrom animation.creation import FadeOut-from camera.camera import Camera-from scene.scene import Scene-from camera.three_d_camera import ThreeDCamera-from scene.three_d_scene import ThreeDScene--from utils.space_ops import angle_betweenfrom utils.space_ops import angle_between_vectorsfrom utils.space_ops import project_along_vectorfrom utils.space_ops import rotate_vector-from utils.space_ops import rotation_matrixfrom utils.space_ops import z_to_vectorfrom scipy.spatial import ConvexHull@@ -39,8 +27,8 @@ SHADOW_COLOR = BLACKSWITCH_ON_RUN_TIME = 1.5FAST_SWITCH_ON_RUN_TIME = 0.1NUM_LEVELS = 30-NUM_CONES = 7 # in first lighthouse scene-NUM_VISIBLE_CONES = 5 # ibidem+NUM_CONES = 7 # in first lighthouse scene+NUM_VISIBLE_CONES = 5 # ibidemARC_TIP_LENGTH = 0.2AMBIENT_FULL = 0.8AMBIENT_DIMMED = 0.5@@ -48,11 +36,15 @@ SPOTLIGHT_FULL = 0.8SPOTLIGHT_DIMMED = 0.5LIGHTHOUSE_HEIGHT = 0.8-DEGREES = TAU/360+DEGREES = TAU / 360+++def inverse_power_law(maxint, scale, cutoff, exponent):+ return (lambda r: maxint * (cutoff / (r / scale + cutoff))**exponent)+-inverse_power_law = lambda maxint,scale,cutoff,exponent: \- (lambda r: maxint * (cutoff/(r/scale+cutoff))**exponent)-inverse_quadratic = lambda maxint,scale,cutoff: inverse_power_law(maxint,scale,cutoff,2)+def inverse_quadratic(maxint, scale, cutoff):+ return inverse_power_law(maxint, scale, cutoff, 2)class SwitchOn(LaggedStart):@@ -62,12 +54,14 @@ class SwitchOn(LaggedStart):}def __init__(self, light, **kwargs):- if (not isinstance(light,AmbientLight) and not isinstance(light,Spotlight)):- raise Exception("Only AmbientLights and Spotlights can be switched on")+ if (not isinstance(light, AmbientLight) and not isinstance(light, Spotlight)):+ raise Exception(+ "Only AmbientLights and Spotlights can be switched on")LaggedStart.__init__(self, FadeIn, light, **kwargs)+class SwitchOff(LaggedStart):CONFIG = {"lag_ratio": 0.2,@@ -75,23 +69,26 @@ class SwitchOff(LaggedStart):}def __init__(self, light, **kwargs):- if (not isinstance(light,AmbientLight) and not isinstance(light,Spotlight)):- raise Exception("Only AmbientLights and Spotlights can be switched off")+ if (not isinstance(light, AmbientLight) and not isinstance(light, Spotlight)):+ raise Exception(+ "Only AmbientLights and Spotlights can be switched off")light.submobjects = light.submobjects[::-1]LaggedStart.__init__(self,- FadeOut, light, **kwargs)+ FadeOut, light, **kwargs)light.submobjects = light.submobjects[::-1]+class Lighthouse(SVGMobject):CONFIG = {- "file_name" : "lighthouse",- "height" : LIGHTHOUSE_HEIGHT,- "fill_color" : WHITE,- "fill_opacity" : 1.0,+ "file_name": "lighthouse",+ "height": LIGHTHOUSE_HEIGHT,+ "fill_color": WHITE,+ "fill_opacity": 1.0,}- def move_to(self,point):- self.next_to(point, DOWN, buff = 0)+ def move_to(self, point):+ self.next_to(point, DOWN, buff=0)+class AmbientLight(VMobject):@@ -104,18 +101,18 @@ class AmbientLight(VMobject):# * the number of subdivisions (levels, annuli)CONFIG = {- "source_point": VectorizedPoint(location = ORIGIN, stroke_width = 0, fill_opacity = 0),- "opacity_function" : lambda r : 1.0/(r+1.0)**2,- "color" : LIGHT_COLOR,- "max_opacity" : 1.0,- "num_levels" : NUM_LEVELS,- "radius" : 5.0+ "source_point": VectorizedPoint(location=ORIGIN, stroke_width=0, fill_opacity=0),+ "opacity_function": lambda r: 1.0 / (r + 1.0)**2,+ "color": LIGHT_COLOR,+ "max_opacity": 1.0,+ "num_levels": NUM_LEVELS,+ "radius": 5.0}def generate_points(self):# in theory, this method is only called once, right?# so removing submobs shd not be necessary- #+ ## Note: Usually, yes, it is only called within Mobject.__init__,# but there is no strong guarantee of that, and you may want certain# update functions to regenerate points here and there.@@ -130,71 +127,61 @@ class AmbientLight(VMobject):for r in np.arange(0, self.radius, dr):alpha = self.max_opacity * self.opacity_function(r)annulus = Annulus(- inner_radius = r,- outer_radius = r + dr,- color = self.color,- fill_opacity = alpha+ inner_radius=r,+ outer_radius=r + dr,+ color=self.color,+ fill_opacity=alpha)annulus.move_to(self.get_source_point())self.add(annulus)--- def move_source_to(self,point):- #old_source_point = self.get_source_point()- #self.shift(point - old_source_point)+ def move_source_to(self, point):+ # old_source_point = self.get_source_point()+ # self.shift(point - old_source_point)self.move_to(point)return self----def get_source_point(self):return self.source_point.get_location()------- def dimming(self,new_alpha):+ def dimming(self, new_alpha):old_alpha = self.max_opacityself.max_opacity = new_alphafor submob in self.submobjects:old_submob_alpha = submob.fill_opacitynew_submob_alpha = old_submob_alpha * new_alpha / old_alpha- submob.set_fill(opacity = new_submob_alpha)+ submob.set_fill(opacity=new_submob_alpha)+class Spotlight(VMobject):CONFIG = {- "source_point": VectorizedPoint(location = ORIGIN, stroke_width = 0, fill_opacity = 0),- "opacity_function" : lambda r : 1.0/(r/2+1.0)**2,- "color" : GREEN, # LIGHT_COLOR,- "max_opacity" : 1.0,- "num_levels" : 10,- "radius" : 10.0,- "screen" : None,+ "source_point": VectorizedPoint(location=ORIGIN, stroke_width=0, fill_opacity=0),+ "opacity_function": lambda r: 1.0 / (r / 2 + 1.0)**2,+ "color": GREEN, # LIGHT_COLOR,+ "max_opacity": 1.0,+ "num_levels": 10,+ "radius": 10.0,+ "screen": None,"camera_mob": None}def projection_direction(self):# Note: This seems reasonable, though for it to work you'd- # need to be sure that any 3d scene including a spotlight- # somewhere assigns that spotlights "camera" attribute+ # need to be sure that any 3d scene including a spotlight+ # somewhere assigns that spotlights "camera" attribute# to be the camera associated with that scene.- if self.camera_mob == None:+ if self.camera_mob is None:return OUTelse:[phi, theta, r] = self.camera_mob.get_center()- v = np.array([np.sin(phi)*np.cos(theta), np.sin(phi)*np.sin(theta), np.cos(phi)])- return v #/np.linalg.norm(v)+ v = np.array([np.sin(phi) * np.cos(theta),+ np.sin(phi) * np.sin(theta), np.cos(phi)])+ return v # /np.linalg.norm(v)- def project(self,point):+ def project(self, point):v = self.projection_direction()- w = project_along_vector(point,v)+ w = project_along_vector(point, v)return wdef get_source_point(self):@@ -205,7 +192,7 @@ class Spotlight(VMobject):self.add(self.source_point)- if self.screen != None:+ if self.screen is not None:# look for the screen and create annular sectorslower_angle, upper_angle = self.viewing_angles(self.screen)self.radius = float(self.radius)@@ -213,18 +200,18 @@ class Spotlight(VMobject):lower_ray, upper_ray = self.viewing_rays(self.screen)for r in np.arange(0, self.radius, dr):- new_sector = self.new_sector(r,dr,lower_angle,upper_angle)+ new_sector = self.new_sector(r, dr, lower_angle, upper_angle)self.add(new_sector)- def new_sector(self,r,dr,lower_angle,upper_angle):+ def new_sector(self, r, dr, lower_angle, upper_angle):alpha = self.max_opacity * self.opacity_function(r)annular_sector = AnnularSector(- inner_radius = r,- outer_radius = r + dr,- color = self.color,- fill_opacity = alpha,- start_angle = lower_angle,- angle = upper_angle - lower_angle+ inner_radius=r,+ outer_radius=r + dr,+ color=self.color,+ fill_opacity=alpha,+ start_angle=lower_angle,+ angle=upper_angle - lower_angle)# rotate (not project) it into the viewing planerotation_matrix = z_to_vector(self.projection_direction())@@ -232,13 +219,13 @@ class Spotlight(VMobject):# now rotate it inside that planerotated_RIGHT = np.dot(RIGHT, rotation_matrix.T)projected_RIGHT = self.project(RIGHT)- omega = angle_between_vectors(rotated_RIGHT,projected_RIGHT)- annular_sector.rotate(omega, axis = self.projection_direction())+ omega = angle_between_vectors(rotated_RIGHT, projected_RIGHT)+ annular_sector.rotate(omega, axis=self.projection_direction())annular_sector.move_arc_center_to(self.get_source_point())return annular_sector- def viewing_angle_of_point(self,point):+ def viewing_angle_of_point(self, point):# as measured from the positive x-axisv1 = self.project(RIGHT)v2 = self.project(np.array(point) - self.get_source_point())@@ -247,63 +234,66 @@ class Spotlight(VMobject):# choice of orientation. That choice is set by the camera# position, i. e. projection direction- if np.dot(self.projection_direction(),np.cross(v1, v2)) > 0:+ if np.dot(self.projection_direction(), np.cross(v1, v2)) > 0:return absolute_angleelse:return -absolute_angle- def viewing_angles(self,screen):+ def viewing_angles(self, screen):screen_points = screen.get_anchors()- projected_screen_points = map(self.project,screen_points)+ projected_screen_points = map(self.project, screen_points)viewing_angles = np.array(map(self.viewing_angle_of_point,- projected_screen_points))+ projected_screen_points))lower_angle = upper_angle = 0if len(viewing_angles) != 0:lower_angle = np.min(viewing_angles)upper_angle = np.max(viewing_angles)- if upper_angle - lower_angle > TAU/2:+ if upper_angle - lower_angle > TAU / 2:lower_angle, upper_angle = upper_angle, lower_angle + TAUreturn lower_angle, upper_angle- def viewing_rays(self,screen):+ def viewing_rays(self, screen):lower_angle, upper_angle = self.viewing_angles(screen)- projected_RIGHT = self.project(RIGHT)/np.linalg.norm(self.project(RIGHT))- lower_ray = rotate_vector(projected_RIGHT,lower_angle, axis = self.projection_direction())- upper_ray = rotate_vector(projected_RIGHT,upper_angle, axis = self.projection_direction())-+ projected_RIGHT = self.project(+ RIGHT) / np.linalg.norm(self.project(RIGHT))+ lower_ray = rotate_vector(+ projected_RIGHT, lower_angle, axis=self.projection_direction())+ upper_ray = rotate_vector(+ projected_RIGHT, upper_angle, axis=self.projection_direction())+return lower_ray, upper_raydef opening_angle(self):- l,u = self.viewing_angles(self.screen)+ l, u = self.viewing_angles(self.screen)return u - ldef start_angle(self):- l,u = self.viewing_angles(self.screen)+ l, u = self.viewing_angles(self.screen)return ldef stop_angle(self):- l,u = self.viewing_angles(self.screen)+ l, u = self.viewing_angles(self.screen)return u- def move_source_to(self,point):+ def move_source_to(self, point):self.source_point.set_location(np.array(point))- #self.source_point.move_to(np.array(point))- #self.move_to(point)+ # self.source_point.move_to(np.array(point))+ # self.move_to(point)self.update_sectors()return selfdef update_sectors(self):- if self.screen == None:+ if self.screen is None:returnfor submob in self.submobjects:if type(submob) == AnnularSector:lower_angle, upper_angle = self.viewing_angles(self.screen)- #dr = submob.outer_radius - submob.inner_radius+ # dr = submob.outer_radius - submob.inner_radiusdr = self.radius / self.num_levelsnew_submob = self.new_sector(submob.inner_radius, dr, lower_angle, upper_angle@@ -312,7 +302,7 @@ class Spotlight(VMobject):# submob.set_fill(opacity = 10 * self.opacity_function(submob.outer_radius))Transform(submob, new_submob).update(1)- def dimming(self,new_alpha):+ def dimming(self, new_alpha):old_alpha = self.max_opacityself.max_opacity = new_alphafor submob in self.submobjects:@@ -322,26 +312,28 @@ class Spotlight(VMobject):# it's the shadow, don't dim itcontinueold_submob_alpha = submob.fill_opacity- new_submob_alpha = old_submob_alpha * new_alpha/old_alpha- submob.set_fill(opacity = new_submob_alpha)+ new_submob_alpha = old_submob_alpha * new_alpha / old_alpha+ submob.set_fill(opacity=new_submob_alpha)- def change_opacity_function(self,new_f):+ def change_opacity_function(self, new_f):self.opacity_function = new_f- dr = self.radius/self.num_levels+ dr = self.radius / self.num_levelssectors = []for submob in self.submobjects:if type(submob) == AnnularSector:sectors.append(submob)- for (r,submob) in zip(np.arange(0,self.radius,dr),sectors):+ for (r, submob) in zip(np.arange(0, self.radius, dr), sectors):if type(submob) != AnnularSector:# it's the shadow, don't dim itcontinuealpha = self.opacity_function(r)- submob.set_fill(opacity = alpha)+ submob.set_fill(opacity=alpha)# Warning: This class is likely quite buggy.++class LightSource(VMobject):# combines:# a lighthouse@@ -349,12 +341,12 @@ class LightSource(VMobject):# a spotlight# and a shadowCONFIG = {- "source_point": VectorizedPoint(location = ORIGIN, stroke_width = 0, fill_opacity = 0),+ "source_point": VectorizedPoint(location=ORIGIN, stroke_width=0, fill_opacity=0),"color": LIGHT_COLOR,"num_levels": 10,"radius": 10.0,"screen": None,- "opacity_function": inverse_quadratic(1,2,1),+ "opacity_function": inverse_quadratic(1, 2, 1),"max_opacity_ambient": AMBIENT_FULL,"max_opacity_spotlight": SPOTLIGHT_FULL,"camera_mob": None@@ -366,39 +358,41 @@ class LightSource(VMobject):self.lighthouse = Lighthouse()self.ambient_light = AmbientLight(- source_point = VectorizedPoint(location = self.get_source_point()),- color = self.color,- num_levels = self.num_levels,- radius = self.radius,- opacity_function = self.opacity_function,- max_opacity = self.max_opacity_ambient+ source_point=VectorizedPoint(location=self.get_source_point()),+ color=self.color,+ num_levels=self.num_levels,+ radius=self.radius,+ opacity_function=self.opacity_function,+ max_opacity=self.max_opacity_ambient)if self.has_screen():self.spotlight = Spotlight(- source_point = VectorizedPoint(location = self.get_source_point()),- color = self.color,- num_levels = self.num_levels,- radius = self.radius,- screen = self.screen,- opacity_function = self.opacity_function,- max_opacity = self.max_opacity_spotlight,- camera_mob = self.camera_mob+ source_point=VectorizedPoint(location=self.get_source_point()),+ color=self.color,+ num_levels=self.num_levels,+ radius=self.radius,+ screen=self.screen,+ opacity_function=self.opacity_function,+ max_opacity=self.max_opacity_spotlight,+ camera_mob=self.camera_mob)else:self.spotlight = Spotlight()- self.shadow = VMobject(fill_color = SHADOW_COLOR, fill_opacity = 1.0, stroke_color = BLACK)- self.lighthouse.next_to(self.get_source_point(),DOWN,buff = 0)+ self.shadow = VMobject(fill_color=SHADOW_COLOR,+ fill_opacity=1.0, stroke_color=BLACK)+ self.lighthouse.next_to(self.get_source_point(), DOWN, buff=0)self.ambient_light.move_source_to(self.get_source_point())if self.has_screen():self.spotlight.move_source_to(self.get_source_point())self.update_shadow()- self.add(self.ambient_light,self.spotlight,self.lighthouse, self.shadow)+ self.add(self.ambient_light, self.spotlight,+ self.lighthouse, self.shadow)def has_screen(self):- if self.screen == None:+ if self.screen is None:return Falseelif np.size(self.screen.points) == 0:return False@@ -408,18 +402,18 @@ class LightSource(VMobject):def dim_ambient(self):self.set_max_opacity_ambient(AMBIENT_DIMMED)- def set_max_opacity_ambient(self,new_opacity):+ def set_max_opacity_ambient(self, new_opacity):self.max_opacity_ambient = new_opacityself.ambient_light.dimming(new_opacity)def dim_spotlight(self):self.set_max_opacity_spotlight(SPOTLIGHT_DIMMED)- def set_max_opacity_spotlight(self,new_opacity):+ def set_max_opacity_spotlight(self, new_opacity):self.max_opacity_spotlight = new_opacityself.spotlight.dimming(new_opacity)- def set_camera_mob(self,new_cam_mob):+ def set_camera_mob(self, new_cam_mob):self.camera_mob = new_cam_mobself.spotlight.camera_mob = new_cam_mob@@ -432,40 +426,40 @@ class LightSource(VMobject):camera_mob = self.spotlight.camera_mobself.remove(self.spotlight)self.spotlight = Spotlight(- source_point = VectorizedPoint(location = self.get_source_point()),- color = self.color,- num_levels = self.num_levels,- radius = self.radius,- screen = new_screen,- camera_mob = self.camera_mob,- opacity_function = self.opacity_function,- max_opacity = self.max_opacity_spotlight,+ source_point=VectorizedPoint(location=self.get_source_point()),+ color=self.color,+ num_levels=self.num_levels,+ radius=self.radius,+ screen=new_screen,+ camera_mob=self.camera_mob,+ opacity_function=self.opacity_function,+ max_opacity=self.max_opacity_spotlight,)self.spotlight.move_source_to(self.get_source_point())# Note: This line will make spotlight show up at the end# of the submojects list, which can make it show up on# top of the shadow. To make it show up in the- # same spot, you could try the following line,+ # same spot, you could try the following line,# where "index" is what I defined above:self.submobjects.insert(index, self.spotlight)- #self.add(self.spotlight)-+ # self.add(self.spotlight)+# in any caseself.screen = new_screen- def move_source_to(self,point):+ def move_source_to(self, point):apoint = np.array(point)v = apoint - self.get_source_point()# Note: As discussed, things stand to behave better if source# point is a submobject, so that it automatically interpolates- # during an animation, and other updates can be defined wrt+ # during an animation, and other updates can be defined wrt# that source point's locationself.source_point.set_location(apoint)- #self.lighthouse.next_to(apoint,DOWN,buff = 0)- #self.ambient_light.move_source_to(apoint)+ # self.lighthouse.next_to(apoint,DOWN,buff = 0)+ # self.ambient_light.move_source_to(apoint)self.lighthouse.shift(v)- #self.ambient_light.shift(v)+ # self.ambient_light.shift(v)self.ambient_light.move_source_to(apoint)if self.has_screen():self.spotlight.move_source_to(apoint)@@ -474,8 +468,8 @@ class LightSource(VMobject):def change_spotlight_opacity_function(self, new_of):self.spotlight.change_opacity_function(new_of)-- def set_radius(self,new_radius):++ def set_radius(self, new_radius):self.radius = new_radiusself.ambient_light.radius = new_radiusself.spotlight.radius = new_radius@@ -496,12 +490,12 @@ class LightSource(VMobject):def update_ambient(self):new_ambient_light = AmbientLight(- source_point = VectorizedPoint(location = ORIGIN),- color = self.color,- num_levels = self.num_levels,- radius = self.radius,- opacity_function = self.opacity_function,- max_opacity = self.max_opacity_ambient+ source_point=VectorizedPoint(location=ORIGIN),+ color=self.color,+ num_levels=self.num_levels,+ radius=self.radius,+ opacity_function=self.opacity_function,+ max_opacity=self.max_opacity_ambient)new_ambient_light.apply_matrix(self.rotation_matrix())new_ambient_light.move_source_to(self.get_source_point())@@ -512,13 +506,12 @@ class LightSource(VMobject):def rotation_matrix(self):- if self.camera_mob == None:+ if self.camera_mob is None:return np.eye(3)phi = self.camera_mob.get_center()[0]theta = self.camera_mob.get_center()[1]-R1 = np.array([[1, 0, 0],[0, np.cos(phi), -np.sin(phi)],@@ -526,8 +519,8 @@ class LightSource(VMobject):])R2 = np.array([- [np.cos(theta + TAU/4), -np.sin(theta + TAU/4), 0],- [np.sin(theta + TAU/4), np.cos(theta + TAU/4), 0],+ [np.cos(theta + TAU / 4), -np.sin(theta + TAU / 4), 0],+ [np.sin(theta + TAU / 4), np.cos(theta + TAU / 4), 0],[0, 0, 1]])@@ -542,28 +535,31 @@ class LightSource(VMobject):for point in self.screen.get_anchors():projected_screen_points.append(self.spotlight.project(point))-- projected_source = project_along_vector(self.get_source_point(),self.spotlight.projection_direction())+ projected_source = project_along_vector(+ self.get_source_point(), self.spotlight.projection_direction())projected_point_cloud_3d = np.append(projected_screen_points,- np.reshape(projected_source,(1,3)),- axis = 0+ np.reshape(projected_source, (1, 3)),+ axis=0)- rotation_matrix = self.rotation_matrix() # z_to_vector(self.spotlight.projection_direction())- back_rotation_matrix = rotation_matrix.T # i. e. its inverse+ # z_to_vector(self.spotlight.projection_direction())+ rotation_matrix = self.rotation_matrix()+ back_rotation_matrix = rotation_matrix.T # i. e. its inverse- rotated_point_cloud_3d = np.dot(projected_point_cloud_3d,back_rotation_matrix.T)+ rotated_point_cloud_3d = np.dot(+ projected_point_cloud_3d, back_rotation_matrix.T)# these points now should all have z = 0- point_cloud_2d = rotated_point_cloud_3d[:,:2]+ point_cloud_2d = rotated_point_cloud_3d[:, :2]# now we can compute the convex hull- hull_2d = ConvexHull(point_cloud_2d) # guaranteed to run ccw+ hull_2d = ConvexHull(point_cloud_2d) # guaranteed to run ccwhull = []# we also need the projected source point- source_point_2d = np.dot(self.spotlight.project(self.get_source_point()),back_rotation_matrix.T)[:2]-+ source_point_2d = np.dot(self.spotlight.project(+ self.get_source_point()), back_rotation_matrix.T)[:2]+index = 0for point in point_cloud_2d[hull_2d.vertices]:if np.all(np.abs(point - source_point_2d) < 1.0e-6):@@ -574,35 +570,35 @@ class LightSource(VMobject):hull.append(point_3d)index += 1-hull_mobject = VMobject()hull_mobject.set_points_as_corners(hull)hull_mobject.apply_matrix(rotation_matrix)-anchors = hull_mobject.get_anchors()# add two control points for the outer cone- if np.size(anchors) == 0:+ if np.size(anchors) == 0:self.shadow.points = []returnray1 = anchors[source_index - 1] - projected_source- ray1 = ray1/np.linalg.norm(ray1) * 100+ ray1 = ray1 / np.linalg.norm(ray1) * 100ray2 = anchors[source_index] - projected_source- ray2 = ray2/np.linalg.norm(ray2) * 100+ ray2 = ray2 / np.linalg.norm(ray2) * 100outpoint1 = anchors[source_index - 1] + ray1outpoint2 = anchors[source_index] + ray2new_anchors = anchors[:source_index]- new_anchors = np.append(new_anchors,np.array([outpoint1, outpoint2]),axis = 0)- new_anchors = np.append(new_anchors,anchors[source_index:],axis = 0)+ new_anchors = np.append(new_anchors, np.array(+ [outpoint1, outpoint2]), axis=0)+ new_anchors = np.append(new_anchors, anchors[source_index:], axis=0)self.shadow.set_points_as_corners(new_anchors)# shift it closer to the camera so it is in front of the spotlightself.shadow.mark_paths_closed = True+class ScreenTracker(ContinualAnimation):def __init__(self, light_source, **kwargs):self.light_source = light_source@@ -611,20 +607,3 @@ class ScreenTracker(ContinualAnimation):def update_mobject(self, dt):self.light_source.update()-----------------diff --git a/once_useful_constructs/matrix_multiplication.py b/once_useful_constructs/matrix_multiplication.pyindex a7067cb56..45fe59ee1 100644--- a/once_useful_constructs/matrix_multiplication.py+++ b/once_useful_constructs/matrix_multiplication.py@@ -1,5 +1,7 @@import numpy as np+from constants import *+from animation.creation import ShowCreationfrom animation.transform import ApplyMethodfrom animation.creation import FadeOut@@ -11,12 +13,14 @@ from scene.scene import Scenefrom mobject.geometry import Circlefrom mobject.geometry import Line+class NumericalMatrixMultiplication(Scene):CONFIG = {- "left_matrix" : [[1, 2], [3, 4]],- "right_matrix" : [[5, 6], [7, 8]],- "use_parens" : True,+ "left_matrix": [[1, 2], [3, 4]],+ "right_matrix": [[5, 6], [7, 8]],+ "use_parens": True,}+def construct(self):left_string_matrix, right_string_matrix = [np.array(matrix).astype("string")@@ -34,25 +38,24 @@ class NumericalMatrixMultiplication(Scene):self.organize_matrices(left, right, result)self.animate_product(left, right, result)-def get_result_matrix(self, left, right):(m, k), n = left.shape, right.shape[1]- mob_matrix = np.array([VGroup()]).repeat(m*n).reshape((m, n))+ mob_matrix = np.array([VGroup()]).repeat(m * n).reshape((m, n))for a in range(m):for b in range(n):template = "(%s)(%s)" if self.use_parens else "%s%s"parts = [- prefix + template%(left[a][c], right[c][b])+ prefix + template % (left[a][c], right[c][b])for c in range(k)for prefix in ["" if c == 0 else "+"]]- mob_matrix[a][b] = TexMobject(parts, next_to_buff = 0.1)+ mob_matrix[a][b] = TexMobject(parts, next_to_buff=0.1)return Matrix(mob_matrix)def add_lines(self, left, right):line_kwargs = {- "color" : BLUE,- "stroke_width" : 2,+ "color": BLUE,+ "stroke_width": 2,}left_rows = [VGroup(*row) for row in left.get_mob_matrix()@@ -60,7 +63,7 @@ class NumericalMatrixMultiplication(Scene):h_lines = VGroup()for row in left_rows[:-1]:h_line = Line(row.get_left(), row.get_right(), **line_kwargs)- h_line.next_to(row, DOWN, buff = left.v_buff/2.)+ h_line.next_to(row, DOWN, buff=left.v_buff / 2.)h_lines.add(h_line)right_cols = [@@ -69,7 +72,7 @@ class NumericalMatrixMultiplication(Scene):v_lines = VGroup()for col in right_cols[:-1]:v_line = Line(col.get_top(), col.get_bottom(), **line_kwargs)- v_line.next_to(col, RIGHT, buff = right.h_buff/2.)+ v_line.next_to(col, RIGHT, buff=right.h_buff / 2.)v_lines.add(v_line)self.play(ShowCreation(h_lines))@@ -81,17 +84,16 @@ class NumericalMatrixMultiplication(Scene):equals = TexMobject("=")everything = VGroup(left, right, equals, result)everything.arrange_submobjects()- everything.scale_to_fit_width(FRAME_WIDTH-1)+ everything.scale_to_fit_width(FRAME_WIDTH - 1)self.add(everything)-def animate_product(self, left, right, result):l_matrix = left.get_mob_matrix()r_matrix = right.get_mob_matrix()result_matrix = result.get_mob_matrix()circle = Circle(- radius = l_matrix[0][0].get_height(),- color = GREEN+ radius=l_matrix[0][0].get_height(),+ color=GREEN)circles = VGroup(*[entry.get_point_mobject()@@ -120,10 +122,10 @@ class NumericalMatrixMultiplication(Scene):self.play(Transform(circles, new_circles))self.play(Transform(- start_parts,- result_entry.copy().set_color(YELLOW),- path_arc = -np.pi/2,- submobject_mode = "all_at_once",+ start_parts,+ result_entry.copy().set_color(YELLOW),+ path_arc=-np.pi / 2,+ submobject_mode="all_at_once",),*lagging_anims)@@ -137,4 +139,4 @@ class NumericalMatrixMultiplication(Scene):l_matrix[a][c].set_color(WHITE)r_matrix[c][b].set_color(WHITE)self.play(FadeOut(circles), *lagging_anims)- self.wait()\ No newline at end of file+ self.wait()diff --git a/once_useful_constructs/region.py b/once_useful_constructs/region.pyindex 13fac5be6..2507f4492 100644--- a/once_useful_constructs/region.py+++ b/once_useful_constructs/region.py@@ -1,6 +1,4 @@-import numpy as npimport itertools as it-from PIL import Imagefrom copy import deepcopyfrom mobject.mobject import Mobject@@ -10,11 +8,13 @@ from constants import *# Warning: This is all now pretty depricated, and should not be expected to work+class Region(Mobject):CONFIG = {- "display_mode" : "region"+ "display_mode": "region"}- def __init__(self, condition = (lambda x, y : True), **kwargs):++ def __init__(self, condition=(lambda x, y: True), **kwargs):"""Condition must be a function which takes in two realarrays (representing x and y values of space respectively)@@ -26,25 +26,26 @@ class Region(Mobject):self.condition = conditiondef _combine(self, region, op):- self.condition = lambda x, y : op(+ self.condition = lambda x, y: op(self.condition(x, y),region.condition(x, y))def union(self, region):- self._combine(region, lambda bg1, bg2 : bg1 | bg2)+ self._combine(region, lambda bg1, bg2: bg1 | bg2)return selfdef intersect(self, region):- self._combine(region, lambda bg1, bg2 : bg1 & bg2)+ self._combine(region, lambda bg1, bg2: bg1 & bg2)return selfdef complement(self):self.bool_grid = ~self.bool_gridreturn self+class HalfPlane(Region):- def __init__(self, point_pair, upper_left = True, *args, **kwargs):+ def __init__(self, point_pair, upper_left=True, *args, **kwargs):"""point_pair of the form [(x_0, y_0,...), (x_1, y_1,...)]@@ -56,16 +57,19 @@ class HalfPlane(Region):point_pair = list(point_pair)point_pair.reverse()(x0, y0), (x1, y1) = point_pair[0][:2], point_pair[1][:2]+def condition(x, y):- return (x1 - x0)*(y - y0) > (y1 - y0)*(x - x0)+ return (x1 - x0) * (y - y0) > (y1 - y0) * (x - x0)Region.__init__(self, condition, *args, **kwargs)+def region_from_line_boundary(*lines, **kwargs):reg = Region(**kwargs)for line in lines:reg.intersect(HalfPlane(line, **kwargs))return reg+def region_from_polygon_vertices(*vertices, **kwargs):return region_from_line_boundary(*adjacent_pairs(vertices), **kwargs)@@ -81,7 +85,7 @@ def plane_partition(*lines, **kwargs):half_planes = [HalfPlane(line, **kwargs) for line in lines]complements = [deepcopy(hp).complement() for hp in half_planes]num_lines = len(lines)- for bool_list in it.product(*[[True, False]]*num_lines):+ for bool_list in it.product(*[[True, False]] * num_lines):reg = Region(**kwargs)for i in range(num_lines):if bool_list[i]:@@ -92,6 +96,7 @@ def plane_partition(*lines, **kwargs):result.append(reg)return result+def plane_partition_from_points(*points, **kwargs):"""Returns list of regions cut out by the complete graph@@ -101,9 +106,3 @@ def plane_partition_from_points(*points, **kwargs):"""lines = [[p1, p2] for (p1, p2) in it.combinations(points, 2)]return plane_partition(*lines, **kwargs)------diff --git a/primes.py b/primes.pyindex 126a7b1be..447f61022 100644--- a/primes.py+++ b/primes.py@@ -1,5 +1,6 @@from big_ol_pile_of_manim_imports import *+def is_prime(n):for i in primes(n**0.5):@@ -8,6 +9,7 @@ def is_prime(n):return True+def primes(max_n):if max_n < 2:@@ -23,13 +25,14 @@ def primes(max_n):return p+def prime_factors(n):if is_prime(n):return [n]i = 0- primes_list = primes(n/2)+ primes_list = primes(n / 2)factors = []r = n@@ -38,7 +41,7 @@ def prime_factors(n):p = primes_list[i]if r % p == 0:factors.append(p)- r = r/p+ r = r / pelse:i += 1@@ -48,55 +51,58 @@ def prime_factors(n):RUN_TIME = 0.5DOWN_SHIFT = 0.0 * DOWN+class Primes(Scene):def construct(self):-+N = 100primes_list = np.array(primes(N))- palette = ["#FBA125", "#76CD42", "#30CCF5", "#9377C4", "#F95137",- # 2 3 5 7 11- "#1B442E", TEAL_E, MAROON_A, DARK_BROWN, PINK,- # 13 17 19 23 29- "#9C25FB", GREEN_E, MAROON_E, GOLD_E, GREEN_E,- # 31 37 41 43 47 # last prime to occur in a factorization- LIGHT_BROWN, DARK_BLUE, GREY_BROWN, GREEN_C, BLUE_C,- # 53 59 61 67 71- PURPLE_C, RED_C, YELLOW_E, TEAL_C, MAROON_C]+ palette = ["#FBA125", "#76CD42", "#30CCF5", "#9377C4", "#F95137",+ # 2 3 5 7 11+ "#1B442E", TEAL_E, MAROON_A, DARK_BROWN, PINK,+ # 13 17 19 23 29+ "#9C25FB", GREEN_E, MAROON_E, GOLD_E, GREEN_E,+ # 31 37 41 43 47 # last prime to occur in a factorization+ LIGHT_BROWN, DARK_BLUE, GREY_BROWN, GREEN_C, BLUE_C,+ # 53 59 61 67 71+ PURPLE_C, RED_C, YELLOW_E, TEAL_C, MAROON_C]# 73 79 83 89 97nb_primes = len(primes_list)print nb_primesprime_points_radius = 3.2- angles = np.arange(TAU/4, -3*TAU/4, -TAU/float(nb_primes))+ angles = np.arange(TAU / 4, -3 * TAU / 4, -TAU / float(nb_primes))print len(angles), anglesprime_points = [prime_points_radius * (np.cos(theta) * RIGHT- + np.sin(theta) * UP)- for theta in angles]+ + np.sin(theta) * UP)+ for theta in angles]print len(prime_points)wheel = Wheel()-+angles = [TAU]colors = [LIGHT_GREY]wheel.update_sectors(angles, colors)- wheel.rotate(-TAU/4).shift(DOWN_SHIFT)+ wheel.rotate(-TAU / 4).shift(DOWN_SHIFT)self.add(wheel)- number = DecimalNumber(1, num_decimal_points = 0).scale(2).shift(DOWN_SHIFT)+ number = DecimalNumber(1, num_decimal_points=0).scale(+ 2).shift(DOWN_SHIFT)self.add(number)self.wait(RUN_TIME)j = 0- for i in range(2,N+1):+ for i in range(2, N + 1):factors = prime_factors(i)- factor_indices = [np.where(primes_list == x)[0][0] for x in factors]+ factor_indices = [np.where(primes_list == x)[0][0]+ for x in factors]nb_sectors = float(len(factor_indices))new_angles = np.ones(nb_sectors) / nb_sectors * TAU@@ -104,16 +110,16 @@ class Primes(Scene):new_colors = []for index in factor_indices:new_colors.append(palette[index])-+self.play(- UpdateAngles(wheel, new_angles = new_angles, new_colors = new_colors,- run_time = RUN_TIME),- ChangeDecimalToValue(number, i, run_time = RUN_TIME)+ UpdateAngles(wheel, new_angles=new_angles, new_colors=new_colors,+ run_time=RUN_TIME),+ ChangeDecimalToValue(number, i, run_time=RUN_TIME))self.wait(RUN_TIME)if is_prime(i):- full_wheel = VGroup(wheel,number).copy()+ full_wheel = VGroup(wheel, number).copy()full_wheel_copy = full_wheel.copy()full_wheel_copy.scale(0.15).move_to(prime_points[j])print j@@ -123,47 +129,45 @@ class Primes(Scene):)--class Wheel(VMobject):CONFIG = {- "inner_radius" : 1.2,- "outer_radius" : 2.4,- "nb_sectors" : 25,- "colors" : [BLACK] * 25+ "inner_radius": 1.2,+ "outer_radius": 2.4,+ "nb_sectors": 25,+ "colors": [BLACK] * 25}def generate_points(self):- angle = TAU/self.nb_sectors- angle_range = np.arange(0,TAU,angle)+ angle = TAU / self.nb_sectors+ angle_range = np.arange(0, TAU, angle)for j in range(self.nb_sectors - len(angle_range)):angle_range = np.append(angle_range, TAU)self.colors.append(BLACK)- for (i,theta) in enumerate(angle_range):+ for (i, theta) in enumerate(angle_range):if theta != TAU:use_angle = angleelse:use_angle = 0sector = AnnularSector(- inner_radius = self.inner_radius,- outer_radius = self.outer_radius,- angle = use_angle,- start_angle = theta,- fill_color = self.colors[i],- fill_opacity = 1,- stroke_color = WHITE,- stroke_width = 5- ).rotate_about_origin(TAU/2, axis = UP).shift(DOWN_SHIFT)+ inner_radius=self.inner_radius,+ outer_radius=self.outer_radius,+ angle=use_angle,+ start_angle=theta,+ fill_color=self.colors[i],+ fill_opacity=1,+ stroke_color=WHITE,+ stroke_width=5+ ).rotate_about_origin(TAU / 2, axis=UP).shift(DOWN_SHIFT)self.add(sector)def update_sectors(self, new_angles, new_colors):if len(new_angles) > self.nb_sectors:raise "More angles than sectors!"-+for i in range(len(new_angles), self.nb_sectors):new_angles = np.append(new_angles, 0)new_colors.append(BLACK)@@ -172,30 +176,28 @@ class Wheel(VMobject):new_start_angles = -np.cumsum(new_angles) + new_angles- for (i,sector) in enumerate(self.submobjects):+ for (i, sector) in enumerate(self.submobjects):sector.angle = new_angles[i]sector.start_angle = new_start_angles[i]- sector.set_fill(color = new_colors[i])+ sector.set_fill(color=new_colors[i])sector.generate_points()- sector.rotate_about_origin(TAU/2, axis = UP).shift(DOWN_SHIFT)---+ sector.rotate_about_origin(TAU / 2, axis=UP).shift(DOWN_SHIFT)class UpdateAngles(Animation):- def __init__(self,mobject,**kwargs):+ def __init__(self, mobject, **kwargs):self.old_angles = []for (i, sector) in enumerate(mobject.submobjects):self.old_angles.append(sector.angle)self.old_angles = np.array(self.old_angles)- self.old_start_angles = np.cumsum(self.old_angles) - self.old_angles + TAU/4-+ self.old_start_angles = np.cumsum(+ self.old_angles) - self.old_angles + TAU / 4+digest_config(self, kwargs)- Animation.__init__(self,mobject,**kwargs)+ Animation.__init__(self, mobject, **kwargs)def update_submobject(self, submobject, starting_submobject, alpha):@@ -211,7 +213,8 @@ class UpdateAngles(Animation):self.new_angles = np.append(self.new_angles, 0)self.new_colors.append(BLACK)- self.new_start_angles = np.cumsum(self.new_angles) - self.new_angles + TAU/4+ self.new_start_angles = np.cumsum(+ self.new_angles) - self.new_angles + TAU / 4# this should be in __init__!# but has no effect there@@ -223,30 +226,15 @@ class UpdateAngles(Animation):self.new_start_angles[i], alpha)-interpolated_color = interpolate_color(self.mobject.colors[i],self.new_colors[i],alpha)- submobject.set_fill(color = interpolated_color)+ submobject.set_fill(color=interpolated_color)submobject.generate_points()- submobject.rotate_about_origin(TAU/2, axis = UP).shift(DOWN_SHIFT)+ submobject.rotate_about_origin(TAU / 2, axis=UP).shift(DOWN_SHIFT)if alpha > 0.95:self.mobject.colors[i] = self.new_colors[i]--------------diff --git a/scene/graph_scene.py b/scene/graph_scene.pyindex 41b77b558..3d014d625 100644--- a/scene/graph_scene.py+++ b/scene/graph_scene.py@@ -22,101 +22,103 @@ from utils.space_ops import angle_of_vector# TODO, this should probably reimplemented entirely, especially so as to# better reuse code from mobject/coordinate_systems+class GraphScene(Scene):CONFIG = {- "x_min" : -1,- "x_max" : 10,- "x_axis_width" : 9,- "x_tick_frequency" : 1,- "x_leftmost_tick" : None, #Change if different from x_min- "x_labeled_nums" : None,- "x_axis_label" : "$x$",- "y_min" : -1,- "y_max" : 10,- "y_axis_height" : 6,- "y_tick_frequency" : 1,- "y_bottom_tick" : None, #Change if different from y_min- "y_labeled_nums" : None,- "y_axis_label" : "$y$",- "axes_color" : GREY,- "graph_origin" : 2.5*DOWN + 4*LEFT,- "exclude_zero_label" : True,- "num_graph_anchor_points" : 25,- "default_graph_colors" : [BLUE, GREEN, YELLOW],- "default_derivative_color" : GREEN,- "default_input_color" : YELLOW,- "default_riemann_start_color" : BLUE,- "default_riemann_end_color" : GREEN,+ "x_min": -1,+ "x_max": 10,+ "x_axis_width": 9,+ "x_tick_frequency": 1,+ "x_leftmost_tick": None, # Change if different from x_min+ "x_labeled_nums": None,+ "x_axis_label": "$x$",+ "y_min": -1,+ "y_max": 10,+ "y_axis_height": 6,+ "y_tick_frequency": 1,+ "y_bottom_tick": None, # Change if different from y_min+ "y_labeled_nums": None,+ "y_axis_label": "$y$",+ "axes_color": GREY,+ "graph_origin": 2.5 * DOWN + 4 * LEFT,+ "exclude_zero_label": True,+ "num_graph_anchor_points": 25,+ "default_graph_colors": [BLUE, GREEN, YELLOW],+ "default_derivative_color": GREEN,+ "default_input_color": YELLOW,+ "default_riemann_start_color": BLUE,+ "default_riemann_end_color": GREEN,}+def setup(self):self.default_graph_colors_cycle = it.cycle(self.default_graph_colors)- def setup_axes(self, animate = False):- ##TODO, once eoc is done, refactor this to be less redundant.+ def setup_axes(self, animate=False):+ # TODO, once eoc is done, refactor this to be less redundant.x_num_range = float(self.x_max - self.x_min)- self.space_unit_to_x = self.x_axis_width/x_num_range+ self.space_unit_to_x = self.x_axis_width / x_num_rangeif self.x_labeled_nums is None:self.x_labeled_nums = []if self.x_leftmost_tick is None:self.x_leftmost_tick = self.x_minx_axis = NumberLine(- x_min = self.x_min,- x_max = self.x_max,- unit_size = self.space_unit_to_x,- tick_frequency = self.x_tick_frequency,- leftmost_tick = self.x_leftmost_tick,- numbers_with_elongated_ticks = self.x_labeled_nums,- color = self.axes_color+ x_min=self.x_min,+ x_max=self.x_max,+ unit_size=self.space_unit_to_x,+ tick_frequency=self.x_tick_frequency,+ leftmost_tick=self.x_leftmost_tick,+ numbers_with_elongated_ticks=self.x_labeled_nums,+ color=self.axes_color)- x_axis.shift(self.graph_origin - x_axis.number_to_point(0))+ x_axis.shift(self.graph_origin - x_axis.number_to_point(0))if len(self.x_labeled_nums) > 0:if self.exclude_zero_label:self.x_labeled_nums = filter(- lambda x : x != 0,+ lambda x: x != 0,self.x_labeled_nums)x_axis.add_numbers(*self.x_labeled_nums)if self.x_axis_label:x_label = TextMobject(self.x_axis_label)x_label.next_to(- x_axis.get_tick_marks(), UP+RIGHT,- buff = SMALL_BUFF+ x_axis.get_tick_marks(), UP + RIGHT,+ buff=SMALL_BUFF)x_label.shift_onto_screen()x_axis.add(x_label)self.x_axis_label_mob = x_labely_num_range = float(self.y_max - self.y_min)- self.space_unit_to_y = self.y_axis_height/y_num_range+ self.space_unit_to_y = self.y_axis_height / y_num_rangeif self.y_labeled_nums is None:self.y_labeled_nums = []if self.y_bottom_tick is None:self.y_bottom_tick = self.y_miny_axis = NumberLine(- x_min = self.y_min,- x_max = self.y_max,- unit_size = self.space_unit_to_y,- tick_frequency = self.y_tick_frequency,- leftmost_tick = self.y_bottom_tick,- numbers_with_elongated_ticks = self.y_labeled_nums,- color = self.axes_color,- line_to_number_vect = LEFT,+ x_min=self.y_min,+ x_max=self.y_max,+ unit_size=self.space_unit_to_y,+ tick_frequency=self.y_tick_frequency,+ leftmost_tick=self.y_bottom_tick,+ numbers_with_elongated_ticks=self.y_labeled_nums,+ color=self.axes_color,+ line_to_number_vect=LEFT,)- y_axis.shift(self.graph_origin-y_axis.number_to_point(0))- y_axis.rotate(np.pi/2, about_point = y_axis.number_to_point(0))+ y_axis.shift(self.graph_origin - y_axis.number_to_point(0))+ y_axis.rotate(np.pi / 2, about_point=y_axis.number_to_point(0))if len(self.y_labeled_nums) > 0:if self.exclude_zero_label:self.y_labeled_nums = filter(- lambda y : y != 0,+ lambda y: y != 0,self.y_labeled_nums)y_axis.add_numbers(*self.y_labeled_nums)if self.y_axis_label:y_label = TextMobject(self.y_axis_label)y_label.next_to(- y_axis.get_tick_marks(), UP+RIGHT,- buff = SMALL_BUFF+ y_axis.get_tick_marks(), UP + RIGHT,+ buff=SMALL_BUFF)y_label.shift_onto_screen()y_axis.add(y_label)@@ -131,20 +133,20 @@ class GraphScene(Scene):def coords_to_point(self, x, y):assert(hasattr(self, "x_axis") and hasattr(self, "y_axis"))- result = self.x_axis.number_to_point(x)[0]*RIGHT- result += self.y_axis.number_to_point(y)[1]*UP+ result = self.x_axis.number_to_point(x)[0] * RIGHT+ result += self.y_axis.number_to_point(y)[1] * UPreturn resultdef point_to_coords(self, point):- return (self.x_axis.point_to_number(point),+ return (self.x_axis.point_to_number(point),self.y_axis.point_to_number(point))def get_graph(- self, func,- color = None,- x_min = None,- x_max = None,- ):+ self, func,+ color=None,+ x_min=None,+ x_max=None,+ ):if color is None:color = self.default_graph_colors_cycle.next()if x_min is None:@@ -160,9 +162,9 @@ class GraphScene(Scene):return self.coords_to_point(x, y)graph = ParametricFunction(- parameterized_function,- color = color,- num_anchor_points = self.num_graph_anchor_points,+ parameterized_function,+ color=color,+ num_anchor_points=self.num_graph_anchor_points,)graph.underlying_function = funcreturn graph@@ -170,34 +172,36 @@ class GraphScene(Scene):def input_to_graph_point(self, x, graph):return self.coords_to_point(x, graph.underlying_function(x))- def angle_of_tangent(self, x, graph, dx = 0.01):- vect = self.input_to_graph_point(x + dx, graph) - self.input_to_graph_point(x, graph)+ def angle_of_tangent(self, x, graph, dx=0.01):+ vect = self.input_to_graph_point(+ x + dx, graph) - self.input_to_graph_point(x, graph)return angle_of_vector(vect)def slope_of_tangent(self, *args, **kwargs):return np.tan(self.angle_of_tangent(*args, **kwargs))- def get_derivative_graph(self, graph, dx = 0.01, **kwargs):+ def get_derivative_graph(self, graph, dx=0.01, **kwargs):if "color" not in kwargs:kwargs["color"] = self.default_derivative_color+def deriv(x):return self.slope_of_tangent(x, graph, dx) / self.space_unit_to_yreturn self.get_graph(deriv, **kwargs)def get_graph_label(- self,- graph,- label = "f(x)",- x_val = None,- direction = RIGHT,- buff = MED_SMALL_BUFF,- color = None,- ):+ self,+ graph,+ label="f(x)",+ x_val=None,+ direction=RIGHT,+ buff=MED_SMALL_BUFF,+ color=None,+ ):label = TexMobject(label)color = color or graph.get_color()label.set_color(color)if x_val is None:- #Search from right to left+ # Search from right to leftfor x in np.linspace(self.x_max, self.x_min, 100):point = self.input_to_graph_point(x, graph)if point[1] < FRAME_Y_RADIUS:@@ -206,26 +210,26 @@ class GraphScene(Scene):label.next_to(self.input_to_graph_point(x_val, graph),direction,- buff = buff+ buff=buff)label.shift_onto_screen()return labeldef get_riemann_rectangles(- self,+ 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=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_minx_max = x_max if x_max is not None else self.x_maxif start_color is None:@@ -233,47 +237,47 @@ class GraphScene(Scene):if end_color is None:end_color = self.default_riemann_end_colorrectangles = VGroup()- x_range = np.arange(x_min, x_max, dx)+ 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 = xelif input_sample_type == "right":- sample_input = x+dx+ sample_input = x + dxelse:raise Exception("Invalid input sample type")graph_point = self.input_to_graph_point(sample_input, graph)points = VGroup(*map(VectorizedPoint, [self.coords_to_point(x, 0),- self.coords_to_point(x+width_scale_factor*dx, 0),+ self.coords_to_point(x + width_scale_factor * dx, 0),graph_point]))rect = Rectangle()- rect.replace(points, stretch = True)+ 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)+ rect.set_fill(fill_color, opacity=fill_opacity)+ rect.set_stroke(stroke_color, width=stroke_width)rectangles.add(rect)return rectanglesdef get_riemann_rectangles_list(- self,+ self,graph,n_iterations,- max_dx = 0.5,- power_base = 2,- stroke_width = 1,+ max_dx=0.5,+ power_base=2,+ stroke_width=1,**kwargs- ):+ ):return [self.get_riemann_rectangles(- graph = graph,- dx = float(max_dx)/(power_base**n),- stroke_width = float(stroke_width)/(power_base**n),+ graph=graph,+ dx=float(max_dx) / (power_base**n),+ stroke_width=float(stroke_width) / (power_base**n),**kwargs)for n in range(n_iterations)@@ -281,17 +285,17 @@ class GraphScene(Scene):def transform_between_riemann_rects(self, curr_rects, new_rects, **kwargs):transform_kwargs = {- "run_time" : 2,- "submobject_mode" : "lagged_start"+ "run_time": 2,+ "submobject_mode": "lagged_start"}added_anims = kwargs.get("added_anims", [])transform_kwargs.update(kwargs)curr_rects.align_submobjects(new_rects)- x_coords = set() #Keep track of new repetitions+ x_coords = set() # Keep track of new repetitionsfor rect in curr_rects:x = rect.get_center()[0]if x in x_coords:- rect.set_fill(opacity = 0)+ rect.set_fill(opacity=0)else:x_coords.add(x)self.play(@@ -302,24 +306,24 @@ class GraphScene(Scene):def get_vertical_line_to_graph(self,x, graph,- line_class = Line,+ line_class=Line,**line_kwargs- ):+ ):if "color" not in line_kwargs:line_kwargs["color"] = graph.get_color()return line_class(self.coords_to_point(x, 0),self.input_to_graph_point(x, graph),**line_kwargs- )+ )def get_vertical_lines_to_graph(self, graph,- x_min = None,- x_max = None,- num_lines = 20,+ x_min=None,+ x_max=None,+ num_lines=20,**kwargs- ):+ ):x_min = x_min or self.x_minx_max = x_max or self.x_maxreturn VGroup(*[@@ -328,20 +332,20 @@ class GraphScene(Scene):])def get_secant_slope_group(- self,- x, graph,- dx = None,- dx_line_color = None,- df_line_color = None,- dx_label = None,- df_label = None,- include_secant_line = True,- secant_line_color = None,- secant_line_length = 10,- ):+ self,+ x, graph,+ dx=None,+ dx_line_color=None,+ df_line_color=None,+ dx_label=None,+ df_label=None,+ include_secant_line=True,+ secant_line_color=None,+ secant_line_length=10,+ ):"""Resulting group is of the form VGroup(- dx_line,+ dx_line,df_line,dx_label, (if applicable)df_label, (if applicable)@@ -354,21 +358,21 @@ class GraphScene(Scene):group = VGroup()group.kwargs = kwargs- dx = dx or float(self.x_max - self.x_min)/10+ dx = dx or float(self.x_max - self.x_min) / 10dx_line_color = dx_line_color or self.default_input_colordf_line_color = df_line_color or graph.get_color()p1 = self.input_to_graph_point(x, graph)- p2 = self.input_to_graph_point(x+dx, graph)- interim_point = p2[0]*RIGHT + p1[1]*UP+ p2 = self.input_to_graph_point(x + dx, graph)+ interim_point = p2[0] * RIGHT + p1[1] * UPgroup.dx_line = Line(p1, interim_point,- color = dx_line_color+ color=dx_line_color)group.df_line = Line(interim_point, p2,- color = df_line_color+ color=df_line_color)group.add(group.dx_line, group.df_line)@@ -383,8 +387,8 @@ class GraphScene(Scene):group.add(group.df_label)if len(labels) > 0:- max_width = 0.8*group.dx_line.get_width()- max_height = 0.8*group.df_line.get_height()+ max_width = 0.8 * group.dx_line.get_width()+ max_height = 0.8 * group.df_line.get_height()if labels.get_width() > max_width:labels.scale_to_fit_width(max_width)if labels.get_height() > max_height:@@ -392,40 +396,41 @@ class GraphScene(Scene):if dx_label is not None:group.dx_label.next_to(- group.dx_line,- np.sign(dx)*DOWN,- buff = group.dx_label.get_height()/2+ group.dx_line,+ np.sign(dx) * DOWN,+ buff=group.dx_label.get_height() / 2)group.dx_label.set_color(group.dx_line.get_color())if df_label is not None:group.df_label.next_to(- group.df_line,- np.sign(dx)*RIGHT,- buff = group.df_label.get_height()/2+ group.df_line,+ np.sign(dx) * RIGHT,+ buff=group.df_label.get_height() / 2)group.df_label.set_color(group.df_line.get_color())if include_secant_line:secant_line_color = secant_line_color or self.default_derivative_color- group.secant_line = Line(p1, p2, color = secant_line_color)+ group.secant_line = Line(p1, p2, color=secant_line_color)group.secant_line.scale_in_place(- secant_line_length/group.secant_line.get_length()+ secant_line_length / group.secant_line.get_length())group.add(group.secant_line)return groupdef animate_secant_slope_group_change(- self, secant_slope_group,- target_dx = None,- target_x = None,- run_time = 3,- added_anims = None,+ self, secant_slope_group,+ target_dx=None,+ target_x=None,+ run_time=3,+ added_anims=None,**anim_kwargs- ):+ ):if target_dx is None and target_x is None:- raise Exception("At least one of target_x and target_dx must not be None")+ raise Exception(+ "At least one of target_x and target_dx must not be None")if added_anims is None:added_anims = []@@ -435,6 +440,7 @@ class GraphScene(Scene):target_dx = start_dxif target_x is None:target_x = start_x+def update_func(group, alpha):dx = interpolate(start_dx, target_dx, alpha)x = interpolate(start_x, target_x, alpha)@@ -448,31 +454,10 @@ class GraphScene(Scene):self.play(UpdateFromAlphaFunc(secant_slope_group, update_func,- run_time = run_time,+ run_time=run_time,**anim_kwargs),*added_anims)secant_slope_group.kwargs["x"] = target_xsecant_slope_group.kwargs["dx"] = target_dx---------------------diff --git a/scene/moving_camera_scene.py b/scene/moving_camera_scene.pyindex 70f0f1587..f3f5ed74e 100644--- a/scene/moving_camera_scene.py+++ b/scene/moving_camera_scene.py@@ -6,10 +6,11 @@ from scene.scene import Scenefrom camera.moving_camera import MovingCamerafrom mobject.frame import ScreenRectangle+class MovingCameraScene(Scene):def setup(self):- self.camera_frame = ScreenRectangle(height = FRAME_HEIGHT)- self.camera_frame.set_stroke(width = 0)+ self.camera_frame = ScreenRectangle(height=FRAME_HEIGHT)+ self.camera_frame.set_stroke(width=0)self.camera = MovingCamera(self.camera_frame, **self.camera_config)@@ -22,4 +23,4 @@ class MovingCameraScene(Scene):# When the camera is moving, so is everything,return self.mobjectselse:- return moving_mobjects\ No newline at end of file+ return moving_mobjectsdiff --git a/scene/reconfigurable_scene.py b/scene/reconfigurable_scene.pyindex 555ad69db..f2a0c323c 100644--- a/scene/reconfigurable_scene.py+++ b/scene/reconfigurable_scene.py@@ -1,27 +1,27 @@from __future__ import absolute_import-import numpy as np-from scene.scene import Scenefrom animation.transform import Transformfrom mobject.mobject import Mobjectfrom constants import *+class ReconfigurableScene(Scene):CONFIG = {- "allow_recursion" : True,+ "allow_recursion": True,}+def setup(self):self.states = []self.num_recursions = 0def transition_to_alt_config(- self,- return_to_original_configuration = True,- transformation_kwargs = None,+ self,+ return_to_original_configuration=True,+ transformation_kwargs=None,**new_config- ):+ ):if transformation_kwargs is None:transformation_kwargs = {}original_state = self.get_state()@@ -30,41 +30,37 @@ class ReconfigurableScene(Scene):if not self.allow_recursion:returnalt_scene = self.__class__(- skip_animations = True,- allow_recursion = False,+ skip_animations=True,+ allow_recursion=False,**new_config)- alt_state = alt_scene.states[len(self.states)-1]+ alt_state = alt_scene.states[len(self.states) - 1]if return_to_original_configuration:self.clear()self.transition_between_states(- state_copy, alt_state,+ state_copy, alt_state,**transformation_kwargs)self.transition_between_states(- state_copy, original_state,+ state_copy, original_state,**transformation_kwargs)self.clear()self.add(*original_state)else:self.transition_between_states(- original_state, alt_state,+ original_state, alt_state,**transformation_kwargs)self.__dict__.update(new_config)def get_state(self):- # Want to return a mobject that maintains the most+ # Want to return a mobject that maintains the most# structure. The way to do that is to extract only# those that aren't inside another.- top_level_mobjects = self.get_top_level_mobjects()return Mobject(*self.get_top_level_mobjects())def transition_between_states(self, start_state, target_state, **kwargs):self.play(Transform(start_state, target_state, **kwargs))self.wait()---diff --git a/scene/sample_space_scene.py b/scene/sample_space_scene.pyindex 53bc7cac7..b1fa129fc 100644--- a/scene/sample_space_scene.py+++ b/scene/sample_space_scene.py@@ -21,10 +21,10 @@ class SampleSpaceScene(Scene):def get_division_change_animations(self, sample_space, parts, p_list,- dimension = 1,- new_label_kwargs = None,+ dimension=1,+ new_label_kwargs=None,**kwargs- ):+ ):if new_label_kwargs is None:new_label_kwargs = {}anims = []@@ -34,12 +34,12 @@ class SampleSpaceScene(Scene):vect = DOWN if dimension == 1 else RIGHTparts.generate_target()for part, p in zip(parts.target, p_list):- part.replace(space_copy, stretch = True)+ part.replace(space_copy, stretch=True)part.stretch(p, dimension)- parts.target.arrange_submobjects(vect, buff = 0)+ parts.target.arrange_submobjects(vect, buff=0)parts.target.move_to(space_copy)anims.append(MoveToTarget(parts))- if hasattr(parts, "labels") and parts.labels is not None:+ if hasattr(parts, "labels") and parts.labels is not None:label_kwargs = parts.label_kwargslabel_kwargs.update(new_label_kwargs)new_braces, new_labels = sample_space.get_subdivision_braces_and_labels(@@ -55,7 +55,7 @@ class SampleSpaceScene(Scene):assert(hasattr(self.sample_space, "horizontal_parts"))return self.get_division_change_animations(self.sample_space, self.sample_space.horizontal_parts, p_list,- dimension = 1,+ dimension=1,**kwargs)@@ -63,19 +63,19 @@ class SampleSpaceScene(Scene):assert(hasattr(self.sample_space, "vertical_parts"))return self.get_division_change_animations(self.sample_space, self.sample_space.vertical_parts, p_list,- dimension = 0,+ dimension=0,**kwargs)-+def get_conditional_change_anims(- self, sub_sample_space_index, value, post_rects = None,+ self, sub_sample_space_index, value, post_rects=None,**kwargs- ):+ ):parts = self.sample_space.horizontal_partssub_sample_space = parts[sub_sample_space_index]anims = self.get_division_change_animations(sub_sample_space, sub_sample_space.vertical_parts, value,- dimension = 0,+ dimension=0,**kwargs)if post_rects is not None:@@ -94,10 +94,10 @@ class SampleSpaceScene(Scene):for i in range(2)])- def get_posterior_rectangles(self, buff = MED_LARGE_BUFF):+ def get_posterior_rectangles(self, buff=MED_LARGE_BUFF):prior_rects = self.get_prior_rectangles()areas = [- rect.get_width()*rect.get_height()+ rect.get_width() * rect.get_height()for rect in prior_rects]total_area = sum(areas)@@ -105,19 +105,19 @@ class SampleSpaceScene(Scene):post_rects = prior_rects.copy()for rect, area in zip(post_rects, areas):- rect.stretch_to_fit_height(total_height * area/total_area)+ rect.stretch_to_fit_height(total_height * area / total_area)rect.stretch_to_fit_width(- area/rect.get_height()+ area / rect.get_height())- post_rects.arrange_submobjects(DOWN, buff = 0)+ post_rects.arrange_submobjects(DOWN, buff=0)post_rects.next_to(self.sample_space, RIGHT, buff)return post_rectsdef get_posterior_rectangle_braces_and_labels(- self, post_rects, labels, direction = RIGHT, **kwargs- ):+ self, post_rects, labels, direction=RIGHT, **kwargs+ ):return self.sample_space.get_subdivision_braces_and_labels(post_rects, labels, direction, **kwargs)@@ -132,7 +132,7 @@ class SampleSpaceScene(Scene):def get_posterior_rectangle_change_anims(self, post_rects):def update_rects(rects):- new_rects = self.get_posterior_rectangles()+ new_rects = self.get_posterior_rectangles()Transform(rects, new_rects).update(1)if hasattr(rects, "braces"):self.update_posterior_braces(rects)diff --git a/scene/scene.py b/scene/scene.pyindex 1817a326f..6a3db7626 100644--- a/scene/scene.py+++ b/scene/scene.py@@ -1,4 +1,3 @@-import copyimport inspectimport itertools as itimport numpy as np@@ -6,11 +5,8 @@ import osimport randomimport shutilimport subprocess as sp-import timeimport warnings-from PIL import Image-from colour import Colorfrom tqdm import tqdm as ProgressDisplayfrom constants import *@@ -20,11 +16,11 @@ from animation.transform import MoveToTargetfrom camera.camera import Camerafrom continual_animation.continual_animation import ContinualAnimationfrom mobject.mobject import Mobject-from mobject.types.vectorized_mobject import VMobjectfrom utils.iterables import list_updatefrom container.container import Container+def add_extension_if_not_present(file_name, extension):# This could conceivably be smarter about handling existing differing extensionsif(file_name[-len(extension):] != extension):@@ -32,29 +28,32 @@ def add_extension_if_not_present(file_name, extension):else:return file_name+class Scene(Container):CONFIG = {- "camera_class" : Camera,- "camera_config" : {},- "frame_duration" : LOW_QUALITY_FRAME_DURATION,- "construct_args" : [],- "skip_animations" : False,- "ignore_waits" : False,- "write_to_movie" : False,- "save_frames" : False,- "save_pngs" : False,- "pngs_mode" : "RGBA",- "output_directory" : ANIMATIONS_DIR,- "movie_file_extension" : ".mp4",- "name" : None,- "always_continually_update" : False,- "random_seed" : 0,- "start_at_animation_number" : None,- "end_at_animation_number" : None,- "include_render_quality_in_output_directory" : True,+ "camera_class": Camera,+ "camera_config": {},+ "frame_duration": LOW_QUALITY_FRAME_DURATION,+ "construct_args": [],+ "skip_animations": False,+ "ignore_waits": False,+ "write_to_movie": False,+ "save_frames": False,+ "save_pngs": False,+ "pngs_mode": "RGBA",+ "output_directory": ANIMATIONS_DIR,+ "movie_file_extension": ".mp4",+ "name": None,+ "always_continually_update": False,+ "random_seed": 0,+ "start_at_animation_number": None,+ "end_at_animation_number": None,+ "include_render_quality_in_output_directory": True,}+def __init__(self, **kwargs):- Container.__init__(self, **kwargs) # Perhaps allow passing in a non-empty *mobjects parameter?+ # Perhaps allow passing in a non-empty *mobjects parameter?+ Container.__init__(self, **kwargs)self.camera = self.camera_class(**self.camera_config)self.mobjects = []self.continual_animations = []@@ -86,7 +85,7 @@ class Scene(Container):if self.write_to_movie:self.close_movie_pipe()- print("Played a total of %d animations"%self.num_plays)+ print("Played a total of %d animations" % self.num_plays)def setup(self):"""@@ -101,7 +100,7 @@ class Scene(Container):base.setup(self)def construct(self):- pass #To be implemented in subclasses+ pass # To be implemented in subclassesdef __str__(self):return self.name@@ -128,7 +127,7 @@ class Scene(Container):def get_attrs(self, *keys):return [getattr(self, key) for key in keys]- ### Only these methods should touch the camera+ # Only these methods should touch the cameradef set_camera(self, camera):self.camera = camera@@ -152,12 +151,12 @@ class Scene(Container):self.camera.capture_mobjects(mobjects, **kwargs)def update_frame(- self,- mobjects = None,- background = None,- include_submobjects = True,- dont_update_when_skipping = True,- **kwargs):+ self,+ mobjects=None,+ background=None,+ include_submobjects=True,+ dont_update_when_skipping=True,+ **kwargs):if self.skip_animations and dont_update_when_skipping:returnif mobjects is None:@@ -179,7 +178,7 @@ class Scene(Container):self.clear()###- def continual_update(self, dt = None):+ def continual_update(self, dt=None):if dt is None:dt = self.frame_durationfor continual_animation in self.continual_animations:@@ -190,10 +189,10 @@ class Scene(Container):for continual_animation in continual_animations:continual_animation.begin_wind_down(wind_down_time)self.wait(wind_down_time)- #TODO, this is not done with the remove method so as to- #keep the relevant mobjects. Better way?+ # TODO, this is not done with the remove method so as to+ # keep the relevant mobjects. Better way?self.continual_animations = filter(- lambda ca : ca in continual_animations,+ lambda ca: ca in continual_animations,self.continual_animations)@@ -207,6 +206,7 @@ class Scene(Container):# of another mobject from the scenemobjects = self.get_mobjects()families = [m.submobject_family() for m in mobjects]+def is_top_level(mobject):num_families = sum([(mobject in family)@@ -239,7 +239,7 @@ class Scene(Container):mobjects, continual_animations = self.separate_mobjects_and_continual_animations(mobjects_or_continual_animations)- self.restructure_mobjects(to_remove = mobjects)+ self.restructure_mobjects(to_remove=mobjects)self.mobjects += mobjectsself.continual_animations += continual_animationsreturn self@@ -249,7 +249,7 @@ class Scene(Container):So a scene can just add all mobjects it's defined up to that pointby calling add_mobjects_among(locals().values())"""- mobjects = filter(lambda x : isinstance(x, Mobject), values)+ mobjects = filter(lambda x: isinstance(x, Mobject), values)self.add(*mobjects)return self@@ -263,17 +263,17 @@ class Scene(Container):self.restructure_mobjects(mobjects, list_name, False)self.continual_animations = filter(- lambda ca : ca not in continual_animations and \- ca.mobject not in to_remove,+ lambda ca: ca not in continual_animations and+ ca.mobject not in to_remove,self.continual_animations)return selfdef restructure_mobjects(- self, to_remove,- mobject_list_name = "mobjects",- extract_families = True- ):+ self, to_remove,+ mobject_list_name="mobjects",+ extract_families=True+ ):"""In cases where the scene contains a group, e.g. Group(m1, m2, m3), but oneof its submobjects is removed, e.g. scene.remove(m1), the list of mobjects@@ -289,6 +289,7 @@ class Scene(Container):def get_restructured_mobject_list(self, mobjects, to_remove):new_mobjects = []+def add_safe_mobjects_from_list(list_to_examine, set_to_remove):for mob in list_to_examine:if mob in set_to_remove:@@ -364,7 +365,7 @@ class Scene(Container):run_time = np.max([animation.run_time for animation in animations])time_progression = self.get_time_progression(run_time)time_progression.set_description("".join([- "Animation %d: "%self.num_plays,+ "Animation %d: " % self.num_plays,str(animations[0]),(", etc." if len(animations) > 1 else ""),]))@@ -383,17 +384,18 @@ class Scene(Container):"""animations = []state = {- "curr_method" : None,- "last_method" : None,- "method_args" : [],+ "curr_method": None,+ "last_method": None,+ "method_args": [],}+def compile_method(state):if state["curr_method"] is None:returnmobject = state["curr_method"].im_selfif state["last_method"] and state["last_method"].im_self is mobject:animations.pop()- #method should already have target then.+ # method should already have target then.else:mobject.generate_target()#@@ -402,7 +404,7 @@ class Scene(Container):else:method_kwargs = {}state["curr_method"].im_func(- mobject.target,+ mobject.target,*state["method_args"],**method_kwargs)@@ -453,7 +455,7 @@ class Scene(Container):# Paint all non-moving objects onto the screen, so they don't# have to be rendered every frame- self.update_frame(excluded_mobjects = moving_mobjects)+ self.update_frame(excluded_mobjects=moving_mobjects)static_image = self.get_frame()for t in self.get_animation_time_progression(animations):for animation in animations:@@ -484,27 +486,28 @@ class Scene(Container):return self.mobjects_from_last_animationreturn []- def wait(self, duration = DEFAULT_WAIT_TIME):+ def wait(self, duration=DEFAULT_WAIT_TIME):if self.should_continually_update():for t in self.get_time_progression(duration):self.continual_update()self.update_frame()self.add_frames(self.get_frame())elif self.skip_animations:- #Do nothing+ # Do nothingreturn selfelse:self.update_frame()- self.add_frames(*[self.get_frame()]*int(duration / self.frame_duration))+ self.add_frames(*[self.get_frame()] *+ int(duration / self.frame_duration))return self- def wait_to(self, time, assert_positive = True):- if self.ignore_waits:+ def wait_to(self, time, assert_positive=True):+ if self.ignore_waits:returntime -= self.current_scene_time- if assert_positive:+ if assert_positive:assert(time >= 0)- elif time < 0:+ elif time < 0:returnself.wait(time)@@ -522,23 +525,24 @@ class Scene(Container):def add_frames(self, *frames):if self.skip_animations:return- self.current_scene_time += len(frames)*self.frame_duration+ self.current_scene_time += len(frames) * self.frame_durationif self.write_to_movie:for frame in frames:if self.save_pngs:- self.save_image("frame" + str(self.frame_num), self.pngs_mode, True)+ self.save_image(+ "frame" + str(self.frame_num), self.pngs_mode, True)self.frame_num = self.frame_num + 1self.writing_process.stdin.write(frame.tostring())if self.save_frames:self.saved_frames += list(frames)- #Display methods+ # Display methodsdef show_frame(self):- self.update_frame(dont_update_when_skipping = False)+ self.update_frame(dont_update_when_skipping=False)self.get_image().show()- def get_image_file_path(self, name = None, dont_update = False):+ def get_image_file_path(self, name=None, dont_update=False):folder = "images"if dont_update:folder = str(self)@@ -546,23 +550,23 @@ class Scene(Container):file_name = add_extension_if_not_present(name or str(self), ".png")return os.path.join(path, file_name)- def save_image(self, name = None, mode = "RGB", dont_update = False):+ def save_image(self, name=None, mode="RGB", dont_update=False):path = self.get_image_file_path(name, dont_update)directory_path = os.path.dirname(path)if not os.path.exists(directory_path):os.makedirs(directory_path)if not dont_update:- self.update_frame(dont_update_when_skipping = False)+ self.update_frame(dont_update_when_skipping=False)image = self.get_image()image = image.convert(mode)image.save(path)- def get_movie_file_path(self, name = None, extension = None):+ def get_movie_file_path(self, name=None, extension=None):directory = self.output_directoryif self.include_render_quality_in_output_directory:- sub_dir = "%dp%d"%(+ sub_dir = "%dp%d" % (self.camera.pixel_shape[0],- int(1.0/self.frame_duration)+ int(1.0 / self.frame_duration))directory = os.path.join(directory, sub_dir)if not os.path.exists(directory):@@ -581,21 +585,21 @@ class Scene(Container):name = str(self)file_path = self.get_movie_file_path(name)temp_file_path = file_path.replace(name, name + "Temp")- print("Writing to %s"%temp_file_path)+ print("Writing to %s" % temp_file_path)self.args_to_rename_file = (temp_file_path, file_path)- fps = int(1/self.frame_duration)+ fps = int(1 / self.frame_duration)height, width = self.camera.pixel_shape-+command = [FFMPEG_BIN,- '-y', # overwrite output file if it exists+ '-y', # overwrite output file if it exists'-f', 'rawvideo',- '-s', '%dx%d'%(width, height), # size of one frame+ '-s', '%dx%d' % (width, height), # size of one frame'-pix_fmt', 'rgba',- '-r', str(fps), # frames per second- '-i', '-', # The imput comes from a pipe- '-an', # Tells FFMPEG not to expect any audio+ '-r', str(fps), # frames per second+ '-i', '-', # The imput comes from a pipe+ '-an', # Tells FFMPEG not to expect any audio'-loglevel', 'error',]if self.movie_file_extension == ".mov":@@ -603,7 +607,7 @@ class Scene(Container):# should be transparent.command += ['-vcodec', 'png',- ]+ ]else:command += ['-vcodec', 'libx264',@@ -621,14 +625,6 @@ class Scene(Container):else:os.rename(*self.args_to_rename_file)+class EndSceneEarlyException(Exception):pass---------diff --git a/scene/scene_from_video.py b/scene/scene_from_video.pyindex aab35adec..8498b82c3 100644--- a/scene/scene_from_video.py+++ b/scene/scene_from_video.py@@ -1,8 +1,6 @@from __future__ import absolute_importimport cv2-import itertools as it-import numpy as npfrom tqdm import tqdm as show_progress@@ -11,25 +9,25 @@ from scene.scene import Sceneclass SceneFromVideo(Scene):def construct(self, file_name,- freeze_last_frame = True,- time_range = None):+ freeze_last_frame=True,+ time_range=None):cap = cv2.VideoCapture(file_name)self.shape = (int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT)),int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_WIDTH)))fps = cap.get(cv2.cv.CV_CAP_PROP_FPS)- self.frame_duration = 1.0/fps+ self.frame_duration = 1.0 / fpsframe_count = int(cap.get(cv2.cv.CV_CAP_PROP_FRAME_COUNT))if time_range is None:start_frame = 0end_frame = frame_countelse:- start_frame, end_frame = map(lambda t : fps*t, time_range)+ start_frame, end_frame = map(lambda t: fps * t, time_range)frame_count = end_frame - start_frameprint("Reading in " + file_name + "...")- for count in show_progress(range(start_frame, end_frame+1)):+ for count in show_progress(range(start_frame, end_frame + 1)):returned, frame = cap.read()if not returned:break@@ -41,18 +39,17 @@ class SceneFromVideo(Scene):if freeze_last_frame and len(self.frames) > 0:self.original_background = self.background = self.frames[-1]- def apply_gaussian_blur(self, ksize = (5, 5), sigmaX = 5):+ def apply_gaussian_blur(self, ksize=(5, 5), sigmaX=5):self.frames = [cv2.GaussianBlur(frame, ksize, sigmaX)for frame in self.frames]- def apply_edge_detection(self, threshold1 = 50, threshold2 = 100):+ def apply_edge_detection(self, threshold1=50, threshold2=100):edged_frames = [cv2.Canny(frame, threshold1, threshold2)for frame in self.frames]for index in range(len(self.frames)):for i in range(3):- self.frames[index][:,:,i] = edged_frames[index]-+ self.frames[index][:, :, i] = edged_frames[index]diff --git a/scene/three_d_scene.py b/scene/three_d_scene.pyindex 6896e55f8..c7dcb47b4 100644--- a/scene/three_d_scene.py+++ b/scene/three_d_scene.py@@ -5,8 +5,6 @@ from constants import *from continual_animation.continual_animation import ContinualMovementfrom animation.transform import ApplyMethodfrom camera.three_d_camera import ThreeDCamera-from mobject.types.vectorized_mobject import VGroup-from mobject.three_dimensions import should_shade_in_3dfrom scene.scene import Scenefrom utils.iterables import list_update@@ -14,19 +12,20 @@ from utils.iterables import list_updateclass ThreeDScene(Scene):CONFIG = {- "camera_class" : ThreeDCamera,- "ambient_camera_rotation" : None,+ "camera_class": ThreeDCamera,+ "ambient_camera_rotation": None,}- def set_camera_position(self, phi = None, theta = None, distance = None,- center_x = None, center_y = None, center_z = None):- self.camera.set_position(phi, theta, distance, center_x, center_y, center_z)+ def set_camera_position(self, phi=None, theta=None, distance=None,+ center_x=None, center_y=None, center_z=None):+ self.camera.set_position(phi, theta, distance,+ center_x, center_y, center_z)- def begin_ambient_camera_rotation(self, rate = 0.01):+ def begin_ambient_camera_rotation(self, rate=0.01):self.ambient_camera_rotation = ContinualMovement(self.camera.rotation_mobject,- direction = UP,- rate = rate+ direction=UP,+ rate=rate)self.add(self.ambient_camera_rotation)@@ -37,18 +36,19 @@ class ThreeDScene(Scene):def move_camera(self,- phi = None, theta = None, distance = None,- center_x = None, center_y = None, center_z = None,- added_anims = [],+ phi=None, theta=None, distance=None,+ center_x=None, center_y=None, center_z=None,+ added_anims=[],**kwargs- ):+ ):target_point = self.camera.get_spherical_coords(phi, theta, distance)movement = ApplyMethod(self.camera.rotation_mobject.move_to,target_point,**kwargs)- target_center = self.camera.get_center_of_rotation(center_x, center_y, center_z)+ target_center = self.camera.get_center_of_rotation(+ center_x, center_y, center_z)movement_center = ApplyMethod(self.camera.moving_center.move_to,target_center,diff --git a/scene/zoomed_scene.py b/scene/zoomed_scene.pyindex a5df8796c..d642fcc6c 100644--- a/scene/zoomed_scene.py+++ b/scene/zoomed_scene.py@@ -4,29 +4,29 @@ import numpy as npfrom scene.scene import Scenefrom animation.creation import FadeIn-from camera.camera import Camerafrom camera.moving_camera import MovingCamera-from mobject.mobject import Mobjectfrom mobject.geometry import Rectanglefrom constants import *+class ZoomedScene(Scene):"""Move around self.little_rectangle to determinewhich part of the screen is zoomed in on."""CONFIG = {- "zoomed_canvas_frame_shape" : (3, 3),- "zoomed_canvas_center" : None,- "zoomed_canvas_corner" : UP+RIGHT,- "zoomed_canvas_corner_buff" : DEFAULT_MOBJECT_TO_EDGE_BUFFER,- "zoomed_camera_background" : None,- "little_rectangle_start_position" : ORIGIN,- "zoom_factor" : 6,- "square_color" : WHITE,- "zoom_activated" : False,+ "zoomed_canvas_frame_shape": (3, 3),+ "zoomed_canvas_center": None,+ "zoomed_canvas_corner": UP + RIGHT,+ "zoomed_canvas_corner_buff": DEFAULT_MOBJECT_TO_EDGE_BUFFER,+ "zoomed_camera_background": None,+ "little_rectangle_start_position": ORIGIN,+ "zoom_factor": 6,+ "square_color": WHITE,+ "zoom_activated": False,}+def activate_zooming(self):self.generate_big_rectangle()self.setup_zoomed_canvas()@@ -52,47 +52,46 @@ class ZoomedScene(Scene):def generate_big_rectangle(self):height, width = self.zoomed_canvas_frame_shapeself.big_rectangle = Rectangle(- height = height,- width = width,- color = self.square_color+ height=height,+ width=width,+ color=self.square_color)if self.zoomed_canvas_center is not None:self.big_rectangle.shift(self.zoomed_canvas_center)elif self.zoomed_canvas_corner is not None:self.big_rectangle.to_corner(self.zoomed_canvas_corner,- buff = self.zoomed_canvas_corner_buff+ buff=self.zoomed_canvas_corner_buff)self.add(self.big_rectangle)-def setup_zoomed_canvas(self):- upper_left = self.big_rectangle.get_corner(UP+LEFT)- lower_right = self.big_rectangle.get_corner(DOWN+RIGHT)+ upper_left = self.big_rectangle.get_corner(UP + LEFT)+ lower_right = self.big_rectangle.get_corner(DOWN + RIGHT)pixel_coords = self.camera.points_to_pixel_coords(np.array([upper_left, lower_right]))self.zoomed_canvas_pixel_indices = pixel_coords(up, left), (down, right) = pixel_coordsself.zoomed_canvas_pixel_shape = (- right-left,- down-up,+ right - left,+ down - up,)def setup_zoomed_camera(self):self.little_rectangle = self.big_rectangle.copy()- self.little_rectangle.scale(1./self.zoom_factor)+ self.little_rectangle.scale(1. / self.zoom_factor)self.little_rectangle.move_to(self.little_rectangle_start_position)self.zoomed_camera = MovingCamera(self.little_rectangle,- pixel_shape = self.zoomed_canvas_pixel_shape,- background = self.zoomed_camera_background+ pixel_shape=self.zoomed_canvas_pixel_shape,+ background=self.zoomed_camera_background)self.add(self.little_rectangle)- #TODO, is there a better way to hanld this?- self.zoomed_camera.adjusted_thickness = lambda x : x+ # TODO, is there a better way to hanld this?+ self.zoomed_camera.adjusted_thickness = lambda x: xdef get_frame(self):frame = Scene.get_frame(self)@@ -105,11 +104,12 @@ class ZoomedScene(Scene):self.camera.set_pixel_array(pixel_array)if self.zoom_activated:(up, left), (down, right) = self.zoomed_canvas_pixel_indices- self.zoomed_camera.set_pixel_array(pixel_array[left:right, up:down])+ self.zoomed_camera.set_pixel_array(+ pixel_array[left:right, up:down])def set_camera_background(self, background):self.set_camera_pixel_array(self, background)- #TODO, check this...+ # TODO, check this...def reset_camera(self):self.camera.reset()@@ -125,7 +125,7 @@ class ZoomedScene(Scene):self.zoomed_camera.capture_mobjects(mobjects, **kwargs)-+def get_moving_mobjects(self, *animations):moving_mobjects = Scene.get_moving_mobjects(self, *animations)if self.zoom_activated and self.little_rectangle in moving_mobjects:@@ -133,8 +133,3 @@ class ZoomedScene(Scene):return self.mobjectselse:return moving_mobjects-----diff --git a/utils/bezier.py b/utils/bezier.pyindex cdce51987..6097e1306 100644--- a/utils/bezier.py+++ b/utils/bezier.py@@ -5,18 +5,20 @@ from utils.simple_functions import chooseCLOSED_THRESHOLD = 0.0+def bezier(points):n = len(points) - 1- return lambda t : sum([- ((1-t)**(n-k))*(t**k)*choose(n, k)*point+ return lambda t: sum([+ ((1 - t)**(n - k)) * (t**k) * choose(n, k) * pointfor k, point in enumerate(points)])+def partial_bezier_points(points, a, b):"""- Given an array of points which define+ Given an array of points which definea bezier curve, and two numbers 0<=a<b<=1,- return an array of the same size, which+ return an array of the same size, whichdescribes the portion of the original beziercurve on the interval [a, b].@@ -27,7 +29,7 @@ def partial_bezier_points(points, a, b):for i in range(len(points))])return np.array([- bezier(a_to_1[:i+1])((b-a)/(1.-a))+ bezier(a_to_1[:i + 1])((b - a) / (1. - a))for i in range(len(points))])@@ -35,20 +37,24 @@ def partial_bezier_points(points, a, b):# Linear interpolation variantsdef interpolate(start, end, alpha):- return (1-alpha)*start + alpha*end+ return (1 - alpha) * start + alpha * end+def mid(start, end):- return (start + end)/2.0+ return (start + end) / 2.0+def inverse_interpolate(start, end, value):return np.true_divide(value - start, end - start)+def match_interpolate(new_start, new_end, old_start, old_end, old_value):return interpolate(- new_start, new_end,+ new_start, new_end,inverse_interpolate(old_start, old_end, old_value))+def clamp(lower, upper, val):if val < lower:return lower@@ -58,70 +64,75 @@ def clamp(lower, upper, val):# Figuring out which bezier curves most smoothly connect a sequence of points+def get_smooth_handle_points(points):points = np.array(points)num_handles = len(points) - 1- dim = points.shape[1]+ dim = points.shape[1]if num_handles < 1:return np.zeros((0, dim)), np.zeros((0, dim))- #Must solve 2*num_handles equations to get the handles.- #l and u are the number of lower an upper diagonal rows- #in the matrix to solve.- l, u = 2, 1- #diag is a representation of the matrix in diagonal form- #See https://www.particleincell.com/2012/bezier-splines/- #for how to arive at these equations- diag = np.zeros((l+u+1, 2*num_handles))- diag[0,1::2] = -1- diag[0,2::2] = 1- diag[1,0::2] = 2- diag[1,1::2] = 1- diag[2,1:-2:2] = -2- diag[3,0:-3:2] = 1- #last- diag[2,-2] = -1- diag[1,-1] = 2- #This is the b as in Ax = b, where we are solving for x,- #and A is represented using diag. However, think of entries- #to x and b as being points in space, not numbers- b = np.zeros((2*num_handles, dim))- b[1::2] = 2*points[1:]+ # Must solve 2*num_handles equations to get the handles.+ # l and u are the number of lower an upper diagonal rows+ # in the matrix to solve.+ l, u = 2, 1+ # diag is a representation of the matrix in diagonal form+ # See https://www.particleincell.com/2012/bezier-splines/+ # for how to arive at these equations+ diag = np.zeros((l + u + 1, 2 * num_handles))+ diag[0, 1::2] = -1+ diag[0, 2::2] = 1+ diag[1, 0::2] = 2+ diag[1, 1::2] = 1+ diag[2, 1:-2:2] = -2+ diag[3, 0:-3:2] = 1+ # last+ diag[2, -2] = -1+ diag[1, -1] = 2+ # This is the b as in Ax = b, where we are solving for x,+ # and A is represented using diag. However, think of entries+ # to x and b as being points in space, not numbers+ b = np.zeros((2 * num_handles, dim))+ b[1::2] = 2 * points[1:]b[0] = points[0]b[-1] = points[-1]- solve_func = lambda b : linalg.solve_banded(- (l, u), diag, b- )++ def solve_func(b):+ return linalg.solve_banded((l, u), diag, b)if is_closed(points):- #Get equations to relate first and last points+ # Get equations to relate first and last pointsmatrix = diag_to_matrix((l, u), diag)- #last row handles second derivative+ # last row handles second derivativematrix[-1, [0, 1, -2, -1]] = [2, -1, 1, -2]- #first row handles first derivative- matrix[0,:] = np.zeros(matrix.shape[1])- matrix[0,[0, -1]] = [1, 1]- b[0] = 2*points[0]+ # first row handles first derivative+ matrix[0, :] = np.zeros(matrix.shape[1])+ matrix[0, [0, -1]] = [1, 1]+ b[0] = 2 * points[0]b[-1] = np.zeros(dim)- solve_func = lambda b : linalg.solve(matrix, b)- handle_pairs = np.zeros((2*num_handles, dim))++ def solve_func(b):+ return linalg.solve(matrix, b)+ handle_pairs = np.zeros((2 * num_handles, dim))for i in range(dim):- handle_pairs[:,i] = solve_func(b[:,i])+ handle_pairs[:, i] = solve_func(b[:, i])return handle_pairs[0::2], handle_pairs[1::2]+def diag_to_matrix(l_and_u, diag):"""- Converts array whose rows represent diagonal+ Converts array whose rows represent diagonalentries of a matrix into the matrix itself.See scipy.linalg.solve_banded"""l, u = l_and_udim = diag.shape[1]matrix = np.zeros((dim, dim))- for i in range(l+u+1):+ for i in range(l + u + 1):np.fill_diagonal(- matrix[max(0,i-u):,max(0,u-i):],- diag[i,max(0,u-i):]+ matrix[max(0, i - u):, max(0, u - i):],+ diag[i, max(0, u - i):])return matrix+def is_closed(points):- return np.linalg.norm(points[0] - points[-1]) < CLOSED_THRESHOLD\ No newline at end of file+ return np.linalg.norm(points[0] - points[-1]) < CLOSED_THRESHOLDdiff --git a/utils/color.py b/utils/color.pyindex a4e110829..a3df972e7 100644--- a/utils/color.py+++ b/utils/color.py@@ -7,33 +7,42 @@ from constants import PALETTEfrom utils.bezier import interpolate+def color_to_rgb(color):return np.array(Color(color).get_rgb())-def color_to_rgba(color, alpha = 1):++def color_to_rgba(color, alpha=1):return np.append(color_to_rgb(color), [alpha])+def rgb_to_color(rgb):try:- return Color(rgb = rgb)+ return Color(rgb=rgb)except:return Color(WHITE)+def rgba_to_color(rgba):return rgb_to_color(rgba[:3])+def rgb_to_hex(rgb):- return "#" + "".join('%02x'%int(255*x) for x in rgb)+ return "#" + "".join('%02x' % int(255 * x) for x in rgb)+def invert_color(color):return rgb_to_color(1.0 - color_to_rgb(color))+def color_to_int_rgb(color):- return (255*color_to_rgb(color)).astype('uint8')+ return (255 * color_to_rgb(color)).astype('uint8')-def color_to_int_rgba(color, alpha = 255):++def color_to_int_rgba(color, alpha=255):return np.append(color_to_int_rgb(color), alpha)+def color_gradient(reference_colors, length_of_output):if length_of_output == 0:return reference_colors[0]@@ -41,30 +50,34 @@ def color_gradient(reference_colors, length_of_output):alphas = np.linspace(0, (len(rgbs) - 1), length_of_output)floors = alphas.astype('int')alphas_mod1 = alphas % 1- #End edge case+ # End edge casealphas_mod1[-1] = 1floors[-1] = len(rgbs) - 2return [- rgb_to_color(interpolate(rgbs[i], rgbs[i+1], alpha))+ rgb_to_color(interpolate(rgbs[i], rgbs[i + 1], alpha))for i, alpha in zip(floors, alphas_mod1)]+def interpolate_color(color1, color2, alpha):rgb = interpolate(color_to_rgb(color1), color_to_rgb(color2), alpha)return rgb_to_color(rgb)+def average_color(*colors):rgbs = np.array(map(color_to_rgb, colors))mean_rgb = np.apply_along_axis(np.mean, 0, rgbs)return rgb_to_color(mean_rgb)+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)+ return Color(rgb=new_rgb)+def random_color():- return random.choice(PALETTE)\ No newline at end of file+ return random.choice(PALETTE)diff --git a/utils/config_ops.py b/utils/config_ops.pyindex 08ffc6565..f65a866f9 100644--- a/utils/config_ops.py+++ b/utils/config_ops.py@@ -1,14 +1,16 @@import inspectimport operator as op+def instantiate(obj):"""- Useful so that classes or instance of those classes can be+ Useful so that classes or instance of those classes can beincluded in configuration, which can prevent defaults fromgetting created during compilation/importing"""return obj() if isinstance(obj, type) else obj+def get_all_descendent_classes(Class):awaiting_review = [Class]result = []@@ -18,6 +20,7 @@ def get_all_descendent_classes(Class):result.append(Child)return result+def filtered_locals(caller_locals):result = caller_locals.copy()ignored_local_args = ["self", "kwargs"]@@ -25,12 +28,13 @@ def filtered_locals(caller_locals):result.pop(arg, caller_locals)return result-def digest_config(obj, kwargs, caller_locals = {}):++def digest_config(obj, kwargs, caller_locals={}):"""Sets init args and CONFIG values as local variables- The purpose of this function is to ensure that all- configuration of any object is inheritable, able to+ The purpose of this function is to ensure that all+ configuration of any object is inheritable, able tobe easily passed into instantiation, and is attachedas an attribute of the object."""@@ -44,16 +48,17 @@ def digest_config(obj, kwargs, caller_locals = {}):if hasattr(Class, "CONFIG"):static_configs.append(Class.CONFIG)- #Order matters a lot here, first dicts have higher priority+ # Order matters a lot here, first dicts have higher prioritycaller_locals = filtered_locals(caller_locals)all_dicts = [kwargs, caller_locals, obj.__dict__]all_dicts += static_configsall_new_dicts = [kwargs, caller_locals] + static_configsobj.__dict__ = merge_config(all_dicts)- #Keep track of the configuration of objects upon- #instantiation+ # Keep track of the configuration of objects upon+ # instantiationobj.initial_config = merge_config(all_new_dicts)+def merge_config(all_dicts):all_config = reduce(op.add, [d.items() for d in all_dicts])config = dict()@@ -62,11 +67,12 @@ def merge_config(all_dicts):if not key in config:config[key] = valueelse:- #When two dictionaries have the same key, they are merged.+ # When two dictionaries have the same key, they are merged.if isinstance(value, dict) and isinstance(config[key], dict):config[key] = merge_config([config[key], value])return config+def soft_dict_update(d1, d2):"""Adds key values pairs of d2 to d1 only when d1 doesn't@@ -76,7 +82,8 @@ def soft_dict_update(d1, d2):if key not in d1:d1[key] = value-def digest_locals(obj, keys = None):++def digest_locals(obj, keys=None):caller_locals = filtered_locals(inspect.currentframe().f_back.f_locals)@@ -85,31 +92,10 @@ def digest_locals(obj, keys = None):for key in keys:setattr(obj, key, caller_locals[key])-# Occasionally convenient in order to write dict.x instead of more laborious+# Occasionally convenient in order to write dict.x instead of more laborious# (and less in keeping with all other attr accesses) dict["x"]-class DictAsObject(object):- def __init__(self, dict):- self.__dict__ = dict---------------------+class DictAsObject(object):+ def __init__(self, dict):+ self.__dict__ = dictdiff --git a/utils/images.py b/utils/images.pyindex 9138166d8..38caf2454 100644--- a/utils/images.py+++ b/utils/images.py@@ -4,6 +4,7 @@ import osfrom PIL import Imagefrom constants import RASTER_IMAGE_DIR+def get_full_raster_image_path(image_file_name):possible_paths = [image_file_name,@@ -15,7 +16,8 @@ def get_full_raster_image_path(image_file_name):for path in possible_paths:if os.path.exists(path):return path- raise IOError("File %s not Found"%image_file_name)+ raise IOError("File %s not Found" % image_file_name)+def drag_pixels(frames):curr = frames[0]@@ -25,7 +27,8 @@ def drag_pixels(frames):new_frames.append(np.array(curr))return new_frames+def invert_image(image):arr = np.array(image)arr = (255 * np.ones(arr.shape)).astype(arr.dtype) - arr- return Image.fromarray(arr)\ No newline at end of file+ return Image.fromarray(arr)diff --git a/utils/iterables.py b/utils/iterables.pyindex f77aa45de..b21e3b5b9 100644--- a/utils/iterables.py+++ b/utils/iterables.py@@ -1,6 +1,7 @@import itertools as itimport numpy as np+def remove_list_redundancies(l):"""Used instead of list(set(l)) to maintain order@@ -9,27 +10,32 @@ def remove_list_redundancies(l):reversed_result = []used = set()for x in reversed(l):- if not x in used:+ if x not in used:reversed_result.append(x)used.add(x)reversed_result.reverse()return reversed_result+def list_update(l1, l2):"""Used instead of list(set(l1).update(l2)) to maintain order,making sure duplicates are removed from l1, not l2."""- return filter(lambda e : e not in l2, l1) + list(l2)+ return filter(lambda e: e not in l2, l1) + list(l2)+def list_difference_update(l1, l2):- return filter(lambda e : e not in l2, l1)+ return filter(lambda e: e not in l2, l1)+def all_elements_are_instances(iterable, Class):- return all(map(lambda e : isinstance(e, Class), iterable))+ return all(map(lambda e: isinstance(e, Class), iterable))+def adjacent_pairs(objects):- return zip(objects, list(objects[1:])+[objects[0]])+ return zip(objects, list(objects[1:]) + [objects[0]])+def batch_by_property(items, property_func):"""@@ -39,6 +45,7 @@ def batch_by_property(items, property_func):batches together would give the original list."""batch_prop_pairs = []+def add_batch_prop_pair(batch):if len(batch) > 0:batch_prop_pairs.append(@@ -57,6 +64,7 @@ def batch_by_property(items, property_func):add_batch_prop_pair(curr_batch)return batch_prop_pairs+def tuplify(obj):if isinstance(obj, str):return (obj,)@@ -65,14 +73,17 @@ def tuplify(obj):except:return (obj,)+def stretch_array_to_length(nparray, length):curr_len = len(nparray)if curr_len > length:- raise Warning("Trying to stretch array to a length shorter than its own")- indices = np.arange(length)/ float(length)+ raise Warning(+ "Trying to stretch array to a length shorter than its own")+ indices = np.arange(length) / float(length)indices *= curr_lenreturn nparray[indices.astype('int')]+def make_even(iterable_1, iterable_2):list_1, list_2 = list(iterable_1), list(iterable_2)length = max(len(list_1), len(list_2))@@ -81,6 +92,7 @@ def make_even(iterable_1, iterable_2):[list_2[(n * len(list_2)) / length] for n in xrange(length)])+def make_even_by_cycling(iterable_1, iterable_2):length = max(len(iterable_1), len(iterable_2))cycle1 = it.cycle(iterable_1)@@ -90,24 +102,23 @@ def make_even_by_cycling(iterable_1, iterable_2):[cycle2.next() for x in range(length)])+def composition(func_list):"""func_list should contain elements of the form (f, args)"""return reduce(- lambda (f1, args1), (f2, args2) : (lambda x : f1(f2(x, *args2), *args1)),+ lambda (f1, args1), (f2, args2): (lambda x: f1(f2(x, *args2), *args1)),func_list,- lambda x : x+ lambda x: x)-def remove_nones(sequence):- return filter(lambda x : x, sequence)--## Note this is redundant with it.chain-def concatenate_lists(*list_of_lists):- return [item for l in list_of_lists for item in l]-+def remove_nones(sequence):+ return filter(lambda x: x, sequence)+# Note this is redundant with it.chain+def concatenate_lists(*list_of_lists):+ return [item for l in list_of_lists for item in l]diff --git a/utils/paths.py b/utils/paths.pyindex fd4e6694c..229960a79 100644--- a/utils/paths.py+++ b/utils/paths.py@@ -6,6 +6,7 @@ from utils.space_ops import rotation_matrixSTRAIGHT_PATH_THRESHOLD = 0.01+def straight_path(start_points, end_points, alpha):"""Same function as interpolate, but renamed to reflect@@ -15,27 +16,31 @@ def straight_path(start_points, end_points, alpha):"""return interpolate(start_points, end_points, alpha)-def path_along_arc(arc_angle, axis = OUT):++def path_along_arc(arc_angle, axis=OUT):"""- If vect is vector from start to end, [vect[:,1], -vect[:,0]] is+ If vect is vector from start to end, [vect[:,1], -vect[:,0]] isperpendicular to vect in the left direction."""if abs(arc_angle) < STRAIGHT_PATH_THRESHOLD:return straight_pathif np.linalg.norm(axis) == 0:axis = OUT- unit_axis = axis/np.linalg.norm(axis)+ unit_axis = axis / np.linalg.norm(axis)+def path(start_points, end_points, alpha):vects = end_points - start_points- centers = start_points + 0.5*vects+ centers = start_points + 0.5 * vectsif arc_angle != np.pi:- centers += np.cross(unit_axis, vects/2.0)/np.tan(arc_angle/2)- rot_matrix = rotation_matrix(alpha*arc_angle, unit_axis)- return centers + np.dot(start_points-centers, rot_matrix.T)+ centers += np.cross(unit_axis, vects / 2.0) / np.tan(arc_angle / 2)+ rot_matrix = rotation_matrix(alpha * arc_angle, unit_axis)+ return centers + np.dot(start_points - centers, rot_matrix.T)return path+def clockwise_path():return path_along_arc(-np.pi)+def counterclockwise_path():- return path_along_arc(np.pi)\ No newline at end of file+ return path_along_arc(np.pi)diff --git a/utils/rate_functions.py b/utils/rate_functions.pyindex 566438bae..27da4ff10 100644--- a/utils/rate_functions.py+++ b/utils/rate_functions.py@@ -3,49 +3,60 @@ import numpy as npfrom utils.bezier import bezierfrom utils.simple_functions import sigmoid-def smooth(t, inflection = 10.0):++def smooth(t, inflection=10.0):error = sigmoid(-inflection / 2)- return (sigmoid(inflection*(t - 0.5)) - error) / (1 - 2*error)+ return (sigmoid(inflection * (t - 0.5)) - error) / (1 - 2 * error)+def rush_into(t):- return 2*smooth(t/2.0)+ return 2 * smooth(t / 2.0)+def rush_from(t):- return 2*smooth(t/2.0+0.5) - 1+ return 2 * smooth(t / 2.0 + 0.5) - 1+def slow_into(t):- return np.sqrt(1-(1-t)*(1-t))+ return np.sqrt(1 - (1 - t) * (1 - t))+def double_smooth(t):if t < 0.5:- return 0.5*smooth(2*t)+ return 0.5 * smooth(2 * t)else:- return 0.5*(1 + smooth(2*t - 1))+ return 0.5 * (1 + smooth(2 * t - 1))+-def there_and_back(t, inflection = 10.0):- new_t = 2*t if t < 0.5 else 2*(1 - t)+def there_and_back(t, inflection=10.0):+ new_t = 2 * t if t < 0.5 else 2 * (1 - t)return smooth(new_t, inflection)+def there_and_back_with_pause(t):- if t < 1./3:- return smooth(3*t)- elif t < 2./3:+ if t < 1. / 3:+ return smooth(3 * t)+ elif t < 2. / 3:return 1else:- return smooth(3 - 3*t)+ return smooth(3 - 3 * t)+-def running_start(t, pull_factor = -0.5):+def running_start(t, pull_factor=-0.5):return bezier([0, 0, pull_factor, pull_factor, 1, 1, 1])(t)-def not_quite_there(func = smooth, proportion = 0.7):++def not_quite_there(func=smooth, proportion=0.7):def result(t):- return proportion*func(t)+ return proportion * func(t)return result-def wiggle(t, wiggles = 2):- return there_and_back(t) * np.sin(wiggles*np.pi*t)-def squish_rate_func(func, a = 0.4, b = 0.6):+def wiggle(t, wiggles=2):+ return there_and_back(t) * np.sin(wiggles * np.pi * t)+++def squish_rate_func(func, a=0.4, b=0.6):def result(t):if a == b:return a@@ -55,15 +66,15 @@ def squish_rate_func(func, a = 0.4, b = 0.6):elif t > b:return func(1)else:- return func((t-a)/(b-a))-+ return func((t - a) / (b - a))+return result# Stylistically, should this take parameters (with default values)?# Ultimately, the functionality is entirely subsumed by squish_rate_func,-# but it may be useful to have a nice name for with nice default params for+# but it may be useful to have a nice name for with nice default params for# "lingering", different from squish_rate_func's default params-def lingering(t):- return squish_rate_func(lambda t: t, 0, 0.8)(t)+def lingering(t):+ return squish_rate_func(lambda t: t, 0, 0.8)(t)diff --git a/utils/simple_functions.py b/utils/simple_functions.pyindex 52acc014d..1dda6ff49 100644--- a/utils/simple_functions.py+++ b/utils/simple_functions.py@@ -1,27 +1,33 @@import numpy as npimport operator as op+def sigmoid(x):- return 1.0/(1 + np.exp(-x))+ return 1.0 / (1 + np.exp(-x))+def choose(n, r):- if n < r: return 0- if r == 0: return 1- denom = reduce(op.mul, xrange(1, r+1), 1)- numer = reduce(op.mul, xrange(n, n-r, -1), 1)- return numer//denom+ if n < r:+ return 0+ if r == 0:+ return 1+ denom = reduce(op.mul, xrange(1, r + 1), 1)+ numer = reduce(op.mul, xrange(n, n - r, -1), 1)+ return numer // denom# Just to have a less heavyweight name for this extremely common operation## We may wish to have more fine-grained control over division by zero behavior# in the future (separate specifiable values for 0/0 and x/0 with x != 0),# but for now, we just allow the option to handle indeterminate 0/0.-def fdiv(a, b, zero_over_zero_value = None):- if zero_over_zero_value != None:+++def fdiv(a, b, zero_over_zero_value=None):+ if zero_over_zero_value is not None:out = np.full_like(a, zero_over_zero_value)- where = np.logical_or (a != 0, b != 0)+ where = np.logical_or(a != 0, b != 0)else:out = Nonewhere = True- return np.true_divide(a, b, out = out, where = where)\ No newline at end of file+ return np.true_divide(a, b, out=out, where=where)diff --git a/utils/sounds.py b/utils/sounds.pyindex 28eb56d88..10b1faba3 100644--- a/utils/sounds.py+++ b/utils/sounds.py@@ -1,5 +1,6 @@import os+def play_chord(*nums):commands = ["play",@@ -8,10 +9,10 @@ def play_chord(*nums):"--no-show-progress","synth",] + [- "sin %-"+str(num)+ "sin %-" + str(num)for num in nums] + [- "fade h 0.5 1 0.5",+ "fade h 0.5 1 0.5","> /dev/null"]try:@@ -19,8 +20,10 @@ def play_chord(*nums):except:pass+def play_error_sound():play_chord(11, 8, 6, 1)+def play_finish_sound():- play_chord(12, 9, 5, 2)\ No newline at end of file+ play_chord(12, 9, 5, 2)diff --git a/utils/space_ops.py b/utils/space_ops.pyindex c9f1506ac..792d9539d 100644--- a/utils/space_ops.py+++ b/utils/space_ops.py@@ -3,12 +3,14 @@ import numpy as npfrom constants import OUTfrom constants import RIGHT-#Matrix operations+# Matrix operations-def thick_diagonal(dim, thickness = 2):++def thick_diagonal(dim, thickness=2):row_indices = np.arange(dim).repeat(dim).reshape((dim, dim))col_indices = np.transpose(row_indices)- return (np.abs(row_indices - col_indices)<thickness).astype('uint8')+ return (np.abs(row_indices - col_indices) < thickness).astype('uint8')+def rotation_matrix(angle, axis):"""@@ -19,16 +21,18 @@ def rotation_matrix(angle, axis):axis_to_z = np.linalg.inv(z_to_axis)return reduce(np.dot, [z_to_axis, about_z, axis_to_z])+def rotation_about_z(angle):return [[np.cos(angle), -np.sin(angle), 0],- [np.sin(angle), np.cos(angle), 0],+ [np.sin(angle), np.cos(angle), 0],[0, 0, 1]]+def z_to_vector(vector):"""- Returns some matrix in SO(3) which takes the z-axis to the+ Returns some matrix in SO(3) which takes the z-axis to the(normalized) vector provided as an argument"""norm = np.linalg.norm(vector)@@ -37,7 +41,7 @@ def z_to_vector(vector):v = np.array(vector) / normphi = np.arccos(v[2])if any(v[:2]):- #projection of vector to unit circle+ # projection of vector to unit circleaxis_proj = v[:2] / np.linalg.norm(v[:2])theta = np.arccos(axis_proj[0])if axis_proj[1] < 0:@@ -51,15 +55,18 @@ def z_to_vector(vector):])return np.dot(rotation_about_z(theta), phi_down)-def rotate_vector(vector, angle, axis = OUT):++def rotate_vector(vector, angle, axis=OUT):return np.dot(rotation_matrix(angle, axis), vector)+def angle_between(v1, v2):return np.arccos(np.dot(- v1 / np.linalg.norm(v1),+ v1 / np.linalg.norm(v1),v2 / np.linalg.norm(v2)))+def angle_of_vector(vector):"""Returns polar coordinate theta when vector is project on xy plane@@ -69,6 +76,7 @@ def angle_of_vector(vector):return 0return np.angle(complex(*vector[:2]))+def angle_between_vectors(v1, v2):"""Returns the angle between two 3D vectors.@@ -76,7 +84,8 @@ def angle_between_vectors(v1, v2):"""l1 = np.linalg.norm(v1)l2 = np.linalg.norm(v2)- return np.arccos(np.dot(v1,v2)/(l1*l2))+ return np.arccos(np.dot(v1, v2) / (l1 * l2))+def project_along_vector(point, vector):matrix = np.identity(3) - np.outer(vector, vector)@@ -84,20 +93,23 @@ def project_along_vector(point, vector):###-def compass_directions(n = 4, start_vect = RIGHT):- angle = 2*np.pi/n++def compass_directions(n=4, start_vect=RIGHT):+ angle = 2 * np.pi / nreturn np.array([- rotate_vector(start_vect, k*angle)+ rotate_vector(start_vect, k * angle)for k in range(n)])+def complex_to_R3(complex_num):return np.array((complex_num.real, complex_num.imag, 0))+def R3_to_complex(point):return complex(*point[:2])+def center_of_mass(points):points = [np.array(point).astype("float") for point in points]return sum(points) / len(points)-diff --git a/utils/strings.py b/utils/strings.pyindex 54eaae3ec..fdadf99b4 100644--- a/utils/strings.py+++ b/utils/strings.py@@ -1,22 +1,26 @@import reimport string+def to_camel_case(name):return "".join([filter(- lambda c : c not in string.punctuation + string.whitespace, part+ lambda c: c not in string.punctuation + string.whitespace, part).capitalize()for part in name.split("_")])-def initials(name, sep_values = [" ", "_"]):++def initials(name, sep_values=[" ", "_"]):return "".join([- (s[0] if s else "")+ (s[0] if s else "")for s in re.split("|".join(sep_values), name)])+def camel_case_initials(name):- return filter(lambda c : c.isupper(), name)+ return filter(lambda c: c.isupper(), name)+def complex_string(complex_num):- return filter(lambda c : c not in "()", str(complex_num))+ return filter(lambda c: c not in "()", str(complex_num))