वस्तु की दूरी और उसकी गति को मापना

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

स्वयं विधि के अलावा, लेख OpenCV लाइब्रेरी का उपयोग करके पायथन में इसके कार्यान्वयन पर चर्चा करता है, और वीडियो 4 क्लिनक्स 2 एपीआई का उपयोग करके लिनक्स में वेबकैम से चित्र प्राप्त करने की सुविधाओं पर भी चर्चा करता है।



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

सभी गणना एक एकल सूत्र में घट जाती हैं:
l = L * K / (W / x - 1 + K) , जहां
एल वस्तु के लिए आवश्यक दूरी है, मी;
एल "लाइन" की लंबाई है, मी;
डब्ल्यू - पिक्सल में "शासक" की लंबाई, आमतौर पर छवि की चौड़ाई के समान होती है;
x छवि में ऑब्जेक्ट का समन्वय है;
K = (W - M) / M कैमरे के झुकाव को दर्शाने वाला गुणांक है, यहाँ M "शासक" के मध्य का समन्वय है।

इस सूत्र के निष्कर्ष में, त्रिकोणमिति का स्कूल ज्ञान मेरे लिए बहुत उपयोगी था।

इस फ़ंक्शन का निर्भरता ग्राफ चित्र में दिखाया गया है:


कैमरे का झुकाव जितना अधिक होगा, ग्राफ उतना ही अधिक बढ़ेगा। सीमा मामले में, जब कैमरे का अक्ष "शासक" ( एम = डब्ल्यू / 2 ) के विमान के लिए लंबवत निर्देशित होता है, तो ग्राफ एक सीधी रेखा बन जाता है।

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

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

स्रोत कोड विज्ञान के कुछ विभाग के पृष्ठ से लिए गए थे। इनमें से, मैंने जल्दी से अपने उद्देश्य के लिए अनावश्यक सब कुछ हटा दिया, अंततः दो संपादित फाइलें छोड़ V4L2.cpp : V4L2.cpp और V4L2.h यह, वास्तव में, वेबकेम से जुड़ने के लिए न्यूनतम आवश्यक एपीआई है। पायथन के लिए एक आवरण पर काम करते समय, मुझे पता चला कि video4linux2 उपकरणों को तीन तरीकों से एक्सेस किया जा सकता है: READ, MMAP और STREAM, लेकिन केवल MMAP विधि मेरे वेबकैम के साथ काम करती है। जैसा कि यह निकला, मेरे लिए काम नहीं करने वाले कार्यक्रमों के अन्य उदाहरणों ने READ विधि का उपयोग किया।

यह भी समझा जाता है कि वेबकैम YUYV प्रारूप (YUV422) में एक छवि प्रदान करता है, यह RGB से अलग है कि इसमें 2 बार कम रंग की जानकारी है। YUYV में, दो पिक्सेल 4 बाइट्स में, और RGB में छह से एन्कोडेड हैं, इसलिए बचत डेढ़ गुना है। Y चमक घटक है, प्रत्येक पिक्सेल के लिए यह अलग है। यू और वी रंग अंतर घटक हैं जो पिक्सेल के रंग को निर्धारित करते हैं, इसलिए हर दो पिक्सेल यू और वी के समान मूल्यों का उपयोग करते हैं। यदि आप इन सूचनाओं में वेब कैमरा से बाइट स्ट्रीम का प्रतिनिधित्व करते हैं, तो यह YUYV YUYV YUYV YUYV YUYV YUYV की तरह दिखाई देगा - यह 12 पिक्सेल। आप यह जान सकते हैं कि VLC प्लेयर का उपयोग करके आपका वेबकैम किस प्रारूप में काम करता है, उसके साथ कैप्चरिंग डिवाइस खोलें और फिर कोडेक के बारे में जानकारी का अनुरोध करें, यह इस प्रकार होना चाहिए:


यहां वेबकेम एक्सेस करने के लिए लाइब्रेरी का सोर्स कोड है:
main_v4l2.cpp

 #include "V4L2.h" #include <cstring> #include <iostream> using namespace std; extern "C" { // Specify the video device here V4L2 v4l2("/dev/video0"); unsigned char *rgbFrame; float clamp(float num) { if (num < 0) num = 0; if (num > 255) num = 255; return num; } // Convert between YUV and RGB colorspaces void yuv2rgb(unsigned char y, unsigned char u, unsigned char v, unsigned char &r, unsigned char &g, unsigned char &b) { float C = y - 16; float D = u - 128; float E = v - 128; r = (char)clamp(C + ( 1.402 * E )) ; g = (char)clamp(C - ( 0.344136 * D + 0.714136 * E )) ; b = (char)clamp(C + ( 1.772 * D )) ; } unsigned char *getFrame() { unsigned char *frame = (unsigned char *)v4l2.getFrame(); int i = 0, k = 0; unsigned char Y, U, V, R, G, B; for (i=0;i<640*480*2;i+=4) { Y = frame[i]; U = frame[i+1]; V = frame[i+3]; yuv2rgb(Y, U, V, R, G, B); rgbFrame[k] = R; k++; rgbFrame[k] = G; k++; rgbFrame[k] = B; k++; Y = frame[i+2]; yuv2rgb(Y, U, V, R, G, B); rgbFrame[k] = R; k++; rgbFrame[k] = G; k++; rgbFrame[k] = B; k++; } return rgbFrame; } void stopCapture() { v4l2.freeBuffers(); } // Call this before using the device void openDevice() { // set format struct v4l2_format fmt; CLEAR(fmt); fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; // Adjust resolution fmt.fmt.pix.width = 640; fmt.fmt.pix.height = 480; fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV; if (!v4l2.set(fmt)) { fprintf(stderr, "device does not support used settings.\n"); } v4l2.initBuffers(); v4l2.startCapture(); rgbFrame = (unsigned char *)malloc(640*480*3); } } 

एल्गोरिथ्म काफी समझ में आता है - पहले हम उस डिवाइस को खोलते हैं जिसका नाम पहले ("/ dev / video0") दिया गया है, और फिर प्रत्येक getFrame अनुरोध के लिए हम वेब कैमरा से फ़्रेम पढ़ते हैं, इसे RGB प्रारूप में कनवर्ट करते हैं और फ़्रेम से लिंक उसी को देते हैं जिसने इसे अनुरोध किया था। मैं भी जरूरत पड़ने पर जल्दी से इस लाइब्रेरी को संकलित करने के लिए एक Makefile प्रदान करता हूं।

और यहाँ पाइथन के लिए इस लाइब्रेरी का रैपर है:
v4l2.py

 from ctypes import * import Image import time lib = cdll.LoadLibrary("linux/libv4l2.so") class VideoDevice(object): def __init__(self): lib.openDevice() lib.getFrame.restype = c_void_p def getImage(self): buf = lib.getFrame() frame = (c_char * (640*480*3)).from_address(buf) img = Image.frombuffer('RGB', (640, 480), frame, 'raw', 'RGB', 0, 1) return img, time.time() 

जैसा कि आप देख सकते हैं, बिल्कुल कुछ भी जटिल नहीं है। पुस्तकालय ctypes मॉड्यूल का उपयोग करके जुड़ा हुआ है। रैपर लिखने में कोई समस्या नहीं थी, लाइन को छोड़कर:

 frame = (c_char * (640*480*3)).from_address(buf) 

जिसके लिए मैं तुरंत नहीं आया। तथ्य यह है कि यदि आप getFrame() से getFrame() रूप में डेटा c_char_p , तो ctypes डेटा को शून्य-टर्मिनेटेड स्ट्रिंग के रूप में व्याख्या करेगा, यानी जैसे ही शून्य बाइट स्ट्रीम में होगा, रीडिंग बंद हो जाएगी। एक ही डिज़ाइन आपको स्पष्ट रूप से निर्दिष्ट करने की अनुमति देता है कि कितना बाइट्स पढ़ना है। हमारे मामले में, यह हमेशा एक निश्चित मूल्य है - 640 * 480 * 3।

मैं यहां विंडोज में एक छवि प्राप्त करने के लिए स्रोत कोड प्रदान नहीं करूंगा, लेकिन यह किसी भी जटिलता में भिन्न नहीं होता है और directx.py नाम के साथ windows फ़ोल्डर में संग्रह में स्थित है।

