struct and plotting recipie for embedded hubbard trees

Author: jeffwack

parameters/DynamicPlane.jl

@@ -2,7 +2,20 @@ include("OrientTrees.jl")
 include("../spiders/Spiders.jl")
 include("../parameters/DynamicRays.jl")
 
-function embednodes(OHT::OrientedHubbardTree)
+struct EmbeddedHubbardTree
+    zero::Sequence
+    adj::Dict{Sequence,Vector{Sequence}}
+    boundary::Vector{Sequence}
+    onezero::Dict{Sequence{Char}, Char}
+    angle::Rational
+    rays::Dict{Rational,Vector{ComplexF64}}
+    parameter::ComplexF64
+    vertices::Dict{Sequence, ComplexF64} #maps each vertex in the tree to a point in the plane
+    edges::Dict{Set{Sequence{Char}}, Tuple{Sequence{Char}, Vector{ComplexF64}}} #maps each edge to an oriented polyline
+end
+
+function EmbeddedHubbardTree(OHT::OrientedHubbardTree)
+
     OZ = labelonezero(OHT)
     anglelist = allanglesof(OZ,OHT)
 
@@ -50,24 +63,27 @@ function embednodes(OHT::OrientedHubbardTree)
         end
     end
 
-    return zvalues
+    E = standardedges(OHT.adj,OHT.zero,zvalues)
+    return EmbeddedHubbardTree(OHT.zero,OHT.adj,OHT.boundary,OZ,theta,rays,c,zvalues,E)
 end
 
-function standardedges(OHT::OrientedHubbardTree,zvalues)
-    edges = edgeset(OHT.adj)
+function standardedges(adj,zero,zvalues)
+    edges = edgeset(adj)
 
     edgevectors = []
     for edge in edges
-        start = first(filter(z -> z!= OHT.zero,edge))
+        start = first(filter(z -> z!= zero,edge))
         finish = first(filter(z -> z!= start,edge))
         push!(edgevectors,Pair(edge,(start,[zvalues[start],zvalues[finish]])))
     end
     return Dict(edgevectors)
 end
 
-function longpath(OHT, edgevectors, start, finish)
-    nodes = nodepath(OHT.adj, start, finish)
-    edges = edgepath(OHT.adj, start, finish)
+function longpath(EHT, start, finish)
+    nodes = nodepath(EHT.adj, start, finish)
+    edges = edgepath(EHT.adj, start, finish)
+
+    edgevectors = EHT.edges
 
     segments = [edgevectors[edge][2] for edge in edges]
 
@@ -107,29 +123,31 @@ function refinedtree(OHT,zvalues,steps)
     return E
 end
 
-function refinetree(OHT,c,edgevectors)
+function refinetree!(EHT::EmbeddedHubbardTree)
+
     newedges = []
-    for edge in keys(edgevectors)
-        start = edgevectors[edge][1]
+    for edge in keys(EHT.edges)
+        start = EHT.edges[edge][1]
         finish = first(filter(x->x!=start,edge))
         #determine the image of this edge
-        image = longpath(OHT,edgevectors,shift(start),shift(finish))
+        image = longpath(EHT,shift(start),shift(finish))
 
         refinedimage = [image[1]]
         for point in image[2:end]
             push!(refinedimage, (refinedimage[end]+point)/2)
             push!(refinedimage,point)
         end
 
+        c = EHT.parameter
         x = sqrt(-c + refinedimage[1])
 
-        if abs2(x-edgevectors[edge][2][1]) < abs2(-x-edgevectors[edge][2][1])
-            push!(newedges,Pair(edge,(start,path_sqrt(-c .+ refinedimage))))
+        if abs2(x-EHT.edges[edge][2][1]) < abs2(-x-EHT.edges[edge][2][1])
+            EHT.edges[edge] = (start,path_sqrt(-c .+ refinedimage))
         else
-            push!(newedges,Pair(edge,(start,-path_sqrt(-c .+ refinedimage))))
+            EHT.edges[edge] = (start,-path_sqrt(-c .+ refinedimage))
         end
     end
-    return Dict(newedges)
+    return EHT
 end
 
 function plotedges!(scene,edgevectors)

trees/EmbedTrees.jl

@@ -1,56 +1,37 @@
 using GLMakie
-include("HubbardTrees.jl")
-include("OrientTrees.jl")
 include("EmbedTrees.jl")
 include("../spiders/Spiders.jl")
 include("../parameters/DynamicRays.jl")
+include("../parameters/RenderFractal.jl")
 
