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