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

details vigra/copyimage.hxx VIGRA

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.4.0, Dec 21 2005 )                                    */
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 /*        koethe@informatik.uni-hamburg.de          or                  */
00012 /*        vigra@kogs1.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 "vigra/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 template <class SrcImageIterator, class SrcAccessor,
00146           class DestImageIterator, class DestAccessor>
00147 void
00148 copyImage(SrcImageIterator src_upperleft, 
00149           SrcImageIterator src_lowerright, SrcAccessor sa,
00150           DestImageIterator dest_upperleft, DestAccessor da)
00151 {
00152     int w = src_lowerright.x - src_upperleft.x;
00153     
00154     for(; src_upperleft.y<src_lowerright.y; ++src_upperleft.y, ++dest_upperleft.y)
00155     {
00156         copyLine(src_upperleft.rowIterator(), 
00157                  src_upperleft.rowIterator() + w, sa, 
00158                  dest_upperleft.rowIterator(), da);
00159     }
00160 }
00161     
00162 template <class SrcImageIterator, class SrcAccessor,
00163           class DestImageIterator, class DestAccessor>
00164 inline
00165 void
00166 copyImage(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
00167       pair<DestImageIterator, DestAccessor> dest)
00168 {
00169     copyImage(src.first, src.second, src.third, 
00170                    dest.first, dest.second);
00171 }
00172 
00173 /********************************************************/
00174 /*                                                      */
00175 /*                       copyImageIf                    */
00176 /*                                                      */
00177 /********************************************************/
00178 
00179 /** \brief Copy source ROI into destination image.
00180 
00181     Pixel values are copied whenever the return value of the mask's
00182     accessor is not zero.
00183     If necessary, type conversion takes place.
00184     The function uses accessors to access the pixel data.
00185     
00186     <b> Declarations:</b>
00187     
00188     pass arguments explicitly:
00189     \code
00190     namespace vigra {
00191         template <class SrcImageIterator, class SrcAccessor,
00192               class MaskImageIterator, class MaskAccessor,
00193               class DestImageIterator, clas DestAccessor>
00194         void
00195         copyImageIf(SrcImageIterator src_upperleft, 
00196             SrcImageIterator src_lowerright, SrcAccessor sa,
00197             MaskImageIterator mask_upperleft, MaskAccessor ma,
00198             DestImageIterator dest_upperleft, DestAccessor da)
00199     }
00200     \endcode
00201     
00202     
00203     use argument objects in conjunction with \ref ArgumentObjectFactories:
00204     \code
00205     namespace vigra {
00206         template <class SrcImageIterator, class SrcAccessor,
00207               class MaskImageIterator, class MaskAccessor,
00208               class DestImageIterator, clas DestAccessor>
00209         void
00210         copyImageIf(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
00211             pair<MaskImageIterator, MaskAccessor> mask,
00212             pair<DestImageIterator, DestAccessor> dest)
00213     }
00214     \endcode
00215     
00216     <b> Usage:</b>
00217     
00218         <b>\#include</b> "<a href="copyimage_8hxx-source.html">vigra/copyimage.hxx</a>"<br>
00219         Namespace: vigra
00220     
00221     \code
00222     vigra::copyImageIf(srcImageRange(src), maskImage(mask), destImage(dest));
00223 
00224     \endcode
00225 
00226     <b> Required Interface:</b>
00227     
00228     \code
00229     SrcImageIterator src_upperleft, src_lowerright;
00230     DestImageIterator dest_upperleft;
00231     MaskImageIterator mask_upperleft;
00232     SrcImageIterator::row_iterator sx = src_upperleft.rowIterator();
00233     MaskImageIterator::row_iterator mx = mask_upperleft.rowIterator();
00234     DestImageIterator::row_iterator dx = dest_upperleft.rowIterator();
00235     
00236     SrcAccessor src_accessor;
00237     DestAccessor dest_accessor;
00238     MaskAccessor mask_accessor;
00239     Functor functor;
00240     
00241     if(mask_accessor(mx))
00242         dest_accessor.set(src_accessor(sx), dx);
00243 
00244     \endcode
00245     
00246 */
00247 template <class SrcImageIterator, class SrcAccessor,
00248           class MaskImageIterator, class MaskAccessor,
00249           class DestImageIterator, class DestAccessor>
00250 void
00251 copyImageIf(SrcImageIterator src_upperleft, 
00252             SrcImageIterator src_lowerright, SrcAccessor sa,
00253             MaskImageIterator mask_upperleft, MaskAccessor ma,
00254         DestImageIterator dest_upperleft, DestAccessor da)
00255 {
00256     int w = src_lowerright.x - src_upperleft.x;
00257     
00258     for(; src_upperleft.y<src_lowerright.y; 
00259              ++src_upperleft.y, ++mask_upperleft.y, ++dest_upperleft.y)
00260     {
00261         copyLineIf(src_upperleft.rowIterator(), 
00262                    src_upperleft.rowIterator() + w, sa, 
00263                    mask_upperleft.rowIterator(), ma, 
00264                    dest_upperleft.rowIterator(), da);
00265     }
00266 }
00267 
00268 template <class SrcImageIterator, class SrcAccessor,
00269           class MaskImageIterator, class MaskAccessor,
00270           class DestImageIterator, class DestAccessor>
00271 inline
00272 void
00273 copyImageIf(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> src,
00274         pair<MaskImageIterator, MaskAccessor> mask,
00275         pair<DestImageIterator, DestAccessor> dest)
00276 {
00277     copyImageIf(src.first, src.second, src.third, 
00278                 mask.first, mask.second, 
00279         dest.first, dest.second);
00280 }
00281 
00282 //@}
00283 
00284 } // namespace vigra
00285 
00286 #endif // VIGRA_COPYIMAGE_HXX

© Ullrich Köthe (koethe@informatik.uni-hamburg.de)
Cognitive Systems Group, University of Hamburg, Germany

html generated using doxygen and Python
VIGRA 1.4.0 (21 Dec 2005)