[ 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.4.0, Dec 21 2005 ) */ 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 "vigra/utilities.hxx" 00045 #include "vigra/stdimage.hxx" 00046 #include "vigra/initimage.hxx" 00047 #include "vigra/labelimage.hxx" 00048 #include "vigra/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, 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) |
html generated using doxygen and Python
|