Merge pull request #720 from JuliaRobotics/master

v0.11.2-rc1

Author: dehann

Project.toml

@@ -1,6 +1,6 @@
 name = "DistributedFactorGraphs"
 uuid = "b5cc3c7e-6572-11e9-2517-99fb8daf2f04"
-version = "0.11.1"
+version = "0.11.2"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

src/CloudGraphsDFG/services/CloudGraphsDFG.jl

@@ -397,7 +397,8 @@ function listVariables(dfg::CloudGraphsDFG, regexFilter::Union{Nothing, Regex}=n
     if regexFilter == nothing
         return _getLabelsFromCyphonQuery(dfg.neo4jInstance, "(node:$(join(_getLabelsForType(dfg, DFGVariable),':'))) where node.solvable >= $solvable $tagsFilter")
     else
-        return _getLabelsFromCyphonQuery(dfg.neo4jInstance, "(node:$(join(_getLabelsForType(dfg, DFGVariable),':'))) where node.label =~ '$(regexFilter.pattern)' and node.solvable >= $solvable $tagsFilter")
+        # Not happy about this but need to double escape the strings.
+        return _getLabelsFromCyphonQuery(dfg.neo4jInstance, "(node:$(join(_getLabelsForType(dfg, DFGVariable),':'))) where node.label =~ '$(replace(regexFilter.pattern, "\\" => "\\\\"))' and node.solvable >= $solvable $tagsFilter")
     end
 end
 
@@ -413,7 +414,7 @@ function listFactors(dfg::CloudGraphsDFG, regexFilter::Union{Nothing, Regex}=not
     if regexFilter == nothing
         return _getLabelsFromCyphonQuery(dfg.neo4jInstance, "(node:$(join(_getLabelsForType(dfg, DFGFactor),':'))) where node.solvable >= $solvable")
     else
-        return _getLabelsFromCyphonQuery(dfg.neo4jInstance, "(node:$(join(_getLabelsForType(dfg, DFGFactor),':'))) where node.label =~ '$(regexFilter.pattern)' and node.solvable >= $solvable $tagsFilter")
+        return _getLabelsFromCyphonQuery(dfg.neo4jInstance, "(node:$(join(_getLabelsForType(dfg, DFGFactor),':'))) where node.label =~ '$(replace(regexFilter.pattern, "\\" => "\\\\"))' and node.solvable >= $solvable $tagsFilter")
     end
 end
 

src/DistributedFactorGraphs.jl

@@ -238,6 +238,7 @@ export toDot, toDotFile
 
 # shortest path
 export findShortestPathDijkstra
+export isPathFactorsHomogeneous
 
 # Comparisons
 export

src/LightDFG/services/LightDFG.jl

@@ -366,6 +366,9 @@ end
 
 Speciallized function available to only LightDFG at this time.
 
+Notes
+- Has option for various types of filters (increases memory usage)
+
 Example
 ```julia
 using IncrementalInference
@@ -374,41 +377,82 @@ using IncrementalInference
 fg = generateCanonicalFG_Kaess()
 
 @show path = findShortestPathDijkstra(fg, :x1, :x3)
-@show isVariable.(path)
-@show isFactor.(path)
+@show isVariable.(fg, path)
+@show isFactor.(fg, path)
 ```
 
 DevNotes
-- # TODO expand to other AbstractDFG entities.
+- TODO expand to other AbstractDFG entities.
+- TODO use of filter resource consumption can be improved.
 
 Related
 
-[findFactorsBetweenNaive](@ref), `LightGraphs.dijkstra_shortest_paths`
+[`findFactorsBetweenNaive`](@ref), `LightGraphs.dijkstra_shortest_paths`
 """
 function findShortestPathDijkstra(  dfg::LightDFG, 
                                     from::Symbol,
-                                    to::Symbol  )
-  #
-  # LightDFG internally uses Integers 
-  frI = dfg.g.labels[from]
-  toI = dfg.g.labels[to]
-  
-  path = LightGraphs.dijkstra_shortest_paths(dfg.g.graph, [toI;])
-  # path = LightGraphs.enumerate_paths(path_state, toI)
-  
-  # assemble into the list
-  dijkpath = Symbol[]
-  # test for connectivity
-  if path.dists[frI] < Inf
-    cursor = frI
-    push!(dijkpath, dfg.g.labels[cursor])
-    # walk the path
-    while cursor != toI
-      cursor = path.parents[cursor]
-      push!(dijkpath, dfg.g.labels[cursor])
+                                    to::Symbol;
+                                    regexVariables::Union{Nothing, Regex}=nothing,
+                                    regexFactors::Union{Nothing, Regex}=nothing,
+                                    tagsVariables::Vector{Symbol}=Symbol[],
+                                    tagsFactors::Vector{Symbol}=Symbol[],
+                                    typeVariables::Union{Nothing, <:AbstractVector}=nothing,
+                                    typeFactors::Union{Nothing, <:AbstractVector}=nothing,
+                                    solvable::Int=0,
+                                    initialized::Union{Nothing,Bool}=nothing  )
+    #
+    # helper function to filter on vector of types
+    function _filterTypeList(thelist::Vector{Symbol}, typeList, listfnc=x->ls(dfg, x) )
+        thelist_ = Symbol[]
+        for type_ in typeList
+            union!(thelist_, listfnc(type_))
+        end
+        @show thelist_
+        intersect( thelist, thelist_ )
     end
-  end
 
-  # return the list of symbols
-  return dijkpath
-end
+    #
+    duplicate = regexVariables !== nothing ||
+                regexFactors !== nothing   ||
+                0 < length(tagsVariables)  ||
+                0 < length(tagsFactors)    ||
+                typeVariables !== nothing  ||
+                typeFactors !== nothing    ||
+                initialized !== nothing    ||
+                solvable != 0
+    #
+    dfg_ = if duplicate
+        # use copy if filter is being applied
+        varList = ls(dfg, regexVariables, tags=tagsVariables, solvable=solvable)
+        fctList = lsf(dfg, regexFactors, tags=tagsFactors, solvable=solvable)
+        varList = typeVariables !== nothing ? _filterTypeList(varList, typeVariables) : varList
+        fctList = typeFactors !== nothing ? _filterTypeList(fctList, typeFactors, x->lsf(dfg, x)) : fctList
+        varList = if initialized !== nothing
+            initmask = isInitialized.(dfg, varList) .== initialized
+            varList[initmask]
+        else
+            varList
+        end
+        deepcopyGraph(typeof(dfg), dfg, varList, fctList)
+    else
+        # no filter can be used directly
+        dfg
+    end
+
+    # LightDFG internally uses Integers 
+    if !haskey(dfg_.g.labels, from) || !haskey(dfg_.g.labels, from)
+        # assume filters excluded either `to` or `from` and hence no shortest path
+        return Symbol[]
+    end
+    frI = dfg_.g.labels[from]
+    toI = dfg_.g.labels[to]
+
+    # get shortest path from graph provider
+    path_state = LightGraphs.dijkstra_shortest_paths( dfg_.g.graph, [frI;] )
+    path = LightGraphs.enumerate_paths( path_state, toI )
+    dijkpath = map( x->dfg_.g.labels[x], path )
+
+    # return the list of symbols
+    return dijkpath
+end
+

src/entities/DFGFactor.jl

@@ -2,21 +2,22 @@
 ## Abstract Types
 ##==============================================================================
 
+# TODO consider changing this to AbstractFactor
 abstract type FunctorInferenceType <: Function end
 abstract type PackedInferenceType end
 
+abstract type AbstractPrior <: FunctorInferenceType end
+abstract type AbstractRelative <: FunctorInferenceType end
+abstract type AbstractRelativeRoots <: AbstractRelative end
+abstract type AbstractRelativeMinimize <: AbstractRelative end
+
 # NOTE DF, Convolution is IIF idea, but DFG should know about "FactorOperationalMemory"
 # DF, IIF.CommonConvWrapper <: FactorOperationalMemory #
 abstract type FactorOperationalMemory <: Function end
 # TODO to be removed from DFG,
 # we can add to IIF or have IIF.CommonConvWrapper <: FactorOperationalMemory directly
 # abstract type ConvolutionObject <: FactorOperationalMemory end
 
-abstract type AbstractPrior <: FunctorInferenceType end
-abstract type AbstractRelative <: FunctorInferenceType end
-abstract type AbstractRelativeRoots <: AbstractRelative end
-abstract type AbstractRelativeMinimize <: AbstractRelative end
-
 ##==============================================================================
 ## GenericFunctionNodeData
 ##==============================================================================

src/services/AbstractDFG.jl

@@ -1027,12 +1027,12 @@ Related:
 - [`getNeighborhood`](@ref)
 - [`mergeGraph!`](@ref)
 """
-function deepcopyGraph(::Type{T},
-                       sourceDFG::AbstractDFG,
-                       variableLabels::Vector{Symbol} = ls(sourceDFG),
-                       factorLabels::Vector{Symbol} = lsf(sourceDFG);
-                       sessionId::String = "",
-                       kwargs...) where T <: AbstractDFG
+function deepcopyGraph( ::Type{T},
+                        sourceDFG::AbstractDFG,
+                        variableLabels::Vector{Symbol} = ls(sourceDFG),
+                        factorLabels::Vector{Symbol} = lsf(sourceDFG);
+                        sessionId::String = "",
+                        kwargs...) where T <: AbstractDFG
 
     ginfo = [getDFGInfo(sourceDFG)...]
     if sessionId == ""
@@ -1085,7 +1085,28 @@ function findFactorsBetweenNaive(   dfg::AbstractDFG,
   return fctlist
 end
 
+"""
+    $SIGNATURES
+Return (::Bool,::Vector{TypeName}) of types between two nodes in the factor graph 
+
+DevNotes
+- Only works on LigthDFG at the moment.
+
+Related
 
+[`LightDFG.findShortestPathDijkstra`](@ref)
+"""
+function isPathFactorsHomogeneous(dfg::AbstractDFG, from::Symbol, to::Symbol)
+    # FIXME, must consider all paths, not just shortest...
+    pth = intersect(findShortestPathDijkstra(dfg, from, to), lsf(dfg))
+    types = getFactorType.(dfg, pth) .|> typeof .|> x->(x).name
+    utyp = unique(types)
+    (length(utyp) == 1), utyp
+end
+
+function existsPathOfFactorsType(dfg::AbstractDFG, from::Symbol, to::Symbol, ftype::FunctorInferenceType)
+  error("WIP")
+end
 
 ##==============================================================================
 ## Subgraphs and Neighborhoods

src/services/DFGVariable.jl

@@ -136,23 +136,24 @@ isSolved(dfg::AbstractDFG, sym::Symbol, solveKey::Symbol=:default) = isSolved(ge
 """
     $SIGNATURES
 
-Returns state of vertex data `.initialized` flag.
+Returns state of variable data `.initialized` flag.
 
 Notes:
 - used by both factor graph variable and Bayes tree clique logic.
 """
-function isInitialized(var::DFGVariable, key::Symbol=:default)::Bool
-      data = getSolverData(var, key)
-      if data == nothing
-          #TODO we still have a mixture of 2 error behaviours
-        return false
-      else
-          return data.initialized
-    end
+function isInitialized(var::DFGVariable, key::Symbol=:default)
+  data = getSolverData(var, key)
+  if data === nothing
+    #TODO we still have a mixture of 2 error behaviours
+      # DF, not sure I follow the error here?
+  return false
+  else
+    return data.initialized
+  end
 end
 
-function isInitialized(dfg::AbstractDFG, label::Symbol, key::Symbol=:default)::Bool
-  return isInitialized(getVariable(dfg, label), key)
+function isInitialized(dfg::AbstractDFG, label::Symbol, key::Symbol=:default)
+  return isInitialized(getVariable(dfg, label), key)::Bool
 end