Feature add nanosecond time to DFGVariable and DFGFactor (#478)

* Add nstime to DFGVariable and DFGFactor
* pack/unpack nstime

Author: Affie

src/entities/DFGFactor.jl

@@ -101,6 +101,8 @@ struct DFGFactor{T, N} <: AbstractDFGFactor
     """Variable timestamp.
     Accessors: [`getTimestamp`](@ref), [`setTimestamp`](@ref)"""
     timestamp::DateTime
+    """Nano second time, for more resolution on timestamp (only subsecond information)"""
+    nstime::Nanosecond
     """Factor tags, e.g [:FACTOR].
     Accessors: [`getTags`](@ref), [`mergeTags!`](@ref), and [`removeTags!`](@ref)"""
     tags::Set{Symbol}
@@ -113,15 +115,15 @@ struct DFGFactor{T, N} <: AbstractDFGFactor
     """Internal cache of the ordering of the neighbor variables. Rather use getVariableOrder to get the list as this is an internal value.
     Accessors: [`getVariableOrder`](@ref)"""
     _variableOrderSymbols::NTuple{N,Symbol}
-
     # Inner constructor
     DFGFactor{T}(label::Symbol,
                  timestamp::DateTime,
+                 nstime::Nanosecond,
                  tags::Set{Symbol},
                  solverData::GenericFunctionNodeData{T},
                  solvable::Int,
                  _variableOrderSymbols::NTuple{N,Symbol}) where {T,N} =
-                 new{T,N}(label, timestamp, tags, Ref(solverData), Ref(solvable), _variableOrderSymbols)
+                 new{T,N}(label, timestamp, nstime, tags, Ref(solverData), Ref(solvable), _variableOrderSymbols)
 
 end
 
@@ -135,24 +137,26 @@ Construct a DFG factor given a label.
 """
 DFGFactor(label::Symbol,
           timestamp::DateTime,
+          nstime::Nanosecond,
           tags::Set{Symbol},
           solverData::GenericFunctionNodeData{T},
           solvable::Int,
           _variableOrderSymbols::Tuple) where {T} =
-          DFGFactor{T}(label, timestamp, tags, solverData, solvable, _variableOrderSymbols)
+          DFGFactor{T}(label, timestamp, nstime, tags, solverData, solvable, _variableOrderSymbols)
 
 
 DFGFactor{T}(label::Symbol, variableOrderSymbols::Vector{Symbol}, timestamp::DateTime=now(), data::GenericFunctionNodeData{T} = GenericFunctionNodeData{T}()) where {T} =
-                DFGFactor(label, timestamp, Set{Symbol}(), data, 1, Tuple(variableOrderSymbols))
+                DFGFactor(label, timestamp, Nanosecond(0), Set{Symbol}(), data, 1, Tuple(variableOrderSymbols))
 
 
 DFGFactor(label::Symbol,
           variableOrderSymbols::Vector{Symbol},
           data::GenericFunctionNodeData{T};
           tags::Set{Symbol}=Set{Symbol}(),
           timestamp::DateTime=now(),
-          solvable::Int=1) where {T} =
-                DFGFactor{T}(label, timestamp, tags, data, solvable, Tuple(variableOrderSymbols))
+          solvable::Int=1,
+          nstime::Nanosecond = Nanosecond(0)) where {T} =
+                DFGFactor{T}(label, timestamp, nstime, tags, data, solvable, Tuple(variableOrderSymbols))
 
 
 

src/entities/DFGVariable.jl

@@ -185,6 +185,8 @@ struct DFGVariable{T<:InferenceVariable} <: AbstractDFGVariable
     """Variable timestamp.
     Accessors: [`getTimestamp`](@ref), [`setTimestamp`](@ref)"""
     timestamp::DateTime
+    """Nano second time, for more resolution on timestamp (only subsecond information)"""
+    nstime::Nanosecond
     """Variable tags, e.g [:POSE, :VARIABLE, and :LANDMARK].
     Accessors: [`getTags`](@ref), [`mergeTags!`](@ref), and [`removeTags!`](@ref)"""
     tags::Set{Symbol}
@@ -214,24 +216,26 @@ The default DFGVariable constructor.
 """
 DFGVariable(label::Symbol, softtype::T;
             timestamp::DateTime=now(),
+            nstime::Nanosecond = Nanosecond(0),
             tags::Set{Symbol}=Set{Symbol}(),
             estimateDict::Dict{Symbol, <: AbstractPointParametricEst}=Dict{Symbol, MeanMaxPPE}(),
             solverDataDict::Dict{Symbol, VariableNodeData{T}}=Dict{Symbol, VariableNodeData{T}}(),
             smallData::Dict{String, String}=Dict{String, String}(),
             bigData::Dict{Symbol, AbstractBigDataEntry}=Dict{Symbol,AbstractBigDataEntry}(),
             solvable::Int=1) where {T <: InferenceVariable} =
-    DFGVariable{T}(label, timestamp, tags, estimateDict, solverDataDict, smallData, bigData, Ref(solvable))
+    DFGVariable{T}(label, timestamp, nstime, tags, estimateDict, solverDataDict, smallData, bigData, Ref(solvable))
 
 
 DFGVariable(label::Symbol,
             solverData::VariableNodeData{T};
             timestamp::DateTime=now(),
+            nstime::Nanosecond = Nanosecond(0),
             tags::Set{Symbol}=Set{Symbol}(),
             estimateDict::Dict{Symbol, <: AbstractPointParametricEst}=Dict{Symbol, MeanMaxPPE}(),
             smallData::Dict{String, String}=Dict{String, String}(),
             bigData::Dict{Symbol, AbstractBigDataEntry}=Dict{Symbol,AbstractBigDataEntry}(),
             solvable::Int=1) where {T <: InferenceVariable} =
-    DFGVariable{T}(label, timestamp, tags, estimateDict, Dict{Symbol, VariableNodeData{T}}(:default=>solverData), smallData, bigData, Ref(solvable))
+    DFGVariable{T}(label, timestamp, nstime, tags, estimateDict, Dict{Symbol, VariableNodeData{T}}(:default=>solverData), smallData, bigData, Ref(solvable))
 
 Base.getproperty(x::DFGVariable,f::Symbol) = begin
     if f == :solvable
@@ -251,11 +255,12 @@ end
 
 
 ##------------------------------------------------------------------------------
-function Base.copy(o::DFGVariable)::DFGVariable
-    return DFGVariable(o.label, getSofttype(o)(), tags=copy(o.tags), estimateDict=copy(o.estimateDict),
-                        solverDataDict=copy(o.solverDataDict), smallData=copy(o.smallData),
-                        bigData=copy(o.bigData), solvable=getSolvable(o))
-end
+# TODO: can't see the reason to overwrite copy, leaving it here for now
+# function Base.copy(o::DFGVariable)::DFGVariable
+#     return DFGVariable(o.label, getSofttype(o)(), tags=copy(o.tags), estimateDict=copy(o.estimateDict),
+#                         solverDataDict=copy(o.solverDataDict), smallData=copy(o.smallData),
+#                         bigData=copy(o.bigData), solvable=getSolvable(o))
+# end
 
 ##------------------------------------------------------------------------------
 ## DFGVariableSummary lv1

src/services/AbstractDFG.jl

@@ -394,7 +394,7 @@ function addFactor!(dfg::AbstractDFG, variables::Vector{<:AbstractDFGVariable},
 
     if factor isa DFGFactor
         f = factor
-        newfactor =  DFGFactor(f.label, f.timestamp, f.tags, f.solverData, f.solvable, Tuple(variableLabels))
+        newfactor =  DFGFactor(f.label, f.timestamp, f.nstime, f.tags, f.solverData, f.solvable, Tuple(variableLabels))
         return addFactor!(dfg, newfactor)
     else
         resize!(factor._variableOrderSymbols, length(variableLabels))
@@ -413,7 +413,7 @@ function addFactor!(dfg::AbstractDFG, variableLabels::Vector{Symbol}, factor::F)
 
     if factor isa DFGFactor
         f = factor
-        newfactor =  DFGFactor(f.label, f.timestamp, f.tags, f.solverData, f.solvable, Tuple(variableLabels))
+        newfactor =  DFGFactor(f.label, f.timestamp, f.nstime, f.tags, f.solverData, f.solvable, Tuple(variableLabels))
         return addFactor!(dfg, newfactor)
     else
         resize!(factor._variableOrderSymbols, length(variableLabels))

src/services/DFGFactor.jl

@@ -69,7 +69,7 @@ end
 
 
 function setTimestamp(f::DFGFactor, ts::DateTime)
-    return DFGFactor(f.label, ts, f.tags, f.solverData, f.solvable, getfield(f,:_variableOrderSymbols))
+    return DFGFactor(f.label, ts, f.nstime, f.tags, f.solverData, f.solvable, getfield(f,:_variableOrderSymbols))
 end
 
 function setTimestamp(f::DFGFactorSummary, ts::DateTime)

src/services/DFGVariable.jl

@@ -166,7 +166,7 @@ function setTimestamp(v::DFGVariable, ts::DateTime; verbose::Bool=true)
     if verbose
         @warn "verbose=true: setTimestamp(::DFGVariable,...) creates a returns a new immutable DFGVariable object (and didn't change a distributed factor graph object), make sure you are using the right pointers: getVariable(...).  See setTimestamp!(...) and note suggested use is at addVariable!(..., [timestamp=...]).  See DFG #315 for explanation."
     end
-    return DFGVariable(v.label, ts, v.tags, v.ppeDict, v.solverDataDict, v.smallData, v.bigData, Ref(v.solvable))
+    return DFGVariable(v.label, ts, v.nstime, v.tags, v.ppeDict, v.solverDataDict, v.smallData, v.bigData, Ref(v.solvable))
 end
 
 function setTimestamp(v::DFGVariableSummary, ts::DateTime; verbose::Bool=true)

src/services/Serialization.jl

@@ -9,6 +9,7 @@ function packVariable(dfg::G, v::DFGVariable)::Dict{String, Any} where G <: Abst
     props = Dict{String, Any}()
     props["label"] = string(v.label)
     props["timestamp"] = string(v.timestamp)
+    props["nstime"] = string(v.nstime.value)
     props["tags"] = JSON2.write(v.tags)
     props["ppeDict"] = JSON2.write(v.ppeDict)
     props["solverDataDict"] = JSON2.write(Dict(keys(v.solverDataDict) .=> map(vnd -> packVariableNodeData(dfg, vnd), values(v.solverDataDict))))
@@ -23,6 +24,7 @@ end
 function unpackVariable(dfg::G, packedProps::Dict{String, Any})::DFGVariable where G <: AbstractDFG
     label = Symbol(packedProps["label"])
     timestamp = DateTime(packedProps["timestamp"])
+    nstime = Nanosecond(get(packedProps, "nstime", 0))
     tags =  JSON2.read(packedProps["tags"], Vector{Symbol})
     #TODO this will work for some time, but unpacking in an <: AbstractPointParametricEst would be lekker.
     ppeDict = JSON2.read(packedProps["ppeDict"], Dict{Symbol, MeanMaxPPE})
@@ -37,7 +39,7 @@ function unpackVariable(dfg::G, packedProps::Dict{String, Any})::DFGVariable whe
     solverData = Dict(Symbol.(keys(packed)) .=> map(p -> unpackVariableNodeData(dfg, p), values(packed)))
 
     # Rebuild DFGVariable using the first solver softtype in solverData
-    variable = DFGVariable{softtype}(Symbol(packedProps["label"]), timestamp, Set(tags), ppeDict, solverData,  smallData, Dict{Symbol,AbstractBigDataEntry}(), Ref(packedProps["solvable"]))
+    variable = DFGVariable{softtype}(Symbol(packedProps["label"]), timestamp, nstime, Set(tags), ppeDict, solverData,  smallData, Dict{Symbol,AbstractBigDataEntry}(), Ref(packedProps["solvable"]))
 
     # Now rehydrate complete bigData type.
     for (k,bdeInter) in bigDataIntermed
@@ -96,6 +98,7 @@ function packFactor(dfg::G, f::DFGFactor)::Dict{String, Any} where G <: Abstract
     props = Dict{String, Any}()
     props["label"] = string(f.label)
     props["timestamp"] = string(f.timestamp)
+    props["nstime"] = string(f.nstime.value)
     props["tags"] = JSON2.write(f.tags)
     # Pack the node data
     fnctype = getSolverData(f).fnc.usrfnc!
@@ -132,6 +135,7 @@ end
 function unpackFactor(dfg::G, packedProps::Dict{String, Any})::DFGFactor where G <: AbstractDFG
     label = packedProps["label"]
     timestamp = DateTime(packedProps["timestamp"])
+    nstime = Nanosecond(get(packedProps, "nstime", 0))
     tags = JSON2.read(packedProps["tags"], Vector{Symbol})
 
     data = packedProps["data"]
@@ -161,6 +165,7 @@ function unpackFactor(dfg::G, packedProps::Dict{String, Any})::DFGFactor where G
     #TODO use constuctor to create factor
     factor = DFGFactor(Symbol(label),
                        timestamp,
+                       nstime,
                        Set(tags),
                        fullFactorData,
                        solvable,

test/interfaceTests.jl

@@ -49,14 +49,14 @@ end
     @test printVariable(var1) == nothing
     @test printFactor(fac1) == nothing
 
-    @test printVariable(iobuf, var1, skipfields=[:timestamp, :solver, :ppe]) == nothing
+    @test printVariable(iobuf, var1, skipfields=[:timestamp, :solver, :ppe, :nstime]) == nothing
     @test String(take!(iobuf)) == "DFGVariable{TestSofttype1}\nlabel:\n:a\ntags:\nSet([:VARIABLE, :POSE])\nsmallData:\nDict(\"small\"=>\"data\")\nbigData:\nDict{Symbol,AbstractBigDataEntry}()\nsolvable:\n0\n"
 
     @test printVariable(iobuf, var1, short=true) == nothing
     @test String(take!(iobuf)) == "DFGVariable{TestSofttype1}\nlabel: a\ntags: Set([:VARIABLE, :POSE])\nsize marginal samples: (1, 1)\nkde bandwidths: [0.0]\nNo PPEs\n"
 
 
-    @test printFactor(iobuf, fac1, skipfields=[:timestamp, :solver]) == nothing
+    @test printFactor(iobuf, fac1, skipfields=[:timestamp, :solver, :nstime]) == nothing
     @test occursin(r"DFGFactor.*\nlabel:\n:abf1", String(take!(iobuf)))
 
     String(take!(iobuf)) == "DFGFactor{TestCCW{TestFunctorInferenceType1}}\nlabel:\n:abf1\ntags:\nSet([:tag1, :tag2])\nsolvable:\n0\nsolvable:\n1\n_variableOrderSymbols:\n[:a, :b]\n"

test/testBlocks.jl

@@ -410,7 +410,7 @@ function  VariablesandFactorsCRUD_SET!(fg, v1, v2, v3, f0, f1, f2)
 
 
 if f2 isa DFGFactor
-    f2_mod = DFGFactor(f2.label, f2.timestamp, f2.tags, f2.solverData, f2.solvable, (:a,))
+    f2_mod = DFGFactor(f2.label, f2.timestamp, f2.nstime, f2.tags, f2.solverData, f2.solvable, (:a,))
 else
     f2_mod =  deepcopy(f2)
     pop!(f2_mod._variableOrderSymbols)