Multi otsu(multi-seuillage) avec openCV

Je suis en train de réaliser multi-seuillage avec otsu. La méthode que j'utilise actuellement est en fait via la maximisation de l'écart entre la classe, j'ai réussi à obtenir la même valeur de seuil donnée que par la bibliothèque OpenCV. Cependant, c'est par le biais de l'exécution de otsu méthode une fois.

La Documentation sur la façon de faire de la multi-niveau de seuillage ou plutôt récursive seuillage est plutôt limitée. Où dois-je faire après l'obtention de l'original otsu de la valeur? Apprécierait de quelques conseils, j'ai été jouer avec le code, l'ajout d'une boucle for, mais la prochaine valeur calculée est toujours 254 pour une image:(

Mon code si besoin est:

//compute histogram first
cv::Mat imageh; //image edited to grayscale for histogram purpose
//imageh=image; //to delete and uncomment below;
cv::cvtColor(image, imageh, CV_BGR2GRAY);

int histSize[1] = {256}; //number of bins
float hranges[2] = {0.0, 256.0}; //min andax pixel value
const float* ranges[1] = {hranges};
int channels[1] = {0}; //only 1 channel used

cv::MatND hist;
//Compute histogram
calcHist(&imageh, 1, channels, cv::Mat(), hist, 1, histSize, ranges);

IplImage* im = new IplImage(imageh);//assign the image to an IplImage pointer
IplImage* finalIm = cvCreateImage(cvSize(im->width, im->height), IPL_DEPTH_8U, 1);
double otsuThreshold= cvThreshold(im, finalIm, 0, 255, cv::THRESH_BINARY | cv::THRESH_OTSU );

cout<<"opencv otsu gives "<<otsuThreshold<<endl;

int totalNumberOfPixels= imageh.total();
cout<<"total number of Pixels is " <<totalNumberOfPixels<< endl;


float sum = 0;
for (int t=0 ; t<256 ; t++) 
{
    sum += t * hist.at<float>(t);
}
cout<<"sum is "<<sum<<endl;

float sumB = 0; //sum of background
int wB = 0; //weight of background
int wF = 0; //weight of foreground

float varMax = 0;
int threshold = 0;

//run an iteration to find the maximum value of the between class variance(as between class variance shld be maximise)
for (int t=0 ; t<256 ; t++) 
{
       wB += hist.at<float>(t);               //Weight Background
       if (wB == 0) continue;

       wF = totalNumberOfPixels - wB;                 //Weight Foreground
       if (wF == 0) break;

       sumB += (float) (t * hist.at<float>(t));

       float mB = sumB /wB;            //Mean Background
       float mF = (sum - sumB) /wF;    //Mean Foreground

       //Calculate Between Class Variance
       float varBetween = (float)wB * (float)wF * (mB - mF) * (mB - mF);

       //Check if new maximum found
       if (varBetween > varMax) {
          varMax = varBetween;
          threshold = t;
       }
}

       cout<<"threshold value is: "<<threshold;

Otsu n'2-classe de clustering. Peut-être que vous devriez essayer de k-means pour un 3-classe de cluster et de voir ce qui se passe?
Une approche de ré-appliquer Otsu sur un histogramme qui a déjà été thresholded, est de prendre le tour d'une réinitialisation de la partie de l'histogramme qui est au-dessus ou au-dessous, la première Otsu valeur de seuil. Cela se fait en faisant partie de l'histogramme des poubelles ou des chiffres de la population à zéro.
aussi, s'il vous plaît, fossé ceux IplImages, et l'utilisation de cv::seuil() à la place
peut-être que vous pouvez appliquer otsu une fois, puis diviser l'image en deux cluster, appliquez un peu de la balance des blancs de normalisation sur chacun d'eux (rappelez-vous la normalisation du calcul), puis appliquer otsu sur chacun d'eux. Pour obtenir l'original seuils, vous pouvez annuler la normalisation de calcul pour que les valeurs de seuil.
pouvez-vous partager quelques liens sur tat? Afin que je puisse avoir une meilleure compréhension. N'hésitez pas à mettre comme réponse que j'ai l'habitude de upvote toutes les réponses à ma question, à moins que la réponse est totalement superflus(comme vraiment, vraiment mauvais). Merci(:

