Source code for ManimGraphLibrary

from manim import *
import networkx as nx
from math import *

[docs]class GraphNode:
    """Creates an object which is a node of a graph.

    Parameters
    ----------

    name
        Key of the node used to recall it. It becomes also the label if 'node_label' is not specified.
    name_label
        Label contained inside the circle. Can be omitted.
    font_size
        Scaling of the label inside the circle.
    label_color
        Color of the label inside the circle.
    position
        Position of the circle and the label.
    radius
        Radius of the circle.    
    node_color
        Color of the inside of the circle. The opacity is set to be 0.5.
    stroke_color
        Color of the outline of the circle.     

    """

    def __init__(
        self,
        name,
        name_label=None,
        font_size=1,
        label_color=WHITE,
        position=ORIGIN,
        radius=0.5,        
        node_color=LIGHT_GREY,
        stroke_color=WHITE        
        ):

        self.name = name
        if name_label is None:
            name_label = name
        self.label = Text(str(name_label))
        self.label.scale(font_size)
        self.label.move_to(position)
        self.label.set_color(color=label_color)

        self.center = position
        self.radius = radius
        self.circle = Circle(radius=radius)
        self.circle.move_to(position)
        self.circle.set_fill(color=node_color, opacity=0.5)
        self.circle.set_stroke(color=stroke_color)        

        self.neighbours = []

        # self.visited = False
        # self.previous = None



[docs]    def connect(
        self, 
        other, 
        arrow=False, 
        edge_color=LIGHT_GREY, 
        width=7
        ):

        """Creates a line between node 'self' and node 'other'.
        Adds 'other' to the list of neighbours of the first node.

        Parameters
        ----------

        self
            First node.
        other
            Second node.
        arrow
            If True adds an arrow tip at the end of the line.
        edge_color
            Color of the line.
        width
            Width of the line.

        Returns
        -------

        Line
            Line between node 'self' and 'other'.      


        Notes
        -----

        When we connect two nodes, the line connects the centers of the circles.
        To solve this we get the direction of the line and move 'start' and 'end' by the value of the radius along this direction.


        Examples
        --------

        .. manim:: Connect

            from ManimGraphLibrary import *

            class Connect(Scene):
                def construct(self):
                    node_a = GraphNode(name='a', position=LEFT*2)
                    node_b = GraphNode(name='b', position=RIGHT*2)
                    nodes_view = VGroup(node_a.circle, node_a.label, node_b.circle, node_b.label)
                    edge_view = node_a.connect(node_b, arrow=True, edge_color=WHITE)
                    self.add(nodes_view)
                    self.play(Create(edge_view))
                    self.wait()

        """

        start, end = self.center, other.center
        line_center = Line(start, end)
        direction = line_center.get_unit_vector()
        
        new_start = start + direction * self.radius
        new_end = end - direction * self.radius

        line = Line(new_start, new_end)

        line.set_stroke(width=width)
        line.set_color(color=edge_color)

        if arrow:
            line.add_tip()
            line.get_tip().set_stroke(width=1)

        self.neighbours.append(other)

        return line

