किसी अल्फा पारदर्शी छवि के चारों ओर एक रूपरेखा या स्ट्रोक ड्राइंग के लिए एल्गोरिदम

Question

यह सुनिश्चित नहीं है कि इस एल्गोरिदम के लिए कोई नाम है या नहीं, मैं वर्तमान में विकास कर रहा हूं - "बढ़ते पड़ोस एल्गोरिदम" उचित नाम की तरह लगता है। तो मेरी समस्या क्या है?

मैं इसे रूपरेखा के लिए अल्फा पारदर्शी छवि के चारों ओर एक स्ट्रोक खींचना चाहता हूं। स्ट्रोक का आकार उपयोगकर्ता-परिभाषित होना चाहिए।

मेरे पास एक सरणी है जो शून्य और किसी से भरी हुई है, सरणी के प्रत्येक आइटम को जीवन के खेल जैसे सेल के रूप में मानें। 0 वाला एक आइटम खाली है (पारदर्शी पिक्सेल), 1 वाला आइटम 1 पीढ़ी वाला सेल (गैर पारदर्शी पिक्सेल) है, पीढ़ियों की संख्या को आसपास के स्ट्रोक के आकार से परिभाषित किया जाता है।

0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 1 1 1 1 0 0 0 
0 0 0 1 1 1 1 0 0 0 
0 0 0 1 1 1 1 0 0 0 
0 0 0 1 1 1 1 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 

तो मैं लोगों को हर 0 पीढ़ी मूर पड़ोसी आसपास के द्वारा एक नई पीढ़ी बढ़ने जाने के लिए करना चाहते हैं:

यह उदाहरण अल्फा मूल्यों से घिरा हुआ एक आयत दर्शाया गया है। यह दूसरी पीढ़ी (1px साथ स्ट्रोक) है - इस प्रकार सरणी के बाद के रूप में बढ़ रहा है इस प्रकार है:

0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 2 2 2 2 2 2 0 0 
0 0 2 1 1 1 1 2 0 0 
0 0 2 1 1 1 1 2 0 0 
0 0 2 1 1 1 1 2 0 0 
0 0 2 1 1 1 1 2 0 0 
0 0 2 2 2 2 2 2 0 0 
0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 

3 और 4 पीढ़ी (3px साथ स्ट्रोक):

4 4 4 4 4 4 4 4 4 4 
4 3 3 3 3 3 3 3 3 4 
4 3 2 2 2 2 2 2 3 4 
4 3 2 1 1 1 1 2 3 4 
4 3 2 1 1 1 1 2 3 4 
4 3 2 1 1 1 1 2 3 4 
4 3 2 1 1 1 1 2 3 4 
4 3 2 2 2 2 2 2 3 4 
4 3 3 3 3 3 3 3 3 4 
4 4 4 4 4 4 4 4 4 4 

अब तक तो अच्छा। मैं निम्नलिखित कोड का टुकड़ा द्वारा इस सरल कार्य को प्राप्त करने हूँ:

for (int gen = 1; gen <= 4; gen++) 
{ 
    for (int x = 1; x < arrayWidth - 1; x++) 
    { 
     for (int y = 1; y < arrayHeight - 1; y++) 
     { 
      // See if this cell is in the current generation. 
      if (_generation[x + arrayWidth * y] == gen) 
      { 
       // Generate next generation. 
       for (int i = x - 1; i <= x + 1; i++) 
       { 
        for (int j = y - 1; j <= y + 1; j++) 
        { 
         if (_generation[i + arrayWidth * j] == 0 || _generation[i + arrayWidth * j] > gen) 
         { 
          _generation[i + arrayWidth * j] = gen + 1; 
         } 
        } 
       } 
      } 
     } 
    } 
} 

यह दृष्टिकोण उदाहरण के लिए एक आयत की तरह साधारण आकार के लिए पूरी तरह से काम करता है। लेकिन मैं इसे अंडाकार के लिए कैसे कर सकता हूं? जैसे ही हम कोशिकाओं में एक सीढ़ी पैटर्न की तरह के रूप में, मैं हो रही है गंदा परिणाम:

0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 1 1 1 1 0 0 0 0 0 
0 0 0 0 1 1 1 1 1 1 0 0 0 0 
0 0 0 1 1 1 1 1 1 1 1 0 0 0 
0 0 1 1 1 1 1 1 1 1 1 1 0 0 
0 0 1 1 1 1 1 1 1 1 1 1 0 0 
0 0 1 1 1 1 1 1 1 1 1 1 0 0 
0 0 1 1 1 1 1 1 1 1 1 1 0 0 
0 0 1 1 1 1 1 1 1 1 1 1 0 0 
0 0 0 1 1 1 1 1 1 1 1 0 0 0 
0 0 0 0 1 1 1 1 1 1 0 0 0 0 
0 0 0 0 0 1 1 1 1 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 

0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 2 2 2 2 2 2 0 0 0 0 
0 0 0 2 2 1 1 1 1 2 2 0 0 0 
0 0 2 2 1 1 1 1 1 1 2 2 0 0 
0 2 2 1 1 1 1 1 1 1 1 2 2 0 
0 2 1 1 1 1 1 1 1 1 1 1 2 0 
0 2 1 1 1 1 1 1 1 1 1 1 2 0 
0 2 1 1 1 1 1 1 1 1 1 1 2 0 
0 2 1 1 1 1 1 1 1 1 1 1 2 0 
0 2 1 1 1 1 1 1 1 1 1 1 2 0 
0 2 2 1 1 1 1 1 1 1 1 2 0 0 
0 0 2 2 1 1 1 1 1 1 2 2 0 0 
0 0 0 2 2 1 1 1 1 2 2 0 0 0 
0 0 0 0 2 2 2 2 2 2 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 