और मैं किसी ऑब्जेक्ट के लिए ट्रैकिंग क्लास के स्रोत कोड का बेहतर उल्लेख कर रहा हूं, जो मुझे याद है, ओपनसीवी का उपयोग करके लिखा गया है। मैंने एक उदाहरण के रूप में लिया lkdemo.py उदाहरण जो OpenCV के साथ आया था और फिर से इसे एक वर्ग में परिवर्तित करके हमारी आवश्यकताओं के लिए सरल बनाया:
tracker.py

 class Tracker(object): "Simple object tracking class" def __init__(self): self.grey = None self.point = None self.WIN_SIZE = 10 def target(self, x, y): "Tell which object to track" # It needs to be an array for the optical flow calculation self.point = [(x, y)] def takeImage(self, img): "Loads and processes next frame" # Convert it to IPL Image frame = cv.CreateImageHeader(img.size, 8, 3) cv.SetData(frame, img.tostring()) if self.grey is None: # create the images we need self.grey = cv.CreateImage (cv.GetSize (frame), 8, 1) self.prev_grey = cv.CreateImage (cv.GetSize (frame), 8, 1) self.pyramid = cv.CreateImage (cv.GetSize (frame), 8, 1) self.prev_pyramid = cv.CreateImage (cv.GetSize (frame), 8, 1) cv.CvtColor (frame, self.grey, cv.CV_BGR2GRAY) if self.point: # calculate the optical flow new_point, status, something = cv.CalcOpticalFlowPyrLK ( self.prev_grey, self.grey, self.prev_pyramid, self.pyramid, self.point, (self.WIN_SIZE, self.WIN_SIZE), 3, (cv.CV_TERMCRIT_ITER|cv.CV_TERMCRIT_EPS, 20, 0.03), 0) # If the point is still alive if status[0]: self.point = new_point else: self.point = None # swapping self.prev_grey, self.grey = self.grey, self.prev_grey self.prev_pyramid, self.pyramid = self.pyramid, self.prev_pyramid 

सबसे पहले, हमें उसे बताना चाहिए कि हम किस बिंदु पर निगरानी रखना चाहते हैं, इसके लिए एक target विधि है। फिर हम इसे takeImage विधि का उपयोग करके फ्रेम द्वारा फ्रेम देते हैं, यह बदले में छवि फ्रेम को एक प्रारूप में परिवर्तित करता है जो इसे समझता है, ऑपरेशन के लिए आवश्यक छवि एल्गोरिदम बनाता है, फ्रेम को रंग से ग्रे के रंगों में स्थानांतरित करता है और फिर CalcOpticalFlowPyrLK को सभी कार्यों को CalcOpticalFlowPyrLK , जो ऑप्टिकल स्ट्रीम की गणना करता है लुकास-कनाडा की पिरामिड पद्धति। इस फ़ंक्शन के बाहर निकलने पर, हम उस बिंदु के नए निर्देशांक प्राप्त करते हैं जो हम अनुसरण कर रहे हैं। यदि बिंदु खो गया है, तो status[0] शून्य होगी। ऑप्टिकल फ्लक्स की गणना न केवल एक बिंदु के लिए की जा सकती है। एक वेब कैमरा के साथ lkdemo.py चलाएं और देखें कि यह बहुत सारे बिंदुओं को अच्छी तरह से संभालता है।

मैं पायथन इमेजिंग लाइब्रेरी से एक छवि को OpenCV प्रारूप में बदलने के बारे में भी कहूंगा, तथ्य यह है कि रंग छवियों के लिए OpenCV रंग घटकों के एक अलग क्रम का उपयोग करता है - BGR, पूर्ण रूपांतरण के लिए, आपको अभी भी लाइन cv.CvtColor(frame, frame, cv.CV_BGR2RGB) के साथ कोड को पूरक करने की आवश्यकता होगी cv.CvtColor(frame, frame, cv.CV_BGR2RGB) , लेकिन अधिकांश ट्रैकिंग एल्गोरिदम आपके रंग घटकों के साथ बिल्कुल समान रूप से भ्रमित हैं या नहीं, हमारा उदाहरण आम तौर पर केवल काले और सफेद चित्रों का उपयोग करता है। इसलिए, इस लाइन को कोड में शामिल नहीं किया जा सकता है।

मैं केवल लेख में दूरी की गणना करने के लिए कक्षा का स्रोत कोड प्रदान नहीं करता, क्योंकि केवल सबसे सरल गणित है। यह फ़ाइल में स्थित है distance_measure.py ।

