manim 0.17.3__tar.gz → 0.18.0.post0__tar.gz

{manim-0.17.3 → manim-0.18.0.post0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: manim
-Version: 0.17.3
+Version: 0.18.0.post0
 Summary: Animation engine for explanatory math videos.
 Home-page: https://www.manim.community/
 License: MIT
 Author: The Manim Community Developers
 Author-email: contact@manim.community
-Requires-Python: >=3.8,<3.12
+Requires-Python: >=3.8,<3.13
 Classifier: Development Status :: 4 - Beta
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Natural Language :: English
@@ -15,10 +15,7 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Multimedia :: Graphics
 Classifier: Topic :: Multimedia :: Video
 Classifier: Topic :: Scientific/Engineering
@@ -29,31 +26,34 @@ Requires-Dist: Pygments (>=2.10.0,<3.0.0)
 Requires-Dist: backports.cached-property (>=1.0.1,<2.0.0) ; python_version < "3.8"
 Requires-Dist: click (>=7.2,<=9.0)
 Requires-Dist: click-default-group (>=1.2.2,<2.0.0)
-Requires-Dist: cloup (>=0.13.0,<0.14.0)
-Requires-Dist: colour (>=0.1.5,<0.2.0)
+Requires-Dist: cloup (>=0.13,<2.2)
 Requires-Dist: dearpygui (>=1.3.1,<2.0.0) ; extra == "gui"
 Requires-Dist: decorator (>=5.0.7,<6.0.0)
 Requires-Dist: importlib-metadata (>=4.10.0,<5.0.0) ; python_version < "3.8"
 Requires-Dist: isosurfaces (==0.1.0)
 Requires-Dist: jupyterlab (>=3.0,<4.0) ; extra == "jupyterlab"
-Requires-Dist: manimpango (>=0.4.0.post0,<0.5.0)
+Requires-Dist: manimpango (>=0.5.0,<1.0.0)
 Requires-Dist: mapbox-earcut (>=1.0.0,<2.0.0)
 Requires-Dist: moderngl (>=5.6.3,<6.0.0)
 Requires-Dist: moderngl-window (>=2.3.0,<3.0.0)
-Requires-Dist: networkx (>=2.5,<3.0)
+Requires-Dist: networkx (>=2.5,<3.3)
 Requires-Dist: notebook (>=6.4,<7.0) ; extra == "jupyterlab"
-Requires-Dist: numpy (>=1.19,<2.0)
+Requires-Dist: numpy (>=1.22,<2.0) ; python_version < "3.12"
+Requires-Dist: numpy (>=1.26,<2.0) ; python_version >= "3.12"
 Requires-Dist: pycairo (>=1.21,<2.0)
 Requires-Dist: pydub (>=0.25.1,<0.26.0)
 Requires-Dist: requests (>=2.26.0,<3.0.0)
 Requires-Dist: rich (>=6.0,!=12.0.0)
-Requires-Dist: scipy (>=1.7.3,<2.0.0)
+Requires-Dist: scipy (>=1.11,<2.0) ; python_version >= "3.12"
+Requires-Dist: scipy (>=1.7.3,<2.0.0) ; python_version < "3.12"
 Requires-Dist: screeninfo (>=0.8,<0.9)
-Requires-Dist: skia-pathops (>=0.7.0,<0.8.0)
+Requires-Dist: skia-pathops (>=0.7.0,<0.8.0) ; python_version < "3.12"
+Requires-Dist: skia-pathops (>=0.8.0.post1,<0.9.0) ; python_version >= "3.12"
 Requires-Dist: srt (>=3.5.0,<4.0.0)
 Requires-Dist: svgelements (>=1.8.0,<2.0.0)
 Requires-Dist: tqdm (>=4.62.3,<5.0.0)
-Requires-Dist: watchdog (>=2.1.6,<3.0.0)
+Requires-Dist: typing-extensions (>=4.7.1,<5.0.0)
+Requires-Dist: watchdog (>=2.1,<=3.0.0)
 Project-URL: Bug Tracker, https://github.com/ManimCommunity/manim/issues
 Project-URL: Changelog, https://docs.manim.community/en/stable/changelog.html
 Project-URL: Documentation, https://docs.manim.community/

{manim-0.17.3 → manim-0.18.0.post0}/manim/__init__.py

@@ -46,6 +46,7 @@ from .constants import *
 from .mobject.frame import *
 from .mobject.geometry.arc import *
 from .mobject.geometry.boolean_ops import *
+from .mobject.geometry.labeled import *
 from .mobject.geometry.line import *
 from .mobject.geometry.polygram import *
 from .mobject.geometry.shape_matchers import *

{manim-0.17.3 → manim-0.18.0.post0}/manim/__main__.py

@@ -7,6 +7,7 @@ import cloup
 
 from . import __version__, cli_ctx_settings, console
 from .cli.cfg.group import cfg
+from .cli.checkhealth.commands import checkhealth
 from .cli.default_group import DefaultGroup
 from .cli.init.commands import init
 from .cli.new.group import new
@@ -48,6 +49,7 @@ def main(ctx):
     pass
 
 
+main.add_command(checkhealth)
 main.add_command(cfg)
 main.add_command(plugins)
 main.add_command(init)

{manim-0.17.3 → manim-0.18.0.post0}/manim/_config/__init__.py

@@ -20,7 +20,6 @@ __all__ = [
 ]
 
 parser = make_config_parser()
-logger: logging.Logger
 
 # The logger can be accessed from anywhere as manim.logger, or as
 # logging.getLogger("manim").  The console must be accessed as manim.console.

{manim-0.17.3 → manim-0.18.0.post0}/manim/_config/logger_utils.py

@@ -26,6 +26,7 @@ from rich.theme import Theme
 
 if TYPE_CHECKING:
     from pathlib import Path
+
 HIGHLIGHTED_KEYWORDS = [  # these keywords are highlighted specially
     "Played",
     "animations",

{manim-0.17.3 → manim-0.18.0.post0}/manim/_config/utils.py

@@ -23,13 +23,13 @@ from collections.abc import Mapping, MutableMapping
 from pathlib import Path
 from typing import Any, Iterable, Iterator
 
-import colour
 import numpy as np
 
 from .. import constants
 from ..constants import RendererType
+from ..typing import StrPath
+from ..utils.color import ManimColor
 from ..utils.tex import TexTemplate, TexTemplateFromFile
-from ..utils.tex_templates import TexTemplateLibrary
 
 
 def config_file_paths() -> list[Path]:
@@ -76,7 +76,7 @@ def config_file_paths() -> list[Path]:
 
 
 def make_config_parser(
-    custom_file: str | os.PathLike | None = None,
+    custom_file: StrPath | None = None,
 ) -> configparser.ConfigParser:
     """Make a :class:`ConfigParser` object and load any ``.cfg`` files.
 
@@ -309,6 +309,7 @@ class ManimConfig(MutableMapping):
         "write_to_movie",
         "zero_pad",
         "force_window",
+        "no_latex_cleanup",
     }
 
     def __init__(self) -> None:
@@ -580,6 +581,7 @@ class ManimConfig(MutableMapping):
             "use_projection_stroke_shaders",
             "enable_wireframe",
             "force_window",
+            "no_latex_cleanup",
         ]:
             setattr(self, key, parser["CLI"].getboolean(key, fallback=False))
 
@@ -756,6 +758,7 @@ class ManimConfig(MutableMapping):
             "enable_wireframe",
             "force_window",
             "dry_run",
+            "no_latex_cleanup",
         ]:
             if hasattr(args, key):
                 attr = getattr(args, key)
@@ -960,6 +963,12 @@ class ManimConfig(MutableMapping):
         doc="Set to force window when using the opengl renderer",
     )
 
+    no_latex_cleanup = property(
+        lambda self: self._d["no_latex_cleanup"],
+        lambda self, val: self._set_boolean("no_latex_cleanup", val),
+        doc="Prevents deletion of .aux, .dvi, and .log files produced by Tex and MathTex.",
+    )
+
     @property
     def verbosity(self):
         """Logger verbosity; "DEBUG", "INFO", "WARNING", "ERROR", or "CRITICAL" (-v)."""
@@ -1096,7 +1105,7 @@ class ManimConfig(MutableMapping):
 
     background_color = property(
         lambda self: self._d["background_color"],
-        lambda self, val: self._d.__setitem__("background_color", colour.Color(val)),
+        lambda self, val: self._d.__setitem__("background_color", ManimColor(val)),
         doc="Background color of the scene (-c).",
     )
 
@@ -1172,7 +1181,7 @@ class ManimConfig(MutableMapping):
         keys = ["pixel_width", "pixel_height", "frame_rate"]
         q = {k: self[k] for k in keys}
         for qual in constants.QUALITIES:
-            if all([q[k] == constants.QUALITIES[qual][k] for k in keys]):
+            if all(q[k] == constants.QUALITIES[qual][k] for k in keys):
                 return qual
         return None
 

{manim-0.17.3 → manim-0.18.0.post0}/manim/animation/changing.py

@@ -6,12 +6,16 @@ __all__ = ["AnimatedBoundary", "TracedPath"]
 
 from typing import Callable
 
-from colour import Color
-
-from manim._config import config
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 from manim.mobject.types.vectorized_mobject import VGroup, VMobject
-from manim.utils.color import BLUE_B, BLUE_D, BLUE_E, GREY_BROWN, WHITE
+from manim.utils.color import (
+    BLUE_B,
+    BLUE_D,
+    BLUE_E,
+    GREY_BROWN,
+    WHITE,
+    ParsableManimColor,
+)
 from manim.utils.rate_functions import smooth
 
 
@@ -140,7 +144,7 @@ class TracedPath(VMobject, metaclass=ConvertToOpenGL):
         self,
         traced_point_func: Callable,
         stroke_width: float = 2,
-        stroke_color: Color = WHITE,
+        stroke_color: ParsableManimColor | None = WHITE,
         dissipating_time: float | None = None,
         **kwargs,
     ):

{manim-0.17.3 → manim-0.18.0.post0}/manim/animation/creation.py

@@ -77,13 +77,13 @@ import itertools as it
 from typing import TYPE_CHECKING, Callable, Iterable, Sequence
 
 import numpy as np
-from colour import Color
 
 if TYPE_CHECKING:
     from manim.mobject.text.text_mobject import Text
 
 from manim.mobject.opengl.opengl_surface import OpenGLSurface
 from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVMobject
+from manim.utils.color import ManimColor
 
 from .. import config
 from ..animation.animation import Animation
@@ -92,7 +92,7 @@ from ..constants import TAU
 from ..mobject.mobject import Group, Mobject
 from ..mobject.types.vectorized_mobject import VMobject
 from ..utils.bezier import integer_interpolate
-from ..utils.rate_functions import double_smooth, linear, smooth
+from ..utils.rate_functions import double_smooth, linear
 
 
 class ShowPartial(Animation):
@@ -259,7 +259,7 @@ class DrawBorderThenFill(Animation):
             sm.set_stroke(color=self.get_stroke_color(sm), width=self.stroke_width)
         return outline
 
-    def get_stroke_color(self, vmobject: VMobject | OpenGLVMobject) -> Color:
+    def get_stroke_color(self, vmobject: VMobject | OpenGLVMobject) -> ManimColor:
         if self.stroke_color:
             return self.stroke_color
         elif vmobject.get_stroke_width() > 0:
@@ -563,6 +563,11 @@ class AddTextLetterByLetter(ShowIncreasingSubsets):
         **kwargs,
     ) -> None:
         self.time_per_char = time_per_char
+        # Check for empty text using family_members_with_points()
+        if not text.family_members_with_points():
+            raise ValueError(
+                f"The text mobject {text} does not seem to contain any characters."
+            )
         if run_time is None:
             # minimum time per character is 1/frame_rate, otherwise
             # the animation does not finish.

{manim-0.17.3 → manim-0.18.0.post0}/manim/animation/indication.py

@@ -40,12 +40,12 @@ __all__ = [
 from typing import Callable, Iterable, Optional, Tuple, Type, Union
 
 import numpy as np
-from colour import Color
 
 from manim.mobject.geometry.arc import Circle, Dot
 from manim.mobject.geometry.line import Line
 from manim.mobject.geometry.polygram import Rectangle
 from manim.mobject.geometry.shape_matchers import SurroundingRectangle
+from manim.scene.scene import Scene
 
 from .. import config
 from ..animation.animation import Animation
@@ -58,7 +58,7 @@ from ..constants import *
 from ..mobject.mobject import Mobject
 from ..mobject.types.vectorized_mobject import VGroup, VMobject
 from ..utils.bezier import interpolate, inverse_interpolate
-from ..utils.color import GREY, YELLOW
+from ..utils.color import GREY, YELLOW, ParsableManimColor
 from ..utils.deprecation import deprecated
 from ..utils.rate_functions import smooth, there_and_back, wiggle
 from ..utils.space_ops import normalize
@@ -314,7 +314,7 @@ class ShowPassingFlash(ShowPartial):
         lower = max(lower, 0)
         return (lower, upper)
 
-    def clean_up_from_scene(self, scene: "Scene") -> None:
+    def clean_up_from_scene(self, scene: Scene) -> None:
         super().clean_up_from_scene(scene)
         for submob, start in self.get_all_families_zipped():
             submob.pointwise_become_partial(start, 0, 1)
@@ -609,7 +609,7 @@ class Circumscribe(Succession):
         fade_out=False,
         time_width=0.3,
         buff: float = SMALL_BUFF,
-        color: Color = YELLOW,
+        color: ParsableManimColor = YELLOW,
         run_time=1,
         stroke_width=DEFAULT_STROKE_WIDTH,
         **kwargs

{manim-0.17.3 → manim-0.18.0.post0}/manim/animation/speedmodifier.py

@@ -2,13 +2,12 @@
 
 from __future__ import annotations
 
+import inspect
 import types
 from typing import Callable
 
 from numpy import piecewise
 
-from manim.utils.simple_functions import get_parameters
-
 from ..animation.animation import Animation, Wait, prepare_animation
 from ..animation.composition import AnimationGroup
 from ..mobject.mobject import Mobject, Updater, _AnimationBuilder
@@ -260,8 +259,7 @@ class ChangeSpeed(Animation):
         :class:`.ChangeSpeed`
         :meth:`.Mobject.add_updater`
         """
-        parameters = get_parameters(update_function)
-        if "dt" in parameters:
+        if "dt" in inspect.signature(update_function).parameters:
             mobject.add_updater(
                 lambda mob, dt: update_function(
                     mob, ChangeSpeed.dt if ChangeSpeed.is_changing_dt else dt

manim-0.18.0.post0/manim/animation/updaters/mobject_update_utils.py

@@ -0,0 +1,231 @@
+"""Utility functions for continuous animation of mobjects."""
+
+from __future__ import annotations
+
+__all__ = [
+    "assert_is_mobject_method",
+    "always",
+    "f_always",
+    "always_redraw",
+    "always_shift",
+    "always_rotate",
+    "turn_animation_into_updater",
+    "cycle_animation",
+]
+
+
+import inspect
+from typing import TYPE_CHECKING, Callable
+
+import numpy as np
+
+from manim.constants import DEGREES, RIGHT
+from manim.mobject.mobject import Mobject
+from manim.opengl import OpenGLMobject
+from manim.utils.space_ops import normalize
+
+if TYPE_CHECKING:
+    from manim.animation.animation import Animation
+
+
+def assert_is_mobject_method(method: Callable) -> None:
+    assert inspect.ismethod(method)
+    mobject = method.__self__
+    assert isinstance(mobject, (Mobject, OpenGLMobject))
+
+
+def always(method: Callable, *args, **kwargs) -> Mobject:
+    assert_is_mobject_method(method)
+    mobject = method.__self__
+    func = method.__func__
+    mobject.add_updater(lambda m: func(m, *args, **kwargs))
+    return mobject
+
+
+def f_always(method: Callable[[Mobject], None], *arg_generators, **kwargs) -> Mobject:
+    """
+    More functional version of always, where instead
+    of taking in args, it takes in functions which output
+    the relevant arguments.
+    """
+    assert_is_mobject_method(method)
+    mobject = method.__self__
+    func = method.__func__
+
+    def updater(mob):
+        args = [arg_generator() for arg_generator in arg_generators]
+        func(mob, *args, **kwargs)
+
+    mobject.add_updater(updater)
+    return mobject
+
+
+def always_redraw(func: Callable[[], Mobject]) -> Mobject:
+    """Redraw the mobject constructed by a function every frame.
+
+    This function returns a mobject with an attached updater that
+    continuously regenerates the mobject according to the
+    specified function.
+
+    Parameters
+    ----------
+    func
+        A function without (required) input arguments that returns
+        a mobject.
+
+    Examples
+    --------
+
+    .. manim:: TangentAnimation
+
+        class TangentAnimation(Scene):
+            def construct(self):
+                ax = Axes()
+                sine = ax.plot(np.sin, color=RED)
+                alpha = ValueTracker(0)
+                point = always_redraw(
+                    lambda: Dot(
+                        sine.point_from_proportion(alpha.get_value()),
+                        color=BLUE
+                    )
+                )
+                tangent = always_redraw(
+                    lambda: TangentLine(
+                        sine,
+                        alpha=alpha.get_value(),
+                        color=YELLOW,
+                        length=4
+                    )
+                )
+                self.add(ax, sine, point, tangent)
+                self.play(alpha.animate.set_value(1), rate_func=linear, run_time=2)
+    """
+    mob = func()
+    mob.add_updater(lambda _: mob.become(func()))
+    return mob
+
+
+def always_shift(
+    mobject: Mobject, direction: np.ndarray[np.float64] = RIGHT, rate: float = 0.1
+) -> Mobject:
+    """A mobject which is continuously shifted along some direction
+    at a certain rate.
+
+    Parameters
+    ----------
+    mobject
+        The mobject to shift.
+    direction
+        The direction to shift. The vector is normalized, the specified magnitude
+        is not relevant.
+    rate
+        Length in Manim units which the mobject travels in one
+        second along the specified direction.
+
+    Examples
+    --------
+
+    .. manim:: ShiftingSquare
+
+        class ShiftingSquare(Scene):
+            def construct(self):
+                sq = Square().set_fill(opacity=1)
+                tri = Triangle()
+                VGroup(sq, tri).arrange(LEFT)
+
+                # construct a square which is continuously
+                # shifted to the right
+                always_shift(sq, RIGHT, rate=5)
+
+                self.add(sq)
+                self.play(tri.animate.set_fill(opacity=1))
+    """
+    mobject.add_updater(lambda m, dt: m.shift(dt * rate * normalize(direction)))
+    return mobject
+
+
+def always_rotate(mobject: Mobject, rate: float = 20 * DEGREES, **kwargs) -> Mobject:
+    """A mobject which is continuously rotated at a certain rate.
+
+    Parameters
+    ----------
+    mobject
+        The mobject to be rotated.
+    rate
+        The angle which the mobject is rotated by
+        over one second.
+    kwags
+        Further arguments to be passed to :meth:`.Mobject.rotate`.
+
+    Examples
+    --------
+
+    .. manim:: SpinningTriangle
+
+        class SpinningTriangle(Scene):
+            def construct(self):
+                tri = Triangle().set_fill(opacity=1).set_z_index(2)
+                sq = Square().to_edge(LEFT)
+
+                # will keep spinning while there is an animation going on
+                always_rotate(tri, rate=2*PI, about_point=ORIGIN)
+
+                self.add(tri, sq)
+                self.play(sq.animate.to_edge(RIGHT), rate_func=linear, run_time=1)
+    """
+    mobject.add_updater(lambda m, dt: m.rotate(dt * rate, **kwargs))
+    return mobject
+
+
+def turn_animation_into_updater(
+    animation: Animation, cycle: bool = False, **kwargs
+) -> Mobject:
+    """
+    Add an updater to the animation's mobject which applies
+    the interpolation and update functions of the animation
+
+    If cycle is True, this repeats over and over.  Otherwise,
+    the updater will be popped upon completion
+
+    Examples
+    --------
+
+    .. manim:: WelcomeToManim
+
+        class WelcomeToManim(Scene):
+            def construct(self):
+                words = Text("Welcome to")
+                banner = ManimBanner().scale(0.5)
+                VGroup(words, banner).arrange(DOWN)
+
+                turn_animation_into_updater(Write(words, run_time=0.9))
+                self.add(words)
+                self.wait(0.5)
+                self.play(banner.expand(), run_time=0.5)
+    """
+    mobject = animation.mobject
+    animation.suspend_mobject_updating = False
+    animation.begin()
+    animation.total_time = 0
+
+    def update(m: Mobject, dt: float):
+        run_time = animation.get_run_time()
+        time_ratio = animation.total_time / run_time
+        if cycle:
+            alpha = time_ratio % 1
+        else:
+            alpha = np.clip(time_ratio, 0, 1)
+            if alpha >= 1:
+                animation.finish()
+                m.remove_updater(update)
+                return
+        animation.interpolate(alpha)
+        animation.update_mobjects(dt)
+        animation.total_time += dt
+
+    mobject.add_updater(update)
+    return mobject
+
+
+def cycle_animation(animation: Animation, **kwargs) -> Mobject:
+    return turn_animation_into_updater(animation, cycle=True, **kwargs)

{manim-0.17.3 → manim-0.18.0.post0}/manim/camera/camera.py

@@ -9,7 +9,6 @@ import copy
 import itertools as it
 import operator as op
 import pathlib
-import time
 from functools import reduce
 from typing import Any, Callable, Iterable
 
@@ -24,7 +23,7 @@ from ..mobject.mobject import Mobject
 from ..mobject.types.image_mobject import AbstractImageMobject
 from ..mobject.types.point_cloud_mobject import PMobject
 from ..mobject.types.vectorized_mobject import VMobject
-from ..utils.color import color_to_int_rgba
+from ..utils.color import ManimColor, ParsableManimColor, color_to_int_rgba
 from ..utils.family import extract_mobject_family_members
 from ..utils.images import get_full_raster_image_path
 from ..utils.iterables import list_difference_update
@@ -75,6 +74,8 @@ class Camera:
         frame_height: float | None = None,
         frame_width: float | None = None,
         frame_rate: float | None = None,
+        background_color: ParsableManimColor | None = None,
+        background_opacity: float | None = None,
         **kwargs,
     ):
         self.background_image = background_image
@@ -106,9 +107,14 @@ class Camera:
             frame_rate = config["frame_rate"]
         self.frame_rate = frame_rate
 
-        # TODO: change this to not use kwargs.get
-        for attr in ["background_color", "background_opacity"]:
-            setattr(self, f"_{attr}", kwargs.get(attr, config[attr]))
+        if background_color is None:
+            self._background_color = ManimColor.parse(config["background_color"])
+        else:
+            self._background_color = ManimColor.parse(background_color)
+        if background_opacity is None:
+            self._background_opacity = config["background_opacity"]
+        else:
+            self._background_opacity = background_opacity
 
         # This one is in the same boat as the above, but it doesn't have the
         # same name as the corresponding key so it has to be handled on its own
@@ -886,8 +892,10 @@ class Camera:
         thickness: float,
         pixel_array: np.ndarray,
     ):
-        """Displays a PMobject by modifying the Pixel array suitably..
+        """Displays a PMobject by modifying the pixel array suitably.
+
         TODO: Write a description for the rgbas argument.
+
         Parameters
         ----------
         pmobject
@@ -957,7 +965,7 @@ class Camera:
             The Pixel array to put the imagemobject in.
         """
         corner_coords = self.points_to_pixel_coords(image_mobject, image_mobject.points)
-        ul_coords, ur_coords, dl_coords = corner_coords
+        ul_coords, ur_coords, dl_coords, _ = corner_coords
         right_vect = ur_coords - ul_coords
         down_vect = dl_coords - ul_coords
         center_coords = ul_coords + (right_vect + down_vect) / 2
@@ -1122,17 +1130,19 @@ class Camera:
             ],
         )
 
-    def adjusted_thickness(self, thickness: float):
-        """
+    def adjusted_thickness(self, thickness: float) -> float:
+        """Computes the adjusted stroke width for a zoomed camera.
 
         Parameters
         ----------
         thickness
+            The stroke width of a mobject.
 
         Returns
         -------
         float
-
+            The adjusted stroke width that reflects zooming in with
+            the camera.
         """
         # TODO: This seems...unsystematic
         big_sum = op.add(config["pixel_height"], config["pixel_width"])
@@ -1141,7 +1151,8 @@ class Camera:
         return 1 + (thickness - 1) * factor
 
     def get_thickening_nudges(self, thickness: float):
-        """
+        """Determine a list of vectors used to nudge
+        two-dimensional pixel coordinates.
 
         Parameters
         ----------
@@ -1215,13 +1226,16 @@ class Camera:
 # NOTE: The methods of the following class have not been mentioned outside of their definitions.
 # Their DocStrings are not as detailed as preferred.
 class BackgroundColoredVMobjectDisplayer:
+    """Auxiliary class that handles displaying vectorized mobjects with
+    a set background image.
+
+    Parameters
+    ----------
+    camera
+        Camera object to use.
+    """
+
     def __init__(self, camera: Camera):
-        """
-        Parameters
-        ----------
-        camera
-            Camera object to use.
-        """
         self.camera = camera
         self.file_name_to_pixel_array_map = {}
         self.pixel_array = np.array(camera.pixel_array)