Merge branch 'master' into add_warnings

Author: 3b1b

docs/source/development/changelog.rst

@@ -4,7 +4,28 @@ Changelog
 Unreleased
 ----------
 
-No changes
+Fixed bugs
+^^^^^^^^^^
+
+- `#1592 <https://github.com/3b1b/manim/pull/1592>`__: Fixed ``put_start_and_end_on`` in 3D
+- `#1601 <https://github.com/3b1b/manim/pull/1601>`__: Fixed ``DecimalNumber``'s scaling issue
+
+New Features 
+^^^^^^^^^^^^
+
+- `#1598 <https://github.com/3b1b/manim/pull/1598>`__: Supported the elliptical arc command ``A`` for ``SVGMobject``
+- `#1607 <https://github.com/3b1b/manim/pull/1607>`__: Added ``FlashyFadeIn``
+- `#1607 <https://github.com/3b1b/manim/pull/1607>`__: Save triangulation 
+- `#1625 <https://github.com/3b1b/manim/pull/1625>`__: Added new ``Code`` mobject
+- `bd356da <https://github.com/3b1b/manim/commit/bd356daa99bfe3134fcb192a5f72e0d76d853801>`__: Added ``VCube``
+- `6d72893 <https://github.com/3b1b/manim/commit/6d7289338234acc6658b9377c0f0084aa1fa7119>`__: Supported ``ValueTracker`` to track vectors
+
+Refactor
+^^^^^^^^
+
+- `#1601 <https://github.com/3b1b/manim/pull/1601>`__: Change back to simpler ``Mobject.scale`` implementation
+- `b667db2 <https://github.com/3b1b/manim/commit/b667db2d311a11cbbca2a6ff511d2c3cf1675486>`__: Simplify ``Square``
+- `40290ad <https://github.com/3b1b/manim/commit/40290ada8343f10901fa9151cbdf84689667786d>`__: Removed unused parameter ``triangulation_locked``
 
 v1.1.0
 -------

manimlib/camera/camera.py

@@ -316,17 +316,6 @@ def resize_frame_shape(self, fixed_dimension=0):
         self.frame.set_height(frame_height)
         self.frame.set_width(frame_width)
 
-    def pixel_coords_to_space_coords(self, px, py, relative=False):
-        pw, ph = self.fbo.size
-        fw, fh = self.get_frame_shape()
-        fc = self.get_frame_center()
-        if relative:
-            return 2 * np.array([px / pw, py / ph, 0])
-        else:
-            # Only scale wrt one axis
-            scale = fh / ph
-            return fc + scale * np.array([(px - pw / 2), (py - ph / 2), 0])
-
     # Rendering
     def capture(self, *mobjects, **kwargs):
         self.refresh_perspective_uniforms()
@@ -423,6 +412,8 @@ def set_shader_uniforms(self, shader, shader_wrapper):
             shader[name].value = tid
         for name, value in it.chain(shader_wrapper.uniforms.items(), self.perspective_uniforms.items()):
             try:
+                if isinstance(value, np.ndarray):
+                    value = tuple(value)
                 shader[name].value = value
             except KeyError:
                 pass
@@ -449,21 +440,28 @@ def refresh_perspective_uniforms(self):
         }
 
     def init_textures(self):
-        self.path_to_texture_id = {}
+        self.n_textures = 0
+        self.path_to_texture = {}
 
     def get_texture_id(self, path):
-        if path not in self.path_to_texture_id:
-            # A way to increase tid's sequentially
-            tid = len(self.path_to_texture_id)
+        if path not in self.path_to_texture:
+            tid = self.n_textures
+            self.n_textures += 1
             im = Image.open(path).convert("RGBA")
             texture = self.ctx.texture(
                 size=im.size,
                 components=len(im.getbands()),
                 data=im.tobytes(),
             )
             texture.use(location=tid)
