Realizzare un sistema di sorveglianza con Raspberry Pi e OpenCV

Realizziamo con Raspberry Pi un sistema in grado di rilevare il movimento di persone e oggetti tramite una videocamera e di inviare e-mail di allarme.

La cosiddetta Computer Vision o visione artificiale, è un settore di ricerca che si occupa di come i computer possano interpretare la realtà visiva esattamente come un essere umano; essa si avvale di algoritmi complessi in grado di elaborare immagini fisse o in movimento, al fine di fornire indicazioni e informazioni su persone e oggetti, proprio come farebbe il nostro sistema percettivo.

Dal punto di vista pratico, la visione artificiale elaborata da un computer cerca di automatizzare quelle attività che il sistema visivo umano svolge naturalmente. I campi applicativi della Computer Vision vanno dalla digitalizzazione ambientale, la ricostruzione virtuale di luoghi e scenari, fino al riconoscimento e il monitoraggio visivo degli oggetti e delle persone.

L’acquisizione delle immagini e l’elaborazione delle informazioni visive in tempo reale necessitano solitamente di dispositivi ottici ad alta risoluzione, di potenti computer e software ad hoc.
In questo articolo esporremo un’applicazione di OpenCV 4, ossia la release più recente della diffusa libreria libera, rilasciata sotto una licenza BSD (Berkeley Software Distribution), che permette di sviluppare applicazioni di visione artificiale anche molto complesse.

La libreria OpenCV 4

Dal sito ufficiale di OpenCV vediamo innanzitutto le caratteristiche salienti.
• OpenCV è ora una libreria C++ 11 e richiede un compilatore conforme a C++ 11. La versione CMake minima richiesta è stata portata a 3.5.1.
• Molte API C di OpenCV 1.x sono state rimosse.
• La persistenza (la memorizzazione e il caricamento dei dati strutturati da/a XML, YAML o JSON) nel modulo principale è stata completamente reimplementata in C++ 11 e ha perso anche le API in C.
• È stato aggiunto il nuovo modulo G-API, che funge da motore per pipeline di elaborazione molto efficiente per immagini basate su grafici.
• Il modulo dnn è stato aggiornato con Deep Learning Deployment Toolkit dal toolkit OpenVINO ™ R4. Consultare la guida su come costruire e utilizzare OpenCV con il supporto DLDT.
• Il modulo dnn ora include il backend Vulkan sperimentale e supporta le reti in formato ONNX.
• Il famoso algoritmo Kinect Fusion è stato implementato e ottimizzato per CPU e GPU (OpenCL).
• Un rilevatore e decodificatore di codice QR sono stati aggiunti al modulo objdetect
• L’algoritmo di flusso ottico denso DIS ad alta efficienza è stato spostato da opencv_contrib al modulo video.
• Maggiori dettagli possono essere trovati negli annunci delle versioni precedenti: 4.0-alpha, 4.0-beta, 4.0-rc e nel changelog.

Ricordiamo che OpenCV è disponibile per interfacce C++, Python e Java e supporta le piattaforme Windows, Linux, Mac OS, iOS e Android. Per il nostro progetto verrà utilizzata la versione Linux/Ubuntu ottimizzata per Raspberry Pi 3B+ e interfaccia Python 3.

La scelta di sviluppare un progetto di home automation con OpenCV e la scheda Raspberry Pi si basa su due semplici motivi: il primo è legato alla compattezza del microcomputer, che può essere tranquillamente alloggiato in un piccolo contenitore, magari stampato in casa con la stampante 3D, il secondo è legato alla presenza della porta GPIO di Raspberry Pi a cui possiamo collegare facilmente dispositivi di controllo e di allarme.

Aggiungiamo infine la facilità di sviluppare in ambiente Python, che è già integrato nel suo sistema operativo.

 

VNC Viewer

Anche se si può operare direttamente con un mouse, una tastiera e un monitor HDMI, collegati alla scheda Raspberry Pi, di solito si preferisce creare un collegamento al desktop di Raspbian attraverso una connessione SSH o VNC.

