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

vigra/meshgrid.hxx VIGRA

00001 /************************************************************************/
00002 /*                                                                      */
00003 /*                  Copyright 2009 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 #ifndef VIGRA_MESHGRID_HXX
00037 #define VIGRA_MESHGRID_HXX
00038 
00039 #include "tinyvector.hxx"
00040 #include "diff2d.hxx"
00041 
00042 namespace vigra{
00043 /** \addtogroup RangesAndPoints */
00044 //@{
00045 
00046 /********************************************************/
00047 /*                                                      */
00048 /*                 MeshGridAccessor                     */
00049 /*                                                      */
00050 /********************************************************/
00051 /** Accessor for turning iteration over Diff2D into a mesh grid.
00052 
00053     The mesh grid concept is adapted from MATLAB. It is a two banded image
00054     (i.e. with 2D vector pixel type) whose first band contains the x-coordinates
00055     of the current pixel, and whose second band contains the y-coordinates.
00056     See \ref meshGrid() for more detailed documentation.
00057 */
00058 struct MeshGridAccessor
00059 {
00060         /** the value_type of a mesh grid is a 2D vector
00061         */
00062     typedef TinyVector<Diff2D::MoveX, 2> value_type;
00063 
00064         /** read the current data item
00065         */
00066     template <class ITERATOR>
00067     value_type operator()(ITERATOR const & i) const
00068     {
00069         return value_type(i->x, i->y);
00070     }
00071 
00072         /** read the data item at an offset (can be 1D or 2D or higher order difference).
00073         */
00074     template <class ITERATOR, class DIFFERENCE>
00075     value_type operator()(ITERATOR const & i, DIFFERENCE const & diff) const
00076     {
00077         return value_type(i->x+diff.x, i->y+diff.y);
00078     }
00079 };
00080 
00081 /** Create a mesh grid for the specified rectangle.
00082 
00083     The mesh grid concept is adapted from MATLAB. It is a two banded image
00084     (i.e. with 2D vector pixel type) whose first band contains the x-coordinates
00085     of the current pixel, and whose second band contains the y-coordinates.
00086     If \a upperLeft is not the point (0,0), the mesh grid is translated relative to
00087     the pixel indices.
00088 
00089     <b> Declarations:</b>
00090 
00091     \code
00092     triple<Diff2D, Diff2D, MeshGridAccessor>
00093     meshGrid(Diff2D upperLeft, Diff2D lowerRight);
00094 
00095     triple<Diff2D, Diff2D, MeshGridAccessor>
00096     meshGrid(Rect2D const & r);
00097 
00098     \endcode
00099 
00100     <b>Usage:</b>
00101 
00102     \code
00103     #include <vigra/meshgrid.hxx>
00104     // create an image whose values are equal to each pixel's distance from the image center
00105     int width = 5, height = 7;
00106     int xc = width/2, yc = height/2; // the image center
00107 
00108     FImage dist(width, height);
00109     Point2D upperLeft(-xc, -yc);
00110 
00111     using namespace vigra::functor;
00112     transformImage(meshGrid(upperLeft, upperLeft+dist.size()),
00113                    destImage(dist),
00114                    norm(Arg1()));
00115     \endcode
00116 */
00117 inline
00118 triple<Diff2D, Diff2D, MeshGridAccessor>
00119 meshGrid(Diff2D upperLeft, Diff2D lowerRight)
00120 {
00121     return triple<Diff2D, Diff2D, MeshGridAccessor>(upperLeft, lowerRight, MeshGridAccessor());
00122 }
00123 
00124 inline
00125 triple<Diff2D, Diff2D, MeshGridAccessor>
00126 meshGrid(Rect2D const & r)
00127 {
00128     return triple<Diff2D, Diff2D, MeshGridAccessor>(r.upperLeft(), r.lowerRight(), MeshGridAccessor());
00129 }
00130 
00131 }//namespace vigra
00132 //@}
00133 #endif //VIGRA_MESHGRID_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.9.0 (Tue Nov 6 2012)