Konvexitätsfehler C ++ OpenCV

Question

Ich wäre dir dankbar, wenn du mir bei diesem Problem helfen könntest :)

In Bezug auf diese Frage cvconvexityDepects in opencv 2.x / c ++?, Ich habe das gleiche Problem. Der OpenCV C ++ - Wrapper hat nicht die Funktion cvconvexityDects, die in der C -Version angezeigt wird. Deshalb habe ich versucht, meine eigene Version zu schreiben.

Ein Teil des Codes ist (bitte beachten Sie, dass sowohl Countour als auch Hull Vector <Point> sind, die separat berechnet werden:

CvSeq* contourPoints;
CvSeq* hullPoints;
CvSeq* defects;
CvMemStorage* storage;
CvMemStorage* strDefects;
CvMemStorage* contourStr;
CvMemStorage* hullStr;
CvConvexityDefect *defectArray = 0;

strDefects = cvCreateMemStorage();
defects = cvCreateSeq( CV_SEQ_KIND_GENERIC|CV_32SC2, sizeof(CvSeq),sizeof(CvPoint), strDefects );

//We start converting vector<Point> resulting from findContours
contourStr = cvCreateMemStorage();
contourPoints = cvCreateSeq(CV_SEQ_KIND_GENERIC|CV_32SC2, sizeof(CvSeq), sizeof(CvPoint), contourStr);
printf("Metiendo valores\n");
for(int i=0; i<(int)contour.size(); i++) {
    CvPoint cp = {contour[i].x,  contour[i].y};
    cvSeqPush(contourPoints, &cp);
}
//Now, the hull points obtained from convexHull c++
hullStr = cvCreateMemStorage(0);
hullPoints = cvCreateSeq(CV_SEQ_KIND_GENERIC|CV_32SC2, sizeof(CvSeq), sizeof(CvPoint), hullStr);
for(int i=0; i<(int)hull.size(); i++) {
    CvPoint cp = {hull[i].x,  hull[i].y};
    cvSeqPush(hullPoints, &cp);
}

//And we compute convexity defects
storage = cvCreateMemStorage(0);
defects = cvConvexityDefects(contourPoints, hullPoints, storage);

Die Ausgabe ist Convex hull must represented as a sequence of indices or sequence of pointers in function cvConvexityDefects. Wirklich, ich weiß nicht, wie man die Konvertierung richtig durchführt. Ich habe im Internet gesucht und versucht, einige Codestücke anzupassen/zu kopieren/zu verstehen, aber es ist immer mit der C -Syntax.

Ich hoffe ich war klar. Danke im Voraus!

Answer 1

Ich habe diese Frage aufgeworfen, weil ich keine Lösung herausfinden konnte (es war nicht nur heute, dass ich es mit der Angelegenheit zu tun hatte), sondern schließlich konnte ich das Problem bewältigen!

Ich musste die Art und Weise ändern, wie ich den konvexen Rumpf mit dem Index -Array -Formular berechnete. Jetzt haben wir also einen Vektor <int> stattdessen einen Vektor <Point>.

Dies ist der Code, den ich verwendet habe (er funktioniert die Punkte über ein Bild):

void HandDetection::findConvexityDefects(vector<Point>& contour, vector<int>& hull, vector<Point>& convexDefects){
    if(hull.size() > 0 && contour.size() > 0){
    CvSeq* contourPoints;
    CvSeq* defects;
    CvMemStorage* storage;
    CvMemStorage* strDefects;
    CvMemStorage* contourStr;
    CvConvexityDefect *defectArray = 0;

    strDefects = cvCreateMemStorage();
    defects = cvCreateSeq( CV_SEQ_KIND_GENERIC|CV_32SC2, sizeof(CvSeq),sizeof(CvPoint), strDefects );

    //We transform our vector<Point> into a CvSeq* object of CvPoint.
    contourStr = cvCreateMemStorage();
    contourPoints = cvCreateSeq(CV_SEQ_KIND_GENERIC|CV_32SC2, sizeof(CvSeq), sizeof(CvPoint), contourStr);
    for(int i=0; i<(int)contour.size(); i++) {
        CvPoint cp = {contour[i].x,  contour[i].y};
        cvSeqPush(contourPoints, &cp);
    }

    //Now, we do the same thing with the hull index
    int count = (int)hull.size();
    //int hullK[count];
    int* hullK = (int*)malloc(count*sizeof(int));
    for(int i=0; i<count; i++){hullK[i] = hull.at(i);}
    CvMat hullMat = cvMat(1, count, CV_32SC1, hullK);

    //We calculate convexity defects
    storage = cvCreateMemStorage(0);
    defects = cvConvexityDefects(contourPoints, &hullMat, storage);
    defectArray = (CvConvexityDefect*)malloc(sizeof(CvConvexityDefect)*defects->total);
    cvCvtSeqToArray(defects, defectArray, CV_WHOLE_SEQ);
    //printf("DefectArray %i %i\n",defectArray->end->x, defectArray->end->y);

    //We store defects points in the convexDefects parameter.
    for(int i = 0; i<defects->total; i++){
        CvPoint ptf;
        ptf.x = defectArray[i].depth_point->x;
        ptf.y = defectArray[i].depth_point->y;
        convexDefects.push_back(ptf);
    }

    //We release memory
    cvReleaseMemStorage(contourStr);
    cvReleaseMemStorage(strDefects);
    cvReleaseMemStorage(storage);
    }
}

Das hat für mich funktioniert. Wenn Sie etwas falsch sehen oder eine andere Möglichkeit, es zu verwalten, sagen Sie es mir bitte!

Answer 2

fand einen direkten Ansatz unter Verwendung der CPP -Konvexitätsdefekte. Typhandling durch konvexhull-Funktion. Es füllt nach Typ, int* retektiert indiziert, Punkt* gibt Koordinaten zurück.

void WorkFrame( Mat img, double minArea )
{
//assumption:
// img already preprocessed, threshold, gray, smooth, morphology whatever..

//get some contours
vector<vector<Point> > contours;
vector<Vec4i> hierarchy;
findContours( img, contours, hierarchy, CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE );

for( int i=0; i<contours.size(); i++ ) 
{
    vector<Point>& c=contours[i];
    double area = contourArea( c );
        if( area<minArea ){ continue; } //filter remaining noise

    //convexHull works typedependent.
    //std::vector<Point> ptHull1; //uncomment and compare to ptHull2
    //convexHull( c, ptHull1 ); //convexHull is smart and fills direct coordinates

    std::vector<int> ihull; 
    convexHull( c, ihull ); //convexHull is smart and fills in contourIndices

    std::vector<Vec4i> defects;
    convexityDefects( c, ihull, defects ); //expects indexed hull (internal assertion mat.channels()==1)

    std::vector< Point > ptHull2;
    std::vector<int>::iterator ii=ihull.begin();
    while( ii!=ihull.end() )
    {
        int idx=(*ii);
        ptHull2.push_back( c[idx] );
        ii++;
    }
    cv::polylines( mat, c, true, Scalar( 0xCC,0xCC,0xCC ), 1 );
    cv::polylines( mat, ptHull2, true, Scalar( 0xFF, 0x20, 0x20 ), 1 );

    std::vector<Vec4i>::iterator d=defects.begin();
    while( d!=defects.end() )
    {
        Vec4i& v=(*d); d++;
        int startidx=v[0]; Point ptStart( c[startidx] );
        int endidx=v[1]; Point ptEnd( c[endidx] );
        int faridx=v[2]; Point ptFar( c[faridx] );

        cv::circle( img, ptStart, 4, Scalar( 0x02,0x60,0xFF ), 2 );
        cv::circle( img, ptEnd,   4, Scalar( 0xFF,0x60,0x02 ), 2 );
        cv::circle( img, ptFar,   4, Scalar( 0x60,0xFF,0x02 ), 2 );
    }
}

}