👩🏻‍🤝‍👨🏿 👁‍🗨 👍🏻 आर्केड के लिए बॉट। भाग संख्या 2: हम OpenCV को जोड़ते हैं 👨🏼 💅 🐙

परिचय

हम खेल के लिए बॉट विकसित ~~करने के~~ लिए ~~दुनिया पर शासन~~ करना जारी रखते हैं। पिछली बातचीत ने इस तथ्य पर ध्यान केंद्रित किया कि संपर्क स्थापित है: माउस चलता है, छवि प्राप्त की जाती है। यह वस्तुओं को उजागर करने का समय है, इसके लिए कई अलग-अलग छवि प्रसंस्करण कार्यों के उपयोग की आवश्यकता होती है। बेशक, आप एक साइकिल का आविष्कार कर सकते हैं और इन कार्यों को स्वयं लिख सकते हैं, लेकिन तैयार विचारों का उपयोग करना बेहतर है।

छवि प्रसंस्करण के लिए, व्यापक OpenCV लाइब्रेरी लें । यह .net के लिए अप्रबंधित है, इसलिए हम इसे रैपर OpenCvSharp के माध्यम से जोड़ेंगे ।

छवियों के लिए विभिन्न परिवर्तनों को लागू करने के लिए हमें OpenCV की आवश्यकता है, एक ऐसा परिवर्तन चुनें जो पृष्ठभूमि और छाया को वस्तुओं और वस्तुओं को एक दूसरे से अलग करता है। हम आज इस लक्ष्य की ओर बढ़ेंगे।

विषय कवर : छवि प्रसंस्करण के लिए एक पुस्तकालय का चयन, OpenCV के साथ काम करने के लिए एक आवरण का चयन, बुनियादी OpenCV कार्यों, चलती वस्तुओं पर प्रकाश डाला, HSV रंग मॉडल।

ओपेनव्यू क्यों?

छवि प्रसंस्करण के लिए अन्य अच्छे पुस्तकालय हैं, एक OpenCV पर प्रकाश अभिसरण नहीं हुआ था।

जब प्रोग्रामिंग .net के तहत यह Accord.Net लाइब्रेरी (और इसके पहले के संस्करण AForge.Net ) पर भी ध्यान देने योग्य है। ये दोनों लाइब्रेरी भी मुक्त हैं, लेकिन ओपनसीवी के विपरीत .net प्लेटफॉर्म के लिए देशी (प्रबंधित) हैं।

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

बड़ा समुदाय

पुस्तकालयों की स्वतंत्र पसंद के साथ, यह उन लोगों पर ध्यान केंद्रित करने के लिए समझ में आता है जिनके पास एक बड़ा सक्रिय समुदाय है। बड़ी संख्या में अनुयायियों को एक उच्च परीक्षण पुस्तकालय, उपयोग करने के लिए असुविधा का एक छोटा प्रतिशत, कई प्रकार के दस्तावेज मिलते हैं, और यह काम के दौरान उत्पन्न होने वाले Google प्रश्नों को आसान बनाता है।

OpenCV पूरी तरह से इस थीसिस का समर्थन करता है। इस पर एक पुस्तक है: OpenCV सीखना ( ईमानदार होना, मैंने अभी तक इसे पढ़ा नहीं है, लेकिन मैं इसे निकट भविष्य में ठीक करने जा रहा हूं ), रूसी locv.ru में इसका अनुवाद है ( मैं इसे अभी नहीं खोल सकता ), ऑनलाइन दस्तावेज़ है , इसमें बहुत सारे प्रश्न हैं, जिनके उत्तर बहुत सारे हैं। स्टैकओवरफ्लो पर।

यह सब काम पर रखने के लिए एक त्वरित शुरुआत देता है, "पीली प्रदान करता है! तैयार हो जाओ! उद्देश्य "(जब आप जाते हैं पुस्तकालय का अध्ययन किया जा रहा है) क्लासिक के बजाय" तैयार हो जाओ! लक्ष्य! प्लि! ”(जब पहले काफी समय पुस्तकालय उपकरण के साथ प्रारंभिक परिचित पर खर्च किया जाता है)।

Google प्रश्न

अधिकांश कार्य त्वरित Google की सहायता से हल किए गए थे: कीवर्ड को प्रश्न के विषय में Google में डाला जाता है, और इसका उत्तर तुरंत पहले लिंक में दिया जाता है। अपने दम पर जवाब खोजते समय, ध्यान दें कि वांछित विषय का वर्णन करने के लिए किन कीवर्ड का उपयोग किया जाता है। Google प्रश्न की सुंदरता और व्याकरणिक शुद्धता के बारे में परवाह नहीं करता है, इसके लिए, केवल कीवर्ड की उपस्थिति महत्वपूर्ण है, जिसके द्वारा वह उत्तर का चयन करेगा।

