manim-extensions 1.0.0__py3-none-any.whl

manim_extensions/__init__.py

@@ -0,0 +1,3 @@
+from .mobjects import *
+from .geometry import *
+from .animations import *

manim_extensions/animations.py

@@ -0,0 +1,123 @@
+from manim import *
+import numpy as np
+
+
+def VisDrawArc(
+    scene: Scene,
+    arc: Arc,
+    axis: np.ndarray = OUT,
+    run_time: float = 1,
+) -> None:
+    """可视化绘制圆弧的动画。
+
+    在场景中播放绘制圆弧的动画，同时显示一个沿圆弧移动的点及半径虚线。
+
+    Args:
+        scene: Manim 场景对象。
+        arc: 要绘制的圆弧。
+        axis: 旋转轴方向，``OUT`` 为逆时针，``IN`` 为顺时针。默认为 ``OUT``。
+        run_time: 动画持续时间（秒）。默认为 1。
+    """
+    # 获取弧线的起点、终点和圆心
+    start_point = arc.point_from_proportion(0)
+    end_point = arc.point_from_proportion(1)
+    center = arc.get_arc_center()
+
+    # 根据轴方向确定旋转的起始点和方向
+    if np.array_equal(axis, OUT):  # 逆时针
+        draw_arc = arc  # 使用原始弧线
+        rotation_start = start_point
+        total_angle = arc.get_angle()
+    else:  # 顺时针 (axis=IN)
+        # 创建一个与原弧线方向相反的新弧线
+        draw_arc = Arc(
+            start_angle=angle_of_vector(end_point - center),
+            angle=-arc.get_angle(),  # 负角度表示相反方向
+            radius=np.linalg.norm(end_point - center),
+            arc_center=center,
+            color=arc.get_color(),
+            stroke_width=arc.get_stroke_width(),
+        )
+        rotation_start = end_point
+        total_angle = -arc.get_angle()
+
+    # 创建移动点的标记
+    moving_dot = Dot(point=rotation_start)
+
+    # 创建从圆心到移动点的虚线
+    radius_line = DashedLine(center, rotation_start)
+
+    # 计算实际弧线的半径和起始角度
+    r = np.linalg.norm(rotation_start - center)
+    start_angle = angle_of_vector(rotation_start - center)
+
+    # 创建一个跟踪旋转进度的变量
+    progress = ValueTracker(0)
+
+    # 更新移动点的位置
+    moving_dot.add_updater(
+        lambda d: d.move_to(
+            center
+            + r
+            * np.array(
+                [
+                    np.cos(start_angle + progress.get_value() * total_angle),
+                    np.sin(start_angle + progress.get_value() * total_angle),
+                    0,
+                ]
+            )
+        )
+    )
+
+    # 更新半径线
+    radius_line.add_updater(
+        lambda l: l.become(DashedLine(center, moving_dot.get_center()))
+    )
+
+    # 添加所有元素到场景
+    scene.add(moving_dot, radius_line)
+
+    # 同步执行弧线绘制和点的旋转动画（1秒持续时间）
+    scene.play(
+        Create(draw_arc, rate_func=linear),  # 使用调整后的弧线
+        progress.animate.set_value(1),
+        run_time=run_time,
+        rate_func=linear,
+    )
+
+    # 清除更新器
+    moving_dot.clear_updaters()
+    radius_line.clear_updaters()
+
+    # 移除临时元素
+    scene.remove(moving_dot, radius_line)
+
+
+class TypeWriter(Animation):
+    """打字机效果动画。
+
+    逐个字符显示 ``Text`` 对象的内容，模拟打字机输入效果。
+    默认自动根据字符数量与间隔计算动画总时长。
+
+    Args:
+        mobject: 要动画显示的 ``Text`` 对象。
+        interval: 字符间显示间隔（秒）。默认为 2。
+        **kwargs: 传递给 ``Animation`` 的其他关键字参数。
+    """
+
+    def __init__(self, mobject: Text, interval: float = 2, **kwargs) -> None:
+        assert isinstance(mobject, Text), "TypeWriter only supports Text mobjects."
+        self.interval = interval
+        self.char_count = len(mobject.submobjects)
+
+        # 自动计算run_time
+        if "run_time" not in kwargs:
+            kwargs["run_time"] = self.char_count * self.interval
+
+        super().__init__(mobject, **kwargs)
+
+    def interpolate_mobject(self, alpha: float) -> Text:
+        current_index = int(alpha * self.char_count)
+        for i, char in enumerate(self.mobject.submobjects):
+            char.set_opacity(1 if i < current_index else 0)
+        return self.mobject

manim_extensions/geometry.py

