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

vigra/multi_morphology.hxx |

    00001 /************************************************************************/
    00002 /*                                                                      */
    00003 /*     Copyright 2003-2007 by Kasim Terzic, Christian-Dennis Rahn       */
    00004 /*                        and Ullrich Koethe                            */
    00005 /*                                                                      */
    00006 /*    This file is part of the VIGRA computer vision library.           */
    00007 /*    The VIGRA Website is                                              */
    00008 /*        http://hci.iwr.uni-heidelberg.de/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 #ifndef VIGRA_MULTI_MORPHOLOGY_HXX
    00038 #define VIGRA_MULTI_MORPHOLOGY_HXX
    00039
    00040 #include <vector>
    00041 #include <cmath>
    00042 #include "multi_distance.hxx"
    00043 #include "array_vector.hxx"
    00044 #include "multi_array.hxx"
    00045 #include "accessor.hxx"
    00046 #include "numerictraits.hxx"
    00047 #include "navigator.hxx"
    00048 #include "metaprogramming.hxx"
    00049 #include "multi_pointoperators.hxx"
    00050 #include "functorexpression.hxx"
    00051
    00052 namespace vigra
    00053 {
    00054
    00055 namespace detail {
    00056
    00057 // this class simplifies the design, but more importantly, it makes sure
    00058 // that the in-place code doesn't get compiled for boolean arrays
    00059 // (were it would never executed anyway -- see the specializations below)
    00060 template <class DestType, class TmpType>
    00061 struct MultiBinaryMorphologyImpl
    00062 {
    00063     template <class SrcIterator, class SrcShape, class SrcAccessor,
    00064               class DestIterator, class DestAccessor>
    00065     static void
    00066     exec( SrcIterator s, SrcShape const & shape, SrcAccessor src,
    00067           DestIterator d, DestAccessor dest,
    00068           double radius, bool dilation)
    00069     {
    00070         using namespace vigra::functor;
    00071
    00072         // Allocate a new temporary array if the distances squared wouldn't fit
    00073         MultiArray<SrcShape::static_size, TmpType> tmpArray(shape);
    00074
    00075         separableMultiDistSquared(s, shape, src,
    00076                                   tmpArray.traverser_begin(), typename AccessorTraits<TmpType>::default_accessor(), dilation );
    00077
    00078         // threshold everything less than radius away from the edge
    00079         double radius2 = radius * radius;
    00080         DestType foreground = dilation
    00081                                  ? NumericTraits<DestType>::zero()
    00082                                  : NumericTraits<DestType>::one(),
    00083                  background = dilation
    00084                                  ? NumericTraits<DestType>::one()
    00085                                  : NumericTraits<DestType>::zero();
    00086         transformMultiArray( tmpArray.traverser_begin(), shape, StandardValueAccessor<double>(),
    00087                              d, dest,
    00088                              ifThenElse( Arg1() >= Param(radius2),
    00089                                          Param(foreground), Param(background) ) );
    00090     }
    00091 };
    00092
    00093 template <class DestType>
    00094 struct MultiBinaryMorphologyImpl<DestType, DestType>
    00095 {
    00096     template <class SrcIterator, class SrcShape, class SrcAccessor,
    00097               class DestIterator, class DestAccessor>
    00098     static void
    00099     exec( SrcIterator s, SrcShape const & shape, SrcAccessor src,
    00100           DestIterator d, DestAccessor dest,
    00101           double radius, bool dilation)
    00102     {
    00103         using namespace vigra::functor;
    00104
    00105         separableMultiDistSquared( s, shape, src, d, dest, dilation );
    00106
    00107         // threshold everything less than radius away from the edge
    00108         DestType radius2 = detail::RequiresExplicitCast<DestType>::cast(radius * radius);
    00109         DestType foreground = dilation
    00110                                  ? NumericTraits<DestType>::zero()
    00111                                  : NumericTraits<DestType>::one(),
    00112                  background = dilation
    00113                                  ? NumericTraits<DestType>::one()
    00114                                  : NumericTraits<DestType>::zero();
    00115         transformMultiArray( d, shape, dest, d, dest,
    00116                              ifThenElse( Arg1() > Param(radius2),
    00117                                          Param(foreground), Param(background) ) );
    00118     }
    00119 };
    00120
    00121 template <>
    00122 struct MultiBinaryMorphologyImpl<bool, bool>
    00123 {
    00124     template <class SrcIterator, class SrcShape, class SrcAccessor,
    00125               class DestIterator, class DestAccessor>
    00126     static void
    00127     exec( SrcIterator s, SrcShape const & shape, SrcAccessor src,
    00128           DestIterator d, DestAccessor dest, double radius, bool dilation)
    00129     {
    00130         vigra_fail("multiBinaryMorphology(): Internal error (this function should never be called).");
    00131     }
    00132 };
    00133
    00134 } // namespace detail
    00135
    00136 /** \addtogroup MultiArrayMorphology Morphological operators for multi-dimensional arrays.
    00137
    00138     These functions perform morphological operations on an arbitrary
    00139     dimensional array that is specified by iterators (compatible to \ref MultiIteratorPage)
    00140     and shape objects. It can therefore be applied to a wide range of data structures
    00141     (\ref vigra::MultiArrayView, \ref vigra::MultiArray etc.).
    00142 */
    00143 //@{
    00144
    00145 /********************************************************/
    00146 /*                                                      */
    00147 /*             multiBinaryErosion                       */
    00148 /*                                                      */
    00149 /********************************************************/
    00150 /** \brief Binary erosion on multi-dimensional arrays.
    00151
    00152     This function applies a flat circular erosion operator with a given radius. The
    00153     operation is isotropic. The input is interpreted as a binary multi-dimensional
    00154     array where non-zero pixels represent foreground and zero pixels represent
    00155     background. In the output, foreground is always represented by ones
    00156     (i.e. NumericTrais<typename DestAccessor::value_type>::one()).
    00157
    00158     This function may work in-place, which means that <tt>siter == diter</tt> is allowed.
    00159     A temporary internal array is only allocated if working on the destination
    00160     array directly would cause overflow errors (that is if
    00161     <tt> NumericTraits<typename DestAccessor::value_type>::max() < squaredNorm(shape)</tt>,
    00162     i.e. the squared length of the image diagonal doesn't fit into the destination type).
    00163
    00164     <b> Declarations:</b>
    00165
    00166     pass arguments explicitly:
    00167     \code
    00168     namespace vigra {
    00169         template <class SrcIterator, class SrcShape, class SrcAccessor,
    00170                   class DestIterator, class DestAccessor>
    00171         void
    00172         multiBinaryErosion(SrcIterator siter, SrcShape const & shape, SrcAccessor src,
    00173                                     DestIterator diter, DestAccessor dest, int radius);
    00174
    00175     }
    00176     \endcode
    00177
    00178     use argument objects in conjunction with \ref ArgumentObjectFactories :
    00179     \code
    00180     namespace vigra {
    00181         template <class SrcIterator, class SrcShape, class SrcAccessor,
    00182                   class DestIterator, class DestAccessor>
    00183         void
    00184         multiBinaryErosion(triple<SrcIterator, SrcShape, SrcAccessor> const & source,
    00185                                     pair<DestIterator, DestAccessor> const & dest,
    00186                                     int radius);
    00187
    00188     }
    00189     \endcode
    00190
    00191     <b> Usage:</b>
    00192
    00193     <b>\#include</b> <vigra/multi_morphology.hxx>
    00194
    00195     \code
    00196     MultiArray<3, unsigned char>::size_type shape(width, height, depth);
    00197     MultiArray<3, unsigned char> source(shape);
    00198     MultiArray<3, unsigned char> dest(shape);
    00199     ...
    00200
    00201     // perform isotropic binary erosion
    00202     multiBinaryErosion(srcMultiArrayRange(source), destMultiArray(dest), 3);
    00203     \endcode
    00204
    00205     \see vigra::discErosion()
    00206 */
    00207 doxygen_overloaded_function(template <...> void multiBinaryErosion)
    00208
    00209 template <class SrcIterator, class SrcShape, class SrcAccessor,
    00210           class DestIterator, class DestAccessor>
    00211 void
    00212 multiBinaryErosion( SrcIterator s, SrcShape const & shape, SrcAccessor src,
    00213                              DestIterator d, DestAccessor dest, double radius)
    00214 {
    00215     typedef typename DestAccessor::value_type DestType;
    00216     typedef Int32 TmpType;
    00217
    00218     double dmax = squaredNorm(shape);
    00219
    00220     // Get the distance squared transform of the image
    00221     if(dmax > NumericTraits<DestType>::toRealPromote(NumericTraits<DestType>::max()))
    00222     {
    00223         detail::MultiBinaryMorphologyImpl<DestType, TmpType>::exec(s, shape, src, d, dest, radius, false);
    00224     }
    00225     else    // work directly on the destination array
    00226     {
    00227         detail::MultiBinaryMorphologyImpl<DestType, DestType>::exec(s, shape, src, d, dest, radius, false);
    00228     }
    00229 }
    00230
    00231 template <class SrcIterator, class SrcShape, class SrcAccessor,
    00232           class DestIterator, class DestAccessor>
    00233 inline
    00234 void multiBinaryErosion(
    00235     triple<SrcIterator, SrcShape, SrcAccessor> const & source,
    00236     pair<DestIterator, DestAccessor> const & dest, double radius)
    00237 {
    00238     multiBinaryErosion( source.first, source.second, source.third,
    00239                                  dest.first, dest.second, radius );
    00240 }
    00241
    00242
    00243 /********************************************************/
    00244 /*                                                      */
    00245 /*             multiBinaryDilation                      */
    00246 /*                                                      */
    00247 /********************************************************/
    00248
    00249 /** \brief Binary dilation on multi-dimensional arrays.
    00250
    00251     This function applies a flat circular dilation operator with a given radius. The
    00252     operation is isotropic. The input is interpreted as a binary multi-dimensional
    00253     array where non-zero pixels represent foreground and zero pixels represent
    00254     background. In the output, foreground is always represented by ones
    00255     (i.e. NumericTrais<typename DestAccessor::value_type>::one()).
    00256
    00257     This function may work in-place, which means that <tt>siter == diter</tt> is allowed.
    00258     A temporary internal array is only allocated if working on the destination
    00259     array directly would cause overflow errors (that is if
    00260     <tt> NumericTraits<typename DestAccessor::value_type>::max() < squaredNorm(shape)</tt>,
    00261     i.e. the squared length of the image diagonal doesn't fit into the destination type).
    00262
    00263     <b> Declarations:</b>
    00264
    00265     pass arguments explicitly:
    00266     \code
    00267     namespace vigra {
    00268         template <class SrcIterator, class SrcShape, class SrcAccessor,
    00269                   class DestIterator, class DestAccessor>
    00270         void
    00271         multiBinaryDilation(SrcIterator siter, SrcShape const & shape, SrcAccessor src,
    00272                                     DestIterator diter, DestAccessor dest, int radius);
    00273
    00274     }
    00275     \endcode
    00276
    00277     use argument objects in conjunction with \ref ArgumentObjectFactories :
    00278     \code
    00279     namespace vigra {
    00280         template <class SrcIterator, class SrcShape, class SrcAccessor,
    00281                   class DestIterator, class DestAccessor>
    00282         void
    00283         multiBinaryDilation(triple<SrcIterator, SrcShape, SrcAccessor> const & source,
    00284                                     pair<DestIterator, DestAccessor> const & dest,
    00285                                     int radius);
    00286
    00287     }
    00288     \endcode
    00289
    00290     <b> Usage:</b>
    00291
    00292     <b>\#include</b> <vigra/multi_morphology.hxx>
    00293
    00294     \code
    00295     MultiArray<3, unsigned char>::size_type shape(width, height, depth);
    00296     MultiArray<3, unsigned char> source(shape);
    00297     MultiArray<3, unsigned char> dest(shape);
    00298     ...
    00299
    00300     // perform isotropic binary erosion
    00301     multiBinaryDilation(srcMultiArrayRange(source), destMultiArray(dest), 3);
    00302     \endcode
    00303
    00304     \see vigra::discDilation()
    00305 */
    00306 doxygen_overloaded_function(template <...> void multiBinaryDilation)
    00307
    00308 template <class SrcIterator, class SrcShape, class SrcAccessor,
    00309           class DestIterator, class DestAccessor>
    00310 void
    00311 multiBinaryDilation( SrcIterator s, SrcShape const & shape, SrcAccessor src,
    00312                              DestIterator d, DestAccessor dest, double radius)
    00313 {
    00314     typedef typename DestAccessor::value_type DestType;
    00315     typedef Int32 TmpType;
    00316
    00317     double dmax = squaredNorm(shape);
    00318
    00319     // Get the distance squared transform of the image
    00320     if(dmax > NumericTraits<DestType>::toRealPromote(NumericTraits<DestType>::max()))
    00321     {
    00322         detail::MultiBinaryMorphologyImpl<DestType, TmpType>::exec(s, shape, src, d, dest, radius, true);
    00323     }
    00324     else    // work directly on the destination array
    00325     {
    00326         detail::MultiBinaryMorphologyImpl<DestType, DestType>::exec(s, shape, src, d, dest, radius, true);
    00327     }
    00328 }
    00329
    00330 template <class SrcIterator, class SrcShape, class SrcAccessor,
    00331           class DestIterator, class DestAccessor>
    00332 inline
    00333 void multiBinaryDilation(
    00334     triple<SrcIterator, SrcShape, SrcAccessor> const & source,
    00335     pair<DestIterator, DestAccessor> const & dest, double radius)
    00336 {
    00337     multiBinaryDilation( source.first, source.second, source.third,
    00338                                  dest.first, dest.second, radius );
    00339 }
    00340
    00341 /********************************************************/
    00342 /*                                                      */
    00343 /*             multiGrayscaleErosion                    */
    00344 /*                                                      */
    00345 /********************************************************/
    00346 /** \brief Parabolic grayscale erosion on multi-dimensional arrays.
    00347
    00348     This function applies a parabolic erosion operator with a given spread (sigma) on
    00349     a grayscale array. The operation is isotropic.
    00350     The input is a grayscale multi-dimensional array.
    00351
    00352     This function may work in-place, which means that <tt>siter == diter</tt> is allowed.
    00353     A full-sized internal array is only allocated if working on the destination
    00354     array directly would cause overflow errors (i.e. if
    00355     <tt> typeid(typename DestAccessor::value_type) < N * M*M</tt>, where M is the
    00356     size of the largest dimension of the array.
    00357
    00358     <b> Declarations:</b>
    00359
    00360     pass arguments explicitly:
    00361     \code
    00362     namespace vigra {
    00363         template <class SrcIterator, class SrcShape, class SrcAccessor,
    00364                   class DestIterator, class DestAccessor>
    00365         void
    00366         multiGrayscaleErosion(SrcIterator siter, SrcShape const & shape, SrcAccessor src,
    00367                                     DestIterator diter, DestAccessor dest, double sigma);
    00368
    00369     }
    00370     \endcode
    00371
    00372     use argument objects in conjunction with \ref ArgumentObjectFactories :
    00373     \code
    00374     namespace vigra {
    00375         template <class SrcIterator, class SrcShape, class SrcAccessor,
    00376                   class DestIterator, class DestAccessor>
    00377         void
    00378         multiGrayscaleErosion(triple<SrcIterator, SrcShape, SrcAccessor> const & source,
    00379                                     pair<DestIterator, DestAccessor> const & dest,
    00380                                     double sigma);
    00381
    00382     }
    00383     \endcode
    00384
    00385     <b> Usage:</b>
    00386
    00387     <b>\#include</b> <vigra/multi_morphology.hxx>
    00388
    00389     \code
    00390     MultiArray<3, unsigned char>::size_type shape(width, height, depth);
    00391     MultiArray<3, unsigned char> source(shape);
    00392     MultiArray<3, unsigned char> dest(shape);
    00393     ...
    00394
    00395     // perform isotropic grayscale erosion
    00396     multiGrayscaleErosion(srcMultiArrayRange(source), destMultiArray(dest), 3.0);
    00397     \endcode
    00398
    00399     \see vigra::discErosion()
    00400 */
    00401 doxygen_overloaded_function(template <...> void multiGrayscaleErosion)
    00402
    00403 template <class SrcIterator, class SrcShape, class SrcAccessor,
    00404           class DestIterator, class DestAccessor>
    00405 void
    00406 multiGrayscaleErosion( SrcIterator s, SrcShape const & shape, SrcAccessor src,
    00407                        DestIterator d, DestAccessor dest, double sigma)
    00408 {
    00409     typedef typename NumericTraits<typename DestAccessor::value_type>::ValueType DestType;
    00410     typedef typename NumericTraits<typename DestAccessor::value_type>::Promote TmpType;
    00411     DestType MaxValue = NumericTraits<DestType>::max();
    00412     enum { N = 1 + SrcIterator::level };
    00413
    00414     // temporary array to hold the current line to enable in-place operation
    00415     ArrayVector<TmpType> tmp( shape[0] );
    00416
    00417     typedef MultiArrayNavigator<SrcIterator, N> SNavigator;
    00418     typedef MultiArrayNavigator<DestIterator, N> DNavigator;
    00419
    00420     int MaxDim = 0;
    00421     for( int i=0; i<N; i++)
    00422         if(MaxDim < shape[i]) MaxDim = shape[i];
    00423
    00424     using namespace vigra::functor;
    00425
    00426     ArrayVector<double> sigmas(shape.size(), sigma);
    00427
    00428     // Allocate a new temporary array if the distances squared wouldn't fit
    00429     if(N*MaxDim*MaxDim > MaxValue)
    00430     {
    00431         MultiArray<SrcShape::static_size, TmpType> tmpArray(shape);
    00432
    00433         detail::internalSeparableMultiArrayDistTmp( s, shape, src, tmpArray.traverser_begin(),
    00434             typename AccessorTraits<TmpType>::default_accessor(), sigmas );
    00435
    00436         transformMultiArray( tmpArray.traverser_begin(), shape,
    00437                 typename AccessorTraits<TmpType>::default_accessor(), d, dest,
    00438                 ifThenElse( Arg1() > Param(MaxValue), Param(MaxValue), Arg1() ) );
    00439         //copyMultiArray( tmpArray.traverser_begin(), shape,
    00440         //        typename AccessorTraits<TmpType>::default_accessor(), d, dest );
    00441     }
    00442     else
    00443     {
    00444         detail::internalSeparableMultiArrayDistTmp( s, shape, src, d, dest, sigmas );
    00445     }
    00446
    00447 }
    00448
    00449 template <class SrcIterator, class SrcShape, class SrcAccessor,
    00450           class DestIterator, class DestAccessor>
    00451 inline
    00452 void multiGrayscaleErosion(
    00453     triple<SrcIterator, SrcShape, SrcAccessor> const & source,
    00454     pair<DestIterator, DestAccessor> const & dest, double sigma)
    00455 {
    00456     multiGrayscaleErosion( source.first, source.second, source.third,
    00457             dest.first, dest.second, sigma);
    00458 }
    00459
    00460 /********************************************************/
    00461 /*                                                      */
    00462 /*             multiGrayscaleDilation                   */
    00463 /*                                                      */
    00464 /********************************************************/
    00465 /** \brief Parabolic grayscale dilation on multi-dimensional arrays.
    00466
    00467     This function applies a parabolic dilation operator with a given spread (sigma) on
    00468     a grayscale array. The operation is isotropic.
    00469     The input is a grayscale multi-dimensional array.
    00470
    00471     This function may work in-place, which means that <tt>siter == diter</tt> is allowed.
    00472     A full-sized internal array is only allocated if working on the destination
    00473     array directly would cause overflow errors (i.e. if
    00474     <tt> typeid(typename DestAccessor::value_type) < N * M*M</tt>, where M is the
    00475     size of the largest dimension of the array.
    00476
    00477     <b> Declarations:</b>
    00478
    00479     pass arguments explicitly:
    00480     \code
    00481     namespace vigra {
    00482         template <class SrcIterator, class SrcShape, class SrcAccessor,
    00483                   class DestIterator, class DestAccessor>
    00484         void
    00485         multiGrayscaleDilation(SrcIterator siter, SrcShape const & shape, SrcAccessor src,
    00486                                     DestIterator diter, DestAccessor dest, double sigma);
    00487
    00488     }
    00489     \endcode
    00490
    00491     use argument objects in conjunction with \ref ArgumentObjectFactories :
    00492     \code
    00493     namespace vigra {
    00494         template <class SrcIterator, class SrcShape, class SrcAccessor,
    00495                   class DestIterator, class DestAccessor>
    00496         void
    00497         multiGrayscaleDilation(triple<SrcIterator, SrcShape, SrcAccessor> const & source,
    00498                                     pair<DestIterator, DestAccessor> const & dest,
    00499                                     double sigma);
    00500
    00501     }
    00502     \endcode
    00503
    00504     <b> Usage:</b>
    00505
    00506     <b>\#include</b> <vigra/multi_morphology.hxx>
    00507
    00508     \code
    00509     MultiArray<3, unsigned char>::size_type shape(width, height, depth);
    00510     MultiArray<3, unsigned char> source(shape);
    00511     MultiArray<3, unsigned char> dest(shape);
    00512     ...
    00513
    00514     // perform isotropic grayscale erosion
    00515     multiGrayscaleDilation(srcMultiArrayRange(source), destMultiArray(dest), 3.0);
    00516     \endcode
    00517
    00518     \see vigra::discErosion()
    00519 */
    00520 doxygen_overloaded_function(template <...> void multiGrayscaleDilation)
    00521
    00522 template <class SrcIterator, class SrcShape, class SrcAccessor,
    00523           class DestIterator, class DestAccessor>
    00524 void multiGrayscaleDilation( SrcIterator s, SrcShape const & shape, SrcAccessor src,
    00525                              DestIterator d, DestAccessor dest, double sigma)
    00526 {
    00527     typedef typename NumericTraits<typename DestAccessor::value_type>::ValueType DestType;
    00528     typedef typename NumericTraits<typename DestAccessor::value_type>::Promote TmpType;
    00529     DestType MinValue = NumericTraits<DestType>::min();
    00530     DestType MaxValue = NumericTraits<DestType>::max();
    00531     enum { N = 1 + SrcIterator::level };
    00532
    00533     // temporary array to hold the current line to enable in-place operation
    00534     ArrayVector<TmpType> tmp( shape[0] );
    00535
    00536     typedef MultiArrayNavigator<SrcIterator, N> SNavigator;
    00537     typedef MultiArrayNavigator<DestIterator, N> DNavigator;
    00538
    00539     int MaxDim = 0;
    00540     for( int i=0; i<N; i++)
    00541         if(MaxDim < shape[i]) MaxDim = shape[i];
    00542
    00543     using namespace vigra::functor;
    00544
    00545     ArrayVector<double> sigmas(shape.size(), sigma);
    00546
    00547     // Allocate a new temporary array if the distances squared wouldn't fit
    00548     if(-N*MaxDim*MaxDim < MinValue || N*MaxDim*MaxDim > MaxValue)
    00549     {
    00550         MultiArray<SrcShape::static_size, TmpType> tmpArray(shape);
    00551
    00552         detail::internalSeparableMultiArrayDistTmp( s, shape, src, tmpArray.traverser_begin(),
    00553             typename AccessorTraits<TmpType>::default_accessor(), sigmas, true );
    00554
    00555         transformMultiArray( tmpArray.traverser_begin(), shape,
    00556                 typename AccessorTraits<TmpType>::default_accessor(), d, dest,
    00557                 ifThenElse( Arg1() > Param(MaxValue), Param(MaxValue),
    00558                     ifThenElse( Arg1() < Param(MinValue), Param(MinValue), Arg1() ) ) );
    00559     }
    00560     else
    00561     {
    00562         detail::internalSeparableMultiArrayDistTmp( s, shape, src, d, dest, sigmas, true );
    00563     }
    00564
    00565 }
    00566
    00567
    00568 template <class SrcIterator, class SrcShape, class SrcAccessor,
    00569           class DestIterator, class DestAccessor>
    00570 inline
    00571 void multiGrayscaleDilation(
    00572     triple<SrcIterator, SrcShape, SrcAccessor> const & source,
    00573     pair<DestIterator, DestAccessor> const & dest, double sigma)
    00574 {
    00575     multiGrayscaleDilation( source.first, source.second, source.third,
    00576             dest.first, dest.second, sigma);
    00577 }
    00578
    00579
    00580 //@}
    00581
    00582 } //-- namespace vigra
    00583
    00584
    00585 #endif        //-- VIGRA_MULTI_MORPHOLOGY_HXX

© 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.9.0 (Tue Nov 6 2012)