innerhalb einer Kontur in opencv die Anzahl der Kinder Konturen Zählen

Question

Ich habe dieses Quellbild

und ich habe binäre Schwellwertbildung angewendet diese benutzte ich Konturen

zu erhalten, Unterscheiden Sie zwischen denen, die Kinderkonturen haben, und denen, die dies nicht tun. Das resultierende Bild ist

Aber wie zähle ich die Anzahl der untergeordneten Konturen, die jede grüne Kontur enthält ?. Dies ist der Code habe ich verwendet: -

Mat binMask = lung;// the thresholded image 
Mat lung_src = imread("source.tiff");// the source image 
//imshow("bin mask", binMask); 
vector<std::vector<cv::Point>> contours; 
vector<cv::Vec4i> hierarchy; 
int count = 0, j; 

double largest_area = 0; 
int largest_contour_index = 0; 

findContours(binMask, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, cv::Point(0, 0)); 

for (int i = 0; i < contours.size(); i++) 
{ 
    double a = contourArea(contours[i], false); // Find the area of contour 
    if (a>largest_area) 
    { 
     largest_area = a; 
     largest_contour_index = i; 
    } 
    for (j = 0; j <= i; j++) 
    { 
     if (hierarchy[j][2] != -1) // means it has child contour 
     { 

       drawContours(lung_src, contours, j, Scalar(0, 255, 0), 1, 8, hierarchy, 0, Point()); 

     }   
     else // means it doesn't have any child contour 
     { 
      drawContours(lung_src, contours, j, Scalar(0, 0, 255), 1, 8, hierarchy, 0, Point()); 
     } 
    } 
} 
drawContours(lung_src, contours, largest_contour_index, Scalar(255, 0, 0), 1, 8, hierarchy, 0, Point()); 
imshow("lung-mapped", lung_src); 

EDIT-1- ich den Code aus Humam am Ende, check it out hinzugefügt:

std::vector<int> number_of_inner_contours(contours.size(), -1); 
int number_of_childs = 0; 
for (size_t i = 0; i < contours.size(); i++) 
{ 

    int first_child_index = hierarchy[i][2]; 
    if (first_child_index >= 0) 
    { 
     int next_child_index = hierarchy[first_child_index][0]; 
     if (number_of_inner_contours[next_child_index]<0) 
     { 
      number_of_childs = number_of_inner_contours[next_child_index]; 
     } 
     else 
     { 
      while (next_child_index >= 0) 
      { 
       next_child_index = hierarchy[next_child_index][0]; 
       ++number_of_childs; 
      } 
      number_of_inner_contours[i] = number_of_childs; 
     } 
    } 
    else 
    { 
     number_of_inner_contours[i] = 0; 
    } 
    cout << "\nThe contour[" << i << "] has " << number_of_inner_contours[i] << "child contours"; 
} 

Aber der Ausgang ich bekam, war wie:

 The contour[456 ] has 0 child contours 
     The contour[457 ] has 0 child contours 
     The contour[458 ] has 0 child contours 
     The contour[459 ] has -1 child contours 

Answer 1

Von OpenCV documentation:

Hierarchie - Optionaler Ausgabevektor, der Informationen zur Bildtopologie enthält. Es hat so viele Elemente wie die Anzahl der Konturen. Für werden die i-ten Konturkonturen [i], die Elemente Hierarchie [i] [0], Hierarchie i, Hiearchie [i] [2] und Hierarchie [i] [3] auf 0-basierte Indizes gesetzt in Konturen der nächsten und vorherigen Konturen bei gleichen hierarchischen Ebene, die erste Kind-Kontur und die Eltern- Kontur. Wenn für die Kontur i keine nächsten, vorherigen, übergeordneten oder verschachtelten Konturen vorhanden sind, werden die entsprechenden Elemente der Hierarchie [i] negativ sein.

Dies ist ungetestet Code für den Job:

std::vector<size_t> number_of_inner_contours; 
number_of_inner_contours.reserve(contours.size()); 
for (size_t i = 0; i < contours.size(); i++){ 
    size_t number_of_childs = 0; 
    auto first_child_index=hierarchy[i][2]; 
    if(first_child_index>=0){ 
     auto next_child_index=hierarchy[first_child_index][0]; 
     while (next_child_index>=0){ 
      next_child_index=hierarchy[next_child_index][0]; 
      ++number_of_childs; 
     } 
     number_of_inner_contours.emplace_back(number_of_childs); 
    } 
    else{ 
     number_of_inner_contours.emplace_back(0); 
    } 
} 

Dieser Code in einer besseren Art und Weise getan werden, um das Konzept der dynamischen Programmierung unter Verwendung. Dies ist ein erster Versuch auch:

std::vector<int> number_of_inner_contours(contours.size(),-1); 
for (size_t i = 0; i < contours.size(); i++){ 
    auto number_of_childs = 0; 
    auto first_child_index=hierarchy[i][2]; 
    if(first_child_index>=0){ 
     auto next_child_index=hierarchy[first_child_index][0]; 
     if(number_of_inner_contours[next_child_index]<0){ 
      number_of_childs=number_of_inner_contours[next_child_index]; 
     } 
     else{ 
      while (next_child_index>=0){ 
       next_child_index=hierarchy[next_child_index][0]; 
       ++number_of_childs; 
      } 
      number_of_inner_contours[i]=number_of_childs; 
     } 
    } 
    else{ 
     number_of_inner_contours[i]=0; 
    } 
}