LogPoissonNoiseFilteringTool

java.lang.Object
- edu.stanford.rsl.conrad.filtering.ImageFilteringTool
- - edu.stanford.rsl.conrad.filtering.IndividualImageFilteringTool
  - - edu.stanford.rsl.conrad.filtering.PoissonNoiseFilteringTool
    - - edu.stanford.rsl.conrad.filtering.LogPoissonNoiseFilteringTool

All Implemented Interfaces:

Citeable, GUIConfigurable, SafeSerializable, NamedParallelizableRunnable, ParallelizableRunnable, java.io.Serializable, java.lang.Cloneable, java.lang.Runnable
```
public class LogPoissonNoiseFilteringTool
extends PoissonNoiseFilteringTool
```
Applies Poisson noise to the input image as it would happen in the physical process (based on a monochromatic x-ray source). The relation given the emitted photons by the source , the observed photons , and the absorption coefficients $\mu_i$ in $[\frac{\textnormal{g}}{\textnormal{cm}^3}]$ along the ray segments in $[\textnormal{cm}]$ is given by Lambert-Beer's law:
$N = N_0 \cdot e^{-\sum_i\mu_i \cdot x_i}$ .
We assume that the input data is in log domain, i.e. given as $\sum_i\mu_i \cdot x_i$ in $[\frac{\textnormal{g}}{\textnormal{cm}^2}]$ as returned by a forward projection.
The data is converted to photon count domain via application of the minus exponent transform.
Photon noise statistics are computed according to a Poisson distribution
$P(\mathcal{N} = n) = \frac{\lambda^n}{n!} \cdot e^{-\lambda}$
where $\lambda$ is assumed to be for each pixel. With the mean and standard deviation of the Poisson distribution being $\lambda$ and $\sqrt{\lambda}$ respectively, the Signal-to-Noise-Ration (SNR) is
$\textnormal{SNR} = \frac{\textnormal{Signal}}{\textnormal{Noise}} = \frac{\lambda}{\sqrt{\lambda}} = \sqrt{\lambda} = \sqrt{N}$ .
Hence, the more photons were observed, the better the SNR for the respective pixel.

The user has to specify a photon count (e.g. 75000). This value will correspond to 0 in the log domain image.
Then the photon statistics are applied according to Poisson noise statistics. In the final step the data is then transformed back to minus log domain to match the scaling of the original input data.

Author:

Andreas Maier

See Also:
CUDAForwardProjector, Serialized Form

Constructor Summary

Constructors
Constructor and Description

LogPoissonNoiseFilteringTool()

Constructors
Constructor and Description
`LogPoissonNoiseFilteringTool()`

Method Summary

Methods
Modifier and Type	Method and Description
`Grid2D`	`applyToolToImage(Grid2D imageProcessor)` Is called in every thread to apply the tool to an individual ImageProcessor
`IndividualImageFilteringTool`	`clone()` All ImageFilteringTools need to be Cloneable in order to enable multiple processor usage.
`void`	`configure()` Configures the object before execution
`java.lang.String`	`getBibtexCitation()` Returns the citation in bibTex format
`java.lang.String`	`getMedlineCitation()` Returns the citation in Medline format
`double`	`getPhotonCountMax()`
`java.lang.String`	`getToolName()` returns the name of the actual tool which was used.
`boolean`	`isDeviceDependent()` Cosine filtering depends on the projection geometry and is hence not device depdendent.
`void`	`prepareForSerialization()` Sets all data objects in the serialized object to null which do not implement the Serializable interface.
`void`	`setPhotonCountMax(double photonCountMax)`

Methods inherited from class edu.stanford.rsl.conrad.filtering.IndividualImageFilteringTool
getFilteredImage, getImageIndex, getProcessName, run, setImageIndex, setImageProcessor, setLatch

