Skip to content

armgit / manim

Public Imported from GitHub
0

A community-maintained Python framework for creating mathematical animations.

Cleaning up Line

Grant Sandersonce2b508e102e
diff --git a/manimlib/mobject/geometry.py b/manimlib/mobject/geometry.py
index 0a6c3fbab..a00d35d80 100644
--- a/manimlib/mobject/geometry.py
+++ b/manimlib/mobject/geometry.py
@@ -8,12 +8,12 @@ from manimlib.mobject.types.vectorized_mobject import VGroup
from manimlib.mobject.types.vectorized_mobject import VMobject
from manimlib.utils.bezier import interpolate
from manimlib.utils.config_ops import digest_config
-from manimlib.utils.paths import path_along_arc
from manimlib.utils.space_ops import angle_of_vector
from manimlib.utils.space_ops import center_of_mass
from manimlib.utils.space_ops import compass_directions
from manimlib.utils.space_ops import line_intersection
from manimlib.utils.space_ops import get_norm
+from manimlib.utils.space_ops import normalize
from manimlib.utils.space_ops import rotate_vector
@@ -118,34 +118,14 @@ class Arc(VMobject):
class ArcBetweenPoints(Arc):
def __init__(self, start_point, end_point, angle=TAU / 4, **kwargs):
- if angle == 0:
- raise Exception("Arc with zero curve angle: use Line instead.")
-
- midpoint = 0.5 * (start_point + end_point)
- distance_vector = end_point - start_point
- normal_vector = np.array([-distance_vector[1], distance_vector[0], 0])
- distance = get_norm(normal_vector)
- normal_vector /= distance
- if angle < 0:
- normal_vector *= -1
-
- radius = distance / 2 / np.sin(0.5 * np.abs(angle))
- length = distance / 2 / np.tan(0.5 * np.abs(angle))
- arc_center = midpoint + length * normal_vector
- w = start_point - arc_center
- if w[0] != 0:
- start_angle = np.arctan2(w[1], w[0])
- else:
- start_angle = np.pi / 2
-
Arc.__init__(
self,
- start_angle=start_angle,
angle=angle,
- radius=radius,
- arc_center=arc_center,
- **kwargs
+ **kwargs,
)
+ if angle == 0:
+ self.set_points_as_corners([LEFT, RIGHT])
+ self.put_start_and_end_on(start_point, end_point)
class CurvedArrow(ArcBetweenPoints):
@@ -277,7 +257,6 @@ class Line(VMobject):
CONFIG = {
"buff": 0,
"path_arc": None, # angle of arc specified here
- "n_arc_anchors": 10, # Only used if path_arc is not None
}
def __init__(self, start, end, **kwargs):
@@ -286,14 +265,14 @@ class Line(VMobject):
VMobject.__init__(self, **kwargs)
def generate_points(self):
- if self.path_arc is None:
- self.set_points_as_corners([self.start, self.end])
+ if self.path_arc:
+ arc = ArcBetweenPoints(
+ self.start, self.end,
+ angle=self.path_arc
+ )
+ self.set_points(arc.points)
else:
- path_func = path_along_arc(self.path_arc)
- self.set_points_smoothly([
- path_func(self.start, self.end, alpha)
- for alpha in np.linspace(0, 1, self.n_arc_anchors)
- ])
+ self.set_points_as_corners([self.start, self.end])
self.account_for_buff()
def set_path_arc(self, new_value):
@@ -301,8 +280,10 @@ class Line(VMobject):
self.generate_points()
def account_for_buff(self):
+ if self.buff == 0:
+ return
length = self.get_arc_length()
- if length < 2 * self.buff or self.buff == 0:
+ if length < 2 * self.buff:
return
buff_proportion = self.buff / length
self.pointwise_become_partial(
@@ -310,20 +291,24 @@ class Line(VMobject):
)
def set_start_and_end(self, start, end):
- start_to_end = self.pointify(end) - self.pointify(start)
- vect = np.zeros(len(start_to_end))
- longer_dim = np.argmax(list(map(abs, start_to_end)))
- vect[longer_dim] = start_to_end[longer_dim]
- self.start, self.end = [
- arg.get_edge_center(unit * vect)
- if isinstance(arg, Mobject)
- else np.array(arg)
- for arg, unit in zip([start, end], [1, -1])
- ]
-
- def pointify(self, mob_or_point):
+ # If either start or end are Mobjects, this
+ # gives their centers
+ rough_start = self.pointify(start)
+ rough_end = self.pointify(end)
+ vect = normalize(rough_end - rough_start)
+ # Now that we know the direction between them,
+ # we can the appropriate boundary point from
+ # start and end, if they're mobjects
+ self.start = self.pointify(start, vect)
+ self.end = self.pointify(end, -vect)
+
+ def pointify(self, mob_or_point, direction=None):
if isinstance(mob_or_point, Mobject):
- return mob_or_point.get_center()
+ mob = mob_or_point
+ if direction is None:
+ return mob.get_center()
+ else:
+ return mob.get_boundary_point(direction)
return np.array(mob_or_point)
def get_length(self):
@@ -332,11 +317,13 @@ class Line(VMobject):
def get_arc_length(self):
if self.path_arc:
- anchors = self.get_anchors()
- return sum([
- get_norm(a2 - a1)
- for a1, a2 in zip(anchors, anchors[1:])
+ points = np.array([
+ self.point_from_proportion(a)
+ for a in np.linspace(0, 1, 100)
])
+ diffs = points[1:] - points[:-1]
+ norms = np.apply_along_axis(get_norm, 1, diffs)
+ return np.sum(norms)
else:
return self.get_length()