initial code from IncrementalInference

Author: dehann

src/DistributedFactorGraphs.jl

@@ -5,5 +5,6 @@ using
   DocStringExtensions
 
 
+include("FGOSUtils.jl")
 
 end

src/FGOSUtils.jl

@@ -0,0 +1,301 @@
+# Factor Graph OS type utilities
+#  IIF methods should direclty detect extended types from user import
+# of convert in their namespace
+
+
+function convert{PT <: PackedInferenceType, T <:FunctorInferenceType}(::Type{PT}, ::T)
+  getfield(T.name.module, Symbol("Packed$(T.name.name)"))
+end
+function convert{T <: FunctorInferenceType, PT <: PackedInferenceType}(::Type{T}, ::PT)
+  getfield(PT.name.module, Symbol(string(PT.name.name)[7:end]))
+end
+
+
+
+"""
+    convert2packedfunctionnode(fgl::FactorGraph, fsym::Symbol)
+
+Encode complicated function node type with assumed to exist, user supplied convert
+function to related 'Packed<type>' format.
+"""
+function convert2packedfunctionnode(fgl::FactorGraph,
+      fsym::Symbol,
+      api::DataLayerAPI=localapi  )
+  #
+  fid = fgl.fIDs[fsym]
+  fnc = getfnctype(fgl, fid)
+  usrtyp = convert(PackedInferenceType, fnc)
+  cfnd = convert(PackedFunctionNodeData{usrtyp},getData(fgl, fid, api=api) )
+  return cfnd, usrtyp
+end
+
+
+
+
+"""
+    encodefg(fgl::FactorGraph)
+
+Make a full memory copy of the graph and encode all complicated function node
+types with assumed to exist convert to 'Packed<type>' formats. Same converters
+as used for database persistence storage with CloudGraphs.jl.
+"""
+function encodefg(fgl::FactorGraph;
+      api::DataLayerAPI=localapi  )
+  #
+  fgs = deepcopy(fgl)
+  fgs.cg = nothing
+  fgs.registeredModuleFunctions = nothing
+  fgs.g = Graphs.incdict(Graphs.ExVertex,is_directed=false)
+  @showprogress 1 "Encoding variables..." for (vsym,vid) in fgl.IDs
+    cpvert = deepcopy(getVert(fgl, vid, api=api))
+    api.addvertex!(fgs, cpvert) #, labels=vnlbls)  # currently losing labels
+  end
+
+  @showprogress 1 "Encoding factors..." for (fsym,fid) in fgs.fIDs
+    data,ftyp = convert2packedfunctionnode(fgl, fsym)
+    # data = FunctionNodeData{ftyp}(Int[], false, false, Int[], m, gwpf)
+    newvert = ExVertex(fid,string(fsym))
+    for (key,val) in getVert(fgl,fid,api=api).attributes
+      newvert.attributes[key] = val
+    end
+    setData!(newvert, data)
+    api.addvertex!(fgs, newvert)
+  end
+  fgs.g.inclist = typeof(fgl.g.inclist)()
+
+  # iterated over all edges
+  @showprogress 1 "Encoding edges..." for (eid, edges) in fgl.g.inclist
+    fgs.g.inclist[eid] = Vector{typeof(edges[1])}()
+    for ed in edges
+      newed = Graphs.Edge(ed.index,
+          fgs.g.vertices[ed.source.index],
+          fgs.g.vertices[ed.target.index]  )
+      push!(fgs.g.inclist[eid], newed)
+    end
+  end
+
+  return fgs
+end
+
+"""
+    savefgjld(fgl::FactorGraph; file::AbstractString="tempfg.jld")
+
+Save mostly complete Factor Graph type by converting complicated FunctionNodeData
+types to 'Packed' types using user supplied converters. Ground truth can also be
+saved and recovered by the associated loadjld(file="tempfg.jld") method.
+"""
+function savejld(fgl::FactorGraph;
+      file::AbstractString="tempfg.jld",
+      groundtruth=nothing)
+  fgs = encodefg(fgl)
+  if groundtruth == nothing
+    @save file fgs
+  else
+    @save file fgs groundtruth
+  end
+  return file
+end
+
+
+"""
+    convertfrompackedfunctionnode(fgl, fsym)
+
+If you get unknown type conversion error when loading a .jld, while using your own
+FunctorInferenceTypes, you should:
+Copy these functions below, and overload in your package with local extented
+FunctorInferenceType definitions.
+See RoME/src/fgos.jl for example.
+"""
+function convertfrompackedfunctionnode(fgl::FactorGraph,
+      fsym::Symbol,
+      api::DataLayerAPI=localapi  )
+  #
+  fid = fgl.fIDs[fsym]
+  fnc = getData(fgl, fid).fnc #getfnctype(fgl, fid)
+  usrtyp = convert(FunctorInferenceType, fnc)
+  data = getData(fgl, fid, api=api)
+  newtype = FunctionNodeData{GenericWrapParam{usrtyp}}
+  cfnd = convert(newtype, data)
+  return cfnd, usrtyp
+end
+
+"""
+    decodefg(fgs::FactorGraph)
+
+Unpack PackedFunctionNodeData formats back to regular FunctonNodeData.
+"""
+function decodefg(fgs::FactorGraph; api::DataLayerAPI=localapi)
+  fgu = deepcopy(fgs)
+  fgu.cg = nothing
+  fgu.registeredModuleFunctions = nothing
+  fgu.g = Graphs.incdict(Graphs.ExVertex,is_directed=false)
+  @showprogress 1 "Decoding variables..." for (vsym,vid) in fgs.IDs
+    cpvert = deepcopy(getVert(fgs, vid, api=api))
+    api.addvertex!(fgu, cpvert) #, labels=vnlbls)  # currently losing labels
+  end
+
+  @showprogress 1 "Decoding factors..." for (fsym,fid) in fgu.fIDs
+    data,ftyp = convertfrompackedfunctionnode(fgs, fsym)
+    # data = FunctionNodeData{ftyp}(Int[], false, false, Int[], m, gwpf)
+    newvert = ExVertex(fid,string(fsym))
+    for (key,val) in getVert(fgs,fid,api=api).attributes
+      newvert.attributes[key] = val
+    end
+    setData!(newvert, data)
+    api.addvertex!(fgu, newvert)
+  end
+  fgu.g.inclist = typeof(fgs.g.inclist)()
+
+  # iterated over all edges
+  @showprogress 1 "Decoding edges..." for (eid, edges) in fgs.g.inclist
+    fgu.g.inclist[eid] = Vector{typeof(edges[1])}()
+    for ed in edges
+      newed = Graphs.Edge(ed.index,
+          fgu.g.vertices[ed.source.index],
+          fgu.g.vertices[ed.target.index]  )
+      push!(fgu.g.inclist[eid], newed)
+    end
+  end
+
+  return fgu
+end
+
+"""
+    loadjld(file="tempfg.jld")
+
+Opposite of savejld(fg, gt=gt, file="tempfg.jl") to load data from file. This function
+uses the unpacking converters for converting all PackedInferenceType to FunctorInferenceType.
+"""
+function loadjld(;file::AbstractString="tempfg.jld")
+  dd = JLD.load(file)
+  # fgs = jldopen(file,"r") do file
+  #   read(file, "fgs")
+  # end
+  fgs, gt = nothing, nothing
+  if haskey(dd, "fgs")
+    fgs = dd["fgs"]
+  else
+    error("No factor graph (fgs) data found in this file, only found $(keys(dd))")
+  end
+  if haskey(dd, "groundtruth")
+    gt = dd["groundtruth"]
+    println("Also found ground truth data")
+  end
+  fgd = decodefg(fgs)
+  return fgd, gt
+end
+
+
+
+
+function ls(fgl::FactorGraph, lbl::Symbol; api::DataLayerAPI=dlapi, ring::Int=1)
+  # TODO ring functionality must still be implemented
+  lsa = Symbol[]
+  # v = nothing
+  if haskey(fgl.IDs, lbl)
+    id = fgl.IDs[lbl]
+  else
+    return lsa
+  end
+  # this is unnecessary
+  v = getVert(fgl,id, api=api)
+  for outn in api.outneighbors(fgl, v)
+    # if outn.attributes["ready"] = 1 && outn.attributes["backendset"]=1
+      push!(lsa, Symbol(outn.label))
+    # end
+  end
+  return lsa
+end
+ls(fgl::FactorGraph, lbl::T) where {T <: AbstractString} = ls(fgl, Symbol(lbl))
+
+function ls(fgl::FactorGraph)
+  k = collect(keys(fgl.IDs))
+  l = Int[]
+  x = Int[]
+  for kk in k
+    kstr = string(kk)
+    val = parse(Int,kstr[2:end]) # kk
+    if kstr[1] == 'l'
+      push!(l,val)
+    elseif kstr[1] == 'x'
+      push!(x,val)
+    end
+  end
+  l = sort(l)
+  x = sort(x)
+  ll = Array{Symbol,1}(length(l))
+  xx = Array{Symbol,1}(length(x))
+  for i in 1:length(l)
+    ll[i] = Symbol(string("l",l[i]))
+  end
+  for i in 1:length(x)
+    xx[i] = Symbol(string("x",x[i]))
+  end
+  return xx,ll
+end
+
+function lsf(fgl::FactorGraph, lbl::Symbol; api::DataLayerAPI=dlapi)
+  lsa = Symbol[]
+  # v = Union{}
+  if haskey(fgl.fIDs, lbl)
+    id = fgl.fIDs[lbl]
+  else
+    return lsa
+  end
+  v = getVert(fgl, id, api=api) # fgl.g.vertices[id] #fgl.f[id]
+  for outn in api.outneighbors(fgl, v) # out_neighbors(v, fgl.g)
+    push!(lsa, Symbol(outn.label))
+  end
+  return lsa
+end
+lsf{T <: AbstractString}(fgl::FactorGraph, lbl::T) = lsf(fgl,Symbol(lbl))
+
+function lsf{T <: FunctorInferenceType}(fgl::FactorGraph,
+      mt::Type{T};
+      api::DataLayerAPI=dlapi  )
+  #
+  syms = Symbol[]
+  for (fsym,fid) in fgl.fIDs
+    if typeof(getfnctype(fgl, fid, api=api))==T
+      push!(syms, fsym)
+    end
+  end
+  return syms
+end
+
+function ls2(fgl::FactorGraph, vsym::Symbol)
+  xxf = ls(fgl, vsym)
+  xlxl = Symbol[]
+  for xf in xxf
+    xx = lsf(fgl,xf)
+    xlxl = union(xlxl, xx)
+  end
+  xlxl = setdiff(xlxl, [vsym])
+  return xlxl
+end
+
+
+"""
+    landmarks(fgl::FactorGraph, vsym::Symbol)
+
+Return Vector{Symbol} of landmarks attached to vertex vsym in fgl.
+"""
+function landmarks(fgl::FactorGraph, vsym::Symbol)
+  fsyms = ls(fgl, vsym)
+  lms = Symbol[]
+  for fs in fsyms
+    for varv = lsf(fgl, fs)
+      if string(varv)[1] == 'l'
+        push!(lms, varv)
+      end
+    end
+  end
+  lms
+end
+
+
+
+
+
+
+#