decodePackedType with solverParams type, part of #425

Author: Affie

src/CloudGraphsDFG/entities/CloudGraphsDFG.jl

@@ -11,9 +11,9 @@ mutable struct CloudGraphsDFG{T <: AbstractParams} <: AbstractDFG
     robotId::String
     sessionId::String
     description::String
-    encodePackedTypeFunc
-    getPackedTypeFunc
-    decodePackedTypeFunc
+    encodePackedTypeFunc #TODO Is this planed to be used or deprecated?
+    getPackedTypeFunc #TODO Is this planed to be used or deprecated?
+    decodePackedTypeFunc #TODO Is this planed to be used or deprecated?
     rebuildFactorMetadata!
     addHistory::Vector{Symbol}
     solverParams::T # Solver parameters

src/services/AbstractDFG.jl

@@ -52,6 +52,13 @@ getAddHistory(dfg::AbstractDFG) = dfg.addHistory
 """
 getSolverParams(dfg::AbstractDFG) = dfg.solverParams
 
+"""
+    $(SIGNATURES)
+"""
+getFactorOperationalMemoryType(par::AbstractParams) = par.factorOperationalMemoryType
+
+getFactorOperationalMemoryType(dfg::AbstractDFG) = getFactorOperationalMemoryType(getSolverParams(dfg))
+
 ##------------------------------------------------------------------------------
 ## Setters
 ##------------------------------------------------------------------------------

src/services/Serialization.jl

@@ -118,6 +118,17 @@ function packFactor(dfg::G, f::DFGFactor)::Dict{String, Any} where G <: Abstract
     return props
 end
 
+
+function decodePackedType(::Type{T}, packeddata::GenericFunctionNodeData{PT,<:AbstractString}) where {T<:FactorOperationalMemory, PT}
+  # usrtyp = convert(FunctorInferenceType, packeddata.fnc)
+  # Also look at parentmodule
+  usrtyp = getfield(PT.name.module, Symbol(string(PT.name.name)[7:end]))
+  fulltype = DFG.FunctionNodeData{T{usrtyp}}
+  factordata = convert(fulltype, packeddata)
+  return factordata
+end
+
+
 function unpackFactor(dfg::G, packedProps::Dict{String, Any})::DFGFactor where G <: AbstractDFG
     label = packedProps["label"]
     timestamp = DateTime(packedProps["timestamp"])
@@ -129,10 +140,11 @@ function unpackFactor(dfg::G, packedProps::Dict{String, Any})::DFGFactor where G
     packtype = getTypeFromSerializationModule(dfg, Symbol("Packed"*datatype))
 
     packed = nothing
-    fullFactor = nothing
+    fullFactorData = nothing
     try
         packed = JSON2.read(data, GenericFunctionNodeData{packtype,String})
-        fullFactor = getSerializationModule(dfg).decodePackedType(dfg, packed)
+        decodeType = getFactorOperationalMemoryType(dfg)
+        fullFactorData = decodePackedType(decodeType, packed)
     catch ex
         io = IOBuffer()
         showerror(io, ex, catch_backtrace())
@@ -147,11 +159,11 @@ function unpackFactor(dfg::G, packedProps::Dict{String, Any})::DFGFactor where G
 
     # Rebuild DFGFactor
     #TODO use constuctor to create factor
-    factor = DFGFactor{typeof(fullFactor.fnc), Symbol}(Symbol(label), 0, timestamp)
+    factor = DFGFactor{typeof(fullFactorData.fnc), Symbol}(Symbol(label), 0, timestamp)
 
     union!(factor.tags, tags)
-    # factor.data = fullFactor #TODO
-    setSolverData!(factor, fullFactor)
+    # factor.data = fullFactorData #TODO
+    setSolverData!(factor, fullFactorData)
     factor._variableOrderSymbols = _variableOrderSymbols
     setSolvable!(factor, solvable)
 

test/consolInterfaceDev.jl

@@ -36,7 +36,7 @@ function DFG.CloudGraphsDFG(; hostname="localhost",
                                           description,
                                           nothing,
                                           nothing,
-                                          (dfg,f)->f,#IncrementalInference.decodePackedType,
+                                          nothing,#IncrementalInference.CommonConvWrapper,
                                           (dfg,f)->f,#ncrementalInference.rebuildFactorMetadata!,
                                           solverParams=params)
 
@@ -71,7 +71,7 @@ function DFG.CloudGraphsDFG(description::String,
                                                 description,
                                                 nothing,
                                                 nothing,
-                                                (dfg,f)->f,#IncrementalInference.decodePackedType,
+                                                nothing,#IncrementalInference.CommonConvWrapper,
                                                 (dfg,f)->f,#IncrementalInference.rebuildFactorMetadata!,
                                                 solverParams=solverParams)
 

test/runtests.jl

@@ -42,15 +42,15 @@ end
 
 if get(ENV, "SKIP_CGDFG_TESTS", "") != "true"
     @testset "Consolidation WIP Testing Driver: CloudGraphsDFG" begin
-        global decodePackedType
-        function decodePackedType(dfg::AbstractDFG, packeddata::GenericFunctionNodeData{PT,<:AbstractString}) where PT
-          # usrtyp = convert(FunctorInferenceType, packeddata.fnc)
-          # Also look at parentmodule
-          usrtyp = getfield(PT.name.module, Symbol(string(PT.name.name)[7:end]))
-          fulltype = DFG.FunctionNodeData{TestCCW{usrtyp}}
-          factordata = convert(fulltype, packeddata)
-          return factordata
-        end
+        # global decodePackedType
+        # function decodePackedType(dfg::AbstractDFG, packeddata::GenericFunctionNodeData{PT,<:AbstractString}) where PT
+        #   # usrtyp = convert(FunctorInferenceType, packeddata.fnc)
+        #   # Also look at parentmodule
+        #   usrtyp = getfield(PT.name.module, Symbol(string(PT.name.name)[7:end]))
+        #   fulltype = DFG.FunctionNodeData{TestCCW{usrtyp}}
+        #   factordata = convert(fulltype, packeddata)
+        #   return factordata
+        # end
         @info "Testing Driver: CloudGraphsDFG"
         global testDFGAPI = CloudGraphsDFG
         include("consolInterfaceDev.jl")
@@ -85,7 +85,8 @@ end
 if get(ENV, "IIF_TEST", "") == "true"
 
     # Switch to our upstream test branch.
-    Pkg.add(PackageSpec(name="IncrementalInference", rev="upstream/dfg_integration_test"))
+    # Pkg.add(PackageSpec(name="IncrementalInference", rev="upstream/dfg_integration_test"))
+    Pkg.add(PackageSpec(name="IncrementalInference", rev="develop"))
     @info "------------------------------------------------------------------------"
     @info "These tests are using IncrementalInference to do additional driver tests"
     @info "------------------------------------------------------------------------"

test/testBlocks.jl

@@ -61,6 +61,7 @@ struct TestCCW{T} <: FactorOperationalMemory where {T<:FunctorInferenceType}
 end
 Base.:(==)(a::TestCCW, b::TestCCW) = a.usrfnc! == b.usrfnc!
 
+DFG.getFactorOperationalMemoryType(par::NoSolverParams) = TestCCW 
 
 function Base.convert(::Type{DFG.FunctionNodeData{TestCCW{F}}},
                      d::DFG.PackedFunctionNodeData{<:PackedInferenceType}) where F<:FunctorInferenceType