रोबोट लोडर प्रोजेक्ट: ओरिएंटेशन परिभाषा

एक महीने पहले, मैंने अपने रोबोट लोडर के बारे में लिखा था जो खुद की स्थिति का निर्धारण करता है। (यह अफ़सोस की बात है, मैंने शनिवार की रात एक असफल समय पर उस लेख को पोस्ट किया, इसलिए बहुत कम लोगों ने इसे देखा।) जैसा कि मैंने उल्लेख किया है, पहिया सेंसर की रीडिंग रोबोट को अपनी स्थिति को काफी सटीक रूप से निर्धारित करने की अनुमति देती है - रोबोट के किसी भी बारकोड को स्कैन करते ही धीरे-धीरे जमा होने वाली त्रुटि ठीक हो जाती है। गोदाम की अलमारियों से। दूसरी ओर, संचित दिशात्मक त्रुटि को ठीक करने के लिए कुछ भी नहीं था।

मैंने मानविकी लड़की के साथ अपनी कठिनाइयों पर चर्चा की और पूछा कि अंतरिक्ष में अभिविन्यास के क्या तरीके हैं जो वह जानती थी। उनके अनुसार, लंदन म्यूजियम ऑफ साइंस में, उन्होंने अपने सिर के ऊपर की तरफ चींटियों के उन्मुखीकरण के लिए एक प्रदर्शनी को समर्पित पाया। आगंतुकों को एक दर्पण लेने और कमरे में घूमने के लिए आमंत्रित किया गया था, छत पर दर्पण के पैटर्न को देखते हुए और केवल उन पर ध्यान केंद्रित किया। (एक छत का नक्शा संलग्न था।)

मैंने जाँच करने का निर्णय लिया: गोदाम की छत पर मेरा रोबोट क्या देखता है?


इतनी कम गुणवत्ता वाली रिकॉर्डिंग पर भी, लंबी आयताकार खिड़कियां पूरी तरह से अलग हैं। वे सभी, निश्चित रूप से, गोदाम की कुल्हाड़ियों में से एक के समानांतर हैं, जिसका अर्थ है कि वे अलमारियों की पंक्तियों के समानांतर हैं। यह पता चला है कि अगर कोई खिड़की फ्रेम में मिलती है और मैं इसकी दिशा निर्धारित कर सकता हूं, तो मुझे रोबोट की दिशा 180 डिग्री की सटीकता के साथ मिलती है। गोदाम में कहीं से भी विंडोज दिखाई नहीं देता है, लेकिन आवधिक पाठ्यक्रम सुधार के लिए - वे काफी बार फ्रेम में आते हैं।

पैटर्न की मान्यता में, मैं एक विशेषज्ञ नहीं हूं, और पहली चीज जो मैंने Q & A में पूछी थी कि क्या आयताकार खिड़कियों की मान्यता के लिए कुछ भी तैयार था, उदाहरण के लिए, OpenCV लागू है? दुर्भाग्य से, उन्होंने मुझे कुछ भी समझदार नहीं बताया - जो लोग "जानते" हैं, उन्होंने इसे चायदानी पर चबाने के लिए अपनी गरिमा से कम पाया।

अमेरिकन फ़ोरम: मैंने एक प्रश्न पूछा - आपको एक उत्तर मिलता है।
इजरायल फोरम: एक सवाल पूछा - एक सवाल मिलता है।
रूसी मंच: एक सवाल पूछा - वे आपको समझाएंगे कि आप एक गधे हैं।

इसके अलावा, रोबोट को Microsoft रोबोटिक्स डेवलपमेंट स्टूडियो के तहत नियंत्रित किया गया था, लेकिन मुझे OpenCV के साथ काम करने के लिए एक समाप्त .NET असेंबली नहीं मिली - मैंने स्क्रैच से अपनी पहचान लिखने का फैसला किया। रॉकेट साइंस नहीं, चाय - बस चमकदार सफेद आयतों को पहचानें।

गोदाम की छत को रोबोट द्वारा कुछ इस तरह से देखा जाता है:


सबसे पहले, हम चमकदार सफेद खिड़की को अंधेरे पृष्ठभूमि से अलग करते हैं। हम RGB से YCbCr में अनुवाद करते हैं और Y = 227 द्वारा विभाजित करते हैं (थ्रेसहोल्ड को आनुभविक रूप से चुना गया था, और एक आदर्श दुनिया में इसे समग्र रूप से छवि की चमक द्वारा अनुकूल रूप से चुना जाएगा)। रास्ते के साथ, हम 640x480 की प्रारंभिक छवि को 320x440 तक कम करते हैं - यह हमारे लिए पर्याप्त है, और प्रसंस्करण चार गुना तेजी लाएगा।

कोड:

byte[] bytes = response.Frame; int stride = bytes.Length / height; byte[,] belong = (byte[,])Array.CreateInstance(typeof(byte), new int[] { 326, 246 }, new int[] { -3, -3 }); int Ythreshold = settings.Ythreshold; for (int y = 0; y < 240; y++) { int offset = stride * y * 2; for (int x = 0; x < 320; x++) { int blu = bytes[offset] + bytes[offset + 3] + bytes[offset + stride] + bytes[offset + stride + 3]; offset++; int grn = bytes[offset] + bytes[offset + 3] + bytes[offset + stride] + bytes[offset + stride + 3]; offset++; int red = bytes[offset] + bytes[offset + 3] + bytes[offset + stride] + bytes[offset + stride + 3]; offset += 4; belong[x, y] = (0.299 / 4 * red + 0.587 / 4 * grn + 0.114 / 4 * blu > Ythreshold ? (byte)1 : (byte)0); } } 

अलगाव के परिणामस्वरूप, निम्नलिखित छवि प्राप्त की जाती है:


सामान्य रूप से वीडियो छवियों में, एक सही ढंग से चयनित विंडो के अलावा, हमें चकाचौंध सतहों पर व्यक्तिगत पिक्सेल से शोर मिला, लेकिन एक ही समय में खिड़की के अंदर "पिक्सेल बाहर खटखटाए गए" जो पर्याप्त उज्ज्वल नहीं थे।

हम एक मीडियन फिल्टर के साथ शोर को हटाते हैं (हालांकि क्यूए में मुझे किसी कारण से गॉसियन ब्लर की सलाह दी गई थी। खैर, यहां क्या धब्बा है?) 3 पिक्सल के त्रिज्या के साथ और 21 में से 5 उज्ज्वल पिक्सल की एक सीमा की जांच की गई। इस तरह का एक फिल्टर उज्ज्वल क्षेत्रों के कनेक्शन के लिए "झुकाव" करता है, जिसके बीच अंधेरे पिक्सेल होते हैं - ताकि तीन ग्लास की हमारी खिड़की को एक आयत में जोड़ा जाए।

 private bool[,] filtered = (bool[,])Array.CreateInstance(typeof(bool), new int[] { 326, 246 }, new int[] { -3, -3 }); int medianThreshold = settings.MedianThreshold; for (int x = 0; x < 320; x++) for (int y = 0; y < 240; y++) filtered[x, y] = belong[x - 1, y - 2] + belong[x, y - 2] + belong[x + 1, y - 2] + belong[x - 2, y - 1] + belong[x - 1, y - 1] + belong[x, y - 1] + belong[x + 1, y - 1] + belong[x + 2, y - 1] + belong[x - 2, y * 1] + belong[x - 1, y * 1] + belong[x, y * 1] + belong[x + 1, y * 1] + belong[x + 2, y * 1] + belong[x - 2, y + 1] + belong[x - 1, y + 1] + belong[x, y + 1] + belong[x + 1, y + 1] + belong[x + 2, y + 1] + belong[x - 1, y + 2] + belong[x, y + 2] + belong[x + 1, y + 2] > medianThreshold; 

belong और filtered सरणियों के लिए आयाम - [-3..322, -3..242] - सूचकांक जांच से परेशान किए बिना इन सरणियों के साथ काम करने के लिए प्रत्येक पक्ष पर तीन पिक्सेल के "फ़ील्ड" के साथ उद्देश्य पर चुना गया था।

