现成场景¶

影片代码

import manimgx as m


class ReadyMadeScenesHero(m.LinearTransformationScene):
    def construct(self) -> None:
        self.add_vector([1, 2], color=m.YELLOW)
        self.apply_matrix([[1, 1], [0, 1]])
        self.wait()

这些场景自带某一类视频所需的内容。向量场景从平面的原点绘制向量，并附带它们的标签和坐标。线性变换场景在一次 play 中将矩阵应用于平面及平面上的所有内容。缩放场景在插图中显示帧的放大局部。

VectorScene ¶

代码

import manimgx as m


class VectorSceneExample(m.VectorScene):
    def construct(self) -> None:
        self.add_plane()
        vector = self.add_vector([3, 2], color=m.YELLOW)
        self.write_vector_coordinates(vector)
        self.wait()

用于绘制向量的场景：从原点出发的箭头、其标签与坐标。

其方法添加平面与坐标轴、绘制向量并加标签，以及为从向量到其坐标及反向的转换添加动画。 add_vector 从原点绘制一个向量，以场景单位表示；get_vector 在场景 plane 的坐标中生成一个。

class MyScene(m.VectorScene):

basis_vector_stroke_width: 基向量的描边宽度（见 get_basis_vectors），以场景单位的百分之一表示。

源码

manimgx\scene.py

def __init__(self, basis_vector_stroke_width: float = 6.0) -> None:
    super().__init__()
    self.basis_vector_stroke_width = basis_vector_stroke_width

plane ¶

get_vector 读取其坐标的平面： LinearTransformationScene 创建它；在向量场景中，需将其赋值（self.plane = self.add_plane()）。

grows_vectors ¶

add_vector 是否在未另行告知时以生长方式显示向量：向量场景中为 True，变换场景中为 False。

add_plane ¶

向场景添加一个数平面。

self.add_plane(animate=False, **kwargs)

animate: 是否以动画绘入（Create，其线条重叠）。
x_range: x 轴的范围，[x_min, x_max, x_step]：网格在每个步长处有一条垂直线（默认：画框的宽度，步长 1）。
y_range: y 轴的范围，[y_min, y_max, y_step]：网格在每个步长处有一条水平线（默认：画框的高度，步长 1）。
x_length: x 轴的长度，以场景单位计（默认 None：每单位一个场景单位）。
y_length: y 轴的长度，以场景单位计（默认 None：每单位一个场景单位）。
background_line_style: 网格线的样式关键字，覆盖其默认值：蓝色（BLUE_D）、宽 2、不透明（默认 None：无）。
faded_line_style: 它们之间较暗线的样式关键字（默认 None：网格线的样式，宽度和不透明度减半）。
faded_line_ratio: 较暗线将网格的每个步长分成多少部分：1 表示无较暗线，2 表示每两条网格线之间有一条（默认 1）。
axis_config: 每个坐标轴的数轴关键字：include_numbers、font_size、color、…（默认 None：无）。
x_axis_config: x 轴的数轴关键字，覆盖 axis_config 的（默认 None：无）。
y_axis_config: y 轴的数轴关键字，覆盖 axis_config 的（默认 None：无）。
tips: 每个坐标轴末端是否有箭头（默认 True；平面的坐标轴无箭头，除非 axis_config 包含 include_tip）。
color: 填充与描边共用的颜色（默认白色）；None 表示该类的默认值。
fill_color: 填充的颜色；未给出时为 color。多个颜色沿 sheen_direction 构成渐变。
fill_opacity: 填充的不透明度，取值从 0 到 1（默认 0：无填充）。
stroke_color: 描边的颜色；未给出时为 color。多个颜色构成渐变。
stroke_opacity: 描边的不透明度，取值从 0 到 1（默认 1）。
stroke_width: 描边的宽度，以场景单位的百分之一计（默认 4；0：无描边）。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

返回该平面。除非赋值给它，否则它不是场景的 plane。

源码

manimgx\scene.py

def add_plane(
    self, animate: bool = False, **kwargs: Unpack[NumberPlaneOptions]
) -> NumberPlane:
    """向场景添加一个数平面。

    Args:
        animate: 是否以动画绘入（[`Create`][manimgx.Create]，其线条
            重叠）。
        **kwargs: [数平面关键字][manimgx.NumberPlane]。

    Returns:
        该平面。除非赋值给它，否则它不是场景的
        [`plane`][manimgx.VectorScene.plane]。
    """
    plane = NumberPlane(**kwargs)
    if animate:
        self.play(Create(plane, lag_ratio=0.5))
    self.add(plane)
    return plane

add_axes ¶

向场景添加坐标轴，一个场景单位对应一个单位。

self.add_axes(animate=False, color=WHITE)

animate: 是否以动画绘入（Create）。
color: 其颜色。

返回该坐标轴。

源码

manimgx\scene.py

def add_axes(self, animate: bool = False, color: Colors = WHITE) -> Axes:
    """向场景添加坐标轴，一个场景单位对应一个单位。

    Args:
        animate: 是否以动画绘入（[`Create`][manimgx.Create]）。
        color: 其颜色。

    Returns:
        该坐标轴。
    """
    axes = Axes(color=color, axis_config={"unit_size": 1})
    if animate:
        self.play(Create(axes))
    self.add(axes)
    return axes

get_vector ¶

从场景平面的原点生成一个箭头，指向以平面坐标给定的点。

self.get_vector(numerical_vector, **kwargs)

numerical_vector: 该点在 plane 上的坐标：x 与 y（z 被忽略）。
max_tip_length_to_length_ratio: 尖端最长可为多长，为其长度的比例：短箭头的尖端更短（默认 0.25）。
max_stroke_width_to_length_ratio: 描边最宽可为多宽，以每场景单位长度的百分之一场景单位计：短箭头更细（默认 5）。
tip_shape: 其尖端的类（默认 ArrowTriangleFilledTip）。
path_arc: 直线所弯曲的角度，以弧度计：0 为直；否则为从起点到终点的弧，为正时逆时针（行进时向右弯），为负时顺时针（默认 0）。
color: 填充和描边共用的颜色（默认白色；Circle 的为红色）；None 表示类的默认值。
tip_length: add_tip 所生成尖端的长度，以场景单位计（默认 0.35；Arrow 的可能更短）。
normal_vector: 路径所在平面的法向量（默认 OUT）。为兼容 Manim 而接受；被忽略且不保留。
tip_style: 路径所生成尖端的样式关键字（默认 None：无）。除非在此给出，否则尖端的 fill_color 和 stroke_color 取路径的颜色。
fill_color: 填充的颜色；未给出时为 color。多个颜色沿 sheen_direction 构成渐变。
fill_opacity: 填充的不透明度，取值从 0 到 1（默认 0：无填充）。
stroke_color: 描边的颜色；未给出时为 color。多个颜色构成渐变。
stroke_opacity: 描边的不透明度，取值从 0 到 1（默认 1）。
stroke_width: 描边的宽度，以场景单位的百分之一计（默认 4；0：无描边）。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

返回一个新箭头，未添加到场景。

源码

manimgx\scene.py

def get_vector(
    self, numerical_vector: Vector3DLike, **kwargs: Unpack[ArrowTips]
) -> Arrow:
    """从场景平面的原点生成一个箭头，指向以平面坐标给定的点。

    Args:
        numerical_vector: 该点在 [`plane`][manimgx.VectorScene.plane] 上的
            坐标：x 与 y（z 被忽略）。
        **kwargs: [箭头关键字][manimgx.Arrow]。

    Returns:
        一个新箭头，未添加到场景。
    """
    x, y = np.asarray(numerical_vector, dtype=float)[:2]
    return Arrow(
        self.plane.coords_to_point(0, 0),
        self.plane.coords_to_point(x, y),
        buff=0,
        **kwargs,
    )

add_vector ¶

向场景添加一个向量：给定的箭头，或从原点到给定坐标的 Vector。

若 animate 为是、或在场景的 grows_vectors 为是时（向量场景为是，变换场景为否），它以从原点生长的方式显示（GrowArrow）；然后场景接管它：LinearTransformationScene 使其随平面移动。

self.add_vector(vector, color=PURE_YELLOW, animate=None, **kwargs)

