Instalação do Opencv Raspberry Pi. Instalando OpenCV (Linux)

10.09.2021

Recentemente, durante a implementação de um dos projetos relacionados ao reconhecimento de imagens, tivemos a necessidade de instalar a biblioteca de visão computacional OpenCV em um microcomputador de placa única Raspberry PB2.

Depois de vasculhar a Internet e passar algum tempo fazendo experimentos, resolvemos esse problema com sucesso. O resultado é uma pequena instrução que temos o prazer de compartilhar com todos que decidem usar OpenCV no Raspberry.

Então: instalando o OpenCV:

No exemplo estamos usando o opencv versão 2.4.9.

Primeiro precisamos atualizar nosso sistema:

sudo atualização do apt-get sudo atualização do apt-get

Agora precisamos instalar bibliotecas adicionais:

sudo apt-get -y instalar build-essential cmake cmake-curses-gui pkg-config libpng12-0 libpng12-dev libpng++-dev libpng3 libpnglite-dev zlib1g-dbg zlib1g zlib1g-dev pngtools libtiff4-dev libtiff4 libtiffxx0c2 libtiff-tools libeigen3-dev sudo apt-get -y instalar libjpeg8 libjpeg8-dev libjpeg8-dbg libjpeg-progs ffmpeg libavcodec-dev libavcodec53 libavformat53 libavformat-dev libgstreamer0.10-0-dbg libgstreamer0.10-0 libgstreamer0.10-dev libxine1-ffmpeg -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 libswscale-dev v4l-conf v4l-utils libgtk2.0 -0 libgtk2.0-dev pkg-config libxvidcore-dev libx264-dev libavcodec-dev libavformat-dev libqt4-dev libqt4-opengl-dev libjasper-dev

Depois de terminarmos de instalar as bibliotecas, passamos para a instalação do OpenCV. Durante a instalação pode surgir uma situação em que pode não haver alguma biblioteca para o seu sistema e você precisará olhar o que está faltando e entregar adicionalmente.

Vamos criar uma pasta na qual baixaremos nosso arquivo:

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

Agora precisamos descompactar nosso arquivo. Para fazer isso usamos o comando:

descompactar openCV-2.4.9.zip

Como resultado, criaremos uma pasta openCV-2.4.9. Vá até ele e crie a pasta de lançamento

CD openCV-2.4.9 mkdir liberar CD liberar

É hora de configurar o OpenCV. Se não precisar de configurações de terceiros, você pode usar a configuração padrão (para isso, basta pressionar a tecla “c”). Ao executar o ccmake, uma lista de configurações que você pode especificar aparecerá (conforme mostrado na imagem abaixo)

E então vamos começar:

ccmake ../

(Pressione "c" se a configuração de cache estiver vazia)

Pressione a tecla "c"

Quando a instalação for concluída, pressione a tecla “c” novamente para continuar e a tecla “g” para gerar o makefile.

Agora está tudo configurado e basta clicar em fazer. Este processo levará em média cerca de 10 horas.

fazer sudo fazer instalar

Isso conclui a instalação. Resta apenas verificar a funcionalidade.

Crie o arquivo main.cpp

#incluir #incluir usando espaço para nome cv; int main(int argc, char** argv) ( if (argc != 2) ( printf("uso: n"); return -1; ) Mat image; image = imread(argv, 1); if (!image.data) ( printf("Nenhum dado de imagem n"); return -1; ) imshow("Exibir imagem" , imagem); waitKey(0);

Agora você precisa criar um arquivo CMakeLists.txt e inserir o seguinte nele:

Cmake_minimum_required(VERSÃO 2.8) projeto(DisplayImage) find_package(OpenCV REQUIRED) add_executable(DisplayImage main.cpp) target_link_libraries(DisplayImage $(OpenCV_LIBS))

Tudo o que precisamos fazer é compilar e executar

cmfazer . fazer

Vamos lançar

./DisplayImage caminho_para_foto.jpg

Se tudo correr bem, veremos a imagem que você especificou no parâmetro do caminho do arquivo.

Leonid, programador da Sidstudio

Certa vez, eu estava interessado em montar carros robóticos usando Arduino e Raspberry Pi. Gostei de brincar com o conjunto de construção, mas queria algo mais.

E um dia, vagando pelo Aliexpress, me deparei com um chassi de tanque de alumínio. Esta criação parecia, em comparação com os carros de plástico, uma Ferrari em comparação com um carrinho.

Eu me dei um presente para Ano Novo, o tanque chegou, foi montado e depois foi necessário reanimá-lo. Retirei o próprio Raspberry, o conversor de energia, o controlador do motor e a bateria da máquina. Tudo isso foi instalado no tanque e funcionou perfeitamente.

O tanque deveria atirar, e o próximo passo foi o aparecimento de uma câmera. Não consegui adivinhar com a caixa da câmera - quando ela estava aberta ela não segurava a câmera, mas quando foi fechada estava tão apertada que a lente da câmera voou. Depois de sofrer, simplesmente colei a câmera na tampa da caixa com fita isolante. Agora o tanque não só podia circular pela sala, mas também tirar fotos.

