Opencv raspberry pi ინსტალაცია. OpenCV-ის (Linux) ინსტალაცია

10.09.2021

ცოტა ხნის წინ, გამოსახულების ამოცნობასთან დაკავშირებული ერთ-ერთი პროექტის განხორციელებისას, ჩვენ გვქონდა საჭიროება დაყენებულიყო OpenCV კომპიუტერული ხედვის ბიბლიოთეკა Raspberry PB2 ერთ დაფაზე მიკროკომპიუტერზე.

ინტერნეტის დათვალიერებისა და ექსპერიმენტებზე გარკვეული დროის დახარჯვის შემდეგ, ჩვენ წარმატებით მოვაგვარეთ ეს პრობლემა. შედეგი არის პატარა ინსტრუქცია, რომელსაც სიამოვნებით ვუზიარებთ ყველას, ვინც გადაწყვეტს გამოიყენოს OpenCV Raspberry-ზე.

ასე რომ: OpenCV-ის დაყენება:

მაგალითში ჩვენ ვიყენებთ opencv ვერსიას 2.4.9.

პირველ რიგში უნდა განვაახლოთ ჩვენი სისტემა:

სუდო apt-get განახლება სუდო apt-get განახლება

ახლა ჩვენ უნდა დავაყენოთ დამატებითი ბიბლიოთეკები:

სუდო apt-get -y install build-essential cmake-curses-gui pkg-config libpng12-0 libpng12-dev libpng++-dev libpng3 libpnglite-dev zlib1g-dbg zlib1g zlib1g-dev pngtools libtiffx4- gen3-dev სუდო apt-get -y დააინსტალირე libjpeg8 libjpeg8-dev libjpeg8-dbg libjpeg-progs ffmpeg libavcodec-dev libavcodec53 libavformat53 libavformat-dev libgstreamer0.10-0-dbg libgstreamer0.libffeg0 -dev libxine1- bin libunicap2 libunicap2-dev swig libv4l-0 libv4l-dev python-numpy libpython2.6 python-dev python2.6-dev libgtk2.0-dev swig libv4l-0 libv4l-dev python-numpy libpython2.6 python-dev python2.6-dev libgtk2.0-dev swig libv4l-0 libv4l-dev libsl-conscal-dev4. -0 libgtk2.0-dev pkg-config libxvidcore-dev libx264-dev libavcodec-dev libavformat-dev libqt4-dev libqt4-opengl-dev libjasper-dev

ბიბლიოთეკების ინსტალაციის დასრულების შემდეგ გადავდივართ OpenCV-ის ინსტალაციაზე. ინსტალაციის დროს შეიძლება წარმოიშვას სიტუაცია, როდესაც შეიძლება არ იყოს თქვენი სისტემისთვის გარკვეული ბიბლიოთეკა და მოგიწევთ გადახედოთ რა აკლია და დამატებით მიაწოდოთ.

მოდით შევქმნათ საქაღალდე, რომელშიც გადმოვწერთ ჩვენს არქივს:

mkdir~/opt/opencv/cd ~/opt/opencv wget-O openCV-2.4.9.zip http://sourceforge.net/projects/opencvlibrary/files/opencv-unix/2.4.9/opencv-2.4.9.zip/download

ახლა ჩვენ უნდა გავხსნათ ჩვენი არქივი. ამისათვის ჩვენ ვიყენებთ ბრძანებას:

გახსნა openCV-2.4.9.zip

შედეგად, ჩვენ შევქმნით საქაღალდეს openCV-2.4.9. გადადით მასზე და შექმენით გამოშვების საქაღალდე

CD openCV-2.4.9 mkdirგათავისუფლება CDგათავისუფლება

დროა OpenCV-ის კონფიგურაცია. თუ არ გჭირდებათ მესამე მხარის პარამეტრები, მაშინ შეგიძლიათ გამოიყენოთ ნაგულისხმევი კონფიგურაცია (ამისთვის უბრალოდ დააჭირეთ ღილაკს "c"). როდესაც თქვენ გაუშვით ccmake, გამოჩნდება პარამეტრების სია, რომელიც შეგიძლიათ მიუთითოთ (როგორც ნაჩვენებია ქვემოთ მოცემულ სურათზე)

და მოდით დავიწყოთ:

ccmake ../

(დააჭირეთ "c" თუ ცარიელი ქეშის კონფიგურაცია)

დააჭირეთ ღილაკს "c".

როდესაც ინსტალაცია დასრულდება, კვლავ დააჭირეთ ღილაკს "c" გასაგრძელებლად და "g" ღილაკს მაკიაჟის შესაქმნელად.

ახლა ყველაფერი კონფიგურირებულია და ყველაფერი რაც თქვენ უნდა გააკეთოთ, დააწკაპუნეთ make. ამ პროცესს საშუალოდ დაახლოებით 10 საათი დასჭირდება.

გააკეთე სუდოდააინსტალირეთ

ეს დაასრულებს ინსტალაციას. რჩება მხოლოდ ფუნქციონირების შემოწმება.

შექმენით main.cpp ფაილი

#შეიცავს #შეიცავს სახელთა სივრცის გამოყენებით cv; int main(int argc, char** argv) ( if (argc != 2) ( printf("usage: n"); return -1; ) Mat image; image = imread(argv, 1); if (!image.data) (printf("სურათის მონაცემები არ არის n"); return -1; ) imshow("Display Image" , სურათი waitKey(0);

ახლა თქვენ უნდა შექმნათ ფაილი CMakeLists.txt და შეიყვანოთ მასში შემდეგი:

Cmake_მინიმუმ საჭირო(VERSION 2.8) პროექტი (DisplayImage) find_package(OpenCV REQUIRED) add_executable(DisplayImage main.cpp) target_link_libraries(DisplayImage $(OpenCV_LIBS))

ყველაფერი რაც ჩვენ უნდა გავაკეთოთ არის კომპილაცია და გაშვება

სმაკე . გააკეთე

დავიწყოთ

./DisplayImage path_to_photo.jpg

თუ ყველაფერი კარგად წავიდა, შედეგად ჩვენ დავინახავთ სურათს, რომელიც თქვენ მიუთითეთ ფაილის ბილიკის პარამეტრში.

ლეონიდი, პროგრამისტი Sidstudio-ში

ერთ დროს მაინტერესებდა რობოტული მანქანების აწყობა Arduino-სა და Raspberry Pi-ს გამოყენებით. მომეწონა კონსტრუქციულ კომპლექტთან თამაში, მაგრამ რაღაც მეტი მინდოდა.

და ერთ დღეს, ალიექსპრესის ირგვლივ ხეტიალისას, დამხვდა ალუმინის შასი ტანკისთვის. ეს ქმნილება პლასტმასის მანქანებთან შედარებით ფერარივით გამოიყურებოდა ეტლთან შედარებით.

ჩემს თავს ვაჩუქე ახალი წელი, ტანკი ჩამოვიდა, აწყობილი იყო და შემდეგ მისი გაცოცხლება გახდა საჭირო. თავად Raspberry, დენის გადამყვანი, ძრავის კონტროლერი და ბატარეა ამოვიღე მანქანიდან. ეს ყველაფერი ტანკზე იყო დაყენებული და ბედნიერად მუშაობდა.

ტანკმა უნდა გადაიღოს და შემდეგი ნაბიჯი იყო კამერის გამოჩენა. კამერის ქეისით ვერ ვხვდებოდი - როცა ის ღია იყო, კამერას არ ეჭირა, მაგრამ როცა ძლიერად დახურეს, ისე მჭიდროდ იყო, რომ კამერის ობიექტივი გაფრინდა. ტანჯვის შემდეგ, მე უბრალოდ კამერა საიზოლაციო ლენტით მივაკრა საბინაო ყდაზე. ახლა ტანკს შეეძლო არა მხოლოდ ოთახის გარშემო მოძრაობა, არამედ ფოტოების გადაღებაც.