[docs]    def connect_weight(
        self, 
        other, 
        arrow=False, 
        edge_color=LIGHT_GREY, 
        width=7, 
        weight=None, 
        label_color=WHITE, 
        label_font_size=0.8,
        label_distance=0.3
        ):

        """Recalls the function 'connect' to create a line between node 'self' and node 'other' and to add 'other' to the list of neighbours of the first node.
        Adds also a label with the weight of the edge.

        Parameters
        ----------
        self
            First node.
        other
            Second node.
        arrow
            If True adds an arrow tip at the end of the line.
        edge_color
            Color of the line.
        width
            Width of the line.

        weight
            Weight of the edge from node 'self' to 'other'.
            If None the weight label will be empty.
        label_color
            Color of the weight label.
        label_font_size
            Scaling of the label.
        label_distance
            Distance between the line and the weight label.

        Returns
        -------
        Line
            Line between node 'self' and 'other'.  
        Text
            Label with the weight of the edge.    

        Notes
        -----
        To compute the position for the label we get the direction of the line between the nodes and 
        compute the orthogonal direction anticlockwise: (x, y) -> (y, -x) 
        Then we move the label along this orthogonal direction.

        Examples
        --------
        .. manim:: ConnectWeight

            from ManimGraphLibrary import *

            class ConnectWeight(Scene):
                def construct(self):
                    node_a = GraphNode(name='a', position=LEFT*2)
                    node_b = GraphNode(name='b', position=RIGHT*2)
                    nodes_view = VGroup(node_a.circle, node_a.label, node_b.circle, node_b.label)
                    edge_view = node_a.connect_weight(node_b, arrow=True, weight=3)
                    self.add(nodes_view)
                    self.play(Create(VGroup(*edge_view)))
                    self.wait()


        """

        line = self.connect(other, arrow=arrow, edge_color=edge_color, width=width)

        direction = line.get_unit_vector()
        mean = line.start + direction * line.get_length()/2
        orthogonal_dir = np.array([direction[1], -direction[0], 0]) 

        if weight == None:
            label = Text('') 
        else:
            label = Text(str(weight))

        label.move_to(mean + orthogonal_dir * label_distance)
        label.set_color(color=label_color) 
        label.scale(label_font_size) 

        return line, label

[docs]def node_layout(
    edges_input, 
    layout='kamada_kawai_layout'
    ):

    """Generates positions for the nodes taking a list of edges as the input.

    Parameters
    ----------

    edges_input
        List of edges. 
        Example: [('a','b'), ('b','c')]
    layout 
        Name of the NETWORKX layout desired.

    Returns
    -------

    dict
        Dictionary with node names as keys and positions as values.
        Example: {'a': LEFT, 'b': np.array([-1.6,  0.1,  0. ])} 

    Notes
    -----   

    We use the library NETWORKX, we create a graph and add the edges.
    https://networkx.org/documentation/stable/reference/drawing.html?highlight=layout#module-networkx.drawing.layout

    In the variable 'pos' we save each node label with (x,y) coordinates.
    We want to give as output something in the form {'0': np.array([-1.6,  0.1,  0. ]), '1': np.array([ 0.4, -1.8 ,  0. ])}
    We use (x,y) coordinates from 'pos' and edit them in order to fit the space properly: we compute the ratio 
    between the available space and the space taken by the graph in order to scale it.

    Examples
    --------

    .. manim:: NodeLayout

        from ManimGraphLibrary import *

        class NodeLayout(Scene):
            def construct(self):   
                edges_input = [('a','b'), ('b','c'), ('a','c'), ('c', 'd'), ('a', 'd')]

                nodes_and_positions = node_layout(edges_input, layout = 'spring_layout')
                graph_nodes, nodes_view, edges_view, graph = make_graph(nodes_and_positions, edges_input)

                nodes_and_positions = node_layout(edges_input, layout = 'kamada_kawai_layout')
                graph_nodes_2, nodes_view_2, edges_view_2, graph_2 = make_graph(nodes_and_positions, edges_input)

                nodes_and_positions = node_layout(edges_input, layout = 'planar_layout')
                graph_nodes_3, nodes_view_3, edges_view_3, graph_3 = make_graph(nodes_and_positions, edges_input)

                self.add(graph)
                self.wait()
                graph_copy = graph.copy()
                self.play(ReplacementTransform(graph, graph_2))                
                self.wait()
                self.play(ReplacementTransform(graph_2, graph_3))
                self.wait()
                self.play(ReplacementTransform(graph_3, graph_copy))


    """  

    G = nx.DiGraph()				
    G.add_edges_from(edges_input)  

    try:
        layout_function = eval(f'nx.{layout}')
        pos = layout_function(G)
    
    except:
        print('Layout not available')
        pos = nx.kamada_kawai_layout(G)

        
    labels = list(pos.keys())

    x = [x for x, y in pos.values()]
    y = [y for x, y in pos.values()]

    coeff_x = config.frame_x_radius/(abs(max(x)-min(x)))
    coeff_y = config.frame_y_radius/(abs(max(y)-min(y)))

    positions = []

    for label in labels:
        positions.append(np.array([pos.get(label)[0]*coeff_x, pos.get(label)[1]*coeff_y, 0]))

    nodes_and_positions = dict(zip(labels, positions))

    return nodes_and_positions
 
