You are currently browsing the category archive for the ‘opencv’ category.

Neste vídeo disponibilizo os testes de Face Trackin com GPU ATI após instalação do driver da ATI (post anterior) junto ao AMD SDK.

Neste documento, disponibilizo um texto conceitual (com código fonte CLARO!), com fundamentos sobre processamento de imagem, cujo objetivo principal é idealizar como utilizar recursos de visão computacional para detectar pedestres, ciclistas e animais, como também partes do objeto reconhecido/identificado. Câmeras com tal recurso adaptado em veículos poderiam evitar muitos acidentes. Sendo assim, deixo neste artigo todo o conceito computacional. Clique AQUI E leia o artigo na íntegra.

acidente

Após o lançamento do CUDA 4.2 junto a biblioteca OpenCV 2.4.1 confome o post anterior, resolvi fazer alguns testes no final de feriado (pois trabalhei quase que o dia todo em Sorocaba). Além da tecnologia cuda e OpenCV utilizei a biblioteca TBB para programação multi-nuclear.

Foi publicada na edição 89 da revista LinuxMagazine, o artigo sobre visão computacional utilizando GPU, programação multi-nuclear, QT e mobile (Android CLARO!). Vale a pena conferir, pois neste documento agrupei todos os estudos realizado com projeto de código aberto de domínio público. Além disto contamos com outros excelentes artigos sobre segurança de servidores, GnuPG, Android,DLNA e outros tópicos… Clique AQUI para obter a revista completa, ou AQUI para efetuar o download gratuitamente apenas a publicação sobre visão computacional.

Valeu Stage por emprestar o kinect até o natal… Pois comprei um para o meu bebê de 4 anos e temos que esperar o Papai-Noel chegar… Em breve novidades com este brinquedo super legal!!!

Após os testes com o a biblioteca CUDA 4.1 RC 2 GPU conforme o post anterior, agora compilei a openCV também com a lib TBB e CUDA. Resultado: Performance computacional além da imaginação. Tudo isto em função da programação paralela. Escrito em C++.O TBB se encarrega na adaptação do software, ou seja determinando o número ideal de threads e tornando uma realidade a programação multinúcleo.

Deixo neste post, as alterações necessárias no código fonte da bibliotec openCV 2.3.1 para compilara com o gcc 4.6.2 no openSUSE 12.1 e com a biblioteca CUDA 4.1.

No arquivo  modules/gpu/src/imgproc.cpp:

Linha 762:
Trocar:
    ppSafeCall( nppiRectStdDev_32s32f_C1R(src.ptr<Npp32s>(), static_cast<int>(src.step),
   sqr.ptr<Npp32f>(), static_cast<int>(sqr.step), dst.ptr<Npp32f>(), 
    static_cast<int>(dst.step), sz, nppRect) );
Por:
    nppSafeCall( nppiRectStdDev_32s32f_C1R(src.ptr<Npp32s>(), static_cast<int>(src.step),
   sqr.ptr<Npp64f>(),   static_cast<int>(sqr.step), dst.ptr<Npp32f>(), 
    static_cast<int>(dst.step), sz, nppRect) );

No arquivo modules/gpu/src/graphcuts.cpp

linha 80

Trocar:

    nppSafeCall( nppiGraphcut_32s8u(terminals.ptr<Npp32s>(), leftTransp.ptr<Npp32s>(), 
 rightTransp.ptr<Npp32s>(), top.ptr<Npp32s>(), bottom.ptr<Npp32s>(), 
 static_cast<int>(terminals.step), static_cast<int>(leftTransp.step),
   sznpp, labels.ptr<Npp8u>(), static_cast<int>(labels.step), buf.ptr<Npp8u>()) );

Por:

    nppSafeCall( nppiGraphcut_32s8u(terminals.ptr<Npp32s>(), leftTransp.ptr<Npp32s>(),
   rightTransp.ptr<Npp32s>(), top.ptr<Npp32s>(), bottom.ptr<Npp32s>(), 
 static_cast<int>(terminals.step), static_cast<int>(leftTransp.step), 
 sznpp, labels.ptr<Npp8u>(), static_cast<int>(labels.step), pState) );

Inserir na linha 67
    NppiGraphcutState *pState;
    Npp8u *pDeviceMem;

Adicionar o linha 75 abaixo da funcao nppSafeCall
    cudaSafeCall( cudaMalloc((void **)& pDeviceMem, bufsz) );

Comentar a linha 78
    //if ((size_t)bufsz > buf.cols * buf.rows * buf.elemSize())
    //    buf.create(1, bufsz, CV_8U); Inserir na linha 80 após o comentário.

    nppSafeCall( nppiGraphcutInitAlloc(sznpp, &pState, pDeviceMem) );

No final do metodo cv::gpu::graphcut, linha 91 inserir

    nppSafeCall ( nppiGraphcutFree(pState));
    cudaSafeCall( cudaFree(pDeviceMem) );

No arquivo modules/gpu/src/element_operations.cpp 

Comente as linhas 297 ate a 304
    //    case CV_8UC4:
    //        nppSafeCall( nppiAbsDiff_8u_C4R(src1.ptr<Npp8u>(), static_cast<int>(src1.step), src2.ptr<Npp8u>(), static_cast<int>(src2.step), 
    //            dst.ptr<Npp8u>(), static_cast<int>(dst.step), sz) );
    //        break;
    //    case CV_16UC1:
    //        nppSafeCall( nppiAbsDiff_16u_C1R(src1.ptr<Npp32s>(), static_cast<int>(src1.step), src2.ptr<Npp32s>(), static_cast<int>(src2.step), 
    //            dst.ptr<Npp32s>(), static_cast<int>(dst.step), sz) );
    //        break;

No arquivo modules/gpu/src/matrix_reductions.cpp 

Inserir na linha 117
     int nBufferSize;
    nppiMeanStdDev8uC1RGetBufferHostSize (sz, &nBufferSize);
    Npp8u * pDeviceBuffer;
    cudaSafeCall( cudaMalloc((void **)& pDeviceBuffer, nBufferSize) );

Modificar a linha 124 

Trocar:
    nppSafeCall( nppiMean_StdDev_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step), sz, dbuf, (double*)dbuf + 1) );
Por:
    nppSafeCall( nppiMean_StdDev_8u_C1R(src.ptr<Npp8u>(), static_cast<int>(src.step),  sz, pDeviceBuffer, dbuf, (double*)dbuf + 1) );

Modificar a linha 126 

Trocar:
    cudaSafeCall( cudaDeviceSynchronize() );
Por:
    cudaSafeCall( cudaFree(pDeviceBuffer) ); 

A NVidia acaba de disponibilizar o seu pacote para desenvolvedores CUDA 4.1 RC2. Ou seja uma arquitetura de computação paralela da NVIDIA que possibilita aumentos significativos na performance de computação pelo aproveitamento da potência da GPU (unidade de processamento gráfico).

A computação está evoluindo de um “processamento central” na CPU para um “coprocessamento” na CPU e na GPU. Para permitir esse novo paradigma em computação, a NVIDIA inventou a arquitetura de computação paralela CUDA, que agora vem inclusa em GPUs GeForce, ION, Quadro e Tesla, representando uma base instalada significativa para os desenvolvedores de aplicativos. O download pode ser efetuado AQUI, já estou baixando e em breve novidades…

A seguir, disponibilizo passo-a-passodeixo de como utilizar a GPU aplicada aos recursos de visão computacional utilizando a tecnologia NVIDIA CUDA, uma arquitetura de computação paralela de propósito geral que tira proveito do mecanismo de computação paralela das unidades de processamento gráfico (GPUs) NVIDIA para resolver muitos problemas computacionais complexos em uma fração do tempo necessário em uma CPU.

Download:

O primeiro passo foi baixar o arsenal de pacotes do SDK da NVIDIA, ou seja o Developer Drivers for Linux (285.05.23), o CUDA ToolKit e para finalizar o GPU Computing SDK. Tudo isto esta disponível AQUI.

Sequência de instalação:

Após a instalação do drive com CUDA, execute o CUDA ToolKit , CUDA Tools SDK e para finalizar o GPU Computing SDK:

# ./cudatoolkit_4.1.21_linux_64_suse11.2.run

Crie as variáveis ambientais:

#! /bin/sh
LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda/lib64
PATH=$PATH:/usr/local/cuda/bin
export PATH LD_LIBRARY_PATH

Execute o pacote GPU Computing SDK:

# ./gpucomputingsdk_4.1.21_linux.run

OBS1: Insira a linha a seguir no arquivo ~/NVIDIA_GPU_Computing_SDK/C/common/common.mk na linha 173

NVCCFLAGS   += --compiler-options -fno-strict-aliasing --compiler-options -fno-inline

OBS2: Durante a compilação no openSUSE 12.1, obtive o seguinte erro: “unsupported GNU version! gcc 4.6 and up are not supported!”

A solução foi ignorar o erro comentando as sequintes linha a seguir no arquivo /usr/local/cuda/include/host_config.h

//#if __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5)
//#error -- unsupported GNU version! gcc 4.6 and up are not supported!
//#endif /* __GNUC__> 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 5) */

Pronto neste etapa o NVIDIA CUDA foi instalado com sucesso!

Em breve estarei com um ATRIX (se nada der errado), porém queria terminar os testes com a biblioteca OpenCV em celulares modestos como o Motorola DEXT que possue um processador de 528 Mhz. Queria uma aplicação perfomática sem AINDA o uso na GPU (Tegra 2) no Android. O resultado atendeu as minhas expectativas, pois fazer visão computacional em Android com processadores de 800 Mhz ou superior é mais tranquilo. Agora com um DEXT com Android 2.3 a conversa é outra… Abaixo um vídeo demonstrativo.

Dia 8 de Setembro foi disponibilizada a versão 4.0 da biblioteca TBB Threading Building Blocks cuja função é permitir implementar a programação multi-nuclear sem magia negra. E também no final de agosto foi disponibilizado a versão da biblioteca OpenCV 2.3.1. Entre muitas vantagens destaco a compatibilidade com a câmera Ximea e a compatibilidade com a biblioteca ffmpeg 0.8 (não vou sofrer mais durante a compilação). Brinquei bastante este fim de semana…

Arquivo

Statísticas

  • 572,969 Acessos

ATENÇÃO!

 °v° USE A FORÇA,
/(_)\ LEIA OS FONTES !
 ^ ^

openSUSE 11.4