[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]
00001 /************************************************************************/ 00002 /* */ 00003 /* Copyright 2003-2007 by Kasim Terzic, Christian-Dennis Rahn */ 00004 /* and Ullrich Koethe */ 00005 /* Cognitive Systems Group, University of Hamburg, Germany */ 00006 /* */ 00007 /* This file is part of the VIGRA computer vision library. */ 00008 /* ( Version 1.6.0, Aug 13 2008 ) */ 00009 /* The VIGRA Website is */ 00010 /* http://kogs-www.informatik.uni-hamburg.de/~koethe/vigra/ */ 00011 /* Please direct questions, bug reports, and contributions to */ 00012 /* ullrich.koethe@iwr.uni-heidelberg.de or */ 00013 /* vigra@informatik.uni-hamburg.de */ 00014 /* */ 00015 /* Permission is hereby granted, free of charge, to any person */ 00016 /* obtaining a copy of this software and associated documentation */ 00017 /* files (the "Software"), to deal in the Software without */ 00018 /* restriction, including without limitation the rights to use, */ 00019 /* copy, modify, merge, publish, distribute, sublicense, and/or */ 00020 /* sell copies of the Software, and to permit persons to whom the */ 00021 /* Software is furnished to do so, subject to the following */ 00022 /* conditions: */ 00023 /* */ 00024 /* The above copyright notice and this permission notice shall be */ 00025 /* included in all copies or substantial portions of the */ 00026 /* Software. */ 00027 /* */ 00028 /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND */ 00029 /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES */ 00030 /* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND */ 00031 /* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT */ 00032 /* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, */ 00033 /* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING */ 00034 /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR */ 00035 /* OTHER DEALINGS IN THE SOFTWARE. */ 00036 /* */ 00037 /************************************************************************/ 00038 00039 #ifndef VIGRA_SEEDEDREGIONGROWING_3D_HXX 00040 #define VIGRA_SEEDEDREGIONGROWING_3D_HXX 00041 00042 #include <vector> 00043 #include <stack> 00044 #include <queue> 00045 #include "utilities.hxx" 00046 #include "stdimage.hxx" 00047 #include "stdimagefunctions.hxx" 00048 #include "seededregiongrowing.hxx" 00049 #include "multi_pointoperators.hxx" 00050 00051 namespace vigra { 00052 00053 namespace detail { 00054 00055 template <class COST, class Diff_type> 00056 class SeedRgVoxel 00057 { 00058 public: 00059 Diff_type location_, nearest_; 00060 COST cost_; 00061 int count_; 00062 int label_; 00063 int dist_; 00064 00065 SeedRgVoxel() 00066 //: location_(0,0,0), nearest_(0,0,0), cost_(0), count_(0), label_(0) 00067 { 00068 location_ = Diff_type(0,0,0); 00069 nearest_ = Diff_type(0,0,0); 00070 cost_ = 0; 00071 count_ = 0; 00072 label_ = 0; 00073 } 00074 00075 SeedRgVoxel(Diff_type const & location, Diff_type const & nearest, 00076 COST const & cost, int const & count, int const & label) 00077 : location_(location), nearest_(nearest), 00078 cost_(cost), count_(count), label_(label) 00079 { 00080 int dx = location_[0] - nearest_[0]; 00081 int dy = location_[1] - nearest_[1]; 00082 int dz = location_[2] - nearest_[2]; 00083 dist_ = dx * dx + dy * dy + dz * dz; 00084 } 00085 00086 void set(Diff_type const & location, Diff_type const & nearest, 00087 COST const & cost, int const & count, int const & label) 00088 { 00089 location_ = location; 00090 nearest_ = nearest; 00091 cost_ = cost; 00092 count_ = count; 00093 label_ = label; 00094 00095 int dx = location_[0] - nearest_[0]; 00096 int dy = location_[1] - nearest_[1]; 00097 int dz = location_[2] - nearest_[2]; 00098 dist_ = dx * dx + dy * dy + dz * dz; 00099 } 00100 00101 struct Compare 00102 { 00103 // must implement > since priority_queue looks for largest element 00104 bool operator()(SeedRgVoxel const & l, 00105 SeedRgVoxel const & r) const 00106 { 00107 if(r.cost_ == l.cost_) 00108 { 00109 if(r.dist_ == l.dist_) return r.count_ < l.count_; 00110 00111 return r.dist_ < l.dist_; 00112 } 00113 00114 return r.cost_ < l.cost_; 00115 } 00116 bool operator()(SeedRgVoxel const * l, 00117 SeedRgVoxel const * r) const 00118 { 00119 if(r->cost_ == l->cost_) 00120 { 00121 if(r->dist_ == l->dist_) return r->count_ < l->count_; 00122 00123 return r->dist_ < l->dist_; 00124 } 00125 00126 return r->cost_ < l->cost_; 00127 } 00128 }; 00129 00130 struct Allocator 00131 { 00132 ~Allocator() 00133 { 00134 while(!freelist_.empty()) 00135 { 00136 delete freelist_.top(); 00137 freelist_.pop(); 00138 } 00139 } 00140 00141 SeedRgVoxel * create(Diff_type const & location, Diff_type const & nearest, 00142 COST const & cost, int const & count, int const & label) 00143 { 00144 if(!freelist_.empty()) 00145 { 00146 SeedRgVoxel * res = freelist_.top(); 00147 freelist_.pop(); 00148 res->set(location, nearest, cost, count, label); 00149 return res; 00150 } 00151 00152 return new SeedRgVoxel(location, nearest, cost, count, label); 00153 } 00154 00155 void dismiss(SeedRgVoxel * p) 00156 { 00157 freelist_.push(p); 00158 } 00159 00160 std::stack<SeedRgVoxel<COST,Diff_type> *> freelist_; 00161 }; 00162 }; 00163 00164 } // namespace detail 00165 00166 /** \addtogroup SeededRegionGrowing 00167 Region segmentation and voronoi tesselation 00168 */ 00169 //@{ 00170 00171 /********************************************************/ 00172 /* */ 00173 /* seededRegionGrowing3D */ 00174 /* */ 00175 /********************************************************/ 00176 00177 /** \brief Three-dimensional Region Segmentation by means of Seeded Region Growing. 00178 00179 This algorithm implements seeded region growing as described in 00180 00181 The seed image is a partly segmented multi-dimensional array which contains uniquely 00182 labeled regions (the seeds) and unlabeled voxels (the candidates, label 0). 00183 Seed regions can be as large as you wish and as small as one voxel. If 00184 there are no candidates, the algorithm will simply copy the seed array 00185 into the output array. Otherwise it will aggregate the candidates into 00186 the existing regions so that a cost function is minimized. This 00187 works as follows: 00188 00189 <ol> 00190 00191 <li> Find all candidate pixels that are 6-adjacent to a seed region. 00192 Calculate the cost for aggregating each candidate into its adajacent region 00193 and put the candidates into a priority queue. 00194 00195 <li> While( priority queue is not empty) 00196 00197 <ol> 00198 00199 <li> Take the candidate with least cost from the queue. If it has not 00200 already been merged, merge it with it's adjacent region. 00201 00202 <li> Put all candidates that are 4-adjacent to the pixel just processed 00203 into the priority queue. 00204 00205 </ol> 00206 00207 </ol> 00208 00209 If <tt>SRGType == CompleteGrow</tt> (the default), this algorithm will 00210 produce a complete 6-connected tesselation of the array. 00211 Other grow types (such as keeping contours for watersheds) are currently not 00212 supported 00213 00214 The cost is determined jointly by the source array and the 00215 region statistics functor. The source array contains feature values for each 00216 pixel which will be used by the region statistics functor to calculate and 00217 update statistics for each region and to calculate the cost for each 00218 candidate. The <TT>RegionStatisticsArray</TT> must be compatible to the 00219 \ref ArrayOfRegionStatistics functor and contains an <em> array</em> of 00220 statistics objects for each region. The indices must correspond to the 00221 labels of the seed regions. The statistics for the initial regions must have 00222 been calculated prior to calling <TT>seededRegionGrowing3D()</TT> 00223 00224 For each candidate 00225 <TT>x</TT> that is adjacent to region <TT>i</TT>, the algorithm will call 00226 <TT>stats[i].cost(as(x))</TT> to get the cost (where <TT>x</TT> is a <TT>SrcImageIterator</TT> 00227 and <TT>as</TT> is 00228 the SrcAccessor). When a candidate has been merged with a region, the 00229 statistics are updated by calling <TT>stats[i].operator()(as(x))</TT>. Since 00230 the <TT>RegionStatisticsArray</TT> is passed by reference, this will overwrite 00231 the original statistics. 00232 00233 If a candidate could be merged into more than one regions with identical 00234 cost, the algorithm will favour the nearest region. If, at any point in the algorithm, 00235 the cost of the current candidate exceeds the optional <tt>max_cost</tt> value (which defaults to 00236 <tt>-1</tt>), region growing is aborted, and all voxels not yet assigned to a region 00237 remain unlabeled. 00238 00239 In some cases, the cost only depends on the feature value of the current 00240 voxel. Then the update operation will simply be a no-op, and the <TT>cost()</TT> 00241 function returns its argument. This behavior is implemented by the 00242 \ref SeedRgDirectValueFunctor. 00243 00244 <b> Declarations:</b> 00245 00246 pass arguments explicitly: 00247 \code 00248 namespace vigra { 00249 template <class SrcImageIterator, class Diff_type, class SrcAccessor, 00250 class SeedImageIterator, class SeedAccessor, 00251 class DestImageIterator, class DestAccessor, 00252 class RegionStatisticsArray, class CostThresholdType > 00253 void seededRegionGrowing3D(SrcImageIterator srcul, Diff_type shape, 00254 SrcAccessor as, 00255 SeedImageIterator seedsul, SeedAccessor aseeds, 00256 DestImageIterator destul, DestAccessor ad, 00257 RegionStatisticsArray & stats, 00258 CostThresholdType max_cost = -1.0, 00259 const SRGType srgType == CompleteGrow); 00260 00261 template <class SrcImageIterator, class Diff_type, class SrcAccessor, 00262 class SeedImageIterator, class SeedAccessor, 00263 class DestImageIterator, class DestAccessor, 00264 class RegionStatisticsArray> 00265 void seededRegionGrowing3D(SrcImageIterator srcul, Diff_type shape, 00266 SrcAccessor as, 00267 SeedImageIterator seedsul, SeedAccessor aseeds, 00268 DestImageIterator destul, DestAccessor ad, 00269 RegionStatisticsArray & stats, 00270 const SRGType srgType == CompleteGrow); 00271 00272 } 00273 \endcode 00274 00275 use argument objects in conjunction with \ref ArgumentObjectFactories : 00276 \code 00277 namespace vigra { 00278 template <class SrcImageIterator, class Shape, class SrcAccessor, 00279 class SeedImageIterator, class SeedAccessor, 00280 class DestImageIterator, class DestAccessor, 00281 class RegionStatisticsArray, class CostThresholdType> 00282 void 00283 seededRegionGrowing3D(triple<SrcImageIterator, Shape, SrcAccessor> img1, 00284 pair<SeedImageIterator, SeedAccessor> img3, 00285 pair<DestImageIterator, DestAccessor> img4, 00286 RegionStatisticsArray & stats, 00287 CostThresholdType max_cost = -1.0, 00288 const SRGType srgType == CompleteGrow); 00289 00290 template <class SrcImageIterator, class Shape, class SrcAccessor, 00291 class SeedImageIterator, class SeedAccessor, 00292 class DestImageIterator, class DestAccessor, 00293 class RegionStatisticsArray> 00294 void 00295 seededRegionGrowing3D(triple<SrcImageIterator, Shape, SrcAccessor> img1, 00296 pair<SeedImageIterator, SeedAccessor> img3, 00297 pair<DestImageIterator, DestAccessor> img4, 00298 RegionStatisticsArray & stats, 00299 const SRGType srgType == CompleteGrow); 00300 } 00301 \endcode 00302 00303 */ 00304 doxygen_overloaded_function(template <...> void seededRegionGrowing3D) 00305 00306 template <class SrcImageIterator, class Diff_type, class SrcAccessor, 00307 class SeedImageIterator, class SeedAccessor, 00308 class DestImageIterator, class DestAccessor, 00309 class RegionStatisticsArray, class CostThresholdType> 00310 void seededRegionGrowing3D(SrcImageIterator srcul, Diff_type shape, 00311 SrcAccessor as, 00312 SeedImageIterator seedsul, SeedAccessor aseeds, 00313 DestImageIterator destul, DestAccessor ad, 00314 RegionStatisticsArray & stats, CostThresholdType max_cost, 00315 const SRGType srgType) 00316 { 00317 SrcImageIterator srclr = srcul + shape; 00318 //int w = srclr.x - srcul.x; 00319 int w = shape[0]; 00320 //int h = srclr.y - srcul.y; 00321 int h = shape[1]; 00322 //int d = srclr.z - srcul.z; 00323 int d = shape[2]; 00324 int count = 0; 00325 00326 SrcImageIterator isy = srcul, isx = srcul, isz = srcul; // iterators for the src image 00327 00328 typedef typename RegionStatisticsArray::value_type RegionStatistics; 00329 typedef typename PromoteTraits<typename RegionStatistics::cost_type, CostThresholdType>::Promote CostType; 00330 typedef detail::SeedRgVoxel<CostType, Diff_type> Voxel; 00331 00332 typename Voxel::Allocator allocator; 00333 00334 typedef std::priority_queue< Voxel *, 00335 std::vector<Voxel *>, 00336 typename Voxel::Compare > SeedRgVoxelHeap; 00337 typedef MultiArray<3, int> IVolume; 00338 00339 // copy seed image in an image with border 00340 Diff_type regionshape = shape + Diff_type(2,2,2); 00341 IVolume regions(regionshape); 00342 MultiIterator<3,int> ir = regions.traverser_begin(); 00343 ir = ir + Diff_type(1,1,1); 00344 00345 //IVolume::Iterator iry, irx, irz; 00346 MultiIterator<3,int> iry, irx, irz; 00347 00348 //initImageBorder(destImageRange(regions), 1, SRGWatershedLabel); 00349 initMultiArrayBorder(destMultiArrayRange(regions), 1, SRGWatershedLabel); 00350 00351 copyMultiArray(seedsul, Diff_type(w,h,d), aseeds, ir, AccessorTraits<int>::default_accessor()/* vigra::StandardValueAccessor<int>*/); 00352 00353 // allocate and init memory for the results 00354 00355 SeedRgVoxelHeap pheap; 00356 int cneighbor; 00357 00358 static const Diff_type dist[] = { Diff_type(-1, 0, 0), Diff_type( 0,-1, 0), 00359 Diff_type( 1, 0, 0), Diff_type( 0, 1, 0), 00360 Diff_type( 0, 0,-1), Diff_type( 0, 0, 1) }; 00361 00362 Diff_type pos(0,0,0); 00363 00364 for(isz=srcul, irz=ir, pos[2]=0; pos[2]<d; 00365 pos[2]++, isz.dim2()++, irz.dim2()++) 00366 { 00367 //std::cerr << "Z = " << pos[2] << std::endl; 00368 00369 for(isy=isz, iry=irz, pos[1]=0; pos[1]<h; 00370 pos[1]++, isy.dim1()++, iry.dim1()++) 00371 { 00372 //std::cerr << "Y = " << pos[1] << std::endl; 00373 00374 for(isx=isy, irx=iry, pos[0]=0; pos[0]<w; 00375 pos[0]++, isx.dim0()++, irx.dim0()++) 00376 { 00377 //std::cerr << "X = " << pos[0] << std::endl; 00378 00379 if(*irx == 0) 00380 { 00381 // find candidate pixels for growing and fill heap 00382 for(int i=0; i<6; i++) 00383 { 00384 cneighbor = *(irx + dist[i]); 00385 if(cneighbor > 0) 00386 { 00387 CostType cost = stats[cneighbor].cost(as(isx)); 00388 00389 Voxel * voxel = 00390 allocator.create(pos, pos+dist[i], cost, count++, cneighbor); 00391 pheap.push(voxel); 00392 } 00393 } 00394 } 00395 } 00396 } 00397 } 00398 00399 // perform region growing 00400 while(pheap.size() != 0) 00401 { 00402 Voxel * voxel = pheap.top(); 00403 pheap.pop(); 00404 00405 if(max_cost > NumericTraits<CostThresholdType>::zero() && voxel->cost_ > max_cost) break; 00406 00407 Diff_type pos = voxel->location_; 00408 Diff_type nearest = voxel->nearest_; 00409 int lab = voxel->label_; 00410 00411 allocator.dismiss(voxel); 00412 00413 irx = ir + pos; 00414 isx = srcul + pos; 00415 00416 if(*irx) // already labelled region / watershed? 00417 continue; 00418 00419 if(srgType == KeepContours) 00420 { 00421 for(int i=0; i<6; i++) 00422 { 00423 cneighbor = * (irx + dist[i]); 00424 if((cneighbor>0) && (cneighbor != lab)) 00425 { 00426 lab = SRGWatershedLabel; 00427 break; 00428 } 00429 } 00430 } 00431 00432 *irx = lab; 00433 00434 if((srgType != KeepContours) || (lab > 0)) 00435 { 00436 // update statistics 00437 stats[*irx](as(isx)); 00438 00439 // search neighborhood 00440 // second pass: find new candidate pixels 00441 for(int i=0; i<6; i++) 00442 { 00443 if(*(irx + dist[i]) == 0) 00444 { 00445 CostType cost = stats[lab].cost(as(isx, dist[i])); 00446 00447 Voxel * new_voxel = 00448 allocator.create(pos+dist[i], nearest, cost, count++, lab); 00449 pheap.push(new_voxel); 00450 } 00451 } 00452 } 00453 } 00454 00455 // write result 00456 transformMultiArray(ir, Diff_type(w,h,d), AccessorTraits<int>::default_accessor()/* regions.accessor()*/, destul, ad, 00457 detail::UnlabelWatersheds()); 00458 } 00459 /* 00460 template <class SrcImageIterator, class SrcAccessor, 00461 class SeedImageIterator, class SeedAccessor, 00462 class DestImageIterator, class DestAccessor, 00463 class RegionStatisticsArray> 00464 inline void 00465 seededRegionGrowing3D(SrcImageIterator srcul, 00466 SrcImageIterator srclr, SrcAccessor as, 00467 SeedImageIterator seedsul, SeedAccessor aseeds, 00468 DestImageIterator destul, DestAccessor ad, 00469 RegionStatisticsArray & stats) 00470 { 00471 seededRegionGrowing3D(srcul, srclr, as, 00472 seedsul, aseeds, 00473 destul, ad, 00474 stats, CompleteGrow); 00475 }*/ 00476 /* 00477 template <class SrcImageIterator, class SrcAccessor, 00478 class SeedImageIterator, class SeedAccessor, 00479 class DestImageIterator, class DestAccessor, 00480 class RegionStatisticsArray> 00481 inline void 00482 seededRegionGrowing3D(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> img1, 00483 pair<SeedImageIterator, SeedAccessor> img3, 00484 pair<DestImageIterator, DestAccessor> img4, 00485 RegionStatisticsArray & stats, 00486 SRGType srgType) 00487 { 00488 seededRegionGrowing3D(img1.first, img1.second, img1.third, 00489 img3.first, img3.second, 00490 img4.first, img4.second, 00491 stats, srgType); 00492 } 00493 00494 template <class SrcImageIterator, class SrcAccessor, 00495 class SeedImageIterator, class SeedAccessor, 00496 class DestImageIterator, class DestAccessor, 00497 class RegionStatisticsArray> 00498 inline void 00499 seededRegionGrowing3D(triple<SrcImageIterator, SrcImageIterator, SrcAccessor> img1, 00500 pair<SeedImageIterator, SeedAccessor> img3, 00501 pair<DestImageIterator, DestAccessor> img4, 00502 RegionStatisticsArray & stats) 00503 { 00504 seededRegionGrowing3D(img1.first, img1.second, img1.third, 00505 img3.first, img3.second, 00506 img4.first, img4.second, 00507 stats, CompleteGrow); 00508 } 00509 */ 00510 00511 template <class SrcImageIterator, class Diff_type, class SrcAccessor, 00512 class SeedImageIterator, class SeedAccessor, 00513 class DestImageIterator, class DestAccessor, 00514 class RegionStatisticsArray, class CostThresholdType> 00515 void seededRegionGrowing3D(SrcImageIterator srcul, Diff_type shape, 00516 SrcAccessor as, 00517 SeedImageIterator seedsul, SeedAccessor aseeds, 00518 DestImageIterator destul, DestAccessor ad, 00519 RegionStatisticsArray & stats, CostThresholdType max_cost) 00520 { 00521 seededRegionGrowing3D( srcul, shape, as, seedsul, aseeds, destul, ad, stats, max_cost, CompleteGrow); 00522 } 00523 00524 template <class SrcImageIterator, class Diff_type, class SrcAccessor, 00525 class SeedImageIterator, class SeedAccessor, 00526 class DestImageIterator, class DestAccessor, 00527 class RegionStatisticsArray > 00528 void seededRegionGrowing3D(SrcImageIterator srcul, Diff_type shape, 00529 SrcAccessor as, 00530 SeedImageIterator seedsul, SeedAccessor aseeds, 00531 DestImageIterator destul, DestAccessor ad, 00532 RegionStatisticsArray & stats) 00533 { 00534 seededRegionGrowing3D( srcul, shape, as, seedsul, aseeds, destul, ad, stats, -1.0, CompleteGrow); 00535 } 00536 00537 template <class SrcImageIterator, class Diff_type, class SrcAccessor, 00538 class SeedImageIterator, class SeedAccessor, 00539 class DestImageIterator, class DestAccessor, 00540 class RegionStatisticsArray > 00541 void seededRegionGrowing3D(SrcImageIterator srcul, Diff_type shape, 00542 SrcAccessor as, 00543 SeedImageIterator seedsul, SeedAccessor aseeds, 00544 DestImageIterator destul, DestAccessor ad, 00545 RegionStatisticsArray & stats, SRGType srgType) 00546 { 00547 seededRegionGrowing3D( srcul, shape, as, seedsul, aseeds, destul, ad, stats, -1.0, srgType); 00548 } 00549 00550 00551 00552 template <class SrcImageIterator, class Shape, class SrcAccessor, 00553 class SeedImageIterator, class SeedAccessor, 00554 class DestImageIterator, class DestAccessor, 00555 class RegionStatisticsArray> 00556 inline void 00557 seededRegionGrowing3D(triple<SrcImageIterator, Shape, SrcAccessor> img1, 00558 pair<SeedImageIterator, SeedAccessor> img3, 00559 pair<DestImageIterator, DestAccessor> img4, 00560 RegionStatisticsArray & stats, int max_cost) 00561 { 00562 seededRegionGrowing3D(img1.first, img1.second, img1.third, 00563 img3.first, img3.second, 00564 img4.first, img4.second, 00565 stats, max_cost, CompleteGrow); 00566 } 00567 00568 template <class SrcImageIterator, class Shape, class SrcAccessor, 00569 class SeedImageIterator, class SeedAccessor, 00570 class DestImageIterator, class DestAccessor, 00571 class RegionStatisticsArray, class CostThresholdType> 00572 inline void 00573 seededRegionGrowing3D(triple<SrcImageIterator, Shape, SrcAccessor> img1, 00574 pair<SeedImageIterator, SeedAccessor> img3, 00575 pair<DestImageIterator, DestAccessor> img4, 00576 RegionStatisticsArray & stats, CostThresholdType max_cost, const SRGType srgType) 00577 { 00578 seededRegionGrowing3D(img1.first, img1.second, img1.third, 00579 img3.first, img3.second, 00580 img4.first, img4.second, 00581 stats, max_cost, srgType); 00582 } 00583 00584 00585 template <class SrcImageIterator, class Shape, class SrcAccessor, 00586 class SeedImageIterator, class SeedAccessor, 00587 class DestImageIterator, class DestAccessor, 00588 class RegionStatisticsArray> 00589 inline void 00590 seededRegionGrowing3D(triple<SrcImageIterator, Shape, SrcAccessor> img1, 00591 pair<SeedImageIterator, SeedAccessor> img3, 00592 pair<DestImageIterator, DestAccessor> img4, 00593 RegionStatisticsArray & stats, const SRGType srgType) 00594 { 00595 seededRegionGrowing3D(img1.first, img1.second, img1.third, 00596 img3.first, img3.second, 00597 img4.first, img4.second, 00598 stats, -1.0, srgType); 00599 } 00600 00601 template <class SrcImageIterator, class Shape, class SrcAccessor, 00602 class SeedImageIterator, class SeedAccessor, 00603 class DestImageIterator, class DestAccessor, 00604 class RegionStatisticsArray> 00605 inline void 00606 seededRegionGrowing3D(triple<SrcImageIterator, Shape, SrcAccessor> img1, 00607 pair<SeedImageIterator, SeedAccessor> img3, 00608 pair<DestImageIterator, DestAccessor> img4, 00609 RegionStatisticsArray & stats) 00610 { 00611 seededRegionGrowing3D(img1.first, img1.second, img1.third, 00612 img3.first, img3.second, 00613 img4.first, img4.second, 00614 stats, -1.0, CompleteGrow); 00615 } 00616 00617 00618 00619 } // namespace vigra 00620 00621 #endif // VIGRA_SEEDEDREGIONGROWING_HXX 00622
© Ullrich Köthe (ullrich.koethe@iwr.uni-heidelberg.de) |
html generated using doxygen and Python
|