[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

noise_normalization.hxx VIGRA

1 /************************************************************************/
2 /* */
3 /* Copyright 1998-2006 by Ullrich Koethe */
4 /* */
5 /* This file is part of the VIGRA computer vision library. */
6 /* The VIGRA Website is */
7 /* http://hci.iwr.uni-heidelberg.de/vigra/ */
8 /* Please direct questions, bug reports, and contributions to */
9 /* ullrich.koethe@iwr.uni-heidelberg.de or */
10 /* vigra@informatik.uni-hamburg.de */
11 /* */
12 /* Permission is hereby granted, free of charge, to any person */
13 /* obtaining a copy of this software and associated documentation */
14 /* files (the "Software"), to deal in the Software without */
15 /* restriction, including without limitation the rights to use, */
16 /* copy, modify, merge, publish, distribute, sublicense, and/or */
17 /* sell copies of the Software, and to permit persons to whom the */
18 /* Software is furnished to do so, subject to the following */
19 /* conditions: */
20 /* */
21 /* The above copyright notice and this permission notice shall be */
22 /* included in all copies or substantial portions of the */
23 /* Software. */
24 /* */
25 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
26 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
27 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
28 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
29 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
30 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
31 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
32 /* OTHER DEALINGS IN THE SOFTWARE. */
33 /* */
34 /************************************************************************/
35 
36 
37 #ifndef VIGRA_NOISE_NORMALIZATION_HXX
38 #define VIGRA_NOISE_NORMALIZATION_HXX
39 
40 #include "utilities.hxx"
41 #include "tinyvector.hxx"
42 #include "stdimage.hxx"
43 #include "transformimage.hxx"
44 #include "combineimages.hxx"
45 #include "localminmax.hxx"
46 #include "functorexpression.hxx"
47 #include "numerictraits.hxx"
48 #include "separableconvolution.hxx"
49 #include "linear_solve.hxx"
50 #include "array_vector.hxx"
51 #include "static_assert.hxx"
52 #include "multi_shape.hxx"
53 
54 #include <algorithm>
55 
56 namespace vigra {
57 
58 /** \addtogroup NoiseNormalization Noise Normalization
59  Estimate noise with intensity-dependent variance and transform it into additive Gaussian noise.
60 */
61 //@{
62 
63 /********************************************************/
64 /* */
65 /* NoiseNormalizationOptions */
66 /* */
67 /********************************************************/
68 
69 /** \brief Pass options to one of the noise normalization functions.
70 
71  <tt>NoiseNormalizationOptions</tt> is an argument object that holds various optional
72  parameters used by the noise normalization functions. If a parameter is not explicitly
73  set, a suitable default will be used.
74 
75  <b> Usage:</b>
76 
77  <b>\#include</b> <vigra/noise_normalization.hxx><br>
78  Namespace: vigra
79 
80  \code
81  MultiArray<2, float> src(w,h);
82  std::vector<TinyVector<double, 2> > result;
83 
84  ...
85  noiseVarianceEstimation(src, result,
86  NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0));
87  \endcode
88 */
89 class NoiseNormalizationOptions
90 {
91  public:
92 
93  /** Initialize all options with default values.
94  */
95  NoiseNormalizationOptions()
96  : window_radius(6),
97  cluster_count(10),
98  noise_estimation_quantile(1.5),
99  averaging_quantile(0.8),
100  noise_variance_initial_guess(10.0),
101  use_gradient(true)
102  {}
103 
104  /** Select the noise estimation algorithm.
105 
106  If \a r is <tt>true</tt>, use the gradient-based noise estimator according to F&ouml;rstner (default).
107  Otherwise, use an algorithm that uses the intensity values directly.
108  */
109  NoiseNormalizationOptions & useGradient(bool r)
110  {
111  use_gradient = r;
112  return *this;
113  }
114 
115  /** Set the window radius for a single noise estimate.
116  Every window of the given size gives raise to one intensity/variance pair.<br>
117  Default: 6 pixels
118  */
119  NoiseNormalizationOptions & windowRadius(unsigned int r)
120  {
121  vigra_precondition(r > 0,
122  "NoiseNormalizationOptions: window radius must be > 0.");
123  window_radius = r;
124  return *this;
125  }
126 
127  /** Set the number of clusters for non-parametric noise normalization.
128  The intensity/variance pairs found are grouped into clusters before the noise
129  normalization transform is computed.<br>
130  Default: 10 clusters
131  */
132  NoiseNormalizationOptions & clusterCount(unsigned int c)
133  {
134  vigra_precondition(c > 0,
135  "NoiseNormalizationOptions: cluster count must be > 0.");
136  cluster_count = c;
137  return *this;
138  }
139 
140  /** Set the quantile for cluster averaging.
141  After clustering, the cluster center (i.e. average noise variance as a function of the average
142  intensity in the cluster) is computed using only the cluster members whose estimated variance
143  is below \a quantile times the maximum variance in the cluster.<br>
144  Default: 0.8<br>
145  Precondition: 0 < \a quantile <= 1.0
146  */
147  NoiseNormalizationOptions & averagingQuantile(double quantile)
148  {
149  vigra_precondition(quantile > 0.0 && quantile <= 1.0,
150  "NoiseNormalizationOptions: averaging quantile must be between 0 and 1.");
151  averaging_quantile = quantile;
152  return *this;
153  }
154 
155  /** Set the operating range of the robust noise estimator.
156  Intensity changes that are larger than \a quantile times the current estimate of the noise variance
157  are ignored by the robust noise estimator.<br>
158  Default: 1.5<br>
159  Precondition: 0 < \a quantile
160  */
161  NoiseNormalizationOptions & noiseEstimationQuantile(double quantile)
162  {
163  vigra_precondition(quantile > 0.0,
164  "NoiseNormalizationOptions: noise estimation quantile must be > 0.");
165  noise_estimation_quantile = quantile;
166  return *this;
167  }
168 
169  /** Set the initial estimate of the noise variance.
170  Robust noise variance estimation is an iterative procedure starting at the given value.<br>
171  Default: 10.0<br>
172  Precondition: 0 < \a guess
173  */
174  NoiseNormalizationOptions & noiseVarianceInitialGuess(double guess)
175  {
176  vigra_precondition(guess > 0.0,
177  "NoiseNormalizationOptions: noise variance initial guess must be > 0.");
178  noise_variance_initial_guess = guess;
179  return *this;
180  }
181 
182  unsigned int window_radius, cluster_count;
183  double noise_estimation_quantile, averaging_quantile, noise_variance_initial_guess;
184  bool use_gradient;
185 };
186 
187 //@}
188 
189 template <class ArgumentType, class ResultType>
190 class NonparametricNoiseNormalizationFunctor
191 {
192  struct Segment
193  {
194  double lower, a, b, shift;
195  };
196 
197  ArrayVector<Segment> segments_;
198 
199  template <class T>
200  double exec(unsigned int k, T t) const
201  {
202  if(segments_[k].a == 0.0)
203  {
204  return t / VIGRA_CSTD::sqrt(segments_[k].b);
205  }
206  else
207  {
208  return 2.0 / segments_[k].a * VIGRA_CSTD::sqrt(std::max(0.0, segments_[k].a * t + segments_[k].b));
209  }
210  }
211 
212  public:
213  typedef ArgumentType argument_type;
214  typedef ResultType result_type;
215 
216  template <class Vector>
217  NonparametricNoiseNormalizationFunctor(Vector const & clusters)
218  : segments_(clusters.size()-1)
219  {
220  for(unsigned int k = 0; k<segments_.size(); ++k)
221  {
222  segments_[k].lower = clusters[k][0];
223  segments_[k].a = (clusters[k+1][1] - clusters[k][1]) / (clusters[k+1][0] - clusters[k][0]);
224  segments_[k].b = clusters[k][1] - segments_[k].a * clusters[k][0];
225  // FIXME: set a to zero if it is very small
226  // - determine what 'very small' means
227  // - shouldn't the two formulas (for a == 0, a != 0) be equal in the limit a -> 0 ?
228 
229  if(k == 0)
230  {
231  segments_[k].shift = segments_[k].lower - exec(k, segments_[k].lower);
232  }
233  else
234  {
235  segments_[k].shift = exec(k-1, segments_[k].lower) - exec(k, segments_[k].lower) + segments_[k-1].shift;
236  }
237  }
238  }
239 
240  result_type operator()(argument_type t) const
241  {
242  // find the segment
243  unsigned int k = 0;
244  for(; k < segments_.size(); ++k)
245  if(t < segments_[k].lower)
246  break;
247  if(k > 0)
248  --k;
249  return detail::RequiresExplicitCast<ResultType>::cast(exec(k, t) + segments_[k].shift);
250  }
251 };
252 
253 template <class ArgumentType, class ResultType>
254 class QuadraticNoiseNormalizationFunctor
255 {
256  double a, b, c, d, f, o;
257 
258  void init(double ia, double ib, double ic, double xmin)
259  {
260  a = ia;
261  b = ib;
262  c = ic;
263  d = VIGRA_CSTD::sqrt(VIGRA_CSTD::fabs(c));
264  if(c > 0.0)
265  {
266  o = VIGRA_CSTD::log(VIGRA_CSTD::fabs((2.0*c*xmin + b)/d + 2*VIGRA_CSTD::sqrt(c*sq(xmin) +b*xmin + a)))/d;
267  f = 0.0;
268  }
269  else
270  {
271  f = VIGRA_CSTD::sqrt(b*b - 4.0*a*c);
272  o = -VIGRA_CSTD::asin((2.0*c*xmin+b)/f)/d;
273  }
274  }
275 
276  public:
277  typedef ArgumentType argument_type;
278  typedef ResultType result_type;
279 
280  template <class Vector>
281  QuadraticNoiseNormalizationFunctor(Vector const & clusters)
282  {
283  double xmin = NumericTraits<double>::max();
284  Matrix<double> m(3,3), r(3, 1), l(3, 1);
285  for(unsigned int k = 0; k<clusters.size(); ++k)
286  {
287  l(0,0) = 1.0;
288  l(1,0) = clusters[k][0];
289  l(2,0) = sq(clusters[k][0]);
290  m += outer(l);
291  r += clusters[k][1]*l;
292  if(clusters[k][0] < xmin)
293  xmin = clusters[k][0];
294  }
295 
296  linearSolve(m, r, l);
297  init(l(0,0), l(1,0), l(2,0), xmin);
298  }
299 
300  result_type operator()(argument_type t) const
301  {
302  double r;
303  if(c > 0.0)
304  r = VIGRA_CSTD::log(VIGRA_CSTD::fabs((2.0*c*t + b)/d + 2.0*VIGRA_CSTD::sqrt(c*t*t +b*t + a)))/d-o;
305  else
306  r = -VIGRA_CSTD::asin((2.0*c*t+b)/f)/d-o;
307  return detail::RequiresExplicitCast<ResultType>::cast(r);
308  }
309 };
310 
311 template <class ArgumentType, class ResultType>
312 class LinearNoiseNormalizationFunctor
313 {
314  double a, b, o;
315 
316  void init(double ia, double ib, double xmin)
317  {
318  a = ia;
319  b = ib;
320  if(b != 0.0)
321  {
322  o = xmin - 2.0 / b * VIGRA_CSTD::sqrt(a + b * xmin);
323  }
324  else
325  {
326  o = xmin - xmin / VIGRA_CSTD::sqrt(a);
327  }
328  }
329 
330  public:
331  typedef ArgumentType argument_type;
332  typedef ResultType result_type;
333 
334  template <class Vector>
335  LinearNoiseNormalizationFunctor(Vector const & clusters)
336  {
337  double xmin = NumericTraits<double>::max();
338  Matrix<double> m(2,2), r(2, 1), l(2, 1);
339  for(unsigned int k = 0; k<clusters.size(); ++k)
340  {
341  l(0,0) = 1.0;
342  l(1,0) = clusters[k][0];
343  m += outer(l);
344  r += clusters[k][1]*l;
345  if(clusters[k][0] < xmin)
346  xmin = clusters[k][0];
347  }
348 
349  linearSolve(m, r, l);
350  init(l(0,0), l(1,0), xmin);
351  }
352 
353  result_type operator()(argument_type t) const
354  {
355  double r;
356  if(b != 0.0)
357  r = 2.0 / b * VIGRA_CSTD::sqrt(a + b*t) + o;
358  else
359  r = t / VIGRA_CSTD::sqrt(a) + o;
360  return detail::RequiresExplicitCast<ResultType>::cast(r);
361  }
362 };
363 
364 #define VIGRA_NoiseNormalizationFunctor(name, type, size) \
365 template <class ResultType> \
366 class name<type, ResultType> \
367 { \
368  ResultType lut_[size]; \
369  \
370  public: \
371  typedef type argument_type; \
372  typedef ResultType result_type; \
373  \
374  template <class Vector> \
375  name(Vector const & clusters) \
376  { \
377  name<double, ResultType> f(clusters); \
378  \
379  for(unsigned int k = 0; k < size; ++k) \
380  { \
381  lut_[k] = f(k); \
382  } \
383  } \
384  \
385  result_type operator()(argument_type t) const \
386  { \
387  return lut_[t]; \
388  } \
389 };
390 
391 VIGRA_NoiseNormalizationFunctor(NonparametricNoiseNormalizationFunctor, UInt8, 256)
392 VIGRA_NoiseNormalizationFunctor(NonparametricNoiseNormalizationFunctor, UInt16, 65536)
393 VIGRA_NoiseNormalizationFunctor(QuadraticNoiseNormalizationFunctor, UInt8, 256)
394 VIGRA_NoiseNormalizationFunctor(QuadraticNoiseNormalizationFunctor, UInt16, 65536)
395 VIGRA_NoiseNormalizationFunctor(LinearNoiseNormalizationFunctor, UInt8, 256)
396 VIGRA_NoiseNormalizationFunctor(LinearNoiseNormalizationFunctor, UInt16, 65536)
397 
398 #undef VIGRA_NoiseNormalizationFunctor
399 
400 namespace detail {
401 
402 template <class SrcIterator, class SrcAcessor,
403  class GradIterator>
404 bool
405 iterativeNoiseEstimationChi2(SrcIterator s, SrcAcessor src, GradIterator g,
406  double & mean, double & variance,
407  double robustnessThreshold, int windowRadius)
408 {
409  double l2 = sq(robustnessThreshold);
410  double countThreshold = 1.0 - VIGRA_CSTD::exp(-l2);
411  double f = (1.0 - VIGRA_CSTD::exp(-l2)) / (1.0 - (1.0 + l2)*VIGRA_CSTD::exp(-l2));
412 
413  Diff2D ul(-windowRadius, -windowRadius);
414  int r2 = sq(windowRadius);
415 
416  for(int iter=0; iter<100 ; ++iter) // maximum iteration 100 only for terminating
417  // if something is wrong
418  {
419  double sum=0.0;
420  double gsum=0.0;
421  unsigned int count = 0;
422  unsigned int tcount = 0;
423 
424  SrcIterator siy = s + ul;
425  GradIterator giy = g + ul;
426  for(int y=-windowRadius; y <= windowRadius; y++, ++siy.y, ++giy.y)
427  {
428  typename SrcIterator::row_iterator six = siy.rowIterator();
429  typename GradIterator::row_iterator gix = giy.rowIterator();
430  for(int x=-windowRadius; x <= windowRadius; x++, ++six, ++gix)
431  {
432  if (sq(x) + sq(y) > r2)
433  continue;
434 
435  ++tcount;
436  if (*gix < l2*variance)
437  {
438  sum += src(six);
439  gsum += *gix;
440  ++count;
441  }
442  }
443  }
444  if (count==0) // not homogeneous enough
445  return false;
446 
447  double oldvariance = variance;
448  variance= f * gsum / count;
449  mean = sum / count;
450 
451  if ( closeAtTolerance(oldvariance - variance, 0.0, 1e-10))
452  return (count >= tcount * countThreshold / 2.0); // sufficiently many valid points
453  }
454  return false; // no convergence
455 }
456 
457 template <class SrcIterator, class SrcAcessor,
458  class GradIterator>
459 bool
460 iterativeNoiseEstimationGauss(SrcIterator s, SrcAcessor src, GradIterator,
461  double & mean, double & variance,
462  double robustnessThreshold, int windowRadius)
463 {
464  double l2 = sq(robustnessThreshold);
465  double countThreshold = erf(VIGRA_CSTD::sqrt(0.5 * l2));
466  double f = countThreshold / (countThreshold - VIGRA_CSTD::sqrt(2.0/M_PI*l2)*VIGRA_CSTD::exp(-l2/2.0));
467 
468  mean = src(s);
469 
470  Diff2D ul(-windowRadius, -windowRadius);
471  int r2 = sq(windowRadius);
472 
473  for(int iter=0; iter<100 ; ++iter) // maximum iteration 100 only for terminating
474  // if something is wrong
475  {
476  double sum = 0.0;
477  double sum2 = 0.0;
478  unsigned int count = 0;
479  unsigned int tcount = 0;
480 
481  SrcIterator siy = s + ul;
482  for(int y=-windowRadius; y <= windowRadius; y++, ++siy.y)
483  {
484  typename SrcIterator::row_iterator six = siy.rowIterator();
485  for(int x=-windowRadius; x <= windowRadius; x++, ++six)
486  {
487  if (sq(x) + sq(y) > r2)
488  continue;
489 
490  ++tcount;
491  if (sq(src(six) - mean) < l2*variance)
492  {
493  sum += src(six);
494  sum2 += sq(src(six));
495  ++count;
496  }
497  }
498  }
499  if (count==0) // not homogeneous enough
500  return false;
501 
502  double oldmean = mean;
503  double oldvariance = variance;
504  mean = sum / count;
505  variance= f * (sum2 / count - sq(mean));
506 
507  if ( closeAtTolerance(oldmean - mean, 0.0, 1e-10) &&
508  closeAtTolerance(oldvariance - variance, 0.0, 1e-10))
509  return (count >= tcount * countThreshold / 2.0); // sufficiently many valid points
510  }
511  return false; // no convergence
512 }
513 
514 
515 template <class SrcIterator, class SrcAccessor,
516  class DestIterator, class DestAccessor>
517 void
518 symmetricDifferenceSquaredMagnitude(
519  SrcIterator sul, SrcIterator slr, SrcAccessor src,
520  DestIterator dul, DestAccessor dest)
521 {
522  using namespace functor;
523  int w = slr.x - sul.x;
524  int h = slr.y - sul.y;
525 
526  typedef typename NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
527  typedef BasicImage<TmpType> TmpImage;
528 
529  Kernel1D<double> mask;
530  mask.initSymmetricGradient();
531  mask.setBorderTreatment(BORDER_TREATMENT_REFLECT);
532 
533  TmpImage dx(w, h), dy(w, h);
534  separableConvolveX(srcIterRange(sul, slr, src), destImage(dx), kernel1d(mask));
535  separableConvolveY(srcIterRange(sul, slr, src), destImage(dy), kernel1d(mask));
536  combineTwoImages(srcImageRange(dx), srcImage(dy), destIter(dul, dest), Arg1()*Arg1() + Arg2()*Arg2());
537 }
538 
539 template <class SrcIterator, class SrcAccessor,
540  class DestIterator, class DestAccessor>
541 void
542 findHomogeneousRegionsFoerstner(
543  SrcIterator sul, SrcIterator slr, SrcAccessor src,
544  DestIterator dul, DestAccessor dest,
545  unsigned int windowRadius = 6, double homogeneityThreshold = 40.0)
546 {
547  using namespace vigra::functor;
548  int w = slr.x - sul.x;
549  int h = slr.y - sul.y;
550 
551  BImage btmp(w, h);
552  transformImage(srcIterRange(sul, slr, src), destImage(btmp),
553  ifThenElse(Arg1() <= Param(homogeneityThreshold), Param(1), Param(0)));
554 
555  // Erosion
556  discErosion(srcImageRange(btmp), destIter(dul, dest), windowRadius);
557 }
558 
559 template <class SrcIterator, class SrcAccessor,
560  class DestIterator, class DestAccessor>
561 void
562 findHomogeneousRegions(
563  SrcIterator sul, SrcIterator slr, SrcAccessor src,
564  DestIterator dul, DestAccessor dest)
565 {
566  localMinima(sul, slr, src, dul, dest);
567 }
568 
569 template <class Vector1, class Vector2>
570 void noiseVarianceListMedianCut(Vector1 const & noise, Vector2 & clusters,
571  unsigned int maxClusterCount)
572 {
573  typedef typename Vector2::value_type Result;
574 
575  clusters.push_back(Result(0, noise.size()));
576 
577  while(clusters.size() <= maxClusterCount)
578  {
579  // find biggest cluster
580  unsigned int kMax = 0;
581  double diffMax = 0.0;
582  for(unsigned int k=0; k < clusters.size(); ++k)
583  {
584  int k1 = clusters[k][0], k2 = clusters[k][1]-1;
585 
586 #if 0 // turned the "internal error" in a postcondition message
587  // for the most likely case
588  std::string message("noiseVarianceListMedianCut(): internal error (");
589  message += std::string("k: ") + asString(k) + ", ";
590  message += std::string("k1: ") + asString(k1) + ", ";
591  message += std::string("k2: ") + asString(k2) + ", ";
592  message += std::string("noise.size(): ") + asString(noise.size()) + ", ";
593  message += std::string("clusters.size(): ") + asString(clusters.size()) + ").";
594  vigra_invariant(k1 >= 0 && k1 < (int)noise.size() && k2 >= 0 && k2 < (int)noise.size(), message.c_str());
595 #endif
596 
597  vigra_postcondition(k1 >= 0 && k1 < (int)noise.size() &&
598  k2 >= 0 && k2 < (int)noise.size(),
599  "noiseVarianceClustering(): Unable to find homogeneous regions.");
600 
601  double diff = noise[k2][0] - noise[k1][0];
602  if(diff > diffMax)
603  {
604  diffMax = diff;
605  kMax = k;
606  }
607  }
608 
609  if(diffMax == 0.0)
610  return; // all clusters have only one value
611 
612  unsigned int k1 = clusters[kMax][0],
613  k2 = clusters[kMax][1];
614  unsigned int kSplit = k1 + (k2 - k1) / 2;
615  clusters[kMax][1] = kSplit;
616  clusters.push_back(Result(kSplit, k2));
617  }
618 }
619 
620 struct SortNoiseByMean
621 {
622  template <class T>
623  bool operator()(T const & l, T const & r) const
624  {
625  return l[0] < r[0];
626  }
627 };
628 
629 struct SortNoiseByVariance
630 {
631  template <class T>
632  bool operator()(T const & l, T const & r) const
633  {
634  return l[1] < r[1];
635  }
636 };
637 
638 template <class Vector1, class Vector2, class Vector3>
639 void noiseVarianceClusterAveraging(Vector1 & noise, Vector2 & clusters,
640  Vector3 & result, double quantile)
641 {
642  typedef typename Vector1::iterator Iter;
643  typedef typename Vector3::value_type Result;
644 
645  for(unsigned int k=0; k<clusters.size(); ++k)
646  {
647  Iter i1 = noise.begin() + clusters[k][0];
648  Iter i2 = noise.begin() + clusters[k][1];
649 
650  std::sort(i1, i2, SortNoiseByVariance());
651 
652  std::size_t size = static_cast<std::size_t>(VIGRA_CSTD::ceil(quantile*(i2 - i1)));
653  if(static_cast<std::size_t>(i2 - i1) < size)
654  size = i2 - i1;
655  if(size < 1)
656  size = 1;
657  i2 = i1 + size;
658 
659  double mean = 0.0,
660  variance = 0.0;
661  for(; i1 < i2; ++i1)
662  {
663  mean += (*i1)[0];
664  variance += (*i1)[1];
665  }
666 
667  result.push_back(Result(mean / size, variance / size));
668  }
669 }
670 
671 template <class SrcIterator, class SrcAccessor, class BackInsertable>
672 void noiseVarianceEstimationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
673  BackInsertable & result,
674  NoiseNormalizationOptions const & options)
675 {
676  typedef typename BackInsertable::value_type ResultType;
677 
678  unsigned int w = slr.x - sul.x;
679  unsigned int h = slr.y - sul.y;
680 
681  typedef typename NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
682  typedef BasicImage<TmpType> TmpImage;
683 
684  TmpImage gradient(w, h);
685  symmetricDifferenceSquaredMagnitude(sul, slr, src, gradient.upperLeft(), gradient.accessor());
686 
687  BImage homogeneous(w, h);
688  findHomogeneousRegions(gradient.upperLeft(), gradient.lowerRight(), gradient.accessor(),
689  homogeneous.upperLeft(), homogeneous.accessor());
690 
691  // Generate noise of each of the remaining pixels == centers of homogeneous areas (border is not used)
692  unsigned int windowRadius = options.window_radius;
693  for(unsigned int y=windowRadius; y<h-windowRadius; ++y)
694  {
695  for(unsigned int x=windowRadius; x<w-windowRadius; ++x)
696  {
697  if (! homogeneous(x, y))
698  continue;
699 
700  Diff2D center(x, y);
701  double mean = 0.0, variance = options.noise_variance_initial_guess;
702 
703  bool success;
704 
705  if(options.use_gradient)
706  {
707  success = iterativeNoiseEstimationChi2(sul + center, src,
708  gradient.upperLeft() + center, mean, variance,
709  options.noise_estimation_quantile, windowRadius);
710  }
711  else
712  {
713  success = iterativeNoiseEstimationGauss(sul + center, src,
714  gradient.upperLeft() + center, mean, variance,
715  options.noise_estimation_quantile, windowRadius);
716  }
717  if (success)
718  {
719  result.push_back(ResultType(mean, variance));
720  }
721  }
722  }
723 }
724 
725 template <class Vector, class BackInsertable>
726 void noiseVarianceClusteringImpl(Vector & noise, BackInsertable & result,
727  unsigned int clusterCount, double quantile)
728 {
729  std::sort(noise.begin(), noise.end(), detail::SortNoiseByMean());
730 
731  ArrayVector<TinyVector<unsigned int, 2> > clusters;
732  detail::noiseVarianceListMedianCut(noise, clusters, clusterCount);
733 
734  std::sort(clusters.begin(), clusters.end(), detail::SortNoiseByMean());
735 
736  detail::noiseVarianceClusterAveraging(noise, clusters, result, quantile);
737 }
738 
739 template <class Functor,
740  class SrcIterator, class SrcAccessor,
741  class DestIterator, class DestAccessor>
742 bool
743 noiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
744  DestIterator dul, DestAccessor dest,
745  NoiseNormalizationOptions const & options)
746 {
747  ArrayVector<TinyVector<double, 2> > noiseData;
748  noiseVarianceEstimationImpl(sul, slr, src, noiseData, options);
749 
750  if(noiseData.size() < 10)
751  return false;
752 
753  ArrayVector<TinyVector<double, 2> > noiseClusters;
754 
755  noiseVarianceClusteringImpl(noiseData, noiseClusters,
756  options.cluster_count, options.averaging_quantile);
757 
758  transformImage(sul, slr, src, dul, dest, Functor(noiseClusters));
759 
760  return true;
761 }
762 
763 template <class SrcIterator, class SrcAccessor,
764  class DestIterator, class DestAccessor>
765 bool
766 nonparametricNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
767  DestIterator dul, DestAccessor dest,
768  NoiseNormalizationOptions const & options,
769  VigraTrueType /* isScalar */)
770 {
771  typedef typename SrcAccessor::value_type SrcType;
772  typedef typename DestAccessor::value_type DestType;
773  return noiseNormalizationImpl<NonparametricNoiseNormalizationFunctor<SrcType, DestType> >
774  (sul, slr, src, dul, dest, options);
775 }
776 
777 template <class SrcIterator, class SrcAccessor,
778  class DestIterator, class DestAccessor>
779 bool
780 nonparametricNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
781  DestIterator dul, DestAccessor dest,
782  NoiseNormalizationOptions const & options,
783  VigraFalseType /* isScalar */)
784 {
785  int bands = src.size(sul);
786  for(int b=0; b<bands; ++b)
787  {
788  VectorElementAccessor<SrcAccessor> sband(b, src);
789  VectorElementAccessor<DestAccessor> dband(b, dest);
790  typedef typename VectorElementAccessor<SrcAccessor>::value_type SrcType;
791  typedef typename VectorElementAccessor<DestAccessor>::value_type DestType;
792 
793  if(!noiseNormalizationImpl<NonparametricNoiseNormalizationFunctor<SrcType, DestType> >
794  (sul, slr, sband, dul, dband, options))
795  return false;
796  }
797  return true;
798 }
799 
800 template <class SrcIterator, class SrcAccessor,
801  class DestIterator, class DestAccessor>
802 bool
803 quadraticNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
804  DestIterator dul, DestAccessor dest,
805  NoiseNormalizationOptions const & options,
806  VigraTrueType /* isScalar */)
807 {
808  typedef typename SrcAccessor::value_type SrcType;
809  typedef typename DestAccessor::value_type DestType;
810  return noiseNormalizationImpl<QuadraticNoiseNormalizationFunctor<SrcType, DestType> >
811  (sul, slr, src, dul, dest, options);
812 }
813 
814 template <class SrcIterator, class SrcAccessor,
815  class DestIterator, class DestAccessor>
816 bool
817 quadraticNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
818  DestIterator dul, DestAccessor dest,
819  NoiseNormalizationOptions const & options,
820  VigraFalseType /* isScalar */)
821 {
822  int bands = src.size(sul);
823  for(int b=0; b<bands; ++b)
824  {
825  VectorElementAccessor<SrcAccessor> sband(b, src);
826  VectorElementAccessor<DestAccessor> dband(b, dest);
827  typedef typename VectorElementAccessor<SrcAccessor>::value_type SrcType;
828  typedef typename VectorElementAccessor<DestAccessor>::value_type DestType;
829 
830  if(!noiseNormalizationImpl<QuadraticNoiseNormalizationFunctor<SrcType, DestType> >
831  (sul, slr, sband, dul, dband, options))
832  return false;
833  }
834  return true;
835 }
836 
837 template <class SrcIterator, class SrcAccessor,
838  class DestIterator, class DestAccessor>
839 void
840 quadraticNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
841  DestIterator dul, DestAccessor dest,
842  double a0, double a1, double a2,
843  VigraTrueType /* isScalar */)
844 {
845  ArrayVector<TinyVector<double, 2> > noiseClusters;
846  noiseClusters.push_back(TinyVector<double, 2>(0.0, a0));
847  noiseClusters.push_back(TinyVector<double, 2>(1.0, a0 + a1 + a2));
848  noiseClusters.push_back(TinyVector<double, 2>(2.0, a0 + 2.0*a1 + 4.0*a2));
849  transformImage(sul, slr, src, dul, dest,
850  QuadraticNoiseNormalizationFunctor<typename SrcAccessor::value_type,
851  typename DestAccessor::value_type>(noiseClusters));
852 }
853 
854 template <class SrcIterator, class SrcAccessor,
855  class DestIterator, class DestAccessor>
856 void
857 quadraticNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
858  DestIterator dul, DestAccessor dest,
859  double a0, double a1, double a2,
860  VigraFalseType /* isScalar */)
861 {
862  int bands = src.size(sul);
863  for(int b=0; b<bands; ++b)
864  {
865  VectorElementAccessor<SrcAccessor> sband(b, src);
866  VectorElementAccessor<DestAccessor> dband(b, dest);
867  quadraticNoiseNormalizationImpl(sul, slr, sband, dul, dband, a0, a1, a2, VigraTrueType());
868  }
869 }
870 
871 template <class SrcIterator, class SrcAccessor,
872  class DestIterator, class DestAccessor>
873 bool
874 linearNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
875  DestIterator dul, DestAccessor dest,
876  NoiseNormalizationOptions const & options,
877  VigraTrueType /* isScalar */)
878 {
879  typedef typename SrcAccessor::value_type SrcType;
880  typedef typename DestAccessor::value_type DestType;
881  return noiseNormalizationImpl<LinearNoiseNormalizationFunctor<SrcType, DestType> >
882  (sul, slr, src, dul, dest, options);
883 }
884 
885 template <class SrcIterator, class SrcAccessor,
886  class DestIterator, class DestAccessor>
887 bool
888 linearNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
889  DestIterator dul, DestAccessor dest,
890  NoiseNormalizationOptions const & options,
891  VigraFalseType /* isScalar */)
892 {
893  int bands = src.size(sul);
894  for(int b=0; b<bands; ++b)
895  {
896  VectorElementAccessor<SrcAccessor> sband(b, src);
897  VectorElementAccessor<DestAccessor> dband(b, dest);
898  typedef typename VectorElementAccessor<SrcAccessor>::value_type SrcType;
899  typedef typename VectorElementAccessor<DestAccessor>::value_type DestType;
900 
901  if(!noiseNormalizationImpl<LinearNoiseNormalizationFunctor<SrcType, DestType> >
902  (sul, slr, sband, dul, dband, options))
903  return false;
904  }
905  return true;
906 }
907 
908 template <class SrcIterator, class SrcAccessor,
909  class DestIterator, class DestAccessor>
910 void
911 linearNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
912  DestIterator dul, DestAccessor dest,
913  double a0, double a1,
914  VigraTrueType /* isScalar */)
915 {
916  ArrayVector<TinyVector<double, 2> > noiseClusters;
917  noiseClusters.push_back(TinyVector<double, 2>(0.0, a0));
918  noiseClusters.push_back(TinyVector<double, 2>(1.0, a0 + a1));
919  transformImage(sul, slr, src, dul, dest,
920  LinearNoiseNormalizationFunctor<typename SrcAccessor::value_type,
921  typename DestAccessor::value_type>(noiseClusters));
922 }
923 
924 template <class SrcIterator, class SrcAccessor,
925  class DestIterator, class DestAccessor>
926 void
927 linearNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
928  DestIterator dul, DestAccessor dest,
929  double a0, double a1,
930  VigraFalseType /* isScalar */)
931 {
932  int bands = src.size(sul);
933  for(int b=0; b<bands; ++b)
934  {
935  VectorElementAccessor<SrcAccessor> sband(b, src);
936  VectorElementAccessor<DestAccessor> dband(b, dest);
937  linearNoiseNormalizationImpl(sul, slr, sband, dul, dband, a0, a1, VigraTrueType());
938  }
939 }
940 
941 } // namespace detail
942 
943 template <bool P>
944 struct noiseVarianceEstimation_can_only_work_on_scalar_images
945 : vigra::staticAssert::AssertBool<P>
946 {};
947 
948 /** \addtogroup NoiseNormalization Noise Normalization
949  Estimate noise with intensity-dependent variance and transform it into additive Gaussian noise.
950 */
951 //@{
952 
953 /********************************************************/
954 /* */
955 /* noiseVarianceEstimation */
956 /* */
957 /********************************************************/
958 
959 /** \brief Determine the noise variance as a function of the image intensity.
960 
961  This operator applies an algorithm described in
962 
963  W. F&ouml;rstner: <i>"Image Preprocessing for Feature Extraction in Digital Intensity, Color and Range Images"</i>,
964  Proc. Summer School on Data Analysis and the Statistical Foundations of Geomatics,
965  Lecture Notes in Earth Science, Berlin: Springer, 1999
966 
967  in order to estimate the noise variance as a function of the image intensity in a robust way,
968  i.e. so that intensity changes due to edges do not bias the estimate. The source value type
969  (<TT>SrcAccessor::value_type</TT>) must be a scalar type which is convertible to <tt>double</tt>.
970  The result is written into the \a result sequence, whose <tt>value_type</tt> must be constructible
971  from two <tt>double</tt> values. The following options can be set via the \a options object
972  (see \ref vigra::NoiseNormalizationOptions for details):<br><br>
973 
974  <tt>useGradient</tt>, <tt>windowRadius</tt>, <tt>noiseEstimationQuantile</tt>, <tt>noiseVarianceInitialGuess</tt>
975 
976  <b> Declarations:</b>
977 
978  pass 2D array views:
979  \code
980  namespace vigra {
981  template <class T1, class S1, class BackInsertable>
982  void
983  noiseVarianceEstimation(MultiArrayView<2, T1, S1> const & src,
984  BackInsertable & result,
985  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
986  }
987  \endcode
988 
989  \deprecatedAPI{noiseVarianceEstimation}
990  pass \ref ImageIterators and \ref DataAccessors :
991  \code
992  namespace vigra {
993  template <class SrcIterator, class SrcAccessor, class BackInsertable>
994  void noiseVarianceEstimation(SrcIterator sul, SrcIterator slr, SrcAccessor src,
995  BackInsertable & result,
996  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
997  }
998  \endcode
999  use argument objects in conjunction with \ref ArgumentObjectFactories :
1000  \code
1001  namespace vigra {
1002  template <class SrcIterator, class SrcAccessor, class BackInsertable>
1003  void noiseVarianceEstimation(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1004  BackInsertable & result,
1005  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1006  }
1007  \endcode
1008  \deprecatedEnd
1009 
1010  <b> Usage:</b>
1011 
1012  <b>\#include</b> <vigra/noise_normalization.hxx><br>
1013  Namespace: vigra
1014 
1015  \code
1016  MultiArray<2, float> src(w,h);
1017  std::vector<TinyVector<double, 2> > result;
1018 
1019  ...
1020  noiseVarianceEstimation(src, result,
1021  NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0));
1022 
1023  // print the intensity / variance pairs found
1024  for(int k=0; k<result.size(); ++k)
1025  std::cout << "Intensity: " << result[k][0] << ", estimated variance: " << result[k][1] << std::endl;
1026  \endcode
1027 
1028  \deprecatedUsage{noiseVarianceEstimation}
1029  \code
1030  vigra::BImage src(w,h);
1031  std::vector<vigra::TinyVector<double, 2> > result;
1032 
1033  ...
1034  vigra::noiseVarianceEstimation(srcImageRange(src), result,
1035  vigra::NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0));
1036 
1037  // print the intensity / variance pairs found
1038  for(int k=0; k<result.size(); ++k)
1039  std::cout << "Intensity: " << result[k][0] << ", estimated variance: " << result[k][1] << std::endl;
1040  \endcode
1041  <b> Required Interface:</b>
1042  \code
1043  SrcIterator upperleft, lowerright;
1044  SrcAccessor src;
1045 
1046  typedef SrcAccessor::value_type SrcType;
1047  typedef NumericTraits<SrcType>::isScalar isScalar;
1048  assert(isScalar::asBool == true);
1049 
1050  double value = src(uperleft);
1051 
1052  BackInsertable result;
1053  typedef BackInsertable::value_type ResultType;
1054  double intensity, variance;
1055  result.push_back(ResultType(intensity, variance));
1056  \endcode
1057  \deprecatedEnd
1058 */
1059 doxygen_overloaded_function(template <...> void noiseVarianceEstimation)
1060 
1061 template <class SrcIterator, class SrcAccessor, class BackInsertable>
1062 inline
1063 void noiseVarianceEstimation(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1064  BackInsertable & result,
1065  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1066 {
1067  typedef typename SrcAccessor::value_type SrcType;
1068  typedef typename NumericTraits<SrcType>::isScalar isScalar;
1069 
1070  VIGRA_STATIC_ASSERT((
1071  noiseVarianceEstimation_can_only_work_on_scalar_images<(isScalar::asBool)>));
1072 
1073  detail::noiseVarianceEstimationImpl(sul, slr, src, result, options);
1074 }
1075 
1076 template <class SrcIterator, class SrcAccessor, class BackInsertable>
1077 inline void
1078 noiseVarianceEstimation(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1079  BackInsertable & result,
1080  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1081 {
1082  noiseVarianceEstimation(src.first, src.second, src.third, result, options);
1083 }
1084 
1085 template <class T1, class S1, class BackInsertable>
1086 inline void
1087 noiseVarianceEstimation(MultiArrayView<2, T1, S1> const & src,
1088  BackInsertable & result,
1089  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1090 {
1091  noiseVarianceEstimation(srcImageRange(src), result, options);
1092 }
1093 
1094 /********************************************************/
1095 /* */
1096 /* noiseVarianceClustering */
1097 /* */
1098 /********************************************************/
1099 
1100 /** \brief Determine the noise variance as a function of the image intensity and cluster the results.
1101 
1102  This operator first calls \ref noiseVarianceEstimation() to obtain a sequence of intensity/variance pairs,
1103  which are then clustered using the median cut algorithm. Then the cluster centers (i.e. average variance vs.
1104  average intensity) are determined and returned in the \a result sequence.
1105 
1106  In addition to the options valid for \ref noiseVarianceEstimation(), the following options can be set via
1107  the \a options object (see \ref vigra::NoiseNormalizationOptions for details):<br><br>
1108 
1109  <tt>clusterCount</tt>, <tt>averagingQuantile</tt>
1110 
1111  <b> Declarations:</b>
1112 
1113  pass 2D array views:
1114  \code
1115  namespace vigra {
1116  template <class T1, class S1, class BackInsertable>
1117  void
1118  noiseVarianceClustering(MultiArrayView<2, T1, S1> const & src,
1119  BackInsertable & result,
1120  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1121  }
1122  \endcode
1123 
1124  \deprecatedAPI{noiseVarianceClustering}
1125  pass \ref ImageIterators and \ref DataAccessors :
1126  \code
1127  namespace vigra {
1128  template <class SrcIterator, class SrcAccessor, class BackInsertable>
1129  void noiseVarianceClustering(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1130  BackInsertable & result,
1131  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1132  }
1133  \endcode
1134  use argument objects in conjunction with \ref ArgumentObjectFactories :
1135  \code
1136  namespace vigra {
1137  template <class SrcIterator, class SrcAccessor, class BackInsertable>
1138  void noiseVarianceClustering(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1139  BackInsertable & result,
1140  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1141  }
1142  \endcode
1143  \deprecatedEnd
1144 
1145  <b> Usage:</b>
1146 
1147  <b>\#include</b> <vigra/noise_normalization.hxx><br>
1148  Namespace: vigra
1149 
1150  \code
1151  MultiArray<2, float> src(w,h);
1152  std::vector<TinyVector<double, 2> > result;
1153 
1154  ...
1155  noiseVarianceClustering(src, result,
1156  NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0).
1157  clusterCount(15));
1158 
1159  // print the intensity / variance pairs representing the cluster centers
1160  for(int k=0; k<result.size(); ++k)
1161  std::cout << "Cluster: " << k << ", intensity: " << result[k][0] << ", estimated variance: " << result[k][1] << std::endl;
1162  \endcode
1163 
1164  \deprecatedUsage{noiseVarianceClustering}
1165  \code
1166  vigra::BImage src(w,h);
1167  std::vector<vigra::TinyVector<double, 2> > result;
1168 
1169  ...
1170  vigra::noiseVarianceClustering(srcImageRange(src), result,
1171  vigra::NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0).
1172  clusterCount(15));
1173 
1174  // print the intensity / variance pairs representing the cluster centers
1175  for(int k=0; k<result.size(); ++k)
1176  std::cout << "Cluster: " << k << ", intensity: " << result[k][0] << ", estimated variance: " << result[k][1] << std::endl;
1177  \endcode
1178  <b> Required Interface:</b>
1179  same as \ref noiseVarianceEstimation()
1180  \deprecatedEnd
1181 */
1182 doxygen_overloaded_function(template <...> void noiseVarianceClustering)
1183 
1184 template <class SrcIterator, class SrcAccessor, class BackInsertable>
1185 inline
1186 void noiseVarianceClustering(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1187  BackInsertable & result,
1188  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1189 {
1190  ArrayVector<TinyVector<double, 2> > variance;
1191  noiseVarianceEstimation(sul, slr, src, variance, options);
1192  detail::noiseVarianceClusteringImpl(variance, result, options.cluster_count, options.averaging_quantile);
1193 }
1194 
1195 template <class SrcIterator, class SrcAccessor, class BackInsertable>
1196 inline void
1197 noiseVarianceClustering(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1198  BackInsertable & result,
1199  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1200 {
1201  noiseVarianceClustering(src.first, src.second, src.third, result, options);
1202 }
1203 
1204 template <class T1, class S1, class BackInsertable>
1205 inline void
1206 noiseVarianceClustering(MultiArrayView<2, T1, S1> const & src,
1207  BackInsertable & result,
1208  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1209 {
1210  noiseVarianceClustering(srcImageRange(src), result, options);
1211 }
1212 
1213 /********************************************************/
1214 /* */
1215 /* nonparametricNoiseNormalization */
1216 /* */
1217 /********************************************************/
1218 
1219 /** \brief Noise normalization by means of an estimated non-parametric noise model.
1220 
1221  The original image is assumed to be corrupted by noise whose variance depends on the intensity in an unknown way.
1222  The present functions first calls \ref noiseVarianceClustering() to obtain a sequence of intensity/variance pairs
1223  (cluster centers) which estimate this dependency. The cluster centers are connected into a piecewise linear
1224  function which is the inverted according to the formula derived in
1225 
1226  W. F&ouml;rstner: <i>"Image Preprocessing for Feature Extraction in Digital Intensity, Color and Range Images"</i>,
1227  Proc. Summer School on Data Analysis and the Statistical Foundations of Geomatics,
1228  Lecture Notes in Earth Science, Berlin: Springer, 1999
1229 
1230  The inverted formula defines a pixel-wise intensity transformation whose application turns the original image
1231  into one that is corrupted by additive Gaussian noise with unit variance. Most subsequent algorithms will be able
1232  to handle this type of noise much better than the original noise.
1233 
1234  RGB and other multiband images will be processed one band at a time. The function returns <tt>true</tt> on success.
1235  Noise normalization will fail if the original image does not contain sufficiently homogeneous regions that
1236  allow robust estimation of the noise variance.
1237 
1238  The \a options object may use all options described in \ref vigra::NoiseNormalizationOptions.
1239 
1240  The function returns <tt>false</tt> if the noise estimation failed, so that no normalization could be performed.
1241 
1242  <b> Declarations:</b>
1243 
1244  pass 2D array views:
1245  \code
1246  namespace vigra {
1247  template <class T1, class S1,
1248  class T2, class S2>
1249  bool
1250  nonparametricNoiseNormalization(MultiArrayView<2, T1, S1> const & src,
1251  MultiArrayView<2, T2, S2> dest,
1252  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1253  }
1254  \endcode
1255 
1256  \deprecatedAPI{nonparametricNoiseNormalization}
1257  pass \ref ImageIterators and \ref DataAccessors :
1258  \code
1259  namespace vigra {
1260  template <class SrcIterator, class SrcAccessor,
1261  class DestIterator, class DestAccessor>
1262  bool nonparametricNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1263  DestIterator dul, DestAccessor dest,
1264  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1265  }
1266  \endcode
1267  use argument objects in conjunction with \ref ArgumentObjectFactories :
1268  \code
1269  namespace vigra {
1270  template <class SrcIterator, class SrcAccessor,
1271  class DestIterator, class DestAccessor>
1272  bool nonparametricNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1273  pair<DestIterator, DestAccessor> dest,
1274  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1275  }
1276  \endcode
1277  \deprecatedEnd
1278 
1279  <b> Usage:</b>
1280 
1281  <b>\#include</b> <vigra/noise_normalization.hxx><br>
1282  Namespace: vigra
1283 
1284  \code
1285  MultiArray<2, RGBValue<float> > src(w,h), dest(w, h);
1286 
1287  ...
1288  nonparametricNoiseNormalization(src, dest,
1289  NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0).
1290  clusterCount(15));
1291  \endcode
1292 
1293  \deprecatedUsage{nonparametricNoiseNormalization}
1294  \code
1295  vigra::BRGBImage src(w,h), dest(w, h);
1296 
1297  ...
1298  vigra::nonparametricNoiseNormalization(srcImageRange(src), destImage(dest),
1299  vigra::NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0).
1300  clusterCount(15));
1301  \endcode
1302  <b> Required Interface:</b>
1303  same as \ref noiseVarianceEstimation()
1304  \deprecatedEnd
1305 */
1306 doxygen_overloaded_function(template <...> bool nonparametricNoiseNormalization)
1307 
1308 template <class SrcIterator, class SrcAccessor,
1309  class DestIterator, class DestAccessor>
1310 inline bool
1311 nonparametricNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1312  DestIterator dul, DestAccessor dest,
1313  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1314 {
1315  typedef typename SrcAccessor::value_type SrcType;
1316 
1317  return detail::nonparametricNoiseNormalizationImpl(sul, slr, src, dul, dest, options,
1318  typename NumericTraits<SrcType>::isScalar());
1319 }
1320 
1321 template <class SrcIterator, class SrcAccessor,
1322  class DestIterator, class DestAccessor>
1323 inline bool
1324 nonparametricNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1325  pair<DestIterator, DestAccessor> dest,
1326  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1327 {
1328  return nonparametricNoiseNormalization(src.first, src.second, src.third, dest.first, dest.second, options);
1329 }
1330 
1331 template <class T1, class S1,
1332  class T2, class S2>
1333 inline bool
1334 nonparametricNoiseNormalization(MultiArrayView<2, T1, S1> const & src,
1335  MultiArrayView<2, T2, S2> dest,
1336  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1337 {
1338  vigra_precondition(src.shape() == dest.shape(),
1339  "nonparametricNoiseNormalization(): shape mismatch between input and output.");
1340  return nonparametricNoiseNormalization(srcImageRange(src), destImage(dest), options);
1341 }
1342 
1343 /********************************************************/
1344 /* */
1345 /* quadraticNoiseNormalization */
1346 /* */
1347 /********************************************************/
1348 
1349 /** \brief Noise normalization by means of an estimated or given quadratic noise model.
1350 
1351  This function works like \ref nonparametricNoiseNormalization() excapt that the model for the
1352  dependency between intensity and noise variance is assumed to be a
1353  quadratic function rather than a piecewise linear function. If the data conform to the quadratic model,
1354  this leads to a somewhat smoother transformation. The function returns <tt>false</tt> if the noise
1355  estimation failed, so that no normalization could be performed.
1356 
1357  In the second variant of the function, the parameters of the quadratic model are not estimated,
1358  but explicitly given according to:
1359  \code
1360  variance = a0 + a1 * intensity + a2 * sq(intensity)
1361  \endcode
1362 
1363  <b> Declarations:</b>
1364 
1365  pass 2D array views:
1366  \code
1367  namespace vigra {
1368  // estimate and apply a quadratic noise model
1369  template <class T1, class S1,
1370  class T2, class S2>
1371  bool
1372  quadraticNoiseNormalization(MultiArrayView<2, T1, S1> const & src,
1373  MultiArrayView<2, T2, S2> dest,
1374  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1375 
1376  // apply a given quadratic noise model
1377  template <class T1, class S1,
1378  class T2, class S2>
1379  void
1380  quadraticNoiseNormalization(MultiArrayView<2, T1, S1> const & src,
1381  MultiArrayView<2, T2, S2> dest,
1382  double a0, double a1, double a2);
1383  }
1384  \endcode
1385 
1386  \deprecatedAPI{quadraticNoiseNormalization}
1387  pass \ref ImageIterators and \ref DataAccessors :
1388  \code
1389  namespace vigra {
1390  // estimate and apply a quadratic noise model
1391  template <class SrcIterator, class SrcAccessor,
1392  class DestIterator, class DestAccessor>
1393  bool quadraticNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1394  DestIterator dul, DestAccessor dest,
1395  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1396 
1397  // apply a given quadratic noise model
1398  template <class SrcIterator, class SrcAccessor,
1399  class DestIterator, class DestAccessor>
1400  void quadraticNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1401  DestIterator dul, DestAccessor dest,
1402  double a0, double a1, double a2);
1403  }
1404  \endcode
1405  use argument objects in conjunction with \ref ArgumentObjectFactories :
1406  \code
1407  namespace vigra {
1408  // estimate and apply a quadratic noise model
1409  template <class SrcIterator, class SrcAccessor,
1410  class DestIterator, class DestAccessor>
1411  bool quadraticNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1412  pair<DestIterator, DestAccessor> dest,
1413  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1414 
1415  // apply a given quadratic noise model
1416  template <class SrcIterator, class SrcAccessor,
1417  class DestIterator, class DestAccessor>
1418  void quadraticNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1419  pair<DestIterator, DestAccessor> dest,
1420  double a0, double a1, double a2);
1421  }
1422  \endcode
1423  \deprecatedEnd
1424 
1425  <b> Usage:</b>
1426 
1427  <b>\#include</b> <vigra/noise_normalization.hxx><br>
1428  Namespace: vigra
1429 
1430  \code
1431  MultiArray<2, RGBValue<float> > src(w,h), dest(w, h);
1432 
1433  ...
1434  // estimate the noise model and apply it to normalize the noise variance
1435  bool success = quadraticNoiseNormalization(src, dest,
1436  NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0).
1437  clusterCount(15));
1438  vigra_postcondition(success, "quadraticNoiseNormalization(): Unable to estimate noise model.");
1439 
1440  // apply a pre-computed noise model
1441  quadraticNoiseNormalization(src, dest, 100, 0.02, 1e-6);
1442  \endcode
1443 
1444  \deprecatedUsage{quadraticNoiseNormalization}
1445  \code
1446  vigra::BRGBImage src(w,h), dest(w, h);
1447 
1448  ...
1449  // estimate the noise model and apply it to normalize the noise variance
1450  vigra::quadraticNoiseNormalization(srcImageRange(src), destImage(dest),
1451  vigra::NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0).
1452  clusterCount(15));
1453 
1454  // apply a pre-computed noise model
1455  vigra::quadraticNoiseNormalization(srcImageRange(src), destImage(dest),
1456  100, 0.02, 1e-6);
1457  \endcode
1458  \deprecatedEnd
1459 
1460  <b> Required Interface:</b>
1461 
1462  The source value type must be convertible to <tt>double</tt> or must be a vector whose elements
1463  are convertible to <tt>double</tt>. Likewise, the destination type must be assignable from <tt>double</tt>
1464  or a vector whose elements are assignable from <tt>double</tt>.
1465 */
1466 doxygen_overloaded_function(template <...> bool quadraticNoiseNormalization)
1467 
1468 template <class SrcIterator, class SrcAccessor,
1469  class DestIterator, class DestAccessor>
1470 inline bool
1471 quadraticNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1472  DestIterator dul, DestAccessor dest,
1473  NoiseNormalizationOptions const & options)
1474 {
1475  typedef typename SrcAccessor::value_type SrcType;
1476 
1477  return detail::quadraticNoiseNormalizationImpl(sul, slr, src, dul, dest, options,
1478  typename NumericTraits<SrcType>::isScalar());
1479 }
1480 
1481 template <class SrcIterator, class SrcAccessor,
1482  class DestIterator, class DestAccessor>
1483 inline bool
1484 quadraticNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1485  pair<DestIterator, DestAccessor> dest,
1486  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1487 {
1488  return quadraticNoiseNormalization(src.first, src.second, src.third, dest.first, dest.second, options);
1489 }
1490 
1491 template <class T1, class S1,
1492  class T2, class S2>
1493 inline bool
1494 quadraticNoiseNormalization(MultiArrayView<2, T1, S1> const & src,
1495  MultiArrayView<2, T2, S2> dest,
1496  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1497 {
1498  vigra_precondition(src.shape() == dest.shape(),
1499  "quadraticNoiseNormalization(): shape mismatch between input and output.");
1500  return quadraticNoiseNormalization(srcImageRange(src), destImage(dest), options);
1501 }
1502 
1503 /********************************************************/
1504 /* */
1505 /* quadraticNoiseNormalization */
1506 /* (variant) */
1507 /* */
1508 /********************************************************/
1509 
1510 template <class SrcIterator, class SrcAccessor,
1511  class DestIterator, class DestAccessor>
1512 inline void
1513 quadraticNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1514  DestIterator dul, DestAccessor dest,
1515  double a0, double a1, double a2)
1516 {
1517  typedef typename SrcAccessor::value_type SrcType;
1518 
1519  detail::quadraticNoiseNormalizationImpl(sul, slr, src, dul, dest, a0, a1, a2,
1520  typename NumericTraits<SrcType>::isScalar());
1521 }
1522 
1523 template <class SrcIterator, class SrcAccessor,
1524  class DestIterator, class DestAccessor>
1525 inline void
1526 quadraticNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1527  pair<DestIterator, DestAccessor> dest,
1528  double a0, double a1, double a2)
1529 {
1530  quadraticNoiseNormalization(src.first, src.second, src.third, dest.first, dest.second, a0, a1, a2);
1531 }
1532 
1533 template <class T1, class S1,
1534  class T2, class S2>
1535 inline void
1536 quadraticNoiseNormalization(MultiArrayView<2, T1, S1> const & src,
1537  MultiArrayView<2, T2, S2> dest,
1538  double a0, double a1, double a2)
1539 {
1540  vigra_precondition(src.shape() == dest.shape(),
1541  "quadraticNoiseNormalization(): shape mismatch between input and output.");
1542  quadraticNoiseNormalization(srcImageRange(src), destImage(dest), a0, a1, a2);
1543 }
1544 
1545 /********************************************************/
1546 /* */
1547 /* linearNoiseNormalization */
1548 /* */
1549 /********************************************************/
1550 
1551 /** \brief Noise normalization by means of an estimated or given linear noise model.
1552 
1553  This function works like \ref nonparametricNoiseNormalization() excapt that the model for the
1554  dependency between intensity and noise variance is assumed to be a
1555  linear function rather than a piecewise linear function. If the data conform to the linear model,
1556  this leads to a very simple transformation which is similar to the familiar gamma correction.
1557  The function returns <tt>false</tt> if the noise estimation failed, so that no
1558  normalization could be performed.
1559 
1560  In the second variant of the function, the parameters of the linear model are not estimated,
1561  but explicitly given according to:
1562  \code
1563  variance = a0 + a1 * intensity
1564  \endcode
1565 
1566  <b> Declarations:</b>
1567 
1568  pass 2D array views:
1569  \code
1570  namespace vigra {
1571  // estimate and apply a linear noise model
1572  template <class T1, class S1,
1573  class T2, class S2>
1574  bool
1575  linearNoiseNormalization(MultiArrayView<2, T1, S1> const & src,
1576  MultiArrayView<2, T2, S2> dest,
1577  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1578 
1579  // apply a given linear noise model
1580  template <class T1, class S1,
1581  class T2, class S2>
1582  void
1583  linearNoiseNormalization(MultiArrayView<2, T1, S1> const & src,
1584  MultiArrayView<2, T2, S2> dest,
1585  double a0, double a1);
1586  }
1587  \endcode
1588 
1589  \deprecatedAPI{linearNoiseNormalization}
1590  pass \ref ImageIterators and \ref DataAccessors :
1591  \code
1592  namespace vigra {
1593  // estimate and apply a linear noise model
1594  template <class SrcIterator, class SrcAccessor,
1595  class DestIterator, class DestAccessor>
1596  bool linearNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1597  DestIterator dul, DestAccessor dest,
1598  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1599 
1600  // apply a given linear noise model
1601  template <class SrcIterator, class SrcAccessor,
1602  class DestIterator, class DestAccessor>
1603  void linearNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1604  DestIterator dul, DestAccessor dest,
1605  double a0, double a1);
1606  }
1607  \endcode
1608  use argument objects in conjunction with \ref ArgumentObjectFactories :
1609  \code
1610  namespace vigra {
1611  // estimate and apply a linear noise model
1612  template <class SrcIterator, class SrcAccessor,
1613  class DestIterator, class DestAccessor>
1614  bool linearNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1615  pair<DestIterator, DestAccessor> dest,
1616  NoiseNormalizationOptions const & options = NoiseNormalizationOptions());
1617 
1618  // apply a given linear noise model
1619  template <class SrcIterator, class SrcAccessor,
1620  class DestIterator, class DestAccessor>
1621  void linearNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1622  pair<DestIterator, DestAccessor> dest,
1623  double a0, double a1);
1624  }
1625  \endcode
1626  \deprecatedEnd
1627 
1628  <b> Usage:</b>
1629 
1630  <b>\#include</b> <vigra/noise_normalization.hxx><br>
1631  Namespace: vigra
1632 
1633  \code
1634  vigra::BRGBImage src(w,h), dest(w, h);
1635 
1636  ...
1637  // estimate the noise model and apply it to normalize the noise variance
1638  bool success = linearNoiseNormalization(src, dest,
1639  NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0).
1640  clusterCount(15));
1641  vigra_postcondition(success, "linearNoiseNormalization(): Unable to estimate noise model.");
1642 
1643  // apply a pre-computed noise model
1644  linearNoiseNormalization(src, dest, 100, 0.02);
1645  \endcode
1646 
1647  \deprecatedUsage{linearNoiseNormalization}
1648  \code
1649  vigra::BRGBImage src(w,h), dest(w, h);
1650 
1651  ...
1652  // estimate the noise model and apply it to normalize the noise variance
1653  vigra::linearNoiseNormalization(srcImageRange(src), destImage(dest),
1654  vigra::NoiseNormalizationOptions().windowRadius(9).noiseVarianceInitialGuess(25.0).
1655  clusterCount(15));
1656 
1657  // apply a pre-computed noise model
1658  vigra::linearNoiseNormalization(srcImageRange(src), destImage(dest),
1659  100, 0.02);
1660  \endcode
1661  \deprecatedEnd
1662 
1663  <b> Required Interface:</b>
1664 
1665  The source value type must be convertible to <tt>double</tt> or must be a vector whose elements
1666  are convertible to <tt>double</tt>. Likewise, the destination type must be assignable from <tt>double</tt>
1667  or a vector whose elements are assignable from <tt>double</tt>.
1668 */
1669 doxygen_overloaded_function(template <...> bool linearNoiseNormalization)
1670 
1671 template <class SrcIterator, class SrcAccessor,
1672  class DestIterator, class DestAccessor>
1673 inline bool
1674 linearNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1675  DestIterator dul, DestAccessor dest,
1676  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1677 {
1678  typedef typename SrcAccessor::value_type SrcType;
1679 
1680  return detail::linearNoiseNormalizationImpl(sul, slr, src, dul, dest, options,
1681  typename NumericTraits<SrcType>::isScalar());
1682 }
1683 
1684 template <class SrcIterator, class SrcAccessor,
1685  class DestIterator, class DestAccessor>
1686 inline bool
1687 linearNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1688  pair<DestIterator, DestAccessor> dest,
1689  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1690 {
1691  return linearNoiseNormalization(src.first, src.second, src.third, dest.first, dest.second, options);
1692 }
1693 
1694 template <class T1, class S1,
1695  class T2, class S2>
1696 inline bool
1697 linearNoiseNormalization(MultiArrayView<2, T1, S1> const & src,
1698  MultiArrayView<2, T2, S2> dest,
1699  NoiseNormalizationOptions const & options = NoiseNormalizationOptions())
1700 {
1701  vigra_precondition(src.shape() == dest.shape(),
1702  "linearNoiseNormalization(): shape mismatch between input and output.");
1703  return linearNoiseNormalization(srcImageRange(src), destImage(dest), options);
1704 }
1705 
1706 /********************************************************/
1707 /* */
1708 /* linearNoiseNormalization */
1709 /* (variant) */
1710 /* */
1711 /********************************************************/
1712 
1713 template <class SrcIterator, class SrcAccessor,
1714  class DestIterator, class DestAccessor>
1715 inline
1716 void linearNoiseNormalization(SrcIterator sul, SrcIterator slr, SrcAccessor src,
1717  DestIterator dul, DestAccessor dest,
1718  double a0, double a1)
1719 {
1720  typedef typename SrcAccessor::value_type SrcType;
1721 
1722  detail::linearNoiseNormalizationImpl(sul, slr, src, dul, dest, a0, a1,
1723  typename NumericTraits<SrcType>::isScalar());
1724 }
1725 
1726 template <class SrcIterator, class SrcAccessor,
1727  class DestIterator, class DestAccessor>
1728 inline void
1729 linearNoiseNormalization(triple<SrcIterator, SrcIterator, SrcAccessor> src,
1730  pair<DestIterator, DestAccessor> dest,
1731  double a0, double a1)
1732 {
1733  linearNoiseNormalization(src.first, src.second, src.third, dest.first, dest.second, a0, a1);
1734 }
1735 
1736 template <class T1, class S1,
1737  class T2, class S2>
1738 inline void
1739 linearNoiseNormalization(MultiArrayView<2, T1, S1> const & src,
1740  MultiArrayView<2, T2, S2> dest,
1741  double a0, double a1)
1742 {
1743  vigra_precondition(src.shape() == dest.shape(),
1744  "linearNoiseNormalization(): shape mismatch between input and output.");
1745  linearNoiseNormalization(srcImageRange(src), destImage(dest), a0, a1);
1746 }
1747 
1748 //@}
1749 
1750 } // namespace vigra
1751 
1752 #endif // VIGRA_NOISE_NORMALIZATION_HXX
vigra::NoiseNormalizationOptions::noiseEstimationQuantile
NoiseNormalizationOptions & noiseEstimationQuantile(double quantile)
Definition: noise_normalization.hxx:161
vigra::UInt8
detail::SelectIntegerType< 8, detail::UnsignedIntTypes >::type UInt8
8-bit unsigned int
Definition: sized_int.hxx:179
vigra::linalg::exp
linalg::TemporaryMatrix< T > exp(MultiArrayView< 2, T, C > const &v)
vigra::transformImage
void transformImage(...)
Apply unary point transformation to each pixel.
vigra::localMinima
void localMinima(...)
Find local minima in an image or multi-dimensional array.
vigra::nonparametricNoiseNormalization
bool nonparametricNoiseNormalization(...)
Noise normalization by means of an estimated non-parametric noise model.
vigra::linalg::asin
linalg::TemporaryMatrix< T > asin(MultiArrayView< 2, T, C > const &v)
vigra::NoiseNormalizationOptions::noiseVarianceInitialGuess
NoiseNormalizationOptions & noiseVarianceInitialGuess(double guess)
Definition: noise_normalization.hxx:174
vigra::UInt16
detail::SelectIntegerType< 16, detail::UnsignedIntTypes >::type UInt16
16-bit unsigned int
Definition: sized_int.hxx:181
vigra::linearNoiseNormalization
bool linearNoiseNormalization(...)
Noise normalization by means of an estimated or given linear noise model.
vigra::separableConvolveX
void separableConvolveX(...)
Performs a 1 dimensional convolution in x direction.
vigra::NoiseNormalizationOptions::NoiseNormalizationOptions
NoiseNormalizationOptions()
Definition: noise_normalization.hxx:95
vigra::discErosion
void discErosion(...)
Apply erosion (minimum) filter with disc of given radius to image.
vigra::BImage
BasicImage< UInt8 > BImage
Definition: stdimage.hxx:62
vigra::NoiseNormalizationOptions::averagingQuantile
NoiseNormalizationOptions & averagingQuantile(double quantile)
Definition: noise_normalization.hxx:147
vigra::sq
NumericTraits< T >::Promote sq(T t)
The square function.
Definition: mathutil.hxx:382
vigra::sum
NumericTraits< V >::Promote sum(TinyVectorBase< V, SIZE, D1, D2 > const &l)
sum of the vector's elements
Definition: tinyvector.hxx:2073
vigra::NoiseNormalizationOptions::clusterCount
NoiseNormalizationOptions & clusterCount(unsigned int c)
Definition: noise_normalization.hxx:132
vigra::asString
std::string asString(T t)(...)
vigra::combineTwoImages
void combineTwoImages(...)
Combine two source images into destination image.
vigra::NoiseNormalizationOptions::useGradient
NoiseNormalizationOptions & useGradient(bool r)
Definition: noise_normalization.hxx:109
vigra::doxygen_overloaded_function
doxygen_overloaded_function(template<...> void separableConvolveBlockwise) template< unsigned int N
Separated convolution on ChunkedArrays.
vigra::linalg::outer
void outer(const MultiArrayView< 2, T, C1 > &x, const MultiArrayView< 2, T, C2 > &y, MultiArrayView< 2, T, C3 > &r)
Definition: matrix.hxx:1459
vigra::NoiseNormalizationOptions
Pass options to one of the noise normalization functions.
Definition: noise_normalization.hxx:89
vigra::closeAtTolerance
bool closeAtTolerance(T1 l, T2 r, typename PromoteTraits< T1, T2 >::Promote epsilon)
Tolerance based floating-point equality.
Definition: mathutil.hxx:1638
vigra::linalg::log
linalg::TemporaryMatrix< T > log(MultiArrayView< 2, T, C > const &v)
vigra::NoiseNormalizationOptions::windowRadius
NoiseNormalizationOptions & windowRadius(unsigned int r)
Definition: noise_normalization.hxx:119
vigra::ceil
int ceil(FixedPoint< IntBits, FracBits > v)
rounding up.
Definition: fixedpoint.hxx:675
vigra::quadraticNoiseNormalization
bool quadraticNoiseNormalization(...)
Noise normalization by means of an estimated or given quadratic noise model.
vigra::noiseVarianceEstimation
void noiseVarianceEstimation(...)
Determine the noise variance as a function of the image intensity.
vigra::noiseVarianceClustering
void noiseVarianceClustering(...)
Determine the noise variance as a function of the image intensity and cluster the results...
vigra::separableConvolveY
void separableConvolveY(...)
Performs a 1 dimensional convolution in y direction.
vigra::linalg::linearSolve
bool linearSolve(...)
vigra::sqrt
SquareRootTraits< FixedPoint< IntBits, FracBits > >::SquareRootResult sqrt(FixedPoint< IntBits, FracBits > v)
square root.
Definition: fixedpoint.hxx:616

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
vigra 1.11.1 (Fri May 19 2017)