#ifndef _JV_H_
#define _JV_H_

#if defined(__cplusplus)
extern "C" {
#endif

typedef struct {
 float x, y;
 int valid;
} jvPoint2D;

typedef struct {
 float v1x, v1y, v2x, v2y;
 int valid;
} jvLine;

/*
 API da callback passada para jvInterpret chamada sempre que encontrar uma interpretação válida.
 A callback deverá retornar 1 se a interpretação seja satisfatória e que não se deseja procurar por nenhuma outra. Caso contrário, retorne 0 
 para procurar outra.
 A callback deverá guardar a melhor solução para o propósito desejado. Para isto, definiu-se userdata.
 Parâmetros:
 userdata - ponteiro para estrutura definida pelo usuário, passado na função jvInterpret;
 n_lines_img - número de linhas a serem interpretadas;
 lines_img - conjunto de linhas a serem interpretadas;
 n_lines_mdl - número de linhas do modelo;
 lines_mdl - conjunto de linhas do modelo;
 current_interpretation - resultado de uma interpretação, current_interpretation[i]=j, significa que a linha i da imagem corresponde a
            linha j do modelo.  255 significa que a linha da imagem não tem correspondencia no modelo.
*/
typedef int (* PFNINTERPPROC) (void *userdata, int nlines_img, jvLine* lines_img, int nlines_mdl, jvLine* lines_mdl, unsigned char* current_interpretation);

#define MAXPTS 200 /* Número máximo de pontos utilizados para encontrar a homografia. */

/*
Abre a biblioteca de visão 2D que reconhece 
linhas de um modelo presentes em imagens.
Parametros:
 w - largura da imagens em pixels.
 h - altura das imagens em pixels.
 dw - largura das celulas das imagens (usualmente 10).
 dh - altura das celunas das imagens (usualmente 10).
 model_file_name - nome do arquivo que contem o modelo de linhas.
Retorna 0 caso houve algum problema, senão 1.
Obs. dw e dh devem ser divisores de w e h, respectivamente.
*/
int  jvInit(int w, int h, int dw, int dh, char* model_file_name);

/* 
Filtragem LoG em uma imagem monocromática (img_in), com threshold determinado.
É esperado que as linhas a serem realçadas tenham intensidade monocromática maior que do fundo.
O resultado está colocado no buffer de imagem monocromática img_out.
O vetor de unsigned char img_out deve ser pré-alocado com a dimensão de w*h.
Na ausencia de um conhecimento melhor sobre a imagem, sugere-se o valor de 20 para o parâmetro threshold. 
*/
void jvLoGFilter(unsigned char *img_in, int threshold, unsigned char *img_out);

/* 
Detecção de linhas de uma imagem monocromática (img), definindo o fator limit_ratio que determina a 
razão mínima entre o maior e menor autovalor que caracterizam as direções principais de cada célula.
Os parâmetros dw e dh definem a largura das células das imagens (usualmente 10) e a altura das células 
das imagens (usualmente 10), respectivamente.
O número de linhas detectadas na imagem é fornecido no valor de retorno da função.
Na ausencia de conhecimento especifico, sugere-se o valor de 20 para o parâmetro limit_ratio.
O parâmetro colinear_factor é utilizado como fator para teste de colinearidade (sugere-se igual à 1.0f). Esse
fator é multiplicado por um definido por FATORCOLINEAR;
*/
int jvEdgeDetect(unsigned char *img, float limit_ratio, jvLine *img_lines, float colinear_factor);

/*
Função de reconhecimento de correspondecias de linhas baseada numa árvore de interpretação.
Parâmetros:
 userdata - ponteiro para dados do usuário - repassado para interp_function como primeiro parâmetro;
 n_lines_img - número de linhas a serem interpretadas;
 lines_img - conjunto de linhas a serem interpretadas;
 eta - fator de distorção perspectiva dada na direção vertical da imagem (sugere-se igual à 1.0f). 
Esse fator é multiplicado por um definido por ETA; Vide tese "Acompanhamento de Cenas com Calibração 
Automática de Câmeras" equação 4.2.
 ro - tolerância de paralelismo (sugere-se igual à 1.0f). Esse fator é multiplicado por um definido 
por RO; Vide tese "Acompanhamento de Cenas com Calibração Automática de Câmeras" equação 4.2.
 interp_function - callback chamada toda vez que a função encontrar uma interpretação válida para o reconhecimento.
*/
void jvInterpret(void *userdata, int n_lines_img, jvLine *lines_img, float eta, float ro, PFNINTERPPROC interp_function);

/*
Função para ajusta linhas segundo a imagem img.
Parâmetros:
 img - imagem;
 n_lines_img - número de linhas a serem ajustadas;
 lines_img - conjunto de linhas a serem ajustadas. As linhas são reposicionadas conforme o ajuste.
 tol - Meia distância, em pixel, dos pontos a serem levados em consideração para o ajuste.
 As linhas que o algoritmo não for capaz de ajustar retornam com o campo valid igual à zero.
*/
void jvAdjust(unsigned char *img, int n_lines_img, jvLine *lines_img, int tol);

/*
Função para encontrar a tranformaçào de homografia H[9] (3x3, descrita por linhas) pré-alocada.
a partir de pares de pontos (p1[i], p2[i]), onde n0 é o número de pares de pontos (limite MAXPTS).
p1 são os pontos do modelo e p2 pontos da imagem capturada e H {p2[i]} = [H]*{p1[i]}
*/
int jvFindTransf(float *H, int n0, jvPoint2D *p1, jvPoint2D *p2);

/*
Reamostra os pares de pontos segundo pares de pontos originais.
Parâmetros:
 Entrada
  minx, miny, maxx, maxy - caixa-envoltória dos pontos do modelo;
  H - homografia;
  npnx - número de pares de pontos novos na direção x do modelo. (Max. 10);
  npny - número de pares de pontos novos na direção y do modelo. (Max. 10).
 Saída:
  p1n - ponto novo do mundo;
  p2n - ponto novo em coodernadas da tela em pixel.
*/
void jvBuildNewData(float minx, float miny, float maxx, float maxy, float *H,
                    int npnx, int npny, jvPoint2D *p1n, jvPoint2D *p2n);

/*
Função para desalocar memórias usadas nos métodos.
*/
void jvClose(void);

#if defined(__cplusplus)
}
#endif

#endif
