NoOp(){

}

inline

void init(int /*labels*/){

}

inline

void initElement(const int /*nlabels*/){

}

inline

void operator()(int r, int c, int l){

(void)r;

(void)c;

(void)l;

}

void finish(){

}

inline

void setNextLoc(const int /*nextLoc*/){

}

inline static

void mergeStats(const cv::Mat& /*imgLabels*/, NoOp * /*sopArray*/, NoOp& /*sop*/, const int& /*nLabels*/){

}

const _OutputArray *_mstatsv;

cv::Mat statsv;

const _OutputArray *_mcentroidsv;

cv::Mat centroidsv;

std::vector<Point2ui64> integrals;

int _nextLoc;

CCStatsOp() : _mstatsv(0), _mcentroidsv(0), _nextLoc(0) {}

CCStatsOp(OutputArray _statsv, OutputArray _centroidsv) : _mstatsv(&_statsv), _mcentroidsv(&_centroidsv), _nextLoc(0){}

inline

void init(int nlabels){

_mstatsv->create(cv::Size(CC_STAT_MAX, nlabels), cv::DataType<int>::type);

statsv = _mstatsv->getMat();

_mcentroidsv->create(cv::Size(2, nlabels), cv::DataType<double>::type);

centroidsv = _mcentroidsv->getMat();

for (int l = 0; l < (int)nlabels; ++l){

int *row = (int *)&statsv.at<int>(l, 0);

row[CC_STAT_LEFT] = INT_MAX;

row[CC_STAT_TOP] = INT_MAX;

row[CC_STAT_WIDTH] = INT_MIN;

row[CC_STAT_HEIGHT] = INT_MIN;

row[CC_STAT_AREA] = 0;

}

integrals.resize(nlabels, Point2ui64(0, 0));

}

inline

void initElement(const int nlabels){

statsv = cv::Mat(nlabels, CC_STAT_MAX, cv::DataType<int>::type);

for (int l = 0; l < (int)nlabels; ++l){

int *row = (int *)statsv.ptr(l);

row[CC_STAT_LEFT] = INT_MAX;

row[CC_STAT_TOP] = INT_MAX;

row[CC_STAT_WIDTH] = INT_MIN;

row[CC_STAT_HEIGHT] = INT_MIN;

row[CC_STAT_AREA] = 0;

}

integrals.resize(nlabels, Point2ui64(0, 0));

}

void operator()(int r, int c, int l){

int *row =& statsv.at<int>(l, 0);

row[CC_STAT_LEFT] = MIN(row[CC_STAT_LEFT], c);

row[CC_STAT_WIDTH] = MAX(row[CC_STAT_WIDTH], c);

row[CC_STAT_TOP] = MIN(row[CC_STAT_TOP], r);

row[CC_STAT_HEIGHT] = MAX(row[CC_STAT_HEIGHT], r);

row[CC_STAT_AREA]++;

Point2ui64& integral = integrals[l];

integral.x += c;

integral.y += r;

}

void finish(){

for (int l = 0; l < statsv.rows; ++l){

int *row =& statsv.at<int>(l, 0);

row[CC_STAT_WIDTH] = row[CC_STAT_WIDTH] - row[CC_STAT_LEFT] + 1;

row[CC_STAT_HEIGHT] = row[CC_STAT_HEIGHT] - row[CC_STAT_TOP] + 1;

Point2ui64& integral = integrals[l];

double *centroid = &centroidsv.at<double>(l, 0);

double area = ((unsigned*)row)[CC_STAT_AREA];

centroid[0] = double(integral.x) / area;

centroid[1] = double(integral.y) / area;

}

}

inline

void setNextLoc(const int nextLoc){

_nextLoc = nextLoc;

}

inline static

