Abstrato
- 1145
- 173
- Enrique Gutkowski PhD
Convenções usadas neste artigo:
- $ - Execução na linha de comando por um usuário não privilegiado
- # - Execução na linha de comando por um superusor
- o comando real a ser executado na linha de comando ou código de programa a ser compilado
- SAÍDA: Saída produzida na linha de comando por execução de comando
- OBSERVAÇÃO: Notas gerais e informações adicionais
Introdução
Em palavras simples, uma visão computacional é um campo científico que tenta fornecer uma visão à máquina. Este campo científico se expandiu rapidamente nos últimos anos. Entre os pesquisadores, esse crescimento se deve a muitas melhorias dos algoritmos de visão e entre os entusiastas da visão computacional, isso se deve aos componentes de hardware mais baratos e ao poder de processamento. A Biblioteca OpenCV desempenha um grande papel no campo da visão computacional, pois ajuda muito a reduzir o tempo de custo e preparação do ambiente de pesquisa de visão computacional necessária para estudantes universitários, entusiastas e profissionais. OpenCV também fornece funções simples de usar para realizar o trabalho de maneira simples, eficaz e elegante. OpenCV foi iniciado pela Intel e, mais tarde, foi transformado em um projeto de código aberto agora disponível no SourceForge.líquido. A Biblioteca OpenCV possui disponibilidade de várias plataformas e é parcialmente escrita na linguagem C ++ e C. Apesar de essa biblioteca estar disponível em muitas distribuições Linux de seus repositórios de pacotes relevantes, neste artigo tentaremos instalar e usar a biblioteca OpenCV compilada a partir de um código -fonte baixado do SourceForge.Site da rede.
Os motivos para compilar um código -fonte podem incluir:
- Nova versão 2.0.0 Recentemente lançado e mais recursos disponíveis
- Alguns bugs corrigidos que afetaram o Linux OpenCV 1.0.0 versões (como cvgetcaptureProperty () etc. )
- Mais suporte está disponível para OpenCV 2.0.0 versão do que para anterior 1.0.0 versão
Este artigo começará com a instalação do OpenCV no Debian 5.0 (Lenny). Mais tarde, um leitor será guiado por vários exemplos de como usar o OpenCV para exibir uma imagem, reproduzir um vídeo e usar a câmera para capturar o fluxo de entrada de vídeo.
Instalação
A seção a seguir descreverá um processo de instalação da Biblioteca OpenCV, construindo um binário a partir de um código -fonte disponível no SourceForge.líquido. O procedimento de instalação demonstrado aqui foi testado no Debian 5.0 (Lenny) e Ubuntu 9.10 (Karmic Koala). O procedimento de instalação real deve ser semelhante ou exatamente o mesmo para a maioria das distribuições Linux, além da primeira etapa, onde as dependências de pacotes são instaladas a partir de repositórios relevantes de Debian e Ubuntu Distribution. No sistema RPM Linux, você poderia consultar sua ferramenta Red Hat Package Management (RPM) para alternativas para os pré -requisitos OpenCV descritos na próxima seção.
Pré -requisitos
Primeiro, o que precisa ser feito é a instalação dos pré -requisitos exigidos pela biblioteca OpenCV. A lista de dependências pode ser ligeiramente modificada de acordo com suas necessidades:
- libavformat -dev - arquivos de desenvolvimento para libavformat the ffmpeg file format biblioteca
- libgtk2.0 -DEV - Arquivos de desenvolvimento para a biblioteca de interface do usuário GTK+
- PKG -Config - Gerenciar sinalizadores de compilação e vincular para bibliotecas
- LIBSWSCALE -DEV - Arquivos de desenvolvimento para libswscale The FFMPEG Video Scaling Library
- CMake-Um sistema de código aberto, de plataforma cruzada, usada para compilação do código-fonte
- BZIP2-Compressor de arquivo de classificação de bloco de alta qualidade usado para extrair arquivo de origem OpenCV
O comando Linux a seguir buscará e instalará automaticamente todos os pacotes necessários e suas dependências:
# instalação apt-get.0-dev pkg-config cmake libswscale-dev bzip2
Obtendo código -fonte OpenCV
Versão atual da biblioteca OpenCV no momento da redação é uma versão 2.0.0. Você pode baixar um código fonte do OpenCV, apontando seu navegador da web para openCV-SOURCEFORGE.Net ou use o comando wget para adquirir um código -fonte diretamente na linha de comando:
$ wget http: // downloads.sourceforge.net/Project/OpenCvlibrary/OpenCV-UNIX/2.0/OpenCV-2.0.0.alcatrão.BZ2
Extrair código -fonte OpenCV
Se você usou o navegador da web ou o utilitário wget para baixar o código-fonte da biblioteca OpenCV, você deve acabar com o OpenCV-2.0.0.alcatrão.BZ2 Tarball em seu diretório de trabalho atual. O próximo passo é extrair arquivos de origem com o comando alcaturaco. O comando Linux a seguir extrairá todos os arquivos para OpenCV-2.0.0 diretório:
$ tar xvjf opencv-2.0.0.alcatrão.BZ2
Novo OpenCv-2.0.0 diretório (aprox. 67 MB) deve estar agora disponível em seu diretório de trabalho atual e conterá todos os arquivos de origem necessários para uma compilação.
Compilação e instalação de binários OpenCV
Para compilar o código-fonte do OpenCV, vamos usar um sistema de código aberto. As seguintes bandeiras de compilação de configuração do CMake serão definidas:
- Cmake_build_type = liberação: cmake irá a um projeto de liberação
- Cmake_install_prefix =/usr/local: diretório a ser usado como destino de instalação
- Build_python_support: Ativar suporte de python
OBSERVAÇÃO: O utilitário cmake por padrão não fornece uma maneira de desinstalar seu projeto de um sistema. Se você precisar desinstalar o sistema OpenCCV do seu sistema, você deve fazer alterações apropriadas antes de prosseguir com a compilação.
Navegue para OpenCV-2.0.0 Diretório contendo um código -fonte:
$ CD OpenCV-2.0.0/
Crie e navegue para um novo diretório a ser usado pelo CMake. I Nesse caso, o nome do diretório é o mesmo que o tipo de projeto, "Release":
$ mkdir liberação; liberação do CD
Use cmake para criar arquivos de configuração com sinalizadores de configuração descritos acima:
OBSERVAÇÃO: Sinalizador cmake_install_prefix pode ser definido como qualquer caminho de instalação desejado
cmake -d cmake_build_type = release -d cmake_install_prefix =/usr/local -d build_python_support = on…
Após a execução do comando cmake, o resumo da instalação será exibido e será parecido com o abaixo.
SAÍDA:
- Configuração geral para OpenCV 2.0.0 ======================================
-
- Compilador:
- Sinalizadores c ++ (liberação): -wall -thread -function -sections -o3 -dndebug -fomit -frame -pointer -o3 -ffast -math -mmx -dndebug
- Sinalizadores C ++ (Debug): -Wall -Thread -function -Sections -g -o0 -ddebug -d_debug
- Bandeiras do vinculador (liberação):
- Bandeiras do vinculador (Debug):
-
- GUI:
- GTK+ 2.x: 1
- Gthread: 1
-
- Imagem E/S:
- JPEG: Verdadeiro
- PNG: Verdadeiro
- TIFF: FALSO
- Jasper: Falso
-
- E/S de vídeo:
- DC1394 1.x: 0
- DC1394 2.x: 0
- Ffmpeg: 1
- Codec: 1
- Formato: 1
- UTIL: 1
- SWSCALE: 1
- Gentoo-estilo: 1
- GSTREAMER: 0
- Unicap:
- V4l/v4l2: 1/1
- Xine: 0
-
- Interfaces:
- Python velho: 0
- Python: ON
- Use IPP: não
- Crie documentação 0
-
- Instalar caminho: /usr /local
-
- cvconfig.h está em:/home/sandbox/opencv-2.0.0/liberação
- -
-
- Configurando feito
- Gerando feito
- Os arquivos de construção foram gravados para:/home/sandbox/opencv-2.0.0/liberação
Quando a execução do comando cmake não produziu erros, estamos prontos para compilar um código -fonte.:
OBSERVAÇÃO: Haverá várias mensagens de aviso mostradas no seu terminal durante um processo de construção. Essas mensagens de alerta podem ser ignoradas, a menos que afetem suas configurações de ambiente preferidas de openCV!
$ make
Se nenhum erro foi exibido no terminal e a caixa de diálogo de progresso atingida [100%] durante o processo de compilação, estamos prontos para instalar bibliotecas OpenCV. A instalação é opcional, desde que sua variável ambiental ld_library_path esteja vinculada a um diretório de openCV apropriado. Se você deseja instalar o OpenCV em /usr /local, conforme definido por sinalizadores cmake acima, execute um comando Linux a seguir:
# faça instalar
Exportar caminho correto para a variável de ambiente LD_LIBRARY_PATH e use o LDConfig para vincular dinamicamente a uma biblioteca OpenCV:
$ export ld_library_path =/usr/local/lib/: $ ld_library_path
# ldconfig
Se você não deseja instalar a biblioteca OpenCV, basta exportar um caminho correto para o diretório de criação da biblioteca OpenCV para que seu sistema saiba onde a biblioteca está localizada. Suponha que seu novo diretório de liberação esteja localizado em ~/opencv-2.0.0/liberação, então seu caminho de exportação ficará assim:
$ export ld_library_path = ~/opencv-2.0.0/release/: $ ld_library_path
# ldconfig
Isso completa um procedimento de instalação da Biblioteca OpenCV. Para obter informações adicionais sobre o guia de instalação da instalação do OpenCV, visite OpenCV.
Exemplos de OpenCV
Sem prolongar uma discussão sobre o que é a visão computacional e como está relacionada ao OpenCV, agora iremos direto para alguns exemplos sobre como escrever, compilar e executar programas simples usando a biblioteca OpenCV. Se você estiver interessado em uma introdução mais intensa à visão computacional e à OpenCV, recomendo um livro: “Aprendizagem OpenCV: Visão computacional com a Biblioteca OpenCV de Gary Bradski e Adrian Kaehler“.
Uma conversão de imagem
Vamos começar com algo realmente simples e que são 7 linhas de código para converter a imagem entre os seguintes tipos de imagem:
- Windows Bitmaps - BMP, DIB
- Arquivos JPEG - JPEG, JPG, JPE
- Gráficos de rede portáteis - PNG
- Formato de imagem portátil - PBM, PGM, PPM
- Sun Rasters - SR, RAS
- Arquivos TIFF - TIFF, TIF
O programa a seguir aceitará dois argumentos da linha de comando, imagem de origem e imagem de destino. A imagem de origem será armazenada como um tipo de imagem especificado pela extensão do arquivo de imagem de destino. Salve o seguinte código em um arquivo chamado Image-conversion.C:
#include "Highgui.h "
int main (int argc, char ** argv)
Iplimage* img = cvLoadImage (argv [1]);
cvSaveImage (argv [2], img);
cvReleaseImage (& img);
return0;
O código -fonte do nosso novo programa está pronto e aqui vem a parte de compilação. Supondo que você tenha salvado seu primeiro programa de OpenCV como conversão de imagem.C Você pode compilar seu programa com o seguinte comando Linux:
$ g ++ 'pkg-config opencv--cflags--libs'.C -O Conversão de imagem
Após a compilação bem-sucedida, um novo arquivo binário executável denominado conversão de imagem é criado em seu diretório de trabalho atual. Antes de testarmos este novo programa, precisamos de alguma imagem de amostra:
$ wget -o imagem.png http: // www.LinuxConfig.org/modsates/rhuk_milkyway/imagens/mw_joomla_logo.png
WGet baixou e salvou uma imagem de imagem.PNG em seu diretório atual, e agora podemos tentar converter esta imagem em qualquer tipo de imagem listado acima. O comando Linux a seguir converterá o tipo de imagem PNG em JPG. Supondo que a compilação do programa não produzisse erros e seu arquivo binário seja salvo como conversão de imagem, você pode converter entre dois tipos de imagem com o seguinte comando linux:
$ ./imagem de conversão de imagem.Imagem PNG.jpg
Para confirmar que a imagem foi convertida, um comando de arquivo pode ser usado para exibir um tipo de arquivo para um determinado arquivo como argumento:
$ imagem de arquivo.*
SAÍDA:
imagem.JPG: JPEG Image Data, JFIF Standard 1.01
imagem.PNG: imagem PNG, 270 x 105, 8 bits/color
Quando você olha para o comando de compilação mais uma vez, pode observar que um utilitário PKG -Config foi usado para recuperar um local de uma biblioteca OpenCV com o uso da opção -cflags, bem como para obter todas as dependências usando -libs opção. Portanto, um comando alternativo ao acima sem o utilitário PKG-Config pode ser construído para parecer algo assim:
g ++ -i/usr/local/incluir/opencv -l/usr/local/lib \
-LCXCORE -LCV -LHIGHGUI -LCVAUX -LML Image -Conversão.C -O Conversão de imagem
No entanto, em ambos os casos, o comando de compilação criará dependências indesejadas da biblioteca:
$ LDD Conversão de imagem | Grep Local
SAÍDA:
libcxcore.então.2.0 =>/usr/local/libcxcore.então.2.0 (0xb7cc000)
libcv.então.2.0 =>/usr/local/lib/libcv.então.2.0 (0xb7a7a000)
libhighgui.então.2.0 =>/usr/local/libhighgui.então.2.0 (0xb7a3f000)
libcvaux.então.2.0 =>/usr/local/libcvaux.então.2.0 (0xb793b000)
libml.então.2.0 =>/usr/local/lib/libml.então.2.0 (0xb78d8000)
Nosso programa depende do Highgui do OpenCV.biblioteca h e, portanto, incluindo -lcvaux -lml -lcxcore e -lcv dependências em um comando de compilação não é necessário. Uma versão abreviada do comando de compilação ficará assim:
$ g ++ -i/usr/local/incluir/opencv -lHighgui Image -conversion.C -O Conversão de imagem
Consequentemente, uma dependência da biblioteca de programas foi reduzida:
$ LDD Conversão de imagem | Grep Local
SAÍDA:
libhighgui.então.2.0 =>/usr/local/libhighgui.então.2.0 (0xb7f61000)
libcxcore.então.2.0 =>/usr/local/libcxcore.então.2.0 (0xb7a75000)
libcv.então.2.0 =>/usr/local/lib/libcv.então.2.0 (0xb7823000)
A partir de agora, cabe a você como você compila os seguintes exemplos neste artigo. Lembre-se de que o primeiro comando de compilação, incluindo pkg-config, poderá compilar todos os exemplos. No entanto, pode produzir um binário com dependências excessivas.
Exibir uma imagem
Neste ponto, conseguimos converter um tipo de imagem e confirmar sua meta descrição por comando de arquivo. É hora de exibir uma imagem na tela e confirmar visualmente que ela foi convertida corretamente. O programa de exemplo a seguir exibirá uma imagem na tela:
#include "Highgui.h "
int main (int argc, char ** argv)
// cvloadimage determina um tipo de imagem e cria dados de dados com tamanho apropriado
Iplimage* img = cvLoadImage (argv [1]);
// Crie uma janela. O nome da janela é determinado por um argumento fornecido
cvNamedWindow (argv [1], cv_window_autosize);
// exibe uma imagem dentro e janela. O nome da janela é determinado por um argumento fornecido
cvshowImage (argv [1], img);
// Aguar
cvwaitKey (0);
// Libere o ponteiro para um objeto
cvReleaseImage (& img);
// Destrua uma janela
cvDestroyWindow (argv [1]);
OBSERVAÇÃO: Retorne a uma seção de conversão de imagem acima, se você precisar de ajuda sobre como compilar este programa OpenCV.
Execução deste programa de imagem de exibição com uma imagem.O JPG produzido na seção anterior exibirá esta imagem na tela:
$ imagem de imagem de exibição.jpg
SAÍDA:
Gaussiano suave
Você também pode tentar criar uma transformação de imagem simples usando o método suave gaussiano. Adicione uma linha a seguir no seu código de imagem de exibição antes de uma chamada de função cvshowImage:
..
cvNamedWindow (argv [1], cv_window_autosize);
cvsmooth (img, img, cv_gaussian, 9, 9);
cvshowImage (argv [1], img);
..
e adicione como uma primeira linha ao seu programa '#include “cv.H ”'Diretiva.
Isso incorporará um método suave gaussiano centrado em cada pixel com 9 x 9 área na imagem de saída. Após a compilação e execução, será apresentada uma saída seguinte:
SAÍDA:
Reproduzir vídeo
Esta seção inclui um código de programa que criará um player de vídeo simples usando a Biblioteca OpenCV. Exemplo de vídeo, árvore.AVI pode ser encontrado em seu OpenCV-2.0.0 Diretório onde você extraiu seus arquivos de origem (OpenCV-2.0.0/amostras/c/árvore.Avi):
#include "cv.h "
#include "Highgui.h "
// inicializa variáveis globais
int g_slider_position = 0; // Posição do trackbar
CvCapture* g_capture = null; // estrutura para criar uma entrada de vídeo
// rotina a ser chamada quando o usuário move um controle deslizante de trackbar
Void onTrackBarslide (int pos)
cvSetCaptureProperty (
g_capture,
Cv_cap_prop_pos_frames,
POS
);
int main (int argc, char ** argv)
// Crie uma janela com tamanho apropriado. O nome do Windows é determinado pelo nome do arquivo
// fornecido como argumento
cvNamedWindow (argv [1], cv_window_autosize);
// Abra o vídeo
g_capture = cvCreateFilecApture (argv [1]);
// Defina a posição de leitura em unidades de quadros e recupere o número total de quadros
Int Frames = (int) cvgetCaptureProperty (
g_capture,
CV_CAP_PROP_FRAME_COUNT
);
// Não crie treackbar se o vídeo não incluir uma informação
// sobre o número de quadros
if (quadros!= 0)
CVCreateTrackBar (
"Posição",
argv [1],
& g_slider_position,
quadros,
OnTrackBarsLide
);
// Exibir quadro de vídeo por quadro
Iplimage* quadro;
enquanto (1)
quadro = cvQueryFrame (g_capture);
se( !quadro) quebrar;
cvshowImage (argv [1], quadro);
// defina trackbar para uma posição de quadro atual
cvSettrackBarPos ("Position", argv [1], g_slider_position);
g_slider_Position ++;
char c = cvwaitKey (33);
// saia se o ESC for pressionado
if (c == 27) quebra;
// memoria livre
cvReleasecApture (& g_capture);
cvDestroyWindow (argv [1]);
retornar (0);
OBSERVAÇÃO: Retorne a uma seção de conversão de imagem acima, se você precisar de ajuda sobre como compilar este programa OpenCV.
Execute seu novo programa OpenCV e, como argumento, forneça um arquivo de vídeo:
$ ./Video-player ~/OpenCv-2.0.0/amostras/c/árvore.Avi
SAÍDA:
Entrada de uma câmera de vídeo
O objetivo desta seção é fornecer algumas dicas simples sobre como configurar uma câmera em um sistema Linux e como confirmar que sua câmera de vídeo é reconhecida pelo seu sistema corretamente. Quando sua câmera estiver pronta, você receberá um programa simples que é capaz de exibir um vídeo usando uma câmera de vídeo como uma entrada.
Para este artigo, usei um Logitech, Inc. Câmera Quickcam Pro 9000. Instalação desta câmera no Debian 5.0 ou Ubuntu 9.10 (Karmic Koala) Sistema foi um procedimento simples de plug & play. Aqui estão algumas dicas sobre como confirmar que sua câmera foi reconhecida pelo seu sistema:
OBSERVAÇÃO: Sua saída será diferente !
$ lsusb
SAÍDA:
Bus 002 Dispositivo 003: ID 046D: 0990 Logitech, Inc. Quickcam Pro 9000
Bus 002 Dispositivo 001: ID 1d6b: 0002 Fundação Linux 2.0 hub de raiz
Bus 001 Dispositivo 002: ID 045E: 00D1 Microsoft Corp. Mouse óptico com roda de inclinação
Bus 001 Dispositivo 001: ID 1d6b: 0001 Fundação Linux 1.1 hub de raiz
O comando lsusb revela um tipo de câmera conectado ao seu sistema. A saída do comando LSUSB não significa que sua câmera agora está pronta para usar. Vamos ver se alguns módulos estão associados ao vídeo:
$ lsmod | Vídeo Grep
SAÍDA:
UVCVideo 45800 0
compat_ioctl32 1312 1 UVCVideo
VideoDev 27520 1 UVCVideo
v4l1_compat 12260 2 uvcvideo, videodev
USBCORE 118192 7 SND_USB_AUDIO, SND_USB_LIB, UVCVIDEO, USBHID, EHCI_HCD, OHCI_HCD
Isso parece muito promissor. Minha câmera está usando o módulo UVCVideo. Se você não vê nenhum ouptut ou ver apenas a saída não relacionada ao seu dispositivo de câmera, talvez seja necessário recompilar seu kernel ou instalar um módulo apropriado.
Agora precisamos encontrar um arquivo de dispositivo correspondente à sua câmera. Para fazer isso, usamos o utilitário XAWTV:
OBSERVAÇÃO: Se o comando xawtv não for avistalable, você precisará instalar o pacote XAWTV.
$ xawtv -hwscan
SAÍDA:
Isso é XAWTV-3.95.dfsg.1, executando no Linux/i686 (2.6.26-2-686)
Procurando por dispositivos disponíveis
Porta 65-96
Tipo: xvideo, scaler de imagem
Nome: NV Blitter de vídeo
/dev/video0: ok [-Device/dev/video0]
Tipo: v4l2
Nome: Câmera UVC (046d: 0990)
Bandeiras: Capture
O arquivo de dispositivo Associado com minha câmera é /dev /video0 . Você também pode ver um erro no seu terminal dizendo: aberto /dev /video0: permissão negada. Para corrigir esse problema, você precisa fazer de si mesmo parte de um grupo "vídeo". Agora teste sua câmera com um comando Linux a seguir:
$ xawtv -c /dev /video0
Se você teve alguns problemas em algumas das etapas anteriores, aqui estão alguns links, que podem ajudá -lo a solucionar seu problema:
- Compatibilidade da câmera Linux OpenCV
- Linux webcam Howto
- Câmeras suportadas usando drivers SPCA5XX
- Câmeras suportadas usando drivers uvcvideo
Usar uma câmera com a biblioteca OpenCV é simples como escrever um programa para reproduzir vídeo. Copie um código fonte criado anteriormente do seu programa de player de vídeo e altere a linha:
Cvcapture* captura = cvCreateFilecApture (argv [1]);
para:
Cvcapture* capture = cvCreateCameRAcApture (0);
Portanto, todo o código será semelhante ao abaixo:
#include "Highgui.h "
int main (int argc, char ** argv)
cvNamedWindow ("Exemplo2", cv_window_autosize);
Cvcapture* capture = cvCreateCameRAcApture (0);
Iplimage* quadro;
enquanto (1)
quadro = cvQueryFrame (captura);
se( !quadro) quebrar;
cvshowImage ("Exemplo2", quadro);
char c = cvwaitKey (33);
if (c == 27) quebra;
cvReleaseCapture (& Capture);
cvDestroyWindow ("Exemplo2");
Observe que uma função cvcreatecameracapture () não tomou nenhum arquivo de dispositivo ou argumento específico. Nesse caso, o OpenCV começará a usar a primeira câmera disponível em seu sistema. Compilar e executar este programa e se tudo até este ponto correu bem, você deve se ver na tela.
OBSERVAÇÃO: Retorne a uma seção de conversão de imagem acima, se você precisar de ajuda sobre como compilar este programa OpenCV.
Escreva o arquivo AVI de uma câmera
O último exemplo tentará ler uma entrada de uma câmera e escrevê -la em um arquivo. Enquanto isso, o programa também exibirá uma janela com um fluxo de vídeo de entrada de câmera. A entrada de vídeo é salva em um arquivo fornecido como um argumento na linha de comando. O codec usado é especificado por quatrocc (código de quatro caracteres) MJPG, que neste caso é o movimento JPEG. Este programa de amostra é muito básico e há muito espaço para melhorias:
#incluir
#incluir
main (int argc, char* argv [])
CvCapture* capture = null;
capture = cvcreatecameracapture (0);
Iplimage *quadros = cvQueryFrame (captura);
// Obtenha um tamanho de quadro a ser usado pela estrutura do escritor
Size cvsize = cvsize (
(int) cvgetCaptureProperty (Capture, CV_CAP_PROP_FRAME_WIDTH),
(int) cvgetcaptureProperty (captura, cv_cap_prop_frame_height)
);
// Declare a estrutura do escritor
// Use quatrocc (código de quatro caracteres) mjpg, o codec JPEG de movimento
// O arquivo de saída é especificado pelo primeiro argumento
Cvvideowriter *writer = cvcreatevideowriter (
argv [1],
Cv_fourcc ('m', 'j', 'p', 'g'),
30, // Defina FPS
tamanho
);
// Crie uma nova janela
cvnamedwindow ("gravação ... pressione esc para parar !", Cv_window_autosize);
// mostra captura na janela e grave em um arquivo
// grava até o usuário atingir a tecla ESC
enquanto (1)
quadros = cvQueryFrame (captura);
se( !quadros) quebrar;
cvshowImage ("Gravação ... pressione ESC para parar !", quadros);
cvWriteFrame (escritor, quadros);
char c = cvwaitKey (33);
if (c == 27) quebra;
cvReleaseVideowriter (& Writer);
cvReleaseCapture (& Capture);
cvDestroywindow ("gravação ... pressione ESC para parar !");
return0;
Supondo que você salvou e compilou este programação como "Salve-Camera-Input", você pode gravar um vídeo em um arquivo de vídeo.Avi com este comando:
OBSERVAÇÃO: Retorne a uma seção de conversão de imagem acima, se você precisar de ajuda sobre como compilar este programa OpenCV.
$ ./salve-camera-input Video-File.Avi
Conclusão
Este artigo deve dar a você um bom começo para a biblioteca OpenCV de uma perspectiva de instalação. Exemplos apresentados não têm muito a ver com a própria visão computacional, mas eles fornecem um bom campo de testes para sua instalação OpenCV. Mesmo a partir desses exemplos simples de OpenCV, também fica claro que o OpenCV é uma biblioteca altamente civilizada, pois, com apenas algumas linhas de código OpenCV, você pode obter ótimos resultados. Seu comentário sobre este artigo é muito apreciado, pois pode ter um grande impacto na qualidade do artigo. Há mais variação sobre o OpenCV, então fique atento ao assinar o LinuxConfig.feed org rss (canto superior esquerdo).
Tutoriais do Linux relacionados:
- Coisas para instalar no Ubuntu 20.04
- Como fazer bota dupla kali linux e windows 10
- Melhor software de edição de vídeo no Linux
- Coisas para fazer depois de instalar o Ubuntu 20.04 fossa focal linux
- Uma introdução à automação, ferramentas e técnicas do Linux
- Melhor leitor de PDF para Linux
- Como obter o endereço MAC no Linux
- Mint 20: Melhor que o Ubuntu e o Microsoft Windows?
- Manjaro Linux Windows 10 Boot dual
- Arquivos de configuração do Linux: os 30 primeiros mais importantes