@@ -0,0 +1,342 @@
+from manim import *
+import math
+import numpy as np
+from typing import Optional, Tuple, Union
+
+
+def CircleInt(
+    circle1: Circle, circle2: Circle
+) -> Optional[Tuple[list[float], list[float]]]:
+    """计算两个圆的交点。
+
+    Args:
+        circle1: 第一个圆。
+        circle2: 第二个圆。
+
+    Returns:
+        若两圆相交，返回包含两个交点坐标的元组，每个坐标为 ``[x, y, 0]``；
+        若不相交，返回 ``None``。
+    """
+    circle1_center = circle1.get_center()
+    circle1_radius = circle1.radius
+    circle2_center = circle2.get_center()
+    circle2_radius = circle2.radius
+    x1, y1, _ = circle1_center
+    x2, y2, _ = circle2_center
+    d = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+    if d > circle1_radius + circle2_radius or d < abs(circle1_radius - circle2_radius):
+        return None
+    a = (circle1_radius**2 - circle2_radius**2 + d**2) / (2 * d)
+    h = math.sqrt(circle1_radius**2 - a**2)
+    xm = x1 + a * (x2 - x1) / d
+    ym = y1 + a * (y2 - y1) / d
+    xs1 = xm + h * (y2 - y1) / d
+    xs2 = xm - h * (y2 - y1) / d
+    ys1 = ym - h * (x2 - x1) / d
+    ys2 = ym + h * (x2 - x1) / d
+    return [xs1, ys1, 0], [xs2, ys2, 0]
+
+
+def LineCircleInt(
+    line: Line, circle: Circle
+) -> Optional[Union[Tuple[np.ndarray, np.ndarray], np.ndarray]]:
+    """计算线段与圆的交点。
+
+    仅返回落在线段参数范围 ``[0, 1]`` 内的交点。
+
+    Args:
+        line: 线段。
+        circle: 圆。
+
+    Returns:
+        若有两个交点，返回两个交点坐标的元组；
+        若有一个交点，返回该交点坐标；
+        若无交点，返回 ``None``。
+    """
+    p1 = line.get_start()
+    p2 = line.get_end()
+    c = circle.get_center()
+    r = circle.radius
+    dx, dy, _ = p2 - p1
+    cx, cy, _ = p1 - c
+    a = dx**2 + dy**2
+    b = 2 * (dx * cx + dy * cy)
+    c = cx**2 + cy**2 - r**2
+    discriminant = b**2 - 4 * a * c
+    if discriminant < 0:
+        return None
+    t1 = (-b + math.sqrt(discriminant)) / (2 * a)
+    t2 = (-b - math.sqrt(discriminant)) / (2 * a)
+    intersections = []
+    for t in [t1, t2]:
+        if 0 <= t <= 1:
+            intersection = p1 + t * (p2 - p1)
+            intersections.append(intersection)
+    try:
+        return intersections[0], intersections[1]
+    except Exception:
+        try:
+            return intersections[0]
+        except Exception:
+            return None
+
+
+def LineInt(line1: Line, line2: Line) -> Optional[list[float]]:
+    """计算两条线段的交点。
+
+    在二维平面上计算两条无限延长线段的交点
+    （返回结果不限制在线段端点范围内）。
+
+    Args:
+        line1: 第一条线段。
+        line2: 第二条线段。
+
+    Returns:
+        若两直线相交，返回交点坐标 ``[x, y, 0]``；
+        若平行，返回 ``None``。
+    """
+
+    def det(a: tuple[float, float], b: tuple[float, float]) -> float:
+        return a[0] * b[1] - a[1] * b[0]
+
+    p1 = line1.get_start()[:2]
+    p2 = line1.get_end()[:2]
+    p3 = line2.get_start()[:2]
+    p4 = line2.get_end()[:2]
+    xdiff = (p1[0] - p2[0], p3[0] - p4[0])
+    ydiff = (p1[1] - p2[1], p3[1] - p4[1])
+    div = det(xdiff, ydiff)
+    if div == 0:
+        return None
+    d = (det(p1, p2), det(p3, p4))
+    x = det(d, xdiff) / div
+    y = det(d, ydiff) / div
+    return [x, y, 0]
+
+
+def LineArcInt(
+    line: Line, arc: Arc
+) -> Optional[Union[Tuple[list[float], list[float]], list[float]]]:
+    """计算线段与圆弧的交点。
+
+    Args:
+        line: 线段。
+        arc: 圆弧。
+
+    Returns:
+        若有两个交点，返回两个交点坐标的元组；
+        若有一个交点，返回该交点坐标列表；
+        若无交点，返回 ``None``。
+    """
+    # 获取线段起点和终点（仅x,y坐标）
+    p1 = line.start[:2]
+    p2 = line.end[:2]
+
+    # 处理线段退化为点的情况
+    direction = p2 - p1
+    length = np.linalg.norm(direction)
+    if length < 1e-8:
+        return None
+
+    # 获取圆弧参数（关键修正：使用ManimCE的正确属性）
+    center = arc.arc_center[:2]  # 圆弧中心（x,y）
+    radius = arc.radius  # 半径
+    start_angle = arc.start_angle  # 起始角度（弧度）
+    angle = arc.angle  # 角度跨度（弧度，正=逆时针，负=顺时针）
+
+    # 线段参数方程转换（以圆弧中心为原点）
+    p1_centered = p1 - center
+    p2_centered = p2 - center
+    dx = p2_centered[0] - p1_centered[0]
+    dy = p2_centered[1] - p1_centered[1]
+
+    # 联立线段与圆的方程（二次方程）
+    a = dx**2 + dy**2
+    b = 2 * (p1_centered[0] * dx + p1_centered[1] * dy)
+    c = p1_centered[0] ** 2 + p1_centered[1] ** 2 - radius**2
+    discriminant = b**2 - 4 * a * c
+
+    # 无实根（直线与圆无交点）
+    if discriminant < 0:
+        return None
+
+    # 计算t值（线段参数）
+    sqrt_d = np.sqrt(discriminant)
+    t1 = (-b + sqrt_d) / (2 * a)
+    t2 = (-b - sqrt_d) / (2 * a)
+    t_values = []
+    for t in [t1, t2]:
+        if 0 <= t <= 1 and (len(t_values) == 0 or abs(t - t_values[0]) > 1e-8):
+            t_values.append(t)
+
+    # 检查交点是否在圆弧范围内（关键修正：角度判断+容差）
+    intersections = []
+    TOLERANCE = 1e-6  # 角度容差（弧度）
+    for t in t_values:
+        # 计算交点相对圆弧中心的坐标
+        x = p1_centered[0] + t * dx
+        y = p1_centered[1] + t * dy
+        theta = np.arctan2(y, x) % (2 * np.pi)  # 交点角度（0~2π弧度）
+
+        # 圆弧的角度范围（模2π处理）
+        start_angle_mod = start_angle % (2 * np.pi)
+        end_angle_mod = (start_angle + angle) % (2 * np.pi)
+
+        # 判断角度是否在圆弧范围内（带容差）
+        if angle > 0:  # 逆时针圆弧
+            if start_angle_mod < end_angle_mod:
+                valid = (
+                    start_angle_mod - TOLERANCE
+                    <= theta
+                    <= end_angle_mod + TOLERANCE
+                )
+            else:
+                valid = (theta >= start_angle_mod - TOLERANCE) or (
+                    theta <= end_angle_mod + TOLERANCE
+                )
+        else:  # 顺时针圆弧
+            if end_angle_mod < start_angle_mod:
+                valid = (
+                    end_angle_mod - TOLERANCE
+                    <= theta
+                    <= start_angle_mod + TOLERANCE
+                )
+            else:
+                valid = (theta <= start_angle_mod + TOLERANCE) or (
+                    theta >= end_angle_mod - TOLERANCE
+                )
+
+        if valid:
+            # 转换为绝对坐标（添加z=0）
+            intersection = [x + center[0], y + center[1], 0.0]
+            intersections.append(intersection)
+    try:
+        return intersections[0], intersections[1]
+    except Exception:
+        try:
+            return intersections[0]
+        except Exception:
+            return None
+
+
+def TangentPoint(
+    p1: Union[np.ndarray, tuple, list],
+    p2: Union[np.ndarray, tuple, list],
+    line_start: Union[np.ndarray, tuple, list],
+    line_end: Union[np.ndarray, tuple, list],
+) -> Optional[np.ndarray]:
+    """计算以两点为圆上点且与线段相切的切点坐标。
+
+    Args:
+        p1: 圆上的第一个点，格式为 ``(x, y)`` 或 ``(x, y, z)``。
+        p2: 圆上的第二个点，格式为 ``(x, y)`` 或 ``(x, y, z)``。
+        line_start: 线段的起点，格式为 ``(x, y)`` 或 ``(x, y, z)``。
+        line_end: 线段的终点，格式为 ``(x, y)`` 或 ``(x, y, z)``。
+
+    Returns:
+        切点坐标 ``(x, y, 0)`` 的 numpy 数组；
+        若无法计算则返回 ``None``。
+    """
+
+    def to_3d(point: Union[np.ndarray, tuple, list]) -> np.ndarray:
+        if len(point) == 2:
+            return np.array([point[0], point[1], 0.0])
+        return np.array(point[:3])
+
+    p1 = to_3d(p1)
+    p2 = to_3d(p2)
+    line_start = to_3d(line_start)
+    line_end = to_3d(line_end)
+
+    # 计算线段方向向量
+    line_direction = line_end - line_start
+    line_length = np.linalg.norm(line_direction)
+
+    # 处理线段退化为点的情况
+    if line_length < 1e-8:
+        # 检查线段端点是否在圆上
+        dist_p1 = np.linalg.norm(line_start - p1)
+        dist_p2 = np.linalg.norm(line_start - p2)
+        if abs(dist_p1 - dist_p2) < 1e-8:
+            return line_start
+        return None
+
+    line_direction = line_direction / line_length
+
+    # 计算线段p1-p2的中点
+    midpoint = (p1 + p2) / 2
+
+    # 计算线段p1-p2的方向向量
+    p1p2_direction = p2 - p1
+    p1p2_length = np.linalg.norm(p1p2_direction)
+
+    if p1p2_length < 1e-8:
+        # p1和p2重合，无法确定唯一的圆
+        return None
+
+    p1p2_direction = p1p2_direction / p1p2_length
+
+    # 计算线段p1-p2的垂直向量（在二维平面上）
+    perpendicular_dir = np.array([-p1p2_direction[1], p1p2_direction[0], 0.0])
+
+    # 构建线性方程组求解圆心c = midpoint + t * perpendicular_dir
+    cross_perp_line = np.cross(perpendicular_dir, line_direction)
+    cross_mid_line = np.cross(midpoint - line_start, line_direction)
+
+    a = np.dot(perpendicular_dir, perpendicular_dir) - np.dot(
+        cross_perp_line, cross_perp_line
+    )
+    b = 2 * (
+        np.dot(midpoint - p1, perpendicular_dir)
+        - np.dot(cross_mid_line, cross_perp_line)
+    )
+    c = np.dot(midpoint - p1, midpoint - p1) - np.dot(
+        cross_mid_line, cross_mid_line
+    )
+
+    # 处理a接近零的特殊情况（退化为一次方程）
+    if abs(a) < 1e-8:
+        if abs(b) < 1e-8:
+            return None  # 无解或无穷多解
+        t = -c / b
+        centers = [midpoint + t * perpendicular_dir]
+    else:
+        # 计算判别式
+        discriminant = b**2 - 4 * a * c
+
+        if discriminant < 0:
+            # 无实数解
+            return None
+
+        # 求解t
+        sqrt_d = np.sqrt(discriminant)
+        t1 = (-b + sqrt_d) / (2 * a)
+        t2 = (-b - sqrt_d) / (2 * a)
+
+        # 计算可能的圆心
+        centers = [midpoint + t * perpendicular_dir for t in [t1, t2]]
+
+    # 计算对应的切点（在直线上）
+    valid_tangents = []
+    for center in centers:
+        # 计算从line_start到center的向量在直线方向上的投影
+        projection = np.dot(center - line_start, line_direction)
+
+        # 检查投影是否在线段范围内 [0, line_length]
+        if 0 <= projection <= line_length:
+            # 计算切点
+            tangent_point = line_start + projection * line_direction
+
+            # 验证切点到圆心的距离是否等于圆心到p1的距离
+            radius = np.linalg.norm(center - p1)
+            dist_to_tangent = np.linalg.norm(center - tangent_point)
+
+            if abs(radius - dist_to_tangent) < 1e-6:
+                valid_tangents.append(tangent_point)
+
+    # 选择距离p1和p2较近的解
+    if not valid_tangents:
+        return None
+
+    # 如果有多个解，选择第一个
+    return valid_tangents[0]