void mergeStats(const cv::Mat& imgLabels, CCStatsOp *sopArray, CCStatsOp& sop, const int& nLabels){

const int h = imgLabels.rows;

if (sop._nextLoc != h){

for (int nextLoc = sop._nextLoc; nextLoc < h; nextLoc = sopArray[nextLoc]._nextLoc){

//merge between sopNext and sop

for (int l = 0; l < nLabels; ++l){

int *rowNext = (int*)sopArray[nextLoc].statsv.ptr(l);

if (rowNext[CC_STAT_AREA] > 0){ //if changed merge all the stats

int *rowMerged = (int*)sop.statsv.ptr(l);

rowMerged[CC_STAT_LEFT] = MIN(rowMerged[CC_STAT_LEFT], rowNext[CC_STAT_LEFT]);

rowMerged[CC_STAT_WIDTH] = MAX(rowMerged[CC_STAT_WIDTH], rowNext[CC_STAT_WIDTH]);

rowMerged[CC_STAT_TOP] = MIN(rowMerged[CC_STAT_TOP], rowNext[CC_STAT_TOP]);

rowMerged[CC_STAT_HEIGHT] = MAX(rowMerged[CC_STAT_HEIGHT], rowNext[CC_STAT_HEIGHT]);

rowMerged[CC_STAT_AREA] += rowNext[CC_STAT_AREA];

sop.integrals[l].x += sopArray[nextLoc].integrals[l].x;

sop.integrals[l].y += sopArray[nextLoc].integrals[l].y;

}

}

}

}

}

LabelT root = i;

while (P[root] < root){

root = P[root];

}

return root;

while (P[i] < i){

LabelT j = P[i];

P[i] = root;

i = j;

}

P[i] = root;

LabelT root = findRoot(P, i);

setRoot(P, i, root);

return root;

LabelT root = findRoot(P, i);

if (i != j){

LabelT rootj = findRoot(P, j);

if (root > rootj){

root = rootj;

}

setRoot(P, j, root);

}

setRoot(P, i, root);

return root;

LabelT k = 1;

for (LabelT i = 1; i < length; ++i){

if (P[i] < i){

P[i] = P[P[i]];

}

else{

P[i] = k; k = k + 1;

}

}

return k;

for (int i = start; i < start + nElem; ++i){

if (P[i] < i){//node that point to root

P[i] = P[P[i]];

}

else{ //for root node

P[i] = k;

k = k + 1;

}

}

class FirstScan8Connectivity : public cv::ParallelLoopBody{

const cv::Mat& img_;

cv::Mat& imgLabels_;

LabelT *P_;

int *chunksSizeAndLabels_;

public:

FirstScan8Connectivity(const cv::Mat& img, cv::Mat& imgLabels, LabelT *P, int *chunksSizeAndLabels)

: img_(img), imgLabels_(imgLabels), P_(P), chunksSizeAndLabels_(chunksSizeAndLabels){}

FirstScan8Connectivity& operator=(const FirstScan8Connectivity& ) { return *this; }

void operator()(const cv::Range& range) const CV_OVERRIDE

{

int r = range.start;

chunksSizeAndLabels_[r] = range.end;

LabelT label = LabelT((r + 1) / 2) * LabelT((imgLabels_.cols + 1) / 2) + 1;

const LabelT firstLabel = label;

const int w = img_.cols;

const int limitLine = r, startR = r;

// Rosenfeld Mask

// +-+-+-+

// |p|q|r|

// +-+-+-+

// |s|x|

// +-+-+

for (; r != range.end; ++r)

{

PixelT const * const img_row = img_.ptr<PixelT>(r);

PixelT const * const img_row_prev = (PixelT *)(((char *)img_row) - img_.step.p[0]);

LabelT * const imgLabels_row = imgLabels_.ptr<LabelT>(r);

LabelT * const imgLabels_row_prev = (LabelT *)(((char *)imgLabels_row) - imgLabels_.step.p[0]);

for (int c = 0; c < w; ++c) {

#define condition_p c > 0 && r > limitLine && img_row_prev[c - 1] > 0

#define condition_q r > limitLine && img_row_prev[c] > 0

#define condition_r c < w - 1 && r > limitLine && img_row_prev[c + 1] > 0

#define condition_s c > 0 && img_row[c - 1] > 0

#define condition_x img_row[c] > 0

if (condition_x){

if (condition_q){

//copy q

imgLabels_row[c] = imgLabels_row_prev[c];

}

else{

//not q

if (condition_r){

if (condition_p){

//concavity p->x->r. Merge

imgLabels_row[c] = set_union(P_, imgLabels_row_prev[c - 1], imgLabels_row_prev[c + 1]);

}

else{ //not p and q

if (condition_s){

//step s->x->r. Merge

imgLabels_row[c] = set_union(P_, imgLabels_row[c - 1], imgLabels_row_prev[c + 1]);

}

else{ //not p, q and s

//copy r

imgLabels_row[c] = imgLabels_row_prev[c + 1];

}

}

}

else{

//not r and q

if (condition_p){

//copy p

imgLabels_row[c] = imgLabels_row_prev[c - 1];

}

else{//not r,q and p

if (condition_s){

imgLabels_row[c] = imgLabels_row[c - 1];

}

else{

//new label

imgLabels_row[c] = label;

P_[label] = label;

label = label + 1;

}

}

}

}

}

else{

//x is a background pixel

imgLabels_row[c] = 0;

}

}

}

//write in the follower memory location

chunksSizeAndLabels_[startR + 1] = label - firstLabel;

}

#undef condition_p

#undef condition_q

#undef condition_r

#undef condition_s

#undef condition_x

};