აღსანიშნავია ტანკის სერიოზული უპირატესობა სახლში მანქანებთან შედარებით - მუხლუხო ტრასებზე არ აქვს მნიშვნელობა, მოძრაობს იგი მყარ იატაკზე თუ ხალიჩაზე. ბორბლებიანი მანქანები სრიალებენ რბილ ხალიჩაზე, იქამდე, რომ ვერ ახერხებენ შემობრუნებას.

შემდეგი, მე მინდოდა შემემუშავებინა ტანკი ავტონომიური ნავიგაციის მიმართულებით, კამერის ფოტოებზე დაყრდნობით. მომიწია კომპიუტერული ხედვის სამყაროში ჩაძირვა და OpenCV-ის აღმოჩენა. ყველაფერი ფერების და კონტურის ამოცნობით დაიწყო – ქაღალდზე წითელი წრე დავბეჭდე, ტელევიზორს მივაწებე და რობოტი დავატრიალე, სანამ წრე იპოვეს.

იდეა იყო ოთახში შესამჩნევი ობიექტების მონიშვნა (დივანი, ტელევიზორი, მაგიდა) ფერადი წრეებით და რობოტს ფერის მიხედვით ნავიგაცია ესწავლებინა.

OpenCV-ის გამოყენებით მოძებნეს სასურველი ფერის კონტურები (მისაღები ტოლერანტობით), შემდეგ მოძებნეს წრე კონტურებს შორის.

ჩანდა, რომ მთავარი პრობლემა შეიძლება იყოს სასურველი ფერის შემთხვევითი წრე ერთ-ერთ ობიექტზე.

თუმცა, მთავარი პრობლემა ის იყო, რომ ფერი ძალიან ცვალებადია განათების მიხედვით, ამიტომ დიაპაზონი, რომელშიც წითელი (მაგალითად) იყო აღიარებული, უნდა გადაჭიმულიყო ფერებში, რომლებიც ძალიან ბუნდოვნად წააგავს თავდაპირველ ფერს. ან აირჩიეთ სასურველი ფერი სურათიდან, მაგრამ ნებისმიერ შემთხვევაში ეს იყო არა წითელი, არამედ ყავისფერი ელფერით.

მოძებნეთ წითელი წრე:

იმპორტი cv2 იმპორტი numpy როგორც np import sys def mask_color(img, c1, c2): img = cv2.medianBlur(img, 5) hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) mask = cv2.inRange,c1,h c2) mask = cv2.erode(mask, None, iterations=2) mask = cv2.dilate(mask, none, iterations=2) return mask def find_contours(img): ნაცრისფერი = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) ბუნდოვანი = cv2.GaussianBlur(ნაცრისფერი, (5, 5), 0) thresh = cv2.threshold(ბუნდოვანი, 30, 255, cv2.THRESH_BINARY) thresh = cv2.bitwise_not(thresh) im2, cnts, hierarchy.find(C) thresh, cv2.RETR_CCOMP, cv2.CHAIN_APPROX_SIMPLE) cp_img = img.copy() cv2.drawContours(cp_img, cnts, -1, (0,255,0), 3) return cp_img def find_circles): img, cv2.COLOR_BGR2GRAY) ბუნდოვანი = cv2.medianBlur(ნაცრისფერი,5) წრეები = cv2.HoughCircles(ბუნდოვანი,cv2.HOUGH_GRADIENT,1,20,param1=50,param2=30,minadius=0,ma) img თუ წრეები არ არის არცერთი: წრეები = np.uint16(np.around(circles)) i-სთვის წრეებში: cv2.circle(img,(i,i),i,(255,0,0),2) cv2 .circle(img,(i,i),2,(0,0,255),3) ბეჭდვა "C", i,i,i დაბრუნება cimg def find_circle(img, rgb): ტოლერანტობა = 4 hsv = cv2.cvtColor( rgb, cv2.COLOR_BGR2HSV) H = hsv c1 = (H - ტოლერანტობა, 100, 100) c2 = (H + ტოლერანტობა, 255, 255) c_mask = mask_color(img, c1, c2) rgb = cv2.cvt,Clor .COLOR_GRAY2RGB) cont_img = find_contours(rgb) circ_img = find_circles(cont_img) cv2.imshow("Image", circ_img) cv2.waitKey(0) if __name__ == "__real_main__" sy.imgv_name: img. img_name) rgb = np.uint8 ([[]]) find_circle (img, rgb)
ფერების ამოცნობამ ჩიხამდე მიაღწია, ყურადღება გამიფანტა ჰარის კასკადებმა, ტანკის გამოყენებით კატის გადასაღებად. კატა კარგად გადაიღმა, რის გამოც კასკადს ნახევარი დრო უშვებდა შეცდომებს (თუ ვინმემ არ იცის, OpenCV მოყვება Haar-ის კასკადი, რომელიც სპეციალურად არის გაწვრთნილი კატებზე - აიღეთ და გამოიყენეთ).

კატაზე ნადირობას რობოტისთვის სასარგებლო შედეგები მოჰყვა - ვინაიდან ნადირობის ობიექტის სტატიკური კამერით დაჭერა ყოველთვის არ შეიძლებოდა, დავაყენე სამფეხა ორი სერვომოტორით (და PWM მოდული, რომ მართავდნენ მათ Raspberry-ის საშუალებით).

გავაგრძელე ჩემი კვლევა იმის შესახებ, თუ რისი ამოღება შესაძლებელია ოთახის ფოტოებიდან, ბუნებრივად მივედი ნერვულ ქსელებთან. ტენსორფლოს გაკვეთილის ჩაყლაპვის შემდეგ, მე დავამუშავე იგი სატანკო ფოტო დეტექტორით და შედეგები იმედისმომცემი იყო - ტელევიზორი, მაგიდა, დივანი, კატა და მაცივარი ცალსახად იქნა აღიარებული.

ეს ექსპერიმენტები ჩატარდა კომპიუტერზე და დარჩა მხოლოდ TF-ის გადატანა Raspberry Pi-ზე. საბედნიეროდ, Github-ზე ცხოვრობს უნიკალური ადამიანი, რომელიც მოთმინებით დაარღვია ყველა დამოკიდებულების ინსტალაცია და კომპილაციის მრავალი საათი - და გამოაქვეყნა ზოგადი წვდომაშედგენილი Tensorflow-ის მიერ Raspberry Pi-სთვის.

თუმცა, თემის შემდგომმა შესწავლამ აჩვენა, რომ OpenCV არ დგას და მისმა ავტორებმა გამოუშვეს DNN (Deep Neural Networks) მოდული, რომელიც გთავაზობთ TensorFlow-ზე გაწვრთნილ ნერვულ ქსელებთან ინტეგრაციას. ეს გამოსავალი ბევრად უფრო მოსახერხებელია შესამუშავებლად, გარდა ამისა, არ არის საჭირო თავად TF. ცოტა ჯადოქრობა მომიწია, რადგან მობილური SSD ნეირონული ქსელის უახლესი ვერსია TF-სთვის აღარ იქნა აღებული OpenCV-ის უახლესი ვერსიით. უნდა მენახა
და შეამოწმეთ მობილური SSD-ის სამუშაო ვერსია. გარდა ამისა, DNN მუშაობს ნორმალურად მხოლოდ OpenCV 3.4-ზე და მე ვერ ვიპოვე ეს ვერსია Raspberry-სთვის. მე თვითონ მომიწია მისი აწყობა, რადგან ეს ბევრად უფრო ადვილია, ვიდრე TensorFlow-ის არევა. ამავდროულად, შეუძლებელი იყო OpenCV-ის შედგენა Raspbian-ის (Stretch) უახლესი ვერსიისთვის, მაგრამ უახლესი ვერსია წინა თაობა(ჯესი) ყველაფერი ისე წავიდა, როგორც უნდა.

კოდის მაგალითი DNN-ის გამოყენებით და არა Tensorflow-ის გამოყენებით.

