Merge pull request #150 from 3b1b/WindingNumber

Winding number

animation/transform.py

@@ -168,9 +168,6 @@ class FadeOut(Transform):
     def __init__(self, mobject, **kwargs):
         target = mobject.copy()
         target.fade(1)
-        if isinstance(mobject, VMobject):
-            target.set_stroke(width = 0)
-            target.set_fill(opacity = 0)
         Transform.__init__(self, mobject, target, **kwargs)
 
     def clean_up(self, surrounding_scene = None):

helpers.py

@@ -359,6 +359,11 @@ def mid(start, end):
 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, 
+        inverse_interpolate(old_start, old_end, old_value))
+
 def clamp(lower, upper, val):
     if val < lower:
         return lower

mobject/mobject.py

@@ -527,16 +527,34 @@ class Mobject(Container):
         self.highlight(self.color)
         return self
 
-    def fade_to(self, color, alpha):
-        for mob in self.family_members_with_points():
-            start = color_to_rgb(mob.get_color())
+    # 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), 
+    # and then have fade() itself call this recursively on each submobject
+    #
+    # Similarly for fade_to_no_recurse and fade_to, the underlying functions
+    # used by default for fade()ing
+
+    def fade_to_no_recurse(self, color, alpha):
+        if self.get_num_points() > 0:
+            start = color_to_rgb(self.get_color())
             end = color_to_rgb(color)
             new_rgb = interpolate(start, end, alpha)
-            mob.highlight(Color(rgb = new_rgb), family = False)
+            self.highlight(Color(rgb = new_rgb), family = False)
+        return self
+
+    def fade_to(self, color, alpha):
+        for mob in self.subobject_family():
+            mob.fade_to_no_recurse(self, color, alpha)
+        return self
+
+    def fade_no_recurse(self, darkness):
+        self.fade_to_no_recurse(BLACK, darkness)
         return self
 
     def fade(self, darkness = 0.5):
-        self.fade_to(BLACK, darkness)
+        for submob in self.submobject_family():
+            submob.fade_no_recurse(darkness)
         return self
 
     def get_color(self):

mobject/vectorized_mobject.py

@@ -113,14 +113,13 @@ class VMobject(Mobject):
             sm1.match_style(sm2)
         return self
 
-    def fade(self, darkness = 0.5):
-        for submob in self.submobject_family():
-            submob.set_stroke(
-                width = (1-darkness)*submob.get_stroke_width(),
+    def fade_no_recurse(self, darkness):
+        self.set_stroke(
+            width = (1-darkness)*self.get_stroke_width(),
             family = False
         )
-            submob.set_fill(
-                opacity = (1-darkness)*submob.get_fill_opacity(),
+        self.set_fill(
+            opacity = (1-darkness)*self.get_fill_opacity(),
             family = False
         )
         return self

topics/complex_numbers.py

@@ -170,7 +170,6 @@ class ComplexPlane(NumberPlane):
         "unit_size" : 1,
         "line_frequency" : 1,
         "faded_line_frequency" : 0.5,
-        "number_scale_factor" : 0.5,
     }
     def __init__(self, **kwargs):
         digest_config(self, kwargs)
@@ -204,6 +203,8 @@ class ComplexPlane(NumberPlane):
                 for y in range(-int(self.y_radius), int(self.y_radius)+1)
             ]
         for number in numbers:
+            if number == complex(0, 0):
+                continue
             point = self.number_to_point(number)
             num_str = str(number).replace("j", "i")
             if num_str.startswith("0"):
@@ -212,9 +213,8 @@ class ComplexPlane(NumberPlane):
                 num_str = num_str.replace("1", "")
             num_mob = TexMobject(num_str)
             num_mob.add_background_rectangle()
-            num_mob.scale(self.number_scale_factor)
-            vect = DOWN + LEFT
-            num_mob.next_to(point, vect, SMALL_BUFF)
+            num_mob.scale_to_fit_height(self.written_coordinate_height)
+            num_mob.next_to(point, DOWN+LEFT, SMALL_BUFF)
             result.add(num_mob)
         return result