vector: 一个箭头，或向量尖端的坐标，以场景单位表示。
color: 当由坐标生成时向量的颜色。
animate: 是否以 play 生长；None 取场景的 grows_vectors。
max_tip_length_to_length_ratio: 尖端最长可为多长，为其长度的比例：短箭头的尖端更短（默认 0.25）。
max_stroke_width_to_length_ratio: 描边最宽可为多宽，以每场景单位长度的百分之一场景单位计：短箭头更细（默认 5）。
tip_shape: 其尖端的类（默认 ArrowTriangleFilledTip）。
path_arc: 直线所弯曲的角度，以弧度计：0 为直；否则为从起点到终点的弧，为正时逆时针（行进时向右弯），为负时顺时针（默认 0）。
tip_length: add_tip 所生成尖端的长度，以场景单位计（默认 0.35；Arrow 的可能更短）。
normal_vector: 路径所在平面的法向量（默认 OUT）。为兼容 Manim 而接受；被忽略且不保留。
tip_style: 路径所生成尖端的样式关键字（默认 None：无）。除非在此给出，否则尖端的 fill_color 和 stroke_color 取路径的颜色。
fill_color: 填充的颜色；未给出时为 color。多个颜色沿 sheen_direction 构成渐变。
fill_opacity: 填充的不透明度，取值从 0 到 1（默认 0：无填充）。
stroke_color: 描边的颜色；未给出时为 color。多个颜色构成渐变。
stroke_opacity: 描边的不透明度，取值从 0 到 1（默认 1）。
stroke_width: 描边的宽度，以场景单位的百分之一计（默认 4；0：无描边）。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

返回该箭头。

源码

manimgx\scene.py

def add_vector(
    self,
    vector: Arrow | Vector3DLike,
    color: Colors = PURE_YELLOW,
    animate: bool | None = None,
    **kwargs: Unpack[ArrowTipsBase],
) -> Arrow:
    """向场景添加一个向量：给定的箭头，或从原点到给定坐标的
    [Vector][manimgx.Vector]。

    若 `animate` 为是、或在场景的 `grows_vectors` 为是时（向量场景为是，
    变换场景为否），它以从原点生长的方式显示（[GrowArrow][manimgx.GrowArrow]）；
    然后场景接管它：[LinearTransformationScene][manimgx.LinearTransformationScene]
    使其随平面移动。

    Args:
        vector: 一个箭头，或向量尖端的坐标，以场景单位表示。
        color: 当由坐标生成时向量的颜色。
        animate: 是否以 play 生长；None 取场景的 `grows_vectors`。
        **kwargs: 由坐标生成向量时的[箭头关键字][manimgx.mobjects.shapes.ArrowTipsBase]。

    Returns:
        该箭头。
    """
    if not isinstance(vector, Arrow):
        vector = Vector(np.asarray(vector, dtype=float), color=color, **kwargs)
    if self.grows_vectors if animate is None else animate:
        self.play(GrowArrow(vector))
    self.add(vector)
    self.added_vector(vector)
    return vector

write_vector_coordinates ¶

在一个 Write 的 play 中，将向量的坐标作为一列写在其尖端旁（其 coordinate_label）。

self.write_vector_coordinates(vector, **kwargs)

v_buff: 各行之间的距离，以场景单位表示，从一行的条目对齐角到下一行的对齐角（默认 0.8）。
h_buff: 各列之间的距离，以场景单位表示，同上（默认 1.3）。
bracket_h_buff: 条目与每个括号之间的间距，以场景单位表示（默认 0.25）。
bracket_v_buff: 当括号被拉伸时，括号在条目上下方延伸的距离，以场景单位表示（默认 0.25）。
add_background_rectangles_to_entries: 每个条目是否获得一个背景矩形（默认 False）。
include_background_rectangle: 矩阵是否获得一个背景矩形（默认 False）。
element_alignment_corner: 每个条目放置在网格上的角，以方向命名：DR 使一列中的条目按其右侧对齐， UL 则按其左侧对齐（默认 DR）。
left_bracket: 左括号，作为 LaTeX 分隔符："[", "(", "\{", "\langle", "|", …（默认 "["）。
right_bracket: 右括号，作为 LaTeX 分隔符（默认 "]"）。
stretch_brackets: 括号是否被拉伸到条目的高度，并再延伸 bracket_v_buff 的距离（默认 True）。
bracket_config: 括号的 Math 关键字：其 color，…（默认 None：无）。
element_to_mobject: 构造每个条目的 mobject 的函数，以条目和 element_to_mobject_config 的关键字参数调用（默认：矩阵类自身的函数，对于 Matrix 为 MathTex）。
element_to_mobject_config: element_to_mobject 的关键字参数（默认 None：矩阵类自身的设置，对于 Matrix 为无）。
color: 填充与描边共用的颜色（默认白色）；None 表示该类的默认值。
fill_color: 填充的颜色；未给出时为 color。多个颜色沿 sheen_direction 构成渐变。
fill_opacity: 填充的不透明度，取值从 0 到 1（默认 0：无填充）。
stroke_color: 描边的颜色；未给出时为 color。多个颜色构成渐变。
stroke_opacity: 描边的不透明度，取值从 0 到 1（默认 1）。
stroke_width: 描边的宽度，以场景单位的百分之一计（默认 4；0：无描边）。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

返回该列。

源码

manimgx\scene.py

def write_vector_coordinates(
    self, vector: Vector, **kwargs: Unpack[MatrixOptions]
) -> Matrix:
    """在一个 [`Write`][manimgx.Write] 的 play 中，将向量的坐标作为一列写在
    其尖端旁（其 `coordinate_label`）。

    Args:
        **kwargs: 该列的[矩阵关键字][manimgx.mobjects.grid.MatrixOptions]。

    Returns:
        该列。
    """
    coords = vector.coordinate_label(**kwargs)
    self.play(Write(coords))
    return coords

get_basis_vectors ¶

生成基向量 î 与 ĵ：从原点到 (1, 0) 与 (0, 1) 的箭头，以场景单位表示。

self.get_basis_vectors(i_hat_color=X_COLOR, j_hat_color=Y_COLOR)

i_hat_color: î 的颜色。
j_hat_color: ĵ 的颜色。

返回二者的新组，î 在前。

源码

manimgx\scene.py

def get_basis_vectors(
    self, i_hat_color: Colors = X_COLOR, j_hat_color: Colors = Y_COLOR
) -> VGroup:
    """生成基向量 î 与 ĵ：从原点到 (1, 0) 与 (0, 1) 的箭头，以场景单位
    表示。

    Args:
        i_hat_color: î 的颜色。
        j_hat_color: ĵ 的颜色。

    Returns:
        二者的新组，î 在前。
    """
    return VGroup(
        *(
            Vector(
                np.asarray(vect, dtype=float),
                color=color,
                stroke_width=self.basis_vector_stroke_width,
            )
            for vect, color in [([1, 0], i_hat_color), ([0, 1], j_hat_color)]
        )
    )

get_basis_vector_labels ¶

为基向量生成标签：î 与 ĵ，颜色取 x 与 y 轴的颜色（绿色与红色）。

self.get_basis_vector_labels(**kwargs)

at_tip: 标签是否位于向量尖端之外，而非其旁边中部（默认 False）。
direction: 沿向量方向看时标签所在的侧（默认 "left"）。
rotate: 标签是否随向量转动，而非保持直立（默认 False）。

返回两个标签的新组，î 的在前。

源码

manimgx\scene.py

def get_basis_vector_labels(self, **kwargs: Unpack[LabelPlacement]) -> VGroup:
    """为基向量生成标签：î 与 ĵ，颜色取 x 与 y 轴的颜色
    （绿色与红色）。

    Args:
        **kwargs: [标签位置关键字][manimgx.scene.LabelPlacement]。

    Returns:
        两个标签的新组，î 的在前。
    """
    i_hat, j_hat = self.get_basis_vectors().submobjects
    return VGroup(
        *(
            self.get_vector_label(
                vect, label, color=color, label_scale_factor=1, **kwargs
            )
            for vect, label, color in [
                (i_hat, "\\hat{\\imath}", X_COLOR),
                (j_hat, "\\hat{\\jmath}", Y_COLOR),
            ]
            if isinstance(vect, Vector)
        )
    )