फ़िल्टरिंग के बाद, केवल तीन ग्लासों से संयुक्त विंडो और शेल्फ पर कई हाइलाइट्स छवि पर सफेद रहते हैं:


मान लीजिए कि फ़्रेम में सबसे बड़ा सफेद स्थान सभी तरह से एक खिड़की है। प्रत्येक बाढ़ स्थान (फ्लडफ़िल) को भरें और सबसे बड़ा क्षेत्र लें।

 int biggest_area = 0; byte area_id = 1, biggest_id = 0; // areas start from 2 Rectangle bounds = new Rectangle(); PointF cg = new PointF(); // center Point[] stack = new Point[320*200]; for (int x = 0; x < 320; x++) for (int y = 0; y < 240; y++) if (filtered[x, y] && belong[x, y] <= 1) { int area = 0, left = 320, top = 240, right = 0, bottom = 0; int sx = 0, sy = 0; ++area_id; // FloodFill int sp = 0; stack[0] = new Point(x, y); while (sp >= 0) { Point next = stack[sp--]; area++; sx += next.X; sy += next.Y; belong[next.X, next.Y] = area_id; if (next.X < left) left = next.X; if (next.X > right) right = next.X; if (next.Y < top) top = next.Y; if (next.Y > bottom) bottom = next.Y; if (filtered[next.X - 1, next.Y] && belong[next.X - 1, next.Y] <= 1) stack[++sp] = new Point(next.X - 1, next.Y); if (filtered[next.X, next.Y - 1] && belong[next.X, next.Y - 1] <= 1) stack[++sp] = new Point(next.X, next.Y - 1); if (filtered[next.X, next.Y + 1] && belong[next.X, next.Y + 1] <= 1) stack[++sp] = new Point(next.X, next.Y + 1); if (filtered[next.X + 1, next.Y] && belong[next.X + 1, next.Y] <= 1) stack[++sp] = new Point(next.X + 1, next.Y); } if (area > biggest_area) { biggest_area = area; biggest_id = area_id; bounds = new Rectangle(left, top, right - left, bottom - top); cg = new PointF((float)sx / area, (float)sy / area); } } 

मान्यता चित्र तैयार है! दो-स्तर - एक काली पृष्ठभूमि पर एक सफेद आयत। भरने के दौरान, हमने इसके "द्रव्यमान के केंद्र" cg (छवि में लाल बिंदु) और सीमाओं (ग्रीन डॉट - बाउंडिंग बॉक्स का केंद्र) के निर्देशांक की भी गणना की। अब हम जांच सकते हैं कि हमारा सफेद स्थान खिड़की की तरह कितना दिखता है: सबसे biggest_area कम से कम 2000 पिक्सेल होना चाहिए, दो केंद्रों के बीच की दूरी 20 पिक्सेल से अधिक नहीं होनी चाहिए, अन्यथा आयत के लिए आंकड़ा बहुत विषम है। लेकिन हम इसके उन्मुखीकरण को और कैसे निर्धारित करेंगे?


मिसाइल वैज्ञानिक, शायद, हूप ट्रांसफॉर्म को लागू करेंगे, छवि को आयत की संभावना मापदंडों (चौड़ाई, लंबाई, झुकाव कोण, मूल से ऑफसेट) के 4-आयामी स्थान पर स्थानांतरित करेंगे, और वहां अधिकतम की तलाश करेंगे। लेकिन मैंने श्रमिकों और किसानों के कार्य के लिए संपर्क किया, और एक शुरुआत के लिए मैंने अपने ज्यामितीय केंद्र से आयत के बिंदुओं को हटाने का एक "हिस्टोग्राम" बनाया:

 PointF c = new PointF(bounds.Left + (float)bounds.Width / 2, bounds.Top + (float)bounds.Height / 2); int[] hist = new int[400]; for (int i = 0; i < 400; i++) hist[i] = 0; int maxdist = 0; for (int x = bounds.Left; x <= bounds.Right; x++) for (int y = bounds.Top; y <= bounds.Bottom; y++) if (belong[x, y] == biggest_id) { int dist = (int)Math.Sqrt(Sqr(x - cX) + Sqr(y - cY)); hist[dist]++; if (dist > maxdist) maxdist = dist; } 

