bool t_sorted_clip_list::assign_nodes( t_quadtree_node* parent_node, int & current_index, int current_level)
{
//assign the block of 4 nodes child to node
current_level++;
if (current_level > m_sub_division_level)
return true;
parent_node->node_a = current_index++;
parent_node->node_b = current_index++;
parent_node->node_c = current_index++;
parent_node->node_d = current_index++;
bool val = calcuate_quadtree_child_area(
m_quadtree_array[parent_node->node_a].area,
m_quadtree_array[parent_node->node_b].area,
m_quadtree_array[parent_node->node_c].area,
m_quadtree_array[parent_node->node_d].area,
parent_node->area);
if (val == false)
return false;
if (assign_nodes( &m_quadtree_array[parent_node->node_a], current_index, current_level) == false)
return false;
if (assign_nodes( &m_quadtree_array[parent_node->node_b], current_index, current_level) == false)
return false;
if (assign_nodes( &m_quadtree_array[parent_node->node_c], current_index, current_level) == false)
return false;
if (assign_nodes( &m_quadtree_array[parent_node->node_d], current_index, current_level) == false)
return false;
return true;
}
bool t_sorted_clip_list::preallocate_quadtree_nodes( int sub_division_level, t_screen_rect extent )
{
//sub_division level defines how many levels deep the quadtree goes.
//the total_number_nodes
//4 levels deep , the limit currently.
if (sub_division_level > 4)
sub_division_level = 4;
int total_number_nodes = calcualte_quadtree_size( sub_division_level );
m_sub_division_level = sub_division_level;
m_quadtree_array_size = total_number_nodes;
m_quadtree_array.reserve(m_quadtree_array_size);
m_quadtree_array.resize(m_quadtree_array_size);
int current_level = 0;
int current_index = 0;
m_parent_node.area = extent;
bool val = assign_nodes(&m_parent_node, current_index, current_level);
if (val == false)
{
//error with node filling
assert(0);
return false;
}
clear(extent);
m_intersect_threshold = ((float)extent.width()*extent.height()) * k_intersect_threshold_precent;
m_insert_threshold = ((float)extent.width()*extent.height()) * k_insert_threshold_precent;
m_remove_threshold = ((float)extent.width()*extent.height()) * k_remove_threshold_precent;
return true;
}
chm_compute(struct nbperf *nbperf)
#endif
{
struct state state;
int retval = -1;
uint32_t v, e;
#ifdef BUILD_CHM3
if (nbperf->c == 0)
nbperf-> c = 1.24;
if (nbperf->c < 1.24)
errx(1, "The argument for option -c must be at least 1.24");
if (nbperf->hash_size < 3)
errx(1, "The hash function must generate at least 3 values");
#else
if (nbperf->c == 0)
nbperf-> c = 2;
if (nbperf->c < 2)
errx(1, "The argument for option -c must be at least 2");
if (nbperf->hash_size < 2)
errx(1, "The hash function must generate at least 2 values");
#endif
(*nbperf->seed_hash)(nbperf);
e = nbperf->n;
v = nbperf->c * nbperf->n;
#ifdef BUILD_CHM3
if (v == 1.24 * nbperf->n)
++v;
if (v < 10)
v = 10;
#else
if (v == 2 * nbperf->n)
++v;
#endif
state.g = calloc(sizeof(uint32_t), v);
state.visited = calloc(sizeof(uint8_t), v);
if (state.g == NULL || state.visited == NULL)
err(1, "malloc failed");
#ifdef BUILD_CHM3
graph3_setup(&state.graph, v, e);
if (graph3_hash(nbperf, &state.graph))
goto failed;
if (graph3_output_order(&state.graph))
goto failed;
#else
graph2_setup(&state.graph, v, e);
if (graph2_hash(nbperf, &state.graph))
goto failed;
if (graph2_output_order(&state.graph))
goto failed;
#endif
assign_nodes(&state);
print_hash(nbperf, &state);
retval = 0;
failed:
#ifdef BUILD_CHM3
graph3_free(&state.graph);
#else
graph2_free(&state.graph);
#endif
free(state.g);
free(state.visited);
return retval;
}
