Sideway
output.to from Sideway
Draft for Information Only

Content

Manim Package
 Structure of Manim Package
 Source and Reference

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

©sideway

ID: 200401502 Last Updated: 4/15/2020 Revision: 0


Latest Updated LinksValid XHTML 1.0 Transitional Valid CSS!Nu Html Checker Firefox53 Chromena IExplorerna
IMAGE

Home 5

Business

Management

HBR 3

Information

Recreation

Hobbies 8

Culture

Chinese 1097

English 339

Reference 79

Computer

Hardware 249

Software

Application 213

Digitization 32

Latex 52

Manim 205

KB 1

Numeric 19

Programming

Web 289

Unicode 504

HTML 66

CSS 65

SVG 46

ASP.NET 270

OS 429

DeskTop 7

Python 72

Knowledge

Mathematics

Formulas 8

Algebra 84

Number Theory 206

Trigonometry 31

Geometry 34

Coordinate Geometry 2

Calculus 67

Complex Analysis 21

Engineering

Tables 8

Mechanical

Mechanics 1

Rigid Bodies

Statics 92

Dynamics 37

Fluid 5

Fluid Kinematics 5

Control

Process Control 1

Acoustics 19

FiniteElement 2

Natural Sciences

Matter 1

Electric 27

Biology 1

Geography 1


Copyright © 2000-2024 Sideway . All rights reserved Disclaimers last modified on 06 September 2019