[docs]def make_graph(
    nodes_pos_input, 
    edges_input, 
    undirected=False,     
    radius=0.5, 
    font_size=1,
    node_color=LIGHT_GREY, 
    stroke_color=WHITE, 
    node_label_color=WHITE,
    edge_color=LIGHT_GREY, 
    width=7,     
    edge_label_color=WHITE,   
    label_font_size=0.8,
    label_distance=0.3,
    arrow=False, 
    ):

    """Defines logical relations between 'GraphNode's and creates visual objects.
    See section 'Returns' to better understand the shape of the output.

    Parameters
    ----------

    nodes_pos_input
        Dictionary with node names as keys and positions as values.
        Example: {'a': LEFT, 'b': np.array([-1.6,  0.1,  0. ]), 'c': UP + RIGHT*2} 
    edges_input
        For not weighted graphs: list of edges.              Example: [('a','b'), ('b','c')].
        For weighted graphs: dictionary of edges-weights.    Example: {('a','b'): 2, ('b','c'): 3}.
    undirected
        If True, when the user adds the edge ('a','b'), ('b','a') gets automatically added.
        The weight label gets added only for the first edge.
    
    radius
        Radius of the circle. 
    font_size
        Scaling of the label inside the circle.
    node_color
        Color of the inside of the circle. The opacity is set to be 0.5.
    stroke_color
        Color of the outline of the circle.
    node_label_color
        Color of the label inside the circle.

    edge_color
        Color of the line.
    width
        Width of the line.
    edge_label_color
        Color of the weight label.     
    label_font_size
        Scaling of the label.
    label_distance
        Distance between the line and the weight label.
    arrow
        If True adds am arrow tip at the end of the edge.

    Returns
    -------
    dict
        Dictionary of node keys and 'GraphNode' values, which contain logical properties of the graph (for example list of neighbours)
    dict
        Dictionary of node keys and visual objects values (circle and node label)
    dict
        Dictionary of edge keys and visual objects values (line and weight label)
    VGroup
        Group that contains all the visual objects of the graph (circles, node labels, lines, weight labels).
        Useful to move/scale/animate them together.
   
    Examples
    --------

    .. manim:: MakeGraph

        from ManimGraphLibrary import *

        class MakeGraph(Scene):
            def construct(self):   
                nodes_and_positions = { 'a': LEFT * 4, 
                                        'b': LEFT * 2 + UP * 2, 'c': LEFT * 2 + DOWN * 2,
                                        'd': RIGHT * 2 + UP * 2, 'e': RIGHT * 2 + DOWN * 2,
                                        'f': RIGHT * 4 } 
                edges_input = [('a','b') , ('a','c'), ('b','c'), ('b','d'), ('b','e'), ('c','e'), ('d','e'), ('d','f'), ('e','f')]

                graph_nodes, nodes_view, edges_view, graph = make_graph(nodes_and_positions, edges_input)

                self.play(Create(graph), run_time=2)
                self.wait()

    """

    graph_nodes = {}
    nodes_view = {}
    edges_view = {}
    graph = VGroup()

    for node_label in nodes_pos_input.keys():
        pos = nodes_pos_input[node_label]
        graph_nodes[node_label] = GraphNode(node_label, position=pos, radius=radius, font_size=font_size, 
                                            node_color=node_color, label_color=node_label_color, stroke_color=stroke_color)
        nodes_view[node_label] = graph_nodes[node_label].circle, graph_nodes[node_label].label
        graph.add(*nodes_view[node_label])
    
    if isinstance(edges_input, list):
        for edge in edges_input:
            edges_view[edge] = graph_nodes[edge[0]].connect(graph_nodes[edge[1]], arrow=arrow, edge_color=edge_color, width=width)
            graph.add(edges_view[edge])
            if undirected:
                edges_view[(edge[1], edge[0])] = graph_nodes[edge[1]].connect(graph_nodes[edge[0]], arrow=arrow, edge_color=edge_color, width=width)
                graph.add(edges_view[(edge[1], edge[0])])

    if isinstance(edges_input, dict):
        for edge in edges_input.keys():
            weight=edges_input[edge]
            edges_view[edge] = graph_nodes[edge[0]].connect_weight(graph_nodes[edge[1]], arrow=arrow, edge_color=edge_color, width=width,
                                                    weight=weight, label_color=edge_label_color, label_font_size=label_font_size, label_distance=label_distance)   
            graph.add(*edges_view[edge])                                                                
            if undirected:
                edges_view[(edge[1], edge[0])] = graph_nodes[edge[1]].connect_weight(graph_nodes[edge[0]], arrow=arrow, edge_color=edge_color, width=width,
                                                                                    weight=None)
                graph.add(*edges_view[(edge[1], edge[0])]) 

    return graph_nodes, nodes_view, edges_view, graph

