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