0 0 0 3 3 3 3 3 3 3 3 0 0 0 
0 0 3 3 2 2 2 2 2 2 3 3 0 0 
0 3 3 2 2 1 1 1 1 2 2 3 3 0 
3 3 2 2 1 1 1 1 1 1 2 2 3 3 
3 2 2 1 1 1 1 1 1 1 1 2 2 3 
3 2 1 1 1 1 1 1 1 1 1 1 2 3 
3 2 1 1 1 1 1 1 1 1 1 1 2 3 
3 2 1 1 1 1 1 1 1 1 1 1 2 3 
3 2 1 1 1 1 1 1 1 1 1 1 2 3 
3 2 1 1 1 1 1 1 1 1 1 1 2 3 
3 2 2 1 1 1 1 1 1 1 1 2 2 3 
3 3 2 2 1 1 1 1 1 1 2 2 3 3 
0 3 3 2 2 1 1 1 1 2 2 3 3 0 
0 0 3 3 2 2 2 2 2 2 3 3 0 0 
0 0 0 3 3 3 3 3 3 3 3 0 0 0 

जब एक अंडाकार को यह एल्गोरिथ्म को लागू करने, रूपरेखा इस समस्या (बाएं की वजह से थोड़े अजीब लग रहा है: एल्गोरिथ्म परिणाम , सही: अनुरोध परिणाम):

1 0 0 0 0 0 0 1 
0 1 0 0 0 0 1 0 
0 0 1 0 0 1 0 0 
0 0 0 1 1 0 0 0 

:

समस्या यहाँ है कि मैं उन 2 2 और 3 3 डुप्लिकेट ब्लॉक जो हर बार जब मैं इस "सीढ़ी" पैटर्न है घटित नहीं करना चाहती है

मैं चाहता हूँ ऊपर 2 और 3 री पीढ़ी गणना इस तरह दिखेगा:

0 0 0 0 0 0 0 0 0 0 0 0 0 0 
0 0 0 0 0 2 2 2 2 0 0 0 0 0 
0 0 0 0 2 1 1 1 1 2 0 0 0 0 
0 0 0 2 1 1 1 1 1 1 2 0 0 0 
0 0 2 1 1 1 1 1 1 1 1 2 0 0 
0 2 1 1 1 1 1 1 1 1 1 1 2 0 
0 2 1 1 1 1 1 1 1 1 1 1 2 0 
0 2 1 1 1 1 1 1 1 1 1 1 2 0 
0 2 1 1 1 1 1 1 1 1 1 1 2 0 
0 2 1 1 1 1 1 1 1 1 1 1 2 0 
0 0 2 1 1 1 1 1 1 1 1 2 0 0 
0 0 0 2 1 1 1 1 1 1 2 0 0 0 
0 0 0 0 2 1 1 1 1 2 0 0 0 0 
0 0 0 0 0 2 2 2 2 0 0 0 0 0 
0 0 0 0 0 0 0 0 0 0 0 0 0 0 

0 0 0 0 0 3 3 3 3 0 0 0 0 0 
0 0 0 0 3 2 2 2 2 2 3 0 0 0 
0 0 0 3 2 1 1 1 1 2 3 0 0 0 
0 0 3 2 1 1 1 1 1 1 2 3 0 0 
0 3 2 1 1 1 1 1 1 1 1 2 3 0 
3 2 1 1 1 1 1 1 1 1 1 1 2 3 
3 2 1 1 1 1 1 1 1 1 1 1 2 3 
3 2 1 1 1 1 1 1 1 1 1 1 2 3 
3 2 1 1 1 1 1 1 1 1 1 1 2 3 
3 2 1 1 1 1 1 1 1 1 1 1 2 3 
0 3 2 1 1 1 1 1 1 1 1 2 3 0 
0 0 3 2 1 1 1 1 1 1 2 3 0 0 
0 0 0 3 2 1 1 1 1 2 3 0 0 0 
0 0 0 3 2 2 2 2 2 2 3 0 0 0 
0 0 0 0 3 3 3 3 3 3 0 0 0 0 

मैं उन नकली सेल ब्लॉक को फ़िल्टर करने के कई तरीकों की कोशिश की है, लेकिन मैं हल करने के लिए एक आसान और सामान्य समाधान नहीं मिल सकता है मुसीबत।

कोई विचार है कि मुझे फ़ोटोशॉप या पेंट.नेट से जैसे स्ट्रोक/रूपरेखा कैसे प्राप्त करें?

धन्यवाद!

चीयर्स पी

Answer 1

उचित नाम dilation रूपात्मक संचालन की जाँच करता है। आपको सर्कल तत्व के साथ फैलाव का प्रयास करना चाहिए, यह आपको अनुरोधित परिणाम देगा।

यहाँ एक Matlab कोड से पता चलता है कि यह कैसे किया जाता है है:

im = imcircle(70); 
im = padarray(im,[20,20]); 
figure;imshow(im); 
im2 = imdilate(im,strel('disk',8)); 
figure;imshow(im2);