class FirstScan4Connectivity : public cv::ParallelLoopBody{

const cv::Mat& img_;

cv::Mat& imgLabels_;

LabelT *P_;

int *chunksSizeAndLabels_;

public:

FirstScan4Connectivity(const cv::Mat& img, cv::Mat& imgLabels, LabelT *P, int *chunksSizeAndLabels)

: img_(img), imgLabels_(imgLabels), P_(P), chunksSizeAndLabels_(chunksSizeAndLabels){}

FirstScan4Connectivity& operator=(const FirstScan4Connectivity& ) { return *this; }

void operator()(const cv::Range& range) const CV_OVERRIDE

{

int r = range.start;

chunksSizeAndLabels_[r] = range.end;

LabelT label = LabelT((r * imgLabels_.cols + 1) / 2 + 1);

const LabelT firstLabel = label;

const int w = img_.cols;

const int limitLine = r, startR = r;

// Rosenfeld Mask

// +-+-+-+

// |-|q|-|

// +-+-+-+

// |s|x|

// +-+-+

for (; r != range.end; ++r){

PixelT const * const img_row = img_.ptr<PixelT>(r);

PixelT const * const img_row_prev = (PixelT *)(((char *)img_row) - img_.step.p[0]);

LabelT * const imgLabels_row = imgLabels_.ptr<LabelT>(r);

LabelT * const imgLabels_row_prev = (LabelT *)(((char *)imgLabels_row) - imgLabels_.step.p[0]);

for (int c = 0; c < w; ++c) {

#define condition_q r > limitLine && img_row_prev[c] > 0

#define condition_s c > 0 && img_row[c - 1] > 0

#define condition_x img_row[c] > 0

if (condition_x){

if (condition_q){

if (condition_s){

//step s->x->q. Merge

imgLabels_row[c] = set_union(P_, imgLabels_row[c - 1], imgLabels_row_prev[c]);

}

else{

//copy q

imgLabels_row[c] = imgLabels_row_prev[c];

}

}

else{

if (condition_s){ // copy s

imgLabels_row[c] = imgLabels_row[c - 1];

}

else{

//new label

imgLabels_row[c] = label;

P_[label] = label;

label = label + 1;

}

}

}

else{

//x is a background pixel

imgLabels_row[c] = 0;

}

}

}

//write in the following memory location

chunksSizeAndLabels_[startR + 1] = label - firstLabel;

}

#undef condition_q

#undef condition_s

#undef condition_x

};

class SecondScan : public cv::ParallelLoopBody{

cv::Mat& imgLabels_;

const LabelT *P_;

StatsOp& sop_;

StatsOp *sopArray_;

LabelT& nLabels_;

public:

SecondScan(cv::Mat& imgLabels, const LabelT *P, StatsOp& sop, StatsOp *sopArray, LabelT& nLabels)

: imgLabels_(imgLabels), P_(P), sop_(sop), sopArray_(sopArray), nLabels_(nLabels){}

SecondScan& operator=(const SecondScan& ) { return *this; }

void operator()(const cv::Range& range) const CV_OVERRIDE

{

int r = range.start;

const int rowBegin = r;

const int rowEnd = range.end;

if (rowBegin > 0){

sopArray_[rowBegin].initElement(nLabels_);

sopArray_[rowBegin].setNextLoc(rowEnd); //_nextLoc = rowEnd;

for (; r < rowEnd; ++r) {

LabelT * img_row_start = imgLabels_.ptr<LabelT>(r);

LabelT * const img_row_end = img_row_start + imgLabels_.cols;

for (int c = 0; img_row_start != img_row_end; ++img_row_start, ++c){

*img_row_start = P_[*img_row_start];

sopArray_[rowBegin](r, c, *img_row_start);

}

}

}

else{

//the first thread uses sop in order to make less merges

sop_.setNextLoc(rowEnd);

for (; r < rowEnd; ++r) {

LabelT * img_row_start = imgLabels_.ptr<LabelT>(r);

LabelT * const img_row_end = img_row_start + imgLabels_.cols;

for (int c = 0; img_row_start != img_row_end; ++img_row_start, ++c){

*img_row_start = P_[*img_row_start];

sop_(r, c, *img_row_start);

}

}

}

}

};