get_vector_label ¶

为向量生成标签：在其旁边中部，左侧或右侧，或在其尖端之外。

字符串以 LaTeX 排版，单字母作为粗体向量（\vec{\textbf{v}}），颜色取向量的颜色。标签带有背景矩形，以便在其下方的线条之上可读。

self.get_vector_label(vector, label, at_tip=False, direction='left', rotate=False, color=None, label_scale_factor=LARGE_BUFF - 0.2)

vector: 该向量，从原点出发。
label: 该标签：一个 mobject，或 LaTeX。
at_tip: 是否位于向量尖端之外，而非其旁边中部。
direction: 沿向量方向看时标签所在的侧。
rotate: 是否随向量转动，而非保持直立。
color: 当由字符串生成时的颜色；None 取向量的颜色。
label_scale_factor: 其缩放倍数。

返回该标签，未添加到场景。

源码

manimgx\scene.py

def get_vector_label(
    self,
    vector: Vector,
    label: ManimTextLabel | str,
    at_tip: bool = False,
    direction: Literal["left", "right"] = "left",
    rotate: bool = False,
    color: ParsableManimColor | None = None,
    label_scale_factor: float = LARGE_BUFF - 0.2,
) -> ManimTextLabel:
    r"""为向量生成标签：在其旁边中部，左侧或右侧，或在其尖端之外。

    字符串以 LaTeX 排版，单字母作为粗体向量
    （`\vec{\textbf{v}}`），颜色取向量的颜色。标签带有背景矩形，
    以便在其下方的线条之上可读。

    Args:
        vector: 该向量，从原点出发。
        label: 该标签：一个 mobject，或 LaTeX。
        at_tip: 是否位于向量尖端之外，而非其旁边中部。
        direction: 沿向量方向看时标签所在的侧。
        rotate: 是否随向量转动，而非保持直立。
        color: 当由字符串生成时的颜色；None 取向量的颜色。
        label_scale_factor: 其缩放倍数。

    Returns:
        该标签，未添加到场景。
    """
    if isinstance(label, str):
        if len(label) == 1:
            label = f"\\vec{{\\textbf{{{label}}}}}"
        label = MathTex(label)
        label.set_color(vector.get_color() if color is None else color)
    label.scale(label_scale_factor)
    label.add_background_rectangle()
    if at_tip:
        vect = vector.get_vector()
        label.next_to(
            vector.get_end(), vect / np.linalg.norm(vect), buff=SMALL_BUFF
        )
    else:
        angle = vector.get_angle()
        if not rotate:
            label.rotate(-angle, about_point=ORIGIN)
        if direction == "left":
            label.shift(-np.asarray(label.get_bottom()) + 0.1 * UP)
        else:
            label.shift(-np.asarray(label.get_top()) + 0.1 * DOWN)
        label.rotate(angle, about_point=ORIGIN)
        label.shift((vector.get_end() - vector.get_start()) / 2)
    return label

label_vector ¶

为向量加标签，并将标签添加到场景（见 get_vector_label）。

self.label_vector(vector, label, animate=True, **kwargs)

vector: 该向量，从原点出发。
label: 该标签：一个 mobject，或 LaTeX。
animate: 是否以动画写入（Write）。
color: 当标签由字符串生成时的颜色（默认 None：取向量的颜色）。
label_scale_factor: 标签的缩放倍数（默认 0.8）。
at_tip: 标签是否位于向量尖端之外，而非其旁边中部（默认 False）。
direction: 沿向量方向看时标签所在的侧（默认 "left"）。
rotate: 标签是否随向量转动，而非保持直立（默认 False）。

返回该标签。

源码

manimgx\scene.py

def label_vector(
    self,
    vector: Vector,
    label: ManimTextLabel | str,
    animate: bool = True,
    **kwargs: Unpack[VectorLabelOptions],
) -> ManimTextLabel:
    """为向量加标签，并将标签添加到场景（见
    [`get_vector_label`][manimgx.VectorScene.get_vector_label]）。

    Args:
        vector: 该向量，从原点出发。
        label: 该标签：一个 mobject，或 LaTeX。
        animate: 是否以动画写入（[`Write`][manimgx.Write]）。
        **kwargs: [向量标签关键字][manimgx.scene.VectorLabelOptions]。

    Returns:
        该标签。
    """
    mathtex_label = self.get_vector_label(vector, label, **kwargs)
    if animate:
        self.play(Write(mathtex_label, run_time=1))
    self.add(mathtex_label)
    return mathtex_label

vector_to_coords ¶

以一系列 play 展示向量如何给出其坐标。

向量（当由坐标给定时先绘制）获得一条沿 x 的线与一条到其尖端的线，各带其坐标写入；然后坐标移动到其尖端旁的一列中。

self.vector_to_coords(vector, integer_labels=True, clean_up=True)

vector: 该向量，从原点出发，或其坐标。
integer_labels: 坐标是否四舍五入为整数。
clean_up: 场景是否在结束时保持其之前所持有的内容。

返回坐标列、沿 x 的线与到尖端的线。

源码

manimgx\scene.py

def vector_to_coords(
    self,
    vector: Vector | Vector3DLike,
    integer_labels: bool = True,
    clean_up: bool = True,
) -> tuple[Matrix, Line, Line]:
    """以一系列 play 展示向量如何给出其坐标。

    向量（当由坐标给定时先绘制）获得一条沿 x 的线与一条到其尖端的线，
    各带其坐标写入；然后坐标移动到其尖端旁的一列中。

    Args:
        vector: 该向量，从原点出发，或其坐标。
        integer_labels: 坐标是否四舍五入为整数。
        clean_up: 场景是否在结束时保持其之前所持有的内容。

    Returns:
        坐标列、沿 x 的线与到尖端的线。
    """
    starting_mobjects = list(self.mobjects)
    show_creation = not isinstance(vector, Vector)
    arrow = vector if isinstance(vector, Vector) else Vector(vector)
    end = arrow.get_end()[:2]
    array = arrow.coordinate_label(integer_labels=integer_labels)
    x_line = Line(ORIGIN, end[0] * RIGHT)
    y_line = Line(x_line.get_end(), arrow.get_end())
    x_line.set_color(X_COLOR)
    y_line.set_color(Y_COLOR)
    x_coord, y_coord = array.get_entries().submobjects[:2]
    x_coord_start = self.position_x_coordinate(x_coord.copy(), x_line, end)
    y_coord_start = self.position_y_coordinate(y_coord.copy(), y_line, end)
    brackets = array.get_brackets()
    if show_creation:
        self.play(Create(arrow))
    self.play(Create(x_line), Write(x_coord_start), run_time=1)
    self.play(Create(y_line), Write(y_coord_start), run_time=1)
    self.wait()
    self.play(
        Transform(x_coord_start, x_coord, lag_ratio=0),
        Transform(y_coord_start, y_coord, lag_ratio=0),
        Write(brackets, run_time=1),
    )
    self.wait()
    self.remove(x_coord_start, y_coord_start, brackets)
    self.add(array)
    if clean_up:
        self.clear()
        self.add(*starting_mobjects)
    return array, x_line, y_line

LinearTransformationScene ¶

代码

import manimgx as m


class LinearTransformationSceneExample(m.LinearTransformationScene):
    def __init__(self) -> None:
        super().__init__(show_coordinates=True, leave_ghost_vectors=True)

    def construct(self) -> None:
        self.add_unit_square()
        self.add_vector([-1, 2], color=m.YELLOW)
        self.apply_matrix([[1, 1], [0, 1]])  # a shear
        self.wait()

用于平面的线性变换的场景：一个矩阵作用于平面及其上的一切，在一次动画中。

在 construct 之前，它铺设一个静止的背景平面（background_plane）、其上一个随变换移动的平面（plane）以及基向量 î 与 ĵ （i_hat 与 j_hat，合称 basis_vectors）。 apply_matrix 随后按类别变换场景所持有的一切：可变换 mobject 的点，如同平面的点；向量，重绘到其尖端所去之处；跟随它们的标签；以及移动 mobject，整体移动到其中心所去之处。背景与前景 mobject 留在原处。

class MyScene(m.LinearTransformationScene):

