void compute_kernel(Simulator *sim)
{
// printf("compute_kernel...\n");
sim->kernel_width = cvRound(6 * sim->sigma) + 1;
if (sim->kernel_width > MAX_KERNEL_WIDTH)
sim->kernel_width = MAX_KERNEL_WIDTH;
if (sim->kernel_width % 2 == 0)
sim->kernel_width--;
compute_gaussian_kernel(sim->kernel_width, sim->kernel, sim->sigma);
}
void vegaGaussianBlur(VGImage dst, VGImage src,
VGfloat stdDeviationX,
VGfloat stdDeviationY,
VGTilingMode tilingMode)
{
struct vg_context *ctx = vg_current_context();
struct vg_image *d, *s;
VGfloat *buffer, *kernel;
VGint kernel_width, kernel_height, kernel_size;
VGint buffer_len;
VGint idx, i, j;
struct filter_info info;
if (dst == VG_INVALID_HANDLE || src == VG_INVALID_HANDLE) {
vg_set_error(ctx, VG_BAD_HANDLE_ERROR);
return;
}
if (stdDeviationX <= 0 || stdDeviationY <= 0) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
if (tilingMode < VG_TILE_FILL ||
tilingMode > VG_TILE_REFLECT) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
d = handle_to_image(dst);
s = handle_to_image(src);
if (vg_image_overlaps(d, s)) {
vg_set_error(ctx, VG_ILLEGAL_ARGUMENT_ERROR);
return;
}
kernel_width = compute_kernel_size(stdDeviationX);
kernel_height = compute_kernel_size(stdDeviationY);
kernel_size = kernel_width * kernel_height;
kernel = malloc(sizeof(VGfloat)*kernel_size);
compute_gaussian_kernel(kernel, kernel_width, kernel_height,
stdDeviationX, stdDeviationY);
buffer_len = 8 + 2 * 4 * kernel_size;
buffer = malloc(buffer_len * sizeof(VGfloat));
buffer[0] = 0.f;
buffer[1] = 1.f;
buffer[2] = 2.f; /*unused*/
buffer[3] = 4.f; /*unused*/
buffer[4] = kernel_width * kernel_height;
buffer[5] = 1.f;/*scale*/
buffer[6] = 0.f;/*bias*/
buffer[7] = 0.f;
idx = 8;
for (j = 0; j < kernel_height; ++j) {
for (i = 0; i < kernel_width; ++i) {
VGint index = j * kernel_width + i;
VGfloat x, y;
x = texture_offset(s->width, kernel_width, i, kernel_width/2);
y = texture_offset(s->height, kernel_height, j, kernel_height/2);
buffer[idx + index*4 + 0] = x;
buffer[idx + index*4 + 1] = y;
buffer[idx + index*4 + 2] = 0.f;
buffer[idx + index*4 + 3] = 0.f;
}
}
idx += kernel_size * 4;
for (j = 0; j < kernel_height; ++j) {
for (i = 0; i < kernel_width; ++i) {
/* transpose the kernel */
VGint index = j * kernel_width + i;
VGint kindex = (kernel_width - i - 1) * kernel_height + (kernel_height - j - 1);
buffer[idx + index*4 + 0] = kernel[kindex];
buffer[idx + index*4 + 1] = kernel[kindex];
buffer[idx + index*4 + 2] = kernel[kindex];
buffer[idx + index*4 + 3] = kernel[kindex];
}
}
info.dst = d;
info.src = s;
info.setup_shader = &setup_convolution;
info.user_data = (void*)(long)(buffer_len/4);
info.const_buffer = buffer;
info.const_buffer_len = buffer_len * sizeof(VGfloat);
info.tiling_mode = tilingMode;
info.extra_texture_view = NULL;
execute_filter(ctx, &info);
free(buffer);
free(kernel);
}
// ----------------------------------------------------------------------------
// min_avarage_association2_filter -
//
// Entrada: filter_desc - Descritor do filtro
//
// Saida: Nenhuma
// ----------------------------------------------------------------------------
void min_avarage_association2_filter (FILTER_DESC *filter_desc)
{
NEURON_LAYER_LIST *n_list = NULL;
NEURON_LAYER *nl = NULL;
PARAM_LIST *p_list = NULL;
static RECEPTIVE_FIELD_DESCRIPTION receptive_field_descriptor;
static NEURON_LAYER *filter_output = NULL;
static int nNumNL, nNumParam;
static int flagInit = 0;
static float *fltMinAvarageValue;
static int wo, ho;
float fltDisparity;
int i, x, y;
float fltAvgDisparity, fltAux;
float fltSigma;
int nKernelSize;
if (!flagInit)
{
// Achar o numero de neuron layers
for (nNumNL = 0, n_list = filter_desc->neuron_layer_list; n_list != NULL; n_list = n_list->next, nNumNL++);
// nNumNL--;
// printf("nNumNL: %d\n", nNumNL);
// Achar o numero de parametros
for (nNumParam = 0, p_list = filter_desc->filter_params; p_list != NULL; p_list = p_list->next, nNumParam++);
nNumParam--;
// printf("nNumParam: %d\n", nNumParam);
// Numero de neuron layers deve ser igual ao numero de parametros
if (nNumNL != (nNumParam-2))
{
Erro ("Wrong number of parameters for min_avarage_association2_filter.", "", "");
return;
}
// Buscar o KernelSize e o Sigma
for (i = 0, p_list = filter_desc->filter_params; i <= nNumNL; p_list = p_list->next, i++);
nKernelSize = p_list->param.ival;
fltSigma = p_list->next->param.fval;
// Ponteiro para a 'output' associada ao filtro
filter_output = filter_desc->output;
// Dimensao da 'output' associada ao filtro
wo = filter_output->dimentions.x;
ho = filter_output->dimentions.y;
// Alocar espaco auxiliar
fltMinAvarageValue = (float*)malloc(sizeof(float)*wo*ho);
// Inicializa o kernel com a gausiana
compute_gaussian_kernel(&receptive_field_descriptor, nKernelSize, fltSigma);
flagInit = 1;
}
for (x = 0; x < wo * ho; x++)
{
fltMinAvarageValue[x] = 0.0;
switch (filter_output->output_type)
{
case GREYSCALE:
{
filter_output->neuron_vector[x].output.ival = 0;
}
break;
case GREYSCALE_FLOAT:
{
filter_output->neuron_vector[x].output.fval = 0.0;
}
break;
}
}
// Copia a primeira camada neural
n_list = filter_desc->neuron_layer_list;
p_list = filter_desc->filter_params->next;
nl = n_list->neuron_layer;
// Percorre as proximas neuron layers (se houver)
for (i = 0; i < nNumNL; n_list = n_list->next, p_list = p_list->next, i++)
{
nl = n_list->neuron_layer;
fltDisparity = (float) p_list->param.ival;
for (x = 0; x < wo; x++)
{
for (y = 0; y < ho; y++)
{
fltAux = apply_gaussian_kernel(&receptive_field_descriptor, nl, x, y);
// RTBC
if (fltAux == 0.0)
fltAux = 0.000001;
fltMinAvarageValue[y * wo + x] += 1.0 / (fltAux * fltAux);
filter_output->neuron_vector[y * wo + x].output.fval += fltDisparity / (fltAux * fltAux);
}
}
}
for (x = 0; x < wo * ho; x++)
{
switch (filter_output->output_type)
{
case GREYSCALE:
{
filter_output->neuron_vector[x].output.ival = filter_output->neuron_vector[x].output.fval / fltMinAvarageValue[x];
}
break;
case GREYSCALE_FLOAT:
{
filter_output->neuron_vector[x].output.fval = filter_output->neuron_vector[x].output.fval / fltMinAvarageValue[x];
}
break;
}
}
// Imprime a media
switch (filter_output->output_type)
{
case GREYSCALE:
{
for (i = 0, fltAvgDisparity = 0.0; i < wo*ho; fltAvgDisparity += (float) filter_output->neuron_vector[i].output.ival, i++);
}
break;
case GREYSCALE_FLOAT:
{
for (i = 0, fltAvgDisparity = 0.0; i < wo*ho; fltAvgDisparity += filter_output->neuron_vector[i].output.fval, i++);
}
break;
}
fltAvgDisparity /= wo*ho;
printf("Avarage disparity = %.2f\n", fltAvgDisparity);
}
void robot_gaussian_filter (FILTER_DESC *filter_desc)
{
NEURON_LAYER_LIST *n_list;
NEURON_LAYER *nl;
RECEPTIVE_FIELD_DESCRIPTION *receptive_field;
PARAM_LIST *p_list;
int i, j;
int wo, ho, nKernelSize;
float fltSigma;
for (i = 0, n_list = filter_desc->neuron_layer_list; n_list != NULL; n_list = n_list->next, i++);
if (filter_desc->private_state == NULL)
{
if (i != 1)
{
Erro ("Wrong number of neuron layers. The robot_gaussian_filter must be applied on only one neuron layer.", "", "");
return;
}
if (filter_desc->neuron_layer_list->neuron_layer->output_type != filter_desc->output->output_type)
{
Erro ("The output type of input neuron layer is different of the robot_gaussian_filter output.", "", "");
return;
}
// Buscar o KernelSize e o Sigma
for (i = 0, p_list = filter_desc->filter_params; p_list != NULL; p_list = p_list->next, i++);
i--;
if (i != 2)
{
Erro ("Wrong number of parameters. The robot_gaussian_filter have 2 parameters: kernel_size and sigma respectivally.", "", "");
return;
}
nKernelSize = filter_desc->filter_params->next->param.ival;
fltSigma = filter_desc->filter_params->next->next->param.fval;
receptive_field = (RECEPTIVE_FIELD_DESCRIPTION*)malloc(sizeof(RECEPTIVE_FIELD_DESCRIPTION));
compute_gaussian_kernel(receptive_field, nKernelSize, fltSigma);
filter_desc->private_state = (void*)receptive_field;
}
receptive_field = (RECEPTIVE_FIELD_DESCRIPTION*)filter_desc->private_state;
nl = filter_desc->neuron_layer_list->neuron_layer;
wo = filter_desc->output->dimentions.x;
ho = filter_desc->output->dimentions.y;
switch (filter_desc->output->output_type)
{
case GREYSCALE:
{
for (i = 0; i < wo; i++)
{
for (j = 0; j < ho; j++)
{
filter_desc->output->neuron_vector[j * wo + i].output.ival = (int)apply_gaussian_kernel(receptive_field, nl, i, j);
}
}
}
break;
case GREYSCALE_FLOAT:
{
for (i = 0; i < wo; i++)
{
for (j = 0; j < ho; j++)
{
filter_desc->output->neuron_vector[j * wo + i].output.fval = apply_gaussian_kernel(receptive_field, nl, i, j);
}
}
}
break;
}
}
// ----------------------------------------------------------------------------
// min_avarage_association_interpolation_filter -
//
// Entrada: filter_desc - Descritor do filtro
//
// Saida: Nenhuma
// ----------------------------------------------------------------------------
void min_avarage_association_interpolation_filter (FILTER_DESC *filter_desc)
{
NEURON_LAYER_LIST *n_list, *n_list_previous, *n_list_next;
NEURON_LAYER *nl;
PARAM_LIST *p_list, *p_list_previous, *p_list_next;
static RECEPTIVE_FIELD_DESCRIPTION receptive_field_descriptor;
static NEURON_LAYER *filter_output = NULL;
static int nNumNL, nNumParam;
static int flagInit = 0;
static float *fltMinAvarageValue;
static int wo, ho;
float fltDisparity;
static float fltMinDisparity, fltMaxDisparity;
int i, x, y;
float fltAvgDisparity, fltAux;
float fltSigma;
int nKernelSize;
float x0, y0, x1, y1, x2, y2;
if (!flagInit)
{
// Achar o numero de neuron layers
for (nNumNL = 0, n_list = filter_desc->neuron_layer_list; n_list != NULL; n_list = n_list->next, nNumNL++);
// nNumNL--;
// printf("nNumNL: %d\n", nNumNL);
// Achar o numero de parametros
for (nNumParam = 0, p_list = filter_desc->filter_params; p_list != NULL; p_list = p_list->next, nNumParam++);
nNumParam--;
// printf("nNumParam: %d\n", nNumParam);
// Numero de neuron layers deve ser igual ao numero de parametros
if (nNumNL != (nNumParam-2))
{
Erro ("Wrong number of parameters for min_avarage_association_interpolation_filter.", "", "");
return;
}
// Buscar o KernelSize e o Sigma
for (i = 0, p_list = filter_desc->filter_params; i <= nNumNL; p_list = p_list->next, i++);
nKernelSize = p_list->param.ival;
fltSigma = p_list->next->param.fval;
// Busca a menor e a maior disparidade
fltMinDisparity = (float) filter_desc->filter_params->next->param.ival;
for (i = 0, p_list = filter_desc->filter_params->next; i <= (nNumNL - 2); p_list = p_list->next, i++);
fltMaxDisparity = (float) p_list->param.ival;
printf("fltMinDisparity: %f - fltMaxDisparity: %f\n", fltMinDisparity, fltMaxDisparity);
// Ponteiro para a 'output' associada ao filtro
filter_output = filter_desc->output;
// Dimensao da 'output' associada ao filtro
wo = filter_output->dimentions.x;
ho = filter_output->dimentions.y;
// Alocar espaco auxiliar
fltMinAvarageValue = (float*)malloc(sizeof(float)*wo*ho);
// Inicializa o kernel com a gausiana
compute_gaussian_kernel(&receptive_field_descriptor, nKernelSize, fltSigma);
flagInit = 1;
}
// Copia a primeira camada neural
n_list = filter_desc->neuron_layer_list;
p_list = filter_desc->filter_params->next;
nl = n_list->neuron_layer;
fltDisparity = (float) p_list->param.ival;
for (x = 0; x < wo; x++)
{
for (y = 0; y < ho; y++)
{
fltMinAvarageValue[y * wo + x] = apply_gaussian_kernel(&receptive_field_descriptor, nl, x, y);
switch (filter_output->output_type)
{
case GREYSCALE:
{
filter_output->neuron_vector[y * wo + x].output.ival = (int) fltDisparity;
}
break;
case GREYSCALE_FLOAT:
{
filter_output->neuron_vector[y * wo + x].output.fval = fltDisparity;
}
break;
}
}
}
n_list = n_list->next;
p_list = p_list->next;
// Percorre as proximas neuron layers (se houver)
for (i = 1; i < nNumNL; n_list = n_list->next, p_list = p_list->next, i++)
{
nl = n_list->neuron_layer;
fltDisparity = (float) p_list->param.ival;
for (x = 0; x < wo; x++)
{
for (y = 0; y < ho; y++)
{
fltAux = apply_gaussian_kernel(&receptive_field_descriptor, nl, x, y);
if (fltAux < fltMinAvarageValue[y * wo + x])
{
fltMinAvarageValue[y * wo + x] = fltAux;
switch (filter_output->output_type)
{
case GREYSCALE:
{
filter_output->neuron_vector[y * wo + x].output.ival = (int) fltDisparity;
}
break;
case GREYSCALE_FLOAT:
{
filter_output->neuron_vector[y * wo + x].output.fval = fltDisparity;
}
break;
}
}
}
}
}
// Vai saber -- Ai fudeu com forca ainda...
for (i = 0; i < wo * ho; i++)
{
fltDisparity = filter_output->neuron_vector[i].output.fval;
if ((fltDisparity != fltMaxDisparity) && (fltDisparity != fltMinDisparity))
{
// Encontrar as neuron_layers com disparidade imediatamente anterior e posterior
n_list = filter_desc->neuron_layer_list;
p_list = filter_desc->filter_params->next;
do
{
n_list_previous = n_list;
n_list = n_list->next;
n_list_next = n_list->next;
p_list_previous = p_list;
p_list = p_list->next;
p_list_next = p_list->next;
} while (p_list->param.ival < (int)fltDisparity);
x0 = (float) p_list_previous->param.ival;
y0 = (float) n_list_previous->neuron_layer->neuron_vector[i].output.fval;
x1 = (float) p_list->param.ival;
y1 = (float) n_list->neuron_layer->neuron_vector[i].output.fval;
x2 = (float) p_list_next->param.ival;
y2 = (float) n_list_next->neuron_layer->neuron_vector[i].output.fval;
if ((y1 < y2) && (y1 < y0))
filter_output->neuron_vector[i].output.fval = x_min_lagrange(x0, y0, x1, y1, x2, y2);
}
}
// Imprime a media
switch (filter_output->output_type)
{
case GREYSCALE:
{
for (i = 0, fltAvgDisparity = 0.0; i < wo*ho; fltAvgDisparity += (float) filter_output->neuron_vector[i].output.ival, i++);
}
break;
case GREYSCALE_FLOAT:
{
for (i = 0, fltAvgDisparity = 0.0; i < wo*ho; fltAvgDisparity += filter_output->neuron_vector[i].output.fval, i++);
}
break;
}
fltAvgDisparity /= wo*ho;
printf("Avarage disparity = %.2f\n", fltAvgDisparity);
}