É importante notar a grande vantagem de um tanque sobre os carros em casa - nas lagartas não faz diferença se ele dirige em piso duro ou em carpete. Os veículos com rodas escorregam em um tapete macio, a ponto de não conseguirem virar.

A seguir, quis desenvolver o tanque no sentido da navegação autônoma, contando com fotos da câmera. Tive que mergulhar no mundo da visão computacional e descobrir o OpenCV. Tudo começou com o reconhecimento de cores e contornos - imprimi um círculo vermelho no papel, colei na TV e forcei o robô a girar até encontrar o círculo.

A ideia era marcar objetos visíveis na sala (sofá, TV, mesa) com círculos multicoloridos e ensinar o robô a navegar por cores.

Usando OpenCV, foram pesquisados contornos da cor desejada (com tolerância aceitável) e, em seguida, um círculo foi pesquisado entre os contornos.

Parecia que o principal problema poderia ser um círculo aleatório da cor desejada em um dos objetos.

No entanto, o principal problema acabou sendo que a cor parece muito mutável dependendo da iluminação, de modo que a faixa em que o vermelho (por exemplo) foi reconhecido teve que ser esticada para tons que lembram vagamente a cor original. Ou selecione a cor desejada na imagem, mas em qualquer caso não era vermelho, mas sim um tom de marrom.

Procure um círculo vermelho:

Importar cv2 importar numpy como np importar sys def máscara_color(img, c1, c2): img = cv2.medianBlur(img, 5) hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV) máscara = cv2.inRange(hsv, c1, c2) máscara = cv2.erode(máscara, Nenhum, iterações=2) máscara = cv2.dilate(máscara, Nenhum, iterações=2) máscara de retorno def find_contours(img): cinza = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) desfocado = cv2.GaussianBlur (cinza, (5, 5), 0) limite = cv2.threshold (desfocado, 30, 255, cv2.THRESH_BINARY) limite = cv2.bitwise_not (limite) im2, cnts, hierarquia = cv2.findContours ( 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): cinza = cv2.cvtColor( img, cv2.COLOR_BGR2GRAY) desfocado = cv2.medianBlur (cinza, 5) círculos = cv2.HoughCircles (desfocado, cv2.HOUGH_GRADIENT, 1,20, param1 = 50, param2 = 30, minRadius = 0, maxRadius = 0) cimg = img se círculos não for Nenhum: círculos = np.uint16(np.around(círculos)) para i em círculos: cv2.circle(img,(i,i),i,(255,0,0),2) cv2 .circle(img,(i,i),2,(0,0,255),3) print "C", i,i,i return cimg def find_circle(img, rgb): tolerância = 4 hsv = cv2.cvtColor( rgb, cv2.COLOR_BGR2HSV) H = hsv c1 = (H - tolerância, 100, 100) c2 = (H + tolerância, 255, 255) c_mask = mask_color(img, c1, c2) rgb = cv2.cvtColor(c_mask,cv2) .COLOR_GRAY2RGB) cont_img = find_contours(rgb) circ_img = find_circles(cont_img) cv2.imshow("Imagem", circ_img) cv2.waitKey(0) if __name__ == "__main__": img_name = sys.argv img = cv2.imread( img_name) rgb = np.uint8([[]]) find_circle(img, rgb)
O reconhecimento de cores começou a chegar a um beco sem saída, fui distraído pelas Haar Cascades, usando o tanque para fotografar um gato. O gato se disfarçou bem, fazendo com que a cascata cometesse erros na metade das vezes (se alguém não sabe, o OpenCV vem com uma cascata Haar especialmente treinada para gatos - pegue e use).

Caçar um gato teve consequências úteis para o robô - como nem sempre era possível capturar o objeto da caça em uma câmera estática, instalei um tripé com dois servomotores (e um módulo PWM para controlá-los via Raspberry).

Continuando minha pesquisa sobre o que pode ser extraído das fotografias de uma sala, naturalmente cheguei às redes neurais. Depois de devorar o tutorial do Tensorflow, processei-o com um fotodetector de tanque e os resultados foram promissores - uma TV, uma mesa, um sofá, um gato e uma geladeira foram reconhecidos inequivocamente.

Esses experimentos foram realizados em um computador e só faltou transferir o TF para o Raspberry Pi. Felizmente, existe uma pessoa única morando no Github, que foi paciente e conseguiu instalar todas as dependências e muitas horas de compilação - e postou no acesso geral compilado por Tensorflow para Raspberry Pi.

No entanto, um estudo mais aprofundado do tema revelou que o OpenCV não fica parado e seus colaboradores lançaram um módulo DNN (Deep Neural Networks) que oferece integração com redes neurais treinadas no TensorFlow. Esta solução é muito mais conveniente de desenvolver, além de não haver necessidade do próprio TF. Tive que fazer um pouco de mágica, já que a versão mais recente da rede neural Mobile SSD para TF não foi mais adotada pela versão mais recente do OpenCV. eu tive que olhar
e verifique a versão funcional do Mobile SSD. Além disso, o DNN funciona normalmente apenas no OpenCV 3.4, e não encontrei esta versão para Raspberry. Tive que montá-lo sozinho, pois é muito mais fácil do que mexer no TensorFlow. Ao mesmo tempo, não foi possível compilar o OpenCV para a versão mais recente do Raspbian (Stretch), mas em última versão geração anterior(Jessie) tudo correu como deveria.