OriginalL'auteur rockinfresh | 2014-03-28

D'étendre Otsu du seuillage de la méthode multi-niveau de seuillage de l'écart entre la classe équation devient:

Multi otsu(multi-seuillage) avec openCV

S'il vous plaît vérifier Deng-Yuan Huang, Ta-Wei Lin, Wu-Hu Chih, Automatique
Multi-niveaux de Seuillage Basé sur Deux étapes Otsu de la Méthode du Cluster
La détermination par la Vallée de l'Estimation, de l'Int. Journal of innovative
L'informatique, 2011, 7:5631-5644 pour plus d'informations.

http://www.ijicic.org/ijicic-10-05033.pdf

Voici mon C# de mise en œuvre de Otsu Multi pour 2 seuils:

/* Otsu (1979) - multi */

Tuple < int, int > otsuMulti(object sender, EventArgs e) {
    //image histogram
    int[] histogram = new int[256];

    //total number of pixels
    int N = 0;

    //accumulate image histogram and total number of pixels
    foreach(int intensity in image.Data) {
        if (intensity != 0) {
            histogram[intensity] += 1;
            N++;
        }
    }

    double W0K, W1K, W2K, M0, M1, M2, currVarB, optimalThresh1, optimalThresh2, maxBetweenVar, M0K, M1K, M2K, MT;

    optimalThresh1 = 0;
    optimalThresh2 = 0;

    W0K = 0;
    W1K = 0;

    M0K = 0;
    M1K = 0;

    MT = 0;
    maxBetweenVar = 0;
    for (int k = 0; k <= 255; k++) {
        MT += k * (histogram[k] /(double) N);
    }


    for (int t1 = 0; t1 <= 255; t1++) {
        W0K += histogram[t1] /(double) N; //Pi
        M0K += t1 * (histogram[t1] /(double) N); //i * Pi
        M0 = M0K /W0K; //(i * Pi)/Pi

        W1K = 0;
        M1K = 0;

        for (int t2 = t1 + 1; t2 <= 255; t2++) {
            W1K += histogram[t2] /(double) N; //Pi
            M1K += t2 * (histogram[t2] /(double) N); //i * Pi
            M1 = M1K /W1K; //(i * Pi)/Pi

            W2K = 1 - (W0K + W1K);
            M2K = MT - (M0K + M1K);

            if (W2K <= 0) break;

            M2 = M2K /W2K;

            currVarB = W0K * (M0 - MT) * (M0 - MT) + W1K * (M1 - MT) * (M1 - MT) + W2K * (M2 - MT) * (M2 - MT);

            if (maxBetweenVar < currVarB) {
                maxBetweenVar = currVarB;
                optimalThresh1 = t1;
                optimalThresh2 = t2;
            }
        }
    }

    return new Tuple(optimalThresh1, optimalThresh2);
}

Et c'est le résultat que j'ai obtenu par seuillage d'une image d'analyse de sol avec le code ci-dessus:

(T1 = 110, T2 = 147).

Multi otsu(multi-seuillage) avec openCV

Otsu de l'article original: "Nobuyuki Otsu, Une Méthode de Sélection de Seuil
à partir de Niveau de Gris de l'Histogramme, IEEE Transactions sur les Systèmes, l'Homme, et
La cybernétique, 1979, 9:62-66" mentionne aussi brièvement l'extension de
Multithresholding.

https://engineering.purdue.edu/kak/computervision/ECE661.08/OTSU_paper.pdf

Espère que cette aide.

M0 = M0K / W0K; //(i * Pi)/Pi ressemble à la somme de t1 à moi (= Somme(0, i)). Même pour les M1.

OriginalL'auteur Antoni4

2

J'ai écrit un exemple sur la façon otsu seuillage de travail en python avant. Vous pouvez voir le code source ici: https://github.com/subokita/Sandbox/blob/master/otsu.py

Dans l'exemple il y a 2 variantes, otsu2() qui est la version optimisée, comme on le voit sur la page Wikipedia, et otsu() qui est plus naïf de la mise en œuvre basée sur la description d'algorithme lui-même.

