défauts de convexité C ++ opencv

Question

Je serais reconnaissant si vous pouviez me aider avec cette question:)

relative à cette question dans OpenCV 2.X / C ++? , je ont le même problème. Le OpenCV C ++ emballage n'a pas la fonction cvConvexityDefects qui apparaît dans la version C, alors j'ai essayé d'écrire ma propre version.

Une partie du code est (s'il vous plaît noter que les deux Countour et la coque sont vecteur , calculé séparément:

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);

La sortie est Convex hull must represented as a sequence of indices or sequence of pointers in function cvConvexityDefects. Vraiment, je ne sais pas comment faire la conversion de la bonne façon, j'ai ben recherche sur le web et essayé d'adapter / copier / comprendre certains morceaux de code, mais il est toujours avec la syntaxe C.

J'espère avoir été clair. Merci d'avance!

Answer 1

Je soulevé cette question parce que je ne pouvais pas trouver une solution (il est non seulement aujourd'hui que je traite de la question hehe), mais après tout ce que j'été en mesure de gérer le problème!

I eu à changer la façon dont je calcule la coque convexe, en utilisant la forme de tableau d'index. Alors maintenant, nous avons un vecteur à la place un vecteur .

Ce code je (cela fonctionne, je peignais les points sur une image):

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);
    }
}

Cela a fonctionné pour moi. Si vous constatez une erreur ou d'une autre façon de le gérer, s'il vous plaît me dire!

Answer 2

a trouvé une approche directe en utilisant les convexityDefects cpp. Typehandling par fonction enveloppe convexe. Il remplit par type, int * renvoie indizes, point * coordonnées renvoie.

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 );
    }
}

}