opencv contours

package it.neo7bf;

import java.util.ArrayList;
import java.util.List;

import org.opencv.core.Core;
import org.opencv.core.Mat;
import org.opencv.core.MatOfPoint;
import org.opencv.core.MatOfPoint2f;
import org.opencv.core.Point;
import org.opencv.core.Rect;
import org.opencv.core.RotatedRect;
import org.opencv.core.Scalar;
import org.opencv.core.Size;
import org.opencv.imgcodecs.Imgcodecs;
import org.opencv.imgproc.Imgproc;

import nu.pattern.OpenCV;

public class SeparationTest3 {

    static {
          OpenCV.loadShared();
          //System.loadLibrary(org.opencv.core.Core.NATIVE_LIBRARY_NAME); Serve ? Tutte e due le istruzioni caricano le librerie native. La seconda da per scontatto che siano state già installate.
          //La prima le deposita in una cartella temporanea e poi le carica.
    }

    static class I {
        public String name;
        public int v;
        I(String name, int v) {
            this.name = name;
            this.v = v;
        }
    }

    public static void cannyTest() {

        List<I> images = List.of(
            new I("2022-04-16_085329",3)
        );

        for(I image : images) {

            Mat srcMat = Imgcodecs.imread("C:\\ProgettoScontrino\\scontrini\\campioni-test\\test-separazione\\"+image.name+".jpg");

            Mat grayMat = new Mat();
            Mat blurredMat = new Mat();
            Mat dilatedMat = new Mat();
            Mat cannyMat = new Mat();


            Imgproc.resize(srcMat, srcMat, new Size(0,0), 0.5, 0.5, Imgproc.INTER_AREA);
            Imgproc.cvtColor(srcMat, grayMat, Imgproc.COLOR_BGR2GRAY);
            Imgproc.threshold(grayMat, grayMat, 177, 200, Imgproc.THRESH_BINARY);
            Imgproc.GaussianBlur(grayMat, blurredMat, new Size(21,21),0, 0,Core.BORDER_DEFAULT); //3,3, 9,9 15,15,....

            Mat rectKernel = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(21,21));

            Imgproc.dilate(blurredMat, dilatedMat, rectKernel, new Point(0,0),1);
            Imgproc.Canny(dilatedMat,cannyMat,100,200,3);

            List<MatOfPoint> contours = new ArrayList<MatOfPoint>();
            final Mat hierarchy = new Mat();

            Imgproc.findContours(cannyMat, contours, hierarchy, Imgproc.RETR_TREE, Imgproc.CHAIN_APPROX_SIMPLE);

            contours = getMaxContours(contours,image.v);

            for(MatOfPoint cnt : contours) {
                    MatOfPoint2f mop2f = new MatOfPoint2f(cnt.toArray());
                    Imgproc.approxPolyDP(mop2f, mop2f, 0.02*Imgproc.arcLength(mop2f, true), true);
                    RotatedRect rr = Imgproc.minAreaRect(mop2f);
                    MatOfPoint m = new MatOfPoint();
                    Imgproc.boxPoints(rr, m);
                    Point[] rectPoints = new Point[4];
                    rr.points(rectPoints);
                    for (int j = 0; j < 4; ++j) {
                      Imgproc.line(srcMat, rectPoints[j], rectPoints[(j + 1) % 4], new Scalar(0,255,0), 20);
                    }

                    //BoundingBox
                    Rect boundingRect = Imgproc.boundingRect(cnt);
                    Imgproc.rectangle(srcMat, boundingRect, new Scalar(0,0,255),20); //scalar not is RGB but BGR !
            }

            //C:\ProgettoScontrino\scontrini\campioni-test\test-separazione\output\
            Imgcodecs.imwrite("C:\\ProgettoScontrino\\scontrini\\campioni-test\\test-separazione\\output\\"+image.name+"gray.jpg", grayMat);
            Imgcodecs.imwrite("C:\\ProgettoScontrino\\scontrini\\campioni-test\\test-separazione\\output\\"+image.name+"blurred.jpg", blurredMat);
            Imgcodecs.imwrite("C:\\ProgettoScontrino\\scontrini\\campioni-test\\test-separazione\\output\\"+image.name+"dilated.jpg", dilatedMat);
            Imgcodecs.imwrite("C:\\ProgettoScontrino\\scontrini\\campioni-test\\test-separazione\\output\\"+image.name+"canny.jpg", cannyMat);
            Imgcodecs.imwrite("C:\\ProgettoScontrino\\scontrini\\campioni-test\\test-separazione\\output\\"+image.name+"contours.jpg", srcMat);
        }
    }

    private static List<MatOfPoint> getMaxContours(List<MatOfPoint> contours,int maxStackSize) {
        List<MatOfPoint> queue = new ArrayList<MatOfPoint>();
        for(MatOfPoint currCnt : contours) {
            if(queue.isEmpty())
                queue.add(currCnt);
            else {
                Rect boundingCurrRect = Imgproc.boundingRect(currCnt);
                for(int i=0; i<queue.size(); i++) {
                    Rect boundingRect = Imgproc.boundingRect(queue.get(i));
                    System.out.println("current area: "+ boundingCurrRect.area());
                    System.out.println("area-"+i+": "+ boundingRect.area());
                    if(boundingCurrRect.area() > boundingRect.area()) {
                        queue.add(i,currCnt);
                        if(queue.size() > maxStackSize)
                            queue.remove(queue.size()-1);
                        break;
                    }
                }
            }
        }
        return queue;
    }

    public static void main(String[] args) {
        cannyTest();
    }
}