Calcul automatique de bas et de haut seuils pour le Savant opération dans opencv

Je suis tombé sur cette réponse alors que je cherchais un moyen pour générer automatiquement Habile de valeurs de seuil.

Espère que cela aide quelqu'un qui vient les chercher pour une bonne méthode pour la détermination automatique des valeurs de seuil pour les Futés de l'algorithme...

Si votre image se compose de distinct de premier plan et d'arrière-plan, puis le bord de l'objet au premier plan pouvez utiliser extraites par ce qui suit:

1. Calculer Otsu du seuil de l'aide:

   double otsu_thresh_val = cv::threshold(
       orig_img, _img, 0, 255, CV_THRESH_BINARY | CV_THRESH_OTSU
   );

   Nous n'avons pas besoin de la _img. Nous sommes intéressés uniquement par le otsu_thresh_val mais malheureusement, il n'existe actuellement aucune méthode dans OpenCV qui vous permet de ne calculer que la valeur de seuil.

2. Utiliser le Otsu seuil de la valeur seuil plus élevé et la moitié de la même façon que le seuil inférieur pour les Futés de l'algorithme.

   double high_thresh_val  = otsu_thresh_val,
          lower_thresh_val = otsu_thresh_val * 0.5;
   cv::Canny( orig_img, cannyOP, lower_thresh_val, high_thresh_val );

Plus d'informations liées à ce qui peut être trouvé dans ce papier: L'Étude sur L'Application de la Méthode d'Otsu en Habile Opérateur. L'explication de Otsu de la mise en œuvre peut être trouvé ici.

Aussi, il y a le code pour faire cela automatiquement, par la mise en au OpenCV construire. Je l'ai trouvé sur le OpenCV-liste de diffusion des utilisateurs, donc pas garanties. 🙂

Discussion: http://opencv-users.1802565.n2.nabble.com/Automatic-thresholding-in-cvCanny-td5871024.html
GitHub (code): https://gist.github.com/756833

J'ai regardé dans le code source de Matlab Savant détection de bord et j'ai réussi à l'écrire en Java avec OpenCV 3.

private static Mat getpartialedge(Mat image){
    double nonEdgeRate = 0.6;
    double thresholdRate = 0.6;
    double w = image.cols();
    double h = image.rows();
    int bins = 256;
    Mat sobel = new Mat();
    Mat sobelx = new Mat();
    Mat sobely = new Mat();
    Mat sobelxabs = new Mat();
    Mat sobelyabs = new Mat(); 
    Size gsz = new Size(5, 5);
    if(false) {
        Imgproc.Canny(image, sobel, 41, 71);
    }else {

        //Imgproc.GaussianBlur(graycopy,graycopy, gsz, 2);
        //Imgproc.dilate(image, image, kernel8);
        Imgproc.GaussianBlur(image, image, gsz, 2);


        int apertureSize = 3;
        Imgproc.Sobel(image, sobelx, CvType.CV_16S, 1, 0, apertureSize, 1, 0);
        Core.convertScaleAbs(sobelx, sobelxabs);
        Imgproc.Sobel(image, sobely, CvType.CV_16S, 0, 1, apertureSize, 1, 0);
        Core.convertScaleAbs(sobely, sobelyabs);
        Core.addWeighted(sobelxabs, 1, sobelyabs, 1, 0, sobel);
        sobel.convertTo(sobel, CvType.CV_8U);


        Mat equalized = new Mat();
        Imgproc.equalizeHist(sobel, equalized);
        Imgcodecs.imwrite(filePath + "aftersobel(eq).png", equalized);
        Imgcodecs.imwrite(filePath + "aftersobel.png", sobel);


        Mat hist = new Mat();
        List<Mat> matList = new ArrayList<Mat>();
        matList.add(sobel);
        Imgproc.calcHist(matList, new MatOfInt(0), new Mat(), hist, new MatOfInt(bins), new MatOfFloat(0f, 256f));
        float accu = 0;
        float t = (float) (nonEdgeRate * w * h);
        float bon = 0;
        float[] accutemp = new float[bins];
        for (int i = 0; i < bins; i++) {
            float tf[] = new float[1];
            hist.get(i, 0, tf);
            accu = accu + tf[0];
            accutemp[i] = accu;
            if (accu > t) {
                bon = (float) i;
                break;
            }
        }
        Imgproc.threshold(sobel, sobel, bon, 255, Imgproc.THRESH_BINARY);
        double ut = bon;
        double lt = thresholdRate * bon;


        Imgproc.Canny(image, sobel, lt, ut);
        //Imgproc.dilate(sobel, sobel, kernel2);
    }
    return sobel;
}

Le chemin est le lieu de sortie des images. Et l'image d'entrée doit être d'une échelle de gris de l'image avec U8 type de données.
Le principe de base est d'écarter nonEdgeRate(60%) des pixels non-edge pixel de la luminosité. Un histogramme est utilisé pour trier la luminosité et le seuil supérieur sera réglé de sorte qu'il y a 60% de pixels en dessous. Le seuil inférieur est fixé en multipliant le seuil supérieur par le thresholdRate(0.6).

Noter que le double nonEdgeRate = 0,6 et double thresholdRate = 0.6 est réglé par moi-même dans mon cas d'utilisation spécifiques. Th valeurs d'origine sont de 0,7 et 0,4 séparément dans matlab.

Que Luca Del Tongo a suggéré, vous pouvez calculer les seuils de gris de l'image, par exemple, en Java à l'aide d'OpenCV...

MatOfDouble mu = new MatOfDouble();
MatOfDouble stddev = new MatOfDouble();
Core.meanStdDev(greyMat, mu, stddev);
threshold1 = mu.get(0, 0)[0];
threshold2 = stddev.get(0, 0)[0];
Imgproc.Canny(greyMat, outputMat, threshold1, threshold2);