manim_extensions/mobjects.py

@@ -0,0 +1,193 @@
+from manim import *
+import numpy as np
+
+
+class ChineseMathTex(MathTex):
+    """支持中文显示的 MathTex 类。
+
+    自动将输入文本中的中文字符用 ``\\text{}`` 包裹，
+    并配置 ``xelatex`` 与 ``xeCJK`` 宏包以支持中文字体渲染。
+
+    Args:
+        *texts: 要渲染的 LaTeX 文本字符串。
+        font: 中文字体名称。默认为 ``"SimSun"``。
+        tex_to_color_map: 文本到颜色的映射字典。默认为 ``{}``。
+        **kwargs: 传递给 ``MathTex`` 的其他关键字参数。
+    """
+
+    def __init__(
+        self,
+        *texts: str,
+        font: str = "SimSun",
+        tex_to_color_map: dict = {},
+        **kwargs,
+    ) -> None:
+        tex_template = TexTemplate(tex_compiler="xelatex", output_format=".xdv")
+        tex_template.add_to_preamble(r"\usepackage{amsmath}")
+        tex_template.add_to_preamble(r"\usepackage{xeCJK}")
+        tex_template.add_to_preamble(rf"\setCJKmainfont{{{font}}}")
+
+        combined_chinesetext = []
+        for text in texts:
+            chinesetext = ""
+            for i in range(len(text)):
+                if (
+                    ("\u4e00" <= text[i] <= "\u9fff")
+                    or ("\u3000" <= text[i] <= "\u303f")
+                    or ("\uff00" <= text[i] <= "\uffef")
+                ):
+                    chinesetext += rf"\text{{{text[i]}}}"
+                else:
+                    chinesetext += text[i]
+            combined_chinesetext.append(chinesetext)
+
+        new_dict = {}
+        for key in tex_to_color_map.keys():
+            new_key = ""
+            for char in key:
+                if (
+                    ("\u4e00" <= char <= "\u9fff")
+                    or ("\u3000" <= char <= "\u303f")
+                    or ("\uff00" <= char <= "\uffef")
+                ):
+                    new_key += rf"\text{{{char}}}"
+                else:
+                    new_key += char
+            new_dict[new_key] = tex_to_color_map[key]
+
+        super().__init__(
+            *combined_chinesetext,
+            tex_template=tex_template,
+            tex_to_color_map=new_dict,
+            **kwargs,
+        )
+
+
+class LabelDot(VGroup):
+    """带标签的圆点。
+
+    在指定位置创建一个圆点，并在其旁边添加 MathTex 标签。
+
+    Args:
+        dot_label: 标签文本内容。
+        dot_pos: 圆点的位置坐标。
+        label_pos: 标签相对圆点的方向。默认为 ``DOWN``。
+        buff: 标签与圆点之间的间距。默认为 0.1。
+        **kwargs: 传递给 ``VGroup`` 的其他关键字参数。
+    """
+
+    def __init__(
+        self,
+        dot_label: str,
+        dot_pos: np.ndarray,
+        label_pos: np.ndarray = DOWN,
+        buff: float = 0.1,
+        **kwargs,
+    ) -> None:
+        super().__init__(**kwargs)
+        dot = Dot().move_to(dot_pos)
+        label = MathTex(dot_label).next_to(dot, label_pos, buff=buff)
+        self.add(dot, label)
+
+
+class MathTexLine(VGroup):
+    """带 MathTex 公式的线段。
+
+    创建一条线段，并在其指定方向旁放置一个 MathTex 公式。
+
+    Args:
+        formula: 要放置的 MathTex 公式对象。
+        direction: 公式相对线段的方向。默认为 ``UP``。
+        buff: 公式与线段之间的间距。默认为 0.5。
+        **kwargs: 传递给 ``Line`` 的其他关键字参数。
+    """
+
+    def __init__(
+        self,
+        formula: MathTex,
+        direction: np.ndarray = UP,
+        buff: float = 0.5,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        line = Line(**kwargs)
+        tex = formula.next_to(line, direction, buff=buff)
+        self.add(line, tex)
+
+
+class MathTexBrace(VGroup):
+    """带 MathTex 公式的花括号。
+
+    为指定对象创建一个花括号，并在其旁边放置一个 MathTex 公式。
+
+    Args:
+        target: 要被花括号标注的目标对象（如线段、矩形等）。
+        formula: 要放置的 MathTex 公式对象。
+        direction: 公式与花括号相对目标的方向。默认为 ``UP``。
+        buff: 公式与花括号之间的间距。默认为 0.5。
+        **kwargs: 传递给 ``Brace`` 的其他关键字参数。
+    """
+
+    def __init__(
+        self,
+        target,
+        formula: MathTex,
+        direction: np.ndarray = UP,
+        buff: float = 0.5,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        brace = Brace(target, direction=direction, **kwargs)
+        tex = formula.next_to(brace, direction, buff=buff)
+        self.add(brace, tex)
+
+
+class MathTexDoublearrow(VGroup):
+    """带 MathTex 公式的双向箭头。
+
+    创建一个双向箭头，并在其指定方向旁放置一个 MathTex 公式。
+
+    Args:
+        formula: 要放置的 MathTex 公式对象。
+        direction: 公式相对双向箭头的方向。默认为 ``UP``。
+        buff: 公式与双向箭头之间的间距。默认为 0.5。
+        **kwargs: 传递给 ``DoubleArrow`` 的其他关键字参数。
+    """
+
+    def __init__(
+        self,
+        formula: MathTex,
+        direction: np.ndarray = UP,
+        buff: float = 0.5,
+        **kwargs,
+    ) -> None:
+        super().__init__()
+        doublearrow = DoubleArrow(**kwargs)
+        tex = formula.next_to(doublearrow, direction, buff=buff)
+        self.add(doublearrow, tex)
+
+
+class ExtendedLine(Line):
+    """可延长的线段。
+
+    基于一条已有的 ``Line``，在其两端按原方向各延长指定距离。
+
+    Args:
+        line: 作为基准的原始线段。
+        extend_distance: 两端各延长的距离。
+        **kwargs: 传递给 ``Line`` 的其他关键字参数。
+    """
+
+    def __init__(self, line: Line, extend_distance: float, **kwargs) -> None:
+        start_point = line.get_start()
+        end_point = line.get_end()
+        direction_vector = end_point - start_point
+        vector_length = np.linalg.norm(direction_vector)
+        if vector_length < 1e-8:
+            super().__init__(start_point, end_point, **kwargs)
+        else:
+            unit_direction_vector = direction_vector / vector_length
+            new_start_point = start_point - extend_distance * unit_direction_vector
+            new_end_point = end_point + extend_distance * unit_direction_vector
+            super().__init__(new_start_point, new_end_point, **kwargs)
+        self.match_style(line)

manim_extensions-1.0.0.dist-info/METADATA

@@ -0,0 +1,586 @@
+Metadata-Version: 2.4
+Name: manim_extensions
+Version: 1.0.0
+Summary: A package for tools and extensions in Manim
+Author-email: Zhu Chongjing <zhuchongjing_pypi@163.com>
+License: MIT
+Project-URL: Homepage, https://github.com/zhuchongjing/manim_extensions
+Project-URL: Issues, https://github.com/zhuchongjing/manim_extensions/issues
+Keywords: manim,animation,math,latex,geometry
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: manim
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+
+# manim_extensions
+
+[English](#english) | [中文](#中文)
+
+<a name="中文"></a>
+## 中文
+
+manim_extensions 是一个用于 [Manim](https://www.manim.community/) 的扩展工具包，提供了中文公式渲染、几何计算、带标注的图形以及常用动画效果，帮助你更高效地制作数学动画。
+
+### 安装
+
+```bash
+pip install manim_extensions
+```
+
+依赖：`manim`
+
+### 模块概览
+
+| 模块 | 说明 |
+|------|------|
+| `mobjects` | Mobject 类扩展，包含中文公式、带标签圆点、可延长线段等 |
+| `geometry` | 纯几何计算函数，用于求交点、切点等 |
+| `animations` | 动画效果，如可视化绘弧、打字机效果 |
+
+---
+
+### mobjects 模块
+
+#### `ChineseMathTex(*texts, font="SimSun", tex_to_color_map={}, **kwargs)`
+
+支持中文显示的 `MathTex` 子类。可直接在公式中写入中文，无需手动包裹 `\text{}`。
+
+```python
+from manim_extensions import ChineseMathTex
+
+formula = ChineseMathTex(
+    "\\frac{1}{2} + 你好 = x",
+    tex_to_color_map={"你好": RED},
+    font="SimSun"
+)
+```
+
+**参数**
+- `*texts` — LaTeX 文本字符串
+- `font` — 中文字体名称，默认 `"SimSun"`
+- `tex_to_color_map` — 文本到颜色的映射字典，默认 `{}`
+- `**kwargs` — 传递给 `MathTex` 的其他参数
+
+---
+
+#### `LabelDot(dot_label, dot_pos, label_pos=DOWN, buff=0.1, **kwargs)`
+
+在指定位置创建一个圆点，并在其旁边添加 `MathTex` 标签。
+
+```python
+from manim_extensions import LabelDot
+
+dot = LabelDot("A", [1, 2, 0], label_pos=UP, buff=0.2)
+```
+
+**参数**
+- `dot_label` — 标签文本
+- `dot_pos` — 圆点位置
+- `label_pos` — 标签相对圆点的方向，默认 `DOWN`
+- `buff` — 标签与圆点的间距，默认 `0.1`
+- `**kwargs` — 传递给 `VGroup` 的其他参数
+
+---
+
+#### `MathTexLine(formula, direction=UP, buff=0.5, **kwargs)`
+
+创建一条线段，并在其指定方向旁放置 `MathTex` 公式。
+
+```python
+from manim_extensions import MathTexLine
+
+line = MathTexLine(MathTex("y = x"), direction=UP, color=BLUE)
+```
+
+**参数**
+- `formula` — `MathTex` 公式对象
+- `direction` — 公式相对线段的方向，默认 `UP`
+- `buff` — 公式与线段的间距，默认 `0.5`
+- `**kwargs` — 传递给 `Line` 的其他参数
+
+---
+
+#### `MathTexBrace(target, formula, direction=UP, buff=0.5, **kwargs)`
+
+为指定对象创建一个花括号，并在其旁边放置 `MathTex` 公式。
+
+```python
+from manim_extensions import MathTexBrace
+
+line = Line(LEFT, RIGHT)
+brace = MathTexBrace(line, MathTex("\\Delta x"), direction=UP)
+```
+
+**参数**
+- `target` — 要被花括号标注的目标对象
+- `formula` — `MathTex` 公式对象
+- `direction` — 公式与花括号相对目标的方向，默认 `UP`
+- `buff` — 公式与花括号的间距，默认 `0.5`
+- `**kwargs` — 传递给 `Brace` 的其他参数
+
+---
+
+#### `MathTexDoublearrow(formula, direction=UP, buff=0.5, **kwargs)`
+
+创建一个双向箭头，并在其指定方向旁放置 `MathTex` 公式。
+
+```python
+from manim_extensions import MathTexDoublearrow
+
+arrow = MathTexDoublearrow(MathTex("\\Leftrightarrow"), direction=DOWN)
+```
+
+**参数**
+- `formula` — `MathTex` 公式对象
+- `direction` — 公式相对箭头的方向，默认 `UP`
+- `buff` — 公式与箭头的间距，默认 `0.5`
+- `**kwargs` — 传递给 `DoubleArrow` 的其他参数
+
+---
+
+#### `ExtendedLine(line, extend_distance, **kwargs)`
+
+基于一条已有的 `Line`，在其两端按原方向各延长指定距离。
+
+```python
+from manim_extensions import ExtendedLine
+
+original = Line(LEFT, RIGHT)
+extended = ExtendedLine(original, extend_distance=1.0, color=RED)
+```
+
+**参数**
+- `line` — 原始线段
+- `extend_distance` — 两端各延长的距离
+- `**kwargs` — 传递给 `Line` 的其他参数
+
+---
+
+### geometry 模块
+
+#### `CircleInt(circle1, circle2)`
+
+计算两个圆的交点。
+
+```python
+from manim_extensions import CircleInt
+
+c1 = Circle(radius=2).shift(LEFT)
+c2 = Circle(radius=2).shift(RIGHT)
+result = CircleInt(c1, c2)  # ([x1, y1, 0], [x2, y2, 0]) 或 None
+```
+
+**返回**
+- 若相交，返回两个交点坐标的元组 `([x, y, 0], [x, y, 0])`
+- 若不相交，返回 `None`
+
+---
+
+#### `LineCircleInt(line, circle)`
+
+计算线段与圆的交点，仅返回落在线段参数范围 `[0, 1]` 内的交点。
+
+```python
+from manim_extensions import LineCircleInt
+
+line = Line(LEFT * 3, RIGHT * 3)
+circle = Circle(radius=1)
+result = LineCircleInt(line, circle)
+```
+
+**返回**
+- 两个交点、一个交点，或 `None`
+
+---
+
+#### `LineInt(line1, line2)`
+
+在二维平面上计算两条无限延长线段的交点（不限制在线段端点范围内）。
+
+```python
+from manim_extensions import LineInt
+
+l1 = Line(LEFT, RIGHT)
+l2 = Line(DOWN, UP)
+result = LineInt(l1, l2)  # [0.0, 0.0, 0] 或 None
+```
+
+**返回**
+- 交点坐标 `[x, y, 0]`，或平行时返回 `None`
+
+---
+
+#### `LineArcInt(line, arc)`
+
+计算线段与圆弧的交点，会检查交点是否真正落在圆弧的角度范围内。
+
+```python
+from manim_extensions import LineArcInt
+
+line = Line(LEFT, RIGHT)
+arc = Arc(start_angle=0, angle=PI, radius=1)
+result = LineArcInt(line, arc)
+```
+
+**返回**
+- 两个交点、一个交点，或 `None`
+
+---
+
+#### `TangentPoint(p1, p2, line_start, line_end)`
+
+计算以 `p1` 和 `p2` 为圆上点、且与线段相切的切点坐标。
+
+```python
+from manim_extensions import TangentPoint
+
+p = TangentPoint(
+    [1, 0, 0], [-1, 0, 0],
+    line_start=[0, -2, 0], line_end=[0, 2, 0]
+)
+```
+
+**参数**
+- `p1`, `p2` — 圆上的两个点，格式 `(x, y)` 或 `(x, y, z)`
+- `line_start`, `line_end` — 线段的起点和终点
+
+**返回**
+- 切点坐标 `np.ndarray`，若无法计算则返回 `None`
+
+---
+
+### animations 模块
+
+#### `VisDrawArc(scene, arc, axis=OUT, run_time=1)`
+
+可视化绘制圆弧的动画，会同时显示一个沿圆弧移动的点及半径虚线。**直接调用即可，无需放入 `self.play()` 中。**
+
+```python
+from manim_extensions import VisDrawArc
+
+class MyScene(Scene):
+    def construct(self):
+        arc = Arc(start_angle=0, angle=PI, radius=2)
+        VisDrawArc(self, arc, axis=OUT, run_time=2)
+```
+
+**参数**
+- `scene` — Manim 场景对象
+- `arc` — 要绘制的 `Arc`
+- `axis` — 旋转方向，`OUT` 为逆时针，`IN` 为顺时针，默认 `OUT`
+- `run_time` — 动画时长（秒），默认 `1`
+
+---
+
+#### `TypeWriter(mobject, interval=2, **kwargs)`
+
+打字机效果动画，逐个字符显示 `Text` 对象的内容。自动根据字符数量与间隔计算动画总时长。
+
+```python
+from manim_extensions import TypeWriter
+
+class MyScene(Scene):
+    def construct(self):
+        text = Text("Hello World")
+        self.play(TypeWriter(text, interval=0.1))
+```
+
+**参数**
+- `mobject` — `Text` 对象
+- `interval` — 字符间显示间隔（秒），默认 `2`
+- `**kwargs` — 传递给 `Animation` 的其他参数
+
+---
+
+<a name="english"></a>
+## English
+
+manim_extensions is an extension toolkit for [Manim](https://www.manim.community/), providing Chinese formula rendering, geometric calculations, annotated graphics, and common animation effects to help you create mathematical animations more efficiently.
+
+### Installation
+
+```bash
+pip install manim_extensions
+```
+
+Dependency: `manim`
+
+### Module Overview
+
+| Module | Description |
+|--------|-------------|
+| `mobjects` | Mobject class extensions, including Chinese formulas, labeled dots, extendable lines, etc. |
+| `geometry` | Pure geometric calculation functions for finding intersections, tangent points, etc. |
+| `animations` | Animation effects, such as visualized arc drawing and typewriter effects |
+
+---
+
+### mobjects Module
+
+#### `ChineseMathTex(*texts, font="SimSun", tex_to_color_map={}, **kwargs)`
+
+A `MathTex` subclass that supports Chinese characters. You can write Chinese directly in the formula without manually wrapping it in `\text{}`.
+
+```python
+from manim_extensions import ChineseMathTex
+
+formula = ChineseMathTex(
+    "\\frac{1}{2} + 你好 = x",
+    tex_to_color_map={"你好": RED},
+    font="SimSun"
+)
+```
+
+**Parameters**
+- `*texts` — LaTeX text strings
+- `font` — Chinese font name, default `"SimSun"`
+- `tex_to_color_map` — Dictionary mapping text to colors, default `{}`
+- `**kwargs` — Other arguments passed to `MathTex`
+
+---
+
+#### `LabelDot(dot_label, dot_pos, label_pos=DOWN, buff=0.1, **kwargs)`
+
+Creates a dot at the specified position and adds a `MathTex` label next to it.
+
+```python
+from manim_extensions import LabelDot
+
+dot = LabelDot("A", [1, 2, 0], label_pos=UP, buff=0.2)
+```
+
+**Parameters**
+- `dot_label` — Label text
+- `dot_pos` — Dot position
+- `label_pos` — Direction of the label relative to the dot, default `DOWN`
+- `buff` — Spacing between label and dot, default `0.1`
+- `**kwargs` — Other arguments passed to `VGroup`
+
+---
+
+#### `MathTexLine(formula, direction=UP, buff=0.5, **kwargs)`
+
+Creates a line segment and places a `MathTex` formula next to it in the specified direction.
+
+```python
+from manim_extensions import MathTexLine
+
+line = MathTexLine(MathTex("y = x"), direction=UP, color=BLUE)
+```
+
+**Parameters**
+- `formula` — `MathTex` formula object
+- `direction` — Direction of the formula relative to the line, default `UP`
+- `buff` — Spacing between formula and line, default `0.5`
+- `**kwargs` — Other arguments passed to `Line`
+
+---
+
+#### `MathTexBrace(target, formula, direction=UP, buff=0.5, **kwargs)`
+
+Creates a brace for a target object and places a `MathTex` formula next to it.
+
+```python
+from manim_extensions import MathTexBrace
+
+line = Line(LEFT, RIGHT)
+brace = MathTexBrace(line, MathTex("\\Delta x"), direction=UP)
+```
+
+**Parameters**
+- `target` — The object to be braced
+- `formula` — `MathTex` formula object
+- `direction` — Direction of the brace relative to the target, default `UP`
+- `buff` — Spacing between formula and brace, default `0.5`
+- `**kwargs` — Other arguments passed to `Brace`
+
+---
+
+#### `MathTexDoublearrow(formula, direction=UP, buff=0.5, **kwargs)`
+
+Creates a double arrow and places a `MathTex` formula next to it in the specified direction.
+
+```python
+from manim_extensions import MathTexDoublearrow
+
+arrow = MathTexDoublearrow(MathTex("\\Leftrightarrow"), direction=DOWN)
+```
+
+**Parameters**
+- `formula` — `MathTex` formula object
+- `direction` — Direction of the formula relative to the arrow, default `UP`
+- `buff` — Spacing between formula and arrow, default `0.5`
+- `**kwargs` — Other arguments passed to `DoubleArrow`
+
+---
+
+#### `ExtendedLine(line, extend_distance, **kwargs)`
+
+Extends an existing `Line` by a specified distance at both ends along its original direction.
+
+```python
+from manim_extensions import ExtendedLine
+
+original = Line(LEFT, RIGHT)
+extended = ExtendedLine(original, extend_distance=1.0, color=RED)
+```
+
+**Parameters**
+- `line` — Original line segment
+- `extend_distance` — Distance to extend at each end
+- `**kwargs` — Other arguments passed to `Line`
+
+---
+
+### geometry Module
+
+#### `CircleInt(circle1, circle2)`
+
+Calculates the intersection points of two circles.
+
+```python
+from manim_extensions import CircleInt
+
+c1 = Circle(radius=2).shift(LEFT)
+c2 = Circle(radius=2).shift(RIGHT)
+result = CircleInt(c1, c2)  # ([x1, y1, 0], [x2, y2, 0]) or None
+```
+
+**Returns**
+- A tuple of two intersection points `([x, y, 0], [x, y, 0])` if they intersect
+- `None` if they do not intersect
+
+---
+
+#### `LineCircleInt(line, circle)`
+
+Calculates the intersection points of a line segment and a circle, returning only points within the segment parameter range `[0, 1]`.
+
+```python
+from manim_extensions import LineCircleInt
+
+line = Line(LEFT * 3, RIGHT * 3)
+circle = Circle(radius=1)
+result = LineCircleInt(line, circle)
+```
+
+**Returns**
+- Two intersection points, one intersection point, or `None`
+
+---
+
+#### `LineInt(line1, line2)`
+
+Calculates the intersection point of two infinitely extended line segments in 2D (not restricted to the segment endpoints).
+
+```python
+from manim_extensions import LineInt
+
+l1 = Line(LEFT, RIGHT)
+l2 = Line(DOWN, UP)
+result = LineInt(l1, l2)  # [0.0, 0.0, 0] or None
+```
+
+**Returns**
+- Intersection point `[x, y, 0]`, or `None` if parallel
+
+---
+
+#### `LineArcInt(line, arc)`
+
+Calculates the intersection points of a line segment and an arc, checking whether the points truly lie within the arc's angle range.
+
+```python
+from manim_extensions import LineArcInt
+
+line = Line(LEFT, RIGHT)
+arc = Arc(start_angle=0, angle=PI, radius=1)
+result = LineArcInt(line, arc)
+```
+
+**Returns**
+- Two intersection points, one intersection point, or `None`
+
+---
+
+#### `TangentPoint(p1, p2, line_start, line_end)`
+
+Calculates the tangent point of a circle (passing through `p1` and `p2`) and a line segment.
+
+```python
+from manim_extensions import TangentPoint
+
+p = TangentPoint(
+    [1, 0, 0], [-1, 0, 0],
+    line_start=[0, -2, 0], line_end=[0, 2, 0]
+)
+```
+
+**Parameters**
+- `p1`, `p2` — Two points on the circle, in the format `(x, y)` or `(x, y, z)`
+- `line_start`, `line_end` — Start and end points of the line segment
+
+**Returns**
+- Tangent point coordinates as `np.ndarray`, or `None` if calculation fails
+
+---
+
+### animations Module
+
+#### `VisDrawArc(scene, arc, axis=OUT, run_time=1)`
+
+Visualized arc drawing animation, showing a moving dot and a dashed radius line. **Call it directly; no need to wrap it in `self.play()`.**
+
+```python
+from manim_extensions import VisDrawArc
+
+class MyScene(Scene):
+    def construct(self):
+        arc = Arc(start_angle=0, angle=PI, radius=2)
+        VisDrawArc(self, arc, axis=OUT, run_time=2)
+```
+
+**Parameters**
+- `scene` — Manim scene object
+- `arc` — The `Arc` to draw
+- `axis` — Rotation direction, `OUT` for counterclockwise and `IN` for clockwise, default `OUT`
+- `run_time` — Animation duration in seconds, default `1`
+
+---
+
+#### `TypeWriter(mobject, interval=2, **kwargs)`
+
+Typewriter effect animation that displays `Text` content character by character. Automatically calculates the total animation duration based on character count and interval.
+
+```python
+from manim_extensions import TypeWriter
+
+class MyScene(Scene):
+    def construct(self):
+        text = Text("Hello World")
+        self.play(TypeWriter(text, interval=0.1))
+```
+
+**Parameters**
+- `mobject` — `Text` object
+- `interval` — Display interval between characters in seconds, default `2`
+- `**kwargs` — Other arguments passed to `Animation`
+
+---
+
+## License
+
+MIT License

manim_extensions-1.0.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+manim_extensions/__init__.py,sha256=mSVCmyhQZ_mxkTRYvesCKgedQSdsThlvZVhSaH5sHeE,74
+manim_extensions/animations.py,sha256=4SHKkXpotYT3IPLPfWbo6GNrRHW49V8hgIxrg-N4iaY,3973
+manim_extensions/geometry.py,sha256=ynRfxm_CqVtqOg-bslRM9lOXuZMkQF9S11jaIzGCjpU,10956
+manim_extensions/mobjects.py,sha256=Xwytb-uxjXSi57YGmuVY6XZXmc1M8YKAvUKHnx0Cf-o,6344
+manim_extensions-1.0.0.dist-info/METADATA,sha256=2V6uOI1r9t16Bs9KriGDNq5dk-IqTc4fPIzoY5cv47I,16143
+manim_extensions-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+manim_extensions-1.0.0.dist-info/top_level.txt,sha256=tJjvk037RxPiZCC4X2Udw9at25l6iHyflk8bqqZExcU,17
+manim_extensions-1.0.0.dist-info/RECORD,,

manim_extensions-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

manim_extensions-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+manim_extensions