Código de exemplo usando DNN e não usando Tensorflow.

Vários arquivos responsáveis pelos nomes dos objetos foram extraídos do TF e a dependência do próprio TF foi removida (havia apenas leitura do arquivo).
Código fonte no GitHub.

Importar CV2 como CV Importar TF_labels Importar SYS DNN_PATH = "--- PATH-TO: SSD_MOBILENET_V1_COCO_11_06_2017/Frozen_inferencios _map.pbtxt " tf_labels.initLabels(PATH_TO_LABELS) cvNet = cv.dnn.readNetFromTensorflow(pb_path, pb_txt) img = cv.imread(sys.argv) linhas = img.shape cols = img.shape cvNet.setInput(cv.dnn.blobFromImage(img , 1,0/127,5, (300, 300), (127,5, 127,5, 127,5), swapRB=True, crop=False)) cvOut = cvNet.forward() para detecção em cvOut: score = float(detection) se score > 0,25 : esquerda = int (detecção * colunas) superior = int (detecção * linhas) direita = int (detecção * colunas) inferior = int (detecção * linhas) rótulo = tf_labels.getLabel (int (detecção)) imprimir (rótulo, pontuação, esquerda, superior, direita, inferior) text_color = (23, 230, 210) cv.rectangle(img, (esquerda, superior), (direita, inferior), text_color, espessura=2) cv.putText(img, label, ( esquerda, topo), cv.FONT_HERSHEY_SIMPLEX, 1, text_color, 2) cv.imshow("img", img) cv.waitKey()
Em geral, as fotos dos tanques agora podem ser reconhecidas por uma rede neural, e este é um passo muito importante na navegação em termos de reconhecimento de pontos de referência. Porém, as imagens por si só não foram suficientes para uma navegação completa; foi necessário medir as distâncias aos obstáculos. Foi assim que o robô conseguiu um ecobatímetro. Para conectar o localizador de peixes ao Raspberry, você precisa trabalhar um pouco - o localizador de peixes retorna um sinal de 5V e o Raspberry recebe 3,3V. No joelho, esse problema é resolvido principalmente com resistores no brainboard, mas eu não queria fazer tanto barulho no robô. Como resultado, foi encontrado o chip Level Shifter, que faz tudo o que é necessário e tem o tamanho de uma unha.

Além disso, estou preocupado aparência robô - não gostei muito que os microcircuitos e a câmera com ecobatímetro estivessem presos em papelão. O desenvolvimento da tecnologia em nosso mundo nos permite cortar plástico com laser a um custo razoável de tempo e dinheiro. No geral, encontrei uma oficina com uma máquina a laser, passei um tempinho estudando as instruções dessa máquina maravilhosa e, não na primeira tentativa, recortei painéis para microcircuitos e uma câmera com ecobatímetro.

Está tudo pronto para a navegação autônoma, mas a tarefa acabou não sendo tão simples e na primeira tentativa me perdi um pouco. Decidi fazer uma pausa, pensar em tudo e estudar análogos. Talvez esta navegação sirva de tema para um artigo à parte.

Interface REST que o robô fornece como base para uso posterior:

GET /ping GET /versão GET /nome GET /dist POST /fwd/on POST /fwd/off POST /back/on POST /back/off POST /left/on POST /left/off POST /right/on POST /right /off POST /photo/make GET /photo/:phid GET /photo/list POST /cam/up POST /cam/down POST /cam/right POST /cam/left POST /detect/haar/:phid POST /detect/ dnn/:phid

Proteja seu peito de olhares indiscretos sem lembrar de uma combinação ou usar uma chave. Seu rosto servirá de chave para abrir o baú!

EM este projeto mostra como usar um microcomputador Raspberry Pi e uma câmera Pi para abrir um baú usando tecnologia de reconhecimento facial.

A parte de software deste projeto é baseada em um algoritmo apresentado na biblioteca de visão computacional OpenCV. O Raspberry Pi é uma plataforma ideal para este projeto porque tem poder de processamento suficiente para rodar OpenCV e é pequeno para caber em qualquer lugar.

Este projeto é de complexidade média. Ele compila e instala Programas em um microcomputador Raspberry Pi. Se você tem experiência na criação de coisas semelhantes e não tem problemas ao usar a linha de comando, então está totalmente preparado para seguir todas as etapas deste projeto. Você também pode consultar os materiais de ajuda do sistema de aprendizagem Adafruit se encontrar algum problema.

Passo #1: Preparando o Baú

Faça um furo de 7/16" na parte superior do baú para acomodar a câmera Pi.
Faça um furo maior na parte de trás do baú para inserir o botão e os cabos de alimentação.

Passo #2: Fazendo a trava

Instale um pino na frente do baú que ficará preso na trava quando o servo for girado.
Faça uma pequena estrutura para apoiar o Pi e a trava servo. O servo é fixado à estrutura por meio de uma placa de madeira e parafusos de fenda.
Faça uma trava com dois pedaços de madeira colados em ângulo reto e presos ao braço do servo.