ग्रे ग्राफ हिस्टोग्राम है, इस पर अंधेरे पट्टी अधिकतम है, अर्थात। आयत के केंद्र से इतनी दूरी पर सबसे बड़ी संख्या में बिंदु स्थित हैं। (इस दूरी के अनुसार आयत पर एक डार्क सर्कल बनाया गया है।) यह समझना आसान है कि यह दूरी आयत की आधी चौड़ाई है: इसके लिए, सर्कल पूरी तरह से आयत के अंदर रखे जाते हैं, और हिस्टोग्राम रैखिक रूप से बढ़ता है (गुणांक with के साथ); तब हिस्टोग्राम धीरे-धीरे कम हो जाता है जब तक यह आयत की आधी लंबाई तक नहीं पहुंचता; अब से, सर्कल के केवल चार "कोनों" को आयत के अंदर रखा गया है, और हिस्टोग्राम तेजी से गिरता है। दुर्भाग्य से, हिस्टोग्राम पर इस "क्लिफ" के माध्यम से लंबाई का पता लगाना संभव नहीं है - आयत के किनारों को बहुत अधिक रैगिंग किया गया है और हिस्टोग्राम शोर का अंत करना है। हम एक और रास्ता तय करेंगे, और आयत की तुलना में 5 पिक्सेल चौड़े पर विचार करें। आयत के अनुप्रस्थ अक्ष पर इसके दो काले "पक्ष" होंगे:



हम इन "साइडवॉल" के द्रव्यमान के केंद्रों को ध्यान से देखते हैं: यहाँ कठिनाई उन्हें अलग करना है। हम प्रत्येक "चतुर्थांश" में द्रव्यमान के केंद्र को अलग-अलग मानते हैं, फिर केंद्रों की निकटता के अनुसार "युग्मकों" को दो युग्मों में संयोजित करते हैं।

 int r1 = 0; // incircle radius for (int x = maxdist; x >= 3; x--) { if (hist[x] > hist[r1]) r1 = x; } int rSample = r1 + 5; int[] voters = new int[4]; Point[] sums = new Point[4]; Point sampleOrg = new Point(Math.Max((int)(cX - rSample), 0), Math.Max((int)(cY - rSample), 0)); Rectangle sample = new Rectangle(sampleOrg, new Size( Math.Min((int)(cX + rSample), 319) - sampleOrg.X, Math.Min((int)(cY + rSample), 239) - sampleOrg.Y)); for (int x = sample.Left; x <= sample.Right; x++) for (int y = sample.Top; y <= sample.Bottom; y++) if (belong[x, y] != biggest_id) { int dist = (int)Math.Sqrt(Sqr(x - cX) + Sqr(y - cY)); if (dist > r1 && dist <= rSample) { int idx = y < cY ? (x < cX ? 1 : 0) : (x < cX ? 2 : 3); voters[idx]++; sums[idx].X += x; sums[idx].Y += y; } } PointF adjusted = new PointF(); int vAbove = voters[0] + voters[1], vBelow = voters[2] + voters[3], vLeft = voters[2] + voters[1], vRight = voters[0] + voters[3], allVoters = vAbove + vBelow; if (allVoters == 0) { // abort: no black pixels found } else { if (vAbove > 0 && vBelow > 0) { // split vertically PointF above = new PointF((float)(sums[0].X + sums[1].X) / vAbove - cX, (float)(sums[0].Y + sums[1].Y) / vAbove - cY), below = new PointF((float)(sums[2].X + sums[3].X) / vBelow - cX, (float)(sums[2].Y + sums[3].Y) / vBelow - cY); double dAbove = Math.Sqrt(above.X * above.X + above.Y * above.Y), dBelow = Math.Sqrt(below.X * below.X + below.Y * below.Y); if (dAbove >= r1 && dAbove <= rSample && dBelow >= r1 && dBelow <= rSample) // the split is valid adjusted = new PointF((above.X * vAbove - below.X * vBelow) / allVoters, (above.Y * vAbove - below.Y * vBelow) / allVoters); } if (adjusted.X == 0 && adjusted.Y == 0 && vLeft > 0 && vRight > 0) { // split horizontally PointF toleft = new PointF((float)(sums[2].X + sums[1].X) / vLeft - cX, (float)(sums[2].Y + sums[1].Y) / vLeft - cY), toright = new PointF((float)(sums[0].X + sums[3].X) / vRight - cX, (float)(sums[0].Y + sums[3].Y) / vRight - cY); double dLeft = Math.Sqrt(toleft.X * toleft.X + toleft.Y * toleft.Y), dRight = Math.Sqrt(toright.X * toright.X + toright.Y * toright.Y); if (dLeft >= r1 && dLeft <= rSample && dRight >= r1 && dRight <= rSample) // the split is valid adjusted = new PointF((toleft.X * vLeft - toright.X * vRight) / allVoters, (toleft.Y * vLeft - toright.Y * vRight) / allVoters); } } 

