rm factor data

Author: Affie

src/Deprecated.jl

@@ -227,6 +227,49 @@ function FactorCompute(
     )
 end
 
+function getSolverData(f::FactorCompute)
+    return error(
+        "getSolverData(f::FactorCompute) is obsolete, use getState, getObservation, or getWorkmem instead",
+    )
+end
+
+function setSolverData!(f::FactorCompute, data::GenericFunctionNodeData)
+    return error(
+        "setSolverData!(f::FactorCompute, data::GenericFunctionNodeData) is obsolete, use setState!, or setWorkmem! instead",
+    )
+end
+
+@deprecate unpackFactor(dfg::AbstractDFG, factor::FactorDFG; skipVersionCheck::Bool = false) unpackFactor(
+    factor;
+    skipVersionCheck,
+)
+
+@deprecate rebuildFactorMetadata!(args...; kwargs...) rebuildFactorWorkmem!(
+    args...;
+    kwargs...,
+)
+
+export reconstFactorData
+function reconstFactorData end
+
+function decodePackedType(
+    dfg::AbstractDFG,
+    varOrder::AbstractVector{Symbol},
+    ::Type{T},
+    packeddata::GenericFunctionNodeData{PT},
+) where {T <: FactorOperationalMemory, PT}
+    error("decodePackedType is obsolete")
+    #
+    # TODO, to solve IIF 1424
+    # variables = map(lb->getVariable(dfg, lb), varOrder)
+
+    # Also look at parentmodule
+    usrtyp = convertStructType(PT)
+    fulltype = DFG.FunctionNodeData{T{usrtyp}}
+    factordata = reconstFactorData(dfg, varOrder, fulltype, packeddata)
+    return factordata
+end
+
 ## ================================================================================
 ## Deprecated in v0.25
 ##=================================================================================

src/DistributedFactorGraphs.jl

@@ -262,7 +262,7 @@ export mergeVariableData!, mergeGraphVariableData!
 # Serialization type conversion
 export convertPackedType, convertStructType
 
-export reconstFactorData
+export pack, unpack, packDistribution, unpackDistribution
 
 ##------------------------------------------------------------------------------
 ## Other utility functions
@@ -286,7 +286,7 @@ export findClosestTimestamp, findVariableNearTimestamp
 
 # Serialization
 export packVariable, unpackVariable, packFactor, unpackFactor
-export rebuildFactorMetadata!
+export rebuildFactorWorkmem!
 export @defVariable
 
 # File import and export

src/FileDFG/services/FileDFG.jl

@@ -99,7 +99,6 @@ function loadDFG!(
     dst::AbstractString;
     overwriteDFGMetadata::Bool = true,
 )
-
     #
     # loaddir gets deleted so needs to be unique
     loaddir = split(joinpath("/", "tmp", "caesar", "random", string(uuid1())), '-')[1]
