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

details Basic Morphological Operations VIGRA


Functions

template<...> void discRankOrderFilter (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, DestIterator upperleft2, DestAccessor da, int radius, float rank)
 Apply rank order filter with disc structuring function to the image.

template<...> void discErosion (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, DestIterator upperleft2, DestAccessor da, int radius)
 Apply erosion (minimum) filter with disc of given radius to image.

template<...> void discDilation (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, DestIterator upperleft2, DestAccessor da, int radius)
 Apply dilation (maximum) filter with disc of given radius to image.

template<...> void discMedian (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, DestIterator upperleft2, DestAccessor da, int radius)
 Apply median filter with disc of given radius to image.

template<...> void discRankOrderFilterWithMask (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, MaskIterator upperleftm, MaskAccessor mask, DestIterator upperleft2, DestAccessor da, int radius, float rank)
 Apply rank order filter with disc structuring function to the image using a mask.

template<...> void discErosionWithMask (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, MaskIterator upperleftm, MaskAccessor mask, DestIterator upperleft2, DestAccessor da, int radius)
 Apply erosion (minimum) filter with disc of given radius to image using a mask.

template<...> void discDilationWithMask (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, MaskIterator upperleftm, MaskAccessor mask, DestIterator upperleft2, DestAccessor da, int radius)
 Apply dilation (maximum) filter with disc of given radius to image using a mask.

template<...> void discMedianWithMask (SrcIterator upperleft1, SrcIterator lowerright1, SrcAccessor sa, MaskIterator upperleftm, MaskAccessor mask, DestIterator upperleft2, DestAccessor da, int radius)
 Apply median filter with disc of given radius to image using a mask.



Detailed Description


Perform erosion, dilation, and median with disc structuring functions


Function Documentation


  void discDilation (...)
 
 

Apply dilation (maximum) filter with disc of given radius to image.

This is an abbreviation vor the rank order filter with rank = 1.0. See discRankOrderFilter() for more information.

Declarations:

pass arguments explicitely:

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class DestIterator, class DestAccessor>
        inline void 
        discDilation(SrcIterator upperleft1, 
                    SrcIterator lowerright1, SrcAccessor sa,
                    DestIterator upperleft2, DestAccessor da,
                    int radius)
    }

use argument objects in conjunction with Argument Object Factories:

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class DestIterator, class DestAccessor>
        void
        discDilation(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                    pair<DestIterator, DestAccessor> dest,
                    int radius)
    }


  void discDilationWithMask (...)
 
 

Apply dilation (maximum) filter with disc of given radius to image using a mask.

This is an abbreviation vor the masked rank order filter with rank = 1.0. See discRankOrderFilterWithMask() for more information.

Declarations:

pass arguments explicitely:

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class MaskIterator, class MaskAccessor,
                  class DestIterator, class DestAccessor>
        inline void 
        discDilationWithMask(SrcIterator upperleft1, 
                            SrcIterator lowerright1, SrcAccessor sa,
                            MaskIterator upperleftm, MaskAccessor mask,
                            DestIterator upperleft2, DestAccessor da,
                            int radius)
    }

group arguments (use in conjunction with Argument Object Factories):

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class MaskIterator, class MaskAccessor,
                  class DestIterator, class DestAccessor>
        inline void 
        discDilationWithMask(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                            pair<MaskIterator, MaskAccessor> mask,
                            pair<DestIterator, DestAccessor> dest,
                            int radius)
    }


  void discErosion (...)
 
 

Apply erosion (minimum) filter with disc of given radius to image.

This is an abbreviation vor the rank order filter with rank = 0.0. See discRankOrderFilter() for more information.

Declarations:

pass arguments explicitely:

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class DestIterator, class DestAccessor>
        inline void 
        discErosion(SrcIterator upperleft1, 
                    SrcIterator lowerright1, SrcAccessor sa,
                    DestIterator upperleft2, DestAccessor da,
                    int radius)
    }

use argument objects in conjunction with Argument Object Factories:

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class DestIterator, class DestAccessor>
        void
        discErosion(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                    pair<DestIterator, DestAccessor> dest,
                    int radius)
    }


  void discErosionWithMask (...)
 
 

Apply erosion (minimum) filter with disc of given radius to image using a mask.

This is an abbreviation vor the masked rank order filter with rank = 0.0. See discRankOrderFilterWithMask() for more information.

Declarations:

pass arguments explicitely:

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class MaskIterator, class MaskAccessor,
                  class DestIterator, class DestAccessor>
        inline void 
        discErosionWithMask(SrcIterator upperleft1, 
                            SrcIterator lowerright1, SrcAccessor sa,
                            MaskIterator upperleftm, MaskAccessor mask,
                            DestIterator upperleft2, DestAccessor da,
                            int radius)
    }

group arguments (use in conjunction with Argument Object Factories):

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class MaskIterator, class MaskAccessor,
                  class DestIterator, class DestAccessor>
        inline void 
        discErosionWithMask(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                            pair<MaskIterator, MaskAccessor> mask,
                            pair<DestIterator, DestAccessor> dest,
                            int radius)
    }


  void discMedian (...)
 
 

Apply median filter with disc of given radius to image.

This is an abbreviation vor the rank order filter with rank = 0.5. See discRankOrderFilter() for more information.

Declarations:

pass arguments explicitely:

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class DestIterator, class DestAccessor>
        inline void 
        discMedian(SrcIterator upperleft1, 
                    SrcIterator lowerright1, SrcAccessor sa,
                    DestIterator upperleft2, DestAccessor da,
                    int radius)
    }

use argument objects in conjunction with Argument Object Factories:

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class DestIterator, class DestAccessor>
        void
        discMedian(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                    pair<DestIterator, DestAccessor> dest,
                    int radius)
    }


  void discMedianWithMask (...)
 
 

Apply median filter with disc of given radius to image using a mask.

This is an abbreviation vor the masked rank order filter with rank = 0.5. See discRankOrderFilterWithMask() for more information.

Declarations:

pass arguments explicitely:

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class MaskIterator, class MaskAccessor,
                  class DestIterator, class DestAccessor>
        inline void 
        discMedianWithMask(SrcIterator upperleft1, 
                            SrcIterator lowerright1, SrcAccessor sa,
                            MaskIterator upperleftm, MaskAccessor mask,
                            DestIterator upperleft2, DestAccessor da,
                            int radius)
    }

group arguments (use in conjunction with Argument Object Factories):

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class MaskIterator, class MaskAccessor,
                  class DestIterator, class DestAccessor>
        inline void 
        discMedianWithMask(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                            pair<MaskIterator, MaskAccessor> mask,
                            pair<DestIterator, DestAccessor> dest,
                            int radius)
    }


  void discRankOrderFilter (...)
 
 

Apply rank order filter with disc structuring function to the image.

The pixel values of the source image must be in the range 0...255. Radius must be >= 0. Rank must be in the range 0.0 <= rank <= 1.0. The filter acts as a minimum filter if rank = 0.0, as a median if rank = 0.5, and as a maximum filter if rank = 1.0. Accessor are used to access the pixel data.

Declarations:

pass arguments explicitely:

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class DestIterator, class DestAccessor>
        void
        discRankOrderFilter(SrcIterator upperleft1, 
                            SrcIterator lowerright1, SrcAccessor sa,
                            DestIterator upperleft2, DestAccessor da,
                            int radius, float rank)
    }

use argument objects in conjunction with Argument Object Factories:

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class DestIterator, class DestAccessor>
        void
        discRankOrderFilter(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                            pair<DestIterator, DestAccessor> dest,
                            int radius, float rank)
    }

Usage:

#include "vigra/flatmorphology.hxx"
Namespace: vigra

    vigra::CImage src, dest;
    
    // do median filtering
    vigra::discRankOrderFilter(srcImageRange(src), destImage(dest), 10, 0.5);

Required Interface:

    SrcIterator src_upperleft;
    DestIterator dest_upperleft;
    int x, y;
    unsigned char value;
    
    SrcAccessor src_accessor;
    DestAccessor dest_accessor;
    
    // value_type of accessor must be convertible to unsigned char
    value = src_accessor(src_upperleft, x, y); 
    
    dest_accessor.set(value, dest_upperleft, x, y);

Preconditions:

    for all source pixels: 0 <= value <= 255
    
    (rank >= 0.0) && (rank <= 1.0)
    radius >= 0


  void discRankOrderFilterWithMask (...)
 
 

Apply rank order filter with disc structuring function to the image using a mask.

The pixel values of the source image must be in the range 0...255. Radius must be >= 0. Rank must be in the range 0.0 <= rank <= 1.0. The filter acts as a minimum filter if rank = 0.0, as a median if rank = 0.5, and as a maximum filter if rank = 1.0. Accessor are used to access the pixel data.

The mask is only applied to th input image, i.e. the function generates an output wherever the current disc contains at least one pixel with mask value 'true'. Source pixels with mask value 'false' are ignored during the calculation of the rank order.

Declarations:

pass arguments explicitely:

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class MaskIterator, class MaskAccessor,
                  class DestIterator, class DestAccessor>
        void
        discRankOrderFilterWithMask(SrcIterator upperleft1, 
                                    SrcIterator lowerright1, SrcAccessor sa,
                                    MaskIterator upperleftm, MaskAccessor mask,
                                    DestIterator upperleft2, DestAccessor da,
                                    int radius, float rank)
    }

group arguments (use in conjunction with Argument Object Factories):

    namespace vigra {
        template <class SrcIterator, class SrcAccessor,
                  class MaskIterator, class MaskAccessor,
                  class DestIterator, class DestAccessor>
        void
        discRankOrderFilterWithMask(triple<SrcIterator, SrcIterator, SrcAccessor> src,
                                    pair<MaskIterator, MaskAccessor> mask,
                                    pair<DestIterator, DestAccessor> dest,
                                    int radius, float rank)
    }

Usage:

#include "vigra/flatmorphology.hxx"
Namespace: vigra

    vigra::CImage src, dest, mask;
    
    // do median filtering
    vigra::discRankOrderFilterWithMask(srcImageRange(src), 
                                maskImage(mask), destImage(dest), 10, 0.5);

Required Interface:

    SrcIterator src_upperleft;
    DestIterator dest_upperleft;
    MaskIterator mask_upperleft;
    int x, y;
    unsigned char value;
    
    SrcAccessor src_accessor;
    DestAccessor dest_accessor;
    MaskAccessor mask_accessor;
                     
    mask_accessor(mask_upperleft, x, y) // convertible to bool
    
    // value_type of accessor must be convertible to unsigned char
    value = src_accessor(src_upperleft, x, y); 
    
    dest_accessor.set(value, dest_upperleft, x, y);

Preconditions:

    for all source pixels: 0 <= value <= 255
    
    (rank >= 0.0) && (rank <= 1.0)
    radius >= 0

© Ullrich Köthe (koethe@informatik.uni-hamburg.de)
Cognitive Systems Group, University of Hamburg, Germany

html generated using doxygen and Python
VIGRA 1.5.0 (7 Dec 2006)