imregionalmax matlab function's equivalent in opencv

Question

I have an image of connected components(circles filled).If i want to segment them i can use watershed algorithm.I prefer writing my own function for watershed instead of using the inbuilt function in OPENCV.I have successfu How do i find the regionalmax of objects using opencv?

Answer 1

I wrote a function myself. My results were quite similar to MATLAB, although not exact. This function is implemented for CV_32F but it can easily be modified for other types.

1. I mark all the points that are not part of a minimum region by checking all the neighbors. The remaining regions are either minima, maxima or areas of inflection.
2. I use connected components to label each region.
3. I check each region for any point belonging to a maxima, if yes then I push that label into a vector.
4. Finally I sort the bad labels, erase all duplicates and then mark all the points in the output as not minima.
5. All that remains are the regions of minima.

Here is the code:

//  output is a binary image
//  1: not a min region
//  0: part of a min region
//  2: not sure if min or not
//  3: uninitialized
void imregionalmin(cv::Mat& img, cv::Mat& out_img)
{
    // pad the border of img with 1 and copy to img_pad
    cv::Mat img_pad;
    cv::copyMakeBorder(img, img_pad, 1, 1, 1, 1, IPL_BORDER_CONSTANT, 1);

    //  initialize binary output to 2, unknown if min
    out_img = cv::Mat::ones(img.rows, img.cols, CV_8U)+2;

    //  initialize pointers to matrices
    float* in = (float *)(img_pad.data);
    uchar* out = (uchar *)(out_img.data);

    //  size of matrix
    int in_size = img_pad.cols*img_pad.rows;
    int out_size = img.cols*img.rows;

    int x, y;
    for (int i = 0; i < out_size; i++) {
        //  find x, y indexes
        y = i % img.cols;
        x = i / img.cols;

        neighborCheck(in, out, i, x, y, img_pad.cols);  //  all regions are either min or max
    }

    cv::Mat label;
    cv::connectedComponents(out_img, label);

    int* lab = (int *)(label.data);

    in = (float *)(img.data);
    in_size = img.cols*img.rows;

    std::vector<int> bad_labels;

    for (int i = 0; i < out_size; i++) {
        //  find x, y indexes
        y = i % img.cols;
        x = i / img.cols;

        if (lab[i] != 0) {
            if (neighborCleanup(in, out, i, x, y, img.rows, img.cols) == 1) {
                bad_labels.push_back(lab[i]);
            }
        }
    }

    std::sort(bad_labels.begin(), bad_labels.end());
    bad_labels.erase(std::unique(bad_labels.begin(), bad_labels.end()), bad_labels.end());

    for (int i = 0; i < out_size; ++i) {
        if (lab[i] != 0) {
            if (std::find(bad_labels.begin(), bad_labels.end(), lab[i]) != bad_labels.end()) {
                out[i] = 0;
            }
        }
    }
}

int inline neighborCleanup(float* in, uchar* out, int i, int x, int y, int x_lim, int y_lim)
{
    int index;
    for (int xx = x - 1; xx < x + 2; ++xx) {
        for (int yy = y - 1; yy < y + 2; ++yy) {
            if (((xx == x) && (yy==y)) || xx < 0 || yy < 0 || xx >= x_lim || yy >= y_lim)
                continue;
            index = xx*y_lim + yy;
            if ((in[i] == in[index]) && (out[index] == 0))
                return 1;
        }
    }

    return 0;
}

void inline neighborCheck(float* in, uchar* out, int i, int x, int y, int x_lim)
{   
    int indexes[8], cur_index;
    indexes[0] = x*x_lim + y;
    indexes[1] = x*x_lim + y+1;
    indexes[2] = x*x_lim + y+2;
    indexes[3] = (x+1)*x_lim + y+2;
    indexes[4] = (x + 2)*x_lim + y+2;
    indexes[5] = (x + 2)*x_lim + y + 1;
    indexes[6] = (x + 2)*x_lim + y;
    indexes[7] = (x + 1)*x_lim + y;
    cur_index = (x + 1)*x_lim + y+1;

    for (int t = 0; t < 8; t++) {
        if (in[indexes[t]] < in[cur_index]) {
            out[i] = 0;
            break;
        }
    }

    if (out[i] == 3)
        out[i] = 1;
}

Answer 2

The following listing is a function similar to Matlab's "imregionalmax". It looks for at most nLocMax local maxima above threshold, where the found local maxima are at least minDistBtwLocMax pixels apart. It returns the actual number of local maxima found. Notice that it uses OpenCV's minMaxLoc to find global maxima. It is "opencv-self-contained" except for the (easy to implement) function vdist, which computes the (euclidian) distance between points (r,c) and (row,col).

input is one-channel CV_32F matrix, and locations is nLocMax (rows) by 2 (columns) CV_32S matrix.

int imregionalmax(Mat input, int nLocMax, float threshold, float minDistBtwLocMax, Mat locations)
{
    Mat scratch = input.clone();
    int nFoundLocMax = 0;
    for (int i = 0; i < nLocMax; i++) {
        Point location;
        double maxVal;
        minMaxLoc(scratch, NULL, &maxVal, NULL, &location);
        if (maxVal > threshold) {
            nFoundLocMax += 1;
            int row = location.y;
            int col = location.x;
            locations.at<int>(i,0) = row;
            locations.at<int>(i,1) = col;
            int r0 = (row-minDistBtwLocMax > -1 ? row-minDistBtwLocMax : 0);
            int r1 = (row+minDistBtwLocMax < scratch.rows ? row+minDistBtwLocMax : scratch.rows-1);
            int c0 = (col-minDistBtwLocMax > -1 ? col-minDistBtwLocMax : 0);
            int c1 = (col+minDistBtwLocMax < scratch.cols ? col+minDistBtwLocMax : scratch.cols-1);
            for (int r = r0; r <= r1; r++) {
                for (int c = c0; c <= c1; c++) {
                    if (vdist(Point2DMake(r, c),Point2DMake(row, col)) <= minDistBtwLocMax) {
                        scratch.at<float>(r,c) = 0.0;
                    }
                }
            }
        } else {
            break;
        }
    }
    return nFoundLocMax;
}

Answer 3

I do not know if it is what you want, but in my answer to this post, I gave some code to find local maxima (peaks) in a grayscale image (resulting from distance transform). The approach relies on subtracting the original image from the dilated image and finding the zero pixels). I hope it helps, Good luck

Answer 4

I had the same problem some time ago, and the solution was to reimplement the imregionalmax algorithm in OpenCV/Cpp. It is not that complicated, because you can find the C++ source code of the function in the Matlab distribution. (somewhere in toolbox). All you have to do is to read carefully and understand the algorithm described there. Then rewrite it or remove the matlab-specific checks and you'll have it.