Si vous êtes d'accord, dans la lecture de python codes (dans ce cas, ils sont assez simples, presque le pseudo-code), vous voudrez peut-être regarder à otsu() dans l'exemple et de le modifier. Le portage de code C++ n'est pas dur non plus.

Yup. Je sais comment otsu seuillage de travail, mon otsu code est en fait similaire à votre otsu2() du code, la maximisation de l'écart entre la classe. Le problème maintenant est de savoir comment faire un appel récursif ou plutôt un multi-niveau de seuillage avec la valeur donnée à partir de la première otsu. Mais encore, merci pour l'essayer, un upvote pour vous(:
ce n'est pas une réponse à la question, veuillez downvote au lieu de upvote. Upvoting n'est pas la même chose que "merci", et de le faire à une mauvaise réponse peut induire en erreur les futurs lecteurs.

OriginalL'auteur sub_o

@Antoni4 donne la meilleure réponse, à mon avis et c'est très droite vers l'avant pour augmenter le nombre de niveaux.

C'est pour trois niveau de seuillage:

#include "Shadow01-1.cuh"

void multiThresh(double &optimalThresh1, double &optimalThresh2, double &optimalThresh3, cv::Mat &imgHist, cv::Mat &src)
{
double W0K, W1K, W2K, W3K, M0, M1, M2, M3, currVarB, maxBetweenVar, M0K, M1K, M2K, M3K, MT;
unsigned char *histogram = (unsigned char*)(imgHist.data);

int N = src.rows*src.cols;
W0K = 0;
W1K = 0;
M0K = 0;
M1K = 0;
MT = 0;
maxBetweenVar = 0;

for (int k = 0; k <= 255; k++) {
    MT += k * (histogram[k] /(double) N);
}

for (int t1 = 0; t1 <= 255; t1++)
{
    W0K += histogram[t1] /(double) N; //Pi
    M0K += t1 * (histogram[t1] /(double) N); //i * Pi
    M0 = M0K /W0K; //(i * Pi)/Pi

    W1K = 0;
    M1K = 0;

    for (int t2 = t1 + 1; t2 <= 255; t2++)
    {
        W1K += histogram[t2] /(double) N; //Pi
        M1K += t2 * (histogram[t2] /(double) N); //i * Pi
        M1 = M1K /W1K; //(i * Pi)/Pi
        W2K = 1 - (W0K + W1K);
        M2K = MT - (M0K + M1K);

        if (W2K <= 0) break;

        M2 = M2K /W2K;

        W3K = 0;
        M3K = 0;

        for (int t3 = t2 + 1; t3 <= 255; t3++)
        {
            W2K += histogram[t3] /(double) N; //Pi
            M2K += t3 * (histogram[t3] /(double) N); //i*Pi
            M2 = M2K /W2K; //(i*Pi)/Pi
            W3K = 1 - (W1K + W2K);
            M3K = MT - (M1K + M2K);

            M3 = M3K /W3K;
            currVarB = W0K * (M0 - MT) * (M0 - MT) + W1K * (M1 - MT) * (M1 - MT) + W2K * (M2 - MT) * (M2 - MT) + W3K * (M3 - MT) * (M3 - MT);

            if (maxBetweenVar < currVarB)
            {
                maxBetweenVar = currVarB;
                optimalThresh1 = t1;
                optimalThresh2 = t2;
                optimalThresh3 = t3;
            }
        }
    }
}
}

OriginalL'auteur Guilherme Silva

1

@Guilherme Silva

Votre code a un BUG

Vous Devez Remplacer:
```
    W3K = 0;
    M3K = 0;
```
avec
```
    W2K = 0;
    M2K = 0;
```
et
```
        W3K = 1 - (W1K + W2K);
        M3K = MT - (M1K + M2K);
```
avec
```
        W3K = 1 - (W0K + W1K + W2K);
        M3K = MT - (M0K + M1K + M2K);
```
😉
Ce qui concerne

MODIFIER(1): [Toby Speight]
J'ai découvert ce bug par l'application de l'effet à la même image à différents resoultions(Tailles) et de voir que les résultats étaient très différents les uns des autres (Même en changeant la résolution un peu)

W3K et M3K doivent être les totaux moins les Précédentes Semaines et MKs.
(J'ai pensé à cela pour le Code-similitude avec l'une avec un niveau moins)
En ce moment à cause de mon manque de l'anglais je ne peux pas expliquer Mieux Comment et Pourquoi

Pour être honnête, je ne suis pas encore sûr à 100% que c'est correct, même la pensée de mes sorties, je pourrais dire qu'elle donne de meilleurs résultats. (Même avec 1 Niveau de plus (5 nuances de gris))
Vous pouvez essayer vous-même 😉
Désolé

Mes Sorties:

3 Seuils
4 les Seuils de

Quelques explications sur les changements serait sans doute utile pour les autres.
Je l'ai découvert en regardant les résultats de sortie. J'ai vu que les résultats de sortie où bien différents de l'application de l'effet sur la même photo avec des tailles différentes. Fondamentalement W3K et M3K doivent être les totaux, moins les niveaux précédents W et M. (désolé pour mon anglais)
Bien que ce code peut aider à résoudre le problème, ça n'explique pas pourquoi et/ou comment il répond à la question. La fourniture de ce contexte supplémentaire permettrait d'améliorer de façon significative à long terme sa valeur éducative. Veuillez modifier votre réponse pour ajouter des explications, y compris quelles sont les limites et les hypothèses s'appliquent.

OriginalL'auteur reexre

J'ai trouvé une pièce utile de code dans ce fil. Je cherchais un multi-niveau de Otsu mise en œuvre pour double/float images. Donc, j'ai essayé de généraliser exemple pour N-niveaux avec double/float matrice en entrée. Dans mon code ci-dessous je suis en utilisant tatou bibliothèque de dépendance. Mais ce code peut être facilement adapté pour la norme C++ tableaux, il suffit de remplacer vec, uvec des objets avec unidimensionnels double et entier des tableaux, des tapis et umat avec deux dimensions. Deux autres fonctions de tatou utilisés ici sont: vectoriser et hist.

//Input parameters:
//map - input image (double matrix)
//mask - region of interest to be thresholded
//nBins - number of bins
//nLevels - number of Otsu thresholds

#include <armadillo>
#include <algorithm>
#include <vector>

mat OtsuFilterMulti(mat map, int nBins, int nLevels) {

    mat mapr;   //output thresholded image
    mapr = zeros<mat>(map.n_rows, map.n_cols);

    unsigned int numElem = 0;
    vec threshold = zeros<vec>(nLevels);
    vec q = zeros<vec>(nLevels + 1);
    vec mu = zeros<vec>(nLevels + 1);
    vec muk = zeros<vec>(nLevels + 1);
    uvec binv = zeros<uvec>(nLevels);

    if (nLevels <= 1) return mapr;

    numElem = map.n_rows*map.n_cols;


    uvec histogram = hist(vectorise(map), nBins);

    double maxval = map.max();
    double minval = map.min();
    double odelta = (maxval - abs(minval)) /nBins;     //distance between histogram bins

    vec oval = zeros<vec>(nBins);
    double mt = 0, variance = 0.0, bestVariance = 0.0;

    for (int ii = 0; ii < nBins; ii++) {
        oval(ii) = (double)odelta*ii + (double)odelta*0.5;  //centers of histogram bins
        mt += (double)ii*((double)histogram(ii)) /(double)numElem;
    }

    for (int ii = 0; ii < nLevels; ii++) {
        binv(ii) = ii;
    }

    double sq, smuk;
    int nComb;

    nComb = nCombinations(nBins,nLevels);
    std::vector<bool> v(nBins);
    std::fill(v.begin(), v.begin() + nLevels, true);

    umat ibin = zeros<umat>(nComb, nLevels); //indices from combinations will be stored here

    int cc = 0;
    int ci = 0;
    do {
        for (int i = 0; i < nBins; ++i) {
            if(ci==nLevels) ci=0;
                if (v[i]) {
                ibin(cc,ci) = i;
                ci++;
            }
        }
        cc++;
    } while (std::prev_permutation(v.begin(), v.end()));

    uvec lastIndex = zeros<uvec>(nLevels);

    //Perform operations on pre-calculated indices
    for (int ii = 0; ii < nComb; ii++) {
        for (int jj = 0; jj < nLevels; jj++) {
            smuk = 0;
            sq = 0;
            if (lastIndex(jj) != ibin(ii, jj) || ii == 0) {
                q(jj) += double(histogram(ibin(ii, jj))) /(double)numElem;
                muk(jj) += ibin(ii, jj)*(double(histogram(ibin(ii, jj)))) /(double)numElem;
                mu(jj) = muk(jj) /q(jj);
                q(jj + 1) = 0.0;
                muk(jj + 1) = 0.0;

                if (jj>0) {
                    for (int kk = 0; kk <= jj; kk++) {
                        sq += q(kk);
                        smuk += muk(kk);
                    }
                    q(jj + 1) = 1 - sq;
                    muk(jj + 1) = mt - smuk;
                    mu(jj + 1) = muk(jj + 1) /q(jj + 1);
                }
                if (jj>0 && jj<(nLevels - 1)) {
                    q(jj + 1) = 0.0;
                    muk(jj + 1) = 0.0;
                }

                lastIndex(jj) = ibin(ii, jj);
            }
        }

        variance = 0.0;
        for (int jj = 0; jj <= nLevels; jj++) {
            variance += q(jj)*(mu(jj) - mt)*(mu(jj) - mt);
        }    

        if (variance > bestVariance) {
            bestVariance = variance;
            for (int jj = 0; jj<nLevels; jj++) {
                threshold(jj) = oval(ibin(ii, jj));
            }
        }    
    }

    cout << "Optimized thresholds: ";
    for (int jj = 0; jj<nLevels; jj++) {
        cout << threshold(jj) << " ";
    }
    cout << endl;

    for (unsigned int jj = 0; jj<map.n_rows; jj++) {
        for (unsigned int kk = 0; kk<map.n_cols; kk++) {
            for (int ll = 0; ll<nLevels; ll++) {
                if (map(jj, kk) >= threshold(ll)) {
                    mapr(jj, kk) = ll+1;
                }
            }
        }
    }

    return mapr;
}


int nCombinations(int n, int r) {

    if (r>n) return 0;
    if (r*2 > n) r = n-r;
    if (r == 0) return 1;

    int ret = n;
    for( int i = 2; i <= r; ++i ) {
        ret *= (n-i+1);
        ret /= i;
    }
    return ret;
}

OriginalL'auteur Gregor Bauman

Ici est une simple approche générale pour 'n' seuils python (>3.0) :

# developed by- SUJOY KUMAR GOSWAMI
# source paper- https://people.ece.cornell.edu/acharya/papers/mlt_thr_img.pdf

import cv2
import numpy as np
import math

img = cv2.imread('path-to-image')
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
a = 0
b = 255
n = 6 # number of thresholds (better choose even value)
k = 0.7 # free variable to take any positive value
T = [] # list which will contain 'n' thresholds

def sujoy(img, a, b):
    if a>b:
        s=-1
        m=-1
        return m,s

    img = np.array(img)
    t1 = (img>=a)
    t2 = (img<=b)
    X = np.multiply(t1,t2)
    Y = np.multiply(img,X)
    s = np.sum(X)
    m = np.sum(Y)/s
    return m,s

for i in range(int(n/2-1)):
    img = np.array(img)
    t1 = (img>=a)
    t2 = (img<=b)
    X = np.multiply(t1,t2)
    Y = np.multiply(img,X)
    mu = np.sum(Y)/np.sum(X)

    Z = Y - mu
    Z = np.multiply(Z,X)
    W = np.multiply(Z,Z)
    sigma = math.sqrt(np.sum(W)/np.sum(X))

    T1 = mu - k*sigma
    T2 = mu + k*sigma

    x, y = sujoy(img, a, T1)
    w, z = sujoy(img, T2, b)

    T.append(x)
    T.append(w)

    a = T1+1
    b = T2-1
    k = k*(i+1)

T1 = mu
T2 = mu+1
x, y = sujoy(img, a, T1)
w, z = sujoy(img, T2, b)    
T.append(x)
T.append(w)
T.sort()
print(T)

Pour l'étude complète et plus d'informations visitez ce lien.

OriginalL'auteur Sujoy Kumar Goswami

Vous devez vous connecter pour publier un commentaire.