Methods inherited from class edu.stanford.rsl.conrad.filtering.ImageFilteringTool
getFilterTools, isConfigured, setConfigured, toString

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - LogPoissonNoiseFilteringTool
```
public LogPoissonNoiseFilteringTool()
```
- Method Detail
  - getPhotonCountMax
```
public double getPhotonCountMax()
```
    Returns:
    the photonCountMax
  - setPhotonCountMax
```
public void setPhotonCountMax(double photonCountMax)
```
    Parameters:
    photonCountMax - the photonCountMax to set
  - clone
```
public IndividualImageFilteringTool clone()
```
    Description copied from class: IndividualImageFilteringTool
    
    All ImageFilteringTools need to be Cloneable in order to enable multiple processor usage.
    
    Overrides:
    
    clone in class PoissonNoiseFilteringTool
  - getToolName
```
public java.lang.String getToolName()
```
    Description copied from class: ImageFilteringTool
    
    returns the name of the actual tool which was used.
    
    Overrides:
    
    getToolName in class PoissonNoiseFilteringTool
    
    Returns:
    the name of the tool as string.
  - applyToolToImage
```
public Grid2D applyToolToImage(Grid2D imageProcessor)
                        throws java.lang.Exception
```
    Description copied from class: IndividualImageFilteringTool
    
    Is called in every thread to apply the tool to an individual ImageProcessor
    
    Overrides:
    
    applyToolToImage in class PoissonNoiseFilteringTool
    
    Parameters:
    imageProcessor - the ImageProcessor
    
    Returns:
    the filtered instance of the ImageProcessor
    
    Throws:
    
    java.lang.Exception
  - prepareForSerialization
```
public void prepareForSerialization()
```
    Description copied from interface: SafeSerializable
    
    Sets all data objects in the serialized object to null which do not implement the Serializable interface. It can also be used to save space in the serialized form. Configuration parameters are preserved. Processing data is discarded.
    
    Specified by:
    
    prepareForSerialization in interface SafeSerializable
    
    Overrides:
    
    prepareForSerialization in class PoissonNoiseFilteringTool
  - configure
```
public void configure()
               throws java.lang.Exception
```
    Description copied from interface: GUIConfigurable
    
    Configures the object before execution
    
    Specified by:
    
    configure in interface GUIConfigurable
    
    Overrides:
    
    configure in class PoissonNoiseFilteringTool
    
    Throws:
    
    java.lang.Exception - may happen
  - getBibtexCitation
```
public java.lang.String getBibtexCitation()
```
    Description copied from interface: Citeable
    
    Returns the citation in bibTex format
    
    Specified by:
    
    getBibtexCitation in interface Citeable
    
    Overrides:
    
    getBibtexCitation in class PoissonNoiseFilteringTool
    
    Returns:
    citation as String
  - getMedlineCitation
```
public java.lang.String getMedlineCitation()
```
    Description copied from interface: Citeable
    
    Returns the citation in Medline format
    
    Specified by:
    
    getMedlineCitation in interface Citeable
    
    Overrides:
    
    getMedlineCitation in class PoissonNoiseFilteringTool
    
    Returns:
    citation as String
  - isDeviceDependent
```
public boolean isDeviceDependent()
```
    Cosine filtering depends on the projection geometry and is hence not device depdendent.
    
    Overrides:
    
    isDeviceDependent in class PoissonNoiseFilteringTool
    
    Returns:
    true if the method is device dependent.

Class LogPoissonNoiseFilteringTool

Constructor Summary

Method Summary

Methods inherited from class edu.stanford.rsl.conrad.filtering.IndividualImageFilteringTool

Methods inherited from class edu.stanford.rsl.conrad.filtering.ImageFilteringTool

Methods inherited from class java.lang.Object

Constructor Detail

LogPoissonNoiseFilteringTool

Method Detail

getPhotonCountMax

setPhotonCountMax

clone

getToolName

applyToolToImage

prepareForSerialization

configure

getBibtexCitation

getMedlineCitation

isDeviceDependent