Region filling kernel implementing flood fill starting from a given seed. More...

#include <region_filling.h>

Public Types
typedef in_t::pixtype::operating_type	inpixvaltype

Static Public Member Functions
static void	process (AbstractBitmap &input, AbstractBitmap &output, IntPoint maskOffset, IntPoint seed, inpixvaltype tolerance, std::vector< IntPoint > &border, IntRectangle &bounds)
	Fills a region in an output bitmap starting from a given position in an input bitmap. More...

Detailed Description

template<typename in_t, typename out_t>
class Kernels::FillRegion< in_t, out_t >

Region filling kernel implementing flood fill starting from a given seed.

Definition at line 31 of file region_filling.h.

Member Typedef Documentation

◆ inpixvaltype

template<typename in_t , typename out_t >

typedef in_t::pixtype::operating_type Kernels::FillRegion< in_t, out_t >::inpixvaltype

Definition at line 33 of file region_filling.h.

Member Function Documentation

◆ process()

template<typename in_t , typename out_t >

static void Kernels::FillRegion< in_t, out_t >::process	(	AbstractBitmap &	input,
		AbstractBitmap &	output,
		IntPoint	maskOffset,
		IntPoint	seed,
		inpixvaltype	tolerance,
		std::vector< IntPoint > &	border,
		IntRectangle &	bounds
	)

inlinestatic

Fills a region in an output bitmap starting from a given position in an input bitmap.

Parameters

input	Input bitmap reader
output	Output mask writer
maskOffset	Mask position in the bitmap
seed	Entry point
tolerance	Tolerance level: how much a pixel has to be different from seed to not to be filled
border	A vector to put border points to for further processing
bounds	Bounding box of the filled region; the input value is updated but not reset

Definition at line 44 of file region_filling.h.

           {
             in_t in(input);
             out_t out(output);
  
             const int
                 W = in.getWidth() - 1, H = in.getHeight() - 1,
                 MW = out.getWidth() - 1, MH = out.getHeight() - 1;
  
             std::queue<IntPoint> queue;
             queue.push(IntPoint(seed.x, seed.y));
             in.goTo(seed.x, seed.y);
  
             const typename in_t::pixtype ref = in();    // reference input value
             const int range = out.MAX_UNNORM_VALUE;
  
             inpixvaltype diff;
             unsigned char newval, oldval;
  
             // performance critical cycle
             while (!queue.empty()) {
                 // popping from queue front
                 IntPoint p = queue.front();
                 queue.pop();
                 int
                     mx = p.x - maskOffset.x,
                     my = p.y - maskOffset.y;
  
                 // checking neighbor pixels
                 bool onBorder = false;
  
                 if (p.x > 0 && mx > 0 && (diff = (in(p.x - 1, p.y) - ref).abs().max()) <= tolerance) {
                     newval = (tolerance > 0 && diff > 0) ? (range * (tolerance - diff) / tolerance + 1) : out.MAX_UNNORM_VALUE;
                     out.goTo(mx - 1, my);
                     oldval = out.getValue();
                     if (oldval < newval) {
                         out.putValue(newval);
                         queue.push(IntPoint(p.x - 1, p.y));
                     }
                 }
                 else onBorder = true;
  
                 if (p.y > 0 && my > 0 && (diff = (in(p.x, p.y - 1) - ref).abs().max()) <= tolerance) {
                     newval = (tolerance > 0 && diff > 0) ? (range * (tolerance - diff) / tolerance + 1) : out.MAX_UNNORM_VALUE;
                     out.goTo(mx, my - 1);
                     oldval = out.getValue();
                     if (oldval < newval) {
                         out.putValue(newval);
                         queue.push(IntPoint(p.x, p.y - 1));
                     }
                 }
                 else onBorder = true;
  
                 if (p.x < W && mx < MW && (diff = (in(p.x + 1, p.y) - ref).abs().max()) <= tolerance) {
                     newval = (tolerance > 0 && diff > 0) ? (range * (tolerance - diff) / tolerance + 1) : out.MAX_UNNORM_VALUE;
                     out.goTo(mx + 1, my);
                     oldval = out.getValue();
                     if (oldval < newval) {
                         out.putValue(newval);
                         queue.push(IntPoint(p.x + 1, p.y));
                     }
                 }
                 else onBorder = true;
  
                 if (p.y < H && my < MH && (diff = (in(p.x, p.y + 1) - ref).abs().max()) <= tolerance) {
                     newval = (tolerance > 0 && diff > 0) ? (range * (tolerance - diff) / tolerance + 1) : out.MAX_UNNORM_VALUE;
                     out.goTo(mx, my + 1);
                     oldval = out.getValue();
                     if (oldval < newval) {
                         out.putValue(newval);
                         queue.push(IntPoint(p.x, p.y + 1));
                     }
                 }
                 else onBorder = true;
  
                 if (onBorder) {
                     border.push_back(IntPoint(mx, my));
  
                     if (mx < bounds.a.x)
                         bounds.a.x = mx;
                     if (mx > bounds.b.x)
                         bounds.b.x = mx;
                     if (my < bounds.a.y)
                         bounds.a.y = my;
                     if (my > bounds.b.y)
                         bounds.b.y = my;
                 }
             }
         }

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

core/masking/region_filling.h

Public Types