-            self.path_to_texture_id[path] = tid
-        return self.path_to_texture_id[path]
+            self.path_to_texture[path] = (tid, texture)
+        return self.path_to_texture[path][0]
+
+    def release_texture(self, path):
+        tid_and_texture = self.path_to_texture.pop(path, None)
+        if tid_and_texture:
+            tid_and_texture[1].release()
+        return self
 
 
 # Mostly just defined so old scenes don't break

manimlib/mobject/changing.py

@@ -1,8 +1,13 @@
-from manimlib.constants import *
+import numpy as np
+from manimlib.constants import BLUE_D
+from manimlib.constants import BLUE_B
+from manimlib.constants import BLUE_E
+from manimlib.constants import GREY_BROWN
+from manimlib.constants import WHITE
+from manimlib.mobject.mobject import Mobject
 from manimlib.mobject.types.vectorized_mobject import VMobject
 from manimlib.mobject.types.vectorized_mobject import VGroup
 from manimlib.utils.rate_functions import smooth
-from manimlib.utils.space_ops import get_norm
 
 
 class AnimatedBoundary(VGroup):
@@ -74,25 +79,63 @@ class TracedPath(VMobject):
     CONFIG = {
         "stroke_width": 2,
         "stroke_color": WHITE,
-        "min_distance_to_new_point": 0.1,
+        "time_traced": np.inf,
+        "fill_opacity": 0,
+        "time_per_anchor": 1 / 15,
     }
 
     def __init__(self, traced_point_func, **kwargs):
         super().__init__(**kwargs)
         self.traced_point_func = traced_point_func
-        self.add_updater(lambda m: m.update_path())
+        self.time = 0
+        self.traced_points = []
+        self.add_updater(lambda m, dt: m.update_path(dt))
 
-    def update_path(self):
-        new_point = self.traced_point_func()
-        if not self.has_points():
-            self.start_new_path(new_point)
-            self.add_line_to(new_point)
+    def update_path(self, dt):
+        if dt == 0:
+            return self
+        point = self.traced_point_func().copy()
+        self.traced_points.append(point)
+
+        if self.time_traced < np.inf:
+            n_relevant_points = int(self.time_traced / dt + 0.5)
+            # n_anchors = int(self.time_traced / self.time_per_anchor)
+            n_tps = len(self.traced_points)
+            if n_tps < n_relevant_points:
+                points = self.traced_points + [point] * (n_relevant_points - n_tps)
+            else:
+                points = self.traced_points[n_tps - n_relevant_points:]
+            # points = [
+            #     self.traced_points[max(n_tps - int(alpha * n_relevant_points) - 1, 0)]
+            #     for alpha in np.linspace(1, 0, n_anchors)
+            # ]
+            # Every now and then refresh the list
+            if n_tps > 10 * n_relevant_points:
+                self.traced_points = self.traced_points[-n_relevant_points:]
+        else:
+            # sparseness = max(int(self.time_per_anchor / dt), 1)
+            # points = self.traced_points[::sparseness]
+            # points[-1] = self.traced_points[-1]
+            points = self.traced_points
+
+        if points:
+            self.set_points_smoothly(points)
+
+        self.time += dt
+        return self
+
+
+class TracingTail(TracedPath):
+    CONFIG = {
+        "stroke_width": (0, 3),
+        "stroke_opacity": (0, 1),
+        "stroke_color": WHITE,
+        "time_traced": 1.0,
+    }
+
+    def __init__(self, mobject_or_func, **kwargs):
+        if isinstance(mobject_or_func, Mobject):
+            func = mobject_or_func.get_center
         else:
-            # Set the end to be the new point
-            self.get_points()[-1] = new_point
-
-            # Second to last point
-            nppcc = self.n_points_per_curve
-            dist = get_norm(new_point - self.get_points()[-nppcc])
-            if dist >= self.min_distance_to_new_point:
-                self.add_line_to(new_point)
+            func = mobject_or_func
+        super().__init__(func, **kwargs)

