Classes

5.3.2.1 HogDescriptor

Uma das classes principais do sistema, fornece as funcionalidades usadas para o c´alculo do descritor, permite configurar o algoritmo, e fornece algumas fun¸c˜oes para facilitar as tarefas de classifica¸c˜ao e descri¸c˜ao, caso seja fornecido um classificador. A classe HogGPU ´e subclasse desta, sobrescrevendo apenas os m´etodos que usam a GPU, de maneira a evitar duplica¸c˜ao de c´odigo.

A seguir uma breve descri¸c˜ao de cada um dos m´etodos p´ublicos da classe.

vo id a l l o c _ b u f f e r(cv::Si ze b u f f e r _ s i z e, int type,

cv::Mat& b u f f e r) ;

Reserva uma regi˜ao de mem´oria para ser usada pela biblioteca. N˜ao possui muita utilidade para a implementa¸c˜ao em CPU.

G H O G _ L I B _ S T A T U S i m a g e _ n o r m a l i z a t i o n(cv::Mat& image,

I m a g e C a l l b a c k* c a l l b a c k) ;

G H O G _ L I B _ S T A T U S c a l c _ g r a d i e n t(cv::Mat i n p u t _ i m g,

cv::Mat& m a g n i t u d e,

cv::Mat& phase,

G r a d i e n t C a l l b a c k* c a l l b a c k) ;

vo id c a l c _ g r a d i e n t _ s y n c(cv::Mat i n p u t _ i m g,

cv::Mat& m a g n i t u d e,

cv::Mat& p h a s e) ;

Vers˜oes ass´ıncrona e s´ıncrona para calcular a magnitude e a orienta¸c˜ao de gradi- ente da imagem. G H O G _ L I B _ S T A T U S c r e a t e _ d e s c r i p t o r(cv::Mat m a g n i t u d e, cv::Mat phase, cv::Mat& d e s c r i p t o r, D e s c r i p t o r C a l l b a c k* c a l l b a c k) ; vo id c r e a t e _ d e s c r i p t o r _ s y n c(cv::Mat m a g n i t u d e, cv::Mat phase, cv::Mat& d e s c r i p t o r) ;

Vers˜oes ass´ıncrona e s´ıncrona para obter o descritor a partir dos gradientes.

G H O G _ L I B _ S T A T U S c l a s s i f y(cv::Mat img,

C l a s s i f y C a l l b a c k* c a l l b a c k) ;

bo ol c l a s s i f y _ s y n c(cv::Mat img) ;

Vers˜oes ass´ıncrona e s´ıncrona para realizar a classifica¸c˜ao de uma imagem. Chama os trˆes m´etodos acima (normaliza¸c˜ao, c´alculo de gradientes e c´alculo do descritor), pas- sando o resultado para o classificador. Requer que um classificador tenha sido passado para a classe e treinado.

G H O G _ L I B _ S T A T U S l o c a t e(cv::Mat img,

cv::Rec t roi,

cv::Siz e w i n d o w _ s i z e,

cv::Siz e w i n d o w _ s t r i d e,

std::vector< cv::Re ct > l o c a t e _ s y n c(cv::Mat img,

cv::Rec t roi,

cv::Siz e w i n d o w _ s i z e,

cv::Siz e w i n d o w _ s t r i d e) ;

Vers˜oes ass´ıncrona e s´ıncrona para localizar objetos de interesse em uma imagem.

N˜ao implementado no momento.

vo id l o a d _ s e t t i n g s(std::s t r i n g f i l e n a m e) ;

Carrega configura¸c˜oes a partir de um arquivo XML(Extensible Markup Language - Linguagem de marca¸c˜ao extend´ıvel).

vo id s e t _ c l a s s i f i e r(I C l a s s i f i e r* c l a s s i f i e r) ;

Muda o classificador utilizado.

G H O G _ L I B _ S T A T U S s e t _ p a r a m(std::s t r i n g param,

std::s t r i n g v a l u e) ;

std::s t r i n g g e t _ p a r a m(std::s t r i n g p a r a m) ;

Respectivamente modifica e lˆe configura¸c˜oes da biblioteca.

5.3.2.2 HogGPU

A classe reimplementa alguns m´etodos da HogDescriptor. Detalhes sobre a im- plementa¸c˜ao s˜ao discutidas no pr´oximo cap´ıtulo.

vo id a l l o c _ b u f f e r(cv::Si ze b u f f e r _ s i z e, int type,

cv::Mat& b u f f e r) ;

Reserva uma regi˜ao de mem´oria compartilhada entre a GPU e a CPU.

G H O G _ L I B _ S T A T U S i m a g e _ n o r m a l i z a t i o n(cv::Mat& image,

I m a g e C a l l b a c k* c a l l b a c k) ;

vo id i m a g e _ n o r m a l i z a t i o n _ s y n c(cv::Mat& i m a g e) ;

vo id c a l c _ g r a d i e n t _ s y n c(cv::Mat i n p u t _ i m g, cv::Mat& m a g n i t u d e, cv::Mat& p h a s e) ; v i r t u a l G H O G _ L I B _ S T A T U S c r e a t e _ d e s c r i p t o r(cv::Mat m a g n i t u d e, cv::Mat phase, cv::Mat& d e s c r i p t o r, D e s c r i p t o r C a l l b a c k* c a l l b a c k) ; v i r t u a l v oid c r e a t e _ d e s c r i p t o r _ s y n c(cv::Mat m a g n i t u d e, cv::Mat phase, cv::Mat& d e s c r i p t o r) ;

Reimplementa¸c˜ao das fun¸c˜oes de normaliza¸c˜ao, c´alculo de gradientes e gera¸c˜ao dos descritores. Chamam fun¸c˜oes kernel implementadas no arquivo HogHPU impl.cu.

5.3.2.3 HogGPU impl.cu

Nesse arquivo est˜ao implementados os m´etodos kernel chamados pela classe HogGPU.

_ _ g l o b a l _ _ vo id g a m m a _ n o r m _ k e r n e l(f l o a t* img, int i m a g e _ h e i g h t,

int i m a g e _ w i d t h, int i m a g e _ s t e p) ;

Cada bloco de threads calcula a normaliza¸c˜ao de at´e 64 pixels de uma linha da imagem de entrada. _ _ g l o b a l _ _ vo id g r a d i e n t _ k e r n e l(f l o a t* i n p u t _ i m g, f l o a t* m a g n i t u d e, f l o a t* phase, int i m a g e _ h e i g h t, int i m a g e _ w i d t h, int i n p u t _ i m a g e _ s t e p, int m a g n i t u d e _ s t e p, int p h a s e _ s t e p) ;

Cada bloco de threads calcula o gradiente de maior magnitude de at´e 64 pixels de uma linha da imagem de entrada.

_ _ g l o b a l _ _ vo id h i s t o g r a m _ k e r n e l(f l o a t* m a g n i t u d e, f l o a t* phase, f l o a t* h i s t o g r a m s, int i n p u t _ w i d t h, int i n p u t _ h e i g h t, int m a g n i t u d e _ s t e p, int p h a s e _ s t e p, int c e l l _ r o w _ s t e p, int c e l l _ w i d t h, int c e l l _ h e i g h t, int n u m _ b i n s) ;

Cada bloco de threads calcula, para 64 pixels de uma linha da imagem de entrada, a soma parcial dos histogramas correspondentes a esses pixels. Essa divis˜ao foi feita dessa maneira para otimizar o acesso `a mem´oria global.

_ _ g l o b a l _ _ vo id g a m m a _ n o r m _ k e r n e l(f l o a t* img, int i m a g e _ h e i g h t,

int i m a g e _ w i d t h, int i m a g e _ s t e p) ;

Cada bloco de threads realiza o agrupamento e normaliza¸c˜ao de at´e 8 blocos do descritor, em uma linha de blocos (ou seja, ele n˜ao pega mais do que uma linha de blocos da malha).

5.3.2.4 Settings

Possui m´etodos para ler e escrever parˆametros de ocnfigura¸c˜ao do sistema em um arquivo XML, usando a biblioteca TinyXML para isso.

5.3.2.5 Utils

Criada para conter fun¸c˜oes est´aticas de utilidade para o sistema. No momento s´o possui um m´etodo, para fazer divis˜oes entre n´umeros com duas dimens˜oes:

s t a t i c cv::S ize p a r t i t i o n(cv::S ize n u m e r a t o r,

cv::Siz e d e n o m i n a t o r) ;

O resultado dessa opera¸c˜ao ´e  a1 a2, b1 b2  , sendo (a1, b1) o numerador e (a2, b2) o denominador.

descritor de caracter´ısticas. Define duas classes de callback, para serem usadas em m´etodos ass´ıncronos: c l a s s C l a s s i f i c a t i o n C a l l b a c k { p u b l i c: v i r t u a l ~C l a s s i f i c a t i o n C a l l b a c k() = 0;

v i r t u a l v oid r e s u l t(cv::Mat inputs,

cv::Mat o u t p u t) = 0; }; c l a s s T r a i n i n g C a l l b a c k { p u b l i c: v i r t u a l ~T r a i n i n g C a l l b a c k() = 0; v i r t u a l v oid f i n i s h e d(cv::Mat t r a i n _ d a t a) = 0; };

Al´em disso, define os seguintes m´etodos:

v i r t u a l G H O G _ L I B _ S T A T U S t r a i n _ a s y n c(cv::Mat t r a i n _ d a t a,

cv::Mat e x p e c t e d _ o u t p u t s,

T r a i n i n g C a l l b a c k* c a l l b a c k) = 0;

v i r t u a l G H O G _ L I B _ S T A T U S t r a i n _ s y n c(cv::Mat t r a i n _ d a t a,

cv::Mat e x p e c t e d _ o u t p u t s) = 0;

Vers˜ao ass´ıncrona e s´ıncrona para realizar o treinamento. O parˆametro train data ´e uma matriz onde cada linha representa a entrada de uma instˆancia de treinamento e o parˆametro expected outputs ´e um vetor com cada elemento sendo a sa´ıda esperada correspondente a uma das entradas.

v i r t u a l G H O G _ L I B _ S T A T U S c l a s s i f y _ a s y n c(cv::Mat input,

C l a s s i f i c a t i o n C a l l b a c k* c a l l b a c k) = 0;

v i r t u a l cv::Mat c l a s s i f y _ s y n c(cv::Mat i n p u t) = 0;

Vers˜ao ass´ıncrona e s´ıncrona para realizar a classifica¸c˜ao. O parˆametro input ´e um vetor contendo o descritor a ser classificado e a fun¸c˜ao retorna um vetor resultante,

para o caso de classificadores que retornam um resultado multidimensional (como, por exemplo, redes neurais).

v i r t u a l G H O G _ L I B _ S T A T U S lo ad(std::s t r i n g f i l e n a m e) = 0; v i r t u a l G H O G _ L I B _ S T A T U S sa ve(std::s t r i n g f i l e n a m e) = 0; v i r t u a l G H O G _ L I B _ S T A T U S s e t _ p a r a m e t e r(std::s t r i n g p a r a m e t e r, std::s t r i n g v a l u e) = 0; v i r t u a l std::s t r i n g g e t _ p a r a m e t e r(std::s t r i n g p a r a m e t e r) = 0;

M´etodos para fazer a permanˆencia de configura¸c˜ao e do treinamento do classifi- cador.

6 IMPLEMENTA ¸C ˜AO DO HOG EM GPU

Neste cap´ıtulo ser´a detalhada a implementa¸c˜ao e invoca¸c˜ao de cada um dos quatro kernels utilizados para o c´alculo do descritor HOG.

Cada kernel foi projetado considerando blocos de threads de tamanho fixo, procu- rando realizar acesso coalescido da mem´oria e uso de mem´oria compartilhada para acesso a dados gerados por outras threads. Para a divis˜ao do problema em blocos foi aplicada uma t´ecnica comumente utilizada em programa¸c˜ao CUDA, onde se fixa o tamanho do bloco de threads e se calcula o tamanho do grid a partir do tamanho do bloco e do tamanho da entrada. Foram usados blocos com uma, duas ou trˆes dimens˜oes conforme apropriado para a abstra¸c˜ao da organiza¸c˜ao do problema e exclusivamente grids de duas dimens˜oes. Para exemplificar o c´alculo do tamanho do grid, ser´a usado um tamanho de entrada de 1280 × 720 pixels