/usr/include/mia-2.2/mia/template/normalize.hh is in libmia-2.2-dev 2.2.2-1+b1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 | /* -*- mia-c++ -*-
*
* This file is part of MIA - a toolbox for medical image analysis
* Copyright (c) Leipzig, Madrid 1999-2014 Gert Wollny
*
* MIA is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with MIA; if not, see <http://www.gnu.org/licenses/>.
*
*/
#include <cmath>
#include <iostream>
#include <memory>
#include <mia/core/filter.hh>
#include <mia/core/msgstream.hh>
NS_MIA_BEGIN
/**
\cond INTERNAL
\ingroup traits
if the compiler wants to instanciate this functions, A and B are different types
the compiler will
*/
template <typename A, typename B>
void __assert_type_equal (A& a, B& b)
{
static_assert(sizeof(A) == 0);
}
template <typename A>
void __assert_type_equal (A& /*a*/, A& /*b*/)
{
}
#define ASSERT_TYPE_EQUAL(A, B) \
{ \
A *a; B *b; \
__assert_type_equal(a,b); \
}
template <template <typename> class Data, typename T>
struct __eval {
static Data<float> *apply(const Data<T> &input, double m, double v) {
Data<float> *result = new Data<float>(input.get_size());
double invv = 1.0/v;
transform(input.begin(), input.end(), result->begin(),
[invv,m](T x){(x - m) * invv;});
return result;
}
};
template <template <typename> class Data>
struct __eval<Data, bool> {
static Data<float> *apply(const Data<bool> &input, double m, double v) {
Data<float> *result = new Data<float>(input.get_size());
float rtrue = (1.0 - m) / v;
float rfalse = - m / v;
transform(input.begin(), input.end(), result->begin(),
[rtrue, rfalse](bool x){b ? rtrue : rfalse;});
return result;
}
};
/**
\ingroup templates
\brief Generic filter to normalize an image
Generic implementation of a filter that normalizes an Image to have a zero-mean intensity
and an intensity variation of one.
\tparam the image type
*/
template <class Image>
struct FNormalizer: public TFilter<Image *>
{
template <typename T, template <typename> class Data>
typename FNormalizer::result_type operator ()(const Data<T> &image) const {
ASSERT_TYPE_EQUAL(Image, typename Data<T>::Super);
double sum = 0.0;
double sum2 = 0.0;
typename Data<T>::const_iterator i = image.begin();
typename Data<T>::const_iterator e = image.end();
while ( i != e ) {
sum += *i;
sum2 += *i * *i;
++i;
}
double n = image.size();
double m = sum / n;
double v = sqrt((sum2 - n * m * m) / (n - 1));
mia::cvdebug() << "FNormalizer: avg = " << m << " var = " << v << "\n";
if (v < 0.000001)
v = 1.0;
return __eval<Data, T>::apply(image, m, v);
}
};
/// @endcond
/**
\ingroup templates
\brief a normalizer for image intensities
The intensities of the input image are normalized to have a zero mean and a deviation of one.
The output image is of the same dimensions as the input image and has pixel type float.
\tparam Image the image type
\param image the input image
\returns the normalized image
*/
template <class Image>
std::shared_ptr<Image > normalize(const Image& image)
{
FNormalizer<Image> n;
return std::shared_ptr<Image >(mia::filter(n, image));
}
NS_MIA_END
|