[docs]def highlight_node(
    scene, 
    node_circle, 
    color=RED, 
    width=8,
    run_time=1
    ):   

    """Creates a copy of a given circle, modifies its color and stroke width and animates its creation.

    Parameters
    ----------

    scene
        Canvas of animations, which are played by calling scene.play().
    node_circle
        Circle that gets copied into the object 'highlighted_node'. 
    color
        Color of the outline of the new object.
    width
        Width of the outline.
    run_time
        Duration of the animation.

    Returns
    -------

    Circle
        Copy of 'node_circle' with different color and width of the outline.
        The inside of the circle has opacity 0.

    Examples
    --------

    .. manim:: HighlightNode

        from ManimGraphLibrary import *

        class HighlightNode(Scene):
            def construct(self):  
                nodes_and_positions = { 'a': LEFT * 2, 'b': RIGHT * 2 }
                edges_input = [('a','b')]
                graph_nodes, nodes_view, edges_view, graph = make_graph(nodes_and_positions, edges_input, arrow=True)                
                self.add(graph)

                highlight_node(self, nodes_view['a'][0])
                self.wait()


    """  

    highlighted_node = node_circle.copy()
    highlighted_node.set_stroke(width=width)
    highlighted_node.set_color(color)
    highlighted_node.set_fill(opacity=0)

    scene.play(Create(highlighted_node), run_time=run_time)
    
    return highlighted_node        

[docs]def highlight_edge(
    scene, 
    edge, 
    color=RED, 
    width=7,
    run_time=1
    ):    

    """Creates a copy of a given edge (expected Line or ArcBetweenPoints), modifies its color and stroke width and animates its creation.

    Parameters
    ----------

    scene
        Canvas of animations, which are played by calling scene.play().
    edge
        Object that gets copied into the object 'highlighted_edge'.
    color
        Color of the new object.
    width
        Width of the new object.
    run_time
        Duration of the animation.

    Returns
    -------

    Mobject
        Copy of 'edge' with different color and width.

    Notes
    -----

    If the edge has an arrow tip, modifying the width of the tip can cause problems with the alignment of the new object with the existing one. 
    To solve this, we set the width of the arrow to its original width.

    Examples
    --------

    .. manim:: HighlightEdge

        from ManimGraphLibrary import *

        class HighlightEdge(Scene):
            def construct(self):  
                nodes_and_positions = { 'a': LEFT * 2, 'b': RIGHT * 2 }
                edges_input = [('a','b')]
                graph_nodes, nodes_view, edges_view, graph = make_graph(nodes_and_positions, edges_input, arrow=True)                
                self.add(graph)

                highlight_edge(self, edges_view[('a','b')][0])
                self.wait()

    """

    highlighted_edge = edge.copy()
    highlighted_edge.set_stroke(width=width)
    highlighted_edge.set_color(color)                                            

    if hasattr(edge, 'tip'):
        arrow_width = edge.get_tip().get_width()
        highlighted_edge.get_tip().set_stroke(width = arrow_width)  

    scene.play(Create(highlighted_edge), run_time=run_time)
    
    return highlighted_edge   

