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 #ifndef MLN_CORE_IMAGE_DMORPH_SLICE_IMAGE_HH
00027 # define MLN_CORE_IMAGE_DMORPH_SLICE_IMAGE_HH
00028
00034
00035 # include <mln/core/internal/image_domain_morpher.hh>
00036 # include <mln/core/alias/box3d.hh>
00037 # include <mln/core/alias/box2d.hh>
00038
00039
00040 namespace mln
00041 {
00042
00043
00044 template <typename I> struct slice_image;
00045
00046
00047 namespace internal
00048 {
00049
00051 template <typename I>
00052 struct data< slice_image<I> >
00053 {
00054 data(I& ima, def::coord sli);
00055
00056 I ima_;
00057 def::coord sli_;
00058 box2d b_;
00059 };
00060
00061 }
00062
00063
00064 namespace trait
00065 {
00066
00067 template <typename I>
00068 struct image_< slice_image<I> > : default_image_morpher< I,
00069 mln_value(I),
00070 slice_image<I> >
00071 {
00072 typedef trait::image::category::domain_morpher category;
00073
00074 typedef trait::image::dimension::two_d dimension;
00075
00076
00077
00078
00079
00080 typedef trait::image::vw_io::none vw_io;
00081 typedef trait::image::vw_set::none vw_set;
00082 typedef trait::image::value_alignment::not_aligned value_alignment;
00083 typedef trait::image::value_storage::disrupted value_storage;
00084 };
00085
00086 }
00087
00088
00089
00093
00094 template <typename I>
00095 struct slice_image : public internal::image_domain_morpher< I,
00096 box2d,
00097 slice_image<I> >
00098 {
00100 typedef slice_image< tag::image_<I> > skeleton;
00101
00103 slice_image();
00104
00106 slice_image(I& ima, def::coord sli);
00107
00108 void init_(I& ima, def::coord sli);
00109
00110
00112 const box2d& domain() const;
00113
00115 def::coord sli() const;
00116
00118 mln_rvalue(I) operator()(const point2d& p) const;
00119
00121 mln_morpher_lvalue(I) operator()(const point2d& p);
00122
00123
00125 operator slice_image<const I>() const;
00126 };
00127
00128
00129
00130 template <typename I>
00131 slice_image<I>
00132 slice(Image<I>& ima, def::coord sli);
00133
00134 template <typename I>
00135 slice_image<const I>
00136 slice(const Image<I>& ima, def::coord sli);
00137
00138
00139
00140
00141 namespace trait
00142 {
00143
00144 template <typename I, typename V>
00145 struct ch_value< slice_image<I>, V >
00146 {
00147 typedef image2d<V> ret;
00148 };
00149
00150 }
00151
00152
00153
00154 # ifndef MLN_INCLUDE_ONLY
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164
00165
00166
00167
00168
00169
00170
00171
00172
00173 namespace internal
00174 {
00175
00176 template <typename I>
00177 inline
00178 data< slice_image<I> >::data(I& ima, def::coord sli)
00179 : ima_(ima),
00180 sli_(sli)
00181 {
00182 b_ = make::box2d(ima.domain().pmin().row(), ima.domain().pmin().col(),
00183 ima.domain().pmax().row(), ima.domain().pmax().col());
00184 }
00185
00186 }
00187
00188
00189
00190
00191 template <typename I>
00192 inline
00193 slice_image<I>::slice_image()
00194 {
00195 }
00196
00197 template <typename I>
00198 inline
00199 slice_image<I>::slice_image(I& ima, def::coord sli)
00200 {
00201 init_(ima, sli);
00202 }
00203
00204 template <typename I>
00205 inline
00206 void
00207 slice_image<I>::init_(I& ima, def::coord sli)
00208 {
00209 mln_precondition(! this->is_valid());
00210 this->data_ = new internal::data< slice_image<I> >(ima, sli);
00211 }
00212
00213 template <typename I>
00214 inline
00215 const box2d&
00216 slice_image<I>::domain() const
00217 {
00218 mln_precondition(this->is_valid());
00219 return this->data_->b_;
00220 }
00221
00222 template <typename I>
00223 inline
00224 def::coord
00225 slice_image<I>::sli() const
00226 {
00227 mln_precondition(this->is_valid());
00228 return this->data_->sli_;
00229 }
00230
00231 template <typename I>
00232 inline
00233 mln_rvalue(I)
00234 slice_image<I>::operator()(const point2d& p) const
00235 {
00236 mln_precondition(this->has(p));
00237 point3d p_(this->data_->sli_, p.row(), p.col());
00238 mln_precondition(this->data_->ima_.has(p_));
00239 return this->data_->ima_(p_);
00240 }
00241
00242 template <typename I>
00243 inline
00244 mln_morpher_lvalue(I)
00245 slice_image<I>::operator()(const point2d& p)
00246 {
00247 mln_precondition(this->has(p));
00248 point3d p_(this->data_->sli_, p.row(), p.col());
00249 mln_precondition(this->data_->ima_.has(p_));
00250 return this->data_->ima_(p_);
00251 }
00252
00253 template <typename I>
00254 inline
00255 slice_image<I>::operator slice_image<const I>() const
00256 {
00257 mln_precondition(this->is_valid());
00258 slice_image<const I> tmp(this->data_->ima_,
00259 this->data_->sli_);
00260 return tmp;
00261 }
00262
00263
00264
00265
00266 template <typename I>
00267 inline
00268 slice_image<I>
00269 slice(Image<I>& ima_, def::coord sli)
00270 {
00271 mlc_equal(mln_domain(I), box3d)::check();
00272
00273 I& ima = exact(ima_);
00274 mln_precondition(ima.is_valid());
00275 mln_precondition(sli >= ima.domain().pmin().sli() &&
00276 sli <= ima.domain().pmax().sli());
00277
00278 slice_image<I> tmp(ima, sli);
00279 return tmp;
00280 }
00281
00282 template <typename I>
00283 inline
00284 slice_image<const I>
00285 slice(const Image<I>& ima_, def::coord sli)
00286 {
00287 mlc_equal(mln_domain(I), box3d)::check();
00288
00289 const I& ima = exact(ima_);
00290 mln_precondition(ima.is_valid());
00291 mln_precondition(sli >= ima.domain().pmin().sli() &&
00292 sli <= ima.domain().pmax().sli());
00293
00294 slice_image<const I> tmp(ima, sli);
00295 return tmp;
00296 }
00297
00298
00299 # endif // ! MLN_INCLUDE_ONLY
00300
00301 }
00302
00303
00304
00305 #endif // ! MLN_CORE_IMAGE_DMORPH_SLICE_IMAGE_HH