Sem categorizado

Introdução à visão computacional com a biblioteca OpenCV no Linux

Introdução à visão computacional com a biblioteca OpenCV no Linux

Abstrato

O objetivo deste documento é ajudar um leitor a começar com a biblioteca de visão computacional OpenCV no sistema Linux. O OpenCCV é uma biblioteca de várias plataformas, mas este artigo será focado apenas no OpenCV usando o sistema operacional Linux (embora apenas a instalação da biblioteca e a câmera de vídeo OpenCV seja específica da plataforma, todos os exemplos deste artigo devem compilar em qualquer plataforma onde OpenCV está instalado corretamente, como Mac OS, MS Windows e etc.). O leitor será guiado por um guia passo a passo sobre como instalar e usar algumas das funções básicas da biblioteca OpenCV, como exibir imagens, reproduzir um vídeo ou usar uma câmera de vídeo para processar um fluxo de entrada de vídeo.

Convenções usadas neste artigo:

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:

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:

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:

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:

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:

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).

Conexão de Internet de banda larga móvel e Sakis3g
Este artigo é apenas uma continuação do meu primeiro artigo sobre minha experiência com a Internet de banda larga móvel em um sistema Linux. Para encu...
Cisco CCNA - Faixa de Classe B de Endereço IP
Bits de rede 16 bits de rede disponíveis (x) 10xxxxxx xxxxxxxxx hosts Isso nos deixa com 14 bits designados para o número de redes. Desde então......
Encontre por IP - Perl IP para o exemplo de localização
Nas próximas linhas, descreveremos um processo de como recuperar informações geográficas de um endereço IP . Para isso, usaremos um......