In questo modo, dopo aver configurato la rete Wi-Fi o Ethernet di Raspberry Pi, si può accedere al desktop remoto utilizzando uno dei tanti terminali SSH oppure tramite il comodo VNC Viewer, scaricabile gratuitamente dal sito ufficiale e disponibile per tutte le piattaforme. Per la cronaca, abbiamo usato la versione per PC Windows, ma l’utilizzo è identico anche per tutti gli altri OS.

Configurazione delle interfacce di Raspberry Pi

Prima di configurare la connessione VNC è necessario attivare l’interfaccia VNC dal menu Preferenze > Raspberry Pi Configuration di Raspbian, come illustrato in Fig. 1.

Per fare questo, una volta aperta la finestra Raspberry Pi Configuration, basta fare clic sulla voce VNC. Nella stessa finestra si possono attivare anche tutte le altre interfacce, compresa l’interfaccia Camera, come illustrato in Fig. 2.

Le altre interfacce, anche se non servono per questo progetto, potranno venire utili in futuro.

 

 

 

Per usare la connessione VNC bisogna conoscere l’indirizzo IP che è stato assegnato automaticamente alla scheda al momento della prima configurazione WLAN o LAN. Se si vuole sfruttare la rete Wi-Fi della scheda è sufficiente aprire la finestra Network Preferences (Fig. 3) in cui è visibile l’indirizzo assegnato dalla connessione WLAN.

Connessione VNC

Per creare una nuova connessione con VNC Viewer, basta inserire nella finestra Properties l’indirizzo IP della scheda Raspberry Pi, come illustrato in Fig. 4.

Una volta avviata la connessione VNC verrà chiesto il nome utente e la password di autenticazione che, per default, sono rispettivamente “pi” e “raspberry” (Fig. 5).

 

 

 

 

Una volta effettuata la connessione, il desktop di Raspbian sarà visibile a tutto schermo sul monitor del PC. Da questo momento in poi, si potranno scollegare il mouse, la tastiera e il monitor dalla scheda Raspberry Pi e avere il controllo totale da remoto. Può capitare che l’indirizzo IP assegnato dal DHCP cambi, quindi è consigliabile configurare un IP statico nella scheda Raspberry Pi.

Configurare un IP statico su Raspberry Pi

Per configurare un IP statico è sufficiente aprire una finestra del terminale (Fig. 6) e digitare il seguente comando:

 

sudo nano /etc/dhcpcd.conf

Questo aprirà il file dhcpcd.conf nella finestra dell’editor nano.
Nell’esempio riportato nel file dhcpcd.conf , basta quindi decommentare le seguenti righe e modificare i dati in base alla propria rete e all’indirizzo IP che si vuole usare per la connessione remota:

interface wlan0

#oppure eth0 se si usa una rete LAN

static ip_address=192.168.1.100/24

#un qualsiasi indirizzo nel segmento di rete del proprio router

static routers=192.168.1.1

#indirizzo IP del router

static domain_name_servers=192.168.1.1 8.8.8.8

#indirizzi statici dei server

Una volta salvato il file e riavviato il sistema, l’IP statico così impostato permetterà di effettuare la connessione VNC utilizzando sempre lo stesso indirizzo.

Raspberry Pi 3B+ e Camera Module v2

Per questo progetto abbiamo optato per la scheda Raspberry Pi modello 3B+ e per Raspberry Pi Camera Module v2. La versione 2 della videocamera offre una risoluzione di ben 8 Megapixel e 3.820 x 2.464 pixel di risoluzione del sensore.

La Camera Module v2 va collegata come illustrato in Fig. 7, usando il flat cable in dotazione e facendo attenzione al verso di inserimento alla porta CSI di Raspberry Pi 3 B+.

Test della videocamera

Per vedere se la videocamera funziona correttamente con Python, si consiglia di effettuare questo semplice test. In una nuova finestra dell’editor di Python scrivere queste poche righe di codice:

from picamera import PiCamera
from time import sleep
camera = PiCamera()
camera.start_preview()
sleep(10)
camera.stop_preview()