ობიექტების სახელებზე პასუხისმგებელი რამდენიმე ფაილი ამოიღეს TF-დან და თავად TF-ზე დამოკიდებულება მოიხსნა (იყო მხოლოდ ფაილიდან კითხვა).
წყაროს კოდი GitHub-ზე.

cv2-ის იმპორტი, როგორც cv იმპორტი tf_labels იმპორტი sys DNN_PATH = "--path-to:ssd_mobilenet_v1_coco_11_06_2017/frozen_inference_graph.pb" DNN_TXT_PATH = "--path-to:ssd_mobilenet_PATH.BExt co_label _map.pbtxt " tf_labels.initLabels(PATH_TO_LABELS) cvNet = cv.dnn.readNetFromTensorflow(pb_path, pb_txt) img = cv.imread(sys.argv) რიგები = img.shape cols = img.shape cvNet.dromn , 1.0/127.5, (300, 300), (127.5, 127.5, 127.5), swapRB=True, crop=False)) cvOut = cvNet.forward() cvOut-ში გამოვლენისთვის: ქულა = float(გამოვლენა) თუ ქულა >5. : მარცხენა = int(გამოვლენა * cols) top = int(გამოვლენა * რიგები) მარჯვნივ = int(გამოვლენა * cols) ქვედა = int(გამოვლენა * რიგები) label = tf_labels.getLabel(int(გამოვლენა)) print(label, score, მარცხენა , ზედა, მარჯვნივ, ქვედა) text_color = (23, 230, 210) cv.rectangle(img, (მარცხნივ, ზედა), (მარჯვნივ, ქვედა), text_color, სისქე=2) cv.putText(img, label, ( მარცხნივ, ზევით), cv.FONT_HERSHEY_SIMPLEX, 1, ტექსტის_ფერი, 2) cv.imshow("img", img) cv.waitKey()
ზოგადად, სატანკო ფოტოების ამოცნობა უკვე შესაძლებელია ნერვული ქსელით და ეს არის ძალიან მნიშვნელოვანი ნაბიჯი ნავიგაციაში ღირსშესანიშნაობების ამოცნობის თვალსაზრისით. თუმცა, მხოლოდ სურათები არ იყო საკმარისი სრული ნავიგაციისთვის, საჭირო იყო დაბრკოლებამდე მანძილის გაზომვა. ასე მიიღო რობოტმა ექოს ხმა. თევზის მპოვნელის ჟოლოს დასაკავშირებლად საჭიროა ცოტათი იმუშაოთ - თევზის მპოვნელი უბრუნებს სიგნალს 5 ვ-ზე, ხოლო Raspberry იღებს 3.3 ვ. მუხლზე ეს პრობლემა გვარდება ძირითადად რეზისტორებით დაფაზე, მაგრამ რობოტზე ასეთი აურზაური არ მინდოდა. შედეგად, იპოვეს Level Shifter ჩიპი, რომელიც აკეთებს ყველაფერს, რაც საჭიროა და ის თითის ფრჩხილის ზომისაა.

გარდა ამისა, შეშფოთებული ვარ გარეგნობარობოტი - მე ნამდვილად არ მომეწონა, რომ მიკროსქემები და კამერა ექო ჟღერადობით იყო მიმაგრებული მუყაოზე. ჩვენს სამყაროში ტექნოლოგიის განვითარება საშუალებას გვაძლევს დავჭრათ პლასტმასი ლაზერით დროისა და ფულის გონივრულ ფასად. ზოგადად, ვიპოვე სახელოსნო ლაზერული აპარატით, ცოტა დრო გავატარე ამ მშვენიერი აპარატის ინსტრუქციების შესწავლაზე და არა პირველივე ცდაზე, პანელები ამოვიღე მიკროსქემებისთვის და კამერა ექო ხმით.

ყველაფერი მზად არის ავტონომიური ნავიგაციისთვის, მაგრამ ამოცანა არც ისე მარტივი აღმოჩნდა და პირველივე მცდელობისას ცოტა დავიკარგე. გადავწყვიტე შესვენება, ყველაფერი კარგად მომეფიქრებინა და ანალოგების შესწავლა. შესაძლოა, ეს ნავიგაცია გამოდგება ცალკე სტატიის თემად.

REST ინტერფეისი, რომელსაც რობოტი უზრუნველყოფს შემდგომი გამოყენების საფუძველს:

GET /ping GET /ვერსია GET /სახელი GET /dist POST /fwd/POST-ზე /fwd/off POST /back/on POST /back/off POST /მარცხნივ/POST-ზე /მარცხნივ/გამორთული POST /მარჯვნივ/POST-ზე /მარჯვნივ /გამორთვა POST /ფოტო/გაკეთება GET /ფოტო/:phid GET /ფოტო/სიტი POST /კამერა/ზემოთ POST /კამერა/ქვემოთ POST /კამერა/მარჯვნივ POST /კამერა/მარცხნივ POST /გამოვლენა/ჰაარ/:phid POST /გამოვლენა/ dnn/:phid

დაიცავით თქვენი გულმკერდი ცნობისმოყვარე თვალებისგან კოდის კომბინაციის გახსენების ან გასაღების გამოყენების გარეშე. შენი სახე იქნება მკერდის გასახსნელად!

IN ამ პროექტსგვიჩვენებს, თუ როგორ გამოვიყენოთ Raspberry Pi მიკროკომპიუტერი და Pi კამერა გულმკერდის გასახსნელად სახის ამოცნობის ტექნოლოგიის გამოყენებით.

ამ პროექტის პროგრამული ნაწილი ეფუძნება ალგორითმს, რომელიც წარმოდგენილია OpenCV კომპიუტერული ხედვის ბიბლიოთეკაში. Raspberry Pi არის იდეალური პლატფორმა ამ პროექტისთვის, რადგან მას აქვს საკმარისი დამუშავების ძალა OpenCV-ის გასაშვებად და არის მცირე ზომის, ასე რომ მას შეუძლია ნებისმიერ ადგილას მოთავსება.

ეს პროექტი საშუალო სირთულისაა. იგი ადგენს და ინსტალაციას პროგრამული უზრუნველყოფა Raspberry Pi მიკროკომპიუტერზე. თუ თქვენ გაქვთ მსგავსი ნივთების შექმნის გამოცდილება და არანაირი პრობლემა არ გაქვთ ბრძანების ხაზის გამოყენებით, მაშინ სრულად მზად ხართ ამ პროექტის ყველა საფეხურის გასავლელად. თქვენ ასევე შეგიძლიათ მიმართოთ Adafruit სასწავლო სისტემის დამხმარე მასალებს, თუ რაიმე პრობლემა შეგექმნათ.

ნაბიჯი #1: გულმკერდის მომზადება

გაბურღეთ 7/16" ხვრელი მკერდის ზედა ნაწილში Pi კამერის ჩასართავად.
გაბურღეთ უფრო დიდი ხვრელი მკერდის უკანა ღილაკისა და დენის კაბელის ჩასართავად.

ნაბიჯი #2: ჩამკეტის დამზადება

დააინსტალირეთ ქინძისთავები მკერდის წინა მხარეს, რომელიც დაიჭერს სამაგრს, როდესაც სერვო შემობრუნდება.
გააკეთეთ პატარა ჩარჩო Pi და სერვო ჩამკეტის მხარდასაჭერად. სერვო მიმაგრებულია ჩარჩოზე ხის ფირფიტისა და დაჭრილი თავის ხრახნების გამოყენებით.
გააკეთეთ ჩამკეტი ხის ორი ნაწილისგან, რომლებიც ერთმანეთზეა დამაგრებული მარჯვენა კუთხით და დამაგრებულია სერვო მკლავზე.

ნაბიჯი #3: მკერდის დასრულება

