VIGRA - vigra/localminmax.hxx Source File

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