All’avvio dello script dovrebbe aprirsi una finestra di preview e chiudersi dopo 10 secondi.
Se questo non accade, controllare che il flat cable sia ben inserito nel verso giusto nello slot. Se tutto funziona a dovere, si può proseguire tranquillamente all’installazione di OpenCV 4.

Installazione di OpenCV 4 su Raspbian Stretch

Come per le precedenti versioni, anche OpenCV 4 necessita di una particolare installazione. Per cui, se non si dispone del già citato sistema operativo Raspbian Stretch, è necessario aggiornare il sistema operativo per sfruttare le nuove funzionalità.
Attenzione! OpenCV 4 non è stato testato su versioni di Raspbian precedenti a Stretch.
Data la giovane età di OpenCV 4, non abbiamo trovato molte guide on-line, per cui ci siamo affidati all’esperienza di Adrian Rosebrock che gestisce il suo blog sul Deep Learning all’indirizzo https://www.pyimagesearch.com e di Satya Mallick che gestisce il sito https://www.learnopencv.com dedicato alla Computer Vision a al Machine Learning. Entrambi riportano pressappoco la stessa procedura di installazione.
Notate che per molti comandi da terminale si deve usare il carattere tilde (~). Se non è presente sulla tastiera, usare i tasti SHIFT+CTRL+u e inserire il codice esadecimale 7e + INVIO.

Installare le dipendenze di OpenCV 4

Prima di avviare qualsiasi installazione su Raspbian è sempre consigliabile aggiornare i repository con il comando apt-get, aprendo una finestra del terminale:

sudo apt-get update && sudo apt-get upgrade

Quindi, sempre con apt-get, si devono installare tutti gli strumenti di sviluppo, inclusa l’ultima versione di CMake:

sudo apt-get install build-essential cmake unzip pkg-config

Successivamente, installiamo una selezione di librerie per il trattamento delle immagini e del video:

sudo apt-get install libjpeg-dev libpng-dev libtiff-dev
sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev
sudo apt-get install libxvidcore-dev libx264-dev

Quindi, installiamo i toolkit GTK per l’interfaccia grafica:

sudo apt-get install libgtk-3-dev
sudo apt-get install libcanberra-gtk*

(l’asterisco acquisirà la specifica GTK ARM)

A questo punto servono due pacchetti che contengono ottimizzazioni numeriche per OpenCV:

sudo apt-get install libatlas-base-dev gfortran

Infine, installiamo gli strumenti di sviluppo per Python 3:

sudo apt-get install python3-dev

Dopo aver installato tutti i prerequisiti, è possibile eseguire il download di OpenCV 4.

Download di OpenCV 4

È preferibile scaricare gli archivi di OpenCV4 nella cartella Home. Tutte le librerie di OpenCV 4 sono disponibili in due repository github chiamati opencv e opencv_contrib. Il repository contrib contiene moduli aggiuntivi creati dagli utenti.
Ecco i comandi da digitare per tornare alla cartella Home e scaricare i due repository.

cd ~
wget -O opencv.zip https://github.com/opencv/opencv/archive/4.0.0.zip
wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/4.0.0.zip

Una volta scaricati gli archivi zip, vanno decompressi, sempre nella cartella Home:

unzip opencv.zip
unzip opencv_contrib.zip

Verranno così create le directory opencv-4.0.0 e opencv_contrib-4.0.0. Per motivi pratici si consiglia di rinominare le cartelle come opencv e opencv_contrib:

mv opencv-4.0.0 opencv
mv opencv_contrib-4.0.0 opencv_contrib

A questo punto, prima della compilazione vera e propria della libreria OpenCV 4, è necessario predisporre l’ambiente virtuale di Python 3.

Configurare l’ambiente virtuale di Python 3

Se non si ha familiarità con gli ambienti virtuali di Python e per sapere perché è consigliabile lavorare su un ambiente virtuale si veda il box dedicato.
Per prima cosa, bisogna installare pip:

wget https://bootstrap.pypa.io/get-pip.py
sudo python3 get-pip.py

Quindi installiamo virtualenv e virtualenvwrapper che consentono di creare ambienti virtuali di Python 3:

sudo pip install virtualenv virtualenvwrapper
sudo rm -rf ~/get-pip.py ~/.cache/pip

Per completare l’installazione di questi strumenti, è necessario aggiornare il file ~/.profile, usando questi semplici comandi echo:

echo “export WORKON_HOME=$HOME/.virtualenvs” >> ~/.profile
echo “export VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3” >> ~/.profile
echo “source /usr/local/bin/virtualenvwrapper.sh” >> ~/.profile

Le aggiunte al profilo indicano il percorso della cartella di lavoro virtualenvs, creata dallo strumento virtualenv nella Home e il percorso dello script virtualwrapper che si trova nella cartella /usr/bin. Una volta aggiornato il profilo, basta attivarlo con il comando seguente:

source ~/.profile

Creare un ambiente virtuale per contenere OpenCV 4 e i pacchetti aggiuntivi

A questo punto si può creare un ambiente virtuale OpenCV 4 per Python 3 e lavorare così in maniera indipendente da altri ambienti.
Questa linea di comando crea semplicemente un ambiente virtuale Python 3 chiamato “cv”.

mkvirtualenv cv -p python3

Si può dare un nome qualsiasi all’ambiente virtuale, ma si consiglia, per praticità, di tenere un nome corto. Se il profilo è attivato correttamente e viene creato l’ambiente virtuale “cv”, si può verificare che siamo nell’ambiente “cv” usando il comando workon, come indicato dalla freccia di Fig. 8:

 

workon cv

Installazione di NumPy

Il pacchetto Python richiesto da OpenCV 4 è NumPy. Per installarlo basta digitare il comando seguente:

pip install numpy

CMake e compilazione di OpenCV 4

Per compilare OpenCV 4, si userà CMake, seguito da make. Questo è il passo più dispendioso in termini di tempo. Innanzitutto, bisogna torna alla cartella opencv nella Home e creare al suo interno una sottodirectory build:

cd ~/opencv
mkdir build
cd build

A questo punto eseguite CMake per la creazione della build di tipo release.

 cmake -D CMAKE_BUILD_TYPE=RELEASE \
-D CMAKE_INSTALL_PREFIX=/usr/local \
-D OPENCV_EXTRA_MODULES_PATH=~/opencv_contrib/modules \
-D ENABLE_NEON=ON \
-D ENABLE_VFPV3=ON \
-D BUILD_TESTS=OFF \
-D OPENCV_ENABLE_NONFREE=ON \
-D INSTALL_PYTHON_EXAMPLES=OFF \
-D BUILD_EXAMPLES=OFF ..

Notate che il carattere backslash serve a continuare il comando con un a capo. Notare anche la presenza del percorso per la compilazione dei moduli aggiuntivi opencv_contrib.

Aumentare lo SWAP sul Raspberry Pi

Prima di iniziare la compilazione vera e propria si consiglia di aumentare lo spazio di swap. Questo per evitare che la compilazione si interrompa a causa dell’esaurimento della memoria. Per fare ciò basta modificare temporaneamente il file di swap che si trova in questo percorso /etc/dphys-swapfile:

sudo nano /etc/dphys-swapfile

… e quindi modificare la variabile CONF_SWAPSIZE portandola da 100 a 2.048 MB. Con il carattere # si commenta la riga:

# CONF_SWAPSIZE=100
CONF_SWAPSIZE=2048

Se non si esegue questo passaggio è molto probabile che la scheda si blocchi durante la compilazione. Una volta modificato il file di swap, bisogna fermare e riavviare il servizio di swap:

sudo /etc/init.d/dphys-swapfile stop
sudo /etc/init.d/dphys-swapfile start

Compilazione di OpenCV 4

Ora tutto è pronto per compilare OpenCV 4. Digitare semplicemente il comando seguente:

make -j4

Si noti che l’opzione – j4 specifica l’uso di 4 core per la compilazione. Se si verificano errori di compilazione o la scheda si blocca, si può provare senza l’opzione -j4. Normalmente, il processo di compilazione di OpenCV 4 è abbastanza lungo e dispendioso di risorse, per cui si consiglia di prendersi una bella pausa e lasciare che la scheda lavori senza interventi esterni di nessun tipo, ovvero senza toccare mouse o tastiera. Al termine della compilazione, se tutto è andato bene si potrà vedere la percentuale di compilazione al 100% (Fig. 9).

 

