I think the code is self explanatory:
// Set the bbox min and max of the lower node
current_min_bound = lower_get_bbox_min(buf, lower_handle);
current_max_bound = lower_get_bbox_max(buf, lower_handle);
// Set lower node bbox
if(current_min_bound.x > leaf_node->bbox_min.x) {
current_min_bound.x = leaf_node->bbox_min.x;
}
if(current_min_bound.y > leaf_node->bbox_min.y) {
current_min_bound.y = leaf_node->bbox_min.y;
}
if(current_min_bound.z > leaf_node->bbox_min.z) {
current_min_bound.z = leaf_node->bbox_min.z;
}
if(current_max_bound.x < leaf_node->origin.x + highest_voxel_coord.x) {
current_max_bound.x = leaf_node->origin.x + highest_voxel_coord.x;
}
if(current_max_bound.y < leaf_node->origin.y + highest_voxel_coord.y) {
current_max_bound.y = leaf_node->origin.y + highest_voxel_coord.y;
}
if(current_max_bound.z < leaf_node->origin.z + highest_voxel_coord.z) {
current_max_bound.z = leaf_node->origin.z + highest_voxel_coord.z;
}
lower_set_bbox_min(buf, lower_handle, current_min_bound);
lower_set_bbox_max(buf, lower_handle, current_max_bound);
So I would like to know if there is a faster way to compare and get the tighest bounding box in a given 3D coord system? I think so many comparations are killing my CPU performance here. The data structure is a tree but I think it doesn't matter for this problem.
Cheers.
Whether it is possible to code a faster way to calculate the math problem.
EDIT:
It looks like using the ternary conditional operator allows compiler to optimize the code:
// Set lower node bbox min
current_min_bound.x = (current_min_bound.x > leaf_node->origin.x + lowest_voxel_coord.x) ? leaf_node->origin.x + lowest_voxel_coord.x : current_min_bound.x;
current_min_bound.y = (current_min_bound.y > leaf_node->origin.y + lowest_voxel_coord.y) ? leaf_node->origin.y + lowest_voxel_coord.y : current_min_bound.y;
current_min_bound.z = (current_min_bound.z > leaf_node->origin.z + lowest_voxel_coord.z) ? leaf_node->origin.z + lowest_voxel_coord.z : current_min_bound.z;
// Set lower node bbox max
current_max_bound.x = (current_max_bound.x < leaf_node->origin.x + highest_voxel_coord.x) ? leaf_node->origin.x + highest_voxel_coord.x : current_max_bound.x;
current_max_bound.y = (current_max_bound.y < leaf_node->origin.y + highest_voxel_coord.y) ? leaf_node->origin.y + highest_voxel_coord.y : current_max_bound.y;
current_max_bound.z = (current_max_bound.z < leaf_node->origin.z + highest_voxel_coord.z) ? leaf_node->origin.z + highest_voxel_coord.z : current_max_bound.z;
Iterations: 27 546
Same iterations previous code: 0.860708 in seconds Same iterations current code: 0.717957 in seconds
Branch prediction failure can slow things down.
You could try "branchless" comparisons:
static int min( int x, int y ) { return y ^ ((x^y) & -(x<y)); }
static int max( int x, int y ) { return y ^ ((x^y) & -(x>y)); }
Leaving it to you to convert these to macros, perhaps.