[docs]def highlight_path(
    scene, 
    nodes_view, 
    edges_view, 
    path_list, 
    node_color=RED, 
    node_width=8, 
    node_run_time=0.5, 
    edge_color=RED, 
    edge_width=7, 
    edge_run_time=0.5
    ):   

    """Creates and animates a path given a list of edges. Uses functions 'highlight_node' and 'highlight_edge'.

    Parameters
    ----------

    scene
        Canvas of animations, which are played by calling scene.play().
    nodes_view
        Dictionary of node keys and visual objects values (circle and node label)        
    edges_view
        Dictionary of edge keys and visual objects values (line and weight label)
    path_list
        List of edge keys of the path.

    node_color
        Color of the outline of the node of the highlighted path.
    node_width
        Width of the outline of the node of the highlighted path.
    node_run_time
        Duration of the animation.

    edge_color
        Color of the edge of the highlighted path.
    edge_width
        Width of the edge of the highlighted path.
    edge_run_time
        Duration of the animation.


    Returns
    -------

    dict
        Dictionary with node names and edge names as keys and objects as values.

    
    Examples
    --------

    .. manim:: HighlightPath

        from ManimGraphLibrary import *

        class HighlightPath(Scene):
            def construct(self):  
                edges_input = [('a','b'), ('b','c'), ('a','c'), ('c', 'd'), ('a', 'd')]
                nodes_and_positions = node_layout(edges_input, layout = 'planar_layout')
                graph_nodes, nodes_view, edges_view, graph = make_graph(nodes_and_positions, edges_input, undirected=True)
                self.add(graph)

                highlight_path(self, nodes_view, edges_view, [('d','c'), ('c','a'), ('a','b')])
                self.wait()

    .. manim:: BreadthFirstSearch

        from ManimGraphLibrary import *
        from graph_algorithms import bfs

        class BreadthFirstSearch(Scene):
            def construct(self):
                edges_input = [('a','b') , ('a','c'), ('b','c'), ('b','d'), ('b','e'), ('c','e'), ('d','e'), ('d','f'), ('e','f')]
                nodes_and_positions = { 'a': LEFT * 4, 
                                        'b': LEFT * 2 + UP * 2, 'c': LEFT * 2 + DOWN * 2,
                                        'd': RIGHT * 2 + UP * 2, 'e': RIGHT * 2 + DOWN * 2,
                                        'f': RIGHT * 4 } 
                graph_nodes, nodes_view, edges_view, graph = make_graph(nodes_and_positions, edges_input, undirected=True)
                self.add(graph)

                bfs_edges = bfs(graph_nodes, 'a')

                highlight_path(self, nodes_view, edges_view, bfs_edges)

                self.wait()

    """

    highlighted_path_dict={}
    start=path_list[0][0]

    highlighted_node = highlight_node(scene, nodes_view[start][0], color=node_color, width=node_width, run_time=node_run_time)
    highlighted_path_dict[start] = highlighted_node

    for current_edge_key in path_list:
           
        highlighted_edge = highlight_edge(scene, edges_view[current_edge_key][0], color=edge_color, width=edge_width, run_time=edge_run_time)
        highlighted_path_dict[current_edge_key] = highlighted_edge

        second_node = current_edge_key[1]
        highlighted_node = highlight_node(scene, nodes_view[second_node][0], color=node_color, width=node_width, run_time=node_run_time)
        highlighted_path_dict[second_node] = highlighted_node
    	
    return highlighted_path_dict  