Ora non ci resta che installare OpenCV 4 con due tipici comandi:

sudo make install
sudo ldconfig

Non dimenticare di ripristinare lo swapfile, riportandolo a 100 MB, e riavviandolo:

sudo nano /etc/dphys-swapfile
CONF_SWAPSIZE=2048
sudo /etc/init.d/dphys-swapfile stop
sudo /etc/init.d/dphys-swapfile start

Collegamento simbolico di OpenCV

Un’ultima cosa molto importante è il collegamento simbolico di OpenCV 4 con la directory dei pacchetti del nostro ambiente virtuale. Bisogna entrare nella directory dei site-packages dell’ambiente virtuale e linkare la libreria cv2.so. Ecco i comandi:

cd ~/.virtualenvs/cv/lib/python3.5/site-packages/
ln -s /usr/local/python/cv2/python-3.5/cv2.cpython-35m-arm-linux-gnueabihf.so cv2.so
cd ~

Notate l’opzione –s di ln che sta per symbolic.

Se non si esegue questo passaggio, OpenCV 4 non riconoscerà i pacchetti dell’ambiente virtuale di Python 3. A questo proposito controllare che nella directory ~/.virtualenvs/cv/lib/python3.5/site-packages sia presenti il link alla libreria cv2.so.

Virtual Environment in Python 3

Virtual Environment sta per ambiente virtuale. Si tratta di una pratica che permette di creare degli spazi indipendenti dal resto del sistema in cui è possibile testare e lavorare con Python e pip.

In altre parole, gli ambienti virtuali consentono di lavorare e sperimentare con più progetti contemporaneamente, nonostante questi utilizzino una versione diversa degli stessi moduli.

Inoltre, permettono di installare moduli con pip senza i privilegi di root, con tutti i vantaggi che questo comporta in termini di sicurezza.

In pratica, viene creata una cartella che conterrà i file necessari al funzionamento dell’ambiente e una copia dei binary di Python. Dentro questa cartella potremo poi installare tutti i moduli con la versione che vogliamo in base al progetto su cui si sta lavorando.

Una volta creato un ambiente virtuale, basta attivarlo e iniziare a lavorare al suo interno.

Se non è già stato fatto in precedenza, bisogna installare il pacchetto virtualenv con pip:

pip install virtualenv

Prima di tutto, si consiglia di creare una cartella di lavoro:

mkdir progetto
cd progetto

Con il comando che segue si può creare l’ambiente virtuale nella
cartella progetto, scegliendo un nome qualsiasi:

virtualenv env_name

Questo comando installerà tutti gli strumenti necessari all’interno dell’ambiente virtuale env_name.

Infine, ci si sposta nella cartella bin dell’ambiente virtuale env_name
e lo si attiva con il comando activate:

cd env_name/bin
source activate

Per disattivare l’ambiente virtuale e tornare al prompt normale, basta digitare il comando deactivate.

Verifica dell’installazione di OpenCV 4

Per vedere se OpenCV 4 è stato installato correttamente, rimanendo all’interno dell’ambiente virtuale cv, eseguire quanto segue dal terminale:

python
>>> import cv2
>>> cv2.__version__
‘4.0.0’
>>> exit()

Come illustrato in Fig. 10, il primo comando apre l’interprete Python 3 associato all’ambiente cv.

 

Il comando import cv2 importa la lib reria e il comando cv2.__version__ fa vedere la versione 4.0.0 della libreria. Con il comando exit() si esce dall’interprete e si torna al terminale.

Ricordate che al riavvio del sistema bisogna riattivare ogni volta l’ambiente virtuale (nel nostro caso “cv”) e quindi iniziare a lavorare, con il comando workon cv:

source ~/. Profile
workon cv

Per usare l’interfaccia IDLE di Python 3 all’interno dell’ambiente virtuale è necessario digitare il seguente comando:

python -m idlelib.idle