Passo #3: Finalizando o Baú

Verifique se a estrutura, Pi e a trava na parte superior do baú estão fazendo contato adequado. Certifique-se de que a trava do servo gire para baixo e encaixe no pino dentro da parte frontal do baú.
Instale pinos que passam pela parte superior do baú para apoiar a estrutura.
Elimine defeitos no baú com grosa e lixa e depois pinte a superfície de madeira conforme desejado.

Passo #4: Conectando Componentes Eletrônicos

Conecte a linha de sinal do servo ao pino 18 do GPIO no Raspberry Pi. A alimentação e o aterramento do servo devem ser conectados aos terminais de alimentação da bateria.
Conecte um pino do botão ao pino 25 do GPIO do Pi e, por meio de um resistor de 10K, ao pino de tensão de alimentação de 3,3V do Pi. Conecte o segundo pino do botão ao pino terra do Pi.
Conecte os cabos de aterramento da bateria e do Pi juntos.
Monte a câmera Pi através do orifício na parte superior do baú e conecte o cabo ao microcomputador Pi.

Etapa 5: Compilando OpenCV

Neste ponto, você precisa instalar a versão mais recente do OpenCV no seu Raspberry Pi. Infelizmente, você precisa primeiro compilar o OpenCV a partir do código-fonte, já que a versão binária antiga não contém os algoritmos de reconhecimento facial usados no projeto. A compilação do OpenCV no Pi leva cerca de 5 horas.
Ligue o Pi e conecte-se a ele por meio de uma sessão de terminal.
Execute os seguintes comandos para instalar dependências OpenCV:

sudo apt-get update && sudo apt-get install build-essential cmake pkg-config python-dev libgtk2.0-dev libgtk2.0 zlib1g-dev libpng-dev libjpeg-dev libtiff-dev libjasper-dev libavcodec-dev swig

Execute os seguintes comandos para baixar e descompactar o código-fonte da versão mais recente do 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

Execute os seguintes comandos para se preparar para compilar o código-fonte 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_opencv_ocl=OFF

Executar este comando para executar a compilação OpenCV (observe que a compilação leva cerca de 5 horas):

Assim que a compilação do OpenCV for concluída, execute este comando para instalar o Pi:

Etapa 6: testar o reconhecimento facial

