[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]
vigra/copyimage.hxx | ![]() |
00001 /************************************************************************/ 00002 /* */ 00003 /* Copyright 1998-2002 by Ullrich Koethe */ 00004 /* */ 00005 /* This file is part of the VIGRA computer vision library. */ 00006 /* The VIGRA Website is */ 00007 /* http://hci.iwr.uni-heidelberg.de/vigra/ */ 00008 /* Please direct questions, bug reports, and contributions to */ 00009 /* ullrich.koethe@iwr.uni-heidelberg.de or */ 00010 /* vigra@informatik.uni-hamburg.de */ 00011 /* */ 00012 /* Permission is hereby granted, free of charge, to any person */ 00013 /* obtaining a copy of this software and associated documentation */ 00014 /* files (the "Software"), to deal in the Software without */ 00015 /* restriction, including without limitation the rights to use, */ 00016 /* copy, modify, merge, publish, distribute, sublicense, and/or */ 00017 /* sell copies of the Software, and to permit persons to whom the */ 00018 /* Software is furnished to do so, subject to the following */ 00019 /* conditions: */ 00020 /* */ 00021 /* The above copyright notice and this permission notice shall be */ 00022 /* included in all copies or substantial portions of the */ 00023 /* Software. */ 00024 /* */ 00025 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */ 00026 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */ 00027 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */ 00028 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */ 00029 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */ 00030 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */ 00031 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */ 00032 /* OTHER DEALINGS IN THE SOFTWARE. */ 00033 /* */ 00034 /************************************************************************/ 00035 00036 00037 #ifndef VIGRA_COPYIMAGE_HXX 00038 #define VIGRA_COPYIMAGE_HXX 00039 00040 #include "utilities.hxx" 00041 00042 namespace vigra { 00043 00044 /** \addtogroup CopyAlgo Algorithms to Copy Images 00045 Copy images or regions 00046 */ 00047 //@{ 00048 00049 /********************************************************/ 00050 /* */ 00051 /* copyLine */ 00052 /* */ 00053 /********************************************************/ 00054 00055 template <class SrcIterator, class SrcAccessor, 00056 class DestIterator, class DestAccessor> 00057 void 00058 copyLine(SrcIterator s, 00059 SrcIterator send, SrcAccessor src, 00060 DestIterator d, DestAccessor dest) 00061 { 00062 for(; s != send; ++s, ++d) 00063 dest.set(src(s), d); 00064 } 00065 00066 template <class SrcIterator, class SrcAccessor, 00067 class MaskIterator, class MaskAccessor, 00068 class DestIterator, class DestAccessor> 00069 void 00070 copyLineIf(SrcIterator s, 00071 SrcIterator send, SrcAccessor src, 00072 MaskIterator m, MaskAccessor mask, 00073 DestIterator d, DestAccessor dest) 00074 { 00075 for(; s != send; ++s, ++d, ++m) 00076 if(mask(m)) 00077 dest.set(src(s), d); 00078 } 00079 00080 template <class SrcIterator, class SrcAccessor, 00081 class DestIterator, class DestAccessor> 00082 void 00083 swapLine(SrcIterator s, 00084 SrcIterator send, SrcAccessor src, 00085 DestIterator d, DestAccessor dest) 00086 { 00087 for(; s != send; ++s, ++d) 00088 { 00089 typename SrcAccessor::value_type t = src(s); 00090 src.set(dest(d), s); 00091 dest.set(t, d); 00092 } 00093 } 00094 00095 /********************************************************/ 00096 /* */ 00097 /* copyImage */ 00098 /* */ 00099 /********************************************************/ 00100 00101 /** \brief Copy source image into destination image. 00102 00103 If necessary, type conversion takes place. 00104 The function uses accessors to access the pixel data. 00105 00106 <b> Declarations:</b> 00107 00108 pass arguments explicitly: 00109 \code 00110 namespace vigra { 00111 template <class SrcImageIterator, class SrcAccessor, 00112 class DestImageIterator, class DestAccessor> 00113 void 00114 copyImage(SrcImageIterator src_upperleft, 00115 SrcImageIterator src_lowerright, SrcAccessor sa, 00116 DestImageIterator dest_upperleft, DestAccessor da) 00117 } 00118 \endcode 00119 00120 00121 use argument objects in conjunction with \ref ArgumentObjectFactories : 00122 \code 00123 namespace vigra { 00124 template <class SrcImageIterator, class SrcAccessor, 00125 class DestImageIterator, class DestAccessor> 00126 void 00127 copyImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, 00128 pair<DestImageIterator, DestAccessor> dest) 00129 } 00130 \endcode 00131 00132 <b> Usage:</b> 00133 00134 <b>\#include</b> <vigra/copyimage.hxx><br> 00135 Namespace: vigra 00136 00137 \code 00138 vigra::copyImage(srcImageRange(src), destImage(dest)); 00139 00140 \endcode 00141 00142 <b> Required Interface:</b> 00143 00144 \code 00145 SrcImageIterator src_upperleft, src_lowerright; 00146 DestImageIterator dest_upperleft; 00147 SrcImageIterator::row_iterator sx = src_upperleft.rowIterator(); 00148 DestImageIterator::row_iterator dx = dest_upperleft.rowIterator(); 00149 00150 SrcAccessor src_accessor; 00151 DestAccessor dest_accessor; 00152 00153 dest_accessor.set(src_accessor(sx), dx); 00154 00155 \endcode 00156 00157 */ 00158 doxygen_overloaded_function(template <...> void copyImage) 00159 00160 template <class SrcImageIterator, class SrcAccessor, 00161 class DestImageIterator, class DestAccessor> 00162 void 00163 copyImage(SrcImageIterator src_upperleft, 00164 SrcImageIterator src_lowerright, SrcAccessor sa, 00165 DestImageIterator dest_upperleft, DestAccessor da) 00166 { 00167 int w = src_lowerright.x - src_upperleft.x; 00168 00169 for(; src_upperleft.y<src_lowerright.y; ++src_upperleft.y, ++dest_upperleft.y) 00170 { 00171 copyLine(src_upperleft.rowIterator(), 00172 src_upperleft.rowIterator() + w, sa, 00173 dest_upperleft.rowIterator(), da); 00174 } 00175 } 00176 00177 template <class SrcImageIterator, class SrcAccessor, 00178 class DestImageIterator, class DestAccessor> 00179 inline 00180 void 00181 copyImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, 00182 pair<DestImageIterator, DestAccessor> dest) 00183 { 00184 copyImage(src.first, src.second, src.third, 00185 dest.first, dest.second); 00186 } 00187 00188 template <class SrcImageIterator, class SrcAccessor, 00189 class DestImageIterator, class DestAccessor> 00190 void 00191 swapImageData(SrcImageIterator src_upperleft, 00192 SrcImageIterator src_lowerright, SrcAccessor sa, 00193 DestImageIterator dest_upperleft, DestAccessor da) 00194 { 00195 int w = src_lowerright.x - src_upperleft.x; 00196 00197 for(; src_upperleft.y<src_lowerright.y; ++src_upperleft.y, ++dest_upperleft.y) 00198 { 00199 swapLine(src_upperleft.rowIterator(), 00200 src_upperleft.rowIterator() + w, sa, 00201 dest_upperleft.rowIterator(), da); 00202 } 00203 } 00204 00205 template <class SrcImageIterator, class SrcAccessor, 00206 class DestImageIterator, class DestAccessor> 00207 inline 00208 void 00209 swapImageData(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, 00210 pair<DestImageIterator, DestAccessor> dest) 00211 { 00212 swapImageData(src.first, src.second, src.third, 00213 dest.first, dest.second); 00214 } 00215 00216 /********************************************************/ 00217 /* */ 00218 /* copyImageIf */ 00219 /* */ 00220 /********************************************************/ 00221 00222 /** \brief Copy source ROI into destination image. 00223 00224 Pixel values are copied whenever the return value of the mask's 00225 accessor is not zero. 00226 If necessary, type conversion takes place. 00227 The function uses accessors to access the pixel data. 00228 00229 <b> Declarations:</b> 00230 00231 pass arguments explicitly: 00232 \code 00233 namespace vigra { 00234 template <class SrcImageIterator, class SrcAccessor, 00235 class MaskImageIterator, class MaskAccessor, 00236 class DestImageIterator, clas DestAccessor> 00237 void 00238 copyImageIf(SrcImageIterator src_upperleft, 00239 SrcImageIterator src_lowerright, SrcAccessor sa, 00240 MaskImageIterator mask_upperleft, MaskAccessor ma, 00241 DestImageIterator dest_upperleft, DestAccessor da) 00242 } 00243 \endcode 00244 00245 00246 use argument objects in conjunction with \ref ArgumentObjectFactories : 00247 \code 00248 namespace vigra { 00249 template <class SrcImageIterator, class SrcAccessor, 00250 class MaskImageIterator, class MaskAccessor, 00251 class DestImageIterator, clas DestAccessor> 00252 void 00253 copyImageIf(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, 00254 pair<MaskImageIterator, MaskAccessor> mask, 00255 pair<DestImageIterator, DestAccessor> dest) 00256 } 00257 \endcode 00258 00259 <b> Usage:</b> 00260 00261 <b>\#include</b> <vigra/copyimage.hxx><br> 00262 Namespace: vigra 00263 00264 \code 00265 vigra::copyImageIf(srcImageRange(src), maskImage(mask), destImage(dest)); 00266 00267 \endcode 00268 00269 <b> Required Interface:</b> 00270 00271 \code 00272 SrcImageIterator src_upperleft, src_lowerright; 00273 DestImageIterator dest_upperleft; 00274 MaskImageIterator mask_upperleft; 00275 SrcImageIterator::row_iterator sx = src_upperleft.rowIterator(); 00276 MaskImageIterator::row_iterator mx = mask_upperleft.rowIterator(); 00277 DestImageIterator::row_iterator dx = dest_upperleft.rowIterator(); 00278 00279 SrcAccessor src_accessor; 00280 DestAccessor dest_accessor; 00281 MaskAccessor mask_accessor; 00282 Functor functor; 00283 00284 if(mask_accessor(mx)) 00285 dest_accessor.set(src_accessor(sx), dx); 00286 00287 \endcode 00288 00289 */ 00290 doxygen_overloaded_function(template <...> void copyImageIf) 00291 00292 template <class SrcImageIterator, class SrcAccessor, 00293 class MaskImageIterator, class MaskAccessor, 00294 class DestImageIterator, class DestAccessor> 00295 void 00296 copyImageIf(SrcImageIterator src_upperleft, 00297 SrcImageIterator src_lowerright, SrcAccessor sa, 00298 MaskImageIterator mask_upperleft, MaskAccessor ma, 00299 DestImageIterator dest_upperleft, DestAccessor da) 00300 { 00301 int w = src_lowerright.x - src_upperleft.x; 00302 00303 for(; src_upperleft.y<src_lowerright.y; 00304 ++src_upperleft.y, ++mask_upperleft.y, ++dest_upperleft.y) 00305 { 00306 copyLineIf(src_upperleft.rowIterator(), 00307 src_upperleft.rowIterator() + w, sa, 00308 mask_upperleft.rowIterator(), ma, 00309 dest_upperleft.rowIterator(), da); 00310 } 00311 } 00312 00313 template <class SrcImageIterator, class SrcAccessor, 00314 class MaskImageIterator, class MaskAccessor, 00315 class DestImageIterator, class DestAccessor> 00316 inline 00317 void 00318 copyImageIf(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src, 00319 pair<MaskImageIterator, MaskAccessor> mask, 00320 pair<DestImageIterator, DestAccessor> dest) 00321 { 00322 copyImageIf(src.first, src.second, src.third, 00323 mask.first, mask.second, 00324 dest.first, dest.second); 00325 } 00326 00327 //@} 00328 00329 } // namespace vigra 00330 00331 #endif // VIGRA_COPYIMAGE_HXX
© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) |
html generated using doxygen and Python
|