Con l’interfaccia IDLE aperta, si possono creare nuovi script o aprire quelli già fatti in precedenza.

Se si tenta di aprire al di fuori dell’ambiente virtuale uno script che importa la libreria cv2, apparirà il Traceback con l’avviso di errore:
ImportError: No module named ‘cv2’.

Videosorveglianza con OpenCV 4 e Raspberry Pi

Abbiamo pensato a questo progetto come a una valida alternativa ai sistemi d’allarme basati su sensori PIR, a ultrasuoni, a contatto e così via. Una volta rilevato un movimento, lo script fotografa l’intruso e manda la foto a un indirizzo di posta elettronica per identificare la persona.

Qualunque sia lo scopo, abbiamo creato lo script basato su OpenCV 4 per la cattura del movimento per l’invio di email a un indirizzo di posta. Contemporaneamente, il movimento rilevato attiva una porta GPIO alla quale collegare eventualmente un relè e un sistema di allarme. Raspbian include le librerie per la gestione della posta e della porta GPIO, per cui non serve installare altro.

Di seguito commentiamo le parti salienti dello script (il codice completo potete scaricarlo dal nostro sito www.elettronicain.it). Le librerie importate all’inizio dello script servono solo alla gestione SMTP, ovvero all’invio di e-mail tramite un server di posta noto. Per questo utilizzo, è necessario connettere Raspberry Pi alla rete WiFi o Ethernet.

from smtplib import SMTP_SSL as SMTP 
from email.mime.text import MIMEText
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email import Encoders

Nella sezione che segue vanno cambiati i parametri per il server SMTP. Si consiglia di impiegare il server SMTP normalmente usato per l’invio di posta dal computer di casa.

Le variabili sender e destination contengono gli indirizzi del mittente e del destinatario, ovvero l’indirizzo con il quale si mandano normalmente le email e l’indirizzo a cui si vuol inviare il messaggio.

Le variabili username e password sono il nome utente e la password usati per l’invio al server SMTP. Il tipo di messaggio è di testo plain e la variabile content indica il contenuto del messaggio mentre la variabile subject riporta l’oggetto del messaggio. L’istanza msg eredita i metodi della libreria MIMEMultipart.

SMTPserver = ‘smtps.server.xxx’ 
sender = ‘[email protected]’
destination = ‘[email protected]’
username = ‘[email protected]’
password = ‘myPassword’
text_subtype = ‘plain’
content=’Messaggio’
subject=’Allarme’
msg = MIMEMultipart()

La funzione email_send() è designata all’invio di un’email con un allegato, che nel nostro caso è un’immagine jpg dell’intruso o dell’oggetto che si è mosso nella stanza. Come vedremo più avanti, la funzione di invio e-mail è opzionale e può essere chiamata o meno nello script. Se l’invio avviene correttamente, sul terminale verrà stampato “Invio eseguito” altrimenti apparirà “Invio fallito”.

def email_send():
try:

msg[‘Subject’]= subject
msg[‘From’] = sender
msg[‘To’] = destination 
msg.attach(MIMEText(content, ‘plain’))
msg.attach(part)
conn = SMTP(SMTPserver)
conn.set_debuglevel(False)
conn.login(USERNAME, PASSWORD)
try:
conn.sendmail(sender, destination, msg.as_string())
print(“Invio eseguito”)
finally:
conn.quit()
except Exception: print(“Invio fallito”)

Quelle che seguono sono le librerie che devono essere importate per la gestione della videocamera, della data, dell’orario, degli effetti video, dei file json, di cv2 (OpenCV 4) e della porta GPIO.

import cv2
import time
import datetime
import imutils
import json
import RPi.GPIO as GPIO
from picamera.array import PiRGBArray
from picamera import PiCamera

Le istruzioni seguenti impostano l’uscita GPIO26 (potete, da qui, sceglierne un’altra):

GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(26,GPIO.OUT)

Lo script prevede l’importazione di alcuni parametri attraverso un file di configurazione, che abbiamo chiamato appunto “configurazione.json”. Grazie alla libreria json si può quindi fare il parsing dei valori assegnati ai parametri di configurazione e assegnarli alle variabili o alle funzioni. L’istruzione che segue permette il caricamento del file json che viene spiegato nel prossimo paragrafo.

