Tikz graph plot

.gitignore

@@ -1,3 +1,4 @@
 /.vscode/
 /Manifest.toml
 .DS_Store
+_local/

project/vizgadget.jl

@@ -1,38 +1,16 @@
-using UnitDiskMapping, Graphs
+using UnitDiskMapping.TikzGraph, Graphs
+using UnitDiskMapping: crossing_ruleset, Pattern, source_graph, mapped_graph
 
-function command_graph(locs, graph, pins, dx, dy, r, name)
-    cmd = ""
+function command_graph!(canvas, locs, graph, pins, dx, dy, r, name)
     for (i,loc) in enumerate(locs)
         if count(==(loc), locs) == 2
-            type = 2
-        else
-            type = 1
+            Node(loc[1]+dx, loc[2]+dy, fill="none", id="ext-$name$i", minimum_size="$(1.5*r)cm") >> canvas
         end
-        cmd *= command_node(loc[1]+dx, loc[2]+dy, type, i ∈ pins, "$name$i", r) * "\n"
+        Node(loc[1]+dx, loc[2]+dy, fill=i∈pins ? "red" : "black", draw="none", id="$name$i", minimum_size="$(r)cm") >> canvas
     end
     for e in edges(graph)
-        cmd *= command_edge("$name$(e.src)", "$name$(e.dst)") * "\n"
+        Line("$name$(e.src)", "$name$(e.dst)"; line_width=1.0) >> canvas
     end
-    return cmd
-end
-
-function command_node(x, y, type::Int, ispin::Bool, id, r)
-    if type == 2
-        return "\\node[fill=black,circle,radius=$(r)cm,inner sep=0cm, minimum size=$(r)cm] at ($x, $y) () {};\n\\node[draw=black,fill=none,circle,radius=$(1.5*r)cm,minimum size=$(1.5*r)cm,inner sep=0cm] at ($x, $y) ($id) {};"
-    elseif abs(type) == 1
-        if ispin
-            color = "red"
-        else
-            color = "black"
-        end
-        return "\\node[fill=$color,circle,radius=$(r)cm,inner sep=0cm, minimum size=$(r)cm] at ($x, $y) ($id) {};"
-    else
-        error("")
-    end
-end
-
-function command_edge(i, j)
-    return "\\draw[thick] ($i) -- ($j);"
 end
 
 function viz_gadget(p::Pattern)
@@ -45,28 +23,22 @@ function viz_gadget(p::Pattern)
     xmid, ymid = Wx/2-0.5, Wy/2-0.5
     dx1, dy1 = xmid-Gx, 0
     dx2, dy2 = xmid+1, 0
-    source_nodes = command_graph(locs1, g1, pin1, dx1, dy1, 0.3, "s")
-    mapped_nodes = command_graph(locs2, g2, pin2, dx2, dy2, 0.3, "d")
-    return """
-\\documentclass[crop,tikz]{standalone}% 'crop' is the default for v1.0, before it was 'preview'
-\\begin{document}
-\\begin{tikzpicture}[scale=0.8]
-    \\useasboundingbox (-1,-1) rectangle ($Wx,$Wy);
-    \\draw[step=1cm,gray,very thin] ($dx1,$(dy1)) grid ($(Gx+dx1-1),$(Gy+dy1-1));
-    $source_nodes
-    \\draw[step=1cm,gray,very thin] ($dx2,$(dy2)) grid ($(Gx+dx2-1),$(Gy+dy2-1));
-    $mapped_nodes
-    \\node at ($xmid, $ymid) {\$\\mathbf{\\rightarrow}\$};
-\\end{tikzpicture}
-
-\\end{document}
-"""
+    return canvas(; props=Dict("scale"=>"0.8")) do c
+        BoundingBox(-1,Wx-1,-1,Wy-1) >> c
+        Mesh(dx1, Gx+dx1-1, dy1, Gy+dy1-1; step="1cm", draw=rgbcolor!(c, 100,200,200), line_width=0.5) >> c
+        command_graph!(c, locs1, g1, pin1, dx1, dy1, 0.3, "s")
+        Mesh(dx2, Gx+dx2-1, dy2, Gy+dy2-1; step="1cm", draw=rgbcolor!(c, 200,100,100), line_width=0.03) >> c
+        command_graph!(c, locs2, g2, pin2, dx2, dy2, 0.3, "d")
+        PlainText(xmid, ymid, "\$\\mathbf{\\rightarrow}\$") >> c
+    end
 end
 
 function pattern2tikz(folder::String)
-    for (p, sub) in UnitDiskMapping.crossing_ruleset
-        open(joinpath(folder, sub*"-udg.tex"), "w") do f
+    for p in crossing_ruleset
+        open(joinpath(folder, string(typeof(p).name.name)*"-udg.tex"), "w") do f
             write(f, viz_gadget(p))
         end
     end
-end
+end
+
+pattern2tikz(joinpath("_local"))

src/UnitDiskMapping.jl

@@ -12,11 +12,11 @@ export UNode, contract_graph, compress_graph
 
 include("utils.jl")
 include("gadgets.jl")
