Finish initial docs

Author: nHackel

docs/make.jl

@@ -15,36 +15,43 @@ for (root, dirs, files) in walkdir(INPUT_BASE)
     end
 end
 
+modules = [LinearOperatorCollection,
+            isdefined(Base, :get_extension) ? Base.get_extension(LinearOperatorCollection, :LinearOperatorFFTWExt) : LinearOperatorCollection.LinearOperatorFFTWExt,
+            isdefined(Base, :get_extension) ? Base.get_extension(LinearOperatorCollection, :LinearOperatorNFFTExt) : LinearOperatorCollection.LinearOperatorNFFTExt,
+            isdefined(Base, :get_extension) ? Base.get_extension(LinearOperatorCollection, :LinearOperatorRadonKAExt) : LinearOperatorCollection.LinearOperatorRadonKAExt,
+            isdefined(Base, :get_extension) ? Base.get_extension(LinearOperatorCollection, :LinearOperatorWaveletExt) : LinearOperatorCollection.LinearOperatorWaveletExt]
+
 makedocs(
     format = Documenter.HTML(prettyurls=get(ENV, "CI", "false") == "true",
         canonical="https://github.com/JuliaImageRecon/LinearOperatorCollection.jl",
         assets=String[],
         collapselevel=1,
     ),
-    modules = [LinearOperatorCollection],
+    modules = modules,
     sitename = "LinearOperatorCollection",
     authors = "Tobias Knopp, Niklas Hackelberg and Contributors",
     pages = [
         "Home" => "index.md",
         "Getting Started" => "generated/tutorials/overview.md",
         "Tutorials" => Any[
             "Weighting Operator" => "generated/tutorials/weighting.md",
-            "Product Operator" => "generated/tutorials/product.md",
+            "FFT Operator" => "generated/tutorials/fft.md",
             "Diagonal Operator" => "generated/tutorials/diagonal.md",
             "Gradient Operator" => "generated/tutorials/gradient.md",
-            "Normal Operator" => "generated/tutorials/normal.md",
-            "FFT Operator" => "generated/tutorials/fft.md",
-            "NFFT Operator" => "generated/tutorials/nfft.md",
+            #"Sampling Operator" => "generated/tutorials/sampling.md",
+            #"NFFT Operator" => "generated/tutorials/nfft.md",
             "Wavelet Operator" => "generated/tutorials/wavelet.md",
-            "Radon Operator" => "generated/tutorials/radon.md"
+            "Radon Operator" => "generated/tutorials/radon.md",
+            "Product Operator" => "generated/tutorials/product.md",
+            "Normal Operator" => "generated/tutorials/normal.md",
         ],
         "How to" => Any[
-            "Implement Custom Operators" => "generated/howtos/custom.md",
+            #"Implement Custom Operators" => "generated/howtos/custom.md",
             "Enable GPU Acceleration" => "generated/howtos/gpu.md",
         ],
-        "Explanations" => Any[
-            "Operator Structure" => "operators.md",
-        ],
+        #"Explanations" => Any[
+        #    "Operator Structure" => "operators.md",
+        #],
         "Reference" => "references.md"
     ],
     warnonly = [:missing_docs]

docs/src/index.md

@@ -3,7 +3,7 @@
 *Collection of linear operators for multi-dimensional signal and imaging tasks*
 
 
-## Purpose
+## Introduction
 
 This package contains a collection of linear operators that are particularly useful for multi-dimensional signal and image processing tasks. Linear operators or linear maps behave like matrices in a matrix-vector product, but aren't necessarily matrices themselves. They can utilize more effective algorithms and can defer their computation until they are multiplied with a vector.
 

docs/src/literate/howots/custom.jl

@@ -0,0 +1,2 @@
+# # Implement Custom Operators
+# There are two different ways one can implement a custom LinearOperator. The first one is to directly implement an operator as a LinearOperator from LinearOperators.jl:

docs/src/literate/howots/gpu.jl

@@ -0,0 +1,19 @@
+# # GPU Acceleration
+include("../../util.jl") #hide
+# GPU kernels generally require all their arguments to exist on the GPU. This is not ncessarily the case for matrix-free operators as provides LinearOperators or LinearOperatorCollection.
+# In the case that a matrix free operator is solely a function call and contains no internal array state, the operator is GPU compatible as long as the method has a GPU compatible implementation.
+
+# If the operator has internal fields required for its computation, such as temporary arrays for intermediate values or indices, then it needs to move those to the GPU.
+# Furthermore if the operator needs to create a new array in its execution, e.g. it is used in a non-inplace matrix-vector multiplication or it is combined with other operators, then the operator needs to specify
+# a storage type. LinearOperatorCollection has several GPU compatible operators, where the storage type is given by setting a `S` parameter:
+# ```julia
+# using CUDA # or AMDGPU, Metal, ...
+# image_gpu = cu(image)
+# ```
+using LinearOperatorCollection.LinearOperators
+image_gpu = image #hide
+storage = Complex.(similar(image_gpu, 0))
+fop = FFTOp(eltype(image_gpu), shape = (N, N), S = typeof(storage))
+LinearOperators.storage_type(fop) == typeof(storage)
+
+# GPU operators can be used just like the other operators. Note however, that a GPU operator does not necessarily work with a CPU vector.

docs/src/literate/howtos/custom.jl

@@ -9,7 +9,7 @@ dop = DiagOp(ops)
 typeof(dop)
 
 # We can retrieve the operators:
-dop.ops
+typeof(dop.ops)
 
 # And visualize the result:
 fig = Figure()

docs/src/literate/howtos/gpu.jl

@@ -12,7 +12,7 @@ image_sine = reshape(sop * vec(image), N, N)
 
 fig = Figure()
 plot_image(fig[1,1], image, title = "Image")
-plot_image(fig[1,2], abs.(weighted_frequencies) .+ eps(), title = "Frequency Domain", colorscale = log10)
+plot_image(fig[1,2], abs.(image_frequencies) .+ eps(), title = "Frequency Domain", colorscale = log10)
 plot_image(fig[1,3], image_cosine, title = "Cosine")
 plot_image(fig[1,4], image_sine, title = "Sine")
 resize_to_layout!(fig)

docs/src/literate/tutorials/diagonal.jl

@@ -8,6 +8,7 @@ include("../../util.jl") #hide
 # \end{equation}
 # ```
 # for some operator $\mathbf{A}$:
+using FFTW
 fop = op = FFTOp(ComplexF32, shape = (N, N))
 nop = NormalOp(eltype(fop), parent = fop)
 isapprox(nop * vec(image), vec(image))
@@ -17,7 +18,7 @@ typeof(nop.parent)
 
 # LinearOperatorCollection also provides an opinionated `normalOperator` function which tries to optimize the resulting normal operator.
 # As an example consider the normal operator of a weighted fourier operator:
-weights = collect(range(0, 1, length = N*N))
+weights = Float32.(collect(range(0, 1, length = N*N)))
 wop = WeightingOp(weights)
 pop = ProdOp(wop, fop)
 nop = normalOperator(pop)

docs/src/literate/tutorials/fft.jl

@@ -3,16 +3,17 @@ include("../../util.jl") #hide
 # This operator describes the product or composition between two operators:
 weights = collect(range(0, 1, length = N*N))
 wop = WeightingOp(weights)
-fop = FFTOp(ComplexF64, shape = (N, N))
+fop = FFTOp(ComplexF64, shape = (N, N));
 # A feature of LinearOperators.jl is that operator can be cheaply transposed, conjugated and multiplied and only in the case of a matrix-vector product the combined operation is evaluated.
 tmp_op = wop * fop
 tmp_freqs = tmp_op * vec(image)
 
 
 # Similar to the WeightingOp, the main difference with the product operator provided by LinearOperatorCollection is the dedicated type, which allows for code specialisation.
 pop = ProdOp(wop, fop)
+typeof(pop)
 # and the ability to retrieve the components:
-typoef(pop.A)
+typeof(pop.A)
 # and
 typeof(pop.B)
 
@@ -23,7 +24,7 @@ pop * vec(image) == tmp_op * vec(image)
 
 # We can again visualize our result:
 weighted_frequencies = reshape(pop * vec(image), N, N)
-image_inverse = reshape(adjoint(pop) * y, N, N)
+image_inverse = reshape(adjoint(pop) * vec(weighted_frequencies), N, N)
 fig = Figure()
 plot_image(fig[1,1], image, title = "Image")
 plot_image(fig[1,2], abs.(weighted_frequencies) .+ eps(), title = "Frequency Domain", colorscale = log10)