हल किए जाने वाले मुद्दों के उदाहरण:
- छवि से आर-घटक का चयन करें - Google अनुरोध: google: opencv को एकल चैनल मिलता है , और पहला लिंक कहता है कि यह स्प्लिट फ़ंक्शन का उपयोग करके किया गया है
- छवियों के बीच अंतर खोजें: google: opencv अंतर छवियां , और पहले उत्तर से उदाहरण कहता है कि अनुपस्थित फ़ंक्शन ऐसा करता है। यदि आप खोज करते समय अंतर के बजाय तुलना शब्द का उपयोग करते हैं, तो Google पूरी तरह से अलग-अलग पृष्ठ दिखाना शुरू कर देगा, और यह हिस्टोग्राम तुलना, आदि का उपयोग करने की सिफारिश के साथ अधिक सामान्य उत्तर देगा। यह आपके प्रश्न के उत्तर की खोज करते समय कीवर्ड चुनने के महत्व को दर्शाता है।

OpenCV के लिए .net-आवरण को चुनना

लाइब्रेरी को चुना गया था, यह C # के साथ दोस्त बनाने के लिए बनी हुई है। यह समस्या हमारे सामने पहले ही हल हो चुकी है, और फिर से हमें केवल उपलब्ध विकल्पों के बीच चयन करना है। दो सामान्य आवरण हैं : इमगू केवी और ओपनचर्वशप । Emgu Cv अधिक पुराना और अधिक औपचारिक है, OpenCvSharp अधिक आधुनिक है। यह विकल्प OpenCvSharp तक सीमित था, लेखक के उन शब्दों को रिश्वत देता था, जो आईडीसोपायरी समर्थित हैं। इसका मतलब यह है कि लेखक ने न केवल 1 में C / C ++ से C # 1 में संरचनाओं और कार्यों को स्थानांतरित किया, बल्कि उन्हें एक फ़ाइल के साथ भी जोड़ा ताकि यह उन्हें कोड लिखने की C # शैली में उपयोग करने के लिए अधिक सुविधाजनक हो।

OpenCvSharp को परियोजना से जोड़ना

OpenCvSharp को प्रोजेक्ट से कनेक्ट करना बिना किसी विशेष झंझट के मानक तरीके से किया जाता है। लेखक का एक छोटा सा ट्यूटोरियल है, इसमें OpenCvSharp को नगेट के माध्यम से जोड़ने की क्षमता भी है।

बुनियादी बुनियादी कार्य

OpenCV में छवियों के साथ काम करने के लिए कई कार्य हैं। आइए हम केवल उन मूल बुनियादी कार्यों पर ध्यान केंद्रित करते हैं जो किसी छवि से वस्तुओं को निकालने की समस्या को हल करने के लिए उपयोग किए जाते हैं। OpenCV के दो उपयोग हैं: C- शैली और C ++ - शैली। कोड को सरल बनाने के लिए, हम C ++ शैली (या इसके बजाय, OpenCvSharp के माध्यम से इसके एनालॉग) का उपयोग करेंगे।

दो मुख्य वर्ग हैं: Mat और Cv2। दोनों OpenCvSharp.CPlusPlus के नाम स्थान पर हैं। Mat स्वयं छवि है, और Cv2 छवियों पर क्रियाओं का एक समूह है।
कार्य:

//  var mat = new Mat("test.bmp"); //  mat.ImWrite("out.bmp"); //  bitmap var bmp = mat.ToBitmap(); //  bitmap (  OpenCvSharp.Extensions) var mat2 = new Mat(bmp.ToIplImage(), true); //  using (new Window("", mat)) { Cv2.WaitKey(); } //   (,     ) Cv2.CvtColor(mat, dstMat, ColorConversion.RgbToGray); //      Cv2.Split(mat, out mat_channels) //      Cv2.Merge(mat_channels, mat) //    Cv2.Absdiff(mat1, mat2, dstMat); // ,  /  (50)  (0)   (255) Cv2.Threshold(mat, dstMat, 50, 255, OpenCvSharp.ThresholdType.Binary); //  mat.Circle(x, y, radius, new Scalar(b, g, r)); mat.Line(x1, y1, x2, y2, new CvScalar(b, g, r)); mat.Rectangle(new Rect(x, y, width, height), new Scalar(b, g, r)); mat.Rectangle(new Rect(x, y, width, height), new Scalar(b, g, r), -1); //  mat.PutText("test", new OpenCvSharp.CPlusPlus.Point(x, y), FontFace.HersheySimplex, 2, new Scalar(b, g, r))