conf = json.load(open(‘configurazione.json’))

Il file configurazione.json

Di solito un file JSON (JavaScript Object Notation) viene usato nell’ambiente di programmazione Javascript. Grazie alla sua versatilità, viene usato spessissimo come file di configurazione in altri ambienti.

Si tratta di uno script che supporta il linguaggio Javascript e quindi accetta la sintassi tipica del linguaggio.

Aprendo il file “configurazione.json” con un semplice editor di testo si possono vedere i parametri da assegnare a variabili e funzioni:

{
“use_img”: true,
“use_email”: true,
“video_preview”: true,
“min_time”: 3.0,
“min_motion”: 8,
“threshold”: 5,
“resolution”: [640, 480],
“fps”: 25,
“min_area”: 5000
}

Come vedete, alcuni parametri sono posti a true o false e altri contengono valori numerici e array.

Leggendo questi parametri con la suddetta istruzione conf = json.load(open(‘configurazione.json’)), si possono impostare le funzionalità dello script di videosorveglianza, senza dover toccare ogni volta il codice.

Per esempio, se non si vogliono salvare i file delle immagini catturate e usare la videosorveglianza solo per accendere il relè di allarme, basta scrivere nel file json la seguente istruzione:

“use_img”: false

Allo stesso modo, se non si desidera l’invio di email:

“use_email”: false

Se non volete visualizzare la finestra di anteprima:

“video_preview”: false

 

Gli altri parametri permettono di impostare:
• min_time: valore predefinito 3 secondi; è il tempo minimo per rilevare il movimento;
• min_motion: valore predefinito 8 frame; è il numero minimo di frame prima di attivare l’accensione del LED, il salvataggio dei file e/o l’invio dell’email. Si può aumentare o diminuire il valore per rendere più o meno sensibile il rilevamento ;
• threshold: valore predefinito 5; definisce la soglia di sensibilità per il rilevamento del movimento. Si può aumentare o diminuire questo valore a seconda che si voglia rendere il contrasto più o meno sensibile;
• resolution: (predefinito 640×480 pixel) è la risoluzione video, ovvero la dimensione del riquadro (frame) di preview; si consiglia di lasciare inalterata la risoluzione per evitare rallentamenti nel flusso video o nell’invio delle e-mail;
• fps: imposta i frame al secondo; si consiglia di lasciare il valore predefinito (25) per evitare rallentamenti nel flusso video;
• min_area: predefinito 5000. È il valore minimo dell’area del riquadro verde che viene creata attorno al soggetto rilevato. Di solito non serve modificarla.

Proseguiamo con l’analisi del codice: l’oggetto camera eredita i metodi della libreria picamera. I parametri della videocamera vengono impostati in base alla lettura dei parametri resolution e fps del file json. Notate l’uso del tipo tuple che in Python permette di creare una lista di valori separati da virgole:

camera = PiCamera()
camera.resolution = tuple(conf[“resolution”])
camera.framerate = conf[“fps”]
rawCapture = PiRGBArray(camera, size=tuple(conf[“resolution”]))

Vengono quindi definite alcune variabili che verranno utilizzate nello script per stabilire il tempo di inizio e di fine della cattura dei frame.

count = 0
avg = None
motionCounter = 0
lastUploaded = datetime.datetime.now()

All’avvio dello script, si potrà vedere sul terminale la scritta “Avvio…” poi il sistema attende 2 secondi e inizia la cattura video. Si fa notare che nella finestra di preview viene sovraimposto nella parte alta il testo “Stato attuale: Nessun movimento” e, in basso, la data e l’orario (Fig. 11).

 

A questo scopo, viene usata la libreria imutils per ridimensionare il frame e la libreria datetime per l’orario da Internet, per cui l’orario e la data dovrebbe essere precisi.

Con la libreria cv2 si imposta la maschera per rilevare un oggetto in movimento. Si fa notare che il parametro tresh legge il valore di soglia, ovvero il parametro threshold dal file json di configurazione. La variabile motionFlag viene posta a False.