include_background_plane: 是否有一个平面在背景中保持静止。
include_foreground_plane: 是否有其上一个随变换移动的平面：即场景的 plane。
background_plane_kwargs: 背景平面的数平面关键字，叠加在其自身默认值（灰色线条）之上。
foreground_plane_kwargs: 移动平面的数平面关键字，叠加在其自身默认值（它延伸超出帧，以便移动时帧保持被覆盖）之上。
show_coordinates: 背景平面的坐标轴是否编号。
show_basis_vectors: 是否绘制基向量；它们随变换移动。
basis_vector_stroke_width: 基向量的描边宽度，以场景单位的百分之一表示。
i_hat_color: î 的颜色。
j_hat_color: ĵ 的颜色。
leave_ghost_vectors: 每次变换是否在向量原处留下其褪色副本。

源码

manimgx\scene.py

def __init__(
    self,
    include_background_plane: bool = True,
    include_foreground_plane: bool = True,
    background_plane_kwargs: NumberPlaneOptions | None = None,
    foreground_plane_kwargs: NumberPlaneOptions | None = None,
    show_coordinates: bool = False,
    show_basis_vectors: bool = True,
    basis_vector_stroke_width: float = 6,
    i_hat_color: ParsableManimColor = X_COLOR,
    j_hat_color: ParsableManimColor = Y_COLOR,
    leave_ghost_vectors: bool = False,
) -> None:
    super().__init__()
    self.include_background_plane = include_background_plane
    self.include_foreground_plane = include_foreground_plane
    self.show_coordinates = show_coordinates
    self.show_basis_vectors = show_basis_vectors
    self.basis_vector_stroke_width = basis_vector_stroke_width
    self.i_hat_color = ManimColor(i_hat_color)
    self.j_hat_color = ManimColor(j_hat_color)
    self.leave_ghost_vectors = leave_ghost_vectors
    self.ghost_vectors = VGroup()
    """变换所留的、整体移动之物的褪色副本，在其原处，带
    `leave_ghost_vectors`。"""
    self.background_plane_kwargs = _merged_plane(
        {
            "color": GREY,
            "axis_config": {"color": GREY},
            "background_line_style": {"stroke_color": GREY, "stroke_width": 1},
        },
        background_plane_kwargs,
    )
    self.foreground_plane_kwargs = _merged_plane(
        {
            "x_range": (-config.frame_width, config.frame_width, 1.0),
            "y_range": (-config.frame_width, config.frame_width, 1.0),
            "faded_line_ratio": 1,
        },
        foreground_plane_kwargs,
    )

ghost_vectors ¶

变换所留的、整体移动之物的褪色副本，在其原处，带 leave_ghost_vectors。

setup ¶

铺设平面与基向量，并将其添加到场景。

render 在 construct 之前调用它；它只执行一次。重写它的子类须先调用本方法。

self.setup()

源码

manimgx\scene.py

def setup(self) -> None:
    """铺设平面与基向量，并将其添加到场景。

    [`render`][manimgx.Scene.render] 在 `construct` 之前调用它；它只执行一次。
    重写它的子类须先调用本方法。
    """
    if hasattr(self, "has_already_setup"):
        return
    self.has_already_setup = True
    self.background_mobjects: list[Mobject] = []
    self.foreground_mobjects: list[Mobject] = []
    self.transformable_mobjects: list[Mobject] = []
    self.moving_vectors: list[Mobject] = []
    self.transformable_labels: list[_TransformableLabel] = []
    self.moving_mobjects: list[Mobject] = []
    self.background_plane = NumberPlane(**self.background_plane_kwargs)
    if self.show_coordinates:
        self.background_plane.add_coordinates()
    if self.include_background_plane:
        self.add_background_mobject(self.background_plane)
    if self.include_foreground_plane:
        self.plane = NumberPlane(**self.foreground_plane_kwargs)
        self.add_transformable_mobject(self.plane)
    if self.show_basis_vectors:
        self.basis_vectors = self.get_basis_vectors(
            i_hat_color=self.i_hat_color, j_hat_color=self.j_hat_color
        )
        self.moving_vectors += list(self.basis_vectors)
        self.i_hat, self.j_hat = self.basis_vectors
        self.add(self.basis_vectors)

add_background_mobject ¶

添加变换留在原处的 mobject，如同其留背景平面那样。

self.add_background_mobject(*mobjects)

源码

manimgx\scene.py

def add_background_mobject(self, *mobjects: Mobject) -> None:
    """添加变换留在原处的 mobject，如同其留背景平面那样。
    """
    self.add_special_mobjects(self.background_mobjects, *mobjects)

add_foreground_mobject ¶

添加保持最前的 mobject：绘制在一切之上，且被变换留在原处。

self.add_foreground_mobject(*mobjects)

源码

manimgx\scene.py

def add_foreground_mobject(self, *mobjects: Mobject) -> Self:
    """添加保持最前的 mobject：绘制在一切之上，且被变换留在原处。
    """
    self.add_special_mobjects(self.foreground_mobjects, *mobjects)
    return self

add_transformable_mobject ¶

添加变换逐点移动的 mobject，如同其移动平面那样。

self.add_transformable_mobject(*mobjects)

源码

manimgx\scene.py

def add_transformable_mobject(self, *mobjects: Mobject) -> None:
    """添加变换逐点移动的 mobject，如同其移动平面那样。
    """
    self.add_special_mobjects(self.transformable_mobjects, *mobjects)

add_moving_mobject ¶

添加变换整体移动、形状不变的 mobject：移动到变换所取其中心之处。

self.add_moving_mobject(mobject, target_mobject=None)

target_mobject: 其移动时所变成的形态，放置在变换所取其中心之处； None 表示其自身。

源码

manimgx\scene.py

def add_moving_mobject(
    self, mobject: Mobject, target_mobject: Mobject | None = None
) -> None:
    """添加变换整体移动、形状不变的 mobject：移动到变换所取其中心之处。

    Args:
        target_mobject: 其移动时所变成的形态，放置在变换所取其中心之处；
            None 表示其自身。
    """
    mobject.target = target_mobject
    self.add_special_mobjects(self.moving_mobjects, mobject)

get_ghost_vectors ¶

变换所留的、整体移动之物的褪色副本，在其原处，带 leave_ghost_vectors。

self.get_ghost_vectors()

返回它们的组。

源码

manimgx\scene.py

def get_ghost_vectors(self) -> VGroup:
    """变换所留的、整体移动之物的褪色副本，在其原处，带
    `leave_ghost_vectors`。

    Returns:
        它们的组。
    """
    return self.ghost_vectors

get_unit_square ¶

生成一个覆盖平面单位正方形的矩形：从其原点起，x 方向一单位宽、 y 方向一单位高。

self.get_unit_square(color=PURE_YELLOW, opacity=0.3, stroke_width=3)

color: 其填充与描边的颜色。
opacity: 其填充的不透明度，从 0 到 1。
stroke_width: 其描边的宽度，以场景单位的百分之一表示。

返回一个新矩形，同时保存为场景的 square。

源码

manimgx\scene.py

def get_unit_square(
    self, color: Colors = PURE_YELLOW, opacity: float = 0.3, stroke_width: float = 3
) -> Rectangle:
    """生成一个覆盖平面单位正方形的矩形：从其原点起，x 方向一单位宽、
    y 方向一单位高。

    Args:
        color: 其填充与描边的颜色。
        opacity: 其填充的不透明度，从 0 到 1。
        stroke_width: 其描边的宽度，以场景单位的百分之一表示。

    Returns:
        一个新矩形，同时保存为场景的 `square`。
    """
    square = self.square = Rectangle(
        color=color,
        width=self.plane.get_x_unit_size(),
        height=self.plane.get_y_unit_size(),
        stroke_color=color,
        stroke_width=stroke_width,
        fill_color=color,
        fill_opacity=opacity,
    )
    square.move_to(self.plane.coords_to_point(0, 0), DL)
    return square

add_unit_square ¶

添加平面的单位正方形，变换使其随平面移动：其面积显示变换如何缩放面积。

随后移动向量被带到最前，位于其上。

self.add_unit_square(animate=False, **kwargs)

