[ VIGRA Homepage | Function Index | Class Index | Namespaces | File List | Main Page ]

# vigra/seededregiongrowing3d.hxx

    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) Heidelberg Collaboratory for Image Processing, University of Heidelberg, Germany | html generated using doxygen and Python VIGRA 1.6.0 (13 Aug 2008)