manim 0.17.0__py3-none-any.whl → 0.19.1__py3-none-any.whl

manim/mobject/opengl/opengl_point_cloud_mobject.py

@@ -2,16 +2,37 @@ from __future__ import annotations
 
 __all__ = ["OpenGLPMobject", "OpenGLPGroup", "OpenGLPMPoint"]
 
+from typing import TYPE_CHECKING
+
 import moderngl
 import numpy as np
 
 from manim.constants import *
 from manim.mobject.opengl.opengl_mobject import OpenGLMobject
 from manim.utils.bezier import interpolate
-from manim.utils.color import BLACK, WHITE, YELLOW, color_gradient, color_to_rgba
+from manim.utils.color import (
+    BLACK,
+    WHITE,
+    YELLOW,
+    ParsableManimColor,
+    color_gradient,
+    color_to_rgba,
+)
 from manim.utils.config_ops import _Uniforms
 from manim.utils.iterables import resize_with_interpolation
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from manim.typing import (
+        FloatRGBA_Array,
+        FloatRGBALike_Array,
+        Point3D_Array,
+        Point3DLike_Array,
+    )
+
+__all__ = ["OpenGLPMobject", "OpenGLPGroup", "OpenGLPMPoint"]
+
 
 class OpenGLPMobject(OpenGLMobject):
     shader_folder = "true_dot"
@@ -25,7 +46,11 @@ class OpenGLPMobject(OpenGLMobject):
     point_radius = _Uniforms()
 
     def __init__(
-        self, stroke_width=2.0, color=YELLOW, render_primitive=moderngl.POINTS, **kwargs
+        self,
+        stroke_width: float = 2.0,
+        color: ParsableManimColor = YELLOW,
+        render_primitive: int = moderngl.POINTS,
+        **kwargs,
     ):
         self.stroke_width = stroke_width
         super().__init__(color=color, render_primitive=render_primitive, **kwargs)
@@ -33,15 +58,21 @@ class OpenGLPMobject(OpenGLMobject):
             self.stroke_width * OpenGLPMobject.OPENGL_POINT_RADIUS_SCALE_FACTOR
         )
 
-    def reset_points(self):
-        self.rgbas = np.zeros((1, 4))
-        self.points = np.zeros((0, 3))
+    def reset_points(self) -> Self:
+        self.rgbas: FloatRGBA_Array = np.zeros((1, 4))
+        self.points: Point3D_Array = np.zeros((0, 3))
         return self
 
     def get_array_attrs(self):
         return ["points", "rgbas"]
 
-    def add_points(self, points, rgbas=None, color=None, opacity=None):
+    def add_points(
+        self,
+        points: Point3DLike_Array,
+        rgbas: FloatRGBALike_Array | None = None,
+        color: ParsableManimColor | None = None,
+        opacity: float | None = None,
+    ) -> Self:
         """Add points.
 
         Points must be a Nx3 numpy array.
@@ -63,13 +94,11 @@ class OpenGLPMobject(OpenGLMobject):
         return self
 
     def thin_out(self, factor=5):
-        """
-        Removes all but every nth point for n = factor
-        """
+        """Removes all but every nth point for n = factor"""
         for mob in self.family_members_with_points():
             num_points = mob.get_num_points()
 
-            def thin_func():
+            def thin_func(num_points=num_points):
                 return np.arange(0, num_points, factor)
 
             if len(mob.points) == len(mob.rgbas):
@@ -124,9 +153,7 @@ class OpenGLPMobject(OpenGLMobject):
         return self
 
     def sort_points(self, function=lambda p: p[0]):
-        """
-        function is any map from R^3 to R
-        """
+        """function is any map from R^3 to R"""
         for mob in self.family_members_with_points():
             indices = np.argsort(np.apply_along_axis(function, 1, mob.points))
             for key in mob.data:
@@ -162,7 +189,7 @@ class OpenGLPMobject(OpenGLMobject):
 
 class OpenGLPGroup(OpenGLPMobject):
     def __init__(self, *pmobs, **kwargs):
-        if not all([isinstance(m, OpenGLPMobject) for m in pmobs]):
+        if not all(isinstance(m, OpenGLPMobject) for m in pmobs):
             raise Exception("All submobjects must be of type OpenglPMObject")
         super().__init__(**kwargs)
         self.add(*pmobs)

manim/mobject/opengl/opengl_surface.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Iterable
 from pathlib import Path
-from typing import Iterable
 
 import moderngl
 import numpy as np
@@ -9,14 +9,16 @@ from PIL import Image
 
 from manim.constants import *
 from manim.mobject.opengl.opengl_mobject import OpenGLMobject
+from manim.typing import Point3D_Array, Vector3D_Array
 from manim.utils.bezier import integer_interpolate, interpolate
 from manim.utils.color import *
 from manim.utils.config_ops import _Data, _Uniforms
-from manim.utils.deprecation import deprecated
 from manim.utils.images import change_to_rgba_array, get_full_raster_image_path
 from manim.utils.iterables import listify
 from manim.utils.space_ops import normalize_along_axis
 
+__all__ = ["OpenGLSurface", "OpenGLTexturedSurface"]
+
 
 class OpenGLSurface(OpenGLMobject):
     r"""Creates a Surface.