Nesta fase, testaremos algoritmos de reconhecimento facial que permitirão abrir o baú.
Baixe o software para este projeto do repositório github (nota de rodapé: https://github.com/tdicola/pi-facerec-box).
Descompacte o arquivo e copie o conteúdo para um diretório no Pi.
Durante uma sessão de terminal no Pi, navegue no diretório e execute o seguinte comando para executar o script de teste:

sudo python capture-positivos.py

Enquanto o script está sendo executado, você pode pressionar um botão localizado no peito para tirar fotos usando a câmera do Pi. O script tentará identificar um rosto na imagem capturada e salvá-lo como um quadro capturado corretamente no subdiretório ./training/positivo.
Cada vez que uma imagem é capturada, um quadro é gravado no arquivo capture.pgm. Você pode visualizá-lo em editor gráfico para determinar como a câmera Pi captura e determina uma imagem do seu rosto.
Use o botão para capturar 5 ou mais imagens do seu rosto para obter os resultados corretos. Tente obter imagens de ângulos diferentes, iluminação diferente, etc. Nas fotografias você pode ver as imagens faciais que obtive.
Se estiver interessado, você pode conferir o diretório ./training/negative, que hospeda imagens do banco de dados de reconhecimento facial da AT&T que podem ser usadas como exemplos de pessoas que não deveriam ter acesso para abrir o baú.
Depois de receber as imagens corretas, execute os seguintes comandos para processar as imagens de teste corretas e incorretas e para testar o algoritmo de reconhecimento facial (observe que esta operação de teste leva cerca de 10 minutos):

trem python.py

Passo #7: Configuração Servo

Nesta fase, é necessário determinar as larguras de pulso do servo para travar e destravar a trava.
Com a energia fornecida ao microcomputador Raspberry Pi e ao servo de trava, conecte-se ao Pi em uma sessão de terminal. Certifique-se de que o baú esteja aberto para que você possa ver o servo se mover sem travar.
Execute o seguinte comando para iniciar uma sessão Python interativa como root (você deve ter acesso aos pinos GPIO e a capacidade de mover o servo):

sudo python

EM linha de comando Python >>>, insira este comando para carregar a biblioteca servo RPIO:

do RPIO importar PWM

Em seguida, digite o seguinte comando:

servo = PWM.Servo()

Finalmente, execute este comando para mover a trava do servo para a posição central:

servo.set_servo(18, 1500)

O parâmetro 1500 para set_servo define a largura de pulso do inversor em microssegundos. Os valores extremos variam de 1.000 a 2.000.
Experimente a função set_servo com diferentes larguras de pulso até obter os valores que fazem com que a trava feche e abra corretamente, conforme mostrado nas fotos.
Não se esqueça de que você pode remover o servo rocker e recolocá-lo para orientar corretamente a trava do servo.
Depois que os valores forem adivinhados, abra config.py em editor de texto com direitos de superusuário e altere os seguintes valores:
Defina LOCK_SERVO_UNLOCKED igual ao valor da largura de pulso para desbloquear a posição da trava - desbloqueio. No meu hardware, o valor adequado é 2.000.
Defina LOCK_SERVO_LOCKED para determinar se a posição da trava está travada - travada. No meu caso esse valor é 1100.

Passo #8: Inicie o Software

Depois de verificar o reconhecimento facial e calibrar o servo, você pode executar o código do programa!
Com a energia fornecida ao microcomputador Raspberry Pi e ao servo de trava, conecte-se ao Pi em uma sessão de terminal e navegue até o diretório raiz do projeto.
Execute o seguinte comando para executar o código (tenha cuidado, pois isso bloqueará imediatamente o baú):

sudo python box.py

Após baixar os dados do teste (isso leva alguns minutos), aponte a câmera para o seu rosto e pressione o botão para tentar o reconhecimento facial.
Se o baú reconhecer seu rosto, o servo irá operar e desbloquear a trava. Se o seu rosto não for reconhecido, o terminal exibirá uma mensagem indicando o quão próximo seu rosto estava da imagem de teste.
Para reconhecer um rosto, é necessário que a imagem capturada corresponda à imagem de teste com um nível de confiança de 2.000 ou menos. Se o seu rosto corresponder aos dados da imagem de amostra, mas a confiança for baixa, você poderá alterar o limite de confiança em config.py (na configuração POSITIVE_THRESHOLD). Se o reconhecimento ainda não for confiável, carregue imagens capturadas mais relevantes e execute o teste de reconhecimento novamente. O algoritmo de reconhecimento facial neste projeto é altamente dependente da iluminação do rosto, então tente ter a mesma fonte de iluminação das tentativas de teste (ou adicione algumas imagens adicionais sob diferentes condições de iluminação).
Após abrir o baú, pressione o botão novamente para fechá-lo. Nenhuma operação de reconhecimento facial é necessária para isso.
Se o baú tiver problemas para abrir e não reconhecer seu rosto, siga as etapas de configuração do servo para mover manualmente o servo para a posição destravada usando o comando set_servo.

OpenCV é uma biblioteca de funções popular visão de máquina, que permitem que os robôs reconheçam objetos no mundo circundante. OpenCV é usado para navegação, detecção de obstáculos, reconhecimento facial e de gestos. Este artigo irá sugerir instrução passo a passo sobre a instalação do OpenCV em um computador de placa única Raspberry Pi 3 Este artigo também precede uma série de lições destinadas a dominar as funções básicas do OpenCV.

Passo 1. Espaço livre

O OpenCV e vários pacotes de suporte juntos ocupam bastante espaço. É altamente recomendável usar um cartão SD de pelo menos 16 GB. A primeira coisa que você precisa fazer antes de instalar o OpenCV é expandir o sistema de arquivos para cobrir toda a capacidade do cartão SD. Isso é feito usando o menu de configuração do Raspbian. Vamos ao terminal e digitamos o comando: $ sudo raspi-config Um menu será aberto no qual você precisa selecionar o item superior: Pressione Enter e depois o botão . Depois disso, reiniciamos o sistema com o comando: $ sudo reboot Se o seu cartão SD tiver apenas 8 GB, você pode remover algo desnecessário, por exemplo o pacote wolfram-engine. $ sudo apt-get purge wolfram-engine Esta operação irá liberar 700 MB adicionais de espaço.

Etapa 2: instalar dependências

Para trabalho completo com o OpenCV precisaremos atualizar os pacotes existentes e instalar vários novos. Vamos começar com a atualização. $ sudo apt-get update $ sudo apt-get upgrade Dependendo da velocidade da Internet, essas operações levarão cerca de 5 a 10 minutos. Em seguida, instale o cmake e algumas outras coisas úteis no sistema: $ sudo apt-get install build-essential cmake pkg-config A seguir estão os pacotes para trabalhar com formatos de imagem conhecidos: $ sudo apt-get install libjpeg-dev libtiff5-dev libjasper -dev libpng12- dev Pacotes para trabalhar com vídeo: $ sudo apt-get install libavcodec-dev libavformat-dev libswscale-dev libv4l-dev $ sudo apt-get install libxvidcore-dev libx264-dev Pacotes para criar formulários de tela simples. Tudo isso também será necessário mais tarde. $ sudo apt-get install libgtk2.0-dev Operações especiais aceleradas em matrizes. $ sudo apt-get install libatlas-base-dev gfortran Arquivos de cabeçalho Python 2.7 e 3 $ sudo apt-get install python2.7-dev python3-dev

Etapa 3. Baixe OpenCV do repositório

Primeiro, baixe o arquivo com o próprio OpenCV. Para fazer isso, vá para a pasta /home/pi/Downloads: $ cd ~/Downloads Baixe o arquivo usando wget e descompacte-o: $ wget -O opencv.zip https://github.com/opencv/opencv/archive/ master .zip $ unzip opencv.zip Em seguida, baixe o pacote com itens adicionais - opencv_contrib. $ wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/master.zip $ descompacte opencv_contrib.zip

Etapa 4: Ambiente Virtual

Antes de instalar o OpenCV ainda mais, vamos limpar um pouco as coisas. Vamos criar um ambiente virtual que protegerá nossos experimentos futuros da parte principal sistema operacional. Isso é útil caso você precise remover Versão Atual opencv e instale um novo. Vamos começar instalando o gerenciador de pacotes pip: $ wget https://bootstrap.pypa.io/get-pip.py $ sudo python get-pip.py Em seguida, instale o gerenciador de ambiente virtual: $ sudo pip install virtualenv virtualenvwrapper $ sudo rm -rf ~ /.cache/pip Vamos adicionar algumas linhas ao perfil do usuário, que está armazenado no arquivo ~/.profile: $ echo -e "\n# virtualenv and virtualenvwrapper" >> ~/.profile $ echo "export WORKON_HOME=$HOME/.virtualenvs " >> ~/.profile $ echo "source /usr/local/bin/virtualenvwrapper.sh" >> ~/.profile Agora você precisa executar as três etapas a seguir:

feche todas as janelas do terminal
sair
faça login novamente
abra um terminal e digite o comando: $ source ~/.profile

Observação. Em geral, agora é recomendado inserir este comando a cada login. A seguir, criamos um ambiente virtual com o nome “cv”: $ mkvirtualenv cv -p python3 Para verificar se o ambiente virtual está instalado corretamente, reinicie o Raspberry Pi: $ sudo reboot Abra um terminal e entre no ambiente: $ source ~ /.profile $ workon cv Um indicador de que estamos em um ambiente virtual haverá um prefixo (cv) no início da linha de comando.

A última coisa a fazer antes de construir o OpenCV é instalar o pacote matemático NumPy: $ pip install numpy

Etapa 5. Compilar e instalar OpenCV

Ainda no ambiente virtual criado anteriormente, vamos para a pasta com códigos-fonte OpenCV e execute os comandos: $ cd ~/Downloads/opencv-master $ 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=~/ Downloads /opencv_contrib-master/modules -D BUILD_EXAMPLES=ON .. Ao final do procedimento, aparecerá uma lista de componentes OpenCV prontos para instalação.

A seção dedicada ao python está destacada em vermelho. Bom, agora a parte mais interessante: montar os binários. Sem sair da pasta atual, execute o comando make: $ make -j4 j4 significa que construiremos o pacote usando todos os 4 núcleos do Raspberry Pi. Isso irá acelerar bastante o procedimento, mas mesmo nessas condições a montagem levará cerca de uma hora e meia. A compilação deve terminar com algo assim:

Observação. Pessoalmente, durante a montagem, o sistema congelou algumas vezes. Ou seja, nem o mouse se mexeu. Desligar/ligar e reiniciar a compilação com a opção -j2 ajudou. A última coisa a fazer é instalar o binário compilado na pasta python: $ sudo make install $ sudo ldconfig

Etapa 6: instalação completa

Após a instalação, um arquivo cv2.cpython-34m.so aparecerá na pasta de trabalho do python, que precisa ser renomeado para algo mais eufônico: $ cd /usr/local/lib/python3.4/site-packages/ $ sudo mv cv2.cpython -34m.so cv2.so Para que possamos usar o OpenCV em um ambiente virtual, faremos um link para o cv2.so resultante: $ cd ~/.virtualenvs/cv/lib/python3.4/ pacotes de sites/ $ ln -s /usr/local/lib/python3.4/site-packages/cv2.so cv2.so

Etapa 7: verificar

Para verificar se a instalação está correta, vamos entrar no ambiente virtual, iniciar o interpretador python e tentar importar o módulo cv2: $ source ~/.profile $ workon cv $ python >>> import cv2 >>> cv2.__version__ "3.1 .0" >>> Isso é tudo - OpenCV instalado com sucesso! Nas próximas lições trataremos do processamento de imagens de uma câmera de vídeo em relação à robótica.

Biblioteca de visão computacional de código aberto

Esta é uma biblioteca para a linguagem de programação Python que simplifica o trabalho com visão computacional (seção de aprendizado de máquina).
Para entender, proponho considerar o processo de reconhecimento facial (clássico), caso o OpenCV não existisse:

Em primeiro lugar, você precisa ter uma enorme coleção de imagens com e sem rostos de pessoas.
Para estruturar este conjunto - combinar cada imagem com uma explicação: se há um rosto humano nela.
Divida de maneira uniforme e correta a coleção estruturada em amostras de treinamento e controle.
Em seguida, pesquisando e combinando vários métodos de aprendizado de máquina (“árvore”, “floresta aleatória”, “gradiente descendente”, “vizinhos mais próximos”, etc.) para criar uma rede neural que forneça um resultado de reconhecimento aceitável tanto no treinamento quanto no teste amostras. Esta etapa pode levar meses(!) (dependendo dos recursos computacionais disponíveis)

E os desenvolvedores do OpenCV fornecem a todos um conjunto gratuito de algoritmos de visão computacional de primeira classe para várias aplicações - pegue-o e use-o!)

