web-dev-qa-db-ja.com

opencvで半円を検出

画像内の完全な円と半円を検出しようとしています。enter image description here

私は以下の手順に従っています:画像の処理(Canny Edgeの検出を含む)輪郭を見つけて空の画像に描画し、不要な成分を除去します。 (処理された画像はまさに私が望むものです。)HoughCirclesを使用して円を検出します。そして、これは私が得るものです。

enter image description here

HoughCirclesでパラメーターを変えてみましたが、照明と画像内の円の位置に基づいて変化するため、結果は一貫していません。サイズに基づいてサークルを承認または拒否します。そのため、結果は受け入れられません。また、「受け入れられる」サークルのリストが長いため、HoughCircle paramsにいくらかの余裕が必要です。完全な円に関しては、簡単です。輪郭の「丸み」を簡単に見つけることができます。問題は半円です!

ハフ変換の前に編集した画像を見つけてくださいenter image description here

28
harsh

画像に直接houghCircleを使用します。最初にエッジを抽出しないでください。次に、検出された円ごとに、画像に実際に存在する割合をテストします。

int main()
{
    cv::Mat color = cv::imread("../houghCircles.png");
    cv::namedWindow("input"); cv::imshow("input", color);

    cv::Mat canny;

    cv::Mat gray;
    /// Convert it to gray
    cv::cvtColor( color, gray, CV_BGR2GRAY );

    // compute canny (don't blur with that image quality!!)
    cv::Canny(gray, canny, 200,20);
    cv::namedWindow("canny2"); cv::imshow("canny2", canny>0);

    std::vector<cv::Vec3f> circles;

    /// Apply the Hough Transform to find the circles
    cv::HoughCircles( gray, circles, CV_HOUGH_GRADIENT, 1, 60, 200, 20, 0, 0 );

    /// Draw the circles detected
    for( size_t i = 0; i < circles.size(); i++ ) 
    {
        Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
        int radius = cvRound(circles[i][2]);
        cv::circle( color, center, 3, Scalar(0,255,255), -1);
        cv::circle( color, center, radius, Scalar(0,0,255), 1 );
    }

    //compute distance transform:
    cv::Mat dt;
    cv::distanceTransform(255-(canny>0), dt, CV_DIST_L2 ,3);
    cv::namedWindow("distance transform"); cv::imshow("distance transform", dt/255.0f);

    // test for semi-circles:
    float minInlierDist = 2.0f;
    for( size_t i = 0; i < circles.size(); i++ ) 
    {
        // test inlier percentage:
        // sample the circle and check for distance to the next Edge
        unsigned int counter = 0;
        unsigned int inlier = 0;

        cv::Point2f center((circles[i][0]), (circles[i][1]));
        float radius = (circles[i][2]);

        // maximal distance of inlier might depend on the size of the circle
        float maxInlierDist = radius/25.0f;
        if(maxInlierDist<minInlierDist) maxInlierDist = minInlierDist;

        //TODO: maybe paramter incrementation might depend on circle size!
        for(float t =0; t<2*3.14159265359f; t+= 0.1f) 
        {
            counter++;
            float cX = radius*cos(t) + circles[i][0];
            float cY = radius*sin(t) + circles[i][1];

            if(dt.at<float>(cY,cX) < maxInlierDist) 
            {
                inlier++;
                cv::circle(color, cv::Point2i(cX,cY),3, cv::Scalar(0,255,0));
            } 
           else
                cv::circle(color, cv::Point2i(cX,cY),3, cv::Scalar(255,0,0));
        }
        std::cout << 100.0f*(float)inlier/(float)counter << " % of a circle with radius " << radius << " detected" << std::endl;
    }

    cv::namedWindow("output"); cv::imshow("output", color);
    cv::imwrite("houghLinesComputed.png", color);

    cv::waitKey(-1);
    return 0;
}

この入力の場合:

enter image description here

次の出力が得られます。

enter image description here

赤い丸はハフの結果です。

円上の緑色のサンプリングされたドットはインライアです。

青い点は外れ値です。

コンソール出力:

100 % of a circle with radius 27.5045 detected
100 % of a circle with radius 25.3476 detected
58.7302 % of a circle with radius 194.639 detected
50.7937 % of a circle with radius 23.1625 detected
79.3651 % of a circle with radius 7.64853 detected

ハフではなくRANSACをテストする場合は、 this をご覧ください。

34
Micka

これを行う別の方法、シンプルなRANSACバージョン(速度を向上させるために多くの最適化を行う必要があります)は、エッジイメージで機能します。

