00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #ifndef MLN_CORE_IMAGE_DMORPH_TRANSFORMED_IMAGE_HH
00028 # define MLN_CORE_IMAGE_DMORPH_TRANSFORMED_IMAGE_HH
00029
00036
00037 # include <mln/core/internal/image_domain_morpher.hh>
00038 # include <mln/core/site_set/p_transformed.hh>
00039
00040
00041 namespace mln
00042 {
00043
00044
00045
00046 template <typename I, typename F> struct transformed_image;
00047
00048
00049 namespace internal
00050 {
00051
00053 template <typename I, typename F>
00054 struct data< transformed_image<I,F> >
00055 {
00056 data(I& ima, const F& f);
00057
00058 I ima_;
00059 F f_;
00060 p_transformed< mln_domain(I), F> domain_;
00061 };
00062
00063 }
00064
00065
00066
00067 namespace trait
00068 {
00069
00070 template <typename I, typename F>
00071 struct image_< transformed_image<I,F> > : default_image_morpher< I,
00072 mln_value(I),
00073 transformed_image<I,F> >
00074 {
00075 typedef trait::image::category::domain_morpher category;
00076
00077 typedef trait::image::ext_domain::none ext_domain;
00078 typedef trait::image::ext_value::irrelevant ext_value;
00079 typedef trait::image::ext_io::irrelevant ext_io;
00080
00081 typedef trait::image::vw_io::none vw_io;
00082 typedef trait::image::vw_set::none vw_set;
00083 typedef trait::image::value_alignment::not_aligned value_alignment;
00084 typedef trait::image::value_storage::disrupted value_storage;
00085 };
00086
00087 }
00088
00089
00090
00094
00095 template <typename I, typename F>
00096 struct transformed_image : public internal::image_domain_morpher< I,
00097 p_transformed< mln_domain(I), F>,
00098 transformed_image<I,F> >
00099 {
00101 typedef transformed_image< tag::image_<I>, tag::function_<F> > skeleton;
00102
00104 transformed_image();
00105
00107 transformed_image(I& ima, const F& f);
00108
00110 void init_(I& ima, const F& f);
00111
00112
00114 const p_transformed< mln_domain(I), F>& domain() const;
00115
00116
00118 mln_rvalue(I) operator()(const mln_psite(I)& p) const;
00119
00122 mln_morpher_lvalue(I) operator()(const mln_psite(I)& p);
00123
00124
00126 operator transformed_image<const I, F>() const;
00127 };
00128
00129
00130
00131
00132
00133 template <typename I, typename F>
00134 transformed_image<const I, F>
00135 transform_domain(const Image<I>& ima, const Function_v2v<F>& f);
00136
00137 template <typename I, typename F>
00138 transformed_image<I, F>
00139 transform_domain(Image<I>& ima, const Function_v2v<F>& f);
00140
00141
00142
00143
00144 # ifndef MLN_INCLUDE_ONLY
00145
00146
00147
00148 template <typename I, typename F, typename J>
00149 inline
00150 void init_(tag::image_t, transformed_image<I,F>& target, const J& model)
00151 {
00152 I ima;
00153 init_(tag::image, ima, exact(model));
00154 F f;
00155 init_(tag::function, f, exact(model));
00156 target.init_(ima, f);
00157 }
00158
00159 template <typename I, typename F>
00160 void init_(tag::function_t, F& f, const transformed_image<I,F>& model)
00161 {
00162 f = model.domain().function();
00163 }
00164
00165
00166
00167
00168 namespace internal
00169 {
00170
00171 template <typename I, typename F>
00172 inline
00173 data< transformed_image<I,F> >::data(I& ima, const F& f)
00174 : ima_(ima),
00175 f_(f),
00176 domain_(ima.domain(), f)
00177 {
00178 }
00179
00180 }
00181
00182
00183
00184
00185 template <typename I, typename F>
00186 inline
00187 transformed_image<I,F>::transformed_image()
00188 {
00189 }
00190
00191 template <typename I, typename F>
00192 inline
00193 transformed_image<I,F>::transformed_image(I& ima, const F& f)
00194 {
00195 init_(ima, f);
00196 }
00197
00198 template <typename I, typename F>
00199 inline
00200 void
00201 transformed_image<I,F>::init_(I& ima, const F& f)
00202 {
00203 mln_precondition(! this->is_valid());
00204 this->data_ = new internal::data< transformed_image<I,F> >(ima, f);
00205 }
00206
00207 template <typename I, typename F>
00208 inline
00209 const p_transformed< mln_domain(I), F>&
00210 transformed_image<I,F>::domain() const
00211 {
00212 return this->data_->domain_;
00213 }
00214
00215 template <typename I, typename F>
00216 inline
00217 mln_rvalue(I)
00218 transformed_image<I,F>::operator()(const mln_psite(I)& p) const
00219 {
00220 mln_precondition(this->delegatee_() != 0);
00221 mln_precondition(exact(this)->has(p));
00222 mln_precondition(this->delegatee_()->has(this->data_->f_(p)));
00223 return this->delegatee_()->operator()(this->data_->f_(p));
00224 }
00225
00226 template <typename I, typename F>
00227 inline
00228 mln_morpher_lvalue(I)
00229 transformed_image<I,F>::operator()(const mln_psite(I)& p)
00230 {
00231 mln_precondition(this->delegatee_() != 0);
00232 mln_precondition(exact(this)->has(p));
00233 mln_precondition(this->delegatee_()->has(this->data_->f_(p)));
00234 return this->delegatee_()->operator()(this->data_->f_(p));
00235 }
00236
00237
00238 template <typename I, typename F>
00239 inline
00240 transformed_image<I,F>::operator transformed_image<const I, F>() const
00241 {
00242 transformed_image<const I, F> tmp(this->data_->ima_,
00243 this->data_->f_);
00244 return tmp;
00245 }
00246
00247
00248
00249
00250 template <typename I, typename F>
00251 inline
00252 transformed_image<const I, F>
00253 transform_domain(const Image<I>& ima, const Function_v2v<F>& f)
00254 {
00255 transformed_image<const I, F> tmp(exact(ima), exact(f));
00256 return tmp;
00257 }
00258
00259 template <typename I, typename F>
00260 inline
00261 transformed_image<I, F>
00262 transform_domain(Image<I>& ima, const Function_v2v<F>& f)
00263 {
00264 transformed_image<I, F> tmp(exact(ima), exact(f));
00265 return tmp;
00266 }
00267
00268 # endif // ! MLN_INCLUDE_ONLY
00269
00270 }
00271
00272
00273 #endif // ! MLN_CORE_IMAGE_DMORPH_TRANSFORMED_IMAGE_HH