animate: 是否以动画绘入：先其边框，后其填充。
color: 其填充与描边的颜色（默认黄色）。
opacity: 其填充的不透明度，从 0 到 1（默认 0.3）。
stroke_width: 其描边的宽度，以场景单位的百分之一表示（默认 3）。

源码

manimgx\scene.py

def add_unit_square(
    self, animate: bool = False, **kwargs: Unpack[UnitSquareOptions]
) -> Self:
    """添加平面的单位正方形，变换使其随平面移动：其面积显示变换如何缩放
    面积。

    随后移动向量被带到最前，位于其上。

    Args:
        animate: 是否以动画绘入：先其边框，后其填充。
        **kwargs: [单位正方形关键字][manimgx.scene.UnitSquareOptions]。
    """
    square = self.get_unit_square(**kwargs)
    if animate:
        self.play(
            DrawBorderThenFill(square), Animation(Group(*self.moving_vectors))
        )
    self.add_transformable_mobject(square)
    self.bring_to_front(*self.moving_vectors)
    self.square = square
    return self

write_vector_coordinates ¶

将向量的坐标作为一列写在尖端旁，该列保持最前、原位不动，贯穿变换。

self.write_vector_coordinates(vector, **kwargs)

v_buff: 各行之间的距离，以场景单位表示，从一行的条目对齐角到下一行的对齐角（默认 0.8）。
h_buff: 各列之间的距离，以场景单位表示，同上（默认 1.3）。
bracket_h_buff: 条目与每个括号之间的间距，以场景单位表示（默认 0.25）。
bracket_v_buff: 当括号被拉伸时，括号在条目上下方延伸的距离，以场景单位表示（默认 0.25）。
add_background_rectangles_to_entries: 每个条目是否获得一个背景矩形（默认 False）。
include_background_rectangle: 矩阵是否获得一个背景矩形（默认 False）。
element_alignment_corner: 每个条目放置在网格上的角，以方向命名：DR 使一列中的条目按其右侧对齐， UL 则按其左侧对齐（默认 DR）。
left_bracket: 左括号，作为 LaTeX 分隔符："[", "(", "\{", "\langle", "|", …（默认 "["）。
right_bracket: 右括号，作为 LaTeX 分隔符（默认 "]"）。
stretch_brackets: 括号是否被拉伸到条目的高度，并再延伸 bracket_v_buff 的距离（默认 True）。
bracket_config: 括号的 Math 关键字：其 color，…（默认 None：无）。
element_to_mobject: 构造每个条目的 mobject 的函数，以条目和 element_to_mobject_config 的关键字参数调用（默认：矩阵类自身的函数，对于 Matrix 为 MathTex）。
element_to_mobject_config: element_to_mobject 的关键字参数（默认 None：矩阵类自身的设置，对于 Matrix 为无）。
color: 填充与描边共用的颜色（默认白色）；None 表示该类的默认值。
fill_color: 填充的颜色；未给出时为 color。多个颜色沿 sheen_direction 构成渐变。
fill_opacity: 填充的不透明度，取值从 0 到 1（默认 0：无填充）。
stroke_color: 描边的颜色；未给出时为 color。多个颜色构成渐变。
stroke_opacity: 描边的不透明度，取值从 0 到 1（默认 1）。
stroke_width: 描边的宽度，以场景单位的百分之一计（默认 4；0：无描边）。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

返回该列。

源码

manimgx\scene.py

def write_vector_coordinates(
    self, vector: Vector, **kwargs: Unpack[MatrixOptions]
) -> Matrix:
    """将向量的坐标作为一列写在尖端旁，该列保持最前、原位不动，贯穿变换。

    Args:
        **kwargs: 该列的[矩阵关键字][manimgx.mobjects.grid.MatrixOptions]。

    Returns:
        该列。
    """
    coords = super().write_vector_coordinates(vector, **kwargs)
    self.add_foreground_mobject(coords)
    return coords

add_transformable_label ¶

为向量加一个变换所携带并改写的标签。

变换后，标签位于向量所到之处，并显示 new_label，或变换名所包裹的标签：标签 v 显示为 L(v)。

self.add_transformable_label(vector, label, transformation_name='L', new_label=None, *, animate=True, **kwargs)

vector: 该向量，从原点出发。
label: 该标签：一个 mobject，或 LaTeX（见 get_vector_label）。
transformation_name: 变换的名称。
new_label: 变换后标签所显示的内容；None 表示变换名包裹它。
animate: 是否以动画写入。
color: 当标签由字符串生成时的颜色（默认 None：取向量的颜色）。
label_scale_factor: 标签的缩放倍数（默认 0.8）。
at_tip: 标签是否位于向量尖端之外，而非其旁边中部（默认 False）。
direction: 沿向量方向看时标签所在的侧（默认 "left"）。
rotate: 标签是否随向量转动，而非保持直立（默认 False）。

返回该标签。

源码

manimgx\scene.py

def add_transformable_label(
    self,
    vector: Vector,
    label: ManimTextLabel | str,
    transformation_name: str | ManimTextLabel = "L",
    new_label: str | ManimTextLabel | None = None,
    *,
    animate: bool = True,
    **kwargs: Unpack[VectorLabelOptions],
) -> ManimTextLabel:
    """为向量加一个变换所携带并改写的标签。

    变换后，标签位于向量所到之处，并显示 `new_label`，或变换名所包裹的
    标签：标签 `v` 显示为 `L(v)`。

    Args:
        vector: 该向量，从原点出发。
        label: 该标签：一个 mobject，或 LaTeX（见
            [`get_vector_label`][manimgx.VectorScene.get_vector_label]）。
        transformation_name: 变换的名称。
        new_label: 变换后标签所显示的内容；None 表示变换名包裹它。
        animate: 是否以动画写入。
        **kwargs: [向量标签关键字][manimgx.scene.VectorLabelOptions]。

    Returns:
        该标签。
    """
    label_mob = self.label_vector(vector, label, animate, **kwargs)
    if new_label:
        target_text: str | ManimTextLabel = new_label
    else:
        written = (
            label_mob.tex_string
            if isinstance(label_mob, (MathTex, SingleStringMathTex))
            else str(label)
        )
        target_text = f"{transformation_name}({written})"
    self.transformable_labels.append(
        _TransformableLabel(label_mob, vector, target_text, kwargs)
    )
    return label_mob

add_title ¶

在帧顶部添加标题，最前且静止，带背景矩形。

self.add_title(title, scale_factor=1.5, animate=False)

title: 该标题：一个 mobject，或文本，以 Tex 排版。
scale_factor: 文本的缩放倍数。
animate: 是否以动画写入。

源码

manimgx\scene.py

def add_title(
    self, title: str | Mobject, scale_factor: float = 1.5, animate: bool = False
) -> Self:
    """在帧顶部添加标题，最前且静止，带背景矩形。

    Args:
        title: 该标题：一个 mobject，或文本，以 [`Tex`][manimgx.Tex] 排版。
        scale_factor: 文本的缩放倍数。
        animate: 是否以动画写入。
    """
    if not isinstance(title, Mobject):
        title = Tex(title).scale(scale_factor)
    title.to_edge(UP)
    title.add_background_rectangle()
    if animate:
        self.play(Write(title))
    self.add_foreground_mobject(title)
    self.title = title
    return self

apply_matrix ¶

在一次 play 中将矩阵作用于平面及其上的一切。

变换所移动的一切都去往矩阵所取之处（见 apply_function）。除非给定 path_arc，各点沿弧线移动，弧线转过的角度为矩阵转动 î 与 ĵ 所转角度的均值。

self.apply_matrix(matrix, **kwargs)

matrix: 一个作用于 x 与 y 的 2 × 2 矩阵，或一个 3 × 3 矩阵：其列为矩阵所取 î 与 ĵ 之处。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\scene.py

def apply_matrix(
    self, matrix: npt.ArrayLike, **kwargs: Unpack[TransformOptions]
) -> None:
    """在一次 play 中将矩阵作用于平面及其上的一切。

    变换所移动的一切都去往矩阵所取之处（见
    [`apply_function`][manimgx.LinearTransformationScene.apply_function]）。除非
    给定 `path_arc`，各点沿弧线移动，弧线转过的角度为矩阵转动 î 与 ĵ 所
    转角度的均值。

    Args:
        matrix: 一个作用于 x 与 y 的 2 × 2 矩阵，或一个 3 × 3 矩阵：其列
            为矩阵所取 î 与 ĵ 之处。
        **kwargs: play 中每个动画的[变换选项][manimgx.animation.transform.TransformOptions]
            （除非给定 `run_time`，否则为 3 秒）。
    """
    self.apply_transposed_matrix(np.array(matrix).T, **kwargs)