メソッドは、キャンセルされるまでこれらのステップをループします

  1. ランダムに3エッジピクセルを選択
  2. それらから円を推定します(円を識別するには3ポイントで十分です)
  3. それが実際に円であることを検証または偽造する:与えられたエッジによって表される円の割合を数える
  4. 円が検証された場合、入力/例から円を削除します

    int main()
    {
    //RANSAC
    
    //load Edge image
    cv::Mat color = cv::imread("../circleDetectionEdges.png");
    
    // convert to grayscale
    cv::Mat gray;
    cv::cvtColor(color, gray, CV_RGB2GRAY);
    
    // get binary image
    cv::Mat mask = gray > 0;
    //erode the edges to obtain sharp/thin edges (undo the blur?)
    cv::erode(mask, mask, cv::Mat());
    
    std::vector<cv::Point2f> edgePositions;
    edgePositions = getPointPositions(mask);
    
    // create distance transform to efficiently evaluate distance to nearest Edge
    cv::Mat dt;
    cv::distanceTransform(255-mask, dt,CV_DIST_L1, 3);
    
    //TODO: maybe seed random variable for real random numbers.
    
    unsigned int nIterations = 0;
    
    char quitKey = 'q';
    std::cout << "press " << quitKey << " to stop" << std::endl;
    while(cv::waitKey(-1) != quitKey)
    {
        //RANSAC: randomly choose 3 point and create a circle:
        //TODO: choose randomly but more intelligent, 
        //so that it is more likely to choose three points of a circle. 
        //For example if there are many small circles, it is unlikely to randomly choose 3 points of the same circle.
        unsigned int idx1 = Rand()%edgePositions.size();
        unsigned int idx2 = Rand()%edgePositions.size();
        unsigned int idx3 = Rand()%edgePositions.size();
    
        // we need 3 different samples:
        if(idx1 == idx2) continue;
        if(idx1 == idx3) continue;
        if(idx3 == idx2) continue;
    
        // create circle from 3 points:
        cv::Point2f center; float radius;
        getCircle(edgePositions[idx1],edgePositions[idx2],edgePositions[idx3],center,radius);
    
        float minCirclePercentage = 0.4f;
    
        // inlier set unused at the moment but could be used to approximate a (more robust) circle from alle inlier
        std::vector<cv::Point2f> inlierSet;
    
        //verify or falsify the circle by inlier counting:
        float cPerc = verifyCircle(dt,center,radius, inlierSet);
    
        if(cPerc >= minCirclePercentage)
        {
            std::cout << "accepted circle with " << cPerc*100.0f << " % inlier" << std::endl;
            // first step would be to approximate the circle iteratively from ALL INLIER to obtain a better circle center
            // but that's a TODO
    
            std::cout << "circle: " << "center: " << center << " radius: " << radius << std::endl;
            cv::circle(color, center,radius, cv::Scalar(255,255,0),1);
    
            // accept circle => remove it from the Edge list
            cv::circle(mask,center,radius,cv::Scalar(0),10);
    
            //update Edge positions and distance transform
            edgePositions = getPointPositions(mask);
            cv::distanceTransform(255-mask, dt,CV_DIST_L1, 3);
        }
    
        cv::Mat tmp;
        mask.copyTo(tmp);
    
        // prevent cases where no fircle could be extracted (because three points collinear or sth.)
        // filter NaN values
        if((center.x == center.x)&&(center.y == center.y)&&(radius == radius))
        {
            cv::circle(tmp,center,radius,cv::Scalar(255));
        }
        else
        {
            std::cout << "circle illegal" << std::endl;
        }
    
        ++nIterations;
        cv::namedWindow("RANSAC"); cv::imshow("RANSAC", tmp);
    }
    
    std::cout << nIterations <<  " iterations performed" << std::endl;
    
    
    cv::namedWindow("edges"); cv::imshow("edges", mask);
    cv::namedWindow("color"); cv::imshow("color", color);
    
    cv::imwrite("detectedCircles.png", color);
    cv::waitKey(-1);
    return 0;
    }
    
    
    float verifyCircle(cv::Mat dt, cv::Point2f center, float radius, std::vector<cv::Point2f> & inlierSet)
    {
     unsigned int counter = 0;
     unsigned int inlier = 0;
     float minInlierDist = 2.0f;
     float maxInlierDistMax = 100.0f;
     float maxInlierDist = radius/25.0f;
     if(maxInlierDist<minInlierDist) maxInlierDist = minInlierDist;
     if(maxInlierDist>maxInlierDistMax) maxInlierDist = maxInlierDistMax;
    
     // choose samples along the circle and count inlier percentage
     for(float t =0; t<2*3.14159265359f; t+= 0.05f)
     {
         counter++;
         float cX = radius*cos(t) + center.x;
         float cY = radius*sin(t) + center.y;
    
         if(cX < dt.cols)
         if(cX >= 0)
         if(cY < dt.rows)
         if(cY >= 0)
         if(dt.at<float>(cY,cX) < maxInlierDist)
         {
            inlier++;
            inlierSet.Push_back(cv::Point2f(cX,cY));
         }
     }
    
     return (float)inlier/float(counter);
    }
    
    
    inline void getCircle(cv::Point2f& p1,cv::Point2f& p2,cv::Point2f& p3, cv::Point2f& center, float& radius)
    {
      float x1 = p1.x;
      float x2 = p2.x;
      float x3 = p3.x;
    
      float y1 = p1.y;
      float y2 = p2.y;
      float y3 = p3.y;
    
      // PLEASE CHECK FOR TYPOS IN THE FORMULA :)
      center.x = (x1*x1+y1*y1)*(y2-y3) + (x2*x2+y2*y2)*(y3-y1) + (x3*x3+y3*y3)*(y1-y2);
      center.x /= ( 2*(x1*(y2-y3) - y1*(x2-x3) + x2*y3 - x3*y2) );
    
      center.y = (x1*x1 + y1*y1)*(x3-x2) + (x2*x2+y2*y2)*(x1-x3) + (x3*x3 + y3*y3)*(x2-x1);
      center.y /= ( 2*(x1*(y2-y3) - y1*(x2-x3) + x2*y3 - x3*y2) );
    
      radius = sqrt((center.x-x1)*(center.x-x1) + (center.y-y1)*(center.y-y1));
    }
    
    
    
    std::vector<cv::Point2f> getPointPositions(cv::Mat binaryImage)
    {
     std::vector<cv::Point2f> pointPositions;
    
     for(unsigned int y=0; y<binaryImage.rows; ++y)
     {
         //unsigned char* rowPtr = binaryImage.ptr<unsigned char>(y);
         for(unsigned int x=0; x<binaryImage.cols; ++x)
         {
             //if(rowPtr[x] > 0) pointPositions.Push_back(cv::Point2i(x,y));
             if(binaryImage.at<unsigned char>(y,x) > 0) pointPositions.Push_back(cv::Point2f(x,y));
         }
     }
    
     return pointPositions;
    }
    

