Merge pull request #1022 from JuliaRobotics/23Q3/enh/dropabsrelroots

drop AbstractRelativeRoots

Author: dehann

src/DataBlobs/entities/BlobEntry.jl

@@ -24,7 +24,7 @@ Notes:
     label::Symbol
     """ A hint about where the `Blob` itself might be stored.  Remember that a Blob may be duplicated over multiple blobstores. """
     blobstore::Symbol
-    """ A hash value to ensure data consistency which must correspond to the stored hash upon retrieval.  [Legacy: some usage functions allow the check to be skipped if needed.] """
+    """ A hash value to ensure data consistency which must correspond to the stored hash upon retrieval.  Use `bytes2hex(sha256(blob))`. [Legacy: some usage functions allow the check to be skipped if needed.] """
     hash::String # Probably https://docs.julialang.org/en/v1/stdlib/SHA
     """ Context from which a BlobEntry=>Blob was first created. E.g. user|robot|session|varlabel. """
     origin::String 
@@ -43,7 +43,7 @@ Notes:
     """ Use carefully, but necessary to support advanced usage such as time synchronization over Blob data. """
     lastUpdatedTimestamp::Union{ZonedDateTime,Nothing} = nothing
     """ Self type declaration for when duck-typing happens. """
-    _type::String = "BlobEntry"
+    _type::String = "DistributedFactorGraph.BlobEntry"
     """ Type version of this BlobEntry. TBD.jl consider upgrading to `::VersionNumber`. """
     _version::String = string(_getDFGVersion())
 end

src/DistributedFactorGraphs.jl

@@ -224,7 +224,7 @@ export packBlob, unpackBlob
 # Factor Data
 export GenericFunctionNodeData, PackedFunctionNodeData, FunctionNodeData
 export AbstractFactor, AbstractPackedFactor
-export AbstractPrior, AbstractRelative, AbstractRelativeRoots, AbstractRelativeMinimize, AbstractManifoldMinimize
+export AbstractPrior, AbstractRelative, AbstractRelativeMinimize, AbstractManifoldMinimize
 export FactorOperationalMemory
 
 # accessors

src/entities/DFGFactor.jl

@@ -8,9 +8,9 @@ abstract type AbstractPackedFactor end
 
 abstract type AbstractPrior <: AbstractFactor end
 abstract type AbstractRelative <: AbstractFactor end
-abstract type AbstractRelativeRoots <: AbstractRelative end    # NOTE Cannot be used for partials
+# abstract type AbstractRelativeRoots <: AbstractRelative end    # TODO deprecate
 abstract type AbstractRelativeMinimize <: AbstractRelative end
-abstract type AbstractManifoldMinimize <: AbstractRelative end # FIXME move here from IIF
+abstract type AbstractManifoldMinimize <: AbstractRelative end
 
 # NOTE DF, Convolution is IIF idea, but DFG should know about "FactorOperationalMemory"
 # DF, IIF.CommonConvWrapper <: FactorOperationalMemory #

src/services/AbstractDFG.jl