-### Convenience functions
-function plottree!(scene,angle::Rational)
-    return plottree!(scene,OrientedHubbardTree(angle))
+@recipe(TreePlot,EHT) do scene #TODO add kwargs to toggle plotting the julia set and the external rays
+    Theme()
 end
 
-function plottree!(scene,K::Sequence)
-    return plottree!(scene,HubbardTree(K))
-end
-
-function plottree(H)
-    fig = Figure()
-    ax = Axis(fig[1,1])
-    return (fig,plottree!(ax,H))
-end
-###
-
-
-function plottree!(scene, OHT::OrientedHubbardTree,steps = 8,colors = [])
-    OZ = labelonezero(OHT)
+function Makie.plot!(myplot::TreePlot)
+    (EdgeList,Nodes) = adjlist(EHT.adj)
+    criticalorbit = orbit(EHT.zero)
 
-    anglelist = allanglesof(OZ,OHT)
-
-    (EdgeList,Nodes) = adjlist(OHT.adj)
-
-    criticalorbit = orbit(OHT.zero)
-    
     labels = []
     nodecolors = []
     for node in Nodes
         firstchar = node.items[1]
         if firstchar == '*'
             push!(nodecolors,"black")
         elseif firstchar == 'A' #we are fully in one of the 4 regions
-            if OZ[node] == '0'
+            if EHT.onezero[node] == '0'
                 push!(nodecolors,"blue")
-            elseif OZ[node] == '*'
+            elseif EHT.onezero[node] == '*'
                 push!(nodecolors,"turquoise")
-            elseif OZ[node] == '1'
+            elseif EHT.onezero[node] == '1'
                 push!(nodecolors,"green")
             end
         elseif firstchar == 'B'
-            if OZ[node] == '0'
+            if EHT.onezero[node] == '0'
                 push!(nodecolors,"red")
-            elseif OZ[node] == '*'
+            elseif EHT.onezero[node] == '*'
                 push!(nodecolors,"orangered2")
-            elseif OZ[node] == '1'
+            elseif EHT.onezero[node] == '1'
                 push!(nodecolors,"orange")
             end
         end
@@ -65,22 +46,16 @@ function plottree!(scene, OHT::OrientedHubbardTree,steps = 8,colors = [])
         end
     end
 
-    zvaluedict = embednodes(OHT)
-    zvalues = []
-    for node in Nodes
-        push!(zvalues,zvaluedict[node])
-    end
+    zvalues = [EHT.vertices[node] for node in Nodes]
 
-    E = refinedtree(OHT,zvaluedict,steps)
-
-    pos = Point.(real.(zvalues)/2,imag.(zvalues)/2) #divide by 2 here for the scene coordinate system
+    pos = Point.(real.(zvalues),imag.(zvalues)) 
 
     colorsforinterior = ["red","blue","green","orange"]
 
     for (ii,p) in enumerate(EdgeList)
         for n in p
-            cmplxedge = E[Set([Nodes[ii],Nodes[n]])][2]
-            realedge = Point.(real.(cmplxedge)/2,imag.(cmplxedge)/2) 
+            cmplxedge = EHT.edges[Set([Nodes[ii],Nodes[n]])][2]
+            realedge = Point.(real.(cmplxedge),imag.(cmplxedge)) 
             if nodecolors[ii] in colorsforinterior 
                 col = nodecolors[ii]
             elseif nodecolors[n] in colorsforinterior
@@ -90,17 +65,28 @@ function plottree!(scene, OHT::OrientedHubbardTree,steps = 8,colors = [])
             elseif nodecolors[n] !== "black" 
                 col = nodecolors[n]
             end
-            lines!(scene,realedge,color = col,linewidth = 1,transparency = true,overdraw = true)
+            lines!(myplot,realedge,color = col,linewidth = 1,transparency = true,overdraw = true)
         end
     end
 
-    scatter!(scene,pos,color = nodecolors)
+    julia = inverseiterate(EHT.parameter,20)
+    scatter!(myplot,real(julia),imag(julia),markersize = 1,color = "black")
+
+
+    rays = collect(values(EHT.rays))
+    n = length(rays)
+    for (j ,ray) in enumerate(rays)
+        lines!(myplot,real(ray),imag(ray),color = get(ColorSchemes.rainbow, float(j)/float(n)))
+    end
+
+    scatter!(myplot,pos,color = nodecolors)
     tex = [node[2] for node in labels]
-    text!(scene,pos,text = tex)
-    
-    return scene
+    text!(myplot,pos,text = tex)
+    limits!(-2,2,-2,2)
+    return myplot
 end
 
+
 function plottree!(scene, H::HubbardTree)
 
     (E, nodes) = adjlist(H.adj)