OpenCV में ऑब्जेक्ट्स ( स्ट्रक्चरल एनालिसिस एंड शेप डिस्क्रिप्टर्स , मोशन एनालिसिस एंड ऑब्जेक्ट ट्रैकिंग , फीचर डिटेक्शन , ऑब्जेक्ट डिटेक्शन ) के चयन के लिए भी विशेष कार्य हैं, लेकिन वे उन्हें निचोड़ने में सफल नहीं हुए (उन्हें शायद वैसे भी किताब पढ़ने की जरूरत है ), इसलिए उन्हें बाद के लिए छोड़ दें।

वस्तुओं का चयन करें

वस्तुओं का चयन करने का एक सरल तरीका एक फिल्टर का आविष्कार करने के लिए नीचे आता है जो वस्तुओं से पृष्ठभूमि को काटता है, और एक दूसरे से वस्तुओं को। दुर्भाग्य से, जुमा मैदान की छवि बहुत रंगीन है, और एक साधारण चमक कट-ऑफ काम नहीं करती है। नीचे मूल छवि, इसका काला और सफेद संस्करण और विभिन्न कट-ऑफ की एक सीढ़ी है। अंतिम छवि दिखाती है कि सभी मामलों में पृष्ठभूमि गेंदों के साथ विलीन हो जाती है, या तो दोनों मौजूद हैं, या एक ही समय में अनुपस्थित हैं।

वस्तुओं का चयन उनके "स्ट्रिपिंग" को बहुत जटिल करता है। यहाँ, उदाहरण के लिए, कैनी फ़ंक्शन कैसे प्रतिक्रिया करता है, वस्तुओं के आकृति को उजागर करता है।

व्यक्तिगत रंग घटकों का उपयोग करने से जीवन बेहतर नहीं होता है।

चलती वस्तुओं को हाइलाइट करें

चलती वस्तुओं को उजागर करने का आधार सरल है: दो फ़ाइलों की तुलना की जाती है - परिवर्तित बिंदु वांछित वस्तुएं हैं। व्यवहार में, सब कुछ अधिक जटिल है, और शैतान, हमेशा की तरह, विवरण में है ...

छवि श्रृंखला निर्माण

छवियों की एक श्रृंखला बनाने के लिए, हमारे बॉट में एक छोटा कोड जोड़ें। बॉट अंतिम फ़्रेमों का इतिहास रखेगा, और उन्हें डिस्क पर रीसेट करने के लिए स्पेस बार दबाकर।

  var history = new List<Bitmap>(); for (var tick = 0; ;tick++) { var bmp = GetScreenImage(gameScreenRect); history.Insert(0, bmp); const int maxHistoryLength = 10; if (history.Count > maxHistoryLength) history.RemoveRange(maxHistoryLength, history.Count - maxHistoryLength); if (Console.KeyAvailable) { var keyInfo = Console.ReadKey(); if (keyInfo.Key == ConsoleKey.Spacebar) { for (var i = 0; i < history.Count; ++i) history[i].Save(string.Format("{0}.png", i)); } [..] } [..] }

हम लॉन्च करते हैं, क्लिक करते हैं और आवाज करते हैं - हमारे पास हाथ पर दो फ्रेम हैं।

पड़ोसी की तुलना

एक छवि को दूसरे से घटाएं ... और क्या कहा जाता है "घोड़े एक ढेर, लोगों में मिश्रित होते हैं।" गेंदें कुछ "अजीब" में बदल गईं (यह पूर्ण आकार के टुकड़े में स्पष्ट रूप से दिखाई दे रहा है), लेकिन यह ठीक है, मुख्य बात यह है कि हम गेंदों को पृष्ठभूमि से अलग करने में कामयाब रहे।

एक विशेष रूप से तैयार पृष्ठभूमि के साथ तुलना

पड़ोसी फ्रेम की तुलना "फ्रीस्टैंडिंग" चलती वस्तुओं के लिए अच्छी तरह से अनुकूल है। यदि कसकर चलती वस्तुओं को भेद करना आवश्यक है, तो विशेष रूप से तैयार किए गए स्थिर पृष्ठभूमि के साथ तुलना बेहतर काम करती है।
निम्नलिखित पृष्ठभूमि तैयार करें:

