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

vigra/localminmax.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_LOCALMINMAX_HXX
00039 #define VIGRA_LOCALMINMAX_HXX
00040 
00041 #include <vector>
00042 #include <functional>
00043 #include "utilities.hxx"
00044 #include "stdimage.hxx"
00045 #include "initimage.hxx"
00046 #include "labelimage.hxx"
00047 #include "pixelneighborhood.hxx"
00048 
00049 namespace vigra {
00050 
00051 /** \addtogroup LocalMinMax Local Minima and Maxima
00052 
00053     Detect local minima and maxima of the gray level,
00054     including extremal plateaus larger than 1 pixel
00055 */
00056 //@{
00057 
00058 namespace detail {
00059 
00060 template <class SrcIterator, class SrcAccessor,
00061           class DestIterator, class DestAccessor,
00062           class DestValue, class Neighborhood,
00063           class Compare>
00064 void
00065 localMinMax(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00066                 DestIterator dul, DestAccessor da,
00067                 DestValue marker, Neighborhood neighborhood,
00068                 Compare compare)
00069 {
00070     int w = slr.x - sul.x - 2;
00071     int h = slr.y - sul.y - 2;
00072 
00073     int i,x,y;
00074 
00075     sul += Diff2D(1,1);
00076     dul += Diff2D(1,1);
00077 
00078     for(y=0; y<h; ++y, ++sul.y, ++dul.y)
00079     {
00080         SrcIterator  sx = sul;
00081         DestIterator dx = dul;
00082 
00083         for(x=0; x<w; ++x, ++sx.x, ++dx.x)
00084         {
00085             typename SrcAccessor::value_type v = sa(sx);
00086             NeighborhoodCirculator<SrcIterator, Neighborhood> sc(sx);
00087             for(i = 0; i < Neighborhood::DirectionCount; ++i, ++sc)
00088             {
00089                 if(!compare(v, sa(sc)))
00090                     break;
00091             }
00092 
00093             if(i == Neighborhood::DirectionCount)
00094                 da.set(marker, dx);
00095         }
00096     }
00097 }
00098 
00099 } // namespace detail
00100 
00101 
00102 /********************************************************/
00103 /*                                                      */
00104 /*                       localMinima                    */
00105 /*                                                      */
00106 /********************************************************/
00107 
00108 /** \brief Find local minima in an image.
00109 
00110     The minima are found only when the have a size of one pixel.
00111     Use \ref extendedLocalMinima() to find minimal plateaus. Minima are
00112     marked in the destination image with the given marker value
00113     (default is 1), all other destination pixels remain unchanged.
00114     <TT>SrcAccessor::value_type</TT> must be less-comparable.
00115     A pixel at the image border will never be marked as minimum.
00116     Pass \ref vigra::EightNeighborCode or \ref vigra::FourNeighborCode
00117     to determine the neighborhood where pixel values are compared.
00118     The function uses accessors.
00119 
00120     <b> Declarations:</b>
00121 
00122     pass arguments explicitly:
00123     \code
00124     namespace vigra {
00125         template <class SrcIterator, class SrcAccessor,
00126                   class DestIterator, class DestAccessor,
00127                   class DestValue = DestAccessor::value_type,
00128                   class Neighborhood = EightNeighborCode>
00129         void
00130         localMinima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00131                     DestIterator dul, DestAccessor da,
00132                     DestValue marker = NumericTraits<DestValue>::one(),
00133                     Neighborhood neighborhood = EightNeighborCode())
00134     }
00135     \endcode
00136 
00137     use argument objects in conjunction with \ref ArgumentObjectFactories :
00138     \code
00139     namespace vigra {
00140         template <class SrcIterator, class SrcAccessor,
00141                   class DestIterator, class DestAccessor,
00142                   class DestValue = DestAccessor::value_type,
00143                   class Neighborhood = EightNeighborCode>
00144         void
00145         localMinima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00146                     pair<DestIterator, DestAccessor> dest,
00147                     DestValue marker = NumericTraits<DestValue>::one(),
00148                     Neighborhood neighborhood = EightNeighborCode())
00149     }
00150     \endcode
00151 
00152     <b> Usage:</b>
00153 
00154         <b>\#include</b> <<a href="localminmax_8hxx-source.html">vigra/localminmax.hxx</a>><br>
00155     Namespace: vigra
00156 
00157     \code
00158     vigra::BImage src(w,h), minima(w,h);
00159 
00160     // init destiniation image
00161     minima = 0;
00162 
00163     vigra::localMinima(srcImageRange(src), destImage(minima));
00164     \endcode
00165 
00166     <b> Required Interface:</b>
00167 
00168     \code
00169     SrcImageIterator src_upperleft, src_lowerright;
00170     DestImageIterator dest_upperleft;
00171 
00172     SrcAccessor src_accessor;
00173     DestAccessor dest_accessor;
00174 
00175     SrcAccessor::value_type u = src_accessor(src_upperleft);
00176 
00177     u < u
00178 
00179     DestValue marker;
00180     dest_accessor.set(marker, dest_upperleft);
00181     \endcode
00182 
00183 */
00184 doxygen_overloaded_function(template <...> void localMinima)
00185 
00186 template <class SrcIterator, class SrcAccessor,
00187           class DestIterator, class DestAccessor,
00188           class DestValue, class Neighborhood>
00189 inline void
00190 localMinima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00191             DestIterator dul, DestAccessor da,
00192             DestValue marker, Neighborhood neighborhood)
00193 {
00194     detail::localMinMax(sul, slr, sa, dul, da, marker, neighborhood,
00195                     std::less<typename SrcAccessor::value_type>());
00196 }
00197 
00198 template <class SrcIterator, class SrcAccessor,
00199           class DestIterator, class DestAccessor, class DestValue>
00200 inline void
00201 localMinima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00202             DestIterator dul, DestAccessor da,
00203             DestValue marker)
00204 {
00205     localMinima(sul, slr, sa, dul, da, marker, EightNeighborCode());
00206 }
00207 
00208 template <class SrcIterator, class SrcAccessor,
00209           class DestIterator, class DestAccessor>
00210 inline void
00211 localMinima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00212             DestIterator dul, DestAccessor da)
00213 {
00214     localMinima(sul, slr, sa, dul, da,
00215                 NumericTraits<typename DestAccessor::value_type>::one(),
00216                 EightNeighborCode());
00217 }
00218 
00219 template <class SrcIterator, class SrcAccessor,
00220           class DestIterator, class DestAccessor,
00221           class DestValue, class Neighborhood>
00222 inline void
00223 localMinima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00224             pair<DestIterator, DestAccessor> dest,
00225             DestValue marker, Neighborhood neighborhood)
00226 {
00227     localMinima(src.first, src.second, src.third,
00228                 dest.first, dest.second, marker, neighborhood);
00229 }
00230 
00231 template <class SrcIterator, class SrcAccessor,
00232           class DestIterator, class DestAccessor, class DestValue>
00233 inline void
00234 localMinima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00235             pair<DestIterator, DestAccessor> dest,
00236             DestValue marker)
00237 {
00238     localMinima(src.first, src.second, src.third,
00239                 dest.first, dest.second, marker, EightNeighborCode());
00240 }
00241 
00242 template <class SrcIterator, class SrcAccessor,
00243           class DestIterator, class DestAccessor>
00244 inline void
00245 localMinima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00246             pair<DestIterator, DestAccessor> dest)
00247 {
00248     localMinima(src.first, src.second, src.third,
00249                 dest.first, dest.second,
00250                 NumericTraits<typename DestAccessor::value_type>::one(),
00251                 EightNeighborCode());
00252 }
00253 
00254 /********************************************************/
00255 /*                                                      */
00256 /*                       localMaxima                    */
00257 /*                                                      */
00258 /********************************************************/
00259 
00260 /** \brief Find local maxima in an image.
00261 
00262     The maxima are found only when the have a size of one pixel.
00263     Use \ref extendedLocalMaxima() to find maximal plateaus. Maxima are
00264     marked in the destination image with the given marker value
00265     (default is 1), all other destination pixels remain unchanged.
00266     <TT>SrcAccessor::value_type</TT> must be less-comparable.
00267     A pixel at the image border will never be marked as maximum.
00268     The function uses accessors.
00269 
00270     <b> Declarations:</b>
00271 
00272     pass arguments explicitly:
00273     \code
00274     namespace vigra {
00275         template <class SrcIterator, class SrcAccessor,
00276                   class DestIterator, class DestAccessor,
00277                   class DestValue = DestAccessor::value_type,
00278                   class Neighborhood = EightNeighborCode>
00279         void
00280         localMaxima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00281                     DestIterator dul, DestAccessor da,
00282                     DestValue marker = NumericTraits<DestValue>::one(),
00283                     Neighborhood neighborhood = EightNeighborCode())
00284     }
00285     \endcode
00286 
00287     use argument objects in conjunction with \ref ArgumentObjectFactories :
00288     \code
00289     namespace vigra {
00290         template <class SrcIterator, class SrcAccessor,
00291                   class DestIterator, class DestAccessor,
00292                   class DestValue = DestAccessor::value_type,
00293                   class Neighborhood = EightNeighborCode>
00294         void
00295         localMaxima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00296                     pair<DestIterator, DestAccessor> dest,
00297                     DestValue marker = NumericTraits<DestValue>::one(),
00298                     Neighborhood neighborhood = EightNeighborCode())
00299     }
00300     \endcode
00301 
00302     <b> Usage:</b>
00303 
00304         <b>\#include</b> <<a href="localminmax_8hxx-source.html">vigra/localminmax.hxx</a>><br>
00305     Namespace: vigra
00306 
00307     \code
00308     vigra::BImage src(w,h), maxima(w,h);
00309 
00310     // init destiniation image
00311     maxima = 0;
00312 
00313     vigra::localMaxima(srcImageRange(src), destImage(maxima));
00314     \endcode
00315 
00316     <b> Required Interface:</b>
00317 
00318     \code
00319     SrcImageIterator src_upperleft, src_lowerright;
00320     DestImageIterator dest_upperleft;
00321 
00322     SrcAccessor src_accessor;
00323     DestAccessor dest_accessor;
00324 
00325     SrcAccessor::value_type u = src_accessor(src_upperleft);
00326 
00327     u < u
00328 
00329     DestValue marker;
00330     dest_accessor.set(marker, dest_upperleft);
00331     \endcode
00332 
00333 */
00334 doxygen_overloaded_function(template <...> void localMaxima)
00335 
00336 template <class SrcIterator, class SrcAccessor,
00337           class DestIterator, class DestAccessor,
00338           class DestValue, class Neighborhood>
00339 inline void
00340 localMaxima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00341             DestIterator dul, DestAccessor da,
00342             DestValue marker, Neighborhood neighborhood)
00343 {
00344     detail::localMinMax(sul, slr, sa, dul, da, marker, neighborhood,
00345                     std::greater<typename SrcAccessor::value_type>());
00346 }
00347 
00348 template <class SrcIterator, class SrcAccessor,
00349           class DestIterator, class DestAccessor, class DestValue>
00350 inline void
00351 localMaxima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00352             DestIterator dul, DestAccessor da,
00353             DestValue marker)
00354 {
00355     localMaxima(sul, slr, sa, dul, da, marker, EightNeighborCode());
00356 }
00357 
00358 template <class SrcIterator, class SrcAccessor,
00359           class DestIterator, class DestAccessor>
00360 inline void
00361 localMaxima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00362             DestIterator dul, DestAccessor da)
00363 {
00364     localMaxima(sul, slr, sa, dul, da,
00365                 NumericTraits<typename DestAccessor::value_type>::one(),
00366                 EightNeighborCode());
00367 }
00368 
00369 template <class SrcIterator, class SrcAccessor,
00370           class DestIterator, class DestAccessor,
00371           class DestValue, class Neighborhood>
00372 inline void
00373 localMaxima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00374             pair<DestIterator, DestAccessor> dest,
00375             DestValue marker, Neighborhood neighborhood)
00376 {
00377     localMaxima(src.first, src.second, src.third,
00378                 dest.first, dest.second, marker, neighborhood);
00379 }
00380 
00381 template <class SrcIterator, class SrcAccessor,
00382           class DestIterator, class DestAccessor, class DestValue>
00383 inline void
00384 localMaxima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00385             pair<DestIterator, DestAccessor> dest,
00386             DestValue marker)
00387 {
00388     localMaxima(src.first, src.second, src.third,
00389                 dest.first, dest.second, marker, EightNeighborCode());
00390 }
00391 
00392 template <class SrcIterator, class SrcAccessor,
00393           class DestIterator, class DestAccessor>
00394 inline void
00395 localMaxima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00396             pair<DestIterator, DestAccessor> dest)
00397 {
00398     localMaxima(src.first, src.second, src.third,
00399                 dest.first, dest.second,
00400                 NumericTraits<typename DestAccessor::value_type>::one(),
00401                 EightNeighborCode());
00402 }
00403 
00404 namespace detail {
00405 
00406 template <class SrcIterator, class SrcAccessor,
00407           class DestIterator, class DestAccessor, class DestValue,
00408           class Neighborhood, class Compare, class Equal>
00409 void
00410 extendedLocalMinMax(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00411             DestIterator dul, DestAccessor da, DestValue marker,
00412             Neighborhood /*neighborhood*/, Compare compare, Equal equal)
00413 {
00414     typedef typename SrcAccessor::value_type SrcType;
00415 
00416     int w = slr.x - sul.x;
00417     int h = slr.y - sul.y;
00418 
00419     int i,x,y;
00420 
00421     BasicImage<int> labels(w,h);
00422 
00423     int number_of_regions =
00424         labelImage(sul, slr, sa, labels.upperLeft(), labels.accessor(),
00425                    (Neighborhood::DirectionCount == 8), equal);
00426 
00427     // assume that a region is a extremum until the opposite is proved
00428     std::vector<unsigned char> isExtremum(number_of_regions+1, (unsigned char)1);
00429 
00430     BasicImage<int>::traverser ly = labels.upperLeft();
00431 
00432     for(y=0; y<h; ++y, ++sul.y, ++ly.y)
00433     {
00434         SrcIterator  sx = sul;
00435         BasicImage<int>::traverser lx(ly);
00436 
00437         for(x=0; x<w; ++x, ++sx.x, ++lx.x)
00438         {
00439             int lab = *lx;
00440             if(x == 0 || y == 0 || x == w-1 || y == h-1)
00441             {
00442                 // mark all regions that touch the image border as non-extremum
00443                 isExtremum[lab] = 0;
00444                 continue;
00445             }
00446 
00447             SrcType v = sa(sx);
00448             NeighborhoodCirculator<SrcIterator, Neighborhood> sc(sx);
00449             NeighborhoodCirculator<BasicImage<int>::traverser, Neighborhood> lc(lx);
00450             for(i=0; i<Neighborhood::DirectionCount; ++i, ++sc, ++lc)
00451             {
00452                 if(lab != *lc && compare(sa(sc),v))
00453                     isExtremum[lab] = 0;
00454             }
00455 
00456         }
00457     }
00458 
00459     ly = labels.upperLeft();
00460     for(y=0; y<h; ++y, ++dul.y, ++ly.y)
00461     {
00462         DestIterator  xd = dul;
00463         BasicImage<int>::Iterator lx(ly);
00464 
00465         for(x=0; x<w; ++x, ++xd.x, ++lx.x)
00466         {
00467             if(isExtremum[*lx])
00468                 da.set(marker, xd);
00469         }
00470     }
00471 }
00472 
00473 } // namespace detail
00474 
00475 /********************************************************/
00476 /*                                                      */
00477 /*                 extendedLocalMinima                  */
00478 /*                                                      */
00479 /********************************************************/
00480 
00481 /** \brief Find local minimal regions in an image.
00482 
00483     This function finds regions of uniform pixel value
00484     whose neighboring regions are all have smaller values
00485     (minimal plateaus of arbitrary size). By default, the pixels
00486     in a plateau have exactly identical values. By passing an <tt>EqualityFunctor</tt>
00487     with tolerance, one can allow for plateaus that are not quite constant
00488     (this is often necessary with float pixel values). Pass
00489     \ref vigra::EightNeighborCode or \ref vigra::FourNeighborCode
00490     to determine the neighborhood where pixel values are compared.
00491 
00492 
00493     Minimal regions are
00494     marked in the destination image with the given marker value
00495     (default is 1), all other destination pixels remain unchanged.
00496     <TT>SrcAccessor::value_type</TT> must be equality-comparable and
00497     less-comparable.
00498     A pixel or region touching the image border will never be marked as minimum or
00499     minimal plateau.
00500     The function uses accessors.
00501 
00502     <b> Declarations:</b>
00503 
00504     pass arguments explicitly:
00505     \code
00506     namespace vigra {
00507         template <class SrcIterator, class SrcAccessor,
00508                   class DestIterator, class DestAccessor,
00509                   class DestValue = DestAccessor::value_type,
00510                   class Neighborhood = EightNeighborCode,
00511                   class EqualityFunctor = std::equal_to<typename SrcAssessor::value_type> >
00512         void
00513         extendedLocalMinima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00514                             DestIterator dul, DestAccessor da,
00515                             DestValue marker = NumericTraits<DestValue>::one(),
00516                             Neighborhood neighborhood = EightNeighborCode(),
00517                             EqualityFunctor equal = EqualityFunctor())
00518     }
00519     \endcode
00520 
00521     use argument objects in conjunction with \ref ArgumentObjectFactories :
00522     \code
00523     namespace vigra {
00524         template <class SrcIterator, class SrcAccessor,
00525                   class DestIterator, class DestAccessor,
00526                   class DestValue = DestAccessor::value_type,
00527                   class Neighborhood = EightNeighborCode,
00528                   class EqualityFunctor = std::equal_to<typename SrcAssessor::value_type> >
00529         void
00530         extendedLocalMinima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00531                             pair<DestIterator, DestAccessor> dest,
00532                             DestValue marker = NumericTraits<DestValue>::one(),
00533                             Neighborhood neighborhood = EightNeighborCode(),
00534                             EqualityFunctor equal = EqualityFunctor())
00535     }
00536     \endcode
00537 
00538     <b> Usage:</b>
00539 
00540         <b>\#include</b> <<a href="localminmax_8hxx-source.html">vigra/localminmax.hxx</a>><br>
00541     Namespace: vigra
00542 
00543     \code
00544 
00545     // optional: define an equality functor
00546     template <class T>
00547     struct EqualWithToleranceFunctor
00548     {
00549         EqualWithToleranceFunctor(T tolerance)
00550         : t(tolerance)
00551         {}
00552 
00553         bool operator()(T l, T r) const
00554         {
00555             return vigra::abs(l-r) <= t;
00556         }
00557 
00558         T t;
00559     };
00560 
00561     vigra::BImage src(w,h), minima(w,h);
00562 
00563     // init destiniation image
00564     minima.init(0);
00565 
00566     vigra::extendedLocalMinima(srcImageRange(src), destImage(minima));
00567 
00568     // allow plateaus with tolerance
00569     minima.init(0);
00570     vigra::extendedLocalMinima(srcImageRange(src), destImage(minima), 1.0,
00571                                EqualWithToleranceFunctor<unsigned char>(1));
00572     \endcode
00573 
00574     <b> Required Interface:</b>
00575 
00576     \code
00577     SrcImageIterator src_upperleft, src_lowerright;
00578     DestImageIterator dest_upperleft;
00579 
00580     SrcAccessor src_accessor;
00581     DestAccessor dest_accessor;
00582 
00583     SrcAccessor::value_type u = src_accessor(src_upperleft);
00584 
00585     EqualityFunctor equal;
00586     u == u
00587     equal(u, u);
00588     u < u
00589 
00590     DestValue marker;
00591     dest_accessor.set(marker, dest_upperleft);
00592     \endcode
00593 
00594 */
00595 doxygen_overloaded_function(template <...> void extendedLocalMinima)
00596 
00597 template <class SrcIterator, class SrcAccessor,
00598           class DestIterator, class DestAccessor, class DestValue,
00599           class Neighborhood, class EqualityFunctor>
00600 inline void
00601 extendedLocalMinima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00602             DestIterator dul, DestAccessor da, DestValue marker,
00603             Neighborhood neighborhood, EqualityFunctor equal)
00604 {
00605     typedef typename SrcAccessor::value_type SrcType;
00606 
00607     detail::extendedLocalMinMax(sul, slr, sa, dul, da,
00608                                 marker, neighborhood,
00609                                 std::less<SrcType>(), equal);
00610 }
00611 
00612 template <class SrcIterator, class SrcAccessor,
00613           class DestIterator, class DestAccessor, class DestValue,
00614           class Neighborhood>
00615 inline void
00616 extendedLocalMinima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00617             DestIterator dul, DestAccessor da, DestValue marker,
00618             Neighborhood neighborhood)
00619 {
00620     typedef typename SrcAccessor::value_type SrcType;
00621 
00622     extendedLocalMinima(sul, slr, sa, dul, da,
00623                         marker, neighborhood, std::equal_to<SrcType>());
00624 }
00625 
00626 template <class SrcIterator, class SrcAccessor,
00627           class DestIterator, class DestAccessor, class DestValue>
00628 inline void
00629 extendedLocalMinima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00630             DestIterator dul, DestAccessor da, DestValue marker)
00631 {
00632     typedef typename SrcAccessor::value_type SrcType;
00633 
00634     extendedLocalMinima(sul, slr, sa, dul, da,
00635                         marker, EightNeighborCode());
00636 }
00637 
00638 template <class SrcIterator, class SrcAccessor,
00639           class DestIterator, class DestAccessor>
00640 inline void
00641 extendedLocalMinima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00642             DestIterator dul, DestAccessor da)
00643 {
00644     extendedLocalMinima(sul, slr, sa, dul, da,
00645                 NumericTraits<typename DestAccessor::value_type>::one());
00646 }
00647 
00648 template <class SrcIterator, class SrcAccessor,
00649           class DestIterator, class DestAccessor, class DestValue,
00650           class Neighborhood, class EqualityFunctor>
00651 inline void
00652 extendedLocalMinima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00653             pair<DestIterator, DestAccessor> dest,
00654             DestValue marker, Neighborhood neighborhood,
00655             EqualityFunctor equal)
00656 {
00657     extendedLocalMinima(src.first, src.second, src.third,
00658                 dest.first, dest.second, marker, neighborhood, equal);
00659 }
00660 
00661 template <class SrcIterator, class SrcAccessor,
00662           class DestIterator, class DestAccessor, class DestValue,
00663           class Neighborhood>
00664 inline void
00665 extendedLocalMinima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00666             pair<DestIterator, DestAccessor> dest,
00667             DestValue marker, Neighborhood neighborhood)
00668 {
00669     extendedLocalMinima(src.first, src.second, src.third,
00670                         dest.first, dest.second, marker, neighborhood);
00671 }
00672 
00673 template <class SrcIterator, class SrcAccessor,
00674           class DestIterator, class DestAccessor, class DestValue>
00675 inline void
00676 extendedLocalMinima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00677             pair<DestIterator, DestAccessor> dest,
00678             DestValue marker)
00679 {
00680     extendedLocalMinima(src.first, src.second, src.third,
00681                         dest.first, dest.second, marker);
00682 }
00683 
00684 template <class SrcIterator, class SrcAccessor,
00685           class DestIterator, class DestAccessor>
00686 inline void
00687 extendedLocalMinima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00688             pair<DestIterator, DestAccessor> dest)
00689 {
00690     extendedLocalMinima(src.first, src.second, src.third,
00691                         dest.first, dest.second);
00692 }
00693 
00694 /********************************************************/
00695 /*                                                      */
00696 /*                 extendedLocalMaxima                  */
00697 /*                                                      */
00698 /********************************************************/
00699 
00700 /** \brief Find local maximal regions in an image.
00701 
00702     This function finds regions of uniform pixel value
00703     whose neighboring regions are all have smaller values
00704     (maximal plateaus of arbitrary size). By default, the pixels
00705     in a plateau have exactly identical values. By passing an <tt>EqualityFunctor</tt>
00706     with tolerance, one can allow for plateaus that are not quite constant
00707     (this is often necessary with float pixel values). Pass
00708     \ref vigra::EightNeighborCode or \ref vigra::FourNeighborCode
00709     to determine the neighborhood where pixel values are compared.
00710 
00711 
00712     Maximal regions are
00713     marked in the destination image with the given marker value
00714     (default is 1), all other destination pixels remain unchanged.
00715     <TT>SrcAccessor::value_type</TT> must be equality-comparable and
00716     less-comparable.
00717     A pixel or region touching the image border will never be marked as maximum or
00718     maximal plateau.
00719     The function uses accessors.
00720 
00721     <b> Declarations:</b>
00722 
00723     pass arguments explicitly:
00724     \code
00725     namespace vigra {
00726         template <class SrcIterator, class SrcAccessor,
00727                   class DestIterator, class DestAccessor,
00728                   class DestValue = DestAccessor::value_type,
00729                   class Neighborhood = EightNeighborCode,
00730                   class EqualityFunctor = std::equal_to<typename SrcAssessor::value_type> >
00731         void
00732         extendedLocalMaxima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00733                             DestIterator dul, DestAccessor da,
00734                             DestValue marker = NumericTraits<DestValue>::one(),
00735                             Neighborhood neighborhood = EightNeighborCode(),
00736                             EqualityFunctor equal = EqualityFunctor())
00737     }
00738     \endcode
00739 
00740     use argument objects in conjunction with \ref ArgumentObjectFactories :
00741     \code
00742     namespace vigra {
00743         template <class SrcIterator, class SrcAccessor,
00744                   class DestIterator, class DestAccessor,
00745                   class DestValue = DestAccessor::value_type,
00746                   class Neighborhood = EightNeighborCode,
00747                   class EqualityFunctor = std::equal_to<typename SrcAssessor::value_type> >
00748         void
00749         extendedLocalMaxima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00750                             pair<DestIterator, DestAccessor> dest,
00751                             DestValue marker = NumericTraits<DestValue>::one(),
00752                             Neighborhood neighborhood = EightNeighborCode(),
00753                             EqualityFunctor equal = EqualityFunctor())
00754     }
00755     \endcode
00756 
00757     <b> Usage:</b>
00758 
00759         <b>\#include</b> <<a href="localminmax_8hxx-source.html">vigra/localminmax.hxx</a>><br>
00760     Namespace: vigra
00761 
00762     \code
00763 
00764     // optional: define an equality functor
00765     template <class T>
00766     struct EqualWithToleranceFunctor
00767     {
00768         EqualWithToleranceFunctor(T tolerance)
00769         : t(tolerance)
00770         {}
00771 
00772         bool operator()(T l, T r) const
00773         {
00774             return vigra::abs(l-r) <= t;
00775         }
00776 
00777         T t;
00778     };
00779 
00780     vigra::BImage src(w,h), maxima(w,h);
00781 
00782     // init destiniation image
00783     maxima.init(0);
00784 
00785     vigra::extendedLocalMaxima(srcImageRange(src), destImage(maxima));
00786 
00787     // allow plateaus with tolerance
00788     maxima.init(0);
00789     vigra::extendedLocalMaxima(srcImageRange(src), destImage(maxima), 1.0,
00790                                EqualWithToleranceFunctor<unsigned char>(1));
00791     \endcode
00792 
00793     <b> Required Interface:</b>
00794 
00795     \code
00796     SrcImageIterator src_upperleft, src_lowerright;
00797     DestImageIterator dest_upperleft;
00798 
00799     SrcAccessor src_accessor;
00800     DestAccessor dest_accessor;
00801 
00802     SrcAccessor::value_type u = src_accessor(src_upperleft);
00803 
00804     EqualityFunctor equal;
00805     u == u
00806     equal(u, u);
00807     u < u
00808 
00809     DestValue marker;
00810     dest_accessor.set(marker, dest_upperleft);
00811     \endcode
00812 
00813 */
00814 doxygen_overloaded_function(template <...> void extendedLocalMaxima)
00815 
00816 template <class SrcIterator, class SrcAccessor,
00817           class DestIterator, class DestAccessor, class DestValue,
00818           class Neighborhood, class EqualityFunctor>
00819 inline void
00820 extendedLocalMaxima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00821             DestIterator dul, DestAccessor da, DestValue marker,
00822             Neighborhood neighborhood, EqualityFunctor equal)
00823 {
00824     typedef typename SrcAccessor::value_type SrcType;
00825 
00826     detail::extendedLocalMinMax(sul, slr, sa, dul, da,
00827                                 marker, neighborhood,
00828                                 std::greater<SrcType>(), equal);
00829 }
00830 
00831 template <class SrcIterator, class SrcAccessor,
00832           class DestIterator, class DestAccessor, class DestValue,
00833           class Neighborhood>
00834 inline void
00835 extendedLocalMaxima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00836             DestIterator dul, DestAccessor da, DestValue marker,
00837             Neighborhood neighborhood)
00838 {
00839     typedef typename SrcAccessor::value_type SrcType;
00840 
00841     extendedLocalMaxima(sul, slr, sa, dul, da,
00842                         marker, neighborhood, std::equal_to<SrcType>());
00843 }
00844 
00845 template <class SrcIterator, class SrcAccessor,
00846           class DestIterator, class DestAccessor, class DestValue>
00847 inline void
00848 extendedLocalMaxima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00849             DestIterator dul, DestAccessor da, DestValue marker)
00850 {
00851     typedef typename SrcAccessor::value_type SrcType;
00852 
00853     extendedLocalMaxima(sul, slr, sa, dul, da,
00854                         marker, EightNeighborCode());
00855 }
00856 
00857 template <class SrcIterator, class SrcAccessor,
00858           class DestIterator, class DestAccessor>
00859 inline void
00860 extendedLocalMaxima(SrcIterator sul, SrcIterator slr, SrcAccessor sa,
00861             DestIterator dul, DestAccessor da)
00862 {
00863     extendedLocalMaxima(sul, slr, sa, dul, da,
00864                 NumericTraits<typename DestAccessor::value_type>::one());
00865 }
00866 
00867 template <class SrcIterator, class SrcAccessor,
00868           class DestIterator, class DestAccessor, class DestValue,
00869           class Neighborhood, class EqualityFunctor>
00870 inline void
00871 extendedLocalMaxima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00872             pair<DestIterator, DestAccessor> dest,
00873             DestValue marker, Neighborhood neighborhood,
00874             EqualityFunctor equal)
00875 {
00876     extendedLocalMaxima(src.first, src.second, src.third,
00877                 dest.first, dest.second, marker, neighborhood, equal);
00878 }
00879 
00880 template <class SrcIterator, class SrcAccessor,
00881           class DestIterator, class DestAccessor, class DestValue,
00882           class Neighborhood>
00883 inline void
00884 extendedLocalMaxima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00885             pair<DestIterator, DestAccessor> dest,
00886             DestValue marker, Neighborhood neighborhood)
00887 {
00888     extendedLocalMaxima(src.first, src.second, src.third,
00889                         dest.first, dest.second, marker, neighborhood);
00890 }
00891 
00892 template <class SrcIterator, class SrcAccessor,
00893           class DestIterator, class DestAccessor, class DestValue>
00894 inline void
00895 extendedLocalMaxima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00896             pair<DestIterator, DestAccessor> dest,
00897             DestValue marker)
00898 {
00899     extendedLocalMaxima(src.first, src.second, src.third,
00900                         dest.first, dest.second, marker);
00901 }
00902 
00903 template <class SrcIterator, class SrcAccessor,
00904           class DestIterator, class DestAccessor>
00905 inline void
00906 extendedLocalMaxima(triple<SrcIterator, SrcIterator, SrcAccessor> src,
00907             pair<DestIterator, DestAccessor> dest)
00908 {
00909     extendedLocalMaxima(src.first, src.second, src.third,
00910                         dest.first, dest.second);
00911 }
00912 
00913 //@}
00914 
00915 } // namespace vigra
00916 
00917 #endif // VIGRA_LOCALMINMAX_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)