# Onion Peeling (Dasch)¶

## Introduction¶

The “Dasch onion peeling” deconvolution algorithm is one of several described in the Dasch paper [1]. See also the two_point and three_point descriptions.

## How it works¶

In the onion-peeling method the projection is approximated by rings of constant property between $$r_j - \Delta r/2$$ and $$r_j + \Delta r/2$$ for each data point $$r_j$$.

The projection data is given by $$P(r_i) = \Delta r \sum_{j=i}^\infty W_{ij} F(r_j)$$

where

\begin{align}\begin{aligned}W_{ij} = 0 \, \, (j < i)\\\sqrt{(2j+1)^2 - 4i^2} \, \, (j=i)\\\sqrt{(2j+1)^2 - 4i^2} - \sqrt{(2j-1)^2 - 4i^2} \, \, (j > i)\end{aligned}\end{align}

The onion-peeling deconvolution function is: $$D_{ij} = (W^{-1})_{ij}$$.

## When to use it¶

This method is simple and computationally very efficient. The article states that it has less smoothing that other methods (discussed in Dasch).

## How to use it¶

To complete the inverse transform of a full image with the onion_dasch method, simply use the abel.Transform class:

abel.Transform(myImage, method='onion_peeling').transform


If you would like to access the onion_peeling algorithm directly (to transform a right-side half-image), you can use abel.dasch.onion_peeling_transform().

## Example¶

# -*- coding: utf-8 -*-
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals

"""example_dasch_methods.py.
"""

import numpy as np
import abel
import matplotlib.pyplot as plt

# Dribinski sample image size 501x501
n = 501
IM = abel.tools.analytical.SampleImage(n).image

# speed distribution of original image
orig_speed = abel.tools.vmi.angular_integration_3D(origQ[0], origin=(-1, 0))
scale_factor = orig_speed[1].max()

plt.plot(orig_speed[0], orig_speed[1]/scale_factor, linestyle='dashed',
label="Dribinski sample")

# forward Abel projection
fIM = abel.Transform(IM, direction="forward", method="hansenlaw").transform

# split projected image into quadrants

dasch_transform = {\
"two_point": abel.dasch.two_point_transform,
"three_point": abel.dasch.three_point_transform,
"onion_peeling": abel.dasch.onion_peeling_transform}

for method in dasch_transform.keys():
Q0 = Q[0].copy()
# method inverse Abel transform
AQ0 = dasch_transform[method](Q0)
# speed distribution
speed = abel.tools.vmi.angular_integration_3D(AQ0, origin=(-1, 0))

plt.plot(speed[0], speed[1]*orig_speed[1][14]/speed[1][14]/scale_factor,
label=method)

plt.title("Dasch methods for Dribinski sample image $n={:d}$".format(n))
plt.axis(xmax=250, ymin=-0.1)
plt.legend(loc=0, frameon=False, labelspacing=0.1, fontsize='small')
plt.savefig("plot_example_dasch_methods.png",dpi=100)
plt.show()


or more information on the PyAbel implementation of the onion_peeling algorithm, please see PR #155.

## Citation¶

 [1] C. J. Dasch, “One-dimensional tomography: a comparison of Abel, onion-peeling, and filtered backprojection methods”, Appl. Opt. 31, 1146–1152 (1992).