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

vigra/copyimage.hxx

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