वस्तु का पता लगाने के बाद पिक्सल की रूपरेखा (उत्तल पतवार के बिना)

विचार अंदर की छवि का पता लगाने के लिए grabcut (OpenCV) का उपयोग करना है एक आयत और Direct2D के साथ एक ज्यामिति बनाएँ।

मेरी परीक्षण छवि यह है:

ग्रैब कट करने के बाद, जिसके परिणामस्वरूप यह छवि है:

विचार इसे रेखांकित करना है। मैं बाहर करने के लिए अस्पष्टता ब्रश का उपयोग कर सकता हूं यह पृष्ठभूमि से है, लेकिन मैं अपने संपादक (बहुभुज, लासो, आयत, आदि) में अन्य सभी चयनों की तरह इस पर ज्यामिति को जोड़ने/चौड़ा/गठबंधन करने में सक्षम होने के लिए एक ज्यामितीय ब्रश का उपयोग करना चाहता हूं।

यदि मैं उत्तल पतवार एल्गोरिथ्म को बिंदुओं पर लागू करता हूं, तो मुझे यह मिलता है:

जो निश्चित रूप से मेरे मामले के लिए वांछित नहीं है। मैं छवि को कैसे रेखांकित करूं?

ग्रैबकट से छवि प्राप्त करने के बाद, मैं ल्यूमिनेंस के आधार पर अंक रखता हूं:

DWORD* pixels = ...
    for (UINT y = 0; y < he; y++)
    {
        for (UINT x = 0; x < wi; x++)
        {
            DWORD& col = pixels[y * wi + x];
            auto lumthis = lum(col);
            if (lumthis > Lum_Threshold)
            {
                points.push_back({x,y});
            }
        }
    }

फिर मैं वाई और एक्स पर अंक क्रमबद्ध करता हूं:

std::sort(points.begin(), points.end(), [](D2D1_POINT_2F p1, D2D1_POINT_2F p2) -> bool
        {
            if (p1.y < p2.y)
                return true;
            if ((int)p1.y == (int)p2.y && p1.x < p2.x)
                return true;
            return false;
        });

फिर, प्रत्येक पंक्ति के लिए (ऊपर Y से bototm Y तक उपरोक्त बिंदु सरणी को पार करते हुए) मैं प्रत्येक पंक्ति के लिए "समूह" बनाता हूं:

    struct SECTION
    {
        float left = 0, right = 0;
    };
    auto findgaps = [](D2D1_POINT_2F* p,size_t n) -> std::vector<SECTION>
    {
        std::vector<SECTION> j;
        SECTION* jj = 0;

        for (size_t i = 0; i < n; i++)
        {
            if (i == 0)
            {
                SECTION jp;
                jp.left = p[i].x;
                jp.right = p[i].x;
                j.push_back(jp);
                jj = &j[j.size() - 1];
                continue;
            }
            if ((p[i].x - jj->right) < 1.5f)
            {
                jj->right = p[i].x;
            }
            else
            {
                SECTION jp;
                jp.left = p[i].x;
                jp.right = p[i].x;
                j.push_back(jp);
                jj = &j[j.size() - 1];
            }

        }

        return j;
    };

मैं इस बिंदु पर फंस गया हूँ। मुझे पता है कि अंकों के मनमाने सेट से कई बहुभुज संभव हैं, लेकिन मेरे मामले में बिंदुओं ने परिभाषित किया है कि "बाएं" क्या है और "दाएं" क्या है। मैं यहाँ से कैसे आगे बढ़ूँगा?