Add docstrings

Author: nHackel

docs/make.jl

@@ -1,4 +1,4 @@
-using Documenter, Literate, AbstractImageReconstruction
+using Documenter, Literate, AbstractImageReconstruction, Observables
 
 # Generate examples
 OUTPUT_BASE = joinpath(@__DIR__(), "src/generated")
@@ -40,7 +40,7 @@ makedocs(
             "Caching" => "generated/howto/caching.md",
             "Observables" => "generated/howto/observables.md",
         ],
-        #"API Reference" => Any["Solvers" => "API/solvers.md",
+        "API Reference" => "API/api.md",
         #"Regularization Terms" => "API/regularization.md"],
 
     ],

docs/src/API/algorithm.md

@@ -0,0 +1,50 @@
+# API for Solvers
+This page contains documentation of the public API of the AbstractImageReconstruction. In the Julia
+REPL one can access this documentation by entering the help mode with `?`
+
+## Algorithm and Parameters
+```@docs
+AbstractImageReconstruction.AbstractImageReconstructionAlgorithm
+AbstractImageReconstruction.reconstruct
+Base.put!(::AbstractImageReconstructionAlgorithm, ::Any)
+Base.take!(::AbstractImageReconstructionAlgorithm)
+AbstractImageReconstruction.AbstractImageReconstructionParameters
+AbstractImageReconstruction.process
+AbstractImageReconstruction.parameter
+```
+
+## RecoPlan
+```@docs
+AbstractImageReconstruction.RecoPlan
+Base.propertynames(::RecoPlan)
+Base.getproperty(::RecoPlan, ::Symbol)
+Base.getindex(::RecoPlan, ::Symbol)
+Base.setproperty!(::RecoPlan, ::Symbol, ::Any)
+AbstractImageReconstruction.setAll!
+AbstractImageReconstruction.clear!
+Base.ismissing(::RecoPlan, ::Symbol)
+Observables.on(::Any, ::RecoPlan, ::Symbol)
+Observables.off(::RecoPlan, ::Symbol, ::Any)
+AbstractImageReconstruction.build
+AbstractImageReconstruction.toPlan
+AbstractImageReconstruction.savePlan
+AbstractImageReconstruction.loadPlan
+AbstractImageReconstruction.loadListener!
+AbstractImageReconstruction.parent(::RecoPlan)
+AbstractImageReconstruction.parent!(::RecoPlan, ::RecoPlan)
+AbstractImageReconstruction.parentproperty
+AbstractImageReconstruction.parentproperties
+```
+
+## Miscellaneous
+```@docs
+AbstractImageReconstruction.LinkedPropertyListener
+AbstractImageReconstruction.ProcessResultCache
+Base.hash(::AbstractImageReconstructionParameters, ::UInt64)
+AbstractImageReconstruction.toKwargs(::AbstractImageReconstructionParameters)
+AbstractImageReconstruction.fromKwargs
+AbstractImageReconstruction.toDict
+AbstractImageReconstruction.toDict!
+AbstractImageReconstruction.toDictValue
+AbstractImageReconstruction.toDictValue!
+```

docs/src/API/api.md

@@ -1,7 +1,7 @@
 # Small Reconstruction Package for Radon projections
-In this example we will implement a small image reconstruction package with the help of `AbstractImageReconstruction.jl`. Our example reconstruction package aims to provide direct and iterative reconstruction algorithms for Radon projection data. 
+In this example we will implement a small image reconstruction package using `AbstractImageReconstruction.jl`. Our reconstruction package `OurRadonreco` aims to provide direct and iterative reconstruction algorithms for Radon projection data. 
 
-Most of the desired functionality is already implemented in various Julia packages. Our reconstruction packages now needs to properly connect these packages and transform the data into the appropriate formats for each package. 
+Most of the desired functionality is already implemented in various Julia packages. Our reconstruction package now needs to properly link these packages and transform the data into the appropriate formats for each package. 
 
 !!! note
     The example is intended for developers of reconstruction packages that use `AbstractImageReconstruction`. End-users of such a package can consult the result sections of the example to see the high-level interface of `AbstractImagerReconstruction` and should otherwise consult the documentation of the concrete reconstruction package itself.