apply_inverse ¶

将矩阵的逆作用于平面及其上的一切：撤销同一矩阵的 apply_matrix。

self.apply_inverse(matrix, **kwargs)

matrix: 该矩阵，2 × 2 或 3 × 3，必须可逆。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\scene.py

def apply_inverse(
    self, matrix: npt.ArrayLike, **kwargs: Unpack[TransformOptions]
) -> None:
    """将矩阵的逆作用于平面及其上的一切：撤销同一矩阵的
    [`apply_matrix`][manimgx.LinearTransformationScene.apply_matrix]。

    Args:
        matrix: 该矩阵，2 × 2 或 3 × 3，必须可逆。
        **kwargs: play 中每个动画的[变换选项][manimgx.animation.transform.TransformOptions]。
    """
    self.apply_matrix(np.linalg.inv(np.asarray(matrix, dtype=float)), **kwargs)

apply_transposed_matrix ¶

将矩阵（由其转置给出）作用于平面及其上的一切：如同 apply_matrix 所为。

self.apply_transposed_matrix(transposed_matrix, **kwargs)

transposed_matrix: 矩阵的转置，其行为矩阵所取 î 与 ĵ 之处。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\scene.py

def apply_transposed_matrix(
    self, transposed_matrix: npt.ArrayLike, **kwargs: Unpack[TransformOptions]
) -> None:
    """将矩阵（由其转置给出）作用于平面及其上的一切：如同
    [`apply_matrix`][manimgx.LinearTransformationScene.apply_matrix] 所为。

    Args:
        transposed_matrix: 矩阵的转置，其行为矩阵所取 î 与 ĵ 之处。
        **kwargs: play 中每个动画的[变换选项][manimgx.animation.transform.TransformOptions]。
    """
    func = self.get_transposed_matrix_transformation(transposed_matrix)
    if "path_arc" not in kwargs:
        kwargs["path_arc"] = float(
            np.mean(
                [
                    angle_of_vector(func(RIGHT)),
                    angle_of_vector(func(UP)) - np.pi / 2,
                ]
            )
        )
    self.apply_function(func, **kwargs)

apply_inverse_transpose ¶

将矩阵转置的逆作用于平面及其上的一切。

self.apply_inverse_transpose(t_matrix, **kwargs)

t_matrix: 该矩阵，2 × 2 或 3 × 3，必须可逆。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\scene.py

def apply_inverse_transpose(
    self, t_matrix: npt.ArrayLike, **kwargs: Unpack[TransformOptions]
) -> None:
    """将矩阵转置的逆作用于平面及其上的一切。

    Args:
        t_matrix: 该矩阵，2 × 2 或 3 × 3，必须可逆。
        **kwargs: play 中每个动画的[变换选项][manimgx.animation.transform.TransformOptions]。
    """
    t_inv = np.linalg.inv(np.array(t_matrix, dtype=float).T).T
    self.apply_transposed_matrix(t_inv, **kwargs)

apply_nonlinear_transformation ¶

将一个不必线性的函数作用于平面及其上的一切。

平面的线条先被分为许多曲线，以便其可弯曲（见 apply_function）。

self.apply_nonlinear_transformation(function, **kwargs)

function: 该函数，从点到其像，以场景坐标表示。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\scene.py

def apply_nonlinear_transformation(
    self,
    function: Callable[[np.ndarray], np.ndarray],
    **kwargs: Unpack[TransformOptions],
) -> None:
    """将一个不必线性的函数作用于平面及其上的一切。

    平面的线条先被分为许多曲线，以便其可弯曲（见
    [`apply_function`][manimgx.LinearTransformationScene.apply_function]）。

    Args:
        function: 该函数，从点到其像，以场景坐标表示。
        **kwargs: play 中每个动画的[变换选项][manimgx.animation.transform.TransformOptions]。
    """
    self.plane.prepare_for_nonlinear_transform()
    self.apply_function(function, **kwargs)

apply_function ¶

在一次 play 中将函数作用于平面及其上的一切。

可变换 mobject 的每个点都去往 function 所取之处；每个向量重绘到其尖端所去之处，其可变换标签跟随它；每个移动 mobject 整体移到其中心所去之处；前景 mobject 留在原处。带 leave_ghost_vectors 时，整体移动者的褪色副本留在其后。

self.apply_function(function, added_anims=None, **kwargs)

function: 该函数，从点到其像，以场景坐标表示。
added_anims: 一同播放的动画。
run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

源码

manimgx\scene.py

def apply_function(
    self,
    function: MappingFunction,
    added_anims: Sequence[Animation] | None = None,
    **kwargs: Unpack[TransformOptions],
) -> None:
    """在一次 play 中将函数作用于平面及其上的一切。

    可变换 mobject 的每个点都去往 `function` 所取之处；每个向量重绘到其
    尖端所去之处，其可变换标签跟随它；每个移动 mobject 整体移到其中心所
    去之处；前景 mobject 留在原处。带 `leave_ghost_vectors` 时，整体移动
    者的褪色副本留在其后。

    Args:
        function: 该函数，从点到其像，以场景坐标表示。
        added_anims: 一同播放的动画。
        **kwargs: play 中每个动画的[变换选项][manimgx.animation.transform.TransformOptions]
            （除非给定 `run_time`，否则为 3 秒）。
    """
    kwargs.setdefault("run_time", 3)
    anims: list[Animation] = [
        *(
            ApplyPointwiseFunction(function, t_mob)
            for t_mob in self.transformable_mobjects
        ),
        self.get_vector_movement(function),
        self.get_transformable_label_movement(),
        self.get_moving_mobject_movement(function),
        *(Animation(f_mob) for f_mob in self.foreground_mobjects),
        *(added_anims or ()),
    ]
    self.play(*anims, **kwargs)

ZoomedScene ¶

代码

import manimgx as m


class ZoomedSceneExample(m.ZoomedScene):
    def construct(self) -> None:
        title = m.Text("manimgx", font_size=120).shift(m.LEFT)
        note = m.Text("exact in time, typed throughout", font_size=14)
        note.next_to(title, m.DOWN)
        self.add(title, note)
        frame = self.zoomed_camera.frame
        frame.move_to(note.get_left())
        self.activate_zooming(animate=True)
        self.play(frame.animate.move_to(note.get_right()), run_time=2)

带第二个相机的场景，其画面显示在帧中：一个放大镜。

zoomed_camera 观察其帧（场景中的一个小矩形 zoomed_camera.frame）所覆盖的内容，zoomed_display 在帧的一个角落中较大地显示其画面。二者随 activate_zooming 出现；移动、缩放或为缩放相机的帧添加动画以观察别处，画面随之跟随。

class MyScene(m.ZoomedScene):

zoomed_display_height: 显示的高度，以场景单位表示。
zoomed_display_width: 显示的宽度，以场景单位表示。
zoomed_display_center: 显示中心所在位置；None 表示帧的一个角落。
zoomed_display_corner: 当无 zoomed_display_center 时显示所在的帧的角落：一个方向，如 UR。
zoomed_display_corner_buff: 显示在该角落处距各边的距离，以场景单位表示。
zoomed_camera_config: 缩放相机的外观：其帧的轮廓，及其画面的背景。
zoomed_camera_image_mobject_config: 显示的关键字参数，即缩放相机所观察画面的样式，及其轮廓的（default_display_frame_config）。
zoomed_camera_frame_starting_position: 缩放相机帧的起始位置。
zoom_factor: 缩放相机帧的尺寸，作为显示尺寸的分数：显示放大 1 / zoom_factor 倍。
image_frame_stroke_width: 为兼容 Manim 而接受；被忽略。
zoom_activated: 缩放是否激活： activate_zooming 设置它，其自身不显示任何内容。

源码

manimgx\scene.py