[docs]def compute_arc_start_end(
    start_node_circle, 
    end_node_circle, 
    start_angle=PI/3,
    scale_factor=1    
    ):

    """Given two circles, computes start/end points for a curved edge on the radius of the circles.

    Parameters
    ----------

    start_node_circle
        First circle.
    end_node_circle
        Second circle.
    start_angle
        Gives the direction along which we shift the start/end points (relative to the straight line between the circles).
    scale_factor
        Scaling of each circle applied before the computation of start/end points for the curved edge.

    Returns
    -------
    new_start
        First point shifted on the outline of the circle.
    new_end
        Second point shifted on the outline of the circle.

    Notes
    -----

    To compute the direction along which we shift the start/end points first we compute the 'edge_angle' of the straight line between the nodes.
    Then we add the desired 'start_angle' in anticlockwise direction (negative sign). For the end point we consider the PI-complementary angle.

    Examples
    --------

    .. manim:: ComputeArcStartEnd

        from ManimGraphLibrary import *

        class ComputeArcStartEnd(Scene):
            def construct(self):  
                nodes_and_positions = {'a': LEFT * 2, 'b': RIGHT * 2}
                edges_input = {('a','b'): 2}
                graph_nodes, nodes_view, edges_view, graph = make_graph(nodes_and_positions, edges_input, arrow=True)                
                self.add(graph)
                self.remove(edges_view[('a','b')][0], edges_view[('a','b')][1])

                start, end = compute_arc_start_end(nodes_view['a'][0], nodes_view['b'][0])
                p_start = Dot(start, color=RED)
                p_end = Dot(end, color=RED)
                self.play(Create(VGroup(p_start, p_end)))
                self.wait()

                curved_edge = create_curved_edge(start, end, arrow=True, weight=edges_input[('a','b')], arc_color=DARK_GREY, label_color=DARK_GREY)
                self.play(FadeIn(VGroup(*curved_edge)))
                self.wait()

    """

    start = start_node_circle.get_center()
    end = end_node_circle.get_center()

    radius_start = start_node_circle.get_radius()*scale_factor
    radius_end = end_node_circle.get_radius()*scale_factor

    line = Line(start, end)
    edge_direction = line.get_unit_vector()
    edge_angle = acos(edge_direction[0])
    if(edge_direction[1] < 0):
        edge_angle = -edge_angle

    vector_start = np.array([cos(edge_angle-start_angle), sin(edge_angle-start_angle), 0])        
    vector_end = np.array([cos(edge_angle-(PI-start_angle)), sin(edge_angle-(PI-start_angle)), 0])

    direction_start = normalize(vector_start)
    direction_end = normalize(vector_end)        

    new_start = start + direction_start * radius_start
    new_end = end + direction_end * radius_end

    return new_start, new_end

[docs]def create_curved_edge(
    start,
    end,
    arc_angle=PI/3,
    arrow=False,
    backward=False,
    stroke_width=4,
    arc_color=WHITE, 
    arc_b_color=DARK_GREY,
    weight=None, 
    label_font_size=0.8, 
    label_distance=0.3,    
    label_color=WHITE,
    label_b_color=DARK_GREY,
    scale_factor=1
    ):

    """Creates an arc between two points using 'ArcBetweenPoints' and adds a weight label.

    Parameters
    ----------

    start   
        First point.
    end
        Second point.
    arc_angle
        Angle of the arc.
    arrow
        If True, adds an arrow tip.
    backward
        If True use visual properties of backward edges.
    stroke_width
        Width of the arc.    
    arc_color
        Color of the edge.
    arc_b_color
        Color of the backward edge.
    weight
        Weight of the edge.
    label_font_size
        Size of the weight label.
    label_distance
        Distance between the line and the weight label.
    label_color
        Color of the label. 
    label_b_color
        Color of the label of the backward edge. 
    scale_factor
        Scaling of the edge, useful to create the arrow tip in the right scale.
   

    Returns
    -------

    ArcBetweenPoints
        Arc between 'start' and 'end'.
    Text
        Weight label.
    
    Examples
    --------

    .. manim:: CreateCurvedEdge

        from ManimGraphLibrary import *

        class CreateCurvedEdge(Scene):
            def construct(self):  
                nodes_and_positions = { 'a': LEFT * 2, 'b': RIGHT * 2 }
                edges_input = {('a','b'): 2}
                graph_nodes, nodes_view, edges_view, graph = make_graph(nodes_and_positions, edges_input, arrow=True)                
                self.add(graph)
                self.remove(edges_view[('a','b')][0], edges_view[('a','b')][1])

                start, end = compute_arc_start_end(nodes_view['a'][0], nodes_view['b'][0])
                curved_edge = create_curved_edge(start, end, arrow=True, weight=edges_input[('a','b')])
                self.play(Create(VGroup(*curved_edge)))
                self.wait()

    """
 
    arc = ArcBetweenPoints(start, end, arc_angle)    
    arc.set_stroke(width=stroke_width)

    if backward:
        arc.set_color(arc_b_color)
    else:
        arc.set_color(arc_color)
    
    line = Line(start, end)
    edge_direction = line.get_unit_vector()
    orthogonal_dir = np.array([edge_direction[1], -edge_direction[0], 0]) 
    position = arc.get_boundary_point(orthogonal_dir) + orthogonal_dir*len(line)*label_distance

    if weight == None:
        label = Text('')  
    else:
        label = Text(str(weight))
 
    label.move_to(position) 
    label.scale(label_font_size)    

    if arrow:
        arc.add_tip()         
        arc.get_tip().scale(scale_factor)

    if backward:
        label.set_color(color=label_b_color)        
    else:
        label.set_color(color=label_color)

    return arc, label

