Kernels::ComputeBounds< in_t > Class Template Reference

Static Public Member Functions
static void	process (AbstractBitmap &bitmap, std::vector< IntegerContour2D * > &boundary, std::vector< IntPoint > &border, BinaryMaskWriter &testedPixels, float level)

Detailed Description

template<class in_t>
class Kernels::ComputeBounds< in_t >

Definition at line 27 of file contours.cpp.

Member Function Documentation

process()

template<class in_t >

static void Kernels::ComputeBounds< in_t >::process ( AbstractBitmap &  bitmap, std::vector< IntegerContour2D * > &  boundary, std::vector< IntPoint > &  border, BinaryMaskWriter &  testedPixels, float  level  )

inlinestatic

Definition at line 29 of file contours.cpp.

                                                                                                                                                                      {
            in_t in(bitmap);
 
            typedef struct {
                int x, y;
            } Displacement;
 
            // clockwise direction lookup in function of four neighbour values
            const Displacement LOOKUP_DIRECTION[2][2][2][2] = {
                                //rb          //lb       //rb+lb            //rt       //rt+rb        //rt+lb   //rt+lb+rb
                { { { { 0, 0 }, { 1, 0 } }, { { 0, +1 }, { +1, 0 } } }, { { { 0, -1 }, { 0, -1 } }, { { 9, 9 }, { 0, -1 } } } },
                        //lt       //lt+rb       //lt+lb   //lt+lb+rb         //lt+rt    //lt+rt+rb     //lt+rt+lb
                { { { { -1, 0 }, { 9, 9 } }, { { 0, 1 }, { +1, 0 } } }, { { { -1, 0 }, { -1, 0 } }, { { 0, 1 }, { 0, 0 } } } }
            };
 
            const Displacement LOOKUP_INTERNAL_PIXEL[3][3] = {
                { { 0, 0 }, { 0, -1 }, { 0, 0 } },
                { { -1, -1 }, { 9, 0 }, { 0, 0 } },
                { { 0, 0 }, { -1, 0 }, { 0, 0 } }
            };
 
            const int W = in.getWidth(), H = in.getHeight();
            const float LEVEL = level * in.MAX_VALUE;
            IntPoint seed;
            int x, y;
 
            // scanning boundary pixels
            for (auto seed : border) {
 
                // picking a seed
                x = seed.x;
                y = seed.y;
                testedPixels.goTo(x, y);
                if (testedPixels.getValue() > 0)
                    continue;
                testedPixels.putValue(1);
 
                // a good seed has one neighboring point inside
                int ctr = 0;
                if (x < W && y < H && in().mean() > LEVEL) ++ctr;
                if (x > 0 && y < H && in(x - 1, y).mean() > LEVEL) ++ctr;
                if (x < W && y > 0 && in(x, y - 1).mean() > LEVEL) ++ctr;
                if (x > 0 && y > 0 && in(x - 1, y - 1).mean() > LEVEL) ++ctr;
                if (ctr != 1)
                    continue;
 
                // good seed found: go
                in.goTo(x, y);
                Displacement prev = { 0, 0 };
                IntegerContour2D* contour = new IntegerContour2D();
                boundary.push_back(contour);
 
                // go
                do {
                    // binarize the neighbours
                    bool
                        rb = x < W && y < H && in().mean() > LEVEL,
                        lb = x > 0 && y < H && in(x - 1, y).mean() > LEVEL,
                        rt = x < W && y > 0 && in(x, y - 1).mean() > LEVEL,
                        lt = x > 0 && y > 0 && in(x - 1, y - 1).mean() > LEVEL;
 
                    // check the point: must have a neighbor inside and a neighbor outside
                    if ((rb && lb && rt && lt) || !(rb || lb || rt || lt))
                        throw IntegerContour2D::BadSeedPoint(x, y, lt, rt, lb, rb);
 
                    // add the point
                    contour->addPoint(x, y);
 
                    // compute step direction
                    Displacement d = LOOKUP_DIRECTION[lt][rt][lb][rb];
                    if (d.x == 9) {     // special case: displacement depends on the previous direction
                        if (prev.x == 0 && prev.y == 0)
                            throw IntegerContour2D::BadSeedPoint(x, y, lt, rt, lb, rb);
                        d.x = -prev.y;
                        d.y = prev.x;
                    }
 
                    // marking used pixel
                    Displacement ip = LOOKUP_INTERNAL_PIXEL[d.y + 1][d.x + 1];
                    int ipx = x + ip.x, ipy = y + ip.y;
                    if (ipx >= 0 && ipy >= 0 && ipx < W && ipy < H) {
                        testedPixels.goTo(ipx, ipy);
                        testedPixels.putValue(1);
                    }
 
                    // step
                    x += d.x;
                    y += d.y;
                    prev = d;
 
                    if (x < W && y < H)
                        in.goTo(x, y);
 
                } while (seed.x != x || seed.y != y);
 
                // adding the last point
                contour->addPoint(x, y);
            }
        }

---

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

• core/contours/contours.cpp