@@ -950,20 +950,22 @@ Related:
 - [`getNeighborhood`](@ref)
 - [`mergeGraph!`](@ref)
 """
-function copyGraph!(destDFG::AbstractDFG,
-                    sourceDFG::AbstractDFG,
-                    variableLabels::Vector{Symbol},
-                    factorLabels::Vector{Symbol};
-                    copyGraphMetadata::Bool=false,
-                    overwriteDest::Bool=false,
-                    deepcopyNodes::Bool=false,
-                    verbose::Bool = false)
+function copyGraph!(
+    destDFG::AbstractDFG,
+    sourceDFG::AbstractDFG,
+    variableLabels::AbstractVector{Symbol}=listVariables(sourceDFG),
+    factorLabels::AbstractVector{Symbol}=listFactors(sourceDFG);
+    copyGraphMetadata::Bool=false,
+    overwriteDest::Bool=false,
+    deepcopyNodes::Bool=false,
+    verbose::Bool = false
+)
     # Split into variables and factors
     sourceVariables = map(vId->getVariable(sourceDFG, vId), variableLabels)
     sourceFactors = map(fId->getFactor(sourceDFG, fId), factorLabels)
 
     # Now we have to add all variables first,
-    for variable in sourceVariables
+    @showprogress "copy variables" for variable in sourceVariables
         variableCopy = deepcopyNodes ? deepcopy(variable) : variable
         if !exists(destDFG, variable)
             addVariable!(destDFG, variableCopy)
@@ -974,7 +976,7 @@ function copyGraph!(destDFG::AbstractDFG,
         end
     end
     # And then all factors to the destDFG.
-    for factor in sourceFactors
+    @showprogress "copy factors" for factor in sourceFactors
         # Get the original factor variables (we need them to create it)
         sourceFactorVariableIds = collect(factor._variableOrderSymbols)
         # Find the labels and associated variables in our new subgraph

src/services/CompareUtils.jl

@@ -33,12 +33,13 @@ end
 ## Compare
 ##==============================================================================
 
-function compareField(Allc, Bllc, syms)::Bool
+function compareField(Allc, Bllc, syms)
     (!isdefined(Allc, syms) && !isdefined(Bllc, syms)) && return true
     !isdefined(Allc, syms) && return false
     !isdefined(Bllc, syms) && return false
     a = getproperty(Allc, syms)
     b = getproperty(Bllc, syms)
+    @debug "Comparing field directly a vs b" syms a b 
     if a isa Base.RefValue
       return a[] == b[]
     else
@@ -72,23 +73,23 @@ end
 function compareFields( Al::T,
                         Bl::T;
                         show::Bool=true,
-                        skip::Vector{Symbol}=Symbol[]  )::Bool where {T <: Union{Number, AbstractString}}
+                        skip::Vector{Symbol}=Symbol[]  ) where {T <: Union{Number, AbstractString}}
   #
   return Al == Bl
 end
 
 function compareAll(Al::T,
                     Bl::T;
                     show::Bool=true,
-                    skip::Vector{Symbol}=Symbol[]  )::Bool where {T <: Union{AbstractString,Symbol}}
+                    skip::Vector{Symbol}=Symbol[]  ) where {T <: Union{AbstractString,Symbol}}
   #
   return Al == Bl
 end
 
 function compareAll(Al::T,
                     Bl::T;
                     show::Bool=true,
-                    skip::Vector{Symbol}=Symbol[]  )::Bool where {T <: Union{Array{<:Number}, Number}}
+                    skip::Vector{Symbol}=Symbol[]  ) where {T <: Union{Array{<:Number}, Number}}
   #
   (length(Al) != length(Bl)) && return false
   return norm(Al - Bl) < 1e-6
@@ -97,7 +98,7 @@ end
 function compareAll(Al::T,
                     Bl::T;
                     show::Bool=true,
-                    skip::Vector{Symbol}=Symbol[]  )::Bool where {T <: Array}
+                    skip::Vector{Symbol}=Symbol[]  ) where {T <: Array}
   #
   (length(Al) != length(Bl)) && return false
   for i in 1:length(Al)
@@ -131,7 +132,7 @@ end
 function compareAll(Al::T,
                     Bl::T;
                     show::Bool=true,
-                    skip::Vector{Symbol}=Symbol[]  )::Bool where {T <: Dict}
+                    skip::Vector{Symbol}=Symbol[]  ) where {T <: Dict}
   #
   (length(Al) != length(Bl)) && return false
   for (id, val) in Al

test/testBlocks.jl

@@ -32,7 +32,7 @@ struct TestFunctorInferenceType1 <: AbstractRelative end
 struct TestFunctorInferenceType2 <: AbstractRelative end
 
 struct TestAbstractPrior <: AbstractPrior end
-struct TestAbstractRelativeFactor <: AbstractRelativeRoots end
+# struct TestAbstractRelativeFactor <: AbstractRelativeRoots end
 struct TestAbstractRelativeFactorMinimize <: AbstractRelativeMinimize end
 
 Base.@kwdef struct PackedTestFunctorInferenceType1 <: AbstractPackedFactor