तुलना:

बहुत बेहतर है, लेकिन छाया सब कुछ खराब कर देती है। मैंने कई तरीकों से छाया से छुटकारा पाने की कोशिश की, लेकिन सबसे अच्छा प्रभाव इस विचार से दिया गया था कि छाया, वास्तव में, चमक में बदलाव है, और इसने मुझे पहले से ही एचएसवी रंग मॉडल के बारे में सोचने के लिए प्रेरित किया।

एचएसवी

RGB जैसे HSV कलर मॉडल में तीन चैनल होते हैं। लेकिन उसके विपरीत (वही सीएमवाईके) - यह सिर्फ रंगों का मिश्रण नहीं है।
- पहला चैनल, एच (ह्यू) - रंग टोन। पहले सन्निकटन में, यह इंद्रधनुष से रंग संख्या है।
- दूसरा चैनल, एस (संतृप्ति) - संतृप्ति। इस चैनल का मूल्य जितना कम होगा, ग्रे के रंग के करीब, उतना ही अधिक - रंग स्पष्ट होगा। उच्च संतृप्ति रंगों को "अम्लीय" के रूप में बोलचाल में जाना जाता है।
- तीसरा चैनल, वी (मान) - चमक। यह समझने के लिए सबसे आसान चैनल है, अधिक से अधिक रोशनी, इस चैनल के लिए उच्च मूल्य।
दाईं ओर की तस्वीर आपस में चैनलों और रंगों के संबंधों को दिखाती है। एक सर्कल में एक इंद्रधनुष होता है - यह चैनल एच है। एक विशिष्ट रंग के लिए त्रिकोण (अब यह लाल है) चैनल एस - संतृप्ति (दिशा-ऊपर दाएं) और चैनल वी - चमक (ऊपर-बाएं) में परिवर्तन दिखाता है। शास्त्रीय रूप से, चैनल H का मान 0-360, S - 0-100, V - 0-100 तक है। OpenCV में, एक बाइट के आयाम के उपयोग को अधिकतम करने के लिए सभी चैनलों का मान 0-255 की सीमा तक कम हो जाता है।

RGB रंग मॉडल मानव आंख के करीब है, इसे कैसे व्यवस्थित किया जाता है। एचएसवी रंग मॉडल मस्तिष्क द्वारा रंग को कैसे माना जाता है, इसके करीब है। नीचे मैंने विशेष रूप से छवियों की एक श्रृंखला का हवाला दिया है कि क्या होगा यदि प्रत्येक चैनल को प्लस / माइनस 50 तोतों में बदल दिया जाए। वे दिखाते हैं कि चैनल एस और वी को 100 इकाइयों द्वारा बदलने के बाद भी (और यह आधी सीमा है), छवि लगभग समान रूप से मानी जाती है, लेकिन चैनल एच में एक छोटा सा परिवर्तन भी धारणा को बदल देता है, जिससे छवि "नशे की लत" बन जाती है। यह इस तथ्य के कारण है कि विकास के लंबे वर्षों में मस्तिष्क ने कम स्थिर से अधिक स्थिर डेटा को अलग करना सीख लिया है।

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

Hvv अंतरिक्ष में पृष्ठभूमि के साथ तुलना करें

हम स्थैतिक पृष्ठभूमि से घटाव को दोहराते हैं, लेकिन अब hsv स्थान में रूपांतरण के बाद, और ओह! चमत्कार! चैनलों एच और एस में, गेंदें स्पष्ट रूप से छाया से अलग हो जाती हैं, सभी छाया लगभग पूरी तरह से चैनल वी में चली गईं। एच-चैनल में, गेंदों का "इंडेंटेशन" भी गायब हो जाता है, लेकिन, दुर्भाग्य से, पीले रंग की गेंदों को पृष्ठभूमि के साथ विलय करना शुरू हो जाता है। एस-चैनल में कठोरता बनी हुई है, लेकिन सभी गेंदें स्पष्ट रूप से दिखाई देती हैं, और दो-रंग की छवि में अनुवाद (25 से कम कटे हुए "कचरा") के साथ स्पष्ट सर्कल देता है और सभी अनावश्यक को हटा देता है।

सारांश

आज के लिए निर्धारित लक्ष्य प्राप्त किया गया है (गेंदों को पृष्ठभूमि से और उनकी छाया से अलग किया गया है), और आप शांत आत्मा के साथ सो सकते हैं।