AVISO:

A seguir são discutidos os meandros da instalação do OpenCV no Raspbian, no entanto, as instruções são bastante universais para todas as distribuições da família Debian
instalar o OpenCV leva muito tempo (2 a 3 horas), mas você não precisa percorrer todo o caminho de uma só vez - você pode parar e continuar do mesmo lugar.
Será necessário.
Realizaremos a instalação no Raspberry Pi 3 em um Raspbian Desktop limpo e recém-instalado da versão mais recente. cm.

Preparação

Requer 7 GB espaço livre em uma unidade flash.
Para verificar a disponibilidade de espaço livre no pen drive, abra um terminal (Ctrl + Alt + T) e digite o comando
df-h
Se não houver espaço suficiente, embora o tamanho do pen drive deva permitir, vale a pena verificar se ele está expandido sistema de arquivo para todo o volume disponível (nas novas versões da distribuição isso agora é feito por padrão - a partir de abril de 2018).
Se o sistema não for muito novo, você pode ir para a seção de configurações principais
sudo raspi-config
e selecione o primeiro item “1. Expanda o sistema de arquivos” e reinicie o Raspberry

Instalando pacotes necessários

Se as atualizações não são realizadas há muito tempo, é aconselhável fazê-las agora
sudo apt-get atualização -y && sudo apt-get atualização -y
Instale um conjunto de pacotes para construir programas a partir do código-fonte
sudo apt-get install build-essential cmake pkg-config -y
Em seguida, instalamos um conjunto de bibliotecas para trabalhar com conteúdo gráfico de diversos formatos
sudo apt-get install libjpeg-dev libtiff5-dev libjasper-dev libpng12-dev -y
A seguir, o mesmo para conteúdo de vídeo.
sudo apt-get instalar libavcodec-dev libavformat-dev libswscale-dev libv4l-dev -y sudo apt-get instalar libxvidcore-dev libx264-dev -y
Instale o pacote de compilação do módulo highgui para exibir imagens e interfaces na tela
sudo apt-get install libgtk2.0-dev -y
E finalmente, uma biblioteca de álgebra linear e um compilador Fortran:
sudo apt-get install libatlas-base-dev gfortran -y