adjusted बिंदु अब इसके अनुप्रस्थ अक्ष के साथ आयत के केंद्र से इंगित करता है:


ठीक है, यह संपूर्ण अभिविन्यास है। आयत की लंबाई की गणना करने के लिए शुद्ध ज्यामिति का एक सा बचा है और यह जांचने के लिए कि लंबाई का अनुपात चौड़ाई एक वास्तविक खिड़की के समान है या नहीं।

मैं एक और उदाहरण पर काम का प्रदर्शन करूंगा - जब खिड़की पूरी तरह से फ्रेम में फिट नहीं होती है। इस तथ्य के कारण कि हम मान्यता के लिए हिस्टोग्राम के "अंत" का उपयोग नहीं करते हैं, अधूरी खिड़की हमें बिल्कुल भी भ्रमित नहीं करती है।


मैंने जो कोड WindowDetector था, वह WindowDetector MRDS सेवा में मानक Technologies\Vision\ColorSegment की छवि में तैयार किया गया था। मेरी सेवा कैमकॉर्डर से जुड़ी है, और प्रत्येक फ्रेम अपडेट के लिए यह UpdateFoundWindow को फ्रेम में खिड़की के कोण के साथ ग्राहकों को भेजती है। MRDS सेवा जो रोबोट को नियंत्रित WindowDetector है, उसी तरह से WindowDetector से जुड़ी होती है, WindowDetector कि यह बारकोड स्कैनर से जुड़ी होती है, और यह दोनों को एक ही तरह से संदेश संसाधित करती है - पहले मामले में पाठ्यक्रम को समायोजित करना, दूसरे मामले में।

एक खिड़की डिटेक्टर के साथ, मेरा रोबोट जल्दी से गोदाम के आसपास चला गया:


रोबोट का भाग्य दुखद है। इस वीडियो को शूट करने के ठीक एक घंटे बाद, व्हील सेंसर गोदाम की धूल से भर गया, और रोबोट ने इसकी स्थिति की निगरानी करना बंद कर दिया। रोबोट की प्रारंभिक असेंबली में, इस सेंसर को सबसे पहले रखा जाता है, अर्थात्। इसे बदलने के लिए, आपको आवश्यक रूप से सब कुछ अलग करना होगा और फिर एक नए तरीके से फिर से इकट्ठा करना होगा। मैंने सेंसर को "एक जीवित" रोबोट पर बदलने की कोशिश करने का फैसला किया, लेकिन अजीबता के कारण मैंने रोबोट के अंदर कुछ के बारे में बैटरी को छोटा कर दिया, और इसने पूरी तरह से ड्राइविंग बंद कर दी। मुझे उसे पिछले रोबोट से एक साल पहले स्टोरेज शेल्फ़ पर छोड़ना पड़ा था - जो रूम्बा पर आधारित था। यह रोबोट कब्रिस्तान है, रेजिमेंट नहीं।

इसलिए, ब्रिटेन छोड़ने से पहले, मैंने एडी को काम करने वाले रोबोट-लोडर बनाने का प्रबंधन नहीं किया। लेकिन पहले से ही इस वसंत मैं सबसे अधिक संभावना है कि वे स्पेयर पार्ट्स के साथ वहां लौटेंगे, इसे पुनर्जीवित करेंगे और परीक्षण जारी रखेंगे।