Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Deprecated :meth:`.VMobject.get_points` (#1991)

GameDungeon446c42d8d3b6
diff --git a/docs/source/tutorials/building_blocks.rst b/docs/source/tutorials/building_blocks.rst
index c159d0e26..8c117f880 100644
--- a/docs/source/tutorials/building_blocks.rst
+++ b/docs/source/tutorials/building_blocks.rst
@@ -381,7 +381,7 @@ and :meth:`~.Mobject.get_start`. Here is an example of some important coordinate
p2= [1,-1,0]
p3= [1,1,0]
p4= [-1,1,0]
- a = Line(p1,p2).append_points(Line(p2,p3).get_points()).append_points(Line(p3,p4).get_points())
+ a = Line(p1,p2).append_points(Line(p2,p3).points).append_points(Line(p3,p4).points)
point_start= a.get_start()
point_end = a.get_end()
point_center = a.get_center()
@@ -395,7 +395,7 @@ and :meth:`~.Mobject.get_start`. Here is an example of some important coordinate
self.add(Dot(a.get_bottom()).set_color(GREEN_D).scale(2))
self.add(Dot(a.get_center()).set_color(BLUE).scale(2))
self.add(Dot(a.point_from_proportion(0.5)).set_color(ORANGE).scale(2))
- self.add(*[Dot(x) for x in a.get_points()])
+ self.add(*[Dot(x) for x in a.points])
self.add(a)
Transforming mobjects into other mobjects
diff --git a/manim/animation/transform_matching_parts.py b/manim/animation/transform_matching_parts.py
index 9d58c36f1..7906841bb 100644
--- a/manim/animation/transform_matching_parts.py
+++ b/manim/animation/transform_matching_parts.py
@@ -222,7 +222,7 @@ class TransformMatchingShapes(TransformMatchingAbstractBase):
mobject.save_state()
mobject.center()
mobject.set_height(1)
- result = hash(np.round(mobject.get_points(), 3).tobytes())
+ result = hash(np.round(mobject.points, 3).tobytes())
mobject.restore()
return result
diff --git a/manim/mobject/changing.py b/manim/mobject/changing.py
index 89d2695ed..91352e5ed 100644
--- a/manim/mobject/changing.py
+++ b/manim/mobject/changing.py
@@ -167,4 +167,4 @@ class TracedPath(VMobject, metaclass=ConvertToOpenGL):
nppcc = self.n_points_per_curve
else:
nppcc = self.n_points_per_cubic_curve
- self.set_points(self.get_points()[nppcc:])
+ self.set_points(self.points[nppcc:])
diff --git a/manim/mobject/geometry.py b/manim/mobject/geometry.py
index d5c6c7d8f..e8b934bd3 100644
--- a/manim/mobject/geometry.py
+++ b/manim/mobject/geometry.py
@@ -257,10 +257,10 @@ class TipableVMobject(VMobject, metaclass=ConvertToOpenGL):
return self.tip_length
def get_first_handle(self):
- return self.get_points()[1]
+ return self.points[1]
def get_last_handle(self):
- return self.get_points()[-2]
+ return self.points[-2]
def get_end(self):
if self.has_tip():
@@ -380,7 +380,7 @@ class Arc(TipableVMobject):
anchors, and finds their intersection points
"""
# First two anchors and handles
- a1, h1, h2, a2 = self.get_points()[:4]
+ a1, h1, h2, a2 = self.points[:4]
if np.all(a1 == a2):
# For a1 and a2 to lie at the same point arc radius
@@ -406,7 +406,7 @@ class Arc(TipableVMobject):
return self
def stop_angle(self):
- return angle_of_vector(self.get_points()[-1] - self.get_arc_center()) % TAU
+ return angle_of_vector(self.points[-1] - self.get_arc_center()) % TAU
class ArcBetweenPoints(Arc):
@@ -593,7 +593,7 @@ class Circle(Arc):
The location of the point along the circle's circumference.
"""
- start_angle = angle_of_vector(self.get_points()[0] - self.get_center())
+ start_angle = angle_of_vector(self.points[0] - self.get_center())
return self.point_from_proportion((angle - start_angle) / TAU)
@staticmethod
@@ -863,10 +863,10 @@ class AnnularSector(Arc):
for radius in (self.inner_radius, self.outer_radius)
)
outer_arc.reverse_points()
- self.append_points(inner_arc.get_points())
- self.add_line_to(outer_arc.get_points()[0])
- self.append_points(outer_arc.get_points())
- self.add_line_to(inner_arc.get_points()[0])
+ self.append_points(inner_arc.points)
+ self.add_line_to(outer_arc.points[0])
+ self.append_points(outer_arc.points)
+ self.add_line_to(inner_arc.points[0])
init_points = generate_points
@@ -940,8 +940,8 @@ class Annulus(Circle):
outer_circle = Circle(radius=self.outer_radius)
inner_circle = Circle(radius=self.inner_radius)
inner_circle.reverse_points()
- self.append_points(outer_circle.get_points())
- self.append_points(inner_circle.get_points())
+ self.append_points(outer_circle.points)
+ self.append_points(inner_circle.points)
self.shift(self.arc_center)
init_points = generate_points
@@ -963,7 +963,7 @@ class Line(TipableVMobject):
def set_points_by_ends(self, start, end, buff=0, path_arc=0):
if path_arc:
arc = ArcBetweenPoints(self.start, self.end, angle=self.path_arc)
- self.set_points(arc.get_points())
+ self.set_points(arc.points)
else:
self.set_points_as_corners([start, end])
@@ -1212,7 +1212,7 @@ class DashedLine(Line):
array([-0.98333333, 0. , 0. ])
"""
- return self.submobjects[0].get_points()[1]
+ return self.submobjects[0].points[1]
def get_last_handle(self) -> np.ndarray:
"""Returns the point of the last handle.
@@ -1225,7 +1225,7 @@ class DashedLine(Line):
array([0.98333333, 0. , 0. ])
"""
- return self.submobjects[-1].get_points()[-2]
+ return self.submobjects[-1].points[-2]
class TangentLine(Line):
@@ -1860,7 +1860,7 @@ class Polygram(VMobject, metaclass=ConvertToOpenGL):
# To ensure that we loop through starting with last
arcs = [arcs[-1], *arcs[:-1]]
for arc1, arc2 in adjacent_pairs(arcs):
- new_points.extend(arc1.get_points())
+ new_points.extend(arc1.points)
line = Line(arc1.get_end(), arc2.get_start())
@@ -1869,7 +1869,7 @@ class Polygram(VMobject, metaclass=ConvertToOpenGL):
line.insert_n_curves(int(arc1.get_num_curves() * len_ratio))
- new_points.extend(line.get_points())
+ new_points.extend(line.points)
self.set_points(new_points)
@@ -2235,7 +2235,7 @@ class ArcPolygon(VMobject, metaclass=ConvertToOpenGL):
# the arcs, so that their new values are usable.
self.add(*arcs)
for arc in arcs:
- self.append_points(arc.get_points())
+ self.append_points(arc.points)
# This enables the use of ArcPolygon.arcs as a convenience
# because ArcPolygon[0] returns itself, not the first Arc.
@@ -2367,7 +2367,7 @@ class ArcPolygonFromArcs(VMobject, metaclass=ConvertToOpenGL):
if math.isnan(len_ratio) or math.isinf(len_ratio):
continue
line.insert_n_curves(int(arc1.get_num_curves() * len_ratio))
- self.append_points(line.get_points())
+ self.append_points(line.points)
class Triangle(RegularPolygon):
@@ -2641,7 +2641,7 @@ class ArrowTip(VMobject, metaclass=ConvertToOpenGL):
array([2., 0., 0.])
"""
- return self.get_points()[0]
+ return self.points[0]
@property
def vector(self):
@@ -2814,13 +2814,13 @@ class Cutout(VMobject, metaclass=ConvertToOpenGL):
def __init__(self, main_shape, *mobjects, **kwargs):
super().__init__(**kwargs)
- self.append_points(main_shape.get_points())
+ self.append_points(main_shape.points)
if main_shape.get_direction() == "CW":
sub_direction = "CCW"
else:
sub_direction = "CW"
for mobject in mobjects:
- self.append_points(mobject.force_direction(sub_direction).get_points())
+ self.append_points(mobject.force_direction(sub_direction).points)
class Angle(VMobject, metaclass=ConvertToOpenGL):
@@ -2922,8 +2922,8 @@ class Angle(VMobject, metaclass=ConvertToOpenGL):
norm = l1.get_length()
a1 = Angle(l1, l2, other_angle=True, radius=norm - 0.5).set_color(GREEN)
a2 = Angle(l1, l2, other_angle=True, radius=norm).set_color(GREEN)
- q1 = a1.get_points() # save all coordinates of points of angle a1
- q2 = a2.reverse_direction().get_points() # save all coordinates of points of angle a1 (in reversed direction)
+ q1 = a1.points # save all coordinates of points of angle a1
+ q2 = a2.reverse_direction().points # save all coordinates of points of angle a1 (in reversed direction)
pnts = np.concatenate([q1, q2, q1[0].reshape(1, 3)]) # adds points and ensures that path starts and ends at same point
mfill = VMobject().set_color(ORANGE)
mfill.set_points_as_corners(pnts).set_fill(GREEN, opacity=1)
@@ -3027,7 +3027,7 @@ class Angle(VMobject, metaclass=ConvertToOpenGL):
right_dot.move_to(dot_anchor)
self.add(right_dot)
- self.set_points(angle_mobject.get_points())
+ self.set_points(angle_mobject.points)
def get_lines(self) -> VGroup:
"""Get the lines forming an angle of the :class:`Angle` class.
diff --git a/manim/mobject/opengl_geometry.py b/manim/mobject/opengl_geometry.py
index 6a3e156fd..f71e096d2 100644
--- a/manim/mobject/opengl_geometry.py
+++ b/manim/mobject/opengl_geometry.py
@@ -173,10 +173,10 @@ class OpenGLTipableVMobject(OpenGLVMobject):
return self.tip_length
def get_first_handle(self):
- return self.get_points()[1]
+ return self.points[1]
def get_last_handle(self):
- return self.get_points()[-2]
+ return self.points[-2]
def get_end(self):
if self.has_tip():
@@ -252,7 +252,7 @@ class OpenGLArc(OpenGLTipableVMobject):
anchors, and finds their intersection points
"""
# First two anchors and handles
- a1, h, a2 = self.get_points()[:3]
+ a1, h, a2 = self.points[:3]
# Tangent vectors
t1 = h - a1
t2 = h - a2
@@ -373,10 +373,10 @@ class OpenGLAnnularSector(OpenGLArc):
for radius in (self.inner_radius, self.outer_radius)
)
outer_arc.reverse_points()
- self.append_points(inner_arc.get_points())
- self.add_line_to(outer_arc.get_points()[0])
- self.append_points(outer_arc.get_points())
- self.add_line_to(inner_arc.get_points()[0])
+ self.append_points(inner_arc.points)
+ self.add_line_to(outer_arc.points[0])
+ self.append_points(outer_arc.points)
+ self.add_line_to(inner_arc.points[0])
class OpenGLSector(OpenGLAnnularSector):
@@ -413,8 +413,8 @@ class OpenGLAnnulus(OpenGLCircle):
outer_circle = OpenGLCircle(radius=self.outer_radius)
inner_circle = OpenGLCircle(radius=self.inner_radius)
inner_circle.reverse_points()
- self.append_points(outer_circle.get_points())
- self.append_points(inner_circle.get_points())
+ self.append_points(outer_circle.points)
+ self.append_points(inner_circle.points)
self.shift(self.arc_center)
@@ -564,10 +564,10 @@ class OpenGLDashedLine(OpenGLLine):
return OpenGLLine.get_end(self)
def get_first_handle(self):
- return self.submobjects[0].get_points()[1]
+ return self.submobjects[0].points[1]
def get_last_handle(self):
- return self.submobjects[-1].get_points()[-2]
+ return self.submobjects[-1].points[-2]
class OpenGLTangentLine(OpenGLLine):
@@ -667,7 +667,7 @@ class OpenGLArrow(OpenGLLine):
# Tip
self.add_line_to(tip_width * UP / 2)
self.add_line_to(tip_length * LEFT)
- self.tip_index = len(self.get_points()) - 1
+ self.tip_index = len(self.points) - 1
self.add_line_to(tip_width * DOWN / 2)
self.add_line_to(points2[0])
# Close it out
@@ -694,11 +694,11 @@ class OpenGLArrow(OpenGLLine):
def get_start(self):
nppc = self.n_points_per_curve
- points = self.get_points()
+ points = self.points
return (points[0] + points[-nppc]) / 2
def get_end(self):
- return self.get_points()[self.tip_index]
+ return self.points[self.tip_index]
def put_start_and_end_on(self, start, end):
self.set_points_by_ends(start, end, buff=0, path_arc=self.path_arc)
@@ -779,12 +779,12 @@ class OpenGLPolygon(OpenGLVMobject):
# To ensure that we loop through starting with last
arcs = [arcs[-1], *arcs[:-1]]
for arc1, arc2 in adjacent_pairs(arcs):
- self.append_points(arc1.get_points())
+ self.append_points(arc1.points)
line = OpenGLLine(arc1.get_end(), arc2.get_start())
# Make sure anchors are evenly distributed
len_ratio = line.get_length() / arc1.get_arc_length()
line.insert_n_curves(int(arc1.get_num_curves() * len_ratio))
- self.append_points(line.get_points())
+ self.append_points(line.points)
return self
@@ -832,7 +832,7 @@ class OpenGLArrowTip(OpenGLTriangle):
return self.point_from_proportion(0.5)
def get_tip_point(self):
- return self.get_points()[0]
+ return self.points[0]
def get_vector(self):
return self.get_tip_point() - self.get_base()
diff --git a/manim/mobject/opengl_mobject.py b/manim/mobject/opengl_mobject.py
index 2faf1979f..70bb96f8b 100644
--- a/manim/mobject/opengl_mobject.py
+++ b/manim/mobject/opengl_mobject.py
@@ -15,6 +15,7 @@ from ..constants import *
from ..utils.bezier import integer_interpolate, interpolate
from ..utils.color import *
from ..utils.config_ops import _Data, _Uniforms
+from ..utils.deprecation import deprecated
# from ..utils.iterables import batch_by_property
from ..utils.iterables import (
@@ -292,7 +293,7 @@ class OpenGLMobject:
for mob in self.get_family():
arrs = []
if mob.has_points():
- arrs.append(mob.get_points())
+ arrs.append(mob.points)
if works_on_bounding_box:
arrs.append(mob.get_bounding_box())
@@ -312,8 +313,9 @@ class OpenGLMobject:
# Others related to points
def match_points(self, mobject):
- self.set_points(mobject.get_points())
+ self.set_points(mobject.points)
+ @deprecated(since="0.11.0", replacement="self.points")
def get_points(self):
return self.points
@@ -325,7 +327,7 @@ class OpenGLMobject:
def get_all_points(self):
if self.submobjects:
- return np.vstack([sm.get_points() for sm in self.get_family()])
+ return np.vstack([sm.points for sm in self.get_family()])
else:
return self.points
@@ -1036,12 +1038,12 @@ class OpenGLMobject:
def wag(self, direction=RIGHT, axis=DOWN, wag_factor=1.0):
for mob in self.family_members_with_points():
- alphas = np.dot(mob.get_points(), np.transpose(axis))
+ alphas = np.dot(mob.points, np.transpose(axis))
alphas -= min(alphas)
alphas /= max(alphas)
alphas = alphas ** wag_factor
mob.set_points(
- mob.get_points()
+ mob.points
+ np.dot(
alphas.reshape((len(alphas), 1)),
np.array(direction).reshape((1, mob.dim)),
diff --git a/manim/mobject/svg/brace.py b/manim/mobject/svg/brace.py
index 2ed1aacce..3b59e3986 100644
--- a/manim/mobject/svg/brace.py
+++ b/manim/mobject/svg/brace.py
@@ -138,9 +138,9 @@ class Brace(SVGPathMobject):
def get_tip(self):
# Returns the position of the seventh point in the path, which is the tip.
if config["renderer"] == "opengl":
- return self.get_points()[34]
+ return self.points[34]
- return self.get_points()[28] # = 7*4
+ return self.points[28] # = 7*4
def get_direction(self):
vect = self.get_tip() - self.get_center()
diff --git a/manim/mobject/svg/text_mobject.py b/manim/mobject/svg/text_mobject.py
index da89990f8..06333bf39 100644
--- a/manim/mobject/svg/text_mobject.py
+++ b/manim/mobject/svg/text_mobject.py
@@ -504,9 +504,9 @@ class Text(SVGMobject):
else:
nppc = self.n_points_per_cubic_curve
for each in self:
- if len(each.get_points()) == 0:
+ if len(each.points) == 0:
continue
- points = each.get_points()
+ points = each.points
last = points[0]
each.clear_points()
for index, point in enumerate(points):
@@ -1112,9 +1112,9 @@ class MarkupText(SVGMobject):
else:
nppc = self.n_points_per_cubic_curve
for each in self:
- if len(each.get_points()) == 0:
+ if len(each.points) == 0:
continue
- points = each.get_points()
+ points = each.points
last = points[0]
each.clear_points()
for index, point in enumerate(points):
diff --git a/manim/mobject/types/opengl_vectorized_mobject.py b/manim/mobject/types/opengl_vectorized_mobject.py
index e1688391c..cd3da8772 100644
--- a/manim/mobject/types/opengl_vectorized_mobject.py
+++ b/manim/mobject/types/opengl_vectorized_mobject.py
@@ -360,7 +360,7 @@ class OpenGLVMobject(OpenGLMobject):
self.append_points([self.get_last_point(), handle, anchor])
def add_line_to(self, point):
- end = self.get_points()[-1]
+ end = self.points[-1]
alphas = np.linspace(0, 1, self.n_points_per_curve)
if self.long_lines:
halfway = interpolate(end, point, 0.5)
@@ -392,10 +392,10 @@ class OpenGLVMobject(OpenGLMobject):
return self.get_num_points() % self.n_points_per_curve == 1
def get_last_point(self):
- return self.get_points()[-1]
+ return self.points[-1]
def get_reflection_of_last_handle(self):
- points = self.get_points()
+ points = self.points
return 2 * points[-1] - points[-2]
def close_path(self):
@@ -403,7 +403,7 @@ class OpenGLVMobject(OpenGLMobject):
self.add_line_to(self.get_subpaths()[-1][0])
def is_closed(self):
- return self.consider_points_equals(self.get_points()[0], self.get_points()[-1])
+ return self.consider_points_equals(self.points[0], self.points[-1])
def subdivide_sharp_curves(self, angle_threshold=30 * DEGREES, recurse=True):
vmobs = [vm for vm in self.get_family(recurse) if vm.has_points()]
@@ -498,12 +498,12 @@ class OpenGLVMobject(OpenGLMobject):
return self
def append_vectorized_mobject(self, vectorized_mobject):
- new_points = list(vectorized_mobject.get_points())
+ new_points = list(vectorized_mobject.points)
if self.has_new_path_started():
# Remove last point, which is starting
# a new path
- self.resize_data(len(self.get_points() - 1))
+ self.resize_data(len(self.points - 1))
self.append_points(new_points)
return self
@@ -522,7 +522,7 @@ class OpenGLVMobject(OpenGLMobject):
return self
def reverse_direction(self):
- self.set_points(self.get_points()[::-1])
+ self.set_points(self.points[::-1])
return self
def get_bezier_tuples_from_points(self, points):
@@ -532,7 +532,7 @@ class OpenGLVMobject(OpenGLMobject):
return [points[i : i + nppc] for i in range(0, len(points), nppc)]
def get_bezier_tuples(self):
- return self.get_bezier_tuples_from_points(self.get_points())
+ return self.get_bezier_tuples_from_points(self.points)
def get_subpaths_from_points(self, points):
nppc = self.n_points_per_curve
@@ -552,12 +552,12 @@ class OpenGLVMobject(OpenGLMobject):
]
def get_subpaths(self):
- return self.get_subpaths_from_points(self.get_points())
+ return self.get_subpaths_from_points(self.points)
def get_nth_curve_points(self, n):
assert n < self.get_num_curves()
nppc = self.n_points_per_curve
- return self.get_points()[nppc * n : nppc * (n + 1)]
+ return self.points[nppc * n : nppc * (n + 1)]
def get_nth_curve_function(self, n):
return bezier(self.get_nth_curve_points(n))
@@ -661,7 +661,7 @@ class OpenGLVMobject(OpenGLMobject):
self.throw_error_if_no_points()
if alpha == 1:
- return self.get_points()[-1]
+ return self.points[-1]
curves_and_lengths = tuple(self.get_curve_functions_with_lengths())
@@ -687,18 +687,18 @@ class OpenGLVMobject(OpenGLMobject):
for any i in range(0, len(anchors1))
"""
nppc = self.n_points_per_curve
- points = self.get_points()
+ points = self.points
return [points[i::nppc] for i in range(nppc)]
def get_start_anchors(self):
- return self.get_points()[0 :: self.n_points_per_curve]
+ return self.points[0 :: self.n_points_per_curve]
def get_end_anchors(self):
nppc = self.n_points_per_curve
- return self.get_points()[nppc - 1 :: nppc]
+ return self.points[nppc - 1 :: nppc]
def get_anchors(self):
- points = self.get_points()
+ points = self.points
if len(points) == 1:
return points
return np.array(
@@ -714,7 +714,7 @@ class OpenGLVMobject(OpenGLMobject):
def get_points_without_null_curves(self, atol=1e-9):
nppc = self.n_points_per_curve
- points = self.get_points()
+ points = self.points
distinct_curves = reduce(
op.or_,
[
@@ -754,7 +754,7 @@ class OpenGLVMobject(OpenGLMobject):
return np.zeros(3)
nppc = self.n_points_per_curve
- points = self.get_points()
+ points = self.points
p0 = points[0::nppc]
p1 = points[nppc - 1 :: nppc]
@@ -788,7 +788,7 @@ class OpenGLVMobject(OpenGLMobject):
if area > 0:
return area_vect / area
else:
- points = self.get_points()
+ points = self.points
return get_unit_normal(
points[1] - points[0],
points[2] - points[1],
@@ -801,7 +801,7 @@ class OpenGLVMobject(OpenGLMobject):
# Alignment
def align_points(self, vmobject):
- if self.get_num_points() == len(vmobject.get_points()):
+ if self.get_num_points() == len(vmobject.points):
return
for mob in self, vmobject:
@@ -812,7 +812,7 @@ class OpenGLVMobject(OpenGLMobject):
# If there's only one point, turn it into
# a null curve
if mob.has_new_path_started():
- mob.add_line_to(mob.get_points()[0])
+ mob.add_line_to(mob.points[0])
# Figure out what the subpaths are, and align
subpaths1 = self.get_subpaths()
@@ -846,7 +846,7 @@ class OpenGLVMobject(OpenGLMobject):
def insert_n_curves(self, n, recurse=True):
for mob in self.get_family(recurse):
if mob.get_num_curves() > 0:
- new_points = mob.insert_n_curves_to_point_list(n, mob.get_points())
+ new_points = mob.insert_n_curves_to_point_list(n, mob.points)
# TODO, this should happen in insert_n_curves_to_point_list
if mob.has_new_path_started():
new_points = np.vstack([new_points, mob.get_last_point()])
@@ -915,7 +915,7 @@ class OpenGLVMobject(OpenGLMobject):
i3 = nppc * upper_index
i4 = nppc * (upper_index + 1)
- vm_points = vmobject.get_points()
+ vm_points = vmobject.points
new_points = vm_points.copy()
if num_curves == 0:
new_points[:] = 0
@@ -965,7 +965,7 @@ class OpenGLVMobject(OpenGLMobject):
if not self.needs_new_triangulation:
return self.triangulation
- points = self.get_points()
+ points = self.points
if len(points) <= 1:
self.triangulation = np.zeros(0, dtype="i4")
@@ -1020,11 +1020,11 @@ class OpenGLVMobject(OpenGLMobject):
def wrapper(self, *args, **kwargs):
old_points = np.empty((0, 3))
for mob in self.family_members_with_points():
- old_points = np.concatenate((old_points, mob.get_points()), axis=0)
+ old_points = np.concatenate((old_points, mob.points), axis=0)
func(self, *args, **kwargs)
new_points = np.empty((0, 3))
for mob in self.family_members_with_points():
- new_points = np.concatenate((new_points, mob.get_points()), axis=0)
+ new_points = np.concatenate((new_points, mob.points), axis=0)
if not np.all(new_points == old_points):
self.refresh_triangulation()
self.refresh_unit_normal()
diff --git a/manim/mobject/types/vectorized_mobject.py b/manim/mobject/types/vectorized_mobject.py
index 599e45467..aab8f6910 100644
--- a/manim/mobject/types/vectorized_mobject.py
+++ b/manim/mobject/types/vectorized_mobject.py
@@ -32,7 +32,7 @@ from ...utils.bezier import (
partial_bezier_points,
)
from ...utils.color import BLACK, WHITE, color_to_rgba
-from ...utils.deprecation import deprecated_params
+from ...utils.deprecation import deprecated, deprecated_params
from ...utils.iterables import make_even, stretch_array_to_length, tuplify
from ...utils.simple_functions import clip_in_place
from ...utils.space_ops import rotate_vector, shoelace_direction
@@ -568,6 +568,7 @@ class VMobject(Mobject):
self.points = np.array(points)
return self
+ @deprecated(since="0.11.0", replacement="self.points")
def get_points(self):
return np.array(self.points)
@@ -937,7 +938,7 @@ class VMobject(Mobject):
return (points[i : i + nppcc] for i in range(0, len(points), nppcc))
def get_cubic_bezier_tuples(self):
- return self.get_cubic_bezier_tuples_from_points(self.get_points())
+ return self.get_cubic_bezier_tuples_from_points(self.points)
def _gen_subpaths_from_points(
self, points: np.ndarray, filter_func: typing.Callable[[int], bool]
@@ -995,7 +996,7 @@ class VMobject(Mobject):
typing.Tuple
subpaths.
"""
- return self.get_subpaths_from_points(self.get_points())
+ return self.get_subpaths_from_points(self.points)
def get_nth_curve_points(self, n: int) -> np.ndarray:
"""Returns the points defining the nth curve of the vmobject.
@@ -1136,7 +1137,7 @@ class VMobject(Mobject):
self.throw_error_if_no_points()
if alpha == 1:
- return self.get_points()[-1]
+ return self.points[-1]
curves_and_lengths = tuple(self.get_curve_functions_with_lengths())
@@ -1292,7 +1293,7 @@ class VMobject(Mobject):
if self.has_new_path_started():
new_path_point = self.get_last_point()
- new_points = self.insert_n_curves_to_point_list(n, self.get_points())
+ new_points = self.insert_n_curves_to_point_list(n, self.points)
self.set_points(new_points)
if new_path_point is not None:
diff --git a/manim/mobject/value_tracker.py b/manim/mobject/value_tracker.py
index 67ce33716..b381cfd51 100644
--- a/manim/mobject/value_tracker.py
+++ b/manim/mobject/value_tracker.py
@@ -74,11 +74,11 @@ class ValueTracker(Mobject, metaclass=ConvertToOpenGL):
def get_value(self) -> float:
"""Get the current value of this ValueTracker."""
- return self.get_points()[0, 0]
+ return self.points[0, 0]
def set_value(self, value: float):
"""Sets a new scalar value to the ValueTracker"""
- self.get_points()[0, 0] = value
+ self.points[0, 0] = value
return self
def increment_value(self, d_value: float):
@@ -130,7 +130,7 @@ class ValueTracker(Mobject, metaclass=ConvertToOpenGL):
Turns self into an interpolation between mobject1
and mobject2.
"""
- self.set_points(path_func(mobject1.get_points(), mobject2.get_points(), alpha))
+ self.set_points(path_func(mobject1.points, mobject2.points, alpha))
return self
@@ -164,10 +164,10 @@ class ComplexValueTracker(ValueTracker):
The value is internally stored as a points array [a, b, 0]. This can be accessed directly
to represent the value geometrically, see the usage example."""
- return complex(*self.get_points()[0, :2])
+ return complex(*self.points[0, :2])
def set_value(self, z):
"""Sets a new complex value to the ComplexValueTracker"""
z = complex(z)
- self.get_points()[0, :2] = (z.real, z.imag)
+ self.points[0, :2] = (z.real, z.imag)
return self
diff --git a/manim/renderer/opengl_renderer.py b/manim/renderer/opengl_renderer.py
index f47418992..8ef16274a 100644
--- a/manim/renderer/opengl_renderer.py
+++ b/manim/renderer/opengl_renderer.py
@@ -189,14 +189,14 @@ class OpenGLCamera(OpenGLMobject):
def get_center(self):
# Assumes first point is at the center
- return self.get_points()[0]
+ return self.points[0]
def get_width(self):
- points = self.get_points()
+ points = self.points
return points[2, 0] - points[1, 0]
def get_height(self):
- points = self.get_points()
+ points = self.points
return points[4, 1] - points[3, 1]
def get_focal_distance(self):
diff --git a/manim/renderer/vectorized_mobject_rendering.py b/manim/renderer/vectorized_mobject_rendering.py
index 6f77c90e9..fde06d2da 100644
--- a/manim/renderer/vectorized_mobject_rendering.py
+++ b/manim/renderer/vectorized_mobject_rendering.py
@@ -98,7 +98,7 @@ def triangulate_mobject(mob):
# how to send the points as to the vertex shader.
# First triangles come directly from the points
# normal_vector = mob.get_unit_normal()
- points = mob.get_points()
+ points = mob.points
b0s = points[0::3]
b1s = points[1::3]