Filter (Fiji Javadocs 0-SNAPSHOT API)

java.lang.Object
- mpicbg.ij.util.Filter

```
public class Filter
extends Object
```
Version:

0.2b

Author:

Stephan Saalfeld <saalfeld@mpi-cbg.de>

Constructor Summary

Constructors
Constructor and Description

Filter()

Constructors
Constructor and Description
`Filter()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static void`	`convolveSeparable(ij.process.FloatProcessor input, float[] h, float[] v)` Convolve an image with a horizontal and a vertical kernel simple straightforward, not optimized---replace this with a trusted better version soon
`static ij.process.FloatProcessor`	`createConvolveSeparable(ij.process.FloatProcessor input, float[] h, float[] v)` Create a convolved image with a horizontal and a vertical kernel simple straightforward, not optimized---replace this with a trusted better version soon
`static ij.process.FloatProcessor`	`createDownsampled(ij.process.FloatProcessor source, double scale, float sourceSigma, float targetSigma)` Create a downsampled `FloatProcessor`.
`static ij.process.ImageProcessor`	`createDownsampled(ij.process.ImageProcessor source, double scale, float sourceSigma, float targetSigma)` Create a downsampled ImageProcessor.
`static float[]`	`createGaussianKernel(float sigma)` Create a non-normalized 1d-Gaussian kernel of appropriate size.
`static ij.process.FloatProcessor[]`	`createGradients(ij.process.FloatProcessor array)`
`static float[]`	`createNormalizedGaussianKernel(float sigma)` Create a normalized 1d-Gaussian kernel of appropriate size.
`static ij.process.FloatProcessor`	`createNormalizedShiftedGaussianKernel(float sigma, float offsetX, float offsetY)` Create a non-normalized 2d-Gaussian impulse with appropriate size whose center is slightly shifted away from the middle.
`static ij.process.FloatProcessor`	`createShiftedGaussianKernel(float sigma, float offsetX, float offsetY)` Create a non-normalized 2d-Gaussian impulse with appropriate size whose center is slightly shifted away from the middle.
`static void`	`normalize(float[] data)` Normalize data numerically such that the sum of all fields is 1.0
`static ij.process.ImageProcessor`	`scale(ij.process.ImageProcessor source, float scale)` Scale an image with good quality in both up and down direction
`static void`	`smoothForScale(ij.process.FloatProcessor source, double scale, float sourceSigma, float targetSigma)` Smooth with a Gaussian kernel that represents downsampling at a given scale factor and sourceSigma.
`static void`	`smoothForScale(ij.process.ImageProcessor source, double scale, float sourceSigma, float targetSigma)` Smooth with a Gaussian kernel that represents downsampling at a given scale factor and sourceSigma.

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

- Constructor Detail
  - Filter
```
public Filter()
```
- Method Detail
  - normalize
```
public static final void normalize(float[] data)
```
    Normalize data numerically such that the sum of all fields is 1.0
    
    Parameters:
    
    data -
  - createGaussianKernel
```
public static final float[] createGaussianKernel(float sigma)
```
    Create a non-normalized 1d-Gaussian kernel of appropriate size.
    
    Parameters:
    
    sigma - Standard deviation (σ) of the Gaussian kernel
    
    Returns:
    
    Gaussian kernel of appropriate size
  - createNormalizedGaussianKernel
```
public static final float[] createNormalizedGaussianKernel(float sigma)
```
    Create a normalized 1d-Gaussian kernel of appropriate size. Normalization is performed numerically such that the sum of all fields is 1.0. It turned out to be better to normalize with respect to the sum instead of the integral which would be per-field division by σ/√2π
    
    Parameters:
    
    sigma - Standard deviation (σ) of the Gaussian kernel
    
    Returns:
    
    Gaussian kernel of appropriate size
  - createShiftedGaussianKernel