@@ -16,27 +16,27 @@ Pkg.add("AbstractImageReconstruction")
 This will download and install AbstractImageReconstruction.jl and its dependencies. To install a different version, please consult the [Pkg documentation](https://pkgdocs.julialang.org/dev/managing-packages/#Adding-packages). In addition to AbstractImageReconstruction.jl, we will need a few more packages to get started, which we can install the same way.
 
 
-[RadonKA.jl](https://github.com/roflmaostc/RadonKA.jl/tree/main) provides us with fast Radon forward and backprojections, which we can use for direct reconstructions and preparing example data for our package. 
+[RadonKA.jl](https://github.com/roflmaostc/RadonKA.jl/tree/main) provides us with fast Radon forward and backward projections, which we can use for direct reconstructions and to prepare sample data for our package.
 
-[LinearOperatorCollection.jl](https://github.com/JuliaImageRecon/LinearOperatorCollection.jl) wraps the functionality of RadonKA.jl in a matrix-free linear operator, which can be used in iterative solvers.
+[LinearOperatorCollection.jl](https://github.com/JuliaImageRecon/LinearOperatorCollection.jl) wraps the functionality of RadonKA.jl into a matrix-free linear operator, that can be used in iterative solvers.
 
-[RegularizedLeastSquares.jl](https://github.com/JuliaImageRecon/RegularizedLeastSquares.jl) offers a variety of iterative solver and regularization options.
+[RegularizedLeastSquares.jl](https://github.com/JuliaImageRecon/RegularizedLeastSquares.jl) offers a variety of iterative solvers and regularization options.
 
 [ImagePhantoms.jl](https://github.com/JuliaImageRecon/ImagePhantoms.jl) and [ImageGeoms.jl](https://github.com/JuliaImageRecon/ImageGeoms.jl) allow us to define digital software "phantoms", which we will use to test our reconstruction algorithms.
 
 Lastly, we will use [CairoMakie.jl](https://docs.makie.org/stable/) to visualize our results.
 
 ## Outline
-[Radon Data](generated/example/0_radon_data.md): In this section we get familiar with RadonKA.jl and define a small dataformat for three-dimensional time-series sinograms. We also create the inverse problem, which we want to solve in the remainder of the example.
+[Radon Data](generated/example/0_radon_data.md): this section we will familiarise ourselves with RadonKA.jl and define a small data format for three-dimensional time series sinograms. We also create the inverse problem that we will solve in the rest of the example
 
 [Interface](generated/example/1_interface.md): Here we define the abstract types we will use in our package and take a look at what we need to implement to interact with `AbstractImageReconstruction`. We also start with a first processing step of our algorithms.
 
 [Direct Reconstruction](generated/example/2_direct.md): Now we extend our abstract types with a concrete implementation of reconstruction algorithms using the backprojection and filtered backprojection.
 
-[Direct Reconstruction Result](generated/example/3_direct_result.md): This section shows how to use the algorithm we just implemented.
+[Direct Reconstruction Result](generated/example/3_direct_result.md): This section shows how to use the algorithm we have just implemented.
 
 [Iterative Reconstruction](generated/example/4_iterative.md): We finish our small example package by implementing an iterative reconstruction algorithm. For this algorithm we require more complex parametrization and data processing.
 
-[Iterative Reconstruction Result](generated/example/5_iterative_result.md): The last section again shows how to use the just implemented algorithm. But it also highlights `RecoPlans`, which are a core utility of `AbstractImageReconstruction`. These plans allow a user to easily configure, store and load algorithms as templates.
+[Iterative Reconstruction Result](generated/example/5_iterative_result.md): The last section shows again how to use the just implemented algorithm. But it also highlights `RecoPlans`, which are a core utility of `AbstractImageReconstruction`. These plans allow a user to easily configure, save and load algorithms as templates.
 
-For an even more indepth reconstruction package we refer to the magnetic particle imaging reconstruction package [MPIReco.jl](https://github.com/MagneticParticleImaging/MPIReco.jl).
+For an even more detailed reconstruction package we refer to the magnetic particle imaging reconstruction package [MPIReco.jl](https://github.com/MagneticParticleImaging/MPIReco.jl).

docs/src/API/plan.md

@@ -4,13 +4,14 @@
 
 ## Introduction
 
-AbstractImageReconstruction.jl is a Julia package that serves as the core API for medical imaging packages. It provides implementations an interface and type hierarchy with which one can represent and implement image reconstruction algorithms, their parameters and runtime behaviour. In particular, this package serves as the API of the Julia packages [MPIReco.jl](https://github.com/MagneticParticleImaging/MPIReco.jl).
+AbstractImageReconstruction.jl is a Julia package that serves as the core API for medical imaging packages. It provides implementations an interface and type hierarchy to represent and implement image reconstruction algorithms, their parameters and runtime behaviour. In particular, this package serves as the API of the Julia packages [MPIReco.jl](https://github.com/MagneticParticleImaging/MPIReco.jl).
 
 ## Features
-
+ 
+* Reconstruction control flow defined with multiple-dispatch on extensible and exchangable type hierarchies 
 * Storing, loading and manipulating of reconstruction algorithms with (partially) set parameters
-* Attaching callbacks to parameters changes with Observables.jl
-* Transparent caching of intermediate reconstruction results
+* Attaching callbacks to parameter changes with Observables.jl
+* Various generic utilities such as transparent caching of intermediate reconstruction results
 
 ## Installation
 
@@ -22,7 +23,8 @@ Pkg.add("AbstractImageReconstruction")
 AbstractImageReconstruction is not intended to be used alone, but together with an image reconstruction package that implements the provided interface, such as [MPIReco.jl](https://github.com/MagneticParticleImaging/MPIReco.jl).
 
 ## Usage
-Concrete construction of reconstruction algorithms depend on the implementation of the reconstruction package. Once an algorithms is constructed with the given paramters, images can be reconstructed as follows:
+The actual construction of reconstruction algorithms depends on the implementation of the reconstruction package. Once an algorithm is constructed with the given parameters, images can be reconstructed as follows:
+
 ```julia
 using AbstractImageReconstruction, MPIReco
 
@@ -32,7 +34,7 @@ raw = ... # Setup raw data
 
 image = reconstruct(algo, raw)
 ```
-Once an algorithm is constructed it can be transformed into a `RecoPlan`. These are mutable and transparent wrappers around the nested types of the algorithm and its paramters, that can be stored and restored to and from TOML files.
+An algorithm can be transformed into a `RecoPlan`. These are mutable and transparent wrappers around the nested types of the algorithm and its parameters, which can be saved and restored to and from TOML files.
 
 ```julia
 plan = toPlan(algo)
@@ -42,6 +44,6 @@ plan = loadPlan(MPIReco, "Example", [MPIReco, RegularizedLeastSquares, MPIFiles]
 algo2 = build(plan)
 algo == algo2 # true
 ```
-Unlike concrete algorithm instances, a `RecoPlan` may still be missing certain values of its fields and it can encode the structure of an image reconstruction algorithm without concrete parameterization.
+Unlike concrete algorithm instances, a `RecoPlan` may still be missing certain values of its properties. Futhermore, they can encode the structure of an image reconstruction algorithm without concrete parameterization.
 
-It is also possible to attach `Listeners` to `RecoPlan` fields, that call user-specified functions if they are changed. This allows specific `RecoPlans` to provide smart default paramter choices or embedding a plan into a GUI.
+It is also possible to attach functions to `RecoPlan` properties, that call user-specified functions if they are changed using `Observables.jl`. This allows specific `RecoPlans` to provide smart default parameter choices or embedding a plan into a GUI.

docs/src/example_intro.md

@@ -1,23 +1,23 @@
 # # Radon Data
 
-# In this example we will setup our Radon data using RadonKA.jl, ImagePhantoms.jl and ImageGeoms.jl. We will start with simple 2D images and their sinograms and move up to a time series of 3D images and sinograms.
+# In this example we will set up our radon data using RadonKA.jl, ImagePhantoms.jl and ImageGeoms.jl. We will start with simple 2D images and their sinograms and continue with a time series of 3D images and sinograms.
 
 # ## Background
-# The Radon transform is a integral transform which projects the values of a function(/or a phantom) along straight lines onto a detector.
+# The Radon transform is an integral transform that projects the values of a function(or a phantom) along straight lines onto a detector.
 # These projections are recorded for a number of different angles and form the so-called sinogram. The Radon transform and its adjoint form the mathematical basis
-# for Computed Tomography (CT) and other imaging modalities such as single photon emission computed tomography (SPECT) and positron emission tomography (PET).
+# for computed tomography (CT) and other imaging modalities such as single photon emission computed tomography (SPECT) and positron emission tomography (PET).
 
 # ## 2D Phantom
 # We will use a simple Shepp-Logan phantom to generate our Radon data. The phantom is a standard test image for medical imaging and consists of a number of ellipses with different intensities.
-# It can be generated with ImagePhantoms.jl and ImageGeoms.jl. as follows:
+# It can be generated using ImagePhantoms.jl and ImageGeoms.jl. as follows:
 
 using ImagePhantoms, ImageGeoms
 N = 256
 image = shepp_logan(N, SheppLoganToft())
 size(image)
 
 # This produces a 256x256 image of a Shepp-Logan phantom. Next, we will generate the Radon data using `radon` from RadonKA.jl.
-# The arguments of this function are image or phantom under transformation, the anlges at which the projections are taken, and the used geometry of the system. For this example we will use the default parallel circle geometry. 
+# The arguments of this function are the image or phantom to be transformed, the angles at which the projections are taken, and the used geometry of the system. For this example we will use the default parallel circle geometry. 
 # For more details, we refer to the RadonKA.jl documentation. We will use 256 angles for the projections, between 0 and π.
 using RadonKA
 angles = collect(range(0, π, 256))