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

details vigra/affinegeometry.hxx VIGRA

00001 /************************************************************************/
00002 /*                                                                      */
00003 /*               Copyright 2005-2006 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.5.0, Dec 07 2006 )                                    */
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 #ifndef VIGRA_AFFINEGEOMETRY_HXX
00039 #define VIGRA_AFFINEGEOMETRY_HXX
00040 
00041 #include "mathutil.hxx"
00042 #include "splineimageview.hxx"
00043 #include <cmath>
00044 
00045 namespace vigra {
00046 
00047 /** \addtogroup GeometricTransformations Geometric Transformations
00048 */
00049 //@{
00050 
00051 /********************************************************/
00052 /*                                                      */
00053 /*                      rotateImage                     */
00054 /*                                                      */
00055 /********************************************************/
00056 
00057 /** \brief Rotate image by an arbitrary angle.
00058 
00059     The algorithm performs a rotation about the given center point (the image center by default)
00060     using the given SplineImageView for interpolation. The destination imae must have the same size
00061     as the source SplineImageView. The rotation is counter-clockwise, and the angle must be given in degrees.
00062     
00063     <b> Declarations:</b>
00064     
00065     pass arguments explicitly:
00066     \code
00067     namespace vigra {
00068         // rotate about given center point
00069         template <int ORDER, class T, 
00070                   class DestIterator, class DestAccessor>
00071         void rotateImage(SplineImageView<ORDER, T> const & src,
00072                          DestIterator id, DestAccessor dest, 
00073                          double angleInDegree, TinyVector<double, 2> const & center);
00074                          
00075         // rotate about image center
00076         template <int ORDER, class T, 
00077                   class DestIterator, class DestAccessor>
00078         void 
00079         rotateImage(SplineImageView<ORDER, T> const & src,
00080                     DestIterator id, DestAccessor dest, 
00081                     double angleInDegree)
00082     }
00083     \endcode
00084     
00085     use argument objects in conjunction with \ref ArgumentObjectFactories:
00086     \code
00087     namespace vigra {
00088         // rotate about given center point
00089         template <int ORDER, class T, 
00090                   class DestIterator, class DestAccessor>
00091         void 
00092         rotateImage(SplineImageView<ORDER, T> const & src,
00093                     pair<DestImageIterator, DestAccessor> dest, 
00094                     double angleInDegree, TinyVector<double, 2> const & center);
00095 
00096         // rotate about image center
00097         template <int ORDER, class T, 
00098                   class DestIterator, class DestAccessor>
00099         void 
00100         rotateImage(SplineImageView<ORDER, T> const & src,
00101                     pair<DestImageIterator, DestAccessor> dest, 
00102                     double angleInDegree);
00103     }
00104     \endcode
00105     
00106     <b> Usage:</b>
00107     
00108         <b>\#include</b> "<a href="affinegeometry_8hxx-source.html">vigra/affinegeometry.hxx</a>"<br>
00109         Namespace: vigra
00110     
00111     \code
00112     
00113     Image src(width, height);
00114     vigra::SplineImageView<3, Image::value_type> spline(srcImageRange(src));
00115     
00116     Image dest(width, height);
00117     
00118     vigra::rotateImage(spline, destImage(dest), 38.5);
00119     
00120     \endcode
00121 
00122     <b> Required Interface:</b>
00123     
00124     \code
00125     DestImageIterator dest_upperleft;
00126     
00127     double x = ..., y = ...;
00128     
00129     if (spline.isInside(x,y))
00130         dest_accessor.set(spline(x, y), dest_upperleft);
00131 
00132     \endcode
00133 */
00134 template <int ORDER, class T, 
00135           class DestIterator, class DestAccessor>
00136 void rotateImage(SplineImageView<ORDER, T> const & src,
00137                  DestIterator id, DestAccessor dest, 
00138                  double angleInDegree, TinyVector<double, 2> const & center)
00139 {
00140     int w = src.width();
00141     int h = src.height();
00142     
00143     double angle = angleInDegree*M_PI/180.0;
00144     double c = std::cos(angle);
00145     double s = std::sin(angle);
00146     
00147     for(int y = 0; y < h; ++y, ++id.y)
00148     {
00149         typename DestIterator::row_iterator rd = id.rowIterator();
00150         double sy =  (y - center[1])*c - center[0]*s + center[1];
00151         double sx = -(y - center[1])*s - center[0]*c + center[0];
00152         for(int x=0; x < w; ++x, ++rd, sx += c, sy += s)
00153         {
00154             if(src.isInside(sx, sy))
00155                 dest.set(src(sx, sy), rd);
00156         }
00157     }
00158 }
00159 
00160 template <int ORDER, class T, 
00161           class DestIterator, class DestAccessor>
00162 inline void 
00163 rotateImage(SplineImageView<ORDER, T> const & src,
00164             pair<DestIterator, DestAccessor> dest, 
00165             double angleInDegree, TinyVector<double, 2> const & center)
00166 {
00167     rotateImage(src, dest.first, dest.second, angleInDegree, center);
00168 }
00169 
00170 template <int ORDER, class T, 
00171           class DestIterator, class DestAccessor>
00172 inline void 
00173 rotateImage(SplineImageView<ORDER, T> const & src,
00174             DestIterator id, DestAccessor dest, 
00175             double angleInDegree)
00176 {
00177     TinyVector<double, 2> center((src.width()-1.0) / 2.0, (src.height()-1.0) / 2.0);
00178     rotateImage(src, id, dest, angleInDegree, center);
00179 }
00180 
00181 template <int ORDER, class T, 
00182           class DestIterator, class DestAccessor>
00183 inline void 
00184 rotateImage(SplineImageView<ORDER, T> const & src,
00185             pair<DestIterator, DestAccessor> dest, 
00186             double angleInDegree)
00187 {
00188     TinyVector<double, 2> center((src.width()-1.0) / 2.0, (src.height()-1.0) / 2.0);
00189     rotateImage(src, dest.first, dest.second, angleInDegree, center);
00190 }
00191 
00192 //@}
00193 
00194 } // namespace vigra
00195 
00196 
00197 #endif /* VIGRA_AFFINEGEOMETRY_HXX */

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

html generated using doxygen and Python
VIGRA 1.5.0 (7 Dec 2006)