[ VIGRA Homepage | Class Index | Function Index | File Index | Main Page ]
![]() |
Noise Normalization | ![]() |
---|
Classes | |
class | NoiseNormalizationOptions |
Pass options to one of the noise normalization functions. More... | |
Functions | |
template<...> void | noiseVarianceEstimation (SrcIterator sul, SrcIterator slr, SrcAccessor src, BackInsertable &result, NoiseNormalizationOptions const &options=NoiseNormalizationOptions()) |
Determine the noise variance as a function of the image intensity. | |
template<...> void | noiseVarianceClustering (SrcIterator sul, SrcIterator slr, SrcAccessor src, BackInsertable &result, NoiseNormalizationOptions const &options=NoiseNormalizationOptions()) |
Determine the noise variance as a function of the image intensity and cluster the results. | |
template<...> bool | nonparametricNoiseNormalization (SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest, NoiseNormalizationOptions const &options=NoiseNormalizationOptions()) |
Noise normalization by means of an estimated non-parametric noise model. | |
template<...> bool | quadraticNoiseNormalization (SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest, NoiseNormalizationOptions const &options=NoiseNormalizationOptions()) |
Noise normalization by means of an estimated quadratic noise model. | |
template<...> void | quadraticNoiseNormalization (SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest, double a0, double a1, double a2) |
Noise normalization by means of a given quadratic noise model. | |
template<...> bool | linearNoiseNormalization (SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest, NoiseNormalizationOptions const &options=NoiseNormalizationOptions()) |
Noise normalization by means of an estimated linear noise model. | |
template<...> void | linearNoiseNormalization (SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest, double a0, double a1) |
Noise normalization by means of a given linear noise model. |
Detailed Description |
Estimate noise with intensity-dependent variance and transform it into additive Gaussian noise.
void linearNoiseNormalization (...) |
Noise normalization by means of a given linear noise model. This function works similar to nonparametricNoiseNormalization() with the exception that the functional dependency of the noise variance from the intensity is given (as a linear function) rather than estimated:
variance = a0 + a1 * intensity Declarations: pass arguments explicitly: namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> void linearNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest, double a0, double a1); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> void linearNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src, pair<DestIterator, DestAccessor> dest, double a0, double a1); } Usage:
#include "vigra/noise_normalization.hxx"
vigra::BRGBImage src(w,h), dest(w, h); ... vigra::linearNoiseNormalization(srcImageRange(src), destImage(dest), 100, 0.02); Required Interface:
The source value type must be convertible to |
bool linearNoiseNormalization (...) |
Noise normalization by means of an estimated linear noise model. This function works in the same way as nonparametricNoiseNormalization() with the exception of the model for the dependency between intensity and noise variance: it assumes that this dependency is a linear function rather than a piecewise linear function. If the linear model is applicable, it leads to a very simple transformation which is similar to the familiar gamma correction. Declarations: pass arguments explicitly: namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> bool linearNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest, NoiseNormalizationOptions const & options = NoiseNormalizationOptions()); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> bool linearNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src, pair<DestIterator, DestAccessor> dest, NoiseNormalizationOptions const & options = NoiseNormalizationOptions()); } Usage:
#include "vigra/noise_normalization.hxx"
vigra::BRGBImage src(w,h), dest(w, h); ... vigra::linearNoiseNormalization(srcImageRange(src), destImage(dest), vigra::NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0). clusterCount(15)); Required Interface: same as noiseVarianceEstimation() |
void noiseVarianceClustering (...) |
Determine the noise variance as a function of the image intensity and cluster the results. This operator first calls\ref noiseVarianceEstimation() to obtain a sequence of intensity/variance pairs, which are then clustered using the median cut algorithm. Then the cluster centers (i.e. average variance vs. average intensity) are determined and returned in the result sequence.
In addition to the options valid for noiseVarianceEstimation(), the following options can be set via the options object (see vigra::NoiseNormalizationOptions for details):
Declarations: pass arguments explicitly: namespace vigra { template <class SrcIterator, class SrcAccessor, class BackInsertable> void noiseVarianceClustering(SrcIterator sul, SrcIterator slr, SrcAccessor src, BackInsertable & result, NoiseNormalizationOptions const & options = NoiseNormalizationOptions()); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class SrcIterator, class SrcAccessor, class BackInsertable> void noiseVarianceClustering(triple<SrcIterator, SrcIterator, SrcAccessor> src, BackInsertable & result, NoiseNormalizationOptions const & options = NoiseNormalizationOptions()); } Usage:
#include "vigra/noise_normalization.hxx"
vigra::BImage src(w,h); std::vector<vigra::TinyVector<double, 2> > result; ... vigra::noiseVarianceClustering(srcImageRange(src), result, vigra::NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0). clusterCount(15)); // print the intensity / variance pairs representing the cluster centers for(int k=0; k<result.size(); ++k) std::cout << "Cluster: " << k << ", intensity: " << result[k][0] << ", estimated variance: " << result[k][1] << std::endl; Required Interface: same as noiseVarianceEstimation() |
void noiseVarianceEstimation (...) |
Determine the noise variance as a function of the image intensity. This operator applies an algorithm described in W. Förstner: "Image Preprocessing for Feature Extraction in Digital Intensity, Color and Range Images", Proc. Summer School on Data Analysis and the Statistical Foundations of Geomatics, Lecture Notes in Earth Science, Berlin: Springer, 1999
in order to estimate the noise variance as a function of the image intensity in a robust way, i.e. so that intensity changes due to edges do not bias the estimate. The source value type (
Declarations: pass arguments explicitly: namespace vigra { template <class SrcIterator, class SrcAccessor, class BackInsertable> void noiseVarianceEstimation(SrcIterator sul, SrcIterator slr, SrcAccessor src, BackInsertable & result, NoiseNormalizationOptions const & options = NoiseNormalizationOptions()); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class SrcIterator, class SrcAccessor, class BackInsertable> void noiseVarianceEstimation(triple<SrcIterator, SrcIterator, SrcAccessor> src, BackInsertable & result, NoiseNormalizationOptions const & options = NoiseNormalizationOptions()); } Usage:
#include "vigra/noise_normalization.hxx"
vigra::BImage src(w,h); std::vector<vigra::TinyVector<double, 2> > result; ... vigra::noiseVarianceEstimation(srcImageRange(src), result, vigra::NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0)); // print the intensity / variance pairs found for(int k=0; k<result.size(); ++k) std::cout << "Intensity: " << result[k][0] << ", estimated variance: " << result[k][1] << std::endl; Required Interface:
SrcIterator upperleft, lowerright; SrcAccessor src; typedef SrcAccessor::value_type SrcType; typedef NumericTraits<SrcType>::isScalar isScalar; assert(isScalar::asBool == true); double value = src(uperleft); BackInsertable result; typedef BackInsertable::value_type ResultType; double intensity, variance; result.push_back(ResultType(intensity, variance)); |
bool nonparametricNoiseNormalization (...) |
Noise normalization by means of an estimated non-parametric noise model. The original image is assumed to be corrupted by noise whose variance depends on the intensity in an unknown way. The present functions first calls noiseVarianceClustering() to obtain a sequence of intensity/variance pairs (cluster centers) which estimate this dependency. The cluster centers are connected into a piecewise linear function which is the inverted according to the formula derived in W. Förstner: "Image Preprocessing for Feature Extraction in Digital Intensity, Color and Range Images", Proc. Summer School on Data Analysis and the Statistical Foundations of Geomatics, Lecture Notes in Earth Science, Berlin: Springer, 1999 The inverted formula defines a pixel-wise intensity transformation whose application turns the original image into one that is corrupted by additive Gaussian noise with unit variance. Most subsequent algorithms will be able to handle this type of noise much better than the original noise.
RGB and other multiband images will be processed one band at a time. The function returns The options object may use all options described in vigra::NoiseNormalizationOptions. Declarations: pass arguments explicitly: namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> bool nonparametricNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest, NoiseNormalizationOptions const & options = NoiseNormalizationOptions()); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> bool nonparametricNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src, pair<DestIterator, DestAccessor> dest, NoiseNormalizationOptions const & options = NoiseNormalizationOptions()); } Usage:
#include "vigra/noise_normalization.hxx"
vigra::BRGBImage src(w,h), dest(w, h); ... vigra::nonparametricNoiseNormalization(srcImageRange(src), destImage(dest), vigra::NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0). clusterCount(15)); Required Interface: same as noiseVarianceEstimation() |
void quadraticNoiseNormalization (...) |
Noise normalization by means of a given quadratic noise model. This function works similar to nonparametricNoiseNormalization() with the exception that the functional dependency of the noise variance from the intensity is given (by a quadratic function) rather than estimated:
variance = a0 + a1 * intensity + a2 * sq(intensity) Declarations: pass arguments explicitly: namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> void quadraticNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest, double a0, double a1, double a2); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> void quadraticNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src, pair<DestIterator, DestAccessor> dest, double a0, double a1, double a2); } Usage:
#include "vigra/noise_normalization.hxx"
vigra::BRGBImage src(w,h), dest(w, h); ... vigra::quadraticNoiseNormalization(srcImageRange(src), destImage(dest), 100, 0.02, 1e-6); Required Interface:
The source value type must be convertible to |
bool quadraticNoiseNormalization (...) |
Noise normalization by means of an estimated quadratic noise model. This function works in the same way as nonparametricNoiseNormalization() with the exception of the model for the dependency between intensity and noise variance: it assumes that this dependency is a quadratic function rather than a piecewise linear function. If the quadratic model is applicable, it leads to a somewhat smoother transformation. Declarations: pass arguments explicitly: namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> bool quadraticNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src, DestIterator dul, DestAccessor dest, NoiseNormalizationOptions const & options = NoiseNormalizationOptions()); } use argument objects in conjunction with Argument Object Factories: namespace vigra { template <class SrcIterator, class SrcAccessor, class DestIterator, class DestAccessor> bool quadraticNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src, pair<DestIterator, DestAccessor> dest, NoiseNormalizationOptions const & options = NoiseNormalizationOptions()); } Usage:
#include "vigra/noise_normalization.hxx"
vigra::BRGBImage src(w,h), dest(w, h); ... vigra::quadraticNoiseNormalization(srcImageRange(src), destImage(dest), vigra::NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0). clusterCount(15)); Required Interface: same as noiseVarianceEstimation() |
© Ullrich Köthe (koethe@informatik.uni-hamburg.de) |
html generated using doxygen and Python
|