შეამოწმეთ, რომ ჩარჩო, პი და საკეტი მკერდის ზედა ნაწილში სწორ კონტაქტს ამყარებს. დარწმუნდით, რომ სერვო ჩამკეტი ბრუნავს ქვემოთ და აერთებს ქინძისთავს მკერდის წინა მხარეს.
დააინსტალირეთ ქინძისთავები, რომლებიც გადიან მკერდის ზედა ნაწილში ჩარჩოს დასაყრდენად.
აღმოფხვრა დეფექტები გულმკერდის არეში და ქვიშის ქაღალდის გამოყენებით, შემდეგ კი სურვილისამებრ შეღებეთ ხის ზედაპირი.

ნაბიჯი #4: ელექტრონული კომპონენტების დაკავშირება

შეაერთეთ სერვო სიგნალის ხაზი GPIO პინ 18-ზე Raspberry Pi-ზე. სერვოსთვის სიმძლავრე და დამიწება უნდა იყოს დაკავშირებული ბატარეის კვების ტერმინალებთან.
დააკავშირეთ ღილაკის ერთი პინი Pi-ს GPIO 25 პინზე და 10k ohm რეზისტორის მეშვეობით Pi-ის 3.3V მიწოდების ძაბვის პინზე. შეაერთეთ ღილაკის მეორე პინი Pi-ს დამიწის ქინძისთავთან.
შეაერთეთ ბატარეის და Pi-ის დამიწების მილები.
დააინსტალირეთ Pi კამერა გულმკერდის ზედა ხვრელში და შეაერთეთ კაბელი Pi მიკროკომპიუტერთან.

ნაბიჯი #5: OpenCV-ის შედგენა

ამ ეტაპზე, თქვენ უნდა დააინსტალიროთ OpenCV-ის უახლესი ვერსია თქვენს Raspberry Pi-ზე. სამწუხაროდ, თქვენ ჯერ უნდა შეადგინოთ OpenCV წყაროდან, რადგან ძველი ორობითი ვერსია არ შეიცავს პროექტში გამოყენებულ სახის ამოცნობის ალგორითმებს. Pi-ზე OpenCV-ის შედგენას დაახლოებით 5 საათი სჭირდება.
ჩართეთ Pi და დაუკავშირდით მას ტერმინალის სესიის საშუალებით.
გაუშვით შემდეგი ბრძანებები OpenCV დამოკიდებულებების დასაყენებლად:

sudo apt-get განახლება && sudo apt-get დააინსტალირე build-essential cmake pkg-config python-dev libgtk2.0-dev libgtk2.0 zlib1g-dev libpng-dev libjpeg-dev libtiff-dev libjasper-dev libavcodec-devs

გაუშვით შემდეგი ბრძანებები OpenCV-ის უახლესი ვერსიის საწყისი კოდის ჩამოსატვირთად და გასახსნელად:

wget http://downloads.sourceforge.net/project/opencvlibrary/opencv-unix/2.4.7/opencv-2.4.7.tar.gz && tar zxvf opencv-2.4.7.tar.gz

შეასრულეთ შემდეგი ბრძანებები, რათა მოემზადოთ OpenCV კოდის შედგენისთვის:

cd opencv-2.4.7 && cmake -DCMAKE_BUILD_TYPE=RELEASE -DCMAKE_INSTALL_PREFIX=/usr/local -DBUILD_PERF_TESTS=OFF -DBUILD_opencv_gpu=OFF -DBUILD_loc=OFFv_

შეასრულეთ ამ ბრძანებას OpenCV კრებულის გასაშვებად (გთხოვთ გაითვალისწინოთ, რომ შედგენას დაახლოებით 5 საათი სჭირდება):

მას შემდეგ რაც OpenCV დაასრულებს კომპილაციას, გაუშვით ეს ბრძანება Pi-ის დასაყენებლად:

ნაბიჯი #6: ტესტი სახის ამოცნობა

