Per lavoro puo' essere che puo' essere che mi trovi a dover contare delle lastre dei rilevatori di radon e volevo provare a fare qualcosa di mio con OpenCV. Per prova ho preso delle immagini da Google Images e le ho trattate con OpenCV e gli Hough Circles
Immagine non elaborata con sovrapposizione del riconoscimento e del numero degli eventi
Elabotazione Conteggio 126 eventi
questo e' il file Python che e' preso dagli esempi di OpenCV con minime modifiche
======================================================= import cv2 import numpy as np # Read image as gray-scale img = cv2.imread('cr39film.png', cv2.IMREAD_COLOR) cv2.imshow('Originale',img) # Convert to gray-scale gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # Blur the image to reduce noise img_blur = cv2.medianBlur(gray, 5) # Apply hough transform on the image circles = cv2.HoughCircles(img_blur, cv2.HOUGH_GRADIENT, 1, img.shape[0]/32, param1=50, param2=5, minRadius=0, maxRadius=10) conta = 0 # Draw detected circles if circles is not None: circles = np.uint16(np.around(circles)) for i in circles[0, :]: # Draw outer circle #cv2.circle(img, (i[0], i[1]), i[2], (0, 255, 0), 2) # Draw inner circle conta=conta+1 cv2.circle(img, (i[0], i[1]), 2, (0, 0, 255), 2) print ("Numero identificazioni :"+str(conta)) cv2.imshow('tt',img) cv2.waitKey(0) cv2.destroyAllWindows()
=======================================================
Ho letto sul giornale che i Vigili Urbani di Firenze hanno a disposizione un sistema automatico di lettura delle targhe automobilistiche in modo da interrogare poi un database della motorizzazione per elevare multe...mi sono chiesto...quanto e' complicato questo metodo??
Avevo letto che la libreria OpenCV permetteva di fare il riconoscimento automatico ma frugando ho trovato un prodotto gia' fatto ovvero OpenALPR,,vale la pena provarlo facendo una prova veloce
(ps. per motivi di privacy le targhe sono oscurate, fidatevi che i risultati sono corrispondenti alla realta')
Fornendo all'algoritmo questa foto
Si ha come risultato questa lista. Il primo candidato, quello con il punteggio piu' alto, corrisponde al vero numero di targa.
Non tutte le immagini forniscono dati corretti e per assurdo se si fotografa una targa in primissimo piano l'algoritmo fallisce miseramente
Un amico mi ha chiesto se era possibile sviluppare una piccola applicazione interattiva per il museo di Scienze Geologiche del Dipartimento di Scienze della Terra di Firenze
L'idea di base era quella di usare Kinect per cambiare la slide ad una presentazione a video
L'idea mi sembrava carina ma piuttosto costosa in quanto necessita di un Kinect e di un computer discretamente potente per fare processare i dati (Kinect di suo non interpreta le gesture, e' solo un insieme di sensori)..volevo vedere se era possibile fare la stessa cosa usando solo una Raspberry ed una normale Webcam
L'idea di base e' stata rubata a questo sito semplificando di molto per cio' che non mi occorre. In pratica sull'immagine della Webcam sono state create due aree sensibili (i due cerchietti in alto, per essere precisi vengono letti solo due pixel), se l'utente passa la mano sui cerchietti (o meglio se viene individuata una variazione dell'immagine in corrispondenza dei pixel sensibili) viene generato un evento.
Per evitare falsi allarmi e' stato impostato una distanza minima di 1.5 secondi tra due eventi
Il programma processa i dati della webcam, crea una immagine differenza tra le immagini in sequenza e crea una immagine maschera dei pixel che risultano cambiati (si puo' vedere premendo il tasto d durante l'esecuzione). La condizione di pixel non cambiato e' 0, la condizione di cambiato e' 255
Se viene generato un evento allora mediante il programma xdotool viene inviato un segnale Freccia Destra/ Freccia Sinistra alla finestra che ha per nome "'presentazione.odp - LibreOffice Impress"
Ovviamente ci sono dei limiti all'utilizzo (del tipo la webcam non deve essere orientata verso il corridoio del museo altrimenti vengono generati eventi ogni volta che passa una persona) ma considerando il costo dell'applicazione e le possibili applicazioni (si puo' fare per esempio un quiz interattivo per bambini) direi che e' abbastanza interessante
----------------------------------------------------------------------------- #!/usr/bin/env python import cv import time from scipy import * from scipy.cluster import vq import numpy import sys, os, random#, hashlib from math import * class Target: def __init__(self): if len( sys.argv ) > 1: self.writer = None self.capture = cv.CaptureFromFile( sys.argv[1] ) frame = cv.QueryFrame(self.capture) frame_size = cv.GetSize(frame) else: fps=15 is_color = True self.capture = cv.CaptureFromCAM(0) cv.SetCaptureProperty( self.capture, cv.CV_CAP_PROP_FRAME_WIDTH, 640 ); cv.SetCaptureProperty( self.capture, cv.CV_CAP_PROP_FRAME_HEIGHT, 480 ); frame = cv.QueryFrame(self.capture) frame_size = cv.GetSize(frame) self.writer = None frame = cv.QueryFrame(self.capture) cv.NamedWindow("Museo", 1) def run(self): frame = cv.QueryFrame( self.capture ) frame_size = cv.GetSize( frame ) contatore = 0 tempo_d = 0 tempo_s = 0 # Capture the first frame from webcam for image properties display_image = cv.QueryFrame( self.capture ) # Greyscale image, thresholded to create the motion mask: grey_image = cv.CreateImage( cv.GetSize(frame), cv.IPL_DEPTH_8U, 1 ) # The RunningAvg() function requires a 32-bit or 64-bit image... running_average_image = cv.CreateImage( cv.GetSize(frame), cv.IPL_DEPTH_32F, 3 ) # ...but the AbsDiff() function requires matching image depths: running_average_in_display_color_depth = cv.CloneImage( display_image ) # The difference between the running average and the current frame: difference = cv.CloneImage( display_image ) #t0 = time.time() # For toggling display: image_list = [ "camera", "difference", "threshold"] image_index = 0 # Index into image_list # Prep for text drawing: text_font = cv.InitFont(cv.CV_FONT_HERSHEY_COMPLEX, .5, .5, 0.0, 1, cv.CV_AA ) while True: # Capture frame from webcam camera_image = cv.QueryFrame( self.capture ) frame_t0 = time.time() # Create an image with interactive feedback: display_image = cv.CloneImage( camera_image ) # Create a working "color image" to modify / blur color_image = cv.CloneImage( display_image ) # Smooth to get rid of false positives cv.Smooth( color_image, color_image, cv.CV_GAUSSIAN, 19, 0 ) # Use the Running Average as the static background # a = 0.020 leaves artifacts lingering way too long. # a = 0.320 works well at 320x240, 15fps. (1/a is roughly num frames.) cv.RunningAvg( color_image, running_average_image, 0.320, None ) # Convert the scale of the moving average. cv.ConvertScale( running_average_image, running_average_in_display_color_depth, 1.0, 0.0 ) # Subtract the current frame from the moving average. cv.AbsDiff( color_image, running_average_in_display_color_depth, difference ) # Convert the image to greyscale. cv.CvtColor( difference, grey_image, cv.CV_RGB2GRAY ) # Threshold the image to a black and white motion mask: cv.Threshold( grey_image, grey_image, 2, 255, cv.CV_THRESH_BINARY ) # Smooth and threshold again to eliminate "sparkles" cv.Smooth( grey_image, grey_image, cv.CV_GAUSSIAN, 19, 0 ) cv.Threshold( grey_image, grey_image, 240, 255, cv.CV_THRESH_BINARY ) grey_image_as_array = numpy.asarray( cv.GetMat( grey_image ) ) c = cv.WaitKey(7) % 0x100 if c == 27 or c == 10: break # Toggle which image to show if chr(c) == 'd': image_index = ( image_index + 1 ) % len( image_list ) image_name = image_list[ image_index ] # Display frame to user if image_name == "camera": image = camera_image cv.PutText( image, "O", (50,50), text_font, cv.CV_RGB(255,0,0) ) cv.PutText( image, "O", (590,50), text_font, cv.CV_RGB(0,255,0) ) elif image_name == "difference": image = difference cv.PutText( image, "O", (50,50), text_font, cv.CV_RGB(255,0,0) ) cv.PutText( image, "O", (590,50), text_font, cv.CV_RGB(0,255,0) ) elif image_name == "threshold": # Convert the image to color. cv.CvtColor( grey_image, display_image, cv.CV_GRAY2RGB ) image = display_image # Re-use display image here cv.PutText( image, "O", (50,50), text_font, cv.CV_RGB(255,0,0) ) cv.PutText( image, "O", (590,50), text_font, cv.CV_RGB(0,255,0) ) cv.PutText( image, str(contatore), (320,50), text_font, cv.CV_RGB(0,0,255) ) cv.ShowImage( "Museo", image ) #print grey_image_as_array.item((50,50)) if ((grey_image_as_array.item(50,50) == 255) and ((time.time()-tempo_d) > 1.5)): #print time.time()-tempo_d tempo_d = time.time() contatore = contatore + 1 #print "destra" os.system("xdotool key --window $(xdotool search --name 'presentazione.odp - LibreOffice Impress') Left") if ((grey_image_as_array.item(50,590) == 255) and ((time.time()-tempo_s) > 1.5)): #print time.time()-tempo_s tempo_s = time.time() contatore = contatore - 1 #print "sinistra" os.system("xdotool key --window $(xdotool search --name 'presentazione.odp - LibreOffice Impress') Right") if self.writer: cv.WriteFrame( self.writer, image ); if __name__=="__main__": t = Target() t.run()
Una delle funzioni piu' carine di OpenCV e' quella che permette di individuare oggetti in automatico all'interno di una immagine. Il mio obbiettivo sarebbe quello di determinare la presenza di cartelli stradali.
Per una prova ho preso una normale immagine scattata con la fotocamera del cellulare
Ho cercato quindi di individuare in automatico la posizione del cartello di precedenza
Il programma deriva direttamente dagli esempi di OpenCV
------------------------------------------------- #include <stdio.h> #include <iostream> #include "opencv2/core/core.hpp" #include "opencv2/features2d/features2d.hpp" #include "opencv2/highgui/highgui.hpp" #include "opencv2/calib3d/calib3d.hpp" using namespace cv; void readme(); /** @function main */ int main( int argc, char** argv ) { if( argc != 3 ) { readme(); return -1; } Mat img_object = imread( argv[1], CV_LOAD_IMAGE_GRAYSCALE ); Mat img_scene = imread( argv[2], CV_LOAD_IMAGE_GRAYSCALE ); if( !img_object.data || !img_scene.data ) { std::cout<< " --(!) Error reading images " << std::endl; return -1; } //-- Step 1: Detect the keypoints using SURF Detector int minHessian = 400; SurfFeatureDetector detector( minHessian ); std::vector<KeyPoint> keypoints_object, keypoints_scene; detector.detect( img_object, keypoints_object ); detector.detect( img_scene, keypoints_scene ); //-- Step 2: Calculate descriptors (feature vectors) SurfDescriptorExtractor extractor; Mat descriptors_object, descriptors_scene; extractor.compute( img_object, keypoints_object, descriptors_object ); extractor.compute( img_scene, keypoints_scene, descriptors_scene ); //-- Step 3: Matching descriptor vectors using FLANN matcher FlannBasedMatcher matcher; std::vector< DMatch > matches; matcher.match( descriptors_object, descriptors_scene, matches ); double max_dist = 0; double min_dist = 100; //-- Quick calculation of max and min distances between keypoints for( int i = 0; i < descriptors_object.rows; i++ ) { double dist = matches[i].distance; if( dist < min_dist ) min_dist = dist; if( dist > max_dist ) max_dist = dist; } printf("-- Max dist : %f \n", max_dist ); printf("-- Min dist : %f \n", min_dist ); //-- Draw only "good" matches (i.e. whose distance is less than 3*min_dist ) std::vector< DMatch > good_matches; for( int i = 0; i < descriptors_object.rows; i++ ) { if( matches[i].distance < 3*min_dist ) { good_matches.push_back( matches[i]); } } Mat img_matches; drawMatches( img_object, keypoints_object, img_scene, keypoints_scene, good_matches, img_matches, Scalar::all(-1), Scalar::all(-1), vector<char>(), DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS ); //-- Localize the object std::vector<Point2f> obj; std::vector<Point2f> scene; for( int i = 0; i < good_matches.size(); i++ ) { //-- Get the keypoints from the good matches obj.push_back( keypoints_object[ good_matches[i].queryIdx ].pt ); scene.push_back( keypoints_scene[ good_matches[i].trainIdx ].pt ); } Mat H = findHomography( obj, scene, CV_RANSAC ); //-- Get the corners from the image_1 ( the object to be "detected" ) std::vector<Point2f> obj_corners(4); obj_corners[0] = cvPoint(0,0); obj_corners[1] = cvPoint( img_object.cols, 0 ); obj_corners[2] = cvPoint( img_object.cols, img_object.rows ); obj_corners[3] = cvPoint( 0, img_object.rows ); std::vector<Point2f> scene_corners(4); perspectiveTransform( obj_corners, scene_corners, H); //-- Draw lines between the corners (the mapped object in the scene - image_2 ) line( img_matches, scene_corners[0] + Point2f( img_object.cols, 0), scene_corners[1] + Point2f( img_object.cols, 0), Scalar(0, 255, 0), 4 ); line( img_matches, scene_corners[1] + Point2f( img_object.cols, 0), scene_corners[2] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 ); line( img_matches, scene_corners[2] + Point2f( img_object.cols, 0), scene_corners[3] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 ); line( img_matches, scene_corners[3] + Point2f( img_object.cols, 0), scene_corners[0] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 ); //-- Show detected matches imshow( "Good Matches & Object detection", img_matches ); waitKey(0); return 0; } /** @function readme */ void readme() { std::cout << " Usage: ./SURF_descriptor <img1> <img2>" << std::endl; }
-------------------------------------------------
per prima cosa ho usato come immagine di training il cartello di precedenza estratto dalla medesima immagine.
Il risultato e' ottimale
a questo punto le cose si complicano. Ho scattato una seconda foto spostandomi di qualche metro per cambiare la prospettiva
Si ha ancora un qualche risultato ma chiaramente basta una piccola modifica per confondere l'algoritmo
Ancora piu' difficile. Invece di tagliare l'immagine ho preso una immagine generica di un cartello di precedenza (da Google Images)
il risultato e' decisamente pessimo
sostanzialmente un esperimento fallito e come al solito "conoscere la risposta aiuta nel risolvere un problema"
Per valutare la potenza di calcolo di Raspberry per un eventuale sistema di controllo, ho ricompilato il programma presentato in questo post modificandolo leggermente (non volevo usare il monitor ma solo una connessione di rete via SSH per interagire con la Raspberry) eliminando il namedWindow
Per compilare il programma non ci sono problemi in quanto le libopencv-dev sono disponibili nei repository senza la necessita' di ricompilare da zero le OpenCV
Sempre giocando con OpenCV e' divertente effettuare il riconoscimento automatico dei volti...una operazione di per se complessa si puo' svolgere sostanzialmente in realtime con poca potenza di calcolo
Prendendo l'esempio dei tutorial (con poche modifiche marginali) si puo' ottenere il risultato sottostante (e' stato modificato un parametro rispetto a quelli di default)
per il corretto funzionamento del programma si deve copiare il file haarcascade_frontalface_alt.xml nella directory del programma
--------------------------------------------------------- #include "opencv2/objdetect/objdetect.hpp" #include "opencv2/highgui/highgui.hpp" #include "opencv2/imgproc/imgproc.hpp" #include <iostream> #include <stdio.h> using namespace std; using namespace cv; /** Function Headers */ void detectAndDisplay( Mat frame ); /** Global variables */ String face_cascade_name = "haarcascade_frontalface_alt.xml"; CascadeClassifier face_cascade; string window_name = "Capture - Face detection"; RNG rng(12345); /** @function main */ int main( int argc, const char** argv ) { if( !face_cascade.load( face_cascade_name ) ){ printf("--(!)Error loading\n"); return -1; }; Mat img = imread("immagine.jpg", CV_LOAD_IMAGE_UNCHANGED); detectAndDisplay(img); waitKey(0); return 0; } void detectAndDisplay(Mat frame) { std::vector<Rect> faces; Mat frame_gray; cvtColor( frame, frame_gray, CV_BGR2GRAY ); equalizeHist( frame_gray, frame_gray ); //-- Detect faces face_cascade.detectMultiScale( frame_gray, faces, 1.1, 2, 0|CV_HAAR_SCALE_IMAGE, Size(20, 20) ); for( int i = 0; i < faces.size(); i++ ) { Point center( faces[i].x + faces[i].width*0.5, faces[i].y + faces[i].height*0.5 ); ellipse( frame, center, Size( faces[i].width*0.5, faces[i].height*0.5), 0, 0, 360, Scalar( 255, 0, 255 ), 4, 8, 0 ); Mat faceROI = frame_gray( faces[i] ); } imshow( window_name, frame ); vector<int> compression_params; compression_params.push_back(CV_IMWRITE_JPEG_QUALITY); compression_params.push_back(98); bool bSuccess = imwrite("elaborata2.jpg", frame, compression_params); }
sempre per fare un po' di esperienza per rendere la Raspberry un sistema di controllo video, un esempio di motion detection con OpenCV ripreso da questo link e leggermente modificato per salvare il video su disco
(il video e' accelerato)
per adesso il programma e' stato testato su un portatile. Presto provero' se Raspberry e' in grado di gestire il flusso dati video ed il relativo calcolo in realtime
-------------------------------------------- #include<opencv2/opencv.hpp> #include<iostream> #include<vector> using namespace std;
Per tentare in futuro di usare il riconoscimento real-time degli oggetti ho convertito lo script in Python visto in questo post in questa versione in C++
------------------------------------------------------------- #include "opencv2/highgui/highgui.hpp" #include <iostream> #include <sstream> #include <iomanip> #include <stdlib.h> using namespace cv; using namespace std; int msleep(unsigned long milisec) { struct timespec req={0}; time_t sec=(int)(milisec/1000); milisec=milisec-(sec*1000); req.tv_sec=sec; req.tv_nsec=milisec*1000000L; while(nanosleep(&req,&req)==-1) continue; return 1; } int main(int argc, char* argv[]) { VideoCapture cap(0); // open the video camera no. 0 if (!cap.isOpened()) // if not success, exit program { cout << "Cannot open the video file" << endl; return -1; } double dWidth = cap.get(CV_CAP_PROP_FRAME_WIDTH); //get the width of frames of the video double dHeight = cap.get(CV_CAP_PROP_FRAME_HEIGHT); //get the height of frames of the video vector<int> compression_params; compression_params.push_back(CV_IMWRITE_JPEG_QUALITY); compression_params.push_back(98); / cout << "Frame size : " << dWidth << " x " << dHeight << endl; namedWindow("MyVideo",CV_WINDOW_AUTOSIZE); //create a window called "MyVideo" int i = 0; while (1) { Mat frame; i++; bool bSuccess = cap.read(frame); if (!bSuccess) { cout << "Cannot read a frame from video file" << endl; break; } stringstream ss; ss << std::setfill('0') << std::setw(5) << i; bool bSuccess2 = imwrite("a_"+ss.str()+".jpg", frame, compression_params); msleep(1000); } return 0; }
Riprendendo l'idea precedente (e grazie alla batteria) e' possibile anche fare dei CameraCar
La webcam era posta diretta davanti al volante
in questo caso, data la velocita', avrei dovuto ridurre il tempo di ripresa tra due fotogrammi per rendere il tutto piu' fluido. Sarebbe carino aggiungere un modulo Bluetooth, un GPS bluetooth ed una antenna Wireless per crearsi un piccolo una Google Car
Per questo progettino da un giorno ho provato ad usare la Raspberry per catturare dei time lapse
La base hardware e' quella presente in foto ovvero una Raspberry, una batteria esterna da 10000 mAh per essere autonomi dalle prese di corrente ed una comune webcam Logitech C310
La Raspberry e' configurata con un indirizzo statico ed un DHCP server e SSH Server per collegarsi con un portatile ed un cavo cross in modo da poter interagire in caso di necessita' mediante portatile
Per la configurazione software per prima cosa e' necessario installare OpenCV per Python mediante
apt-get install python-opencv
lo script e' il seguente (molto banale)
------------------------------------------ import cv import time nome = 0 capture = cv.CaptureFromCAM(0) while True: nome = nome + 1 frame = cv.QueryFrame(capture) indice = ("%04d")%nome cv.SaveImage("/home/luca/a_"+indice+".jpg",frame) time.sleep(20)
------------------------------------------
per mandare in esecuzione in automatico lo script e' stato modificato il file /etc/rc.local come segue aggiungendo python /home/luca/camera.py
una volta ottenute le immagini queste sono state montate in file mpg mediante il comando ffmpeg -f image2 -i a_%03d.jpg tramonto.mpg
(attenzione che gli indici di ffmpeg devono iniziare da 1. Le immagini sono denominati come a_001.jpg, a_002,jpg ed a seguire)
Per utilizzare la libreria OpenCV in C++ in ambiente Eclipse si deve prima di tutto aver installato Eclipse con il plugin CDT
Successivamente si puo' installare la libreria con il comando
apt-get install libopencv-dev
A questo punto si crea un nuovo progetto C++ dal wizard di Eclipse e si configurano i puntamenti alle directory di include e lib
nell'esempio sono riportate sono alcune librerie di base di OpenCV2. Se si usano funzioni avanzate sara' necessario aggiungere le corrispondenti librerie
a questo punto si puo' compilare un semplice esempio che mostra una immagine passata come argomento dalla linea di comando
------------------------------------------------- #include "opencv2/highgui/highgui.hpp" #include <iostream> using namespace cv; using namespace std; int main(int argc, char** argv) { Mat im; if (argc == 2) im = imread(argv[1]); if (im.empty()) { cout << "Cannot open image!" << endl; return -1; } imshow("image", im); waitKey(0); return 0; }