```
public static final ij.process.FloatProcessor createShiftedGaussianKernel(float sigma,
                                                                          float offsetX,
                                                                          float offsetY)
```
    Create a non-normalized 2d-Gaussian impulse with appropriate size whose center is slightly shifted away from the middle.
    
    Parameters:
    
    sigma - Standard deviation (σ) of the Gaussian kernel
    
    offsetX - horizontal center shift [0.0,0.5]
    
    offsetY - vertical center shift [0.0,0.5]
    
    Returns:
  - createNormalizedShiftedGaussianKernel
```
public static final ij.process.FloatProcessor createNormalizedShiftedGaussianKernel(float sigma,
                                                                                    float offsetX,
                                                                                    float offsetY)
```
    Create a non-normalized 2d-Gaussian impulse with appropriate size whose center is slightly shifted away from the middle. It turned out to be better to normalize with respect to the sum instead of the integral which would be per-field division by σ²/2π)
    
    Parameters:
    
    sigma - Standard deviation (σ) of the Gaussian kernel
    
    Returns:
    
    Gaussian kernel of appropriate size
  - createGradients
```
public static final ij.process.FloatProcessor[] createGradients(ij.process.FloatProcessor array)
```
  - createConvolveSeparable
```
public static final ij.process.FloatProcessor createConvolveSeparable(ij.process.FloatProcessor input,
                                                                      float[] h,
                                                                      float[] v)
```
    Create a convolved image with a horizontal and a vertical kernel simple straightforward, not optimized---replace this with a trusted better version soon
    
    Parameters:
    
    input - the input image
    
    h - horizontal kernel
    
    v - vertical kernel
    
    Returns:
    
    convolved image
  - convolveSeparable
```
public static final void convolveSeparable(ij.process.FloatProcessor input,
                                           float[] h,
                                           float[] v)
```
    Convolve an image with a horizontal and a vertical kernel simple straightforward, not optimized---replace this with a trusted better version soon
    
    Parameters:
    
    input - the input image
    
    h - horizontal kernel
    
    v - vertical kernel
  - smoothForScale
```
public static final void smoothForScale(ij.process.FloatProcessor source,
                                        double scale,
                                        float sourceSigma,
                                        float targetSigma)
```
    Smooth with a Gaussian kernel that represents downsampling at a given scale factor and sourceSigma.
  - createDownsampled
```
public static final ij.process.FloatProcessor createDownsampled(ij.process.FloatProcessor source,
                                                                double scale,
                                                                float sourceSigma,
                                                                float targetSigma)
```
    Create a downsampled FloatProcessor.
    
    Parameters:
    
    source - the source image
    
    scale - scaling factor
    
    sourceSigma - the Gaussian at which the source was sampled (guess 0.5 if you do not know)
    
    targetSigma - the Gaussian at which the target will be sampled
    
    Returns:
    
    a new FloatProcessor
  - smoothForScale
```
public static final void smoothForScale(ij.process.ImageProcessor source,
                                        double scale,
                                        float sourceSigma,
                                        float targetSigma)
```
    Smooth with a Gaussian kernel that represents downsampling at a given scale factor and sourceSigma.
  - createDownsampled
```
public static final ij.process.ImageProcessor createDownsampled(ij.process.ImageProcessor source,
                                                                double scale,
                                                                float sourceSigma,
                                                                float targetSigma)
```
    Create a downsampled ImageProcessor.
    
    Parameters:
    
    source - the source image
    
    scale - scaling factor
    
    sourceSigma - the Gaussian at which the source was sampled (guess 0.5 if you do not know)
    
    targetSigma - the Gaussian at which the target will be sampled
    
    Returns:
    
    a new FloatProcessor
  - scale
```
public static final ij.process.ImageProcessor scale(ij.process.ImageProcessor source,
                                                    float scale)
```
    Scale an image with good quality in both up and down direction

Class Filter

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Filter

Method Detail

normalize

createGaussianKernel

createNormalizedGaussianKernel

createShiftedGaussianKernel

createNormalizedShiftedGaussianKernel

createGradients

createConvolveSeparable

convolveSeparable

smoothForScale

createDownsampled

smoothForScale

createDownsampled

scale