manimlib/mobject/coordinate_systems.py

@@ -10,6 +10,7 @@
 from manimlib.mobject.number_line import NumberLine
 from manimlib.mobject.svg.tex_mobject import Tex
 from manimlib.mobject.types.vectorized_mobject import VGroup
+from manimlib.utils.config_ops import digest_config
 from manimlib.utils.config_ops import merge_dicts_recursively
 from manimlib.utils.simple_functions import binary_search
 from manimlib.utils.space_ops import angle_of_vector
@@ -25,13 +26,18 @@ class CoordinateSystem():
     """
     CONFIG = {
         "dimension": 2,
-        "x_range": np.array([-8.0, 8.0, 1.0]),
-        "y_range": np.array([-4.0, 4.0, 1.0]),
-        "width": None,
-        "height": None,
+        "default_x_range": [-8.0, 8.0, 1.0],
+        "default_y_range": [-4.0, 4.0, 1.0],
+        "width": FRAME_WIDTH,
+        "height": FRAME_HEIGHT,
         "num_sampled_graph_points_per_tick": 20,
     }
 
+    def __init__(self, **kwargs):
+        digest_config(self, kwargs)
+        self.x_range = np.array(self.default_x_range)
+        self.y_range = np.array(self.default_y_range)
+
     def coords_to_point(self, *coords):
         raise Exception("Not implemented")
 
@@ -127,6 +133,7 @@ def get_graph(self, function, x_range=None, **kwargs):
             **kwargs
         )
         graph.underlying_function = function
+        graph.x_range = x_range
         return graph
 
     def get_parametric_curve(self, function, **kwargs):
@@ -282,7 +289,9 @@ def __init__(self,
                  x_range=None,
                  y_range=None,
                  **kwargs):
-        super().__init__(**kwargs)
+        CoordinateSystem.__init__(self, **kwargs)
+        VGroup.__init__(self, **kwargs)
+
         if x_range is not None:
             self.x_range[:len(x_range)] = x_range
         if y_range is not None:
@@ -441,7 +450,7 @@ def get_lines(self):
         return lines1, lines2
 
     def get_lines_parallel_to_axis(self, axis1, axis2):
-        freq = axis1.x_step
+        freq = axis2.x_step
         ratio = self.faded_line_ratio
         line = Line(axis1.get_start(), axis1.get_end())
         dense_freq = (1 + ratio)
@@ -501,15 +510,15 @@ def point_to_number(self, point):
     def p2n(self, point):
         return self.point_to_number(point)
 
-    def get_default_coordinate_values(self):
+    def get_default_coordinate_values(self, skip_first=True):
         x_numbers = self.get_x_axis().get_tick_range()[1:]
         y_numbers = self.get_y_axis().get_tick_range()[1:]
         y_numbers = [complex(0, y) for y in y_numbers if y != 0]
         return [*x_numbers, *y_numbers]
 
-    def add_coordinate_labels(self, numbers=None, **kwargs):
+    def add_coordinate_labels(self, numbers=None, skip_first=True, **kwargs):
         if numbers is None:
-            numbers = self.get_default_coordinate_values()
+            numbers = self.get_default_coordinate_values(skip_first)
 
         self.coordinate_labels = VGroup()
         for number in numbers:
@@ -522,6 +531,15 @@ def add_coordinate_labels(self, numbers=None, **kwargs):
                 axis = self.get_x_axis()
                 value = z.real
             number_mob = axis.get_number_mobject(value, **kwargs)
+            # For i and -i, remove the "1"
+            if z.imag == 1:
+                number_mob.remove(number_mob[0])
+            if z.imag == -1:
+                number_mob.remove(number_mob[1])
+                number_mob[0].next_to(
+                    number_mob[1], LEFT,
+                    buff=number_mob[0].get_width() / 4
+                )
             self.coordinate_labels.add(number_mob)
         self.add(self.coordinate_labels)
         return self