Merge branch 'master' into feature/20Q1/VNDCondition

Author: dehann

Project.toml

@@ -10,25 +10,29 @@ Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
 DocStringExtensions = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae"
 GraphPlot = "a2cc645c-3eea-5389-862e-a155d0052231"
 Graphs = "86223c79-3864-5bf0-83f7-82e725a168b6"
+JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
 JSON2 = "2535ab7d-5cd8-5a07-80ac-9b1792aadce3"
 LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
 Neo4j = "d2adbeaf-5838-5367-8a2f-e46d570981db"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 Requires = "ae029012-a4dd-5104-9daa-d747884805df"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
+Unmarshal = "cbff2730-442d-58d7-89d1-8e530c41eb02"
 
 [compat]
 Colors = "0.8, 0.9, 0.10, 0.11"
 Distributions = "0.18, 0.19, 0.20, 0.21, 0.22, 0.23, 0.24, 0.25, 1"
 DocStringExtensions = "0.8, 0.9, 0.10, 1"
 GraphPlot = "0.3.1, 0.4"
 Graphs = "0.10.2, 0.11, 1"
+JSON = "0.21"
 JSON2 = "0.3.1"
 LightGraphs = "1.2, 1.3"
 Neo4j = "2"
 Reexport = "0.2, 0.3, 0.4, 0.5, 1"
 Requires = "0.5, 0.6, 0.7, 0.8, 0.9, 0.10, 1"
+Unmarshal = "0.3"
 julia = "0.7, 1"
 
 [extras]

README.md

@@ -22,7 +22,7 @@ add DistributedFactorGraphs
 
 # Usage
 DistributedFactorGraphs (DFG) currently supports two implementations:
-* An in-memory factor graph based on Graphs.jl
+* An in-memory factor graphs based on Graphs.jl and LightGraphs.jl
 * A Neo4j-based factor graph based on Neo4j.jl
 
 The in-memory implementation is the default. The Neo4j driver can be enabled by importing Neo4j before DFG:

docs/Project.toml

@@ -1,5 +1,6 @@
 [deps]
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
+GraphPlot = "a2cc645c-3eea-5389-862e-a155d0052231"
 LightGraphs = "093fc24a-ae57-5d10-9952-331d41423f4d"
 
 [compat]

docs/make.jl

@@ -1,4 +1,5 @@
 using Documenter