def __init__(
    self,
    zoomed_display_height: float = 3,
    zoomed_display_width: float = 3,
    zoomed_display_center: Point3DLike | None = None,
    zoomed_display_corner: Vector3DLike = UR,
    zoomed_display_corner_buff: float = DEFAULT_MOBJECT_TO_EDGE_BUFFER,
    zoomed_camera_config: ZoomedCameraConfig | None = None,
    zoomed_camera_image_mobject_config: ImageCameraOptions | None = None,
    zoomed_camera_frame_starting_position: Point3DLike = ORIGIN,
    zoom_factor: float = 0.15,
    image_frame_stroke_width: float = 3,
    zoom_activated: bool = False,
) -> None:
    self.zoomed_display_height = zoomed_display_height
    self.zoomed_display_width = zoomed_display_width
    self.zoomed_display_center = zoomed_display_center
    self.zoomed_display_corner = zoomed_display_corner
    self.zoomed_display_corner_buff = zoomed_display_corner_buff
    self.zoomed_camera_config = ZoomedCameraConfig(
        default_frame_stroke_width=2, background_opacity=1
    ) | (zoomed_camera_config or ZoomedCameraConfig())
    self.zoomed_camera_image_mobject_config: ImageCameraOptions = (
        zoomed_camera_image_mobject_config or {}
    )
    self.zoomed_camera_frame_starting_position = (
        zoomed_camera_frame_starting_position
    )
    self.zoom_factor = zoom_factor
    self.image_frame_stroke_width = (
        image_frame_stroke_width  # CE stores it and never reads it
    )
    self.zoom_activated = zoom_activated
    super().__init__()

setup ¶

创建缩放相机及其显示：render 在 construct 之前调用它。重写它的子类须先调用本方法。

self.setup()

源码

manimgx\scene.py

def setup(self) -> None:
    """创建缩放相机及其显示：[`render`][manimgx.Scene.render] 在 `construct`
    之前调用它。重写它的子类须先调用本方法。
    """
    from manimgx.mobjects.images import ImageMobjectFromCamera

    super().setup()
    options = self.zoomed_camera_config
    camera = Camera()
    camera.background_opacity = options.get("background_opacity", 1)
    camera.frame.set_stroke(
        options.get("default_frame_stroke_color", WHITE),
        options.get("default_frame_stroke_width", 2),
    )
    display = ImageMobjectFromCamera(
        camera, **self.zoomed_camera_image_mobject_config
    ).add_display_frame()
    for mob in (camera.frame, display):
        mob.stretch_to_fit_height(self.zoomed_display_height)
        mob.stretch_to_fit_width(self.zoomed_display_width)
    camera.frame.scale(self.zoom_factor)
    camera.frame.move_to(self.zoomed_camera_frame_starting_position)
    if self.zoomed_display_center is not None:
        display.move_to(self.zoomed_display_center)
    else:
        display.to_corner(
            self.zoomed_display_corner, buff=self.zoomed_display_corner_buff
        )
    self.zoomed_camera = camera
    self.zoomed_display = display

activate_zooming ¶

在最前显示缩放相机的帧及其显示。

self.activate_zooming(animate=False)

animate: 是否先以两次 play 为其出现添加动画：帧从整个视图缩小到其位置（get_zoom_in_animation），然后显示从中生长到自身位置（get_zoomed_display_pop_out_animation）。

源码

manimgx\scene.py

def activate_zooming(self, animate: bool = False) -> None:
    """在最前显示缩放相机的帧及其显示。

    Args:
        animate: 是否先以两次 play 为其出现添加动画：帧从整个视图缩小到其
            位置（`get_zoom_in_animation`），然后显示从中生长到自身位置
            （`get_zoomed_display_pop_out_animation`）。
    """
    self.zoom_activated = True
    if animate:
        self.play(self.get_zoom_in_animation())
        self.play(self.get_zoomed_display_pop_out_animation())
    self.add_foreground_mobjects(self.zoomed_camera.frame, self.zoomed_display)

get_zoom_in_animation ¶

制作缩放相机帧从整个视图缩小到其位置的动画。

帧立即移动到其起始状态：覆盖视图，以原点为中心，无轮廓，直到动画播放。

self.get_zoom_in_animation(**kwargs)

run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

返回该动画，以供播放。

源码

manimgx\scene.py

def get_zoom_in_animation(self, **kwargs: Unpack[TransformOptions]) -> Animation:
    """制作缩放相机帧从整个视图缩小到其位置的动画。

    帧立即移动到其起始状态：覆盖视图，以原点为中心，无轮廓，直到动画播放。

    Args:
        **kwargs: [变换选项][manimgx.animation.transform.TransformOptions]
            （除非给定 `run_time`，否则为 2 秒）。

    Returns:
        该动画，以供播放。
    """
    from manimgx.animation.motion import Restore

    kwargs.setdefault("run_time", 2)
    frame = self.zoomed_camera.frame
    frame.save_state()
    frame.stretch_to_fit_width(self.camera.frame_width)
    frame.stretch_to_fit_height(self.camera.frame_height)
    frame.center()
    frame.set_stroke(width=0)
    return Restore(frame, **kwargs)

get_zoomed_display_pop_out_animation ¶

制作显示从缩放相机帧生长到其位置的动画。

显示立即移动到其起始状态：覆盖缩放相机的帧，直到动画播放。

self.get_zoomed_display_pop_out_animation(**kwargs)

run_time: 动画播放时长，以秒为单位（默认 1）。
lag_ratio: mobject 各部分如何交错：每个部分在其前一个部分开始后，经过其运行时长的该分数比例后开始（默认 0：全部同时；1：一个接一个）。
rate_func: 动画进度如何随时间运行：一个从 [0, 1] 到 [0, 1] 的函数（默认为 smooth；参见 rate functions）。
reverse_rate_function: 是否反向运行动画（默认 False）。
name: 动画的名称。
remover: 动画结束时 mobject 是否离开场景（默认 False）。
suspend_mobject_updating: 动画期间 mobject 的更新器是否在其下运行（默认 True）：它们持续作用于 mobject，每一帧显示动画应用于其结果。若为 False，则它们作用于被动画的 mobject 本身。
introducer: 动画开始时 mobject 是否加入场景（默认 False）；否则若场景缺少它，play 在其开始时将其带入。
use_override: 若某 mobject 的类用另一个动画代替此动画播放，是否如此执行（默认 True）。

还接受变换关键字。

返回该动画，以供播放。

源码

manimgx\scene.py

def get_zoomed_display_pop_out_animation(
    self, **kwargs: Unpack[TransformOptions]
) -> Animation:
    """制作显示从缩放相机帧生长到其位置的动画。

    显示立即移动到其起始状态：覆盖缩放相机的帧，直到动画播放。

    Args:
        **kwargs: [变换选项][manimgx.animation.transform.TransformOptions]。

    Returns:
        该动画，以供播放。
    """
    from manimgx.animation.motion import Restore

    display = self.zoomed_display
    display.save_state()
    display.replace(self.zoomed_camera.frame, stretch=True)
    return Restore(display, **kwargs)

get_zoom_factor ¶

缩放相机帧相对于显示的尺寸。

self.get_zoom_factor()

返回帧高度除以显示高度：显示放大其倒数。

源码

manimgx\scene.py

def get_zoom_factor(self) -> float:
    """缩放相机帧相对于显示的尺寸。

    Returns:
        帧高度除以显示高度：显示放大其倒数。
    """
    return self.zoomed_camera.frame.height / self.zoomed_display.height

ZoomedCameraConfig ¶

缩放相机的外观：其帧的描边与其画面的背景。

default_frame_stroke_width: 缩放相机帧轮廓的宽度，以场景单位的百分之一表示（默认 2）。
default_frame_stroke_color: 缩放相机帧轮廓的颜色（默认白色）。
background_opacity: 缩放画面背景的不透明度，从 0 到 1（默认 1：遮挡其后的显示内容）。

default_frame_stroke_width ¶

缩放相机帧轮廓的宽度，以场景单位的百分之一表示（默认 2）。

default_frame_stroke_color ¶

缩放相机帧轮廓的颜色（默认白色）。

background_opacity ¶

缩放画面背景的不透明度，从 0 到 1（默认 1：遮挡其后的显示内容）。