पुनश्च

दिखाए गए सभी चित्र OpenCV (कट के तहत कोड) का उपयोग करके उत्पन्न होते हैं।

छिपा हुआ पाठ

  var resizeK = 0.2; var dir = "Example/"; var src = new Mat("0.bmp"); var src_g = new Mat("0.bmp", LoadMode.GrayScale); var src_1 = new Mat("1.bmp"); var src_1_g = new Mat("1.bmp", LoadMode.GrayScale); var background = new Mat("background.bmp"); var background_g = new Mat("background.bmp", LoadMode.GrayScale); src.Resize(resizeK).ImWrite(dir + "0.png"); src_g.Resize(resizeK).ImWrite(dir + "0 g.png"); src_g.ThresholdStairs().Resize(resizeK).ImWrite(dir + "0 g th.png"); var canny = new Mat(); Cv2.Canny(src_g, canny, 50, 200); canny.Resize(0.5).ImWrite(dir + "0 canny.png"); Mat[] src_channels; Cv2.Split(src, out src_channels); for (var i = 0; i < src_channels.Length; ++i) { var channels = Enumerable.Range(0, src_channels.Length).Select(j => new Mat(src_channels[0].Rows, src_channels[0].Cols, src_channels[0].Type())).ToArray(); channels[i] = src_channels[i]; var dst = new Mat(); Cv2.Merge(channels, dst); dst.Resize(resizeK).ImWrite(dir + string.Format("0 ch{0}.png", i)); src_channels[i].ThresholdStairs().Resize(resizeK).ImWrite(dir + string.Format("0 ch{0} th.png", i)); } if (true) { src.Resize(0.4).ImWrite(dir + "0.png"); src_1.Resize(0.4).ImWrite(dir + "1.png"); background.Resize(0.4).ImWrite(dir + "bg.png"); var dst_01 = new Mat(); Cv2.Absdiff(src, src_1, dst_01); dst_01.Resize(resizeK).ImWrite(dir + "01.png"); dst_01.Cut(new Rect(50, src.Height * 4 / 5 - 50, src.Width / 5, src.Height / 5)).ImWrite(dir + "01 part.png"); dst_01.Cut(new Rect(50, src.Height * 4 / 5 - 50, src.Width / 5, src.Height / 5)).CvtColor(ColorConversion.RgbToGray).ImWrite(dir + "01 g.png"); dst_01.CvtColor(ColorConversion.RgbToGray).ThresholdStairs().Resize(resizeK).ImWrite(dir + "01 g th.png"); var dst_01_g = new Mat(); Cv2.Absdiff(src_g, src_1_g, dst_01_g); dst_01_g.Cut(new Rect(50, src.Height * 4 / 5 - 50, src.Width / 5, src.Height / 5)).ImWrite(dir + "0g1g.png"); dst_01_g.ThresholdStairs().Resize(resizeK).ImWrite(dir + "0g1g th.png"); } if (true) { var dst_0b = new Mat(); Cv2.Absdiff(src, background, dst_0b); dst_0b.Resize(0.6).ImWrite(dir + "0b.png"); var dst_0b_g = new Mat(); Cv2.Absdiff(src_g, background_g, dst_0b_g); dst_0b_g.Resize(0.3).ImWrite(dir + "0b g.png"); dst_0b_g.ThresholdStairs().Resize(0.3).ImWrite(dir + "0b g th.png"); } if (true) { var hsv_src = new Mat(); Cv2.CvtColor(src, hsv_src, ColorConversion.RgbToHsv); var hsv_background = new Mat(); Cv2.CvtColor(background, hsv_background, ColorConversion.RgbToHsv); var hsv_background_channels = hsv_background.Split(); var hsv_src_channels = hsv_src.Split(); if (true) { var all = new Mat(src.ToIplImage(), true); for (var i = 0; i < hsv_src_channels.Length; ++i) { hsv_src_channels[i].CvtColor(ColorConversion.GrayToRgb).CopyTo(all, new Rect(i * src.Width / 3, src.Height / 2, src.Width / 3, src.Height / 2)); } src_g.CvtColor(ColorConversion.GrayToRgb).CopyTo(all, new Rect(src.Width / 2, 0, src.Width / 2, src.Height / 2)); all.Resize(0.3).ImWrite(dir + "all.png"); } foreach (var pair in new[] { "h", "s", "v" }.Select((channel, index) => new { channel, index })) { var diff = new Mat(); Cv2.Absdiff(hsv_src_channels[pair.index], hsv_background_channels[pair.index], diff); diff.Resize(0.3).With_Title(pair.channel).ImWrite(dir + string.Format("0b {0}.png", pair.channel)); diff.ThresholdStairs().Resize(0.3).ImWrite(dir + string.Format("0b {0} th.png", pair.channel)); hsv_src_channels[pair.index].Resize(resizeK).With_Title(pair.channel).ImWrite(dir + string.Format("0 {0}.png", pair.channel)); foreach (var d in new[] { -100, -50, 50, 100 }) { var delta = new Mat(hsv_src_channels[pair.index].ToIplImage(), true); delta.Rectangle(new Rect(0, 0, delta.Width, delta.Height), new Scalar(Math.Abs(d)), -1); var new_channel = new Mat(); if (d >= 0) Cv2.Add(hsv_src_channels[pair.index], delta, new_channel); else Cv2.Subtract(hsv_src_channels[pair.index], delta, new_channel); var new_hsv = new Mat(); Cv2.Merge(hsv_src_channels.Select((channel, index) => index == pair.index ? new_channel : channel).ToArray(), new_hsv); var res = new Mat(); Cv2.CvtColor(new_hsv, res, ColorConversion.HsvToRgb); res.Resize(resizeK).With_Title(string.Format("{0} {1:+#;-#}", pair.channel, d)).ImWrite(dir + string.Format("0 {0}{1}.png", pair.channel, d)); } } } static class OpenCvHlp { public static Scalar ToScalar(this Color color) { return new Scalar(color.B, color.G, color.R); } public static void CopyTo(this Mat src, Mat dst, Rect rect) { var mask = new Mat(src.Rows, src.Cols, MatType.CV_8UC1); mask.Rectangle(rect, new Scalar(255), -1); src.CopyTo(dst, mask); } public static Mat Absdiff(this Mat src, Mat src2) { var dst = new Mat(); Cv2.Absdiff(src, src2, dst); return dst; } public static Mat CvtColor(this Mat src, ColorConversion code) { var dst = new Mat(); Cv2.CvtColor(src, dst, code); return dst; } public static Mat Threshold(this Mat src, double thresh, double maxval, ThresholdType type) { var dst = new Mat(); Cv2.Threshold(src, dst, thresh, maxval, type); return dst; } public static Mat ThresholdStairs(this Mat src) { var dst = new Mat(src.Rows, src.Cols, src.Type()); var partCount = 10; var partWidth = src.Width / partCount; for (var i = 0; i < partCount; ++i) { var th_mat = new Mat(); Cv2.Threshold(src, th_mat, 255 / 10 * (i + 1), 255, ThresholdType.Binary); th_mat.Rectangle(new Rect(0, 0, partWidth * i, src.Height), new Scalar(0), -1); th_mat.Rectangle(new Rect(partWidth * (i + 1), 0, src.Width - partWidth * (i + 1), src.Height), new Scalar(0), -1); Cv2.Add(dst, th_mat, dst); } var color_dst = new Mat(); Cv2.CvtColor(dst, color_dst, ColorConversion.GrayToRgb); for (var i = 0; i < partCount; ++i) { color_dst.Line(partWidth * i, 0, partWidth * i, src.Height, new CvScalar(50, 200, 50), thickness: 2); } return color_dst; } public static Mat With_Title(this Mat mat, string text) { var res = new Mat(mat.ToIplImage(), true); res.Rectangle(new Rect(res.Width / 2 - 10, 30, 20 + text.Length * 15, 25), new Scalar(0), -1); res.PutText(text, new OpenCvSharp.CPlusPlus.Point(res.Width / 2, 50), FontFace.HersheyComplex, 0.7, new Scalar(150, 200, 150)); return res; } public static Mat Resize(this Mat src, double k) { var dst = new Mat(); Cv2.Resize(src, dst, new OpenCvSharp.CPlusPlus.Size((int)(src.Width * k), (int)(src.Height * k))); return dst; } public static Mat Cut(this Mat src, Rect rect) { return new Mat(src, rect); } public static Mat[] Split(this Mat hsv_background) { Mat[] hsv_background_channels; Cv2.Split(hsv_background, out hsv_background_channels); return hsv_background_channels; } }

डायरेक्टएक्स-आर्केड के लिए बॉट। भाग संख्या 1: संपर्क करें
आर्केड के लिए बॉट। भाग संख्या 2: हम OpenCV को जोड़ते हैं

आर्केड के लिए बॉट। भाग संख्या 2: हम OpenCV को जोड़ते हैं