opencv अवतल पतवार खोजने



image-processing interpolation (1)

मेरे पास एक छवि में दिखाए गए अलग-अलग बिंदुओं का एक सेट है, जैसे निम्नलिखित

मैं पुनर्निर्माण करना चाहता हूं या नमूनाकरण करना चाहता हूं (मुझे यकीन नहीं है कि छवि का वर्णन करने का सही तरीका क्या है), ताकि परिणाम का चित्र निम्न जैसा होगा । यह उदाहरण की छवि के समान बिल्कुल नहीं होना चाहिए, लेकिन मूल विचार को मूल एक को भरना है।

मुझे यह कैसे करना है इसके बारे में एक प्रारंभिक विचार है लेकिन मुझे नहीं पता कि यह पहला कदम के बाद कैसे करना है। मेरा विचार है कि कमेन्ट्स का उपयोग करने वाली पहली अलग छवि है और विभिन्न ऑब्जेक्ट्स खोजें। और मैंने सफलतापूर्वक इसे किया है। केमेन्स के परिणामस्वरूप छवियां हैं: ।

कमेन्स के बाद, मैं इन आकृतियों की रूपरेखा प्राप्त करने के लिए समोच्च या अंतराल की तरह कुछ ढूंढना चाहता हूं और फ्लेक्स छेद जैसे कार्यों का उपयोग करके आकार भरना चाहता हूं। हालांकि, मुझे "कंटूर लगता है" काम नहीं करता, यह एक समोच्च के रूप में प्रत्येक एकल पिक्सेल पर विचार करेगा।

दूसरी तरफ मैं सोच रहा हूं कि प्रक्षेप का उपयोग करना है लेकिन मुझे यकीन नहीं है कि यह इतने विरल अंक के साथ संभव है या नहीं। क्या किसी को कैसे यह करने के बारे में कोई विचार है? मुझे यकीन नहीं है कि मैं सही रास्ते पर हूं और मैं किसी भी समाधान के लिए खुला हूँ

आपका बहुत बहुत धन्यवाद!


रूपात्मक परिवर्तनों पर एक नज़र डालें मैं बड़े कर्नेल का उपयोग कर एक फैलाव संचालन के साथ शुरू होगा, एक आकार (15,15) के साथ MORPH_ELLIPSE कहें बाद में, पतले परत एक ही आकार कर्नेल के साथ एरोजियन ऑपरेशन का उपयोग करके नीचे वापस आते हैं। डॉक्स पर एक नज़र डालें ध्यान दें कि ओपनसीवी भी श्रृंखलित या अनुक्रमित, रूपवाचक आपरेशनों को भी प्रदान करता है। यहां देखें फिर आप देखेंगे कि मेरा सुझाव एक "समापन" ऑपरेशन है

अपडेट: मैंने छवि में दिखाए गए परिणामों को प्राप्त करने के लिए सरल फैलाव और contouring के साथ प्रयोग किया। परिणाम समस्या की सामान्य आवश्यकताओं को पूरा करने के लिए दिखाई देते हैं।

इसी तरह, एप्लिकेशन के लिए क्या "वास्तविक समय" का अर्थ निर्दिष्ट नहीं है, लेकिन यह संचालन कार्य शीघ्रता से कार्यान्वित किया जा सकता है और आसानी से 30fps आवेदन पर लागू किया जा सकता है।

कोड स्निपेट नीचे:

// Convert image to grayscale
cvtColor(src, gray, CV_BGR2GRAY);
threshold(gray, gray, 128.0, 128.0, THRESH_BINARY);

// Dilate to fill holes
dilate(gray, dest, getStructuringElement(MORPH_ELLIPSE, Size(13,13)));

// Find contours
vector<vector<Point> > contours;
vector<Vec4i> hierarchy;
findContours(dest, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0,0)); 

  // Prune contours
  float maxArea = 0.0f;
  for (size_t i = 0; i< contours.size(); i++)
     {
       if (contourArea(contours[i]) >= maxArea)
         {
            maxArea = contourArea(contours[i]);
         }
     } 

  float minArea = 0.20f * maxArea;
  vector<vector<Point> > prunedContours;
  for (size_t i = 0; i< contours.size(); i++)
     {
       if (contourArea(contours[i]) >= minArea)
         {
           prunedContours.push_back(contours[i]);
         }
     }

// Smooth the contours
vector<vector<Point> > smoothedContours;
  smoothedContours.resize(prunedContours.size());
  for (size_t i=0;i<prunedContours.size();i++)
    {
    vector<float> x;
    vector<float> y;

    const size_t n = prunedContours[i].size();

    for (size_t j=0;j<n;j++)
      {
        x.push_back(prunedContours[i][j].x);
        y.push_back(prunedContours[i][j].y);
      }

    Mat G;
    transpose(getGaussianKernel(11,4.0,CV_32FC1),G);

    vector<float> xSmooth;
    vector<float> ySmooth;

    filter2D(x,xSmooth, CV_32FC1, G);
    filter2D(y,ySmooth, CV_32FC1, G);

    for (size_t j=0;j<n;j++)
      {
        smoothedContours[i].push_back(Point2f(xSmooth[j],ySmooth[j]));
      }
    }




concave