[docs]def show_backward_edge(
    start_node_circle, 
    end_node_circle, 
    arrow=True, 
    start_angle=PI/6, 
    arc_angle=PI/6, 
    arc_color=WHITE, 
    arc_b_color=DARK_GREY,
    stroke_width=4,
    forward_weight=None, 
    backward_weight=None,
    label_color=WHITE,
    label_b_color=DARK_GREY,
    label_font_size=0.8,
    label_distance=0.3,
    scale_factor=1
    ):    

    """Given two (node) circles as start/end returns forward/backward edges between them.

    Parameters
    ----------
 
    start_node_circle
        Circle of the first node.
    end_node_circle
       Circle of the second node.
    arrow
        If True, adds an arrow tip.
    start_angle
        Gives the direction along which we shift the start/end points (relative to the straight line between the circles).
    arc_angle
        Angle of the arc.
    arc_color
        Color of the arc stroke. 
    arc_b_color
        Color of the backward edge.
    stroke_width
        Width of the arc stroke.
    forward_weight
        Weight of the forward edge.
    backward_weight
        Weight of the backward edge.
    label_color
        Color of the weight label.
    label_b_color
        Color of the label of the backward edge.
    label_font_size
        Scaling of the weight label.
    label_distance
        Distance between the line and the weight label.
    scale_factor
        Scaling of each circle applied before the computation of start/end points for the curved edge. 
     
    Returns
    -------
    tuple
        Forward edge (ArcBetweenPoints, Text)
    tuple
        Backward edge (ArcBetweenPoints, Text)

    Examples
    --------

    .. manim:: ShowBackwardEdge

        from ManimGraphLibrary import *

        class ShowBackwardEdge(Scene):
            def construct(self):
                nodes_and_positions = {'a': LEFT * 2, 'b': RIGHT * 2}
                edges_input = {('a','b'): 2}
                graph_nodes, nodes_view, edges_view, graph = make_graph(nodes_and_positions, edges_input, arrow=True)                
                self.add(graph)
                self.wait()
                forward, backward = show_backward_edge(nodes_view['a'][0], nodes_view['b'][0], forward_weight=2, backward_weight=0)
                self.play(ReplacementTransform(VGroup(edges_view[('a','b')][0], edges_view[('a','b')][1]), VGroup(*forward, *backward)))
                self.wait()

    """    

    start, end = compute_arc_start_end(start_node_circle=start_node_circle, end_node_circle=end_node_circle, start_angle=start_angle, scale_factor=scale_factor)

    forward = create_curved_edge(start, end, arrow=arrow, arc_angle=arc_angle, stroke_width=stroke_width, weight=forward_weight,
                                backward=False, label_color=label_color, arc_color=arc_color, label_font_size=label_font_size, label_distance=label_distance)

    start, end = compute_arc_start_end(start_node_circle=end_node_circle, end_node_circle=start_node_circle, start_angle=start_angle, scale_factor=scale_factor)

    backward = create_curved_edge(start, end, arrow=arrow, arc_angle=arc_angle, stroke_width=stroke_width, weight=backward_weight, 
                                backward=True, label_b_color=label_b_color, arc_b_color=arc_b_color, label_font_size=label_font_size, label_distance=label_distance)                             

    return forward, backward