API for Solvers

AbstractImageReconstructionAlgorithm

Abstract type for image reconstruction algorithms. Must implement put! and take! functions. Serialization expects a constructor with a single AbstractImageReconstructionParameters argument.

reconstruct(algo::T, u) where {T<:AbstractImageReconstructionAlgorithm}

Reconstruct an image from input u using algorithm algo. The àlgo will be locked until the result is available or an error occurs.

put!(algo::AbstractImageReconstructionAlgorithm, inputs...)

Perform image reonstruction with algorithm algo on given ìnputs. Depending on the algorithm this might block. Result is stored and can be retrieved with take!.

take!(algo::AbstractImageReconstructionAlgorithm)

Remove and return a stored result from the algorithm algo. Blocks until a result is available.

lock(algo::AbstractImageReconstructionAlgorithm)

Acquire a lock on the algorithm algo. If the lock is already acquired, wait until it is released.

Each lock must be matched with a unlock.

unlock(algo::AbstractImageReconstructionAlgorithm)

Release a lock on the algorithm algo.

isready(algo::AbstractImageReconstructionAlgorithm)

Determine if the algorithm algo has a result available.

wait(algo::AbstractImageReconstructionAlgorithm)

Wait for a result to be available from the specified algo.

AbstractImageReconstructionParameters

Abstract type for image reconstruction parameters. An algorithm consists of one ore more process steps, each can have its own parameters. Parameters can be arbitrarly nested.

process(algo::Union{A, Type{A}}, param::AbstractImageReconstructionParameters, inputs...) where A <: AbstractImageReconstructionAlgorithm

Process inputs with algorithm algo and parameters param. Returns the result of the processing step. If not implemented for an instance of algo, the default implementation is called with the type of algo.

parameter(algo::AbstractImageReconstructionAlgorithm)

Return the parameters of the algorithm algo.

parameter(param::AbstractUtilityReconstructionParameters)

Return the wrapped parameter. Can themselves be utility parameters again

RecoPlan{T <: Union{AbstractImageReconstructionParameters, AbstractImageReconstructionAlgorithm}}

Configuration template for an image reconstruction algorithm or paremeters of type T. A RecoPlan{T} has the same properties with type checking as T with the exception that properties can be missing and nested algorithms and parameters can again be RecoPlans.

Plans can be nested and form a tree. A parent plan can be accessed with parent and set with parent!. Algorithms and parameters can be converted to a plan with toPlan.

Plans feature serialization with toTOML, toPlan and loadPlan and the ability to attach callbacks to property changes with Òbservables and on.

propertynames(plan::RecoPlan{T}) where {T}

Return a tupel of configurable properties of T. Unlike propertynames(T) this does not include properties starting with _.

getproperty(plan::RecoPlan{T}, name::Symbol) where {T}

Get the property name of plan. Equivalent to plan.name.

getindex(plan::RecoPlan{T}, name::Symbol) where {T}

Return the Observable for the name property of plan. Equivalent to plan[name].

setproperty!(plan::RecoPlan{T}, name::Symbol, x::X) where {T, X}

Set the property name of plan to x. Equivalent to plan.name = x. Triggers callbacks attached to the property.

setAll!(plan::RecoPlan{T}, name::Symbol, x) where {T<:AbstractImageReconstructionParameters}

Recursively set the property name of each nested RecoPlan of plan to x.

setAll!(plan::AbstractRecoPlan; kwargs...)

Call setAll! with each given keyword argument.

setAll!(plan::AbstractRecoPlan, dict::Union{Dict{Symbol, Any}, Dict{String, Any}})

Call setAll! with each entries of the dict.

clear!(plan::RecoPlan{T}, preserve::Bool = true) where {T<:AbstractImageReconstructionParameters}

Clear all properties of plan. If preserve is true, nested RecoPlans are preserved.

ismissing(plan::RecoPlan, name::Symbol)

Indicate if the property name of plan is missing.

on(f, plan::RecoPlan, property::Symbol; kwargs...)

Adds function f as listener to property of plan. The function is called whenever the property is changed with setproperty!.

off(plan::RecoPlan, property::Symbol, f)

Remove f from the listeners of property of plan.

build(plan::RecoPlan{T}) where {T}

Recursively build a plan from a RecoPlan by converting all properties to their actual values using keyword argument constructors.

toPlan(param::Union{AbstractImageReconstructionParameters, AbstractImageReconstructionAlgorithm})

Convert an AbstractImageReconstructionParameters or AbstractImageReconstructionAlgorithm to a (nested) RecoPlan.

savePlan(file::Union{AbstractString, IO}, plan::RecoPlan)

Save the plan to the file in TOML format. See also loadPlan, toTOML, toDict.

loadPlan(filename::Union{AbstractString, IO}, modules::Vector{Module})

Load a RecoPlan from a TOML file. The modules argument is a vector of modules that contain the types used in the plan. After loading the plan, the listeners are attached to the properties using loadListener!.

loadListener!(plan, name::Symbol, dict, modDict)

Load a listener from dict and attach it to property name of plan

parent(plan::RecoPlan)

Return the parent of plan.

parent!(plan::RecoPlan, parent::RecoPlan)

Set the parent of plan to parent.

parentproperty(plan::RecoPlan)

Return the property name of plan in its parent, s.t. getproperty(parent(plan), parentproperty(plan)) === plan. Return nothing if plan has no parent.

parentproperties(plan::RecoPlan)

Return a vector of property names of plan in its parent, s.t. getproperty(parent(plan), last(parentproperties(plan))) === plan. Return an empty vector if plan has no parent.

LinkedPropertyListener(fn, target::RecoPlan, targetProp, source::RecoPlan, sourceProp)

Connect two properties of RecoPlans. Set target.targetProp to fn(source.sourceProp) whenever source.sourceProp changes and target.targetProp was not changed outside of the listener.

ProcessResultCache(params::AbstractImageReconstructionParameters; maxsize = 1, kwargs...)

Cache of size maxsize for the result of process methods. The cache is based on the hash of the inputs of the process function. Cache is shared between all algorithms constructed from the same plan. The cache is transparent for properties of the underlying parameter. Cache can be invalidated by calling empty! on the cache.

hash(parameter::AbstractImageReconstructionParameters, h)

Default hash function for image reconstruction paramters. Uses nameof the parameter and all fields not starting with _ to compute the hash.

toKwargs(value::AbstractImageReconstructionParameters; kwargs...)

Convert a AbstractImageReconstructionParameters to a Dict{Symbol, Any} of each property.

Optional keyword arguments:

• flatten::Vector{DataType}: Types to flatten, per default only AbstractImageReconstructionParameters are flattened.
• ignore::Vector{Symbol}: Properties to ignore.
• default::Dict{Symbol, Any}: Default values for properties that are missing.
• overwrite::Dict{Symbol, Any}: Overwrite values for properties.

fromKwargs(type::Type{T}; kwargs...) where {T}

Create a new instance of type from the keyword arguments. Only properties that are part of type are considered.

toDict(value)

Recursively convert value to a Dict{String, Any} using toDict!.

toDict!(dict, value)

Extracts metadata such as the module and type name from value and adds it to dict. The value-representation of value is added using toDictValue!.

toDictValue(value)

Transform value to a value-representation in a dict that can later be serialized as a TOML file.

toDictValue!(dict, value)

Extracts the value-representation of value and adds it to dict. The default implementation for structs with fields adds each field of the argument as a key-value pair with the value being provided by the toDictValue function.

toDictValue!(dict, plan::RecoPlan)

Adds the properties of plan to dict using toDictValue for each not missing field. Additionally, adds each listener::AbstractPlanListener to the dict.