Merge pull request #842 from JuliaRobotics/22Q1/maint/cleanup

cleanup AbstractFactor and initAll!, more

Author: dehann

NEWS.md

@@ -1,5 +1,12 @@
 Listing news on any major breaking changes in DFG.  For regular changes, see integrated Github.com project milestones for DFG.
 
+# v0.18.0
+
+- Unpack of GenericFactorNodeData now get `dfg::AbstractDFG` and `varOrder::Vector{Symbol}`, deprecating previous use of `convert` without the graph context (#832).
+- Switch to GraphsDFG, deprecating archived LightGraphs.jl (#826).
+- Workaround: packed factor data `.fnc` encoded as base64 to avoid escape character problems (#834).
+- Towards distributions serialized via JSON, getting away from custom strings.
+
 # v0.16.0
 
 - `{Packed}VariableNodeData.infoPerCoord::Vector{Float64}` replaces previous `.inferdim::Float64`.  The change should have legacy support to help facilitate the transition.  This datastore is likely to only become part of critical computations downstream in IncrementalInference.jl v0.26, even though the previous `.inferdim` data values are being populated there.  (#804)

attic/DataStoreTests.jl

@@ -19,7 +19,7 @@ dfg = testDFGAPI{NoSolverParams}()
 # struct TestInferenceVariable1 <: InferenceVariable end
 # v1 = DFGVariable(:a, TestInferenceVariable1())
 # v2 = DFGVariable(:b, TestInferenceVariable1())
-# f1 = DFGFactor{TestFunctorInferenceType1}(:f1, [:a,:b]);
+# f1 = DFGFactor{TestAbstractFactor1}(:f1, [:a,:b]);
 # #add tags for filters
 # union!(v1.tags, [:VARIABLE, :POSE])
 # union!(v2.tags, [:VARIABLE, :LANDMARK])

src/Common.jl

@@ -4,8 +4,8 @@ _getmodule(t::T) where T = T.name.module
 _getname(t::T) where T = T.name.name
 
 
-convertPackedType(t::Union{T, Type{T}}) where {T <: FunctorInferenceType} = getfield(_getmodule(t), Symbol("Packed$(_getname(t))"))
-function convertStructType(::Type{PT}) where {PT <: PackedInferenceType}
+convertPackedType(t::Union{T, Type{T}}) where {T <: AbstractFactor} = getfield(_getmodule(t), Symbol("Packed$(_getname(t))"))
+function convertStructType(::Type{PT}) where {PT <: AbstractPackedFactor}
     # see #668 for expanded reasoning.  PT may be ::UnionAll if the type is of template type.
     ptt = PT isa DataType ? PT.name.name : PT
     moduleName = PT isa DataType ? PT.name.module : Main

src/Deprecated.jl

@@ -5,12 +5,6 @@
 ## Deprecated in v0.9 Remove in the v0.10 cycle
 ##==============================================================================
 
-Base.promote_rule(::Type{DateTime}, ::Type{ZonedDateTime}) = DateTime
-function Base.convert(::Type{DateTime}, ts::ZonedDateTime)
-    @warn "DFG now uses ZonedDateTime, temporary promoting and converting to DateTime local time"
-    return DateTime(ts, Local)
-end
-
 @deprecate listSolvekeys(x...) listSolveKeys(x...)
 
 ##==============================================================================
@@ -131,73 +125,6 @@ function updateVariableSolverData!(dfg::AbstractDFG,
 end
 
 
-##==============================================================================
-## Deprecated in v0.11 Remove in the v0.12 cycle
-##==============================================================================
-
-# # @warn("BREAKING CHANGE coming to DistributedFactorGraphs v0.12: deprecating AbstractRelativeFactor, use AbstractRelativeRoots instead")
-# # @warn("BREAKING CHANGE coming to DistributedFactorGraphs v0.12: deprecating AbstractRelativeFactorMinimize, use AbstractRelativeMinimize instead")
-# # export AbstractRelativeFactor, AbstractRelativeFactorMinimize
-# const AbstractRelativeFactor = AbstractRelativeRoots
-# const AbstractRelativeFactorMinimize = AbstractRelativeMinimize
-
-# ##-------------------------------------------------------------------------------
-# ## softtype -> variableType deprecation
-# ##-------------------------------------------------------------------------------
-
-# function Base.getproperty(x::VariableNodeData,f::Symbol)
-#   if f == :softtype
-#     Base.depwarn("`VariableNodeData` field `softtype` is deprecated, use `variableType`", :getproperty)
-#     f = :variableType
-#   end
-#   getfield(x,f)
-# end
-
-# function Base.setproperty!(x::VariableNodeData, f::Symbol, val)
-#   if f == :softtype
-#       Base.depwarn("`VariableNodeData` field `softtype` is deprecated, use `variableType`", :getproperty)
-#     f = :variableType
-#   end
-#   return setfield!(x, f, convert(fieldtype(typeof(x), f), val))
-# end
-
-
-# function Base.getproperty(x::PackedVariableNodeData,f::Symbol)
-#   if f == :softtype
-#     Base.depwarn("`PackedVariableNodeData` field `softtype` is deprecated, use `variableType`", :getproperty)
-#     f = :variableType
-#   end
-#   getfield(x,f)
-# end
-
-# function Base.setproperty!(x::PackedVariableNodeData, f::Symbol, val)
-#   if f == :softtype
-#       Base.depwarn("`PackedVariableNodeData` field `softtype` is deprecated, use `variableType`", :getproperty)
-#   f = :variableType
-#   end
-#   return setfield!(x, f, convert(fieldtype(typeof(x), f), val))
-# end
-
-
-# function Base.getproperty(x::DFGVariableSummary,f::Symbol)
-#   if f == :softtypename
-#     Base.depwarn("`DFGVariableSummary` field `softtypename` is deprecated, use `variableTypeName`", :getproperty)
-#     f = :variableTypeName
-#   end
-#   getfield(x,f)
-# end
-
-# function Base.setproperty!(x::DFGVariableSummary, f::Symbol, val)
-#   if f == :softtypename
-#       Base.depwarn("`DFGVariableSummary` field `softtypename` is deprecated, use `variableTypeName`", :getproperty)
-#   f = :variableTypeName
-#   end
-#   return setfield!(x, f, convert(fieldtype(typeof(x), f), val))
-# end
-
-# @deprecate getSofttype(args...) getVariableType(args...)
-# @deprecate getSofttypename(args...) getVariableTypeName(args...)
-
 
 ## ================================================================================
 ## Deprecate before v0.17
@@ -271,5 +198,17 @@ end
 @deprecate VariableNodeData(val::Vector,bw::AbstractMatrix{<:Real},BayesNetOutVertIDs::AbstractVector{Symbol},dimIDs::AbstractVector{Int},dims::Int,eliminated::Bool,BayesNetVertID::Symbol,separator::AbstractVector{Symbol},variableType,initialized::Bool,inferdim::Real,w...;kw...) VariableNodeData(val,bw,BayesNetOutVertIDs,dimIDs,dims,eliminated,BayesNetVertID,separator,variableType,initialized,Float64[inferdim;],w...;kw...)
 
 
+## ================================================================================
+## Deprecate before v0.19
+##=================================================================================
+
+const FunctorInferenceType = AbstractFactor       # will eventually deprecate
+const PackedInferenceType = AbstractPackedFactor  # will eventually deprecate
+
+Base.promote_rule(::Type{DateTime}, ::Type{ZonedDateTime}) = DateTime
+function Base.convert(::Type{DateTime}, ts::ZonedDateTime)
+    @warn "DFG now uses ZonedDateTime, temporary promoting and converting to DateTime local time"
+    return DateTime(ts, Local)
+end
 
 #

src/entities/DFGFactor.jl

@@ -6,9 +6,6 @@
 abstract type AbstractFactor end
 abstract type AbstractPackedFactor end
 
-const FunctorInferenceType = AbstractFactor       # will eventually deprecate
-const PackedInferenceType = AbstractPackedFactor  # will eventually deprecate
-
 abstract type AbstractPrior <: AbstractFactor end
 abstract type AbstractRelative <: AbstractFactor end
 abstract type AbstractRelativeRoots <: AbstractRelative end
@@ -18,7 +15,7 @@ abstract type AbstractManifoldMinimize <: AbstractRelative end # FIXME move here
 # NOTE DF, Convolution is IIF idea, but DFG should know about "FactorOperationalMemory"
 # DF, IIF.CommonConvWrapper <: FactorOperationalMemory #
 # NOTE was `<: Function` as unnecessary
-abstract type FactorOperationalMemory end   # <: Function
+abstract type FactorOperationalMemory end
 # TODO to be removed from DFG,
 # we can add to IIF or have IIF.CommonConvWrapper <: FactorOperationalMemory directly
 # abstract type ConvolutionObject <: FactorOperationalMemory end
@@ -34,12 +31,12 @@ Notes
 - S::Symbol
 
 Designing (WIP)
-- T <: Union{FactorOperationalMemory, PackedInferenceType}
-- in IIF.CCW{T <: DFG.FunctorInferenceType}
-- in DFG.AbstractRelativeMinimize <: FunctorInferenceType
+- T <: Union{FactorOperationalMemory, AbstractPackedFactor}
+- in IIF.CCW{T <: DFG.AbstractFactor}
+- in DFG.AbstractRelativeMinimize <: AbstractFactor
 - in Main.SomeFactor <: AbstractRelativeMinimize
 """
-mutable struct GenericFunctionNodeData{T<:Union{<:PackedInferenceType, <:AbstractFactor, <:FactorOperationalMemory}}
+mutable struct GenericFunctionNodeData{T<:Union{<:AbstractPackedFactor, <:AbstractFactor, <:FactorOperationalMemory}}
     eliminated::Bool
     potentialused::Bool
     edgeIDs::Vector{Int}
@@ -85,9 +82,9 @@ const FunctionNodeData{T} = GenericFunctionNodeData{T} where T <: Union{<:Abstra
 FunctionNodeData(args...) = FunctionNodeData{typeof(args[4])}(args...)
 
 
-# PackedFunctionNodeData(x2, x3, x4, x6::T, multihypo::Vector{Float64}=[], certainhypo::Vector{Int}=Int[], x9::Int=0) where T <: PackedInferenceType =
+# PackedFunctionNodeData(x2, x3, x4, x6::T, multihypo::Vector{Float64}=[], certainhypo::Vector{Int}=Int[], x9::Int=0) where T <: AbstractPackedFactor =
 #     GenericFunctionNodeData{T}(x2, x3, x4, x6, multihypo, certainhypo, x9)
-# FunctionNodeData(x2, x3, x4, x6::T, multihypo::Vector{Float64}=[], certainhypo::Vector{Int}=Int[], x9::Int=0) where T <: Union{FunctorInferenceType, FactorOperationalMemory} =
+# FunctionNodeData(x2, x3, x4, x6::T, multihypo::Vector{Float64}=[], certainhypo::Vector{Int}=Int[], x9::Int=0) where T <: Union{AbstractFactor, FactorOperationalMemory} =
 #     GenericFunctionNodeData{T}(x2, x3, x4, x6, multihypo, certainhypo, x9)
 
 ##==============================================================================

src/services/AbstractDFG.jl

@@ -630,15 +630,15 @@ function ls(dfg::G, ::Type{T}) where {G <: AbstractDFG, T <: InferenceVariable}
 end
 
 
-function ls(dfg::G, ::Type{T}) where {G <: AbstractDFG, T <: FunctorInferenceType}
+function ls(dfg::G, ::Type{T}) where {G <: AbstractDFG, T <: AbstractFactor}
   xx = getFactors(dfg)
   names = typeof.(getFactorType.(xx)) .|> nameof
   vxx = view(xx, names .== Symbol(T))
   map(x->x.label, vxx)
 end
 
 
-function lsf(dfg::G, ::Type{T}) where {G <: AbstractDFG, T <: FunctorInferenceType}
+function lsf(dfg::G, ::Type{T}) where {G <: AbstractDFG, T <: AbstractFactor}
     ls(dfg, T)
 end
 
@@ -1104,7 +1104,7 @@ function isPathFactorsHomogeneous(dfg::AbstractDFG, from::Symbol, to::Symbol)
     (length(utyp) == 1), utyp
 end
 
-function existsPathOfFactorsType(dfg::AbstractDFG, from::Symbol, to::Symbol, ftype::FunctorInferenceType)
+function existsPathOfFactorsType(dfg::AbstractDFG, from::Symbol, to::Symbol, ftype::AbstractFactor)
   error("WIP")
 end
 

src/services/CompareUtils.jl

@@ -14,7 +14,7 @@ implement compare if needed.
 
 ==(a::FactorOperationalMemory, b::FactorOperationalMemory) = typeof(a) == typeof(b)
 
-==(a::FunctorInferenceType, b::FunctorInferenceType) = typeof(a) == typeof(b)
+==(a::AbstractFactor, b::AbstractFactor) = typeof(a) == typeof(b)
 
 
 # Generate compares automatically for all in this union

test/attic/IIF4DoorsTests.jl

@@ -58,7 +58,7 @@ addFactor!(fg,[:x5;:x6], LinearConditional( Normal(40.0,1.20)) )
 addVariable!(fg,:x7,ContinuousScalar, N=N)
 addFactor!(fg,[:x6;:x7], LinearConditional( Normal(60.0,2.0)) )
 
-# ensureAllInitialized!(fg)
+# initAll!(fg)
 
 mlc = MixturePrior(Normal.(doors[1,:], bws[1]), 0.25*ones(4))
 

test/iifCompareTests.jl

@@ -50,7 +50,7 @@ using Test
     @test compareFactorGraphs(fg, fg)
     @test !compareFactorGraphs(fg, fg2, skipsamples=false)
 
-    ensureAllInitialized!(fg2)
+    initAll!(fg2)
 
     @test compareSimilarVariables(fg, fg2, skipsamples=true, skip=Symbol[:initialized;:inferdim;:ppeDict;:solvedCount])
     # fg2 has been solved, so it should fail on the estimate dictionary

test/testBlocks.jl

@@ -34,7 +34,7 @@ struct TestAbstractPrior <: AbstractPrior end
 struct TestAbstractRelativeFactor <: AbstractRelativeRoots end
 struct TestAbstractRelativeFactorMinimize <: AbstractRelativeMinimize end
 
-struct PackedTestFunctorInferenceType1 <: PackedInferenceType
+struct PackedTestFunctorInferenceType1 <: AbstractPackedFactor
     s::String
 end
 PackedTestFunctorInferenceType1() = PackedTestFunctorInferenceType1("")
@@ -55,7 +55,7 @@ function Base.convert(::Type{TestFunctorInferenceType1}, d::PackedTestFunctorInf
 end
 
 
-struct PackedTestAbstractPrior <: PackedInferenceType
+struct PackedTestAbstractPrior <: AbstractPackedFactor
     s::String
 end
 PackedTestAbstractPrior() = PackedTestAbstractPrior("")
@@ -119,7 +119,7 @@ end
 #test Specific definitions
 # struct TestInferenceVariable1 <: InferenceVariable end
 # struct TestInferenceVariable2 <: InferenceVariable end
-# struct TestFunctorInferenceType1 <: FunctorInferenceType end
+# struct TestFunctorInferenceType1 <: AbstractFactor end
 
 # NOTE see note in AbstractDFG.jl setSolverParams!
 struct GeenSolverParams <: AbstractParams