ამ ეტაპზე ჩვენ შევამოწმებთ სახის ამოცნობის ალგორითმებს, რომლებიც საშუალებას მოგცემთ გახსნათ მკერდი.
ჩამოტვირთეთ ამ პროექტის პროგრამული უზრუნველყოფა github საცავიდან (სქოლიო: https://github.com/tdicola/pi-facerec-box).
გახსენით არქივი და დააკოპირეთ შინაარსი Pi-ის დირექტორიაში.
Pi-ზე ტერმინალის სესიის დროს, დაათვალიერეთ დირექტორია და გაუშვით შემდეგი ბრძანება ტესტის სკრიპტის გასაშვებად:

sudo python capture-positives.py

სანამ სკრიპტი მუშაობს, შეგიძლიათ დააჭიროთ მკერდზე მდებარე ღილაკს Pi-ს კამერის გამოყენებით ფოტოების გადასაღებად. სკრიპტი შეეცდება ამოიცნოს ერთი სახე გადაღებულ სურათში და შეინახოს იგი სწორად გადაღებულ კადრად ./training/positive subdirectory.
ყოველ ჯერზე სურათის გადაღებისას, ჩარჩო იწერება capture.pgm ფაილში. მისი ნახვა შეგიძლიათ მისამართზე გრაფიკული რედაქტორიიმის დასადგენად, თუ როგორ იღებს და განსაზღვრავს Pi კამერა თქვენი სახის სურათს.
გამოიყენეთ ღილაკი თქვენი სახის 5 ან მეტი სურათის გადასაღებად, რათა მიიღოთ სწორი შედეგი. შეეცადეთ მიიღოთ სურათები სხვადასხვა კუთხით, განსხვავებული განათებით და ა.შ. ფოტოებზე ხედავთ ჩემს მიერ მიღებული სახის გამოსახულებებს.
თუ გაინტერესებთ, შეგიძლიათ გაეცნოთ ./training/negative დირექტორიას, რომელიც მასპინძლობს სურათებს AT&T-ის სახის ამოცნობის მონაცემთა ბაზიდან, რომელიც შეიძლება გამოყენებულ იქნას როგორც ადამიანების მაგალითები, რომლებსაც არ უნდა ჰქონდეთ წვდომა გულმკერდის გახსნაზე.
სწორი სურათების მიღების შემდეგ, შეასრულეთ შემდეგი ბრძანებები სწორი და არასწორი სატესტო სურათების დასამუშავებლად და სახის ამოცნობის ალგორითმის შესამოწმებლად (გაითვალისწინეთ, რომ ამ საცდელ ოპერაციას დაახლოებით 10 წუთი სჭირდება):

პითონის მატარებელი.py

ნაბიჯი # 7: სერვო კონფიგურაცია

ამ ეტაპზე აუცილებელია სერვო პულსის სიგანეების დადგენა საკეტის ჩაკეტვისა და განბლოკვისთვის.
Raspberry Pi მიკროკომპიუტერისა და ჩამკეტის სერვოსთვის მიწოდებული დენის საშუალებით, დაუკავშირდით Pi-ს ტერმინალის სესიაზე. დარწმუნდით, რომ გულმკერდი ღიაა, რათა დაინახოთ სერვო მოძრაობა შეფერხების გარეშე.
შეასრულეთ შემდეგი ბრძანება ინტერაქტიული პითონის სესიის დასაწყებად, როგორც root (თქვენ უნდა გქონდეთ წვდომა GPIO პინებზე და სერვოს გადაადგილების შესაძლებლობა):

სუდო პითონი

IN ბრძანების ხაზი Python >>>, შეიყვანეთ ეს ბრძანება RPIO სერვო ბიბლიოთეკის ჩასატვირთად:

RPIO იმპორტის PWM-დან

შემდეგი, შეიყვანეთ შემდეგი ბრძანება:

სერვო = PWM.Servo()

დაბოლოს, გაუშვით ეს ბრძანება, რომ გადაიტანოთ სერვო ჩამკეტი ცენტრალურ პოზიციაზე:

servo.set_servo(18, 1500)

პარამეტრი 1500 set_servo-სთვის განსაზღვრავს პულსის სიგანეს დისკისთვის მიკროწამებში. ექსტრემალური მნიშვნელობები მერყეობს 1000-დან 2000 წლამდე.
სცადეთ set_servo ფუნქცია სხვადასხვა პულსის სიგანეებით, სანამ არ მიიღებთ მნიშვნელობებს, რომლებიც იწვევენ ჩამკეტის დახურვას და სწორად გახსნას, როგორც ეს ნაჩვენებია ფოტოებში.
არ დაგავიწყდეთ, რომ თქვენ შეგიძლიათ ამოიღოთ სერვო როკერი და ხელახლა მიამაგროთ ის, რომ სწორად მოაწყოთ სამაგრი სერვოზე.
მნიშვნელობების გამოცნობის შემდეგ გახსენით config.py შიგნით ტექსტის რედაქტორისუპერმომხმარებლის უფლებებით და შეცვალეთ შემდეგი მნიშვნელობები:
დააყენეთ LOCK_SERVO_UNLOCKED პულსის სიგანის მნიშვნელობის ტოლი საკეტის პოზიციის განბლოკვისთვის - განბლოკვა. ჩემს აპარატზე შესაბამისი მნიშვნელობა არის 2000.
დააყენეთ LOCK_SERVO_LOCKED იმის დასადგენად, არის თუ არა ჩამკეტის პოზიცია დაბლოკილი - ჩაკეტილი. ჩემს შემთხვევაში ეს მნიშვნელობა არის 1100.

ნაბიჯი #8: გაუშვით პროგრამა

სახის ამოცნობის შემოწმებისა და სერვოს დაკალიბრების შემდეგ, შეგიძლიათ პროგრამის კოდის გაშვება!
Raspberry Pi-ს მიკროკომპიუტერთან და ჩამკეტ სერვოსთან მიწოდებული ელექტროენერგიით, დაუკავშირდით Pi-ს ტერმინალის სესიაზე და დაათვალიერეთ პროექტის root დირექტორიაში.
შეასრულეთ შემდეგი ბრძანება კოდის გასაშვებად (ფრთხილად, რადგან ის მაშინვე დაბლოკავს მკერდს):

sudo python box.py

ტესტის მონაცემების ჩამოტვირთვის შემდეგ (ამას რამდენიმე წუთი სჭირდება), მიმართეთ კამერას თქვენს სახეზე და დააჭირეთ ღილაკს სახის ამოცნობის მცდელობისთვის.
თუ გულმკერდი ამოიცნობს თქვენს სახეს, სერვო იმუშავებს და განბლოკავს საკეტს. თუ თქვენი სახე არ არის ამოცნობილი, ტერმინალი აჩვენებს შეტყობინებას, რომელიც მიუთითებს იმაზე, თუ რამდენად ახლოს იყო თქვენი სახე ტესტის სურათთან.
სახის ამოსაცნობად აუცილებელია, რომ გადაღებული სურათი ემთხვეოდეს ტესტის სურათს 2000 ან ნაკლები ნდობის დონით. თუ თქვენი სახე ემთხვევა სურათის ნიმუშის მონაცემებს, მაგრამ ნდობა დაბალია, შეგიძლიათ შეცვალოთ ნდობის ზღვარი config.py-ში (POSITIVE_THRESHOLD პარამეტრით). თუ ამოცნობა ჯერ კიდევ არ არის სანდო, მაშინ ატვირთეთ უფრო შესაბამისი გადაღებული სურათები და ხელახლა გაუშვით ამოცნობის ტესტი. სახის ამოცნობის ალგორითმი ამ პროექტში დიდად არის დამოკიდებული სახის განათებაზე, ამიტომ შეეცადეთ გქონდეთ იგივე განათების წყარო, როგორც თქვენს საცდელ მცდელობებში (ან დაამატეთ რამდენიმე დამატებითი სურათი სხვადასხვა განათების პირობებში).
გულმკერდის გახსნის შემდეგ კვლავ დააჭირეთ ღილაკს, რომ დაიხუროს. ამისთვის სახის ამოცნობის ოპერაცია არ არის საჭირო.
თუ გულმკერდს უჭირს გახსნა და ვერ ცნობს თქვენს სახეს, მაშინ მიჰყევით სერვო კონფიგურაციის ნაბიჯებს, რათა ხელით გადაიტანოთ სერვო განბლოკვის პოზიციაზე set_servo ბრძანების გამოყენებით.

OpenCV არის პოპულარული ფუნქციების ბიბლიოთეკა მანქანური ხედვა, რომელიც რობოტებს საშუალებას აძლევს ამოიცნონ მიმდებარე სამყაროში არსებული ობიექტები. OpenCV გამოიყენება ნავიგაციისთვის, დაბრკოლებების აღმოსაჩენად, სახის და ჟესტების ამოცნობისთვის. ეს სტატია შემოგთავაზებთ ნაბიჯ ნაბიჯ ინსტრუქციები OpenCV-ის ინსტალაციის შესახებ Raspberry Pi 3 ერთბორტ კომპიუტერზე ეს სტატია ასევე წინ უსწრებს გაკვეთილების სერიას, რომელიც მიზნად ისახავს OpenCV-ის ძირითადი ფუნქციების დაუფლებას.

ნაბიჯი 1. თავისუფალი ადგილი

OpenCV და სხვადასხვა დამხმარე პაკეტები ერთად საკმაოდ დიდ ადგილს იკავებს. რეკომენდირებულია მინიმუმ 16 GB SD ბარათის გამოყენება. პირველი, რაც უნდა გააკეთოთ OpenCV-ის ინსტალაციამდე, არის ფაილური სისტემის გაფართოება, რათა დაფაროს SD ბარათის მთელი მოცულობა. ეს კეთდება Raspbian კონფიგურაციის მენიუს გამოყენებით. მივდივართ ტერმინალში და შევიყვანთ ბრძანებას: $ sudo raspi-config გაიხსნება მენიუ, რომელშიც უნდა აირჩიოთ ყველაზე მაღალი ელემენტი: დააჭირეთ Enter და შემდეგ ღილაკს. . ამის შემდეგ, ჩვენ გადატვირთავთ სისტემას ბრძანებით: $ sudo reboot თუ თქვენი SD ბარათი მხოლოდ 8 GB ზომისაა, შეგიძლიათ წაშალოთ რაიმე არასაჭირო, მაგალითად, wolfram-engine პაკეტი.

ნაბიჯი 2: დააინსტალირეთ დამოკიდებულებები

ამისთვის სრულფასოვანი მუშაობა OpenCV-ით დაგვჭირდება არსებული პაკეტების განახლება და რამდენიმე ახლის დაყენება. დავიწყოთ განახლებით.

$ sudo apt-get განახლება $ sudo apt-get განახლება ინტერნეტის სიჩქარიდან გამომდინარე, ამ ოპერაციებს დაახლოებით 5-10 წუთი დასჭირდება. შემდეგ დააინსტალირეთ cmake და რამდენიმე სხვა სასარგებლო რამ სისტემაში: $ sudo apt-get install build-essential cmake pkg-config შემდეგი არის პაკეტები გამოსახულების ცნობილ ფორმატებთან მუშაობისთვის: $ sudo apt-get install libjpeg-dev libtiff5-dev libjasper -dev libpng12- dev პაკეტები ვიდეოსთან მუშაობისთვის: $ sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev $ sudo apt-get install libxvidcore-dev libx264-dev პაკეტები ეკრანის მარტივი ფორმების შესაქმნელად. ეს ყველაფერი ასევე საჭირო იქნება მოგვიანებით.

$ sudo apt-get install libgtk2.0-dev სპეციალური დაჩქარებული ოპერაციები მატრიცებზე.

$ sudo apt-get install libatlas-base-dev gfortran Python სათაურის ფაილები 2.7 და 3 $ sudo apt-get install python2.7-dev python3-dev

ნაბიჯი 3. ჩამოტვირთეთ OpenCV საცავიდან პირველ რიგში, ჩამოტვირთეთ არქივი თავად OpenCV-ით. ამისათვის გადადით /home/pi/Downloads საქაღალდეში: $ cd ~/Downloads ჩამოტვირთეთ არქივი wget-ის გამოყენებით და გახსენით იგი: $ wget -O opencv.zip https://github.com/opencv/opencv/archive/ master .zip $ unzip opencv.zip შემდეგი, ჩამოტვირთეთ პაკეტი დამატებითი მასალებით - opencv_contrib.$ wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/master.zip $ unzip opencv_contrib.zip ნაბიჯი 4: ვირტუალური გარემოსანამ OpenCV-ს შემდგომ დააინსტალირებთ, ჩვენ ცოტას გავასუფთავებთ. მოდით შევქმნათ ვირტუალური გარემო, რომელიც დაიცავს ჩვენს შემდგომ ექსპერიმენტებს ძირითადი ნაწილისგან

ოპერაციული სისტემა
. ეს სასარგებლოა იმ შემთხვევაში, თუ თქვენ გჭირდებათ ამოღება
მიმდინარე ვერსია
opencv და დააინსტალირეთ ახალი. დავიწყოთ პიპ პაკეტის მენეჯერის ინსტალაციით: $ wget https://bootstrap.pypa.io/get-pip.py $ sudo python get-pip.py შემდეგ დააინსტალირეთ ვირტუალური გარემოს მენეჯერი: $ sudo pip install virtualenv virtualenvwrapper $ sudo rm -rf ~ /.cache/pip მოდით დავამატოთ რამდენიმე ხაზი მომხმარებლის პროფილში, რომელიც ინახება ~/.profile ფაილში: $ echo -e "\n# virtualenv და virtualenvwrapper" >> ~/.profile $ echo "ექსპორტი WORKON_HOME=$HOME/.virtualenvs " >> ~/.profile $ echo "source /usr/local/bin/virtualenvwrapper.sh" >> ~/.profile ახლა თქვენ უნდა შეასრულოთ შემდეგი სამი ნაბიჯი:

დახურეთ ყველა ტერმინალის ფანჯარაზოგადად, ახლა რეკომენდებულია ამ ბრძანების შეყვანა ყოველი შესვლისას. შემდეგი, ჩვენ ვქმნით ვირტუალურ გარემოს სახელწოდებით “cv”: $ mkvirtualenv cv -p python3 იმისათვის, რომ შეამოწმოთ, რომ ვირტუალური გარემო სწორად არის დაინსტალირებული, გადატვირთეთ Raspberry Pi: $ sudo reboot გახსენით ტერმინალი და შედით გარემოში: $ source ~ /.profile $ workon cv მაჩვენებელი იმისა, რომ ვირტუალურ გარემოში ვართ, ბრძანების სტრიქონის დასაწყისში იქნება პრეფიქსი (cv).

ბოლო, რაც უნდა გააკეთოთ OpenCV-ის შექმნამდე არის NumPy მათემატიკის პაკეტის დაყენება: $ pip install numpy

ნაბიჯი 5. შეადგინეთ და დააინსტალირეთ OpenCV

ადრე შექმნილ ვირტუალურ გარემოში ყოფნისას მოდით გადავიდეთ საქაღალდეში წყარო კოდებიგახსენით CV და გაუშვით ბრძანებები: $ cd ~/ჩამოტვირთვები/opencv-master $ mkdir build $ cd build $ cmake -D CMAKE_BUILD_TYPE=RELEASE \ -D CMAKE_INSTALL_PREFIX=/usr/local \ -D INSTALL_PYTHON_THON_PA_PL=D INSTALL_PYTHON_THON_PA_D ჩამოტვირთვები /opencv_contrib-master/modules -D BUILD_EXAMPLES=ON .. პროცედურის დასასრულს გამოჩნდება ინსტალაციისთვის მზად OpenCV კომპონენტების სია.

პითონისადმი მიძღვნილი განყოფილება მონიშნულია წითლად. ახლა ყველაზე საინტერესო ნაწილი - ბინარების აწყობა. მიმდინარე საქაღალდის დატოვების გარეშე, გაუშვით make ბრძანება: $ make -j4 j4 ნიშნავს, რომ ჩვენ ავაშენებთ პაკეტს Raspberry Pi-ის ოთხივე ბირთვის გამოყენებით. ეს მნიშვნელოვნად დააჩქარებს პროცედურას, მაგრამ ასეთ პირობებშიც კი აწყობას დაახლოებით საათნახევარი დასჭირდება. კონსტრუქცია უნდა დასრულდეს ასე:

დახურეთ ყველა ტერმინალის ფანჯარაპირადად, შეკრების დროს, სისტემა რამდენჯერმე გაიყინა. ანუ თაგვიც არ მოძრაობდა. გამორთვა/ჩართვა და build-ის გადატვირთვა -j2 გადამრთველით დაეხმარა. ბოლო რაც უნდა გააკეთოთ არის კომპილირებული ბინარის დაინსტალირება პითონის საქაღალდეში: $ sudo make install $ sudo ldconfig

ნაბიჯი 6: დაასრულეთ ინსტალაცია

ინსტალაციის შემდეგ, python-ის სამუშაო საქაღალდეში გამოჩნდება cv2.cpython-34m.so ფაილი, რომელსაც უნდა დაერქვას სახელი უფრო ეიფონიური: $ cd /usr/local/lib/python3.4/site-packages/ $ sudo mv cv2.cpython -34m.so cv2.so იმისათვის, რომ ვირტუალურ გარემოში ყოფნისას ჩვენ შეგვიძლია გამოვიყენოთ OpenCV, ჩვენ გავაკეთებთ ბმულს იქ მიღებული cv2.so: $ cd ~/.virtualenvs/cv/lib/python3.4/ site-packages/ $ ln -s /usr/local/lib/python3.4/site-packages/cv2.so cv2.so

ნაბიჯი 7: შეამოწმეთ

ინსტალაციის სისწორის შესამოწმებლად, მოდით შევიდეთ ვირტუალურ გარემოში, გავუშვით პითონის ინტერპრეტატორი და ვცადოთ cv2 მოდულის იმპორტი: $ source ~/.profile $ workon cv $ python >>> import cv2 >>> cv2.__version__ "3.1 .0" >>> სულ ეს არის - OpenCV წარმატებით დაინსტალირდა! შემდეგ გაკვეთილებში ვისაუბრებთ რობოტიკასთან დაკავშირებით ვიდეო კამერიდან სურათების დამუშავებაზე.

ღია კოდის კომპიუტერული ხედვის ბიბლიოთეკა

ეს არის პითონის პროგრამირების ენის ბიბლიოთეკა, რომელიც ამარტივებს კომპიუტერულ ხედვასთან მუშაობას (მანქანური სწავლების განყოფილება).
გასაგებად, მე გთავაზობთ განიხილოს სახის ამოცნობის პროცესი (კლასიკური), თუ OpenCV არ არსებობდა:

უპირველეს ყოვლისა, თქვენ უნდა გქონდეთ სურათების უზარმაზარი კოლექცია ხალხის სახეებით და მის გარეშე.
ამ ნაკრების სტრუქტურირება - თითოეული სურათის დაკავშირება განმარტებით: არის თუ არა მასზე ადამიანის სახე.
თანაბრად და სწორად დაყავით სტრუქტურირებული კოლექცია სასწავლო და საკონტროლო კომპლექტად.
შემდეგ, მანქანური სწავლების სხვადასხვა მეთოდების ძიებით და კომბინაციით ("ხე", "შემთხვევითი ტყე", "გრადიენტული დაღმართი", "უახლოესი მეზობლები" და ა. ნიმუშები. ამ ეტაპს შეიძლება თვეები დასჭირდეს(!) (დამოკიდებულია ხელმისაწვდომი გამოთვლითი რესურსებიდან)

და OpenCV დეველოპერები ყველას აწვდიან პირველი კლასის კომპიუტერული ხედვის ალგორითმების უფასო კომპლექტს სხვადასხვა აპლიკაციისთვის - აიღეთ და გამოიყენეთ!)

გაფრთხილება:

ქვემოთ განხილულია Raspbian-ზე OpenCV-ის დაყენების სირთულეები, თუმცა, ინსტრუქციები საკმაოდ უნივერსალურია Debian ოჯახის ყველა განაწილებისთვის.
OpenCV-ის ინსტალაციას დიდი დრო სჭირდება (2-3 საათი), მაგრამ თქვენ არ გჭირდებათ მთელი გზის გავლა ერთი ნაბიჯით - შეგიძლიათ გაჩერდეთ და გააგრძელოთ იგივე ადგილიდან.
საჭირო იქნება.
ჩვენ შევასრულებთ ინსტალაციას Raspberry Pi 3-ზე უახლესი ვერსიის სუფთა, ახლად დაყენებულ Raspbian Desktop-ზე. სმ.

მომზადება

საჭიროა 7 GB თავისუფალი ადგილიფლეშკაზე.
ფლეშ დისკზე თავისუფალი სივრცის ხელმისაწვდომობის შესამოწმებლად გახსენით ტერმინალი (Ctrl + Alt + T) და შეიყვანეთ ბრძანება
df -h
თუ არ არის საკმარისი ადგილი, თუმცა ფლეშ დისკის ზომამ უნდა დაუშვას, მაშინ ღირს შემოწმება, არის თუ არა ის გაფართოებული ფაილური სისტემამთელი ხელმისაწვდომი მოცულობისთვის (განაწილების ახალ ვერსიებში ეს ახლა კეთდება ნაგულისხმევად - 2018 წლის აპრილის მდგომარეობით).
თუ სისტემა არ არის ძალიან ახალი, მაშინ შეგიძლიათ გადახვიდეთ ძირითადი პარამეტრების განყოფილებაში
sudo raspi-config
და აირჩიეთ პირველი პუნქტი „1. გააფართოვეთ ფაილური სისტემა“ და შემდეგ გადატვირთეთ Raspberry

საჭირო პაკეტების ინსტალაცია

თუ განახლებები დიდი ხნის განმავლობაში არ განხორციელებულა, მიზანშეწონილია მათი გაკეთება ახლავე
sudo apt-get განახლება -y && sudo apt-get განახლება -y
დააინსტალირეთ პაკეტების ნაკრები წყაროდან პროგრამების შესაქმნელად
sudo apt-get install build-essential cmake pkg-config -y
შემდეგ ვაყენებთ ბიბლიოთეკების კომპლექტს სხვადასხვა ფორმატის გრაფიკულ შინაარსთან მუშაობისთვის
sudo apt-get ინსტალაცია libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev -y
შემდეგი, იგივე ვიდეო შინაარსისთვის.
sudo apt-get ინსტალაცია libavcodec-dev libavformat-dev libswscale-dev libv4l-dev -y sudo apt-get ინსტალაცია libxvidcore-dev libx264-dev -y
დააინსტალირეთ highgui მოდულის კომპილაციის პაკეტი ეკრანზე სურათების და ინტერფეისების ჩვენებისთვის
sudo apt-get დააინსტალირე libgtk2.0-dev -y
და ბოლოს, ხაზოვანი ალგებრის ბიბლიოთეკა და Fortran შემდგენელი:
sudo apt-get დააინსტალირე libatlas-base-dev gfortran -y

პითონი

შემდეგი, დააინსტალირეთ Python (ან Python). ძირითადი ვერსიები 2,7 და 3 უკვე ჩაშენებულია Raspbian-ში, მაგრამ საჭირო იქნება დამატებითი პაკეტები:
sudo apt-get install python2.7-dev python3-dev -y
შემდეგი, პითონისთვის (ან პითონისთვის), გირჩევთ დააინსტალიროთ virtualenv და virtualenvwrapper უტილიტები - ეს არის ანალოგი და მხოლოდ Python-ისთვის, ისინი საშუალებას გაძლევთ იმუშაოთ პითონთან შერჩეულ "ვირტუალურ გარემოში" - გარკვეული პაკეტების ნაკრები. ვერსიები (Ruby gemsets-ის ანალოგები) - ეს მოსახერხებელია, როდესაც მუშაობთ რამდენიმე პროექტზე ბიბლიოთეკების სხვადასხვა კომპლექტით (და განსაკუთრებით ბიბლიოთეკების სხვადასხვა ვერსიით): რომ გადახვიდეთ, ვთქვათ, Python 2.7-ზე OpenCV 3.1-ით, დაგჭირდებათ მხოლოდ ერთის შეყვანა. ბრძანება ტერმინალში. დააინსტალირეთ:
sudo pip install virtualenv virtualenvwrapper sudo rm -rf ~/.cache/pip echo -e "\n# virtualenv and virtualenvwrapper" >> ~/.profile echo "export WORKON_HOME=$HOME/.virtualenvs" >> ~/.profile echo "source /usr/local/bin/virtualenvwrapper.sh" >> ~/.profile source ~/.profile
ეს ავსებს დამოკიდებულებებს.
ჩვენ ვქმნით ვირტუალურ გარემოს virtualenv-ის გამოყენებით. შემდეგ კი თქვენ უნდა გადაწყვიტოთ პითონის ვერსია - თუ მიზანია ნულიდან პროექტის შექმნა, მაშინ უნდა აირჩიოთ python3, წინააღმდეგ შემთხვევაში - python2.
პითონის ენის ისტორიული განვითარების პროცესში ბევრი დაიწერა 2.7 ვერსიის აქტუალურობის დროს. კარგი პროგრამები. და ახლაც, Python 2.7-ის სტაბილური 3.5 ვერსიების დროს, ის ჯერ კიდევ არ არის დავიწყებული და აქტიურად გამოიყენება და მხარდაჭერილია - მოხდა ფილიალი. იგივეა პითონის ბიბლიოთეკებთან დაკავშირებით - ყველა არ იმუშავებს ერთნაირად კარგად როგორც 2.7-ზე, ასევე 3.5-ზე.
mkvirtualenv cv -p python3
ჩვენ დავრწმუნდებით, რომ ახლა ვართ შექმნილ ვირტუალურ გარემოში cv. ამის ამოცნობა შესაძლებელია კომბინაციით „(cv)“ კონსოლში მიმდინარე აქტიური ხაზის გვერდით:

დაბოლოს, დააინსტალირეთ Numpy ბიბლიოთეკა მოსახერხებელი მუშაობისთვის დიდი განზომილებების მასივებთან და მატრიცებთან
pip install numpy

ღია CV-ის ჩამოტვირთვა საცავიდან

შექმენით საქაღალდე ბიბლიოთეკისთვის თქვენს მთავარ დირექტორიაში და გადადით მასში
cd ~ mkdir opencv cd opencv/
მოდით გადავწყვიტოთ OpenCV ვერსია.
3.0 ვერსიის გამოშვების შემდეგ, 2.4.x-ის ძველი ვერსიების მხარდაჭერა და გამოშვება გრძელდება და მათ შორის მნიშვნელოვანი განსხვავებებია. მაგალითად, დამატებითი მოდულების "წვლილის" პაკეტი ხელმისაწვდომია მხოლოდ ახალი ვერსიებისთვის 3+.
მოდით გადავიდეთ პროექტის მთავარ გვერდზე "გამოშვებების" განყოფილებაში. მე გთავაზობთ შემდგომ დააინსტალიროთ უახლესი ვერსია (3+ და არა 2.4.x.x) და არ მიიღოთ უახლესი ვერსია:

ამრიგად, არჩევანი 3.4.0 ვერსიაზე დაეცა.
ჩამოტვირთვის ბმულის მისაღებად გადადით ოფლაინზე. გახსენით CV საცავი გამოშვებების განყოფილებაში: https://github.com/opencv/opencv/releases და დააკოპირეთ ბმული არჩეული ვერსიის zip არქივში:

დავუბრუნდეთ Raspberry-ს.
სანამ იმყოფებით /opencv საქაღალდეში, გაუშვით ბრძანება წყაროების ჩამოსატვირთად:
wget -O opencv.zip https://github.com/opencv/opencv/archive/3.4.0.zip
ეს ბრძანება ჩამოტვირთავს არქივს და დაარქმევს მას opencv.zip
მოდით გავხსნათ გადმოწერილი არქივი და წაშალოთ:
unzip opencv.zip rm opencv.zip
ჩამოტვირთეთ და გახსენით დამატებითი მოდულების იგივე ვერსია წვლილი შეიტანოს(ამ შემთხვევაში - 3.4.0). გამოშვების გვერდი. საცავი: https://github.com/opencv/opencv_contrib/releases
wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/3.4.0.zip unzip opencv_contrib.zip rm opencv_contrib.zip
შედეგი უნდა იყოს შემდეგი (ls ბრძანება აჩვენებს მიმდინარე საქაღალდის შინაარსს):

OpenCV-ის შედგენა და ინსტალაცია

მოდით, კიდევ ერთხელ დავრწმუნდეთ, რომ ჩვენ ვართ OpenCV-სთვის შექმნილ ვირტუალურ გარემოში (Python-ის ინსტალაციის თავი). თუ გარემო უკვე შექმნილია, მაშინ შეგიძლიათ მასზე გადასვლა workon cv ბრძანებით
გადადით შეფუთული OpenCV არქივის საქაღალდეში (ვერსია და, შესაბამისად, საქაღალდის სახელი შეიძლება განსხვავდებოდეს):
CD opencv-3.4.0/
შემდეგი, ჩვენ ვასრულებთ ბრძანებების სერიას ინსტალერის შექმნის პროცესის დასაწყებად.
ეს არის 3 ბრძანება - ბოლო არის მრავალ ხაზოვანი, მასში სპეციალურიყურადღება მიაქციეთ შეუფუთავი კონტრიბუციის არქივის საქაღალდის გზას:
mkdir build cd build cmake -D CMAKE_BUILD_TYPE=RELEASE \ -D CMAKE_INSTALL_PREFIX=/usr/local \ -D INSTALL_PYTHON_EXAMPLES=ON \ -D OPENCV_EXTRA_MODULES_PATH= ~/opencv/opencv_contrib-3.4.0/modules\ -D BUILD_EXAMPLES=ჩართულია ..
თუ მშენებლობა წარმატებულია, ჩვენ ვნახავთ შემდეგს. ჩართულია მომენტშიჩვენ ახლახან შევასრულეთ OpenCV ინსტალერის შედგენის ყველა პირობა, ამიტომ ყურადღება მიაქციეთ Python3 (ან Python2) განყოფილებას, ის უნდა იყოს როგორც ეკრანის სურათზე, წინააღმდეგ შემთხვევაში (ან წარუმატებლობის შემთხვევაში) შეამოწმეთ:

შესაძლოა ვირტუალური გარემო (cv) არ იყო გააქტიურებული ასამბლეის დროს - workon cv
მეტი შესაძლო მიზეზი fail: არასწორი აბსოლუტური გზა დამატებითი მოდულების საქაღალდეში წვლილი შეიტანოს
როგორც ბოლო საშუალება, შეგიძლიათ შეამოწმოთ მიმდინარე დირექტორია - თქვენ უნდა იყოთ შერჩეული ვერსიის შეუფუთავი OpenCV არქივის build საქაღალდეში.
და ბოლოს, დარწმუნდით, რომ ემთხვევა ძირითადი და საწვრთნელი პაკეტების გამოშვების ვერსიები

ნებისმიერ შემთხვევაში, არა უშავს) თქვენ უნდა გადაამოწმოთ ყველაფერი და თავიდან დაიწყოთ მშენებლობა

