/usr/include/mia-2.0/mia/core/transformation.hh is in libmia-2.0-dev 2.0.13-1.
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 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 | /* -*- mia-c++ -*-
*
* This file is part of MIA - a toolbox for medical image analysis
* Copyright (c) Leipzig, Madrid 1999-2013 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/>.
*
*/
#ifndef mia_core_transformation_hh
#define mia_core_transformation_hh
#include <mia/core/iodata.hh>
#include <mia/core/attributes.hh>
#include <mia/core/vector.hh>
NS_MIA_BEGIN
/**
\ingroup registration
\brief generic base class for transformations
Template of a generic tranformation function
\tparam D data type of the object to be transformed
\tparam I interpolator factory to create resampler for type D
\todo the interpolator factory resp. the interpolator kernel
should probably be part of the class
*/
template <typename D, typename I>
class Transformation :public CIOData, public CAttributedData {
public:
/// interface type for plugin implementation and search
static const char *type_descr;
virtual ~Transformation();
/// typedef for the data type to be transformed by this transformation
typedef D Data;
/// type of the interpolator used by this transformation
typedef I InterpolatorFactory;
/**
Constructor to create the transformstion
\param ipf the interpolator factory to be used to create the interpolators for image interpolation
*/
Transformation(const I& ipf);
/** Apply the transformation to the input data
\param input
\returns a shared pointer to the transformed input data
*/
std::shared_ptr<D> operator () (const D& input) const;
/**
Set the interpolator factory
\param ipf the new interpolator factory
*/
void set_interpolator_factory(const I& ipf);
/**
Evaluate the transformation penalty and it's gradient
\param[in,out] gradient at input an allocated vector of the size equal to the
size of the degrees of freedom of the transformation, at output the
enegy penalty gradient with respect to the transformation parameters
\returns the value of the transformation energy penalty
*/
double get_energy_penalty_and_gradient(CDoubleVector& gradient) const;
/// \returns the value of the transformation energy penalty
double get_energy_penalty() const;
/// \returns true if the transformation provides a penalty term
bool has_energy_penalty() const;
protected:
/// \returns the interpolator factory
const I& get_interpolator_factory() const;
private:
virtual std::shared_ptr<D> do_transform(const D& input, const I& ipf) const = 0;
virtual double do_get_energy_penalty_and_gradient(CDoubleVector& gradient) const;
virtual double do_get_energy_penalty() const;
virtual bool do_has_energy_penalty() const;
I m_ipf;
};
/**
\ingroup io
\brief template to unify transformation loading
\tparam T the type of the transformation to be loaded
\param file the file name of the transformation to be loaded
\returns the loaded transformation or an empty shared:ptr
*/
template <typename T>
T load_transform(const std::string& MIA_PARAM_UNUSED(file)) {
static_assert(sizeof(T) == 0, "this needs to specialized for the handled type");
}
// implementation
template <typename D, typename I>
Transformation<D, I>::Transformation(const I& ipf):
m_ipf(ipf)
{
}
template <typename D, typename I>
Transformation<D, I>::~Transformation()
{
}
template <typename D, typename I>
void Transformation<D, I>::set_interpolator_factory(const I& ipf)
{
m_ipf = ipf;
}
template <typename D, typename I>
const I& Transformation<D, I>::get_interpolator_factory() const
{
return m_ipf;
}
template <typename D, typename I>
std::shared_ptr<D > Transformation<D,I>::operator() (const D& input) const
{
return do_transform(input, m_ipf);
}
template <typename D, typename I>
double Transformation<D,I>::get_energy_penalty_and_gradient(CDoubleVector& gradient) const
{
return do_get_energy_penalty_and_gradient(gradient);
}
template <typename D, typename I>
double Transformation<D,I>::get_energy_penalty() const
{
return do_get_energy_penalty();
}
template <typename D, typename I>
double Transformation<D,I>::do_get_energy_penalty_and_gradient(CDoubleVector& gradient) const
{
std::fill(gradient.begin(), gradient.end(), 0.0);
return 0.0;
}
template <typename D, typename I>
double Transformation<D,I>::do_get_energy_penalty() const
{
return 0.0;
}
template <typename D, typename I>
bool Transformation<D,I>::has_energy_penalty() const
{
return do_has_energy_penalty();
}
template <typename D, typename I>
bool Transformation<D,I>::do_has_energy_penalty() const
{
return false;
}
template <typename D, typename I>
const char *Transformation<D, I>::type_descr = "transform";
NS_MIA_END
#endif
|