@@ -98,6 +100,7 @@ class OpenGLSurface(OpenGLMobject):
         # can crop up in the shaders.
         self.epsilon = epsilon
 
+        self.triangle_indices = None
         super().__init__(
             color=color,
             opacity=opacity,
@@ -127,7 +130,7 @@ class OpenGLSurface(OpenGLMobject):
         # - Those generated by values nudged by du
         # - Those generated by values nudged by dv
         point_lists = []
-        for (du, dv) in [(0, 0), (self.epsilon, 0), (0, self.epsilon)]:
+        for du, dv in [(0, 0), (self.epsilon, 0), (0, self.epsilon)]:
             uv_grid = np.array([[[u + du, v + dv] for v in v_range] for u in u_range])
             point_grid = np.apply_along_axis(lambda p: self.uv_func(*p), 2, uv_grid)
             point_lists.append(point_grid.reshape((nu * nv, dim)))
@@ -158,12 +161,14 @@ class OpenGLSurface(OpenGLMobject):
     def get_triangle_indices(self):
         return self.triangle_indices
 
-    def get_surface_points_and_nudged_points(self):
+    def get_surface_points_and_nudged_points(
+        self,
+    ) -> tuple[Point3D_Array, Point3D_Array, Point3D_Array]:
         points = self.points
         k = len(points) // 3
         return points[:k], points[k : 2 * k], points[2 * k :]
 
-    def get_unit_normals(self):
+    def get_unit_normals(self) -> Vector3D_Array:
         s_points, du_points, dv_points = self.get_surface_points_and_nudged_points()
         normals = np.cross(
             (du_points - s_points) / self.epsilon,
@@ -260,7 +265,9 @@ class OpenGLSurface(OpenGLMobject):
             shader_data["du_point"] = du_points
             shader_data["dv_point"] = dv_points
             if self.colorscale:
-                shader_data["color"] = self._get_color_by_value(s_points)
+                if not hasattr(self, "color_by_val"):
+                    self.color_by_val = self._get_color_by_value(s_points)
+                shader_data["color"] = self.color_by_val
             else:
                 self.fill_in_shader_color_info(shader_data)
         return shader_data
@@ -340,91 +347,6 @@ class OpenGLSurface(OpenGLMobject):
     def get_shader_vert_indices(self):
         return self.get_triangle_indices()
 
-    @deprecated(
-        since="v0.16.0",
-        message="Use colorscale attribute instead.",
-    )
-    def set_fill_by_value(self, axes, colors):
-        # directly copied from three_dimensions.py with some compatibility changes.
-        """Sets the color of each mobject of a parametric surface to a color relative to its z-value
-
-        Parameters
-        ----------
-        axes :
-            The axes for the parametric surface, which will be used to map z-values to colors.
-        colors :
-            A list of colors, ordered from lower z-values to higher z-values. If a list of tuples is passed
-            containing colors paired with numbers, then those numbers will be used as the pivots.
-
-        Returns
-        -------
-        :class:`~.Surface`
-            The parametric surface with a gradient applied by value. For chaining.
-
-        Examples
-        --------
-        .. manim:: FillByValueExample
-            :save_last_frame:
-
-            class FillByValueExample(ThreeDScene):
-                def construct(self):
-                    resolution_fa = 42
-                    self.set_camera_orientation(phi=75 * DEGREES, theta=-120 * DEGREES)
-                    axes = ThreeDAxes(x_range=(0, 5, 1), y_range=(0, 5, 1), z_range=(-1, 1, 0.5))
-                    def param_surface(u, v):
-                        x = u
-                        y = v
-                        z = np.sin(x) * np.cos(y)
-                        return z
-                    surface_plane = Surface(
-                        lambda u, v: axes.c2p(u, v, param_surface(u, v)),
-                        resolution=(resolution_fa, resolution_fa),
-                        v_range=[0, 5],
-                        u_range=[0, 5],
-                        )
-                    # surface_plane.set_style(fill_opacity=1)
-                    surface_plane.set_fill_by_value(axes=axes, colors=[(RED, -0.4), (YELLOW, 0), (GREEN, 0.4)])
-                    self.add(axes, surface_plane)
-        """
-        if type(colors[0]) is tuple:
-            new_colors, pivots = [[i for i, j in colors], [j for i, j in colors]]
-        else:
-            new_colors = colors
-
-            pivot_min = axes.z_range[0]
-            pivot_max = axes.z_range[1]
-            pivot_frequency = (pivot_max - pivot_min) / (len(new_colors) - 1)
-            pivots = np.arange(
-                start=pivot_min,
-                stop=pivot_max + pivot_frequency,
-                step=pivot_frequency,
-            )
-
-        for mob in self.family_members_with_points():
-            # import ipdb; ipdb.set_trace(context=7)
-            z_value = axes.point_to_coords(mob.get_midpoint())[2]
-            if z_value <= pivots[0]:
-                mob.set_color(new_colors[0])
-            elif z_value >= pivots[-1]:
-                mob.set_color(new_colors[-1])
-            else:
-                for i, pivot in enumerate(pivots):
-                    if pivot > z_value:
-                        color_index = (z_value - pivots[i - 1]) / (
-                            pivots[i] - pivots[i - 1]
-                        )
-                        color_index = min(color_index, 1)
-                        mob_color = interpolate_color(
-                            new_colors[i - 1],
-                            new_colors[i],
-                            color_index,
-                        )
-                        mob.set_color(mob_color, recurse=False)
-
-                        break
-
-        return self
-
 
 class OpenGLSurfaceGroup(OpenGLSurface):
     def __init__(self, *parametric_surfaces, resolution=None, **kwargs):
@@ -462,7 +384,7 @@ class OpenGLTexturedSurface(OpenGLSurface):
 
         if not isinstance(uv_surface, OpenGLSurface):
             raise Exception("uv_surface must be of type OpenGLSurface")
-        if type(image_file) == np.ndarray:
+        if isinstance(image_file, np.ndarray):
             image_file = change_to_rgba_array(image_file)
 
         # Set texture information

manim/mobject/opengl/opengl_three_dimensions.py

@@ -1,21 +1,25 @@
 from __future__ import annotations
 
+from typing import Any
+
 import numpy as np
 
 from manim.mobject.opengl.opengl_surface import OpenGLSurface
 from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVGroup, OpenGLVMobject
 
+__all__ = ["OpenGLSurfaceMesh"]
+
 
 class OpenGLSurfaceMesh(OpenGLVGroup):
     def __init__(
         self,
-        uv_surface,
-        resolution=None,
-        stroke_width=1,
-        normal_nudge=1e-2,
-        depth_test=True,
-        flat_stroke=False,
-        **kwargs,
+        uv_surface: OpenGLSurface,
+        resolution: tuple[int, int] | None = None,
+        stroke_width: float = 1,
+        normal_nudge: float = 1e-2,
+        depth_test: bool = True,
+        flat_stroke: bool = False,
+        **kwargs: Any,
     ):
         if not isinstance(uv_surface, OpenGLSurface):
             raise Exception("uv_surface must be of type OpenGLSurface")
@@ -29,7 +33,7 @@ class OpenGLSurfaceMesh(OpenGLVGroup):
             **kwargs,
         )
 
-    def init_points(self):
+    def init_points(self) -> None:
         uv_surface = self.uv_surface
 
         full_nu, full_nv = uv_surface.resolution