ArrowTipsBase ¶

Arrow 除两端、缓冲和颜色外的关键字（供设置它们的方法使用）：其尖端、短时如何缩小，以及其弯曲。

max_tip_length_to_length_ratio: 尖端最长可为多长，为其长度的比例：短箭头的尖端更短（默认 0.25）。
max_stroke_width_to_length_ratio: 描边最宽可为多宽，以每场景单位长度的百分之一场景单位计：短箭头更细（默认 5）。
tip_shape: 其尖端的类（默认 ArrowTriangleFilledTip）。
path_arc: 直线所弯曲的角度，以弧度计：0 为直；否则为从起点到终点的弧，为正时逆时针（行进时向右弯），为负时顺时针（默认 0）。
tip_length: add_tip 所生成尖端的长度，以场景单位计（默认 0.35；Arrow 的可能更短）。
normal_vector: 路径所在平面的法向量（默认 OUT）。为兼容 Manim 而接受；被忽略且不保留。
tip_style: 路径所生成尖端的样式关键字（默认 None：无）。除非在此给出，否则尖端的 fill_color 和 stroke_color 取路径的颜色。
fill_color: 填充的颜色；未给出时为 color。多个颜色沿 sheen_direction 构成渐变。
fill_opacity: 填充的不透明度，取值从 0 到 1（默认 0：无填充）。
stroke_color: 描边的颜色；未给出时为 color。多个颜色构成渐变。
stroke_opacity: 描边的不透明度，取值从 0 到 1（默认 1）。
stroke_width: 描边的宽度，以场景单位的百分之一计（默认 4；0：无描边）。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

MatrixOptions ¶

Matrix 除条目以外的关键字参数，供将其传递下去的方法使用（如向量的坐标标签）：即条目的类型，以及其布局、括号和样式。

v_buff: 各行之间的距离，以场景单位表示，从一行的条目对齐角到下一行的对齐角（默认 0.8）。
h_buff: 各列之间的距离，以场景单位表示，同上（默认 1.3）。
bracket_h_buff: 条目与每个括号之间的间距，以场景单位表示（默认 0.25）。
bracket_v_buff: 当括号被拉伸时，括号在条目上下方延伸的距离，以场景单位表示（默认 0.25）。
add_background_rectangles_to_entries: 每个条目是否获得一个背景矩形（默认 False）。
include_background_rectangle: 矩阵是否获得一个背景矩形（默认 False）。
element_alignment_corner: 每个条目放置在网格上的角，以方向命名：DR 使一列中的条目按其右侧对齐， UL 则按其左侧对齐（默认 DR）。
left_bracket: 左括号，作为 LaTeX 分隔符："[", "(", "\{", "\langle", "|", …（默认 "["）。
right_bracket: 右括号，作为 LaTeX 分隔符（默认 "]"）。
stretch_brackets: 括号是否被拉伸到条目的高度，并再延伸 bracket_v_buff 的距离（默认 True）。
bracket_config: 括号的 Math 关键字：其 color，…（默认 None：无）。
element_to_mobject: 构造每个条目的 mobject 的函数，以条目和 element_to_mobject_config 的关键字参数调用（默认：矩阵类自身的函数，对于 Matrix 为 MathTex）。
element_to_mobject_config: element_to_mobject 的关键字参数（默认 None：矩阵类自身的设置，对于 Matrix 为无）。
color: 填充与描边共用的颜色（默认白色）；None 表示该类的默认值。
fill_color: 填充的颜色；未给出时为 color。多个颜色沿 sheen_direction 构成渐变。
fill_opacity: 填充的不透明度，取值从 0 到 1（默认 0：无填充）。
stroke_color: 描边的颜色；未给出时为 color。多个颜色构成渐变。
stroke_opacity: 描边的不透明度，取值从 0 到 1（默认 1）。
stroke_width: 描边的宽度，以场景单位的百分之一计（默认 4；0：无描边）。
background_stroke_color: 绘制于填充之后的轮廓颜色（默认黑色）。
background_stroke_opacity: 轮廓的不透明度，取值从 0 到 1（默认 1）。
background_stroke_width: 轮廓的宽度，以场景单位的百分之一计（默认 0：无）。
sheen_factor: 颜色朝 sheen_direction 变亮的程度，取值从 -1 到 1（默认 0）；负值变暗。
sheen_direction: 颜色变亮的方向（默认 UL）。
joint_type: 描边在路径转折处的连接方式：圆角、斜切或斜接，按二维场景的绘制方式（参见 LineJointType；默认 AUTO：斜接）。
cap_style: 描边在其显示的每一端的端点样式（开放路径的端点、虚线的端点）：圆头、平头或方头，按二维场景的绘制方式（参见 CapStyleType；默认 AUTO：平头）。
shade_in_3d: 三维场景的光是否对该 mobject 着色。
material: 其表面在三维场景中如何反射场景的光（参见 Material）；None：Manim 的着色（默认）。
name: mobject 的名称；未给出时为其类名。
z_index: 其在绘制顺序中的位置：索引较高者绘制于较低者之上（默认 0）。
target: MoveToTarget 将 mobject 移动至的状态。

v_buff ¶

各行之间的距离，以场景单位表示，从一行的条目对齐角到下一行的对齐角（默认 0.8）。

h_buff ¶

各列之间的距离，以场景单位表示，同上（默认 1.3）。

bracket_h_buff ¶

条目与每个括号之间的间距，以场景单位表示（默认 0.25）。

bracket_v_buff ¶

当括号被拉伸时，括号在条目上下方延伸的距离，以场景单位表示（默认 0.25）。

add_background_rectangles_to_entries ¶

每个条目是否获得一个背景矩形（默认 False）。

include_background_rectangle ¶

矩阵是否获得一个背景矩形（默认 False）。

element_alignment_corner ¶

每个条目放置在网格上的角，以方向命名：DR 使一列中的条目按其右侧对齐， UL 则按其左侧对齐（默认 DR）。

left_bracket ¶

左括号，作为 LaTeX 分隔符："[", "(", "\{", "\langle", "|", …（默认 "["）。

right_bracket ¶

右括号，作为 LaTeX 分隔符（默认 "]"）。

stretch_brackets ¶

括号是否被拉伸到条目的高度，并再延伸 bracket_v_buff 的距离（默认 True）。

bracket_config ¶

括号的 Math 关键字：其 color，…（默认 None：无）。

element_to_mobject ¶

构造每个条目的 mobject 的函数，以条目和 element_to_mobject_config 的关键字参数调用（默认：矩阵类自身的函数，对于 Matrix 为 MathTex）。

element_to_mobject_config ¶

element_to_mobject 的关键字参数（默认 None：矩阵类自身的设置，对于 Matrix 为无）。

LabelPlacement ¶

向量标签所在位置（供传递它的方法使用）。

at_tip: 标签是否位于向量尖端之外，而非其旁边中部（默认 False）。
direction: 沿向量方向看时标签所在的侧（默认 "left"）。
rotate: 标签是否随向量转动，而非保持直立（默认 False）。

VectorLabelOptions ¶

向量标签所在位置、其颜色与其尺寸（供传递它们的方法使用）。

color: 当标签由字符串生成时的颜色（默认 None：取向量的颜色）。
label_scale_factor: 标签的缩放倍数（默认 0.8）。
at_tip: 标签是否位于向量尖端之外，而非其旁边中部（默认 False）。
direction: 沿向量方向看时标签所在的侧（默认 "left"）。
rotate: 标签是否随向量转动，而非保持直立（默认 False）。

color ¶

当标签由字符串生成时的颜色（默认 None：取向量的颜色）。

label_scale_factor ¶

标签的缩放倍数（默认 0.8）。

UnitSquareOptions ¶

单位正方形的外观（供传递它的方法使用）。

color: 其填充与描边的颜色（默认黄色）。
opacity: 其填充的不透明度，从 0 到 1（默认 0.3）。
stroke_width: 其描边的宽度，以场景单位的百分之一表示（默认 3）。

color ¶

其填充与描边的颜色（默认黄色）。

opacity ¶

其填充的不透明度，从 0 到 1（默认 0.3）。

stroke_width ¶

其描边的宽度，以场景单位的百分之一表示（默认 3）。