Manim Package

Manim package is based on 19Dec2019 version

Structure of Manim Package

Package Structure16Jan2020 based on 19Dec2019.

• manim.py
  • manimlib
    • animation
      • animation.py
        • class Animation(object)
      • composition.py
        • class AnimationGroup(Animation)
        • class Succession(AnimationGroup)
        • class LaggedStart(AnimationGroup)
        • class LaggedStartMap(LaggedStart)
      • creation.py
        • class ShowPartial(Animation)
        • class ShowCreation(ShowPartial)
        • class Uncreate(ShowCreation)
        • class DrawBorderThenFill(Animation)
        • class Write(DrawBorderThenFill)
        • class ShowIncreasingSubsets(Animation)
        • class ShowSubmobjectsOneByOne(ShowIncreasingSubsets)
        • class AddTextWordByWord(Succession)
      • fading.py
        • class FadeOut(Transform)
        • class FadeIn(Transform)
        • class FadeInFrom(Transform)
        • class FadeInFromDown(FadeInFrom)
        • class FadeOutAndShift(FadeOut)
        • class FadeOutAndShiftDown(FadeOutAndShift)
        • class FadeInFromPoint(FadeIn)
        • class FadeInFromLarge(FadeIn)
        • class VFadeIn(Animation)
        • class VFadeOut(VFadeIn)
        • class VFadeInThenOut(VFadeIn)
      • transform.py
        • class Transform(Animation)
        • class ReplacementTransform(Transform)
        • class TransformFromCopy(Transform)
        • class ClockwiseTransform(Transform)
        • class CounterclockwiseTransform(Transform)
        • class MoveToTarget(Transform)
        • class ApplyMethod(Transform)
        • class ApplyPointwiseFunction(ApplyMethod)
        • class ApplyPointwiseFunctionToCenter(ApplyPointwiseFunction)
        • class FadeToColor(ApplyMethod)
        • class ScaleInPlace(ApplyMethod)
        • class ShrinkToCenter(ScaleInPlace)
        • class Restore(ApplyMethod)
        • class ApplyFunction(Transform)
        • class ApplyMatrix(ApplyPointwiseFunction)
        • class ApplyComplexFunction(ApplyMethod)
        • class CyclicReplace(Transform)
        • class TransformAnimations(Transform)
      • growing.py
        • class GrowFromPoint(Transform)
        • class GrowFromCenter(GrowFromPoint)
        • class GrowFromEdge(GrowFromPoint)
        • class GrowArrow(GrowFromPoint)
        • class SpinInFromNothing(GrowFromCenter)
      • indication.py
        • class FocusOn(Transform)
        • class Indicate(Transform)
        • class Flash(AnimationGroup)
        • class CircleIndicate(Indicate)
        • class ShowPassingFlash(ShowPartial)
        • class ShowCreationThenDestruction(ShowPassingFlash)
        • class ShowCreationThenFadeOut(Succession)
        • class AnimationOnSurroundingRectangle(AnimationGroup)
        • class ShowPassingFlashAround(AnimationOnSurroundingRectangle)
        • class ShowCreationThenDestructionAround(AnimationOnSurroundingRectangle)
        • class ShowCreationThenFadeAround(AnimationOnSurroundingRectangle)
        • class ApplyWave(Homotopy)
        • class WiggleOutThenIn(Animation)
        • class TurnInsideOut(Transform)
      • movement.py
        • class Homotopy(Animation)
        • class SmoothedVectorizedHomotopy(Homotopy)
        • class ComplexHomotopy(Homotopy)
        • class PhaseFlow(Animation)
        • class MoveAlongPath(Animation)
      • numbers.py*
        • class ChangingDecimal(Animation)
        • class ChangeDecimalToValue(ChangingDecimal)
      • rotation.py
        • class Rotating(Animation)
        • class Rotate(Transform)
      • specialized.py
        • class MoveCar(ApplyMethod)
        • class Broadcast(LaggedStart)
      • update.py
        • class UpdateFromFunc(Animation)
        • class UpdateFromAlphaFunc(UpdateFromFunc)
        • class MaintainPositionRelativeTo(Animation)
    • camera
      • camer.py
        • class Camera(object)
        • class BackgroundColoredVMobjectDisplayer(object)
      • mapping_camera.py
        • class MappingCamera(Camera)
        • class OldMultiCamera(Camera)
        • class SplitScreenCamera(OldMultiCamera)
      • moving_camera.py
        • class CameraFrame(VGroup)
        • class MovingCamera(Camera)
      • multi_camera.py
        • class MultiCamera(MovingCamera)
      • three_d_camera.py
        • class ThreeDCamera(Camera)
  • mobject
    • svg
      • brace.py
        • class Brace(TexMobject)
        • class BraceLabel(VMobject)
        • class BraceText(BraceLabel)
      • drawings.py (svg examples)
        • class Lightbulb(SVGMobject)
        • class BitcoinLogo(SVGMobject)
        • class Guitar(SVGMobject)
        • class SunGlasses(SVGMobject)
        • class Speedometer(VMobject)
        • class AoPSLogo(SVGMobject)
        • class PartyHat(SVGMobject)
        • class Laptop(VGroup)
        • class PatreonLogo(SVGMobject)
        • class VideoIcon(SVGMobject)
        • class VideoSeries(VGroup)
        • class Headphones(SVGMobject)
        • class Clock(VGroup)
        • class ClockPassesTime(Animation)
        • class Bubble(SVGMobject)
        • class SpeechBubble(Bubble)
        • class DoubleSpeechBubble(Bubble)
        • class ThoughtBubble(Bubble)
        • class Car(SVGMobject)
        • class VectorizedEarth(SVGMobject)
        • class Logo(VMobject)
        • class DeckOfCards(VGroup)
        • class PlayingCard(VGroup)
        • class SuitSymbol(SVGMobject)
      • svg_mobject.py
        • def string_to_numbers(num_string)
        • class SVGMobject(VMobject)
        • class VMobjectFromSVGPathstring(VMobject)
      • tex_mobject.py
        • class TexSymbol(VMobjectFromSVGPathstring)
        • class SingleStringTexMobject(SVGMobject)
        • class TexMobject(SingleStringTexMobject)
        • class TextMobject(TexMobject)
        • class BulletedList(TextMobject)
        • class TexMobjectFromPresetString(TexMobject)
        • class Title(TextMobject)
      • text_mobject.py
        • class TextSetting(object)
        • class Text(SVGMobject)
    • types
      • image_mobject.py
        • class AbstractImageMobject(Mobject)
        • class ImageMobject(AbstractImageMobject)
        • class ImageMobjectFromCamera(AbstractImageMobject)
      • point_cloud_mobject.py
        • class PMobject(Mobject)
        • class Mobject1D(PMobject)
        • class Mobject2D(PMobject)
        • class PGroup(PMobject)
        • class PointCloudDot(Mobject1D)
        • class Point(PMobject)
      • vectorized_mobject.py
        • class VMobject(Mobject)
        • class VGroup(VMobject)
        • class VectorizedPoint(VMobject)
        • class CurvesAsSubmobjects(VGroup)
        • class DashedVMobject(VMobject)
    • changing.py
      • class AnimatedBoundary(VGroup)
      • class TracedPath(VMobject)
    • coordinate_systems.py
      • class CoordinateSystem()
      • class Axes(VGroup, CoordinateSystem)
      • class ThreeDAxes(Axes)
      • class NumberPlane(Axes)
      • class ComplexPlane(NumberPlane)
    • frame.py
      • class ScreenRectangle(Rectangle)
      • class FullScreenRectangle(ScreenRectangle)
      • class FullScreenFadeRectangle(FullScreenRectangle)
      • class PictureInPictureFrame(Rectangle)
    • functions.py
      • class ParametricFunction(VMobject)
      • class FunctionGraph(ParametricFunction)
    • geometry.py
      • class TipableVMobject(VMobject)
      • class Arc(TipableVMobject)
      • class ArcBetweenPoints(Arc)
      • class CurvedArrow(ArcBetweenPoints)
      • class CurvedDoubleArrow(CurvedArrow)
      • class Circle(Arc)
      • class Dot(Circle)
      • class SmallDot(Dot)
      • class Ellipse(Circle)
      • class AnnularSector(Arc)
      • class Sector(AnnularSector)
      • class Annulus(Circle)
      • class Line(TipableVMobject)
      • class DashedLine(Line)
      • class TangentLine(Line)
      • class Elbow(VMobject)
      • class Arrow(Line)
      • class Vector(Arrow)
      • class DoubleArrow(Arrow)
      • class CubicBezier(VMobject)
      • class Polygon(VMobject)
      • class RegularPolygon(Polygon)
      • class Triangle(RegularPolygon)
      • class ArrowTip(Triangle)
      • class Rectangle(Polygon)
      • class Square(Rectangle)
      • class RoundedRectangle(Rectangle)
    • matrix.py
      • def matrix_to_tex_string(matrix)
      • def matrix_to_mobject(matrix)
      • def vector_coordinate_label
      • class Matrix(VMobject)
      • class DecimalMatrix(Matrix)
      • class IntegerMatrix(Matrix)
      • class MobjectMatrix(Matrix)
      • def get_det_text(matrix, determinant=None, background_rect=False, initial_scale_factor=2)
    • mobject.py
      • class Mobject(Container
      • class Group(Mobject)
    • mobject_update_utils.py
      • def assert_is_mobject_method(method)
      • def always(method, *args, **kwargs)
      • def f_always(method, *arg_generators, **kwargs)
        • def updater(mob)
      • def always_redraw(func)
      • def always_shift(mobject, direction=RIGHT, rate=0.1)
      • def always_rotate(mobject, rate=20 * DEGREES, **kwargs)
      • def turn_animation_into_updater(animation, cycle=False, **kwargs)
        • def update(m, dt)
      • def cycle_animation(animation, **kwargs)
    • number_line.py
      • class NumberLine(Line)
      • class UnitInterval(NumberLine)
    • numbers.py
      • class DecimalNumber(VMobject)
      • class Integer(DecimalNumber)
    • probability.py
      • class SampleSpace(Rectangle)
      • class BarChart(VGroup)
    • shape_matchers.py
      • class SurroundingRectangle(Rectangle)
      • class BackgroundRectangle(SurroundingRectangle)
      • class Cross(VGroup)
      • class Underline
    • three_d_shading_utils.py
      • def get_3d_vmob_gradient_start_and_end_points(vmob)
      • def get_3d_vmob_start_corner_index(vmob)
      • def get_3d_vmob_end_corner_index(vmob)
      • def get_3d_vmob_start_corner(vmob)
      • def get_3d_vmob_end_corner(vmob)
      • def get_3d_vmob_unit_normal(vmob, point_index)
      • def get_3d_vmob_start_corner_unit_normal(vmob)
      • def get_3d_vmob_end_corner_unit_normal(vmob)
    • three_d_utils.py
      • def get_3d_vmob_gradient_start_and_end_points(vmob)
      • def get_3d_vmob_start_corner_index(vmob)
      • def get_3d_vmob_end_corner_index(vmob)
      • def get_3d_vmob_start_corner(vmob)
      • def get_3d_vmob_end_corner(vmob)
      • def get_3d_vmob_unit_normal(vmob, point_index)
      • def get_3d_vmob_start_corner_unit_normal(vmob)
      • def get_3d_vmob_end_corner_unit_normal(vmob)
    • three_dimension.py
      • class ThreeDVMobject(VMobject)
      • class ParametricSurface(VGroup)
      • class Sphere(ParametricSurface)
      • class Cube(VGroup)
      • class Prism(Cube)
    • value_tracker.py
      • class ValueTracker(Mobject)
      • class ExponentialValueTracker(ValueTracker)
      • class ComplexValueTracker(ValueTracker)
    • vector_field.py
      • def get_colored_background_image(scalar_field_func, number_to_rgb_func, pixel_height=DEFAULT_PIXEL_HEIGHT, pixel_width=DEFAULT_PIXEL_WIDTH)
      • def get_rgb_gradient_function(min_value=0, max_value=1, colors=[BLUE, RED], flip_alphas=True, # Why? )
        • def func(values)
      • def get_color_field_image_file(scalar_func, min_value=0, max_value=2, colors=DEFAULT_SCALAR_FIELD_COLORS )
      • def move_along_vector_field(mobject, func)
      • def move_submobjects_along_vector_field(mobject, func)
        • def apply_nudge(mob, dt)
      • def move_points_along_vector_field(mobject, func)
        • def apply_nudge(self, dt)
      • class VectorField(VGroup)
      • class StreamLines(VGroup)
      • class ShowPassingFlashWithThinningStrokeWidth(AnimationGroup)
      • class AnimatedStreamLines(VGroup)
  • scene
    • graph_scene.py
      • class GraphScene(Scene)
    • moving_camera_scene.py
      • class MovingCameraScene(Scene)
    • reconfigurable_scene.py
      • class ReconfigurableScene(Scene)
    • sample_space_scene.py
      • class SampleSpaceScene(Scene)
    • scene.py
      • class Scene(Container)
      • class EndSceneEarlyException(Exception)
    • scene_file_writer.py
      • class SceneFileWriter(object)
    • scene_from_video.py
      • SceneFromVideo(Scene)
    • three_d_scene.py
      • class ThreeDScene(Scene)
      • class SpecialThreeDScene(ThreeDScene)
    • vector_space_scene.py
      • class VectorScene(Scene)
      • class LinearTransformationScene(VectorScene)
    • zoomed_scene.py
      • class ZoomedScene(MovingCameraScene)
  • utils
    • bezier.py
      • def bezier(points)
      • def partial_bezier_points(points, a, b)
      • def interpolate(start, end, alpha)
      • def integer_interpolate(start, end, alpha)
      • def mid(start, end)
      • def inverse_interpolate(start, end, value)
      • def match_interpolate(new_start, new_end, old_start, old_end, old_value)
      • def get_smooth_handle_points(points)
        • def solve_func(b)
          • def closed_curve_solve_func(b)
      • def diag_to_matrix(l_and_u, diag)
      • def is_closed(points)
    • color.py
      • def color_to_rgb(color)
      • def color_to_rgba(color, alpha=1)
      • def rgb_to_color(rgb)
      • def rgba_to_color(rgba)
      • def rgb_to_hex(rgb)
      • def hex_to_rgb(hex_code)
      • def invert_color(color)
      • def color_to_int_rgb(color)
      • def color_to_int_rgba(color, opacity=1.0)
      • def color_gradient(reference_colors, length_of_output)
      • def interpolate_color(color1, color2, alpha)
      • def average_color(*colors)
      • def random_bright_color()
      • def random_color()
      • def get_shaded_rgb(rgb, point, unit_normal_vect, light_source)
    • config_ops.py
      • def get_all_descendent_classes(Class)
      • def filtered_locals(caller_locals)
      • def digest_config(obj, kwargs, caller_locals={})
      • def merge_dicts_recursively(*dicts)
      • def soft_dict_update(d1, d2)
      • def digest_locals(obj, keys=None)
      • class DictAsObject(object):
        • def __init__(self, dict)
    • debug
      • def print_family(mobject, n_tabs=0)
      • def get_submobject_index_labels(mobject, label_height=0.15)
    • file_ops.py
      • def add_extension_if_not_present(file_name, extension)
      • def guarantee_existence(path)
      • def seek_full_path_from_defaults(file_name, default_dir, extensions)
      • def get_sorted_integer_files(directory, min_index=0, max_index=np.inf, remove_non_integer_files=False, remove_indices_greater_than=None, extension=None, )
    • images.py
      • def get_full_raster_image_path(image_file_name)
      • def drag_pixels(frames)
      • def invert_image(image)
    • iterables.py
      • def remove_list_redundancies(l)
      • def list_update(l1, l2)
      • def list_difference_update(l1, l2)
      • def all_elements_are_instances(iterable, Class)
      • def adjacent_n_tuples(objects, n)
      • def adjacent_pairs(objects)
      • def batch_by_property(items, property_func)
        • def add_batch_prop_pair(batch)
      • def tuplify(obj)
      • def stretch_array_to_length(nparray, length)
      • def make_even(iterable_1, iterable_2)
      • def make_even_by_cycling(iterable_1, iterable_2)
      • def remove_nones(sequence)
      • def concatenate_lists(*list_of_lists)
    • paths.py
      • def straight_path(start_points, end_points, alpha)
      • def path_along_arc(arc_angle, axis=OUT)
        • def path(start_points, end_points, alpha)
      • def clockwise_path()
      • def counterclockwise_path()
    • rate_functions/py
      • def linear(t)
      • def smooth(t, inflection=10.0)
      • def rush_into(t, inflection=10.0)
      • def rush_from(t, inflection=10.0)
      • def slow_into(t)
      • def double_smooth(t)
      • def there_and_back(t, inflection=10.0)
      • def there_and_back_with_pause(t, pause_ratio=1. / 3)
      • def running_start(t, pull_factor=-0.5)
      • def not_quite_there(func=smooth, proportion=0.7)
        • def result(t)
      • def wiggle(t, wiggles=2)
      • def squish_rate_func(func, a=0.4, b=0.6)
        • def result(t)
      • def lingering(t)
      • def exponential_decay(t, half_life=0.1)
    • simple_functions.py
      • def sigmoid(x)
      • def choose_using_cache(n, r)
      • def choose(n, r, use_cache=True)
      • def get_num_args(function)
      • def get_parameters(function)
      • def clip_in_place(array, min_val=None, max_val=None)
      • def fdiv(a, b, zero_over_zero_value=None)
      • def binary_search(function, target, lower_bound, upper_bound, tolerance=1e-4)
    • sounds.py
      • def play_chord(*nums)
      • def play_error_sound()
      • def play_finish_sound()
      • def get_full_sound_file_path(sound_file_name)
    • space_ops.py
      • def get_norm(vect)
      • def quaternion_mult(q1, q2)
      • def quaternion_from_angle_axis(angle, axis)
      • def angle_axis_from_quaternion(quaternion)
      • def quaternion_conjugate(quaternion)
      • def rotate_vector(vector, angle, axis=OUT)
      • def thick_diagonal(dim, thickness=2)
      • def rotation_matrix(angle, axis)
      • def rotation_about_z(angle)
      • def z_to_vector(vector)
      • def angle_between(v1, v2)
      • def angle_of_vector(vector)
      • def angle_between_vectors(v1, v2)
      • def project_along_vector(point, vector)
      • def normalize(vect, fall_back=None)
      • def cross(v1, v2)
      • def get_unit_normal(v1, v2)
      • def compass_directions(n=4, start_vect=RIGHT)
      • def complex_to_R3(complex_num)
      • def R3_to_complex(point)
      • def complex_func_to_R3_func(complex_func)
      • def center_of_mass(points)
      • def midpoint(point1, point2)
      • def line_intersection(line1, line2)
        • def det(a, b)
      • def get_winding_number(points)
    • strings.py
      • def to_camel_case(name)
      • def initials(name, sep_values=[" ", "_"])
      • def camel_case_initials(name)
      • def complex_string(complex_num)
      • def split_string_to_isolate_substrings(full_string, *substrings_to_isolate)
      • def split_string_list_to_isolate_substrings(string_list, *substrings_to_isolate)
    • tex_file_writing.py
      • def tex_hash(expression, template_tex_file_body)
      • def tex_to_svg_file(expression, template_tex_file_body)
      • def generate_tex_file(expression, template_tex_file_body)
      • def tex_to_dvi(tex_file)
      • def dvi_to_svg(dvi_file, regen_if_exists=False)

Source and Reference

https://github.com/3b1b/manim19Dec2019