यह केवल मुख्य स्क्रिप्ट के स्रोत कोड को दिखाने के लिए बना हुआ है, जो एक ग्राफिकल इंटरफ़ेस बनाता है और अन्य सभी मॉड्यूल को लोड करता है।
main.py

 from distance_measure import Calculator from webcam import WebCam from tracker import Tracker from Tkinter import * import ImageTk as PILImageTk import time class GUIFramework(Frame): "This is the GUI" def __init__(self,master=None): Frame.__init__(self,master) self.grid(padx=10,pady=10) self.distanceLabel = Label(self, text='Distance =') self.distanceLabel.grid(row=0, column=0) self.speedLabel = Label(self, text='Speed =') self.speedLabel.grid(row=0, column=1) self.imageLabel = None self.cameraImage = None self.webcam = WebCam() # M = 510, L = 0.5, W = 640 self.dist_calculator = Calculator(500, 0.5, 640, 1) self.tracker = Tracker() self.after(100, self.drawImage) def updateMeasure(self, x): (distance, speed) = self.dist_calculator.calculate(x, time.time()) self.distanceLabel.config(text = 'Distance = '+str(distance)) # If you want get km/h instead of m/s just multiply # m/s value by 3.6 #speed *= 3.6 self.speedLabel.config(text = 'Speed = '+str(speed) + ' m/s') def imgClicked(self, event): """ On left mouse button click calculate distance and tell tracker which object to track """ self.updateMeasure(event.x) self.tracker.target(event.x, event.y) def drawImage(self): "Load and display the image" img, timestamp = self.webcam.getImage() # Pass image to tracker self.tracker.takeImage(img) if self.tracker.point: pt = self.tracker.point[0] self.updateMeasure(pt[0]) # Draw rectangle around tracked point img.paste((128, 255, 128), (int(pt[0])-2, int(pt[1])-2, int(pt[0])+2, int(pt[1])+2)) self.cameraImage = PILImageTk.PhotoImage(img) if not self.imageLabel: self.imageLabel = Label(self, image = self.cameraImage) self.imageLabel.bind("<Button-1>", self.imgClicked) self.imageLabel.grid(row=1, column=0, columnspan=2) else: self.imageLabel.config(image = self.cameraImage) # 30 FPS refresh rate self.after(1000/30, self.drawImage) if __name__ == '__main__': guiFrame = GUIFramework() guiFrame.mainloop() 

जैसा कि मैंने ऊपर कहा, मैंने ग्राफिकल इंटरफ़ेस बनाने के लिए टिंकर लाइब्रेरी को चुना, मैंने अन्य टूलकिट्स के साथ भी काम किया, जैसे कि जीटीके, क्यूटी और निश्चित रूप से, wxPython, लेकिन उन्हें अतिरिक्त रूप से स्थापित किया जाना था, जबकि किंकेटर तुरंत काम करता है और यह बहुत ही अच्छा है। हालांकि, इसका उपयोग करना आसान है, ज़ाहिर है, आप इस पर एक जटिल इंटरफ़ेस नहीं बना सकते हैं, लेकिन इसकी क्षमता कार्य के लिए पर्याप्त से अधिक है। कक्षा के आरंभ में, मैं इसमें अन्य विजेट्स को व्यवस्थित करने के लिए एक grid बनाता हूं: दो टेक्स्ट फ़ील्ड और एक छवि। Tkinter के साथ, मुझे वेब कैमरा से छवियां डाउनलोड करने के लिए अलग से स्ट्रीम बनाने की आवश्यकता नहीं है, क्योंकि एक ऐसी पद्धति है जो आपको एक निश्चित अवधि के बाद निर्दिष्ट फ़ंक्शन करने की अनुमति देती है। Label config विधि का उपयोग करके पाठ और छवियों को अपडेट कर सकता है। बहुत आसान है! bind विधि का उपयोग करके माउस क्लिक इवेंट को imgClicked करना imgClicked विधि से imgClicked है।

छवि और इसके टाइमस्टैम्प self.webcam.getImage फ़ंक्शन self.webcam.getImage किए self.webcam.getImage हैं। वेबकैम मॉड्यूल केवल वेबकेम के साथ काम करने के लिए उपयुक्त मॉड्यूल को लोड करता है, जिसके आधार पर वर्तमान में प्रोग्राम जिस ऑपरेटिंग सिस्टम पर चल रहा है।

एक बार फिर मैं कार्यक्रम के साथ संग्रह के लिए एक लिंक दूंगा - दूरी-माप ।
Ubuntu के लिए आवश्यक पैकेज: अजगर, अजगर-इमेजिंग, अजगर-इमेजिंग-टीके, opencv संस्करण 2.2 और V4L2 आवरण को संकलित करने के लिए निर्माण-आवश्यक।
कार्यक्रम के माध्यम से शुरू होता है:
python main.py
किसी ऑब्जेक्ट को ट्रैक करना शुरू करने के लिए, आपको उस पर क्लिक करना होगा।

वह सब है।

उपयोगी लिंक

• Opencv विकी
• ऑप्टिकल प्रवाह
• Video4Linux2
• YUV रंग मॉडल
• एक नज़र में टिक्कर