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