@@ -176,9 +175,10 @@ function loadDFG!(
     end
 
     @info "Loaded $(length(variables)) variables"#- $(map(v->v.label, variables))"
-    @info "Inserting variables into graph..."
-    # Adding variables
-    map(v -> addVariable!(dfgLoadInto, v), variables)
+    @showprogress 1 "Inserting variables into graph" map(
+        v -> addVariable!(dfgLoadInto, v),
+        variables,
+    )
 
     usePackedFactor =
         isa(dfgLoadInto, GraphsDFG) && getTypeDFGFactors(dfgLoadInto) == FactorDFG
@@ -190,21 +190,23 @@ function loadDFG!(
         if usePackedFactor
             return packedfact
         else
-            return unpackFactor(dfgLoadInto, packedfact)
+            return unpackFactor(packedfact)
         end
     end
 
     @info "Loaded $(length(factors)) factors"# - $(map(f->f.label, factors))"
-    @info "Inserting factors into graph..."
     # # Adding factors
-    map(f -> addFactor!(dfgLoadInto, f), factors)
+    @showprogress 1 "Inserting factors into graph" map(
+        f -> addFactor!(dfgLoadInto, f),
+        factors,
+    )
 
     if isa(dfgLoadInto, GraphsDFG) && getTypeDFGFactors(dfgLoadInto) != FactorDFG
         # Finally, rebuild the CCW's for the factors to completely reinflate them
         # NOTE CREATES A NEW FactorCompute IF  CCW TYPE CHANGES
-        @info "Rebuilding CCW's for the factors..."
-        @showprogress 1 "build factor operational memory" for factor in factors
-            rebuildFactorMetadata!(dfgLoadInto, factor)
+        # @info "Rebuilding CCW's for the factors..."
+        @showprogress 1 "Rebuilding factor working memory" for factor in factors
+            rebuildFactorWorkmem!(dfgLoadInto, factor)
         end
     end
 

src/entities/DFGFactor.jl

@@ -114,7 +114,6 @@ Base.@kwdef struct FactorDFG <: AbstractDFGFactor
     nstime::String
     fnctype::String
     solvable::Int
-    data::Union{String, Nothing} = nothing #TODO deprecated in v0.27 remove data completely, use state and observJSON
     metadata::String
     _version::String = string(_getDFGVersion())
     state::FactorState
@@ -169,7 +168,6 @@ function FactorDFG(
         nstime,
         fnctype,
         solvable,
-        data,
         metadata,
         _version,
         state,
@@ -268,9 +266,6 @@ Base.@kwdef struct FactorCompute{FT <: AbstractFactor, N} <: AbstractDFGFactor
     timestamp::ZonedDateTime
     """Nano second time"""
     nstime::Nanosecond
-    """Solver data.
-    Accessors: [`getSolverData`](@ref), [`setSolverData!`](@ref)"""
-    solverData::Base.RefValue{<:GenericFunctionNodeData}
     """Solvable flag for the factor.
     Accessors: [`getSolvable`](@ref), [`setSolvable!`](@ref)"""
     solvable::Base.RefValue{Int}
@@ -309,11 +304,8 @@ function FactorCompute(
     smallData::Dict{Symbol, SmallDataTypes} = Dict{Symbol, SmallDataTypes}(),
     solverData = nothing,
 )
-    if isnothing(solverData)
-        refsolverData = Ref{GenericFunctionNodeData}() #TODO solverData deprecated in v0.27 WIP
-    else
+    if !isnothing(solverData)
         Base.depwarn("`FactorCompute` solverData is deprecated", :FactorCompute)
-        refsolverData = Ref(solverData)
     end
 
     if isnothing(_workmem)
@@ -329,7 +321,6 @@ function FactorCompute(
         Tuple(variableOrder),
         timestamp,
         nstime,
-        refsolverData,
         Ref(solvable),
         smallData,
         observation,
@@ -380,7 +371,6 @@ function FactorCompute(
         timestamp,
         nstime,
         tags,
-        solverData,
         smallData,
         solvable,
     )
@@ -390,16 +380,9 @@ function Base.getproperty(x::FactorCompute, f::Symbol)
     if f == :solvable
         getfield(x, f)[]
     elseif f == :solverData
-        Base.depwarn(
-            "`FactorCompute` field `$(f)` is deprecated, use `getObservation`, `getState` or `getWorkmem` instead.",
-            :getproperty,
+        error(
+            "`solverData` is obsolete in `FactorCompute`. Use `getObservation`, `getState` or `getWorkmem` instead.",
         )
-        # error("WIP removing direct access, breaking change in v0.27, use `state` or `Workmem` instead.")
-        if isassigned(getfield(x, f))
-            getfield(x, f)[]
-        else
-            nothing
-        end
     elseif f == :_variableOrderSymbols
         [getfield(x, f)...]
     else
@@ -408,8 +391,12 @@ function Base.getproperty(x::FactorCompute, f::Symbol)
 end
 
 function Base.setproperty!(x::FactorCompute, f::Symbol, val)
-    if f == :solvable || f == :solverData
+    if f == :solvable
         getfield(x, f)[] = val
+    elseif f == :solverData
+        error(
+            "`solverData` is obsolete in `FactorCompute`. Use `Observation`, `State` or `Workmem` instead.",
+        )
     else
         setfield!(x, f, val)
     end

src/services/AbstractDFG.jl

@@ -116,12 +116,12 @@ end
 
 Method must be overloaded by the user for Serialization to work.
 """
-function rebuildFactorMetadata!(
+function rebuildFactorWorkmem!(
     dfg::AbstractDFG{<:AbstractParams},
     factor::AbstractDFGFactor,
     neighbors = [],
 )
-    return error("rebuildFactorMetadata! is not implemented for $(typeof(dfg))")
+    return error("rebuildFactorWorkmem! is not implemented for $(typeof(dfg))")
 end
 
 """

src/services/CompareUtils.jl

@@ -359,7 +359,7 @@ function compareFactor(
             show = show,
         )
     @debug "compareFactor 3/5" TP
-    
+
     #FIXME is measurement stil in use and should it be checked, skipping for now
     if false # !(:measurement in skip)
         TP =
@@ -388,7 +388,7 @@ function compareFactor(
     @debug "compareFactor 5/5" TP
     #FIXME is varidx stil in use and should it be checked, skipping for now
     if false #!(:varidx in skip) && hasfield(typeof(getSolverData(A).fnc), :varidx) &&
-       getSolverData(A).fnc.varidx isa Base.RefValue
+        getSolverData(A).fnc.varidx isa Base.RefValue
         TP =
             TP & (
                 skipcompute || compareAll(

src/services/DFGFactor.jl

@@ -56,9 +56,16 @@ function getObservation(f::FactorDFG)
     #FIXME completely refactor to not need getTypeFromSerializationModule and just use StructTypes
     packtype = DFG.getTypeFromSerializationModule("Packed" * f.fnctype)
     return packtype(; JSON3.read(f.observJSON)...)
+    # return packtype(JSON3.read(f.observJSON))
 end
 
-getWorkmem(f::FactorCompute) = f.workmem[]
+function getWorkmem(f::FactorCompute)
+    if isassigned(f.workmem)
+        return f.workmem[]
+    else
+        return nothing
+    end
+end
 setWorkmem!(f::FactorCompute, workmem::FactorOperationalMemory) = f.workmem[] = workmem
 
 """
@@ -84,7 +91,6 @@ end
 ## Default Factors Function Macro
 ##==============================================================================
 export PackedSamplableBelief
-# export pack, unpack, packDistribution, unpackDistribution
 
 function pack end
 function unpack end
@@ -94,38 +100,48 @@ function unpackDistribution end
 abstract type PackedSamplableBelief end
 StructTypes.StructType(::Type{<:PackedSamplableBelief}) = StructTypes.UnorderedStruct()
 
+#TODO remove, rather use StructTypes.jl properly
+function Base.convert(::Type{<:PackedSamplableBelief}, nt::Union{NamedTuple, JSON3.Object})
+    distrType = getTypeFromSerializationModule(nt._type)
+    return distrType(; nt...)
+end
+
 """
-    @defFactorType StructName factortype<:AbstractFactor manifolds<:ManifoldsBase.AbstractManifold
+    @defFactorType StructName factortype<:AbstractFactor manifolds<:AbstractManifold
 
-A macro to create a new factor function with name `StructName` and manifolds.  Note that 
-the `manifolds` is an object and *must* be a subtype of `ManifoldsBase.AbstractManifold`.
+A macro to create a new factor function with name `StructName` and manifold. Note that
+the `manifold` is an object and *must* be a subtype of `ManifoldsBase.AbstractManifold`.
 See documentation in [Manifolds.jl on making your own](https://juliamanifolds.github.io/Manifolds.jl/stable/examples/manifold.html). 
 
 Example:
 ```
-DFG.@defFactorType Pose2Pos2 AbstractManifoldMinimize SpecialEuclidean(2)
+DFG.@defFactorType Pose2Pose2 AbstractManifoldMinimize SpecialEuclidean(2)
 ```
 """
 macro defFactorType(structname, factortype, manifold)
     packedstructname = Symbol("Packed", structname)
     return esc(
         quote
+            # user manifold must be a <:Manifold
+            @assert ($manifold isa AbstractManifold) "@defFactorType manifold (" *
+                                                     string($manifold) *
+                                                     ") is not an `AbstractManifold`"
+
+            @assert ($factortype <: AbstractFactor) "@defFactorType factortype (" *
+                                                    string($factortype) *
+                                                    ") is not an `AbstractFactor`"
+
             Base.@__doc__ struct $structname{T} <: $factortype
                 Z::T
             end
 
-            Base.@__doc__ struct $packedstructname{T <: PackedSamplableBelief} <:
-                                 AbstractPackedFactor
-                Z::T
+            #TODO should this be $packedstructname{T <: PackedSamplableBelief}
+            Base.@__doc__ struct $packedstructname <: AbstractPackedFactor
+                Z::PackedSamplableBelief
             end
 
-            # user manifold must be a <:Manifold
-            @assert ($manifold isa AbstractManifold) "@defFactorType of " *
-                                                     string($structname) *
-                                                     " requires that the " *
-                                                     string($manifold) *
-                                                     " be a subtype of `ManifoldsBase.AbstractManifold`"
-
+            # $structname(; Z) = $structname(Z)                                                     
+            $packedstructname(; Z) = $packedstructname(Z)
             DFG.getManifold(::Type{$structname}) = $manifold
             DFG.pack(d::$structname) = $packedstructname(DFG.packDistribution(d.Z))
             DFG.unpack(d::$packedstructname) = $structname(DFG.unpackDistribution(d.Z))
@@ -223,26 +239,6 @@ getVariableOrder(fct::FactorCompute) = fct._variableOrderSymbols::Vector{Symbol}
 getVariableOrder(fct::FactorDFG) = fct._variableOrderSymbols::Vector{Symbol}
 getVariableOrder(dfg::AbstractDFG, fct::Symbol) = getVariableOrder(getFactor(dfg, fct))
 
-##------------------------------------------------------------------------------
-## solverData
-##------------------------------------------------------------------------------
-
-"""
-    $SIGNATURES
-
-Retrieve solver data structure stored in a factor.
-"""
-function getSolverData(f::FactorCompute)
-    Base.depwarn("getSolverData(f::FactorCompute) is deprecated", :getSolverData)
-    if isassigned(getfield(f, :solverData))
-        return getfield(f, :solverData)[]
-    else
-        return nothing
-    end
-end
-
-setSolverData!(f::FactorCompute, data::GenericFunctionNodeData) = f.solverData = data
-
 ##------------------------------------------------------------------------------
 ## utility
 ##------------------------------------------------------------------------------