print “Avvio...”
time.sleep(2)

Tutta la iterazione for serve a contare i frame e rilevare le differenze della maschera di grigio che viene sovraimposta all’immagine catturata, come illustrato in Fig. 12. Il valore di treshold imposta la soglia di intervento per rilevare il movimento.

 

for f in camera.capture_continuous(rawCapture, format=”bgr”, use_video_port=True):
frame = f.array
timestamp = datetime.datetime.now()
text = “Nessun movimento”
motionFlag = False
frame = imutils.resize(frame, width=500)
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
gray = cv2.GaussianBlur(gray, (21, 21), 0)
if avg is None:

avg = gray.copy().astype(“float”)
rawCapture.truncate(0)
continue

cv2.accumulateWeighted(gray, avg, 0.5)
frameDelta = cv2.absdiff(gray, cv2.convertScaleAbs(avg))

thresh = cv2.threshold(frameDelta, conf[“threshold”], 255, cv2.THRESH_BINARY)[1]
thresh = cv2.dilate(thresh, None, iterations=2)
(cnts, _) = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
…
…

Rilevato un movimento, il soggetto viene evidenziato con riquadri verdi attorno ai bordi. Quando il valore di soglia viene superato, apparirà il testo “Stato attuale: Movimento rilevato” e la variabile motionFlag viene posta a True.

text = “Movimento rilevato”
motionFlag = True
ts = timestamp.strftime(“%A %d %B %Y %I:%M:%S%p”)

A questo punto, se la variabile motionFlag è True, inizia il confronto fra il tempo corrente (currentTime) e il tempo impostato per il rilevamento (lastTime) impostato dal parametro min_time nel file json e inizia il conteggio dei movimenti rilevati con la variabile motionCounter.

if text == “Movimento rilevato”: 
if (currentTime - lastTime).seconds >= conf[“min_time”]:
motionCounter += 1

Se il numero dei movimenti rilevati supera quella impostato dal parametro min_motion nel file json, si può decidere se salvare il file jpg del soggetto. Questa opzione viene impostata dal parametro use_img del file json. Notate che il nome del file img = ‘foto_’ + str(count) + ‘.jpg’ segue una numerazione progressiva.
I nomi dei file vengono salvati localmente con l’istruzione cv2.imwrite(img, frame) come foto_1.jpg, foto_2.jpg e così via.

if motionCounter >= conf[“min_motion”]:
if conf[“use_img”]:
count += 1
img = ‘foto_’ + str(count) + ‘.jpg’
cv2.imwrite(img, frame)

Nel frattempo, il LED/relé sul pin GPIO26 viene attivato o disattivato, mentre viene stampato “LED ON” sul terminale, a seconda se viene rilevato o meno il movimento:

GPIO.output(26, GPIO.HIGH)
print “LED ON”.

oppure:

print (“LED OFF”)
GPIO.output(26,GPIO.LOW)

Se è stato impostato l’invio dell’email con il parametro use_email, viene creato l’oggetto part che imposta il formato MIME (Multipurpose Internet Mail Extensions) per comporre il messaggio di posta. Il messaggio viene automaticamente codificato in formato base64 e quindi spedito tramite la funzione email_send(),vista in precedenza.
Il messaggio di posta invierà in allegato il file “foto_1.jpg” e successivamente il file “foto_2.jpg” e così via, in base alle volte che la videocamera rileva un nuovo movimento.
La Fig. 13 illustra un esempio di ricezione di un’e-mail di allarme.

 

if conf[“use_email”]:
part = MIMEBase(‘application’, “octet-stream”)
part.set_payload(open(t, “rb”).read())
Encoders.encode_base64(part)
part.add_header(‘Content-Disposition’, ‘attachment; filename=’+ img)
email_send()

 

Conclusioni

Per ora è tutto. Per fare un po’ di esperienza potete provare a modificare il listato per aggiungere funzionalità o modificare i parametri del file json per vedere cosa succede.
Se volete approfondire l’utilizzo di Open CV4 Futura Academy mette a disposizione un corso specifico.