Introdução
OPENCV- Acrônimo formado para representar o pacote de bibliotecas para visão computacional (Open Source Computer Vision). Sim, um pacote completo de ferramentas computacionais disponíveis em C++ e Python que visa aplicações de tempo real, funciona tanto em sistemas Windows quanto Linux e Android. Logo, fica ao gosto do freguês, nos aqui da equipe BlackBoxLab preferimos Linux.
Como o próprio nome diz OpenCV é uma biblioteca aberta para uso pessoal e comercial, por isso sua persona é livre para compilar, utilizar e comercializar produtos que façam uso dela.
Raspberry PI é uma placa de computação embarcada ou (Física) que desde de meados de 2013 vem fazendo a alegria de entusiastas e profissionais da famigerada eletrônica embarcada ou embutida no Brasil (deixamos aqui a definição para você como lição de casa ou não).
Para finalizar essa breve e modesta introdução, a visão computacional é umas das mais fabulosas e impressionantes ferramentas que o mundo moderno conta para que possamos trabalhar de forma efetiva e brincar em melhorar nossos sorrisos lindos em app's de bolso e também com Inteligência Artificial, Big Data, e Deep Learning (vamos googlar sobre).
Todos devidamente apresentados, café em mãos, e mãos à obra nessa construção!
Materiais utilizados neste tutorial
Uma Raspberry Pi3
Uma Fonte de 5 volts com 1 Ampére, se possível com maior capacidade de corrente, pois o processo de compilação leva a Raspie a alguns picos de corrente e aquecimento.
Se possível colocar um dissipador de calor instalado sobre o processador da Broadcom presente na Raspie (isso pode ser feito satisfatoriamente com pasta térmica e Araldite) e uma ventoinha.
Um cartão SD de 8GB ou mais com o Raspbian 9 Stretch que esteja operacional, lembre-se de configurar acesso SSH e VNC, caso não use monitor, teclado e mouse dedicados ao Raspie.
Um PEN DRIVE de 16 GB
Não esqueça da sua bebida predileta, pois o processo é lento.
Passo 1: preparando o sistema
Raspbian vem com o OpenCV 2.4.9 mesmo que essa versão esteja desatualizada, podemos usá-la para praticar.
Porém, para coisas mais avançadas em visão computacional precisamos de uma versão mais recente da biblioteca.
Os “releases” podem ser conferidos no seguinte endereço: https://opencv.org/releases.html.
Até a data de lançamento do tutorial encontra-se na 3.4.1 o OpenCV 3.
Então, para remover versões anteriores da biblioteca, acesse seu terminal e as remova.
$ sudo apt-get remove libopencv*
$ sudo apt-get autoremove
Agora, vamos atualizar o sistema e o firmware.
$ sudo apt-get update
$ sudo apt-get upgrade
$ sudo apt-get -y dist-upgrade
$ sudo rpi-update
Passo 2: abrindo espaço para compilação
Vamos agora expandir nosso sistema de arquivos para incluir todo o espaço disponível no cartão micro-SD.
$ sudo raspi-config
Siga na interface até a opção Advanced Options >> Expand Filesystem
O sistema irá rebootar automaticamente agora.
Para checar o sistema expandido:
$ df -h
Vamos aumentar o tamanho do espaço de memória de varredura antes de compilar para adicionar mais memória virtual. Isso permitirá que o OpenCV compile com todos os quatro núcleos do Raspie sem problemas de memória.
Abra seu / etc / dphys-swapfile e edite a variável CONF_SWAPSIZE
$ sudo nano /etc/dphys-swapfile
Ele irá abrir o editor nano para editar o CONF_SWAPSIZE. Altere como abaixo:
Em seguida, salve as alterações feitas, pressione Ctrl + O. Para sair do nano, digite Ctrl + X. Se você pedir ao nano para sair de um arquivo modificado, ele perguntará se você deseja salvá-lo. Basta pressionar N para o caso de você não, ou Y, caso você o faça. Em seguida, ele solicitará um nome de arquivo. Basta digitar e pressione Enter.
Em seguida, digite as seguintes linhas para atualizar.
$ sudo /etc/init.d/dphys-swapfile stop
$ sudo /etc/init.d/dphys-swapfile start
No nosso caso, com um cartão de 8 GB teremos uma saída como a da figura acima. Nesse caso, o cartão dispõe de 7.1 GB para o sistema do qual foi utilizado 3.5 GB, consumindo 52% do espaço do cartão. Num geral é necessário no Raspie 3 em torno de 3.5 GB de espaço livre para compilação da biblioteca.
Uma forma opcional de conseguir mais espaço é removendo (mesmo que temporariamente) programas grandes que vem por default, como Libreoffice e Wolfram Engine, o que dá em torno de mais 1 GB livre.
Como meu Raspbian deste cartão ficará exclusivo para minha aplicação de visão computacional os removi sem o menor peso na consciência.
Neste tutorial, vamos baixar e criar o OpenCV 3.4.1 a partir do zero. São necessários por garantia cerca de 4 GB de espaço em disco temporário para compilar o OpenCV. É comum que você não tenha espaço suficiente no seu Raspberry PI para fazer essa compilação caso esteja utilizando um cartão de memória com menos de 16 GB. Nesse caso, você pode ter surpresas desagradáveis durante o processo de compilação.
Uma solução simples é usar algum disco USB externo ou memória onde possa baixar e construir o OpenCV. Depois disso, você pode remover (ou excluir) seu armazenamento externo. No meu caso utilizei um pen drive de 16GB formatado e criei um disco no Linux.
Caso esse problema de espaço em disco não seja o seu pule para o próximo tópico e seja feliz, caso seu cartão seja pequeno e você opte pelo pen drive, abaixo o colocaremos como um disco para o Linux e trabalharemos nele.
Conecte a memória USB, no mínimo 4 GB, no seu Raspberry PI e verifique o nome do dispositivo, o nome típico é / dev / sda1 ou similar, use o comando lsblk para listar os dispositivos de bloco no seu Raspberry PI:
$ lsblk
Certifique-se de que pendrive não esteja montado. No caso vamos desmontá-lo. O Raspbain possui o hotplug então reconheceu meu pen drive de cara. Não sacou bolhufas do que isso quer dizer? Esse tópico aqui pode dar uma desanuviada no crânio. https://www.vivaolinux.com.br/artigo/Montando-um-pendrive-no-Linux
$ sudo umonut /dev/sda1
Crie uma partição do Linux usando
$ sudo fdisk /dev/sda1
Formate a nova partição usando:
$ sudo mkfs -t ext2 /dev/sda1
Crie um ponto de montagem e monte a memória:
$ mkdir ~/usbmem
$ sudo mount /dev/sda1 ~/usbmem
Agora, vamos checar nossa partição.
$lsblk
Pronto, agora temos espaço para compilação dentro da partição no pen derive. A partir daqui iremos trabalhar dentro dela.
$ cd /home/pi/usbmem
Como tinha dito, se seu cartão possui espaço suficiente para compilação no caso você tiver um cartão de 16 GB ou mais por exemplo, será necessário apenas a expansão do filesystem feita lá em cima e seguir para o passo 3. Aí você poderá trabalhar direto na home do Raspbian mesmo.
$ cd ~
Passo 3: instalando os pacotes necessários
Observe que todos os comandos de instalação de pacote possuem o argumento -y que tem como finalidade a não solicitação de confirmação do usuário para instalar os pacotes.
Esses pacotes são necessários para a compilação e o uso do OpenCV, possui Codes de I/O, vídeo, interface gráfica, entre outras ferramentas necessárias para que o sistema Linux opere com o OpenCV satisfatoriamente.
Para isso, precisamos instalar algumas ferramentas de desenvolvedor, incluindo o CMake, que nos ajuda a configurar o processo de compilação do OpenCV:
$ sudo apt-get install build-essential cmake pkg-config
Em seguida, precisamos instalar alguns pacotes de E / S de imagem que nos permitem carregar vários formatos de arquivo de imagem do disco.
Exemplos de tais formatos de arquivo incluem JPEG, PNG, TIFF, etc.
$ sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev
Assim como precisamos de pacotes de E / S de imagem, também precisamos de pacotes de E / S de vídeo. Essas bibliotecas nos permitem ler vários formatos de arquivo de vídeo do disco, bem como trabalhar diretamente com fluxos de vídeo:
$ sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev
$ sudo apt-get install libxvidcore-dev libx264-dev
A biblioteca OpenCV vem com um sub-módulo chamado highgui que é usado para exibir imagens em nossa tela e construir GUIs básicas. Para compilar o módulo highgui, precisamos instalar a biblioteca de desenvolvimento do GTK:
$ sudo apt-get install libgtk2.0-dev libgtk-3-dev
Muitas operações dentro do OpenCV (ou seja, operações de matriz) podem ser otimizadas ainda mais, instalando algumas dependências extras:
$ sudo apt-get install libatlas-base-dev gfortran
Essas bibliotecas de otimização são especialmente importantes para dispositivos com recursos limitados, como o Raspberry Pi.
Por fim, vamos instalar os arquivos de cabeçalho do Python 2.7 e do Python 3 para que possamos compilar o OpenCV com as ligações do Python.
$ sudo apt-get install python2.7-dev python3-dev
Se você está trabalhando com a imagem atualizada do sistema operacional (o que fizemos logo no início hehehe), é possível que essas versões do Python já estejam na versão mais recente, porém não aconselho pular esta etapa do processo.
Passo 4: Fazendo o download das fontes
Lembre-se que se você não tiver pelo menos 4 GB em sua partição raiz, você terá que usar alguma memória externa (partição Linux). Aqui estamos usando uma memória USB montada em / home / pi / usbmem. Caso vc esteja sem esse apertamento, provavelmente estará trabalhando no diretório /home/pi.
Vamos lá “abaixar” os arquivos e descompacta-los.
$ sudo cd /home/pi/usbmem
$ sudo mkdir opencv
$ sudo cd opencv
$ wget -O opencv.zip https://github.com/opencv/opencv/archive/3.4.1.zip
$ wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/3.4.1.zip
$ unzip opencv.zip
$ unzip opencv_contrib.zip
Passo 5: instalando NumPY e SciPY
Vamos instalar alguns pacotes adicionais para análise de dados - numpy e scipy. Eles são necessários, pois qualquer imagem no final das contas é uma matriz que está preenchida por vetores. Logo, precisamos de pacotes com NumPY, SciPY e Matplotlib para que facilite nossa vida na matemática da visão computacional (tá vendo bixo num é que as matrizes tem uma utilidade rapaiz).
$ sudo pip install numpy
$ sudo pip install scipy
Passo 6: habilitando o modulo de vídeo
Habilitando o modulo de vídeo (video for Linux- v4l2) e ativando no boot, principalmente para usar com acesso VNC isso será importante.
O Python gerencia a câmera do Raspberry por meio do módulo picamera. Você pode usar este módulo também no OpenCV, mas você precisa capturar imagens em numpy.array e mapear o array para o OpenCV Mat.
Para usar o loop de captura padrão cv2.VideoCapture (0) com o raspicam, o driver Video4Linux é necessário.
Verifique os pré-requisitos (com sudo raspi-config):
Ativar a câmera
Defina uma memória grande para o gpu_mem (Em Opções Avançadas> Memmory Split set). Se está tudo realmente atualizado 128 já deve estar configurado por padrão do seu Raspbian.
Vamos agora habilitar e colocar no boot para não ter mais que se preocupar com isso.
Primeiramente carregue o modulo e teste.
$ sudo modprobe bcm2835-v4l2
$ v4l2-ctl --list-devices
Você deverá receber um retorno como isto:
Se tudo funcionar bem, adicione o nome do módulo bcm2835-v4l2 à lista de módulos carregados na inicialização em /etc/modules-load.d/modules.conf para que ao inicializar seu Raspie o modulo seja carregado e fique pronto para uso.
$ sudo nano /etc/modules-load.d/modules.conf
Ctrl+X >> Y >> enter.
Passo 7: Compilando o OPENCV
Nessa parte aqui é que vai demorar, é aqui que seu Raspie vai usar praticamente 100% de seu processamento e dar uns picos de corrente de até 1,5 A e vai aquecer. Por isso, prepare o ambiente e se possível fique por perto, mesmo que fazendo outra atividade, pq esses processos são temperamentais. Nem preciso dizer que agora você deve deixar apenas a atividade de compilação rodando na placa.
Vamos preparar tudo com tranquilidade e deixar nosso amiguinho trabalhar!
Primeiramente, vamos criar nosso diretório de trabalho.
$ sudo cd /home/pi/usbmem/opencv/opencv-3.4.1
$ sudo mkdir build
$ sudo cd build
Vamos configurar a compilação usando as linhas de comando.
Usaremos a configuração padrão. Nós não queremos uma versão de depuração nem testes. Sugerimos que habilite a otimização NEON para o ARM Cortex para aumentar (um pouco) o desempenho do OpenCV.
$ cmake -D CMAKE_BUILD_TYPE=RELEASE \
-D CMAKE_INSTALL_PREFIX=/usr/local \
-D BUILD_WITH_DEBUG_INFO=OFF \
-D BUILD_DOCS=OFF \
-D BUILD_EXAMPLES=OFF \
-D BUILD_TESTS=OFF \
-D BUILD_opencv_ts=OFF \
-D BUILD_PERF_TESTS=OFF \
-D INSTALL_C_EXAMPLES=ON \
-D INSTALL_PYTHON_EXAMPLES=ON \
-D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib-3.4.1/modules \
-D ENABLE_NEON=ON \
-D WITH_LIBV4L=ON \
../
O CMake deve começar a construir sua configuração, depois de alguns minutos você deverá ver:
Se você não conseguir ver a geração concluída, alguns problemas já ocorreram. Leia as mensagens de erro e o arquivo de log de erros para investigar.
Agora sim, vamos de fato compilar nosso OpenCV, usarmos o –j4 para utilizar os quatro núcleos nesse processo isso irá ajudar a diminuir o tempo de compilação. Mesmo assim ainda da tempo de ir tomar um café, checar as mensagens da “cheirosa” e tudo mais. No terminal:
$ sudo make –j4
Durante esse processo você verá algo assim, sugiro acompanhar também.
Se tudo correu bem, então teremos isso.
Passo 8: Instalando e configurando o OpenCV
Apenas um passo rápido faremos a instalação e em seguida a configuração. Agora, será indolor.
$ sudo make install
$ sudo ldconfig
Se nenhuma mensagem de erro apareceu, então tudo ok.
Parabéns, o seu Raspberry PI 3 está pronto para a Visão Computacional!
Passo 9: checando a instalação
Por padrão, os arquivos serão instalados em:
$ sudo ls -l /usr/local/lib/libcv*
$ sudo ls -l /usr/local/lib/python2.7/dist-packages/cv*
$ sudo ls -l /usr/local/lib/python3.4/dist-packages/cv*
$ sudo ls -l /usr/local/include/opencv2/
$ sudo ls -l /usr/local/bin/opencv_*
$ sudo ls -l /usr/local/share/OpenCV/
Passo 10: teste a instalação
Passo 12: voltando o tamanho do swap ao original
Isso é necessário para não ferrar o cartão SD.
$ sudo nano /etc/dphys-swapfile
Crtl+X >> Y >> enter
$ sudo /etc/init.d/dphys-swapfile stop
$ sudo /etc/init.d/dphys-swapfile start
Passo 14: Divirta-se.
$ sudo reboot
Caso tenha em mãos uma RaspCAM ou uma webcam.
Acesse o diretório em que você descompactou a pasta opencv-3.4.1/samples/python e execute o exemplo edge.py.
$ sudo python edge.py
Caso tudo de certo tenho certeza que o resultado disso será muito legal estude o código e seja feliz!
# Dicas e referências
Aqui encontra-se uma lista de páginas que consultei para instalar e configurar corretamente o OpenCv 3.4.1 no Raspberry PI 3.
Para facilitar a vida nos criamos um script Bash que realiza o processo de instalação do OpenCV automaticamente, ou pelo menos deveria, para tornar mais rápido o processo todo. Porém, no tutorial algumas coisas existem a mais como a parte do pen drive e a habilitação do modulo para video no boot.
Além disso, existem sites e livros que podemos encontrar muita coisa para apreender sobre python e OpenCV. Deixo aqui minhas sugestões.
Livros.
The OpenCV Tutorials Release 2.4.13.6
OpenCV By Example Enhance your understanding of Computer Vision and image processing by developing real-world projects in OpenCV 3
OpenCV Computer Vision with Python Learn to capture videos, manipulate images, and track objects with Python using the OpenCV Library
Learning OpenCV 3 Computer Vision with Python Second Edition Unleash the power of computer vision with Python using OpenCV
Mastering OpenCV with Practical Computer Vision Projects
Learning OpenCV by Gary Bradski and Adrian Kaehler
MARQUES FILHO, Ogê; VIEIRA NETO, Hugo. Processamento Digital de Imagens, Rio de Janeiro: Brasport, 1999. ISBN 8574520098
De repente da pra achar até naquele site lá, o tal de google :)