თუ ასამბლეამ შეუფერხებლად ჩაიარა, მაშინ OpenCV ინსტალერის შედგენის ყველა პირობა დაკმაყოფილებულია და ახლა ჩვენ შევკრებთ ჩვენს ახალ, სტაბილურ OpenCV დისტრიბუციას დამატებითი მოდულებით საწყისი კოდიდან!
დავიწყოთ შედგენა
პარამეტრი -j4ნიშნავს ჩართული პროცესორის ბირთვების რაოდენობას, Raspberry Pi 3 აქვს 4.
ყურადღება!! ამ პროცესს საუკეთესო შემთხვევაში დაახლოებით 1,5 საათი დასჭირდება!!!
make -j4
თუ შევხედავთ ავარიას შედგენის პირველ 5 წუთში, ეს შეიძლება მოხდეს იდეალურ პირობებშიც კი, შემდეგ ჩვენ აღვადგენთ შედეგს და ვაწარმოებთ კომპილაციას ერთ ბირთვზე:
გააკეთე სუფთა გააკეთე
წარმატების შემთხვევაში ვნახავთ შემდეგს - შედგენის პროცესი 100%-ით დასრულებულია

რჩება მხოლოდ აწყობილი ინსტალერის გაშვება ბრძანებით
sudo make install sudo ldconfig
ესე იგი, OpenCV დაინსტალირებულია Raspberry-ზე! იმისათვის, რომ მისი გამოყენება მოსახერხებელი იყოს, რჩება მხოლოდ მისი გადაგზავნა OpenCV-ზე შექმნილ Python-ის ვირტუალურ გარემოში (cv). მოდით განვსაზღვროთ დირექტორია - რადგან OpenCV არის პითონის ბიბლიოთეკა, ის უნდა იყოს სხვა ბიბლიოთეკების საქაღალდეში, მოდით შევამოწმოთ:

გუნდი lsაჩვენებს მითითებული დირექტორიას შიგთავსს ტერმინალში
არ დაგავიწყდეთ ბრძანებაში მიუთითოთ Python საქაღალდე იმ ვერსიით, რომელზეც რეალურად დააინსტალირეთ OpenCV

ls /usr/local/lib/python3.5/site-packages/

გამონაკლის შემთხვევებში, ბიბლიოთეკა შეიძლება განთავსდეს ახლომდებარე საქაღალდეში დისტანციური პაკეტები:
ls /usr/local/lib/python3.5/dist-packages/
მოდით გადავიდეთ ამ დირექტორიაში
cd /usr/local/lib/python3.5/site-packages/
მოდით გადავარქვათ სახელი ბიბლიოთეკის ფაილს - ეს გაადვილებს მის გამოძახებას Python კოდით
sudo mv cv2.cpython-35m-arm-linux-gnueabihf.so cv2.so
მოდით დავაკოპიროთ ფაილის სრული გზა.

მოდით გადავიდეთ ვირტუალური გარემოს cv ბიბლიოთეკის დირექტორიაში:
cd ~/.virtualenvs/cv/lib/python3.5/site-packages/
მოდით შევქმნათ სიმლინკი აქ OpenCV-ზე:
ln -s /usr/local/lib/python3.5/site-packages/cv2.so cv2.so
მოდით შევამოწმოთ შედეგი ls ბრძანებით:

ექსპერტიზა

გახსენით ახალი ტერმინალის ფანჯარა
წყარო ~/.profile workon cv python import cv2 cv2.__version__
თუ ყველაფერი სწორად გაკეთდა, მაშინ OpenCV ბიბლიოთეკა იმპორტირებულია Python კონსოლში შეცდომების გარეშე.

იმპორტის შეცდომის შემთხვევაში, ყურადღებით შეამოწმეთ, რომ ბიბლიოთეკის ფაილს დაარქვეს სწორად სახელი და შეიქმნა მისი სიმლინკი (გაფართოება - .so), ასევე წარმატებით გადასულიყო cv ვირტუალურ გარემოში.

დაკავშირებული სტატიები