+using GraphPlot
 using DistributedFactorGraphs
 
 makedocs(

docs/src/BuildingGraphs.md

@@ -111,16 +111,16 @@ Reading, updating, and deleting all use DFG functions (as opposed to adding,
 where using the IncrementalInference functions are recommended).
 
 Each variable and factor is uniquely identified by its label. The list of
-variable and factor labels can be retrieved with the `ls`/`getVariableIds` and
-`lsf`/`getFactorIds` functions:
+variable and factor labels can be retrieved with the `ls`/`listVariables` and
+`lsf`/`listFactors` functions:
 
 ```@docs
-getVariableIds
+listVariables
 ls
 ```
 
 ```@docs
-getFactorIds
+listFactors
 lsf
 ```
 

docs/src/GraphData.md

@@ -43,27 +43,24 @@ Labels are the principle identifier of a variable or factor.
 getLabel
 ```
 
-```@docs
-getLabel
-```
-
 #### Timestamps
 
 Each variable or factor can have a timestamp associated with it.
 
 ```@docs
 getTimestamp
-setTimestamp!
+setTimestamp
 ```
 
 #### Tags
 
 Tags are a set of symbols that contain identifiers for the variable or factor.
 
 ```@docs
-addTag
+listTags
 mergeTags!
-deleteTags!
+removeTags!
+emptyTags!
 ```
 
 ### Solvable
@@ -95,7 +92,6 @@ For each PPE structure, there are accessors for getting individual values:
 getMaxPPE
 getMeanPPE
 getSuggestedPPE
-getPPE
 ```
 
 Related functions for getting, adding/updating, and deleting PPE structures:
@@ -106,6 +102,7 @@ getPPE
 addPPE!
 updatePPE!
 deletePPE!
+mergePPEs!
 ```
 
 Example of PPE operations:
@@ -139,6 +136,7 @@ getVariableSolverData
 addVariableSolverData!
 updateVariableSolverData!
 deleteVariableSolverData!
+mergeVariableSolverData!
 ```
 
 Example of solver data operations:
@@ -163,7 +161,7 @@ itself, large entries will slow the graph down, so if data should exceed a
 few bytes/kb, it should rather be saved in bigData.
 
 ```@docs
-getSmallData,
+getSmallData
 setSmallData!
 ```
 

docs/src/TraversingAndQuerying.md

@@ -4,6 +4,5 @@
 getNeighbors
 getSubgraphAroundNode
 getSubgraph
-getIncidenceMatrix
-getIncidenceMatrixSparse
+getBiadjacencyMatrix
 ```

docs/src/func_ref.md

@@ -7,67 +7,6 @@ Pages = [
 Depth = 3
 ```
 
-### Graph Types
-```@docs
-GraphsDFG
-```
-
-### Creating DFG Factor Graphs
-```@docs
-addVariable!
-addFactor!
-```
-
-### Getting Factor Graph Nodes
-```@docs
-getVariables
-getFactors
-getVariable
-getFactor
-getNeighbors
-ls
-lsf
-```
-
-### Updating Factor Graph Nodes
-```@docs
-updateVariable!
-updateFactor!
-```
-
-### Deleting Factor Graph Nodes
-```@docs
-deleteVariable!
-deleteFactor!
-```
-
-### Getting Adjacency Matrix
-```@docs
-getIncidenceMatrix
-getIncidenceMatrixSparse
-```
-
-### Validating Factor Graph Connectivity
-```@docs
-isFullyConnected
-hasOrphans
-```
-
-### Copying Subgraphs
-```@docs
-getSubgraphAroundNode
-getSubgraph
-```
-
-### Summaries
-```@docs
-getSummary
-getSummaryGraph
-```
-
-### Visualization and Plotting
-```@docs
-toDot
-toDotFile
-dfgplot
+```@autodocs
+Modules = [DistributedFactorGraphs, LightDFGs, DFGPlots]
 ```

docs/src/index.md

@@ -1,11 +1,17 @@
 # Introduction
 
-This package is a specialized Julia graphing wrapper.
+DistributedFactorGraphs.jl provides a flexible factor graph API for use in the [Caesar.jl](https://github.com/JuliaRobotics/Caesar.jl) ecosystem. The package supplies:
+* A standardized API for interacting with factor graphs
+* Implementations of the API for in-memory and database-driven operation
+* Visualization extensions to validate the underlying graph
+
+**Note** this package is still under initial development, and will adopt parts of the functionality currently contained in [IncrementalInference.jl](http://www.github.com/JuliaRobotics/IncrementalInference.jl).
 
 ## Installation
-This package is not yet registered with JuliaLang/METADATA.jl, but can be easily installed in Julia 0.6 with:
+
+DistributedFactorGraphs can be installed from Julia packages using:
 ```julia
-julia> ]add https://github.com/GearsAD/GraffSDK.jl.git
+julia> ]add DistributedFactorGraphs
 ```
 
 ## Manual Outline

src/BigData/services/AbstractBigDataEntries.jl

@@ -15,3 +15,96 @@ end
 function ==(a::FileBigDataEntry, b::FileBigDataEntry)
     return a.key == b.key && a.filename == b.filename
 end
+
+"""
+    $(SIGNATURES)
+Add Big Data Entry to a DFG variable
+"""
+function addBigDataEntry!(var::AbstractDFGVariable, bde::AbstractBigDataEntry)::AbstractBigDataEntry
+    haskey(var.bigData,bde.key) && error("BigData entry $(bde.key) already exists in variable")
+    var.bigData[bde.key] = bde
+    return bde
+end
+
+"""
+    $(SIGNATURES)
+Add Big Data Entry to distributed factor graph.
+Should be extended if DFG variable is not returned by reference.
+"""
+function addBigDataEntry!(dfg::AbstractDFG, label::Symbol, bde::AbstractBigDataEntry)::AbstractBigDataEntry
+    return addBigDataEntry!(getVariable(dfg, label), bde)
+end
+
+"""
+    $(SIGNATURES)
+Get big data entry
+"""
+function getBigDataEntry(var::AbstractDFGVariable, key::Symbol)::Union{Nothing, AbstractBigDataEntry}
+    !haskey(var.bigData, key) && (error("BigData entry $(key) does not exist in variable"); return nothing)
+    return var.bigData[key]
+end
+
+function getBigDataEntry(dfg::AbstractDFG, label::Symbol, key::Symbol)::Union{Nothing, AbstractBigDataEntry}
+    return getBigDataEntry(getVariable(dfg, label), key)
+end
+
+"""
+    $(SIGNATURES)
+Update big data entry
+"""
+function updateBigDataEntry!(var::AbstractDFGVariable,  bde::AbstractBigDataEntry)::Union{Nothing, AbstractBigDataEntry}
+    !haskey(var.bigData,bde.key) && (@warn "$(bde.key) does not exist in variable, adding")
+    var.bigData[bde.key] = bde
+    return bde
+end
+function updateBigDataEntry!(dfg::AbstractDFG, label::Symbol,  bde::AbstractBigDataEntry)::Union{Nothing, AbstractBigDataEntry}
+    # !isVariable(dfg, label) && return nothing
+    return updateBigDataEntry!(getVariable(dfg, label), bde)
+end
+
+"""
+    $(SIGNATURES)
+Delete big data entry from the factor graph.
+Note this doesn't remove it from any data stores.
+"""
+function deleteBigDataEntry!(var::AbstractDFGVariable, key::Symbol)::Union{Nothing, AbstractDFGVariable} #users responsibility to delete big data in db before deleting entry
+    bde = getBigDataEntry(var, key)
+    bde == nothing && return nothing
+    delete!(var.bigData, key)
+    return var
+end
+function deleteBigDataEntry!(dfg::AbstractDFG, label::Symbol, key::Symbol)::Union{Nothing, AbstractDFGVariable} #users responsibility to delete big data in db before deleting entry
+    !isVariable(dfg, label) && return nothing
+    return deleteBigDataEntry!(getVariable(dfg, label), key)
+end
+
+function deleteBigDataEntry!(var::AbstractDFGVariable, entry::AbstractBigDataEntry)::Union{Nothing, AbstractDFGVariable} #users responsibility to delete big data in db before deleting entry
+    return deleteBigDataEntry!(var, entry.key)
+end
+
+"""
+    $(SIGNATURES)
+Get big data entries, Vector{AbstractBigDataEntry}
+"""
+function getBigDataEntries(var::AbstractDFGVariable)::Vector{AbstractBigDataEntry}
+    #or should we return the iterator, Base.ValueIterator{Dict{Symbol,AbstractBigDataEntry}}?
+    collect(values(var.bigData))
+end
+function getBigDataEntries(dfg::AbstractDFG, label::Symbol)::Union{Nothing, Vector{AbstractBigDataEntry}}
+    !isVariable(dfg, label) && return nothing
+    #or should we return the iterator, Base.ValueIterator{Dict{Symbol,AbstractBigDataEntry}}?
+    getBigDataEntries(getVariable(dfg, label))
+end
+
+
+"""
+    $(SIGNATURES)
+getBigDataKeys
+"""
+function getBigDataKeys(var::AbstractDFGVariable)::Vector{Symbol}
+    collect(keys(var.bigData))
+end
+function getBigDataKeys(dfg::AbstractDFG, label::Symbol)::Union{Nothing, Vector{Symbol}}
+    !isVariable(dfg, label) && return nothing
+    getBigDataKeys(getVariable(dfg, label))
+end