Update with demo

Author: codejaeger

examples/graph_animations/demo.jl

@@ -0,0 +1,38 @@
+using Javis
+
+function edge(; p1, p2, kwargs...)
+    sethue("black")
+    line(p1, p2, :stroke)
+end
+
+function node(p=O, color="black")
+    sethue(color)
+    circle(p, 10, :fill)
+    return p
+end
+
+function ground(args...) 
+    background("white")
+    sethue("black")
+end
+
+video = Video(400, 400)
+Background(1:150, ground)
+
+g = @Object 1:150 JGraph(true, 100, 100) O
+
+adjacency_list = [[2, 3, 4, 5, 6],
+                  [7, 8],
+                  [7, 8],
+                  [],[],[],[],[]]
+for i in 1:length(adjacency_list)
+    @Graph g i*10:150 GraphVertex(i, (args...; kwargs...)->node()) O
+end
+
+for i in 1:length(adjacency_list)
+    for j in adjacency_list[i]
+        @Graph g 10+i*15:150 GraphEdge(i, j, (args...; kwargs...)->edge(; kwargs...)) O
+    end
+end
+
+render(video; pathname="demo.gif")

examples/graph_animations/example0.md

@@ -24,6 +24,7 @@ The demo serves to list the features that I am going to implement for graph anim
 
 ### Examples
 
+0. [Demo](demo.jl)
 1. [Graph Traversal](example1.md)
 2. [Depth First Search](example2.md)
 2. [Shortest Path](example3.md)

src/Javis.jl

@@ -371,7 +371,12 @@ function draw_object(object, video, frame, origin_matrix)
     cs = get_current_setting()
     !cs.show_object && return
 
-    res = object.func(video, object, frame; collect(object.change_keywords)...)
+    if object.meta !== nothing && :opts in fieldnames(typeof(object.meta))
+        res = object.func(video, object, frame; collect(object.change_keywords)..., collect(object.meta.opts)...)
+    else
+        res = object.func(video, object, frame; collect(object.change_keywords)...)
+    end
+
     current_global_matrix = cairotojuliamatrix(getmatrix())
     # obtain current matrix without the initial matrix part
     current_matrix = inv(origin_matrix) * current_global_matrix

src/structs/GraphEdge.jl

@@ -25,9 +25,9 @@ render(video; pathname="graph_node.gif")
 struct GraphEdge
     from_node::Int
     to_node::Int
-    draw::Function
     animate_on::Symbol
     property_style_map::Dict{Any,Symbol}
+    opts::Dict{Symbol, Any}
 end
 
 """
@@ -53,11 +53,29 @@ Create a graph edge with additional drawing function and options.
         - `:weights`: only possible for weighted graphs i.e. `SimpleWeightedGraphs`.
 - `properties_to_style_map::Dict{Any,Symbol}`: A mapping to of how edge attributes map to edge drawing styles.
 """
+GraphEdge(from_node::Int, to_node::Int, draw::Union{Vector{Function}, Function}; kwargs...) =
+    GraphEdge(CURRENT_GRAPH[1], from_node, to_node, draw; kwargs...)
+
+GraphEdge(graph::AbstractObject, from_node::Int, to_node::Int, draw::Vector{Function}; kwargs...) =
+    GraphEdge(graph, from_node, to_node, compile_draw_funcs(draw); kwargs...)
+
 function GraphEdge(
     graph::AbstractObject,
     from_node::Int,
     to_node::Int,
     draw::Function;
     animate_on::Symbol = :opacity,
-    property_style_map::Dict{Any,Symbol} = Dict(),
-) end
+    property_style_map::Dict{Any,Symbol} = Dict{Any,Symbol}(),
+)
+    g = graph.meta
+    if !(typeof(g) <: JGraph)
+        throw(ErrorException("Cannot define edge since $(typeof(graph)) is not a `JGraph`"))
+    end
+    if get_prop(g.adjacency_list, from_node, to_node) !== nothing
+        @warn "Edge $(from_node)=>$(to_node) is already created on canvas. Recreating it will leave orphan edges in the animation. To undo, call `rem_edge!`"
+    end
+    add_edge!(g.adjacency_list.graph, from_node, to_node)
+    set_prop!(g.adjacency_list, from_node, to_node, length(g.ordering)+1)
+    graph_edge = GraphEdge(from_node, to_node, animate_on, property_style_map, Dict{Symbol, Any}())
+    return draw, graph_edge
+end

src/structs/GraphVertex.jl

@@ -25,6 +25,7 @@ struct GraphVertex
     node::Int
     animate_on::Symbol
     property_style_map::Dict{Any,Symbol}