inline static

void mergeLabels8Connectivity(cv::Mat& imgLabels, LabelT *P, const int *chunksSizeAndLabels){

// Merge Mask

// +-+-+-+

// |p|q|r|

// +-+-+-+

// |x|

// +-+

const int w = imgLabels.cols, h = imgLabels.rows;

for (int r = chunksSizeAndLabels[0]; r < h; r = chunksSizeAndLabels[r]){

LabelT * const imgLabels_row = imgLabels.ptr<LabelT>(r);

LabelT * const imgLabels_row_prev = (LabelT *)(((char *)imgLabels_row) - imgLabels.step.p[0]);

for (int c = 0; c < w; ++c){

#define condition_p c > 0 && imgLabels_row_prev[c - 1] > 0

#define condition_q imgLabels_row_prev[c] > 0

#define condition_r c < w - 1 && imgLabels_row_prev[c + 1] > 0

#define condition_x imgLabels_row[c] > 0

if (condition_x){

if (condition_p){

//merge of two label

imgLabels_row[c] = set_union(P, imgLabels_row_prev[c - 1], imgLabels_row[c]);

}

if (condition_r){

//merge of two label

imgLabels_row[c] = set_union(P, imgLabels_row_prev[c + 1], imgLabels_row[c]);

}

if (condition_q){

//merge of two label

imgLabels_row[c] = set_union(P, imgLabels_row_prev[c], imgLabels_row[c]);

}

}

}

}

#undef condition_p

#undef condition_q

#undef condition_r

#undef condition_x

}

inline static

void mergeLabels4Connectivity(cv::Mat& imgLabels, LabelT *P, const int *chunksSizeAndLabels){

// Merge Mask

// +-+-+-+

// |-|q|-|

// +-+-+-+

// |x|

// +-+

const int w = imgLabels.cols, h = imgLabels.rows;

for (int r = chunksSizeAndLabels[0]; r < h; r = chunksSizeAndLabels[r]){

LabelT * const imgLabels_row = imgLabels.ptr<LabelT>(r);

LabelT * const imgLabels_row_prev = (LabelT *)(((char *)imgLabels_row) - imgLabels.step.p[0]);

for (int c = 0; c < w; ++c){

#define condition_q imgLabels_row_prev[c] > 0

#define condition_x imgLabels_row[c] > 0

if (condition_x){

if (condition_q){

//merge of two label

imgLabels_row[c] = set_union(P, imgLabels_row_prev[c], imgLabels_row[c]);

}

}

}

}

#undef condition_q

#undef condition_x

}

LabelT operator()(const cv::Mat& img, cv::Mat& imgLabels, int connectivity, StatsOp& sop){

CV_Assert(img.rows == imgLabels.rows);

CV_Assert(img.cols == imgLabels.cols);

CV_Assert(connectivity == 8 || connectivity == 4);

const int h = img.rows;

const int w = img.cols;

//A quick and dirty upper bound for the maximum number of labels.

//Following formula comes from the fact that a 2x2 block in 4-way connectivity

//labeling can never have more than 2 new labels and 1 label for background.

//Worst case image example pattern:

//1 0 1 0 1...

//0 1 0 1 0...

//1 0 1 0 1...

//............

//Obviously, 4-way connectivity upper bound is also good for 8-way connectivity labeling

const size_t Plength = (size_t(h) * size_t(w) + 1) / 2 + 1;

//Array used to store info and labeled pixel by each thread.

//Different threads affect different memory location of chunksSizeAndLabels

int *chunksSizeAndLabels = (int *)cv::fastMalloc(h * sizeof(int));

//Tree of labels

LabelT *P = (LabelT *)cv::fastMalloc(Plength * sizeof(LabelT));

//First label is for background

P[0] = 0;

cv::Range range(0, h);

const double nParallelStripes = std::max(1, std::min(h / 2, getNumThreads()*4));

LabelT nLabels = 1;

if (connectivity == 8){

//First scan

cv::parallel_for_(range, FirstScan8Connectivity(img, imgLabels, P, chunksSizeAndLabels), nParallelStripes);

//merge labels of different chunks

mergeLabels8Connectivity(imgLabels, P, chunksSizeAndLabels);

for (int i = 0; i < h; i = chunksSizeAndLabels[i]){

flattenL(P, int((i + 1) / 2) * int((w + 1) / 2) + 1, chunksSizeAndLabels[i + 1], nLabels);

}

}

else{

//First scan

cv::parallel_for_(range, FirstScan4Connectivity(img, imgLabels, P, chunksSizeAndLabels), nParallelStripes);

//merge labels of different chunks

mergeLabels4Connectivity(imgLabels, P, chunksSizeAndLabels);

for (int i = 0; i < h; i = chunksSizeAndLabels[i]){

flattenL(P, int(i * w + 1) / 2 + 1, chunksSizeAndLabels[i + 1], nLabels);

}

}

//Array for statistics dataof threads

StatsOp *sopArray = new StatsOp[h];

sop.init(nLabels);

//Second scan

cv::parallel_for_(range, SecondScan(imgLabels, P, sop, sopArray, nLabels), nParallelStripes);

StatsOp::mergeStats(imgLabels, sopArray, sop, nLabels);

sop.finish();

delete[] sopArray;

cv::fastFree(chunksSizeAndLabels);

cv::fastFree(P);

return nLabels;

}

LabelT operator()(const cv::Mat& img, cv::Mat& imgLabels, int connectivity, StatsOp& sop){

CV_Assert(imgLabels.rows == img.rows);

CV_Assert(imgLabels.cols == img.cols);

CV_Assert(connectivity == 8 || connectivity == 4);

const int h = img.rows;

const int w = img.cols;

//A quick and dirty upper bound for the maximum number of labels.

//Following formula comes from the fact that a 2x2 block in 4-way connectivity

//labeling can never have more than 2 new labels and 1 label for background.

//Worst case image example pattern:

//1 0 1 0 1...

//0 1 0 1 0...

//1 0 1 0 1...

//............

//Obviously, 4-way connectivity upper bound is also good for 8-way connectivity labeling

const size_t Plength = (size_t(h) * size_t(w) + 1) / 2 + 1;

//array P for equivalences resolution

LabelT *P = (LabelT *)fastMalloc(sizeof(LabelT) *Plength);

//first label is for background pixels

P[0] = 0;

LabelT lunique = 1;

if (connectivity == 8){

for (int r = 0; r < h; ++r){

// Get row pointers

PixelT const * const img_row = img.ptr<PixelT>(r);

PixelT const * const img_row_prev = (PixelT *)(((char *)img_row) - img.step.p[0]);

LabelT * const imgLabels_row = imgLabels.ptr<LabelT>(r);

LabelT * const imgLabels_row_prev = (LabelT *)(((char *)imgLabels_row) - imgLabels.step.p[0]);

for (int c = 0; c < w; ++c){

#define condition_p c>0 && r>0 && img_row_prev[c - 1]>0

#define condition_q r>0 && img_row_prev[c]>0

#define condition_r c < w - 1 && r > 0 && img_row_prev[c + 1] > 0

#define condition_s c > 0 && img_row[c - 1] > 0

#define condition_x img_row[c] > 0

if (condition_x){

if (condition_q){

//x <- q

imgLabels_row[c] = imgLabels_row_prev[c];

}

else{

// q = 0

if (condition_r){

if (condition_p){

// x <- merge(p,r)

imgLabels_row[c] = set_union(P, imgLabels_row_prev[c - 1], imgLabels_row_prev[c + 1]);

}

else{

// p = q = 0

if (condition_s){

// x <- merge(s,r)

imgLabels_row[c] = set_union(P, imgLabels_row[c - 1], imgLabels_row_prev[c + 1]);

}

else{

// p = q = s = 0

// x <- r

imgLabels_row[c] = imgLabels_row_prev[c + 1];

}

}

}

else{

// r = q = 0

if (condition_p){

// x <- p

imgLabels_row[c] = imgLabels_row_prev[c - 1];

}

else{

// r = q = p = 0

if (condition_s){

imgLabels_row[c] = imgLabels_row[c - 1];

}

else{

//new label

imgLabels_row[c] = lunique;

P[lunique] = lunique;

lunique = lunique + 1;

}

}

}

}

}

else{

//x is a background pixel

imgLabels_row[c] = 0;

}

}

}

#undef condition_p

#undef condition_q

#undef condition_r

#undef condition_s

#undef condition_x

}

else{

for (int r = 0; r < h; ++r){

PixelT const * const img_row = img.ptr<PixelT>(r);

PixelT const * const img_row_prev = (PixelT *)(((char *)img_row) - img.step.p[0]);

LabelT * const imgLabels_row = imgLabels.ptr<LabelT>(r);

LabelT * const imgLabels_row_prev = (LabelT *)(((char *)imgLabels_row) - imgLabels.step.p[0]);

for (int c = 0; c < w; ++c) {

#define condition_q r > 0 && img_row_prev[c] > 0

#define condition_s c > 0 && img_row[c - 1] > 0

#define condition_x img_row[c] > 0

if (condition_x){

if (condition_q){

if (condition_s){

//Merge s->x->q

imgLabels_row[c] = set_union(P, imgLabels_row[c - 1], imgLabels_row_prev[c]);

}

else{

//copy q

imgLabels_row[c] = imgLabels_row_prev[c];

}

}

else{

if (condition_s){

// copy s

imgLabels_row[c] = imgLabels_row[c - 1];

}

else{

//new label

imgLabels_row[c] = lunique;

P[lunique] = lunique;

lunique = lunique + 1;

}

}

}

else{

//x is a background pixel

imgLabels_row[c] = 0;

}

}

}

#undef condition_q

#undef condition_s

#undef condition_x

}

//analysis

LabelT nLabels = flattenL(P, lunique);

sop.init(nLabels);

for (int r = 0; r < h; ++r) {

LabelT * img_row_start = imgLabels.ptr<LabelT>(r);

LabelT * const img_row_end = img_row_start + w;

for (int c = 0; img_row_start != img_row_end; ++img_row_start, ++c){

*img_row_start = P[*img_row_start];

sop(r, c, *img_row_start);

}

}

sop.finish();

fastFree(P);

return nLabels;

}//End function LabelingWu operator()

class FirstScan : public cv::ParallelLoopBody{

private:

const cv::Mat& img_;

cv::Mat& imgLabels_;

LabelT *P_;

int *chunksSizeAndLabels_;

public:

FirstScan(const cv::Mat& img, cv::Mat& imgLabels, LabelT *P, int *chunksSizeAndLabels)

: img_(img), imgLabels_(imgLabels), P_(P), chunksSizeAndLabels_(chunksSizeAndLabels){}

FirstScan& operator=(const FirstScan&) { return *this; }

void operator()(const cv::Range& range) const CV_OVERRIDE

{

int r = range.start;

r += (r % 2);

chunksSizeAndLabels_[r] = range.end + (range.end % 2);

LabelT label = LabelT((r + 1) / 2) * LabelT((imgLabels_.cols + 1) / 2) + 1;

const LabelT firstLabel = label;

const int h = img_.rows, w = img_.cols;

const int limitLine = r + 1, startR = r;

for (; r < range.end; r += 2){

// Get rows pointer

const PixelT * const img_row = img_.ptr<uchar>(r);

const PixelT * const img_row_prev = (PixelT *)(((char *)img_row) - img_.step.p[0]);

const PixelT * const img_row_prev_prev = (PixelT *)(((char *)img_row_prev) - img_.step.p[0]);

const PixelT * const img_row_fol = (PixelT *)(((char *)img_row) + img_.step.p[0]);

LabelT * const imgLabels_row = imgLabels_.ptr<LabelT>(r);

LabelT * const imgLabels_row_prev_prev = (LabelT *)(((char *)imgLabels_row) - imgLabels_.step.p[0] - imgLabels_.step.p[0]);

for (int c = 0; c < w; c += 2) {

// We work with 2x2 blocks

// +-+-+-+

// |P|Q|R|

// +-+-+-+

// |S|X|

// +-+-+

// The pixels are named as follows

// +---+---+---+

// |a b|c d|e f|

// |g h|i j|k l|

// +---+---+---+

// |m n|o p|

// |q r|s t|

// +---+---+

// Pixels a, f, l, q are not needed, since we need to understand the

// the connectivity between these blocks and those pixels only metter

// when considering the outer connectivities

// A bunch of defines used to check if the pixels are foreground,

// without going outside the image limits.

#define condition_b c-1>=0 && r > limitLine && img_row_prev_prev[c-1]>0

#define condition_c r > limitLine && img_row_prev_prev[c]>0

#define condition_d c+1<w && r > limitLine && img_row_prev_prev[c+1]>0

#define condition_e c+2<w && r > limitLine && img_row_prev_prev[c+2]>0

#define condition_g c-2>=0 && r > limitLine - 1 && img_row_prev[c-2]>0

#define condition_h c-1>=0 && r > limitLine - 1 && img_row_prev[c-1]>0

#define condition_i r > limitLine - 1 && img_row_prev[c]>0

#define condition_j c+1<w && r > limitLine - 1 && img_row_prev[c+1]>0

#define condition_k c+2<w && r > limitLine - 1 && img_row_prev[c+2]>0

#define condition_m c-2>=0 && img_row[c-2]>0

#define condition_n c-1>=0 && img_row[c-1]>0

#define condition_o img_row[c]>0

#define condition_p c+1<w && img_row[c+1]>0

#define condition_r c-1>=0 && r+1<h && img_row_fol[c-1]>0

#define condition_s r+1<h && img_row_fol[c]>0

#define condition_t c+1<w && r+1<h && img_row_fol[c+1]>0

// This is a decision tree which allows to choose which action to

// perform, checking as few conditions as possible.

// Actions are available after the tree.

if (condition_o) {

if (condition_n) {

if (condition_j) {

if (condition_i) {

//Action_6: Assign label of block S

imgLabels_row[c] = imgLabels_row[c - 2];

continue;

}

else {

if (condition_c) {

if (condition_h) {

//Action_6: Assign label of block S

imgLabels_row[c] = imgLabels_row[c - 2];

continue;

}

else {

if (condition_g) {

if (condition_b) {

//Action_6: Assign label of block S

imgLabels_row[c] = imgLabels_row[c - 2];

continue;

}

else {

//Action_11: Merge labels of block Q and S

imgLabels_row[c] = set_union(P_, imgLabels_row_prev_prev[c], imgLabels_row[c - 2]);

continue;

}

}

else {

//Action_11: Merge labels of block Q and S

imgLabels_row[c] = set_union(P_, imgLabels_row_prev_prev[c], imgLabels_row[c - 2]);

continue;

}

}

}

else {

//Action_11: Merge labels of block Q and S

imgLabels_row[c] = set_union(P_, imgLabels_row_prev_prev[c], imgLabels_row[c - 2]);

continue;

}

}

}

else {

if (condition_p) {

if (condition_k) {

if (condition_d) {

if (condition_i) {

//Action_6: Assign label of block S

imgLabels_row[c] = imgLabels_row[c - 2];

continue;

}

else {

if (condition_c) {

if (condition_h) {

//Action_6: Assign label of block S

imgLabels_row[c] = imgLabels_row[c - 2];

continue;

}

else {

if (condition_g) {

if (condition_b) {

//Action_6: Assign label of block S

imgLabels_row[c] = imgLabels_row[c - 2];

continue;

}

else {

//Action_12: Merge labels of block R and S

imgLabels_row[c] = set_union(P_, imgLabels_row_prev_prev[c + 2], imgLabels_row[c - 2]);

continue;

}

}

else {

//Action_12: Merge labels of block R and S

imgLabels_row[c] = set_union(P_, imgLabels_row_prev_prev[c + 2], imgLabels_row[c - 2]);

continue;

}

}

}

else {

//Action_12: Merge labels of block R and S

imgLabels_row[c] = set_union(P_, imgLabels_row_prev_prev[c + 2], imgLabels_row[c - 2]);

continue;

}

}

}

else {

//Action_12: Merge labels of block R and S

imgLabels_row[c] = set_union(P_, imgLabels_row_prev_prev[c + 2], imgLabels_row[c - 2]);

continue;

}

}

else {