void
output_handler_max_value_position (OUTPUT_DESC *output,
int type_call __attribute__ ((unused)) ,
int mouse_button __attribute__ ((unused)) ,
int mouse_state __attribute__ ((unused)) )
{
char *nl_target_coordinates_name = NULL;
int u, v, u_max, v_max, w, h, xi, yi; //, step;
float current_value, max_value = FLT_MIN, log_factor;
NEURON_LAYER *nl_target_coordinates = NULL;
// Gets the output handler parameters
nl_target_coordinates_name = output->output_handler_params->next->param.sval;
log_factor = output->output_handler_params->next->next->param.fval;
// Gets the target coordinates neuron layer
nl_target_coordinates = get_neuron_layer_by_name (nl_target_coordinates_name);
// Gets the Neuron Layer Dimentions
w = output->neuron_layer->dimentions.x;
h = output->neuron_layer->dimentions.y;
// Finds the max value position
for (v = 0, u_max = v_max = 0; v < h; v++)
{
for (u = 0; u < w; u++)
{
current_value = output->neuron_layer->neuron_vector[v * w + u].output.fval;
if (max_value < current_value)
{
max_value = current_value;
u_max = u;
v_max = v;
}
}
}
// Map the max value coordinates to image
map_v1_to_image (&xi, &yi, IMAGE_WIDTH, IMAGE_HEIGHT, u_max, v_max, w, h, 0, 0, (double) h / (double) (h - 1), log_factor);
// Saves the max value position
nl_target_coordinates->neuron_vector[0].output.fval = (1.0/dynamic_scale_factor) * ( (float) 2*xi);
nl_target_coordinates->neuron_vector[1].output.fval = (1.0/dynamic_scale_factor) * ( (float) 2*yi);
}
// ----------------------------------------------------------------------------
// log_polar_filter -
//
// Entrada: filter_desc - Descritor do filtro
//
// Saida: Nenhuma
// ----------------------------------------------------------------------------
void log_polar_filter (FILTER_DESC *filter_desc)
{
NEURON_LAYER_LIST *n_list;
NEURON_LAYER *n_l;
PARAM_LIST *p_list;
int i, u, v, h, w, hi, wi, xi, yi, previous_xi, previous_yi, index;
int x_center, y_center;
INPUT_DESC *input;
NEURON_OUTPUT previous_output;
float fltLogFactor;
float hAux;
int nNumParam;
previous_output.ival = 0;
// Check Neuron Layers
for (i = 0, n_list = filter_desc->neuron_layer_list; n_list != NULL; n_list = n_list->next, i++);
if (i != 1)
{
Erro ("Wrong number of neuron layers. The log_polar_filter filter must be applied on only one neuron layer.", "", "");
return;
}
n_l = filter_desc->neuron_layer_list->neuron_layer;
// Achar o numero de parametros
for (nNumParam = 0, p_list = filter_desc->filter_params; p_list != NULL; p_list = p_list->next, nNumParam++);
nNumParam--;
// Numero de neuron layers deve ser igual a tres
if (nNumParam != 1)
{
Erro ("The log_polar_filter filter must have one parameter: log_factor.", "", "");
return;
}
fltLogFactor = filter_desc->filter_params->next->param.fval;
// printf("fltLogFactor: %f\n", fltLogFactor);
wi = n_l->dimentions.x;
hi = n_l->dimentions.y;
w = filter_desc->output->dimentions.x;
h = filter_desc->output->dimentions.y;
input = get_input_by_neural_layer (n_l);
previous_xi = -1;
previous_yi = -1;
if (input == NULL)
{
x_center = 0;
y_center = 0;
}
else
{
if (TYPE_MOVING_FRAME == STOP)
{
x_center = input->wxd - input->wx;
y_center = input->wyd - input->wy;
}
else
{
x_center = wi/2;
y_center = hi/2;
}
}
hAux = (float) h / (float) (h - 1.0);
for (u = 0; u < w; u++)
{
for (v = 0; v < h; v++)
{
map_v1_to_image (&xi, &yi, wi, hi, u, v, w, h, x_center, y_center, hAux, fltLogFactor);
index = (u < (w / 2)) ? ((w / 2) - 1 - u) : (u - (w / 2));
if ((xi == previous_xi) && (yi == previous_yi))
filter_desc->output->neuron_vector[(v * w) + u].output = previous_output;
else
if (xi >= wi || xi < 0 || yi >= hi || yi < 0)
previous_output.ival = filter_desc->output->neuron_vector[(v * w) + u].output.ival = 0;
else
previous_output = filter_desc->output->neuron_vector[(v * w) + u].output = input->neuron_layer->neuron_vector[yi * wi + xi].output;
previous_xi = xi;
previous_yi = yi;
}
}
}
void activation_pattern_overlay_filter(FILTER_DESC *filter_desc) {
PARAM_LIST *p_list = NULL;
NEURON_LAYER_LIST *n_list = NULL;
NEURON_LAYER *nl_output = NULL, *nl_input = NULL, *nl_act_pattern = NULL;
int nl_number, p_number;
float log_factor;
int xi, yi, wi, hi, xo, yo, wo, ho, wa, ha;
int x_center, y_center;
float max_value = FLT_MIN;
// Checks the Neuron Layers Number
for (nl_number = 0, n_list = filter_desc->neuron_layer_list; n_list != NULL; n_list = n_list->next, nl_number++)
;
// Checks the Parameters Number
for (p_number = 0, p_list = filter_desc->filter_params; p_list != NULL; p_list = p_list->next, p_number++)
;
if (p_number != 2) {
Erro("Error: Wrong number of parameters. The activation_pattern_overlay_filter needs one parameter: <log_factor>.", "", "");
return;
}
// Gets the filter parameters
log_factor = filter_desc->filter_params->next->param.fval;
// Gets the Input Neuron Layer
nl_input = filter_desc->neuron_layer_list->neuron_layer;
// Gets the Activation Pattern Layer
nl_act_pattern = filter_desc->neuron_layer_list->next->neuron_layer;
// Gets the Filter Output
nl_output = filter_desc->output;
// Input layer
wi = nl_input->dimentions.x;
hi = nl_input->dimentions.y;
x_center = wi / 2;
y_center = hi / 2;
// Activation layer
wa = nl_act_pattern->dimentions.x;
ha = nl_act_pattern->dimentions.y;
// Output layer
wo = nl_output->dimentions.x;
ho = nl_output->dimentions.y;
// Copies the neuron layer data
for (yo = 0; yo < ho; yo++)
for (xo = 0; xo < wo; xo++)
nl_output->neuron_vector[xo + yo * wo].output = nl_input->neuron_vector[xo + yo * wo].output;
//Search for the activation layer max value
//TODO: If not initialized, the "nl_act_pattern->neuron_vector" could cause context errors
for (yo = 0; yo < ha; yo++)
for (xo = 0; xo < wa; xo++)
if (max_value < nl_act_pattern->neuron_vector[yo * wa + xo].output.fval)
max_value = nl_act_pattern->neuron_vector[yo * wa + xo].output.fval;
// Now maps the activated pattern into the image
for (yo = 0; yo < ha; yo++)
{
for (xo = 0; xo < wa; xo++)
{
map_v1_to_image(&xi, &yi, wi, hi, xo, yo, wa, ha, x_center, y_center, (double) ha / (double) (ha - 1), log_factor);
if (!(xi >= wi || xi < 0 || yi >= hi || yi < 0))
{
nl_output->neuron_vector[yi * wi + xi].output.ival = float_to_int_grayscale(nl_act_pattern->neuron_vector[yo * wa + xo].output.fval, max_value);
//if inside neuron layer boundaries
if(xo > 0 && xo < wa)
{
if(gaussian_filtered_training_pattern)
{
if( (gaussian_filtered_training_pattern[yo * wa + xo] != 0.0f && gaussian_filtered_training_pattern[yo * wa + xo - 1] == 0.0)
|| (gaussian_filtered_training_pattern[yo * wa + xo] != 0.0f && gaussian_filtered_training_pattern[yo * wa + xo + 1] == 0.0) )
{
nl_output->neuron_vector[yi * wi + xi].output.ival = 0x000000ff;
}
}
}
//previous_output = nl_output->neuron_vector[yi * wi + xi].output;
}
}
}
}
// ----------------------------------------------------------------------------
// image_fusion_filter -
//
// Entrada: filter_desc - Descritor do filtro
//
// Saida: Nenhuma
// ----------------------------------------------------------------------------
void image_fusion_filter (FILTER_DESC *filter_desc)
{
NEURON_LAYER_LIST *n_list;
PARAM_LIST *p_list = NULL;
static INPUT_DESC *input_right, *input_left;
static NEURON_LAYER *nl_input_left, *nl_input_right, *nl_disparity_map;
static NEURON_LAYER *filter_output = NULL;
static int flagInit = 0;
static int wo, ho, wi, hi, w, h;
static float fltLogFactor;
static float hAux;
int nNumNL, nNumParam;
int u, v, xi, yi, xi_left, yi_left, x_center, y_center, x_center_left, y_center_left;
int nRed, nGreen, nBlue;
int nPixelLeft, nPixelRight;
// int nDispXVergOffset;
float fltDisparity;
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++);
// Numero de neuron layers deve ser igual a tres
if (nNumNL != 3)
{
Erro ("The image_fusion_filter must have three neuron layers: image_left, image_right and disparity_map.", "", "");
return;
}
nl_input_left = filter_desc->neuron_layer_list->neuron_layer;
nl_input_right = filter_desc->neuron_layer_list->next->neuron_layer;
nl_disparity_map = filter_desc->neuron_layer_list->next->next->neuron_layer;
// Achar o numero de parametros
for (nNumParam = 0, p_list = filter_desc->filter_params; p_list != NULL; p_list = p_list->next, nNumParam++);
nNumParam--;
// Numero de neuron layers deve ser igual a tres
if (nNumParam != 1)
{
Erro ("The image_fusion_filter must have one parameter: log_factor.", "", "");
return;
}
fltLogFactor = filter_desc->filter_params->next->param.fval;
printf("fltLogFactor: %f\n", fltLogFactor);
// 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;
// Dimensao das neuron layers de entrada
wi = nl_input_right->dimentions.x;
hi = nl_input_right->dimentions.y;
// Dimensao do mapa de disparidade
w = nl_disparity_map->dimentions.x;
h = nl_disparity_map->dimentions.y;
hAux = (float) h / (h - 1);
input_right = get_input_by_neural_layer (nl_input_right);
input_left = get_input_by_neural_layer (nl_input_left);
flagInit = 1;
}
// NAO SEI PORQUE.
// PRECISA DISTO PARA FUNCIONAR DEVIDO A ALTERACAO FEITA POR DIJALMA
if (TYPE_MOVING_FRAME == STOP)
{
x_center = input_right->wxd - input_right->wx;
y_center = input_right->wyd - input_right->wy;
x_center_left = input_left->wxd - input_left->wx;
y_center_left = input_left->wyd - input_left->wy;
}
else
{
x_center = wi/2;
y_center = hi/2;
x_center_left = wi/2;
y_center_left = hi/2;
}
// Zera a saida
for (u = 0; u < (wo * ho); u++)
filter_output->neuron_vector[u].output.ival = 0;
// Percorre a disparity_map
for (u = 0; u < w; u++)
{
for (v = 0; v < h; v++)
{
// Mapeamento logpolar->plano
map_v1_to_image (&xi, &yi, wi, hi, u, v, w, h, x_center, y_center, hAux, fltLogFactor);
if (xi >= wi || xi < 0 || yi >= hi || yi < 0)
continue;
switch (nl_disparity_map->output_type)
{
case GREYSCALE:
{
fltDisparity = (float) nl_disparity_map->neuron_vector[(v * w) + u].output.ival;
}
break;
case GREYSCALE_FLOAT:
{
fltDisparity = nl_disparity_map->neuron_vector[(v * w) + u].output.fval;
}
break;
}
// Achar a coordenada relativa na imagem esquerda
map_v1_to_image (&xi_left, &yi_left, wi, hi, u, v, w, h, x_center_left, y_center_left, hAux, fltLogFactor);
xi_left += (int) fltDisparity;
if (xi_left >= wi || xi_left < 0 || yi_left >= hi || yi_left < 0)
continue;
nPixelRight = nl_input_right->neuron_vector[(yi * wi) + xi].output.ival;
nPixelLeft = nl_input_left->neuron_vector[(yi_left * wi) + xi_left].output.ival;
nRed = (RED(nPixelLeft) + RED(nPixelRight)) / 2;
nGreen = (GREEN(nPixelLeft) + GREEN(nPixelRight)) / 2;
nBlue = (BLUE(nPixelLeft) + BLUE(nPixelRight)) / 2;
filter_output->neuron_vector[(yi * wo) + xi].output.ival = PIXEL(nRed, nGreen, nBlue);
}
}
}
void
scaled_map_image_v1(FILTER_DESC *filter_desc) {
NEURON_LAYER_LIST *n_list = NULL;
PARAM_LIST *p_list = NULL;
NEURON_LAYER *n_l = NULL;
INPUT_DESC *input = NULL;
int i, u, v, h, w, hi, wi, xi, yi, previous_xi, previous_yi;
int x_center, y_center;
float log_factor, scale_factor;
NEURON_OUTPUT previous_output;
previous_output.ival = 0;
// Check Neuron Layers
for (i = 0, n_list = filter_desc->neuron_layer_list; n_list != NULL; n_list = n_list->next, i++)
;
if (i != 1) {
Erro("Wrong number of neuron layers. Map Image V1 filter must be applied on only one neuron layer.", "", "");
return;
}
n_l = filter_desc->neuron_layer_list->neuron_layer;
// Check Param
for (i = 0, p_list = filter_desc->filter_params; p_list != NULL; p_list = p_list->next, i++)
;
// 4 Parameters are passed to this filter
if (i != 4) {
Erro("Wrong number of parameters. Map Image V1 needs three parameters: <input name>, <log_factor>, <scale_factor>.", "", "");
return;
}
input = get_input_by_name(filter_desc->filter_params->next->param.sval);
log_factor = filter_desc->filter_params->next->next->param.fval;
scale_factor = filter_desc->filter_params->next->next->next->param.fval;
wi = n_l->dimentions.x;
hi = n_l->dimentions.y;
w = filter_desc->output->dimentions.x;
h = filter_desc->output->dimentions.y;
previous_xi = -1;
previous_yi = -1;
if (input == NULL) {
x_center = 0;
y_center = 0;
} else {
if (TYPE_MOVING_FRAME == STOP) {
x_center = input->wxd - input->wx;
y_center = input->wyd - input->wy;
} else {
x_center = wi / 2;
y_center = hi / 2;
}
}
for (u = 0; u < w; u++) {
for (v = 0; v < h; v++) {
map_v1_to_image(&xi, &yi, wi, hi, u, v, w, h, x_center, y_center, (double) h / (double) (h - 1), log_factor);
// Adjust "xi" and "yi" according to the scale factor
xi = x_center + (xi - x_center)*(1.0 / scale_factor);
yi = y_center + (yi - y_center)*(1.0 / scale_factor);
if ((xi == previous_xi) && (yi == previous_yi))
filter_desc->output->neuron_vector[(v * w) + u].output = previous_output;
else if (xi >= wi || xi < 0 || yi >= hi || yi < 0)
previous_output.ival = filter_desc->output->neuron_vector[(v * w) + u].output.fval = 0;
else
previous_output = filter_desc->output->neuron_vector[(v * w) + u].output = n_l->neuron_vector[yi * wi + xi].output;
previous_xi = xi;
previous_yi = yi;
}
}
}