+    opts::Dict{Symbol, Any}
 end
 
 """
@@ -56,7 +57,7 @@ GraphVertex(node::Int, draw::Union{Vector{Function}, Function}; kwargs...) =
     GraphVertex(CURRENT_GRAPH[1], node, draw; kwargs...)
 
 GraphVertex(graph::AbstractObject, node::Int, draw::Vector{Function}; kwargs...) =
-    GraphVertex(graph::AbstractObject, node::Int, compile_draw_funcs(draw); kwargs...)
+    GraphVertex(graph, node, compile_draw_funcs(draw); kwargs...)
 
 function GraphVertex(
     graph::AbstractObject,
@@ -71,7 +72,7 @@ function GraphVertex(
     end
     if g.mode == :static
         if get_prop(g.adjacency_list, node) !== nothing
-            @warn "Node $(node) is already created on canvas. Recreating it will leave orphan node objects in the animation. To undo, call `rem_edge!`"
+            @warn "Node $(node) is already created on canvas. Recreating it will leave orphan node objects in the animation. To undo, call `rem_node!`"
         end
         if g.layout != :none
             draw_fn = (args...; position=O, kwargs...) -> begin Luxor.translate(position); draw(args...; position=position, kwargs...) end
@@ -80,7 +81,7 @@ function GraphVertex(
         end
         add_vertex!(g.adjacency_list.graph)
         set_prop!(g.adjacency_list, nv(g.adjacency_list), length(g.ordering)+1)
-        graph_vertex = GraphVertex(node, animate_on, property_style_map)
+        graph_vertex = GraphVertex(node, animate_on, property_style_map, Dict{Symbol, Any}())
         return draw_fn, graph_vertex
     elseif g.mode == :dynamic
     end

src/structs/JGraph.jl

@@ -166,36 +166,43 @@ function _global_property_limits(video, object, frames; kwargs...)
 end
 
 function _global_layout(video, object, frame; kwargs...)
-    if frame != 1
-        return
-    end
     g = object.meta
-    layout_x = []
-    layout_y = []
-    if g.layout == :none
-        return
-    elseif g.layout == :spring
-        # Check due to some errors in calling spring_layout with an empty graph
-        if nv(g.adjacency_list.graph) > 0
-            layout_x, layout_y = spring_layout(g.adjacency_list.graph)
-        end
-    elseif g.layout == :spectral
-        # Check special property layout_weight is defined on edges and collect weights
-        edge_ordering_positions = edge_props(g.adjacency_list.graph)
-        weights = map(
-            (idx) -> get(g.ordering[idx].change_keywords, :layout_weight, 1),
-            edge_ordering_positions,
-        )
-        if nv(g.adjacency_list.graph) > 0
-            layout_x, layout_y = spectral_layout(g.adjacency_list, weights)
+    if frame == first(get_frames(object))
+        layout_x = []
+        layout_y = []
+        if g.layout == :none
+            return
+        elseif g.layout == :spring
+            # Check due to some errors in calling spring_layout with an empty graph
+            if nv(g.adjacency_list.graph) > 0
+                layout_x, layout_y = spring_layout(g.adjacency_list.graph)
+            end
+        elseif g.layout == :spectral
+            # Check special property layout_weight is defined on edges and collect weights
+            edge_ordering_positions = edge_props(g.adjacency_list.graph)
+            weights = map(
+                (idx) -> get(g.ordering[idx].change_keywords, :layout_weight, 1),
+                edge_ordering_positions,
+            )
+            if nv(g.adjacency_list.graph) > 0
+                layout_x, layout_y = spectral_layout(g.adjacency_list, weights)
+            end
         end
+        # Normalize coordinates between -0.5 and 0.5
+        coords = map((p) -> Point(p), collect(zip(layout_x, layout_y))) .- [(0.5, 0.5)]
+        # Scale to graph dimensions
+        coords = coords .* [(g.width, g.height)]
+        object.opts[:layout] = coords
     end
-    # Normalize coordinates between -0.5 and 0.5
-    coords = map((p) -> Point(p), collect(zip(layout_x, layout_y))) .- [(0.5, 0.5)]
-    # Scale to graph dimensions
-    coords = coords .* [(g.width, g.height)]
     # Now assign positions back to all nodes
     for (idx, p) in enumerate(node_props(g.adjacency_list))
-        g.ordering[p].change_keywords[:position] = coords[idx]
+        g.ordering[p].meta.opts[:position] = object.opts[:layout][idx]
+    end
+    # Define keyword arguments for edges defining endpoint position
+    for (_, p) in enumerate(edge_props(g.adjacency_list))
+        from_node = get_prop(g.adjacency_list, g.ordering[p].meta.from_node)
+        to_node = get_prop(g.adjacency_list, g.ordering[p].meta.to_node)
+        g.ordering[p].meta.opts[:p1] = g.ordering[from_node].meta.opts[:position]
+        g.ordering[p].meta.opts[:p2] = g.ordering[to_node].meta.opts[:position]
     end
 end

src/structs/Object.jl

@@ -133,7 +133,8 @@ macro Graph(g, frames, node, start_pos, kwargs...)
     object_kwargs = [esc(i) for i in kwargs]
     return quote
         CURRENT_GRAPH[1]=$(esc(g))
-        push!(CURRENT_GRAPH[1].meta.ordering, Object($frames, $(esc(node))..., $start_pos; $(object_kwargs...)))[length(CURRENT_GRAPH[1].meta.ordering)]
+        _frames=$(esc(frames))
+        push!(CURRENT_GRAPH[1].meta.ordering, Object(_frames, $(esc(node))..., $start_pos; $(object_kwargs...)))[length(CURRENT_GRAPH[1].meta.ordering)]
     end
 end
 

src/structs/WeightedGraph.jl

@@ -127,5 +127,5 @@ end
     edge_props(wg::WeightedGraph)
 """
 function edge_props(wg::WeightedGraph)
-    map((e) -> wg.edge_w[Tuple(e)], edges(wg))
+    map((e) -> wg.edge_w[Pair(e)], edges(wg))
 end