Pitão

Em seguida, instale o Python (ou Python). Versões básicas 2,7 e 3 já estão integrados ao Raspbian, mas serão necessários pacotes adicionais:
sudo apt-get instalar python2.7-dev python3-dev -y
Além disso, para Python (ou Python), recomendo instalar os utilitários virtualenv e virtualenvwrapper - este é um análogo de 'e apenas para Python, eles permitem que você trabalhe com Python no “ambiente virtual” selecionado - um conjunto de pacotes de determinados versões (análogos de gemsets Ruby) - isso é conveniente ao trabalhar em vários projetos com diferentes conjuntos de bibliotecas (e especialmente diferentes versões de bibliotecas): para mudar para, digamos, Python 2.7 com OpenCV 3.1, você só precisará inserir apenas um comando no terminal. Instalar:
sudo pip install virtualenv virtualenvwrapper sudo rm -rf ~/.cache/pip echo -e "\n# virtualenv e virtualenvwrapper" >> ~/.profile echo "export WORKON_HOME=$HOME/.virtualenvs" >> ~/.profile echo "fonte /usr/local/bin/virtualenvwrapper.sh" >> ~/.profile fonte ~/.profile
Isso completa as dependências.
Criamos um ambiente virtual usando virtualenv. E então você deve decidir sobre a versão do Python - se o objetivo é criar um projeto do zero, então você deve escolher python3, caso contrário - python2
No processo de desenvolvimento histórico da linguagem Python, muito foi escrito durante a relevância da versão 2.7 bons programas. E mesmo agora, na época das versões 3.5 estáveis do Python 2.7, ele ainda não foi esquecido e é usado e suportado ativamente - ocorreu uma ramificação. É o mesmo com as bibliotecas Python – nem todas funcionarão igualmente bem em 2.7 e 3.5
mkvirtualenv cv -p python3
Certificamo-nos de que estamos agora no ambiente virtual criado cv. Isso pode ser reconhecido pela combinação “(cv)” no console próximo à linha ativa atual:

E, finalmente, instale a biblioteca Numpy para um trabalho conveniente com arrays e matrizes de grandes dimensões
pip instalar numpy

Baixando Open CV do repositório

Crie uma pasta para a biblioteca em seu diretório inicial e vá até ela
cd ~ mkdir opencv cd opencv/
Vamos decidir sobre a versão OpenCV.
Desde o lançamento da versão 3.0, versões mais antigas do 2.4.x continuam a ser suportadas e lançadas e existem diferenças significativas entre elas. Por exemplo, o pacote 'contrib' de módulos adicionais está disponível apenas para novas versões 3+.
Vamos para a página inicial do projeto na seção “Releases”. Sugiro instalar ainda mais a versão mais recente (3+ e não 2.4.x.x) e não usar a versão mais recente:

Assim, a escolha recaiu sobre a versão 3.4.0.
Para obter o link de download, acesse o modo offline. Abra o repositório de CV na seção de lançamentos: https://github.com/opencv/opencv/releases e copie o link para o arquivo zip da versão selecionada:

Voltemos ao Framboesa.
Enquanto estiver na pasta /opencv, execute o comando para baixar as fontes:
wget -O opencv.zip https://github.com/opencv/opencv/archive/3.4.0.zip
este comando irá baixar o arquivo e renomeá-lo para opencv.zip
Vamos descompactar o arquivo baixado e excluí-lo:
descompacte opencv.zip rm opencv.zip
Baixe e descompacte a mesma versão de módulos adicionais contribuir(neste caso - 3.4.0). Fora da página de lançamentos. repositório: https://github.com/opencv/opencv_contrib/releases
wget -O opencv_contrib.zip https://github.com/opencv/opencv_contrib/archive/3.4.0.zip descompacte opencv_contrib.zip rm opencv_contrib.zip
O resultado deve ser o seguinte (o comando ls mostra o conteúdo da pasta atual):

Compilando e instalando OpenCV

Vamos ter certeza mais uma vez de que estamos no ambiente virtual criado para OpenCV (capítulo de instalação do Python). Se o ambiente já foi criado, você pode acessá-lo com o comando workon cv
Vá para a pasta do arquivo OpenCV descompactado (a versão e, consequentemente, o nome da pasta podem ser diferentes):
CD opencv-3.4.0/
A seguir, executamos uma série de comandos para iniciar o processo de construção do instalador.
Estes são 3 comandos - o último é multilinha, nele ESPECIAL Preste atenção ao caminho para a pasta do arquivo contrib descompactado:
mkdir construir cd construir 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=ON ..
Se a construção for bem-sucedida, veremos o seguinte. Sobre este momento acabamos de cumprir todas as condições para compilar o instalador OpenCV, então preste atenção na seção Python3 (ou Python2), deve ser como na captura de tela, caso contrário (ou em caso de falha) verifique:

talvez o ambiente virtual (cv) não tenha sido ativado durante a montagem - workon cv
Mais razao possivel falha: caminho absoluto incorreto para a pasta de módulos adicionais contribuir
Como último recurso, você pode verificar o diretório atual - você deve estar na pasta de construção do arquivo OpenCV descompactado da versão selecionada
Finalmente, certifique-se de que as versões de lançamento dos pacotes principal e contrib correspondam

De qualquer forma, está tudo bem) Você deve verificar tudo e iniciar a montagem novamente

Se a montagem correu bem, então todas as condições para compilar o instalador OpenCV estão satisfeitas e agora montaremos nossa própria distribuição OpenCV nova e estável com módulos extras do código-fonte!
Vamos começar a compilação
Parâmetro -j4 significa o número de núcleos de processador envolvidos, o Raspberry Pi 3 tem 4.
ATENÇÃO!! Este processo levará cerca de 1,5 horas, no máximo!!!
faça -j4
Se observarmos um travamento nos primeiros 5 minutos de compilação, isso pode acontecer mesmo em condições ideais, então zeramos o resultado e executamos a compilação em um núcleo:
fazer limpeza
Se for bem-sucedido, veremos o seguinte - o processo de compilação está 100% concluído

Resta apenas executar o instalador montado com o comando
sudo make install sudo ldconfig
É isso, o OpenCV está instalado no Raspberry! Para torná-lo conveniente de usar, tudo o que resta fazer é encaminhá-lo para OpenCV para o ambiente virtual Python (cv) criado. Vamos definir um diretório - como o OpenCV é uma biblioteca Python, ele deve estar na pasta das outras bibliotecas, vamos verificar:

equipe eu exibe o conteúdo do diretório especificado no terminal
não se esqueça de especificar no comando a pasta Python com a versão para a qual você realmente instalou o OpenCV

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

Em casos excepcionais, a biblioteca pode estar localizada em uma pasta próxima pacotes dist:
ls /usr/local/lib/python3.5/dist-packages/
Vamos para este diretório
cd /usr/local/lib/python3.5/site-packages/
Vamos renomear o arquivo da biblioteca - isso tornará mais fácil chamá-lo no código Python
sudo mv cv2.cpython-35m-arm-linux-gnueabihf.so cv2.so
Vamos copiar o caminho completo do arquivo.

Vamos ao diretório da biblioteca do ambiente virtual cv:
cd ~/.virtualenvs/cv/lib/python3.5/site-packages/
Vamos criar um link simbólico aqui no OpenCV:
ln -s /usr/local/lib/python3.5/site-packages/cv2.so cv2.so
Vamos verificar o resultado com o comando ls:

Exame

Abra uma nova janela de terminal
fonte ~/.profile workon cv python importar cv2 cv2.__versão__
Se tudo for feito corretamente, a biblioteca OpenCV será importada para o console Python sem erros

Em caso de erro de importação, verifique cuidadosamente se o arquivo da biblioteca foi renomeado corretamente e um link simbólico para ele foi criado (extensão - .so), bem como se a transição para o ambiente virtual cv foi bem-sucedida

Artigos semelhantes