入力:

enter image description here

出力:

enter image description here

コンソール出力:

    press q to stop
    accepted circle with 50 % inlier
    circle: center: [358.511, 211.163] radius: 193.849
    accepted circle with 85.7143 % inlier
    circle: center: [45.2273, 171.591] radius: 24.6215
    accepted circle with 100 % inlier
    circle: center: [257.066, 197.066] radius: 27.819
    circle illegal
    30 iterations performed`

最適化には以下を含める必要があります。

  1. すべてのインライアを使用して、より良い円に適合させる

  2. 検出された各円の後に距離変換を計算しないでください(非常に高価です)。ポイント/エッジセットから直接インライアを計算し、そのリストからインライアエッジを削除します。

  3. 画像に小さな円が多数ある場合(および/またはノイズが多い場合)、3つのEdgeピクセルまたは円にランダムにヒットすることはほとんどありません。 =>最初に輪郭検出を試し、各輪郭の円を検出します。その後、画像に残っているすべての「その他」の円を検出してください。

  4. 他の多くのもの

10
Micka

私はそれが少し遅れていることを知っていますが、はるかに簡単な別のアプローチを使用しました。 cv2.HoughCircles(...)から、円の中心と直径(x、y、r)を取得します。したがって、円のすべての中心点を通過し、円の直径よりも画像のエッジから遠く離れているかどうかを確認します。

ここに私のコードがあります:

        height, width = img.shape[:2]

        #test top Edge
        up = (circles[0, :, 0] - circles[0, :, 2]) >= 0

        #test left Edge
        left = (circles[0, :, 1] - circles[0, :, 2]) >= 0

        #test right Edge
        right = (circles[0, :, 0] + circles[0, :, 2]) <= width

        #test bottom Edge
        down = (circles[0, :, 1] + circles[0, :, 2]) <= height

        circles = circles[:, (up & down & right & left), :]
0
hory

ハフアルゴリズムによって検出された半円は、おそらく正しいものです。ここでの問題は、シーンのジオメトリ、つまりターゲットに対するカメラの正確な位置を厳密に制御しない限り、画像軸がターゲット平面に垂直になると、画像に投影される円ではなく楕円が表示されることです。飛行機。光学系によって引き起こされる歪みは言うまでもなく、幾何学的図形をさらに劣化させます。ここで精度に依存する場合は、 カメラキャリブレーション をお勧めします。

0
brunocodutra

別のkernelgaussian blurで試してみることをお勧めします。

_GaussianBlur( src_gray, src_gray, Size(11, 11), 5,5);
_

size(i,i),j,j)を変更します

0
sandeep