Feature/lightdfg (#85)

* Factor Graphs using LightGraphs and Dict bidirectional maps

* LighDFG with FactorGraphs BiDict

Author: Affie

src/DistributedFactorGraphs.jl

@@ -50,6 +50,8 @@ include("LightGraphsDFG/LightGraphsDFG.jl")
 include("SymbolDFG/SymbolDFG.jl")
 @reexport using .SymbolDFGs
 
+include("LightDFG/LightDFG.jl")
+@reexport using .LightDFGs
 
 export saveDFG, loadDFG
 
@@ -62,7 +64,7 @@ function __init__()
             Rows are all factors, columns are all variables, and each cell contains either nothing or the symbol of the relating factor.
             The first column is the factor headings.
             """
-            function getAdjacencyMatrixDataFrame(dfg::Union{GraphsDFG, LightGraphsDFG, SymbolDFG})::Main.DataFrames.DataFrame
+            function getAdjacencyMatrixDataFrame(dfg::Union{GraphsDFG, LightGraphsDFG, SymbolDFG, LightDFG})::Main.DataFrames.DataFrame
                 varLabels = sort(map(v->v.label, getVariables(dfg)))
                 factLabels = sort(map(f->f.label, getFactors(dfg)))
                 adjDf = DataFrames.DataFrame(:Factor => Union{Missing, Symbol}[])

src/LightDFG/FactorGraphs/BiMaps.jl

@@ -0,0 +1,53 @@
+# import Base: getindex, setindex!, firstindex, lastindex, iterate, keys, isempty
+struct BiDictMap{T <: Integer}
+    int_sym::Dict{T,Symbol}
+    sym_int::Dict{Symbol,T}
+end
+
+BiDictMap{T}(;sizehint=100) where T<:Integer = begin
+    int_sym = Dict{T,Symbol}()
+    sizehint!(int_sym, sizehint)
+    sym_int = Dict{Symbol,T}()
+    sizehint!(sym_int, sizehint)
+    BiDictMap{T}(int_sym, sym_int)
+end
+
+BiDictMap(;sizehint=100) = BiDictMap{Int}(;sizehint=sizehint)
+
+
+Base.getindex(b::BiDictMap, key::Int) = b.int_sym[key]
+Base.getindex(b::BiDictMap, key::Symbol) = b.sym_int[key]
+
+# setindex!(b, value, key) = b[key] = value
+function Base.setindex!(b::BiDictMap, s::Symbol, i::Int)
+    haskey(b.sym_int, s) && delete!(b.int_sym, b[s])
+    haskey(b.int_sym, i) && delete!(b.sym_int, b[i])
+
+    b.int_sym[i] = s
+    b.sym_int[s] = i
+end
+
+function Base.setindex!(b::BiDictMap, i::Int, s::Symbol)
+    haskey(b.int_sym, i) && delete!(b.sym_int, b[i])
+    haskey(b.sym_int, s) && delete!(b.int_sym, b[s])
+
+    b.int_sym[i] = s
+    b.sym_int[s] = i
+end
+
+function Base.delete!(b::BiDictMap, i::Int)
+    s = b[i]
+    delete!(b.int_sym, i)
+    delete!(b.sym_int, s)
+    return b
+end
+
+Base.haskey(b::BiDictMap, s::Symbol) = haskey(b.sym_int, s)
+Base.haskey(b::BiDictMap, i::Int) = haskey(b.int_sym, i)
+
+
+Base.firstindex(v::BiDictMap) = 1
+Base.lastindex(v::BiDictMap) = length(v.int_sym)
+Base.iterate(v::BiDictMap, i=1) = (length(v.int_sym) < i ? nothing : (v.int_sym[i], i + 1))
+Base.keys(v::BiDictMap) = Base.OneTo(length(v.int_sym))
+Base.isempty(v::BiDictMap) = (length(v.int_sym) == 0)

src/LightDFG/FactorGraphs/FactorGraphs.jl

@@ -0,0 +1,165 @@
+module FactorGraphs
+using LightGraphs
+
+import Base:
+    eltype, show, ==, Pair,
+    Tuple, copy, length, size,
+    issubset, zero, getindex
+# import Random:
+#     randstring, seed!
+
+import LightGraphs:
+    AbstractGraph, src, dst, edgetype, nv,
+    ne, vertices, edges, is_directed,
+    add_vertex!, add_edge!, rem_vertex!, rem_edge!,
+    has_vertex, has_edge, inneighbors, outneighbors,
+    weights, indegree, outdegree, degree,
+    induced_subgraph,
+    loadgraph, savegraph, AbstractGraphFormat,
+    reverse
+
+import LightGraphs.SimpleGraphs:
+    AbstractSimpleGraph, SimpleGraph, SimpleDiGraph,
+    SimpleEdge, fadj, badj
+
+export
+    FactorGraph,
+    # addVariable!,
+    # addFactor!,
+    LightBayesGraph,
+    filter_edges,
+    filter_vertices,
+    reverse
+
+import DistributedFactorGraphs: DFGNode
+const AbstractNodeType = DFGNode
+
+include("BiMaps.jl")
+
+struct FactorGraph{T <: Integer,V <: AbstractNodeType, F <: AbstractNodeType} <: AbstractGraph{T}
+    graph::SimpleGraph{T}
+    labels::BiDictMap{T}
+    variables::Dict{Symbol,V}
+    factors::Dict{Symbol,F}
+end
+
+function FactorGraph{T, V, F}(nv::Int=100, nf::Int=100) where {T <: Integer, V <: AbstractNodeType, F <: AbstractNodeType}
+    fadjlist = Vector{Vector{T}}()
+        sizehint!(fadjlist, nv + nf)
+    g = SimpleGraph{T}(0, fadjlist)
+    labels = BiDictMap{T}(sizehint=nv+nf)
+    variables = Dict{Symbol,V}()
+        sizehint!(variables, nv)
+    factors = Dict{Symbol,F}()
+        sizehint!(factors, nf)
+    return FactorGraph{T, V, F}(g, labels, variables, factors)
+end
+
+# fg = FactorGraph{Int, AbstractNodeType, AbstractNodeType}()
+
+FactorGraph() = FactorGraph{Int, AbstractNodeType, AbstractNodeType}()
+FactorGraph{V,F}() where {V <: AbstractNodeType, F <: AbstractNodeType} = FactorGraph{Int, V, F}()
+
+
+function show(io::IO, g::FactorGraph)
+    dir = is_directed(g) ? "directed" : "undirected"
+    print(io, "{$(nv(g)), $(ne(g))} $dir $(eltype(g)) $(typeof(g))")
+end
+
+@inline fadj(g::FactorGraph, x...) = fadj(g.graph, x...)
+@inline badj(g::FactorGraph, x...) = badj(g.graph, x...)
+
+
+eltype(g::FactorGraph) = eltype(g.graph)
+edgetype(g::FactorGraph) = edgetype(g.graph)
+nv(g::FactorGraph) = nv(g.graph)
+vertices(g::FactorGraph) = vertices(g.graph)
+
+ne(g::FactorGraph) = ne(g.graph)
+edges(g::FactorGraph) = edges(g.graph)
+
+has_vertex(g::FactorGraph, x...) = has_vertex(g.graph, x...)
+@inline has_edge(g::FactorGraph, x...) = has_edge(g.graph, x...)
+
+inneighbors(g::FactorGraph, v::Integer) = inneighbors(g.graph, v)
+outneighbors(g::FactorGraph, v::Integer) = fadj(g.graph, v)
+
+is_directed(::Type{FactorGraph}) = false
+is_directed(::Type{FactorGraph{T,V,F}}) where {T,V,F} = false
+is_directed(g::FactorGraph) = false
+
+zero(g::FactorGraph{T,V,F}) where {T,V,F} = FactorGraph{T,V,F}(0,0)
+
+# TODO issubset(g::T, h::T) where T <: FactorGraph = issubset(g.graph, h.graph)
+
+"""
+    add_edge!(g, u, v)
+    Add an edge `(u, v)` to FactorGraph `g`.
+    return true if the edge has been added, false otherwise
+"""
+@inline add_edge!(g::FactorGraph, x...) = add_edge!(g.graph, x...)
+
+@inline rem_edge!(g::FactorGraph, x...) = rem_edge!(g.graph, x...)
+
+
+function addVariable!(g::FactorGraph{T, V, F}, variable::V) where {T, V, F}
+
+    label = variable.label
+
+    haskey(g.labels, label) && (@error "Label already in fg"; return false) #TODO debug error or exception?
+
+    add_vertex!(g.graph) || return false
+
+    g.labels[nv(g.graph)] = label
+
+    push!(g.variables, label=>variable)
+
+    return true
+end
+
+function addFactor!(g::FactorGraph{T, V, F}, variableLabels::Vector{Symbol}, factor::F)::Bool where {T, V, F}
+
+    haskey(g.labels, factor.label) && (@error "Label $(factor.label) already in fg"; return false)
+
+    for vlabel in variableLabels
+        !haskey(g.labels, vlabel) && (@error "Variable '$(vlabel)' not found in graph when creating Factor '$(factor.label)'"; return false) #TODO debug error or exception?
+    end
+
+    add_vertex!(g.graph) || return false
+
+    g.labels[nv(g.graph)] = factor.label
+
+    push!(g.factors, factor.label=>factor)
+
+    # add the edges
+    for vlabel in variableLabels
+        add_edge!(g, g.labels[vlabel], nv(g.graph)) || return false
+    end
+
+    return true
+end
+
+
+
+function rem_vertex!(g::FactorGraph{T,V,F}, v::Integer) where {T,V,F}
+    v in vertices(g) || return false
+    lastv = nv(g)
+
+    rem_vertex!(g.graph, v) || return false
+
+    label = g.labels[v]
+    delete!(g.variables, label)
+    delete!(g.factors, label)
+
+    if v != lastv
+        g.labels[v] = g.labels[lastv] #lastSym
+    else
+        delete!(g.labels, v)
+    end
+
+    return true
+end
+
+
+
+end

src/LightDFG/LightDFG.jl

@@ -0,0 +1,66 @@
+module LightDFGs
+
+using LightGraphs
+using DocStringExtensions
+
+import ...DistributedFactorGraphs: AbstractDFG, DFGNode, AbstractParams, NoSolverParams, DFGVariable, DFGFactor
+
+# import DFG functions to exstend
+import ...DistributedFactorGraphs:  setSolverParams,
+                                    getInnerGraph,
+                                    getFactor,
+                                    setDescription,
+                                    getLabelDict,
+                                    addVariable!,
+                                    getVariable,
+                                    getAddHistory,
+                                    addFactor!,
+                                    getSolverParams,
+                                    exists,
+                                    getDescription,
+                                    updateVariable!,
+                                    updateFactor!,
+                                    deleteVariable!,
+                                    deleteFactor!,
+                                    getVariables,
+                                    getVariableIds,
+                                    ls,
+                                    getFactors,
+                                    getFactorIds,
+                                    lsf,
+                                    isFullyConnected,
+                                    hasOrphans,
+                                    getNeighbors,
+                                    getSubgraphAroundNode,
+                                    getSubgraph,
+                                    getAdjacencyMatrix
+
+include("FactorGraphs/FactorGraphs.jl")
+using .FactorGraphs
+
+# export SymbolEdge, is_directed, has_edge
+# Imports
+include("entities/LightDFG.jl")
+include("services/LightDFG.jl")
+
+# Exports
+export LightDFG
+
+export exists
+export getLabelDict, getDescription, setDescription, getInnerGraph, getAddHistory, getSolverParams, setSolverParams
+#
+export getAddHistory, getDescription, getLabelDict
+export addVariable!, addFactor!
+export ls, lsf, getVariables, getFactors, getVariableIds, getFactorIds
+export getVariable, getFactor
+export updateVariable!, updateFactor!
+export deleteVariable!, deleteFactor!
+export getAdjacencyMatrix
+export getAdjacencyMatrixDataFrame
+export getNeighbors
+export getSubgraphAroundNode
+export getSubgraph
+export isFullyConnected, hasOrphans
+export toDot, toDotFile
+
+end

src/LightDFG/entities/LightDFG.jl

@@ -0,0 +1,43 @@
+
+mutable struct LightDFG{T <: AbstractParams, V <: DFGNode, F <:DFGNode} <: AbstractDFG
+    g::FactorGraph{Int, V, F}
+    description::String
+    userId::String
+    robotId::String
+    sessionId::String
+    #NOTE does not exist
+    # nodeCounter::Int64
+    #NOTE does not exist
+    # labelDict::Dict{Symbol, Int64}
+    addHistory::Vector{Symbol} #TODO: Discuss more - is this an audit trail?
+    solverParams::T # Solver parameters
+end
+
+#TODO? do we not want props such as userId, robotId, sessionId, etc...
+function LightDFG{T,V,F}(g::FactorGraph{Int,V,F}=FactorGraph{Int,V,F}();
+                           description::String="LightGraphs.jl implementation",
+                           userId::String="User ID",
+                           robotId::String="Robot ID",
+                           sessionId::String="Session ID",
+                           params::T=NoSolverParams()) where {T <: AbstractParams, V <:DFGNode, F<:DFGNode}
+
+    LightDFG{T,V,F}(g, description, userId, robotId, sessionId, Symbol[], params)
+end
+
+LightDFG{T}(g::FactorGraph{Int,DFGVariable,DFGFactor}=FactorGraph{Int,DFGVariable,DFGFactor}(); kwargs...) where T <: AbstractParams = LightDFG{T,DFGVariable,DFGFactor}(g, kwargs...)
+
+Base.propertynames(x::LightDFG, private::Bool=false) =
+    (:g, :description, :userId, :robotId, :sessionId, :nodeCounter, :labelDict, :addHistory, :solverParams)
+        # (private ? fieldnames(typeof(x)) : ())...)
+
+Base.getproperty(x::LightDFG,f::Symbol) = begin
+    if f == :nodeCounter
+        @error "Depreciated? returning number of nodes"
+        nv(x.g)
+    elseif f == :labelDict
+        @error "Depreciated? Concider using exists(dfg,label) instead. Returing internals copy"
+        copy(x.g.labels.sym_int)
+    else
+        getfield(x,f)
+    end
+end