-include("simplifiers.jl")
 include("mapping.jl")
 include("weighted.jl")
+include("simplifiers.jl")
 include("extracting_results.jl")
 include("pathdecomposition/pathdecomposition.jl")
-#include("shrinking/compressUDG.jl")
+include("tikz/tikz.jl")
 
 end

src/gadgets.jl

@@ -19,20 +19,20 @@ abstract type Pattern end
 """
 abstract type CrossPattern <: Pattern end
 
-abstract type Node end
-struct SimpleNode{T} <: Node
+abstract type AbstractNode end
+struct SimpleNode{T} <: AbstractNode
     x::T
     y::T
 end
 SimpleNode(xy::Tuple{Int,Int}) = SimpleNode(xy...)
 SimpleNode(xy::Vector{Int}) = SimpleNode(xy...)
 getxy(p::SimpleNode) = (p.x, p.y)
 chxy(p::SimpleNode, loc) = SimpleNode(loc...)
-Base.iterate(p::Node, i) = Base.iterate((p.x, p.y), i)
-Base.iterate(p::Node) = Base.iterate((p.x, p.y))
-Base.length(p::Node) = 2
-Base.getindex(p::Node, i::Int) = i==1 ? p.x : (@assert i==2; p.y)
-offset(p::Node, xy) = chxy(p, getxy(p) .+ xy)
+Base.iterate(p::AbstractNode, i) = Base.iterate((p.x, p.y), i)
+Base.iterate(p::AbstractNode) = Base.iterate((p.x, p.y))
+Base.length(p::AbstractNode) = 2
+Base.getindex(p::AbstractNode, i::Int) = i==1 ? p.x : (@assert i==2; p.y)
+offset(p::AbstractNode, xy) = chxy(p, getxy(p) .+ xy)
 
 export source_matrix, mapped_matrix
 function source_matrix(p::Pattern)
@@ -53,7 +53,7 @@ function mapped_matrix(p::Pattern)
     locs2matrix(m, n, locs)
 end
 
-function locs2matrix(m, n, locs::AbstractVector{NT}) where NT <: Node
+function locs2matrix(m, n, locs::AbstractVector{NT}) where NT <: AbstractNode
     a = fill(empty(_cell_type(NT)), m, n)
     for loc in locs
         add_cell!(a, loc)
@@ -386,16 +386,17 @@ for T in [:RotatedGadget, :ReflectedGadget]
     @eval mis_overhead(p::$T) = mis_overhead(p.gadget)
 end
 
-function _apply_transform(r::RotatedGadget, node::Node, center)
-    loc = getxy(node)
+for T in [:RotatedGadget, :ReflectedGadget]
+    @eval _apply_transform(r::$T, node::AbstractNode, center) = chxy(node, _apply_transform(r, getxy(node), center))
+end
+function _apply_transform(r::RotatedGadget, loc::Tuple{Int,Int}, center)
     for _=1:r.n
         loc = rotate90(loc, center)
     end
-    return chxy(node, loc)
+    return loc
 end
 
-function _apply_transform(r::ReflectedGadget, node::Node, center)
-    loc = getxy(node)
+function _apply_transform(r::ReflectedGadget, loc::Tuple{Int,Int}, center)
     loc = if r.mirror == "x"
         reflectx(loc, center)
     elseif r.mirror == "y"
@@ -407,7 +408,7 @@ function _apply_transform(r::ReflectedGadget, node::Node, center)
     else
         throw(ArgumentError("reflection direction $(r.direction) is not defined!"))
     end
-    chxy(node, loc)
+    return loc
 end
 
 export vertex_overhead
@@ -429,3 +430,17 @@ function _boundary_config(pins, config)
     end
     return res
 end
+
+export rotated_and_reflected
+function rotated_and_reflected(p::Pattern)
+    patterns = Pattern[p]
+    source_matrices = [source_matrix(p)]
+    for pi in [[RotatedGadget(p, i) for i=1:3]..., [ReflectedGadget(p, axis) for axis in ["x", "y", "diag", "offdiag"]]...]
+        m = source_matrix(pi)
+        if m ∉ source_matrices
+            push!(patterns, pi)
+            push!(source_matrices, m)
+        end
+    end
+    return patterns
+end

src/mapping.jl

@@ -373,8 +373,10 @@ It can be a vector or one of the following inputs
 
 Returns a `MappingResult` instance.
 """
-map_graph(g::SimpleGraph; vertex_order=Greedy(), ruleset=[RotatedGadget(DanglingLeg(), n) for n=0:3]) = map_graph(UnWeighted(), g; ruleset=ruleset, vertex_order=vertex_order)
-function map_graph(mode, g::SimpleGraph; vertex_order=Greedy(), ruleset=[RotatedGadget(DanglingLeg(), n) for n=0:3])
+function map_graph(g::SimpleGraph; vertex_order=Greedy(), ruleset=default_simplifier_ruleset(UnWeighted()))
+    map_graph(UnWeighted(), g; ruleset=ruleset, vertex_order=vertex_order)
+end
+function map_graph(mode, g::SimpleGraph; vertex_order=Greedy(), ruleset=default_simplifier_ruleset(mode))
     ug = embed_graph(mode, g; vertex_order=vertex_order)
     mis_overhead0 = mis_overhead_copylines(ug)
     ug, tape = apply_crossing_gadgets!(mode, ug)
@@ -385,3 +387,5 @@ function map_graph(mode, g::SimpleGraph; vertex_order=Greedy(), ruleset=[Rotated
 end
 
 map_configs_back(r::MappingResult{<:Cell}, configs::AbstractVector) = unapply_gadgets!(copy(r.grid_graph), r.mapping_history, copy.(configs))[2]
+default_simplifier_ruleset(::UnWeighted) = vcat([rotated_and_reflected(rule) for rule in simplifier_ruleset]...)
+default_simplifier_ruleset(::Weighted) = weighted.(default_simplifier_ruleset(UnWeighted()))

src/simplifiers.jl

@@ -26,47 +26,57 @@ function vertices_on_boundary(locs, m, n)
     findall(loc->loc[1]==1 || loc[1]==m || loc[2]==1 || loc[2]==n, locs)
 end
 
-struct GridGraph{NT<:Node}
+struct GridGraph{NT<:AbstractNode}
     size::Tuple{Int,Int}
     nodes::Vector{NT}
 end
 vertices_on_boundary(gg::GridGraph) = vertices_on_boundary(gg.nodes, gg.size...)
 
-function gridgraphfromstring(str::String)
-    item_array = Vector{Bool}[]
+function gridgraphfromstring(mode::Union{Weighted, UnWeighted}, str::String)
+    item_array = Vector{Int}[]
     for line in split(str, "\n")
-        list = [item ∈ ("o", "●") ? true : (@assert item ∈ (".", "⋅"); false) for item in split(line, " ") if !isempty(item)]
+        items = [item for item in split(line, " ") if !isempty(item)]
+        list = if mode isa Weighted   # TODO: the weighted version need to be tested! Consider removing it!
+            @assert all(item->item ∈ (".", "⋅", "@", "●", "o", "◯"), items)
+            [item ∈ ("@", "●") ? 2 : (item ∈ ("o", "◯") ? 1 : 0) for item in items]
+        else
+            @assert all(item->item ∈ (".", "⋅", "@", "●"), items)
+            [item ∈ ("@", "●") ? 1 : 0 for item in items]
+        end
         if !isempty(list)
             push!(item_array, list)
         end
     end
     @assert all(==(length(item_array[1])), length.(item_array))
     mat = hcat(item_array...)'
-    locs = [SimpleNode(ci.I) for ci in findall(mat)]
+    locs = [_to_node(mode, ci.I, mat[ci]) for ci in findall(!iszero, mat)]
     return GridGraph(size(mat), locs)
 end
+_to_node(::UnWeighted, loc::Tuple{Int,Int}, w::Int) = SimpleNode(loc...)
+_to_node(::Weighted, loc::Tuple{Int,Int}, w::Int) = WeightedNode(loc..., w)
 
-const simplifier_ruleset = SimplifyPattern[]
-
-macro gg(expr)
+function gg_func(mode, expr)
     @assert expr.head == :(=)
     name = expr.args[1]
     pair = expr.args[2]
     @assert pair.head == :(call) && pair.args[1] == :(=>)
-    g1 = gridgraphfromstring(pair.args[2])
-    g2 = gridgraphfromstring(pair.args[3])
+    g1 = gridgraphfromstring(mode, pair.args[2])
+    g2 = gridgraphfromstring(mode, pair.args[3])
     @assert g1.size == g2.size
     @assert g1.nodes[vertices_on_boundary(g1)] == g2.nodes[vertices_on_boundary(g2)]
     return quote
         struct $(esc(name)) <: SimplifyPattern end
         Base.size(::$(esc(name))) = $(g1.size)
         $UnitDiskMapping.source_locations(::$(esc(name))) = $(g1.nodes)
         $UnitDiskMapping.mapped_locations(::$(esc(name))) = $(g2.nodes)
-        push!($(simplifier_ruleset), $(esc(name))())
         $(esc(name))
     end
 end
 
+macro gg(expr)
+    gg_func(UnWeighted(), expr)
+end
+
 # # How to add a new simplification rule
 # 1. specify a gadget like the following. Use either `o` and `●` to specify a vertex,
 # either `.` or `⋅` to specify a placeholder.
@@ -83,5 +93,11 @@ end
     ⋅ ● ⋅
     """
 
-# 2. run the script `project/createmap` to generate `mis_overhead` and other informations required
+# 2. add your gadget to simplifier ruleset.
+const simplifier_ruleset = SimplifyPattern[DanglingLeg()]
+# set centers (vertices with weight 1) for the weighted version
+source_centers(::WeightedGadget{DanglingLeg}) = [(2,2)]
+mapped_centers(::WeightedGadget{DanglingLeg}) = [(4,2)]
+
+# 3. run the script `project/createmap` to generate `mis_overhead` and other informations required
 # for mapping back. (Note: will overwrite the source file `src/extracting_results.jl`)