rectangle region segmentation

Question

I'm trying to get the red rectangle region below "C", as image below:

And below is my source code use Opencv4Android:

public void threshold() {
    Mat rgbMat = new Mat();
    Mat grayMat = new Mat();
    Mat edgeMat = new Mat();
    Utils.bitmapToMat(bmp, rgbMat);
    Mat intermediate = new Mat();

    Imgproc.cvtColor(rgbMat, intermediate, Imgproc.COLOR_BGR2GRAY);
    Imgproc.GaussianBlur(intermediate, intermediate, new Size(3, 3), 0);
    Imgproc.threshold(intermediate, intermediate, 190, 255, Imgproc.THRESH_BINARY | Imgproc.THRESH_OTSU);

    Imgproc.Canny(intermediate, intermediate, 60, 140);

    List<MatOfPoint> contours = new ArrayList<MatOfPoint>();
    Mat mHierarchy = new Mat();
    Imgproc.findContours(intermediate, contours, mHierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);

    Scalar CONTOUR_COLOR = new Scalar(255,0,0,255);
    Log.e(TAG, "Contours count: " + contours.size());
    Imgproc.drawContours(intermediate, contours, -1, CONTOUR_COLOR);

    Bitmap edgeBmp = Bitmap.createBitmap(bmp.getWidth(), bmp.getHeight(), Config.ARGB_8888);
    Utils.matToBitmap(intermediate, edgeBmp);

    imageView.setImageBitmap(edgeBmp);
}   

but the result is not as I expected: as image below:

As log show, Contours count: 372, and the rectangle region is discontinuous, How can I get the contour of the red rectangle region, and filter another useless region. I have referenced some other questions, but the question still not be solved, Could you do me a favor?

[update] change the code by the suggest from Morotspaj,

public void thresholdNew() {
    Mat rgbMat = new Mat();
    Mat grayMat = new Mat();
    Utils.bitmapToMat(bmp, rgbMat);

    Imgproc.cvtColor(rgbMat, grayMat, Imgproc.COLOR_BGR2GRAY);
    Vector<Mat> bgr_planes = new Vector<Mat>();
    Core.split(rgbMat, bgr_planes);
    Mat redMat = bgr_planes.get(2);
    Mat redness = new Mat();
    Core.subtract(redMat, grayMat, redness);

    Mat intermediateMat1 = new Mat();
    Mat intermediateMat2 = new Mat();
    Imgproc.GaussianBlur(redness, intermediateMat1, new Size(15,15), 0);
    Imgproc.GaussianBlur(redness, intermediateMat2, new Size(55,55), 0);
    Mat red_mask  = new Mat();
    Core.subtract(intermediateMat1, intermediateMat2, red_mask );
    Imgproc.threshold(red_mask , red_mask , 90, 255, Imgproc.THRESH_BINARY | Imgproc.THRESH_OTSU);

    Mat masked_image = rgbMat.clone();
    masked_image = masked_image.setTo(new Scalar(255,0,0), red_mask );

    Bitmap edgeBmp = Bitmap.createBitmap(bmp.getWidth(), bmp.getHeight(), Config.ARGB_8888);
    Utils.matToBitmap(masked_image, edgeBmp);

    imageView.setImageBitmap(edgeBmp);
}

But the result is not as I expected and different with Morotspaj's. Any error exist in the above code?

[update] Sorry, I am very busy these days, I will be try again later, and If I can not implement with Java, I will use Morotspaj's code through JNI. I will be update soon.

Answer 1

I made a filter to mask out the red rectangle region, just for you ;)

Mat rgbMat = imread("red_rectangle.jpg", -1);
Mat grayMat;
cvtColor(rgbMat, grayMat, COLOR_BGR2GRAY);

// Separate the red channel and compare it to the gray image
Mat channels[3];
split(rgbMat, channels);
Mat redness = Mat_<float>(channels[2]) - Mat_<float>(grayMat);

// Find the sharp red region
Mat red_blur1;
Mat red_blur2;
GaussianBlur(redness, red_blur1, Size(15,15), 0);
GaussianBlur(redness, red_blur2, Size(55,55), 0);
Mat red_mask = (red_blur1-red_blur2) > 2;

// Store result
Mat masked_image = rgbMat.clone();
masked_image.setTo(Scalar(0,0,255), red_mask);
imwrite("red_mask.png", red_mask);
imwrite("masked_image.png", masked_image);

The GaussianBlur method calls can be replaced by boxFilter if you need better performance, and the constants here and there can of course be tweaked. Hope this helps!

EDIT: Taking the difference of two differently blurred images is known as Difference of Gaussians (DoG). It finds changes in a certain scale depending on the size of the kernels. The smaller kernel is used to smooth away small details and noise. The bigger kernel destroys the details we are interested in but not the regions with very smooth changes that we don't want. By taking the difference between them we end up with only the details in the scale we are interested in! A mask can then be created easily by thresholding with the > operator.