37 #ifndef VIGRA_NOISE_NORMALIZATION_HXX
38 #define VIGRA_NOISE_NORMALIZATION_HXX
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"
96 noise_estimation_quantile(1.5),
97 averaging_quantile(0.8),
98 noise_variance_initial_guess(10.0),
119 vigra_precondition(r > 0,
120 "NoiseNormalizationOptions: window radius must be > 0.");
132 vigra_precondition(c > 0,
133 "NoiseNormalizationOptions: cluster count must be > 0.");
147 vigra_precondition(quantile > 0.0 && quantile <= 1.0,
148 "NoiseNormalizationOptions: averaging quantile must be between 0 and 1.");
149 averaging_quantile = quantile;
161 vigra_precondition(quantile > 0.0,
162 "NoiseNormalizationOptions: noise estimation quantile must be > 0.");
163 noise_estimation_quantile = quantile;
174 vigra_precondition(guess > 0.0,
175 "NoiseNormalizationOptions: noise variance initial guess must be > 0.");
176 noise_variance_initial_guess = guess;
180 unsigned int window_radius, cluster_count;
181 double noise_estimation_quantile, averaging_quantile, noise_variance_initial_guess;
187 template <
class ArgumentType,
class ResultType>
188 class NonparametricNoiseNormalizationFunctor
192 double lower, a, b, shift;
195 ArrayVector<Segment> segments_;
198 double exec(
unsigned int k, T t)
const
200 if(segments_[k].a == 0.0)
206 return 2.0 / segments_[k].a *
VIGRA_CSTD::sqrt(std::max(0.0, segments_[k].a * t + segments_[k].b));
211 typedef ArgumentType argument_type;
212 typedef ResultType result_type;
214 template <
class Vector>
215 NonparametricNoiseNormalizationFunctor(Vector
const & clusters)
216 : segments_(clusters.size()-1)
218 for(
unsigned int k = 0; k<segments_.size(); ++k)
220 segments_[k].lower = clusters[k][0];
221 segments_[k].a = (clusters[k+1][1] - clusters[k][1]) / (clusters[k+1][0] - clusters[k][0]);
222 segments_[k].b = clusters[k][1] - segments_[k].a * clusters[k][0];
229 segments_[k].shift = segments_[k].lower - exec(k, segments_[k].lower);
233 segments_[k].shift = exec(k-1, segments_[k].lower) - exec(k, segments_[k].lower) + segments_[k-1].shift;
238 result_type operator()(argument_type t)
const
242 for(; k < segments_.size(); ++k)
243 if(t < segments_[k].lower)
247 return detail::RequiresExplicitCast<ResultType>::cast(exec(k, t) + segments_[k].shift);
251 template <
class ArgumentType,
class ResultType>
252 class QuadraticNoiseNormalizationFunctor
254 double a, b, c, d, f, o;
256 void init(
double ia,
double ib,
double ic,
double xmin)
275 typedef ArgumentType argument_type;
276 typedef ResultType result_type;
278 template <
class Vector>
279 QuadraticNoiseNormalizationFunctor(Vector
const & clusters)
281 double xmin = NumericTraits<double>::max();
282 Matrix<double> m(3,3), r(3, 1), l(3, 1);
283 for(
unsigned int k = 0; k<clusters.size(); ++k)
286 l(1,0) = clusters[k][0];
287 l(2,0) =
sq(clusters[k][0]);
289 r += clusters[k][1]*l;
290 if(clusters[k][0] < xmin)
291 xmin = clusters[k][0];
295 init(l(0,0), l(1,0), l(2,0), xmin);
298 result_type operator()(argument_type t)
const
305 return detail::RequiresExplicitCast<ResultType>::cast(r);
309 template <
class ArgumentType,
class ResultType>
310 class LinearNoiseNormalizationFunctor
314 void init(
double ia,
double ib,
double xmin)
329 typedef ArgumentType argument_type;
330 typedef ResultType result_type;
332 template <
class Vector>
333 LinearNoiseNormalizationFunctor(Vector
const & clusters)
335 double xmin = NumericTraits<double>::max();
336 Matrix<double> m(2,2), r(2, 1), l(2, 1);
337 for(
unsigned int k = 0; k<clusters.size(); ++k)
340 l(1,0) = clusters[k][0];
342 r += clusters[k][1]*l;
343 if(clusters[k][0] < xmin)
344 xmin = clusters[k][0];
348 init(l(0,0), l(1,0), xmin);
351 result_type operator()(argument_type t)
const
358 return detail::RequiresExplicitCast<ResultType>::cast(r);
362 #define VIGRA_NoiseNormalizationFunctor(name, type, size) \
363 template <class ResultType> \
364 class name<type, ResultType> \
366 ResultType lut_[size]; \
369 typedef type argument_type; \
370 typedef ResultType result_type; \
372 template <class Vector> \
373 name(Vector const & clusters) \
375 name<double, ResultType> f(clusters); \
377 for(unsigned int k = 0; k < size; ++k) \
383 result_type operator()(argument_type t) const \
389 VIGRA_NoiseNormalizationFunctor(NonparametricNoiseNormalizationFunctor,
UInt8, 256)
390 VIGRA_NoiseNormalizationFunctor(NonparametricNoiseNormalizationFunctor,
UInt16, 65536)
391 VIGRA_NoiseNormalizationFunctor(QuadraticNoiseNormalizationFunctor,
UInt8, 256)
392 VIGRA_NoiseNormalizationFunctor(QuadraticNoiseNormalizationFunctor, UInt16, 65536)
393 VIGRA_NoiseNormalizationFunctor(LinearNoiseNormalizationFunctor, UInt8, 256)
394 VIGRA_NoiseNormalizationFunctor(LinearNoiseNormalizationFunctor, UInt16, 65536)
396 #undef VIGRA_NoiseNormalizationFunctor
400 template <
class SrcIterator,
class SrcAcessor,
403 iterativeNoiseEstimationChi2(SrcIterator s, SrcAcessor src, GradIterator g,
404 double & mean,
double & variance,
405 double robustnessThreshold,
int windowRadius)
407 double l2 =
sq(robustnessThreshold);
411 Diff2D ul(-windowRadius, -windowRadius);
412 int r2 =
sq(windowRadius);
414 for(
int iter=0; iter<100 ; ++iter)
419 unsigned int count = 0;
420 unsigned int tcount = 0;
422 SrcIterator siy = s + ul;
423 GradIterator giy = g + ul;
424 for(
int y=-windowRadius; y <= windowRadius; y++, ++siy.y, ++giy.y)
426 typename SrcIterator::row_iterator six = siy.rowIterator();
427 typename GradIterator::row_iterator gix = giy.rowIterator();
428 for(
int x=-windowRadius; x <= windowRadius; x++, ++six, ++gix)
430 if (
sq(x) +
sq(y) > r2)
434 if (*gix < l2*variance)
445 double oldvariance = variance;
446 variance= f * gsum / count;
450 return (count >= tcount * countThreshold / 2.0);
455 template <
class SrcIterator,
class SrcAcessor,
458 iterativeNoiseEstimationGauss(SrcIterator s, SrcAcessor src, GradIterator,
459 double & mean,
double & variance,
460 double robustnessThreshold,
int windowRadius)
462 double l2 =
sq(robustnessThreshold);
468 Diff2D ul(-windowRadius, -windowRadius);
469 int r2 =
sq(windowRadius);
471 for(
int iter=0; iter<100 ; ++iter)
476 unsigned int count = 0;
477 unsigned int tcount = 0;
479 SrcIterator siy = s + ul;
480 for(
int y=-windowRadius; y <= windowRadius; y++, ++siy.y)
482 typename SrcIterator::row_iterator six = siy.rowIterator();
483 for(
int x=-windowRadius; x <= windowRadius; x++, ++six)
485 if (
sq(x) +
sq(y) > r2)
489 if (
sq(src(six) - mean) < l2*variance)
492 sum2 +=
sq(src(six));
500 double oldmean = mean;
501 double oldvariance = variance;
503 variance= f * (sum2 / count -
sq(mean));
507 return (count >= tcount * countThreshold / 2.0);
513 template <
class SrcIterator,
class SrcAccessor,
514 class DestIterator,
class DestAccessor>
516 symmetricDifferenceSquaredMagnitude(
517 SrcIterator sul, SrcIterator slr, SrcAccessor src,
518 DestIterator dul, DestAccessor dest)
520 using namespace functor;
521 int w = slr.x - sul.x;
522 int h = slr.y - sul.y;
524 typedef typename NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
525 typedef BasicImage<TmpType> TmpImage;
527 Kernel1D<double> mask;
528 mask.initSymmetricGradient();
529 mask.setBorderTreatment(BORDER_TREATMENT_REFLECT);
531 TmpImage dx(w, h), dy(w, h);
534 combineTwoImages(srcImageRange(dx), srcImage(dy), destIter(dul, dest), Arg1()*Arg1() + Arg2()*Arg2());
537 template <
class SrcIterator,
class SrcAccessor,
538 class DestIterator,
class DestAccessor>
540 findHomogeneousRegionsFoerstner(
541 SrcIterator sul, SrcIterator slr, SrcAccessor src,
542 DestIterator dul, DestAccessor dest,
543 unsigned int windowRadius = 6,
double homogeneityThreshold = 40.0)
545 using namespace vigra::functor;
546 int w = slr.x - sul.x;
547 int h = slr.y - sul.y;
549 typedef typename NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
550 typedef BasicImage<TmpType> TmpImage;
554 ifThenElse(Arg1() <= Param(homogeneityThreshold), Param(1), Param(0)));
557 discErosion(srcImageRange(btmp), destIter(dul, dest), windowRadius);
560 template <
class SrcIterator,
class SrcAccessor,
561 class DestIterator,
class DestAccessor>
563 findHomogeneousRegions(
564 SrcIterator sul, SrcIterator slr, SrcAccessor src,
565 DestIterator dul, DestAccessor dest)
570 template <
class Vector1,
class Vector2>
571 void noiseVarianceListMedianCut(Vector1
const & noise, Vector2 & clusters,
572 unsigned int maxClusterCount)
574 typedef typename Vector2::value_type Result;
576 clusters.push_back(Result(0, noise.size()));
578 while(clusters.size() <= maxClusterCount)
581 unsigned int kMax = 0;
582 double diffMax = 0.0;
583 for(
unsigned int k=0; k < clusters.size(); ++k)
585 double diff = noise[clusters[k][1]-1][0] - noise[clusters[k][0]][0];
596 unsigned int k1 = clusters[kMax][0],
597 k2 = clusters[kMax][1];
598 unsigned int kSplit = k1 + (k2 - k1) / 2;
599 clusters[kMax][1] = kSplit;
600 clusters.push_back(Result(kSplit, k2));
604 struct SortNoiseByMean
607 bool operator()(T
const & l, T
const & r)
const
613 struct SortNoiseByVariance
616 bool operator()(T
const & l, T
const & r)
const
622 template <
class Vector1,
class Vector2,
class Vector3>
623 void noiseVarianceClusterAveraging(Vector1 & noise, Vector2 & clusters,
624 Vector3 & result,
double quantile)
626 typedef typename Vector1::iterator Iter;
627 typedef typename Vector3::value_type Result;
629 for(
unsigned int k=0; k<clusters.size(); ++k)
631 Iter i1 = noise.begin() + clusters[k][0];
632 Iter i2 = noise.begin() + clusters[k][1];
634 std::sort(i1, i2, SortNoiseByVariance());
636 std::size_t size =
static_cast<std::size_t
>(
VIGRA_CSTD::ceil(quantile*(i2 - i1)));
637 if(static_cast<std::size_t>(i2 - i1) < size)
648 variance += (*i1)[1];
651 result.push_back(Result(mean / size, variance / size));
655 template <
class SrcIterator,
class SrcAccessor,
class BackInsertable>
656 void noiseVarianceEstimationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
657 BackInsertable & result,
658 NoiseNormalizationOptions
const & options)
660 typedef typename BackInsertable::value_type ResultType;
662 unsigned int w = slr.x - sul.x;
663 unsigned int h = slr.y - sul.y;
665 typedef typename NumericTraits<typename SrcAccessor::value_type>::RealPromote TmpType;
666 typedef BasicImage<TmpType> TmpImage;
668 TmpImage gradient(w, h);
669 symmetricDifferenceSquaredMagnitude(sul, slr, src, gradient.upperLeft(), gradient.accessor());
672 findHomogeneousRegions(gradient.upperLeft(), gradient.lowerRight(), gradient.accessor(),
673 homogeneous.upperLeft(), homogeneous.accessor());
676 unsigned int windowRadius = options.window_radius;
677 for(
unsigned int y=windowRadius; y<h-windowRadius; ++y)
679 for(
unsigned int x=windowRadius; x<w-windowRadius; ++x)
681 if (! homogeneous(x, y))
685 double mean = 0.0, variance = options.noise_variance_initial_guess;
689 if(options.use_gradient)
691 success = iterativeNoiseEstimationChi2(sul + center, src,
692 gradient.upperLeft() + center, mean, variance,
693 options.noise_estimation_quantile, windowRadius);
697 success = iterativeNoiseEstimationGauss(sul + center, src,
698 gradient.upperLeft() + center, mean, variance,
699 options.noise_estimation_quantile, windowRadius);
703 result.push_back(ResultType(mean, variance));
709 template <
class Vector,
class BackInsertable>
710 void noiseVarianceClusteringImpl(Vector & noise, BackInsertable & result,
711 unsigned int clusterCount,
double quantile)
713 std::sort(noise.begin(), noise.end(), detail::SortNoiseByMean());
715 ArrayVector<TinyVector<unsigned int, 2> > clusters;
716 detail::noiseVarianceListMedianCut(noise, clusters, clusterCount);
718 std::sort(clusters.begin(), clusters.end(), detail::SortNoiseByMean());
720 detail::noiseVarianceClusterAveraging(noise, clusters, result, quantile);
723 template <
class Functor,
724 class SrcIterator,
class SrcAccessor,
725 class DestIterator,
class DestAccessor>
727 noiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
728 DestIterator dul, DestAccessor dest,
729 NoiseNormalizationOptions
const & options)
731 ArrayVector<TinyVector<double, 2> > noiseData;
732 noiseVarianceEstimationImpl(sul, slr, src, noiseData, options);
734 if(noiseData.size() < 10)
737 ArrayVector<TinyVector<double, 2> > noiseClusters;
739 noiseVarianceClusteringImpl(noiseData, noiseClusters,
740 options.cluster_count, options.averaging_quantile);
747 template <
class SrcIterator,
class SrcAccessor,
748 class DestIterator,
class DestAccessor>
750 nonparametricNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
751 DestIterator dul, DestAccessor dest,
752 NoiseNormalizationOptions
const & options,
755 typedef typename SrcAccessor::value_type SrcType;
756 typedef typename DestAccessor::value_type DestType;
757 return noiseNormalizationImpl<NonparametricNoiseNormalizationFunctor<SrcType, DestType> >
758 (sul, slr, src, dul, dest, options);
761 template <
class SrcIterator,
class SrcAccessor,
762 class DestIterator,
class DestAccessor>
764 nonparametricNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
765 DestIterator dul, DestAccessor dest,
766 NoiseNormalizationOptions
const & options,
769 int bands = src.size(sul);
770 for(
int b=0; b<bands; ++b)
772 VectorElementAccessor<SrcAccessor> sband(b, src);
773 VectorElementAccessor<DestAccessor> dband(b, dest);
774 typedef typename VectorElementAccessor<SrcAccessor>::value_type SrcType;
775 typedef typename VectorElementAccessor<DestAccessor>::value_type DestType;
777 if(!noiseNormalizationImpl<NonparametricNoiseNormalizationFunctor<SrcType, DestType> >
778 (sul, slr, sband, dul, dband, options))
784 template <
class SrcIterator,
class SrcAccessor,
785 class DestIterator,
class DestAccessor>
787 quadraticNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
788 DestIterator dul, DestAccessor dest,
789 NoiseNormalizationOptions
const & options,
792 typedef typename SrcAccessor::value_type SrcType;
793 typedef typename DestAccessor::value_type DestType;
794 return noiseNormalizationImpl<QuadraticNoiseNormalizationFunctor<SrcType, DestType> >
795 (sul, slr, src, dul, dest, options);
798 template <
class SrcIterator,
class SrcAccessor,
799 class DestIterator,
class DestAccessor>
801 quadraticNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
802 DestIterator dul, DestAccessor dest,
803 NoiseNormalizationOptions
const & options,
806 int bands = src.size(sul);
807 for(
int b=0; b<bands; ++b)
809 VectorElementAccessor<SrcAccessor> sband(b, src);
810 VectorElementAccessor<DestAccessor> dband(b, dest);
811 typedef typename VectorElementAccessor<SrcAccessor>::value_type SrcType;
812 typedef typename VectorElementAccessor<DestAccessor>::value_type DestType;
814 if(!noiseNormalizationImpl<QuadraticNoiseNormalizationFunctor<SrcType, DestType> >
815 (sul, slr, sband, dul, dband, options))
821 template <
class SrcIterator,
class SrcAccessor,
822 class DestIterator,
class DestAccessor>
824 quadraticNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
825 DestIterator dul, DestAccessor dest,
826 double a0,
double a1,
double a2,
829 ArrayVector<TinyVector<double, 2> > noiseClusters;
830 noiseClusters.push_back(TinyVector<double, 2>(0.0, a0));
831 noiseClusters.push_back(TinyVector<double, 2>(1.0, a0 + a1 + a2));
832 noiseClusters.push_back(TinyVector<double, 2>(2.0, a0 + 2.0*a1 + 4.0*a2));
834 QuadraticNoiseNormalizationFunctor<
typename SrcAccessor::value_type,
835 typename DestAccessor::value_type>(noiseClusters));
838 template <
class SrcIterator,
class SrcAccessor,
839 class DestIterator,
class DestAccessor>
841 quadraticNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
842 DestIterator dul, DestAccessor dest,
843 double a0,
double a1,
double a2,
846 int bands = src.size(sul);
847 for(
int b=0; b<bands; ++b)
849 VectorElementAccessor<SrcAccessor> sband(b, src);
850 VectorElementAccessor<DestAccessor> dband(b, dest);
851 quadraticNoiseNormalizationImpl(sul, slr, sband, dul, dband, a0, a1, a2, VigraTrueType());
855 template <
class SrcIterator,
class SrcAccessor,
856 class DestIterator,
class DestAccessor>
858 linearNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
859 DestIterator dul, DestAccessor dest,
860 NoiseNormalizationOptions
const & options,
863 typedef typename SrcAccessor::value_type SrcType;
864 typedef typename DestAccessor::value_type DestType;
865 return noiseNormalizationImpl<LinearNoiseNormalizationFunctor<SrcType, DestType> >
866 (sul, slr, src, dul, dest, options);
869 template <
class SrcIterator,
class SrcAccessor,
870 class DestIterator,
class DestAccessor>
872 linearNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
873 DestIterator dul, DestAccessor dest,
874 NoiseNormalizationOptions
const & options,
877 int bands = src.size(sul);
878 for(
int b=0; b<bands; ++b)
880 VectorElementAccessor<SrcAccessor> sband(b, src);
881 VectorElementAccessor<DestAccessor> dband(b, dest);
882 typedef typename VectorElementAccessor<SrcAccessor>::value_type SrcType;
883 typedef typename VectorElementAccessor<DestAccessor>::value_type DestType;
885 if(!noiseNormalizationImpl<LinearNoiseNormalizationFunctor<SrcType, DestType> >
886 (sul, slr, sband, dul, dband, options))
892 template <
class SrcIterator,
class SrcAccessor,
893 class DestIterator,
class DestAccessor>
895 linearNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
896 DestIterator dul, DestAccessor dest,
897 double a0,
double a1,
900 ArrayVector<TinyVector<double, 2> > noiseClusters;
901 noiseClusters.push_back(TinyVector<double, 2>(0.0, a0));
902 noiseClusters.push_back(TinyVector<double, 2>(1.0, a0 + a1));
904 LinearNoiseNormalizationFunctor<
typename SrcAccessor::value_type,
905 typename DestAccessor::value_type>(noiseClusters));
908 template <
class SrcIterator,
class SrcAccessor,
909 class DestIterator,
class DestAccessor>
911 linearNoiseNormalizationImpl(SrcIterator sul, SrcIterator slr, SrcAccessor src,
912 DestIterator dul, DestAccessor dest,
913 double a0,
double a1,
916 int bands = src.size(sul);
917 for(
int b=0; b<bands; ++b)
919 VectorElementAccessor<SrcAccessor> sband(b, src);
920 VectorElementAccessor<DestAccessor> dband(b, dest);
921 linearNoiseNormalizationImpl(sul, slr, sband, dul, dband, a0, a1, VigraTrueType());
928 struct noiseVarianceEstimation_can_only_work_on_scalar_images
929 : vigra::staticAssert::AssertBool<P>
1020 template <
class SrcIterator,
class SrcAccessor,
class BackInsertable>
1023 BackInsertable & result,
1024 NoiseNormalizationOptions
const & options = NoiseNormalizationOptions())
1026 typedef typename BackInsertable::value_type ResultType;
1027 typedef typename SrcAccessor::value_type SrcType;
1028 typedef typename NumericTraits<SrcType>::isScalar isScalar;
1030 VIGRA_STATIC_ASSERT((
1031 noiseVarianceEstimation_can_only_work_on_scalar_images<(isScalar::asBool)>));
1033 detail::noiseVarianceEstimationImpl(sul, slr, src, result, options);
1036 template <
class SrcIterator,
class SrcAccessor,
class BackInsertable>
1039 BackInsertable & result,
1040 NoiseNormalizationOptions
const & options = NoiseNormalizationOptions())
1109 template <
class SrcIterator,
class SrcAccessor,
class BackInsertable>
1112 BackInsertable & result,
1113 NoiseNormalizationOptions
const & options = NoiseNormalizationOptions())
1115 ArrayVector<TinyVector<double, 2> > variance;
1117 detail::noiseVarianceClusteringImpl(variance, result, options.cluster_count, options.averaging_quantile);
1120 template <
class SrcIterator,
class SrcAccessor,
class BackInsertable>
1123 BackInsertable & result,
1124 NoiseNormalizationOptions
const & options = NoiseNormalizationOptions())
1200 template <
class SrcIterator,
class SrcAccessor,
1201 class DestIterator,
class DestAccessor>
1204 DestIterator dul, DestAccessor dest,
1205 NoiseNormalizationOptions
const & options = NoiseNormalizationOptions())
1207 typedef typename SrcAccessor::value_type SrcType;
1209 return detail::nonparametricNoiseNormalizationImpl(sul, slr, src, dul, dest, options,
1210 typename NumericTraits<SrcType>::isScalar());
1213 template <
class SrcIterator,
class SrcAccessor,
1214 class DestIterator,
class DestAccessor>
1217 pair<DestIterator, DestAccessor> dest,
1218 NoiseNormalizationOptions
const & options = NoiseNormalizationOptions())
1280 template <
class SrcIterator,
class SrcAccessor,
1281 class DestIterator,
class DestAccessor>
1284 DestIterator dul, DestAccessor dest,
1285 NoiseNormalizationOptions
const & options = NoiseNormalizationOptions())
1287 typedef typename SrcAccessor::value_type SrcType;
1289 return detail::quadraticNoiseNormalizationImpl(sul, slr, src, dul, dest, options,
1290 typename NumericTraits<SrcType>::isScalar());
1293 template <
class SrcIterator,
class SrcAccessor,
1294 class DestIterator,
class DestAccessor>
1297 pair<DestIterator, DestAccessor> dest,
1298 NoiseNormalizationOptions
const & options = NoiseNormalizationOptions())
1364 template <
class SrcIterator,
class SrcAccessor,
1365 class DestIterator,
class DestAccessor>
1368 DestIterator dul, DestAccessor dest,
1369 double a0,
double a1,
double a2)
1371 typedef typename SrcAccessor::value_type SrcType;
1373 detail::quadraticNoiseNormalizationImpl(sul, slr, src, dul, dest, a0, a1, a2,
1374 typename NumericTraits<SrcType>::isScalar());
1377 template <
class SrcIterator,
class SrcAccessor,
1378 class DestIterator,
class DestAccessor>
1381 pair<DestIterator, DestAccessor> dest,
1382 double a0,
double a1,
double a2)
1444 template <
class SrcIterator,
class SrcAccessor,
1445 class DestIterator,
class DestAccessor>
1448 DestIterator dul, DestAccessor dest,
1449 NoiseNormalizationOptions
const & options = NoiseNormalizationOptions())
1451 typedef typename SrcAccessor::value_type SrcType;
1453 return detail::linearNoiseNormalizationImpl(sul, slr, src, dul, dest, options,
1454 typename NumericTraits<SrcType>::isScalar());
1457 template <
class SrcIterator,
class SrcAccessor,
1458 class DestIterator,
class DestAccessor>
1461 pair<DestIterator, DestAccessor> dest,
1462 NoiseNormalizationOptions
const & options = NoiseNormalizationOptions())
1528 template <
class SrcIterator,
class SrcAccessor,
1529 class DestIterator,
class DestAccessor>
1532 DestIterator dul, DestAccessor dest,
1533 double a0,
double a1)
1535 typedef typename SrcAccessor::value_type SrcType;
1537 detail::linearNoiseNormalizationImpl(sul, slr, src, dul, dest, a0, a1,
1538 typename NumericTraits<SrcType>::isScalar());
1541 template <
class SrcIterator,
class SrcAccessor,
1542 class DestIterator,
class DestAccessor>
1545 pair<DestIterator, DestAccessor> dest,
1546 double a0,
double a1)
1555 #endif // VIGRA_NOISE_NORMALIZATION_HXX