Kernels::CircularErosion< out_t > Class Template Reference

Circular erosion kernel for flood fill contours postprocessing. More...

#include <region_filling.h>

Static Public Member Functions
static void	process (AbstractBitmap &bitmap, std::vector< IntPoint > &pointSet, int val, float holdRad, float releaseRad)
	Circular erosion of a mask at given points. More...

Detailed Description

template<typename out_t>
class Kernels::CircularErosion< out_t >

Circular erosion kernel for flood fill contours postprocessing.

Definition at line 192 of file region_filling.h.

Member Function Documentation

process()

template<typename out_t >

static void Kernels::CircularErosion< out_t >::process ( AbstractBitmap &  bitmap, std::vector< IntPoint > &  pointSet, int  val, float  holdRad, float  releaseRad  )

inlinestatic

Circular erosion of a mask at given points.

Parameters

bitmap	The mask bitmap
pointSet	The points
val	Max value (amplitude)
holdRad	Inner kernel radius; all pixels inside take val value
releaseRad	Release ring outer radius; all pixels in the ring take linearly attenuated val value

Definition at line 202 of file region_filling.h.

                                                                                                                             {
            out_t mask(bitmap);
            const int morphoSize = (int)ceilf(holdRad + releaseRad);
            const float morphoReleaseRing = releaseRad - holdRad;
            // for each point in the point set...
            for (auto p : pointSet) {
                // determine a bounding box to apply the kernel
                int
                    x1 = std::max(0, p.x - morphoSize),
                    y1 = std::max(0, p.y - morphoSize),
                    x2 = std::min(mask.getWidth() - 1, p.x + morphoSize),
                    y2 = std::min(mask.getHeight() - 1, p.y + morphoSize);
                // apply the kernel
                for (int y = y1; y <= y2; ++y) {
                    mask.goTo(x1, y);
                    for (int x = x1; x <= x2; ++x, mask++) {
                        // squared distance to center
                        int d2 = sqr(x - p.x) + sqr(y - p.y);
                        if (d2 < sqr(holdRad))
                            mask.assign(0);
                        else if (d2 < sqr(releaseRad)) {
                            // linear attenuation
                            int c = (int)roundf((float)val * (sqrtf((float)d2) - holdRad) / morphoReleaseRing);
                            if (mask().x > c)
                                mask.assign(c);
                        }
                    }
                }
            }
        }

---

The documentation for this class was generated from the following file:

• core/masking/region_filling.h