[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

copyimage.hxx
1 /************************************************************************/
2 /* */
3 /* Copyright 1998-2002 by Ullrich Koethe */
4 /* */
5 /* This file is part of the VIGRA computer vision library. */
6 /* The VIGRA Website is */
7 /* http://hci.iwr.uni-heidelberg.de/vigra/ */
8 /* Please direct questions, bug reports, and contributions to */
9 /* ullrich.koethe@iwr.uni-heidelberg.de or */
10 /* vigra@informatik.uni-hamburg.de */
11 /* */
12 /* Permission is hereby granted, free of charge, to any person */
13 /* obtaining a copy of this software and associated documentation */
14 /* files (the "Software"), to deal in the Software without */
15 /* restriction, including without limitation the rights to use, */
16 /* copy, modify, merge, publish, distribute, sublicense, and/or */
17 /* sell copies of the Software, and to permit persons to whom the */
18 /* Software is furnished to do so, subject to the following */
19 /* conditions: */
20 /* */
21 /* The above copyright notice and this permission notice shall be */
22 /* included in all copies or substantial portions of the */
23 /* Software. */
24 /* */
25 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */
26 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */
27 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */
28 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */
29 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */
30 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */
31 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */
32 /* OTHER DEALINGS IN THE SOFTWARE. */
33 /* */
34 /************************************************************************/
35 
36 
37 #ifndef VIGRA_COPYIMAGE_HXX
38 #define VIGRA_COPYIMAGE_HXX
39 
40 #include "utilities.hxx"
41 
42 namespace vigra {
43 
44 /** \addtogroup CopyAlgo Algorithms to Copy Images
45  Copy images or regions
46 */
47 //@{
48 
49 /********************************************************/
50 /* */
51 /* copyLine */
52 /* */
53 /********************************************************/
54 
55 template <class SrcIterator, class SrcAccessor,
56  class DestIterator, class DestAccessor>
57 void
58 copyLine(SrcIterator s,
59  SrcIterator send, SrcAccessor src,
60  DestIterator d, DestAccessor dest)
61 {
62  for(; s != send; ++s, ++d)
63  dest.set(src(s), d);
64 }
65 
66 template <class SrcIterator, class SrcAccessor,
67  class MaskIterator, class MaskAccessor,
68  class DestIterator, class DestAccessor>
69 void
70 copyLineIf(SrcIterator s,
71  SrcIterator send, SrcAccessor src,
72  MaskIterator m, MaskAccessor mask,
73  DestIterator d, DestAccessor dest)
74 {
75  for(; s != send; ++s, ++d, ++m)
76  if(mask(m))
77  dest.set(src(s), d);
78 }
79 
80 template <class SrcIterator, class SrcAccessor,
81  class DestIterator, class DestAccessor>
82 void
83 swapLine(SrcIterator s,
84  SrcIterator send, SrcAccessor src,
85  DestIterator d, DestAccessor dest)
86 {
87  for(; s != send; ++s, ++d)
88  {
89  typename SrcAccessor::value_type t = src(s);
90  src.set(dest(d), s);
91  dest.set(t, d);
92  }
93 }
94 
95 /********************************************************/
96 /* */
97 /* copyImage */
98 /* */
99 /********************************************************/
100 
101 /** \brief Copy source image into destination image.
102 
103  If necessary, type conversion takes place.
104  The function uses accessors to access the pixel data.
105 
106  <b> Declarations:</b>
107 
108  pass arguments explicitly:
109  \code
110  namespace vigra {
111  template <class SrcImageIterator, class SrcAccessor,
112  class DestImageIterator, class DestAccessor>
113  void
114  copyImage(SrcImageIterator src_upperleft,
115  SrcImageIterator src_lowerright, SrcAccessor sa,
116  DestImageIterator dest_upperleft, DestAccessor da)
117  }
118  \endcode
119 
120 
121  use argument objects in conjunction with \ref ArgumentObjectFactories :
122  \code
123  namespace vigra {
124  template <class SrcImageIterator, class SrcAccessor,
125  class DestImageIterator, class DestAccessor>
126  void
127  copyImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
128  pair<DestImageIterator, DestAccessor> dest)
129  }
130  \endcode
131 
132  <b> Usage:</b>
133 
134  <b>\#include</b> <vigra/copyimage.hxx><br>
135  Namespace: vigra
136 
137  \code
138  vigra::copyImage(srcImageRange(src), destImage(dest));
139 
140  \endcode
141 
142  <b> Required Interface:</b>
143 
144  \code
145  SrcImageIterator src_upperleft, src_lowerright;
146  DestImageIterator dest_upperleft;
147  SrcImageIterator::row_iterator sx = src_upperleft.rowIterator();
148  DestImageIterator::row_iterator dx = dest_upperleft.rowIterator();
149 
150  SrcAccessor src_accessor;
151  DestAccessor dest_accessor;
152 
153  dest_accessor.set(src_accessor(sx), dx);
154 
155  \endcode
156 
157 */
158 doxygen_overloaded_function(template <...> void copyImage)
159 
160 template <class SrcImageIterator, class SrcAccessor,
161  class DestImageIterator, class DestAccessor>
162 void
163 copyImage(SrcImageIterator src_upperleft,
164  SrcImageIterator src_lowerright, SrcAccessor sa,
165  DestImageIterator dest_upperleft, DestAccessor da)
166 {
167  int w = src_lowerright.x - src_upperleft.x;
168 
169  for(; src_upperleft.y<src_lowerright.y; ++src_upperleft.y, ++dest_upperleft.y)
170  {
171  copyLine(src_upperleft.rowIterator(),
172  src_upperleft.rowIterator() + w, sa,
173  dest_upperleft.rowIterator(), da);
174  }
175 }
176 
177 template <class SrcImageIterator, class SrcAccessor,
178  class DestImageIterator, class DestAccessor>
179 inline
180 void
181 copyImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
182  pair<DestImageIterator, DestAccessor> dest)
183 {
184  copyImage(src.first, src.second, src.third,
185  dest.first, dest.second);
186 }
187 
188 template <class SrcImageIterator, class SrcAccessor,
189  class DestImageIterator, class DestAccessor>
190 void
191 swapImageData(SrcImageIterator src_upperleft,
192  SrcImageIterator src_lowerright, SrcAccessor sa,
193  DestImageIterator dest_upperleft, DestAccessor da)
194 {
195  int w = src_lowerright.x - src_upperleft.x;
196 
197  for(; src_upperleft.y<src_lowerright.y; ++src_upperleft.y, ++dest_upperleft.y)
198  {
199  swapLine(src_upperleft.rowIterator(),
200  src_upperleft.rowIterator() + w, sa,
201  dest_upperleft.rowIterator(), da);
202  }
203 }
204 
205 template <class SrcImageIterator, class SrcAccessor,
206  class DestImageIterator, class DestAccessor>
207 inline
208 void
209 swapImageData(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
210  pair<DestImageIterator, DestAccessor> dest)
211 {
212  swapImageData(src.first, src.second, src.third,
213  dest.first, dest.second);
214 }
215 
216 /********************************************************/
217 /* */
218 /* copyImageIf */
219 /* */
220 /********************************************************/
221 
222 /** \brief Copy source ROI into destination image.
223 
224  Pixel values are copied whenever the return value of the mask's
225  accessor is not zero.
226  If necessary, type conversion takes place.
227  The function uses accessors to access the pixel data.
228 
229  <b> Declarations:</b>
230 
231  pass arguments explicitly:
232  \code
233  namespace vigra {
234  template <class SrcImageIterator, class SrcAccessor,
235  class MaskImageIterator, class MaskAccessor,
236  class DestImageIterator, clas DestAccessor>
237  void
238  copyImageIf(SrcImageIterator src_upperleft,
239  SrcImageIterator src_lowerright, SrcAccessor sa,
240  MaskImageIterator mask_upperleft, MaskAccessor ma,
241  DestImageIterator dest_upperleft, DestAccessor da)
242  }
243  \endcode
244 
245 
246  use argument objects in conjunction with \ref ArgumentObjectFactories :
247  \code
248  namespace vigra {
249  template <class SrcImageIterator, class SrcAccessor,
250  class MaskImageIterator, class MaskAccessor,
251  class DestImageIterator, clas DestAccessor>
252  void
253  copyImageIf(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
254  pair<MaskImageIterator, MaskAccessor> mask,
255  pair<DestImageIterator, DestAccessor> dest)
256  }
257  \endcode
258 
259  <b> Usage:</b>
260 
261  <b>\#include</b> <vigra/copyimage.hxx><br>
262  Namespace: vigra
263 
264  \code
265  vigra::copyImageIf(srcImageRange(src), maskImage(mask), destImage(dest));
266 
267  \endcode
268 
269  <b> Required Interface:</b>
270 
271  \code
272  SrcImageIterator src_upperleft, src_lowerright;
273  DestImageIterator dest_upperleft;
274  MaskImageIterator mask_upperleft;
275  SrcImageIterator::row_iterator sx = src_upperleft.rowIterator();
276  MaskImageIterator::row_iterator mx = mask_upperleft.rowIterator();
277  DestImageIterator::row_iterator dx = dest_upperleft.rowIterator();
278 
279  SrcAccessor src_accessor;
280  DestAccessor dest_accessor;
281  MaskAccessor mask_accessor;
282  Functor functor;
283 
284  if(mask_accessor(mx))
285  dest_accessor.set(src_accessor(sx), dx);
286 
287  \endcode
288 
289 */
290 doxygen_overloaded_function(template <...> void copyImageIf)
291 
292 template <class SrcImageIterator, class SrcAccessor,
293  class MaskImageIterator, class MaskAccessor,
294  class DestImageIterator, class DestAccessor>
295 void
296 copyImageIf(SrcImageIterator src_upperleft,
297  SrcImageIterator src_lowerright, SrcAccessor sa,
298  MaskImageIterator mask_upperleft, MaskAccessor ma,
299  DestImageIterator dest_upperleft, DestAccessor da)
300 {
301  int w = src_lowerright.x - src_upperleft.x;
302 
303  for(; src_upperleft.y<src_lowerright.y;
304  ++src_upperleft.y, ++mask_upperleft.y, ++dest_upperleft.y)
305  {
306  copyLineIf(src_upperleft.rowIterator(),
307  src_upperleft.rowIterator() + w, sa,
308  mask_upperleft.rowIterator(), ma,
309  dest_upperleft.rowIterator(), da);
310  }
311 }
312 
313 template <class SrcImageIterator, class SrcAccessor,
314  class MaskImageIterator, class MaskAccessor,
315  class DestImageIterator, class DestAccessor>
316 inline
317 void
318 copyImageIf(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
319  pair<MaskImageIterator, MaskAccessor> mask,
320  pair<DestImageIterator, DestAccessor> dest)
321 {
322  copyImageIf(src.first, src.second, src.third,
323  mask.first, mask.second,
324  dest.first, dest.second);
325 }
326 
327 //@}
328 
329 } // namespace vigra
330 
331 #endif // VIGRA_COPYIMAGE_HXX

© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de)
Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany

html generated using doxygen and Python
vigra 1.9.0 (Wed Feb 27 2013)