int main(int argc, char **argv)
{
int size, i;
nodePtr* POIs;
double start, stop;
scanf("%d", &size);
POIs = (nodePtr*) malloc (size*sizeof(nodePtr));
aux = (nodePtr*) malloc(size * sizeof(nodePtr));
for (i=0 ; i<size ; i++)
{
POIs[i]= (nodePtr) malloc (sizeof(node));
aux[i]=(nodePtr) malloc (sizeof(node));
scanf("%d", &POIs[i]->lat.d);
scanf("%d", &POIs[i]->lat.m);
scanf("%d", &POIs[i]->lat.s);
scanf("%d", &POIs[i]->lon.d);
scanf("%d", &POIs[i]->lon.m);
scanf("%d", &POIs[i]->lon.s);
POIs[i]->la = toDouble(POIs[i]->lat);
POIs[i]->lo = toDouble(POIs[i]->lon);
POIs[i]->ind = i;
scanf("%[^\n]",POIs[i]->text);
}
start = getCurrentTimeNano();
mergesort(POIs, size);
stop = getCurrentTimeNano();
/*
for (i = 0; i < size - 1; i++)
{
if ( compare(POIs[i],POIs[i+1]) == 0 )
{
if (POIs[i]->ind > POIs[i+1]->ind)
POIs = rem(POIs, i, &size);
else
POIs = rem(POIs, i+1, &size);
i--;
}
}
*/
for (i=0 ; i<size ; i++)
/*print(POIs[i]), */free(POIs[i]);
free(POIs);
printTimeElapsed(start, stop, "Nanosegundos");
return 0;
}
void timeDirectImplementation( int count, float* in_a, float* in_b, float *out)
{
float sum;
clock_gettime( CLOCK_PROCESS_CPUTIME_ID, &start);
for (int i = 0; i < count; i++) {
for (int j = 0; j < count; j++) {
sum = 0.0;
for (int k = 0; k < count; k++) {
sum += in_a[i*count+k] * in_b[k*count+j];
}
out[i*count+j] =sum;
}
}
clock_gettime( CLOCK_PROCESS_CPUTIME_ID, &stop);
printTimeElapsed( "kernel equivalent on host");
}
// Required entry point
//------------------------------------------------------------------------------
int sample_main( int argc, const char** argv )
{
// show console and redirect printing
NVPWindow::sysVisibleConsole();
const Config config( argc, argv );
Timer timer;
//
// Load scene
//
std::cerr << "Load scene ... "; std::cerr.flush();
timer.start();
bake::Scene scene;
SceneMemory* scene_memory;
float scene_bbox_min[] = {FLT_MAX, FLT_MAX, FLT_MAX};
float scene_bbox_max[] = {-FLT_MAX, -FLT_MAX, -FLT_MAX};
if (!load_scene( config.scene_filename.c_str(), scene, scene_bbox_min, scene_bbox_max, scene_memory, config.num_instances_per_mesh )) {
std::cerr << "Failed to load scene, exiting" << std::endl;
exit(-1);
}
printTimeElapsed( timer );
// Print scene stats
{
std::cerr << "Loaded scene: " << config.scene_filename << std::endl;
std::cerr << "\t" << scene.num_meshes << " meshes, " << scene.num_instances << " instances" << std::endl;
size_t num_vertices = 0;
size_t num_triangles = 0;
for (size_t i = 0; i < scene.num_meshes; ++i) {
num_vertices += scene.meshes[i].num_vertices;
num_triangles += scene.meshes[i].num_triangles;
}
std::cerr << "\tuninstanced vertices: " << num_vertices << std::endl;
std::cerr << "\tuninstanced triangles: " << num_triangles << std::endl;
}
// OptiX Prime requires all instances to have the same vertex stride
for (size_t i = 1; i < scene.num_meshes; ++i) {
if (scene.meshes[i].vertex_stride_bytes != scene.meshes[0].vertex_stride_bytes) {
std::cerr << "Error: all meshes must have the same vertex stride. Bailing.\n";
exit(-1);
}
}
//
// Generate AO samples
//
std::cerr << "Minimum samples per face: " << config.min_samples_per_face << std::endl;
std::cerr << "Generate sample points ... \n"; std::cerr.flush();
timer.reset();
timer.start();
std::vector<size_t> num_samples_per_instance(scene.num_instances);
const size_t total_samples = bake::distributeSamples( scene, config.min_samples_per_face, config.num_samples, &num_samples_per_instance[0] );
bake::AOSamples ao_samples;
allocate_ao_samples( ao_samples, total_samples );
bake::sampleInstances( scene, &num_samples_per_instance[0], config.min_samples_per_face, ao_samples );
printTimeElapsed( timer );
std::cerr << "Total samples: " << total_samples << std::endl;
{
const int sqrt_num_rays = static_cast<int>( sqrtf( static_cast<float>( config.num_rays ) ) + .5f );
std::cerr << "Rays per sample: " << sqrt_num_rays * sqrt_num_rays << std::endl;
std::cerr << "Total rays: " << total_samples * sqrt_num_rays * sqrt_num_rays << std::endl;
}
//
// Evaluate AO samples
//
std::cerr << "Compute AO ... "; std::cerr.flush();
timer.reset();
timer.start();
std::vector<float> ao_values( total_samples );
std::fill(ao_values.begin(), ao_values.end(), 0.0f);
float scene_maxdistance;
float scene_offset;
{
const float scene_scale = std::max(std::max(scene_bbox_max[0] - scene_bbox_min[0],
scene_bbox_max[1] - scene_bbox_min[1]),
scene_bbox_max[2] - scene_bbox_min[2]);
scene_maxdistance = scene_scale * config.scene_maxdistance_scale;
scene_offset = scene_scale * config.scene_offset_scale;
if (config.scene_offset){
scene_offset = config.scene_offset;
}
if (config.scene_maxdistance){
scene_maxdistance = config.scene_maxdistance;
}
}
if (config.use_ground_plane_blocker) {
// Add blocker for ground plane (no surface samples)
std::vector<bake::Mesh> blocker_meshes;
std::vector<bake::Instance> blocker_instances;
std::vector<float> plane_vertices;
std::vector<unsigned int> plane_indices;
make_ground_plane(scene_bbox_min, scene_bbox_max, config.ground_upaxis, config.ground_scale_factor, config.ground_offset_factor,
scene.meshes[0].vertex_stride_bytes,
plane_vertices, plane_indices, blocker_meshes, blocker_instances);
bake::Scene blockers = { &blocker_meshes[0], blocker_meshes.size(), &blocker_instances[0], blocker_instances.size() };
bake::computeAOWithBlockers(scene, blockers,
ao_samples, config.num_rays, scene_offset, scene_maxdistance, config.use_cpu, config.conserve_memory, &ao_values[0]);
} else {
bake::computeAO(scene, ao_samples, config.num_rays, scene_offset, scene_maxdistance, config.use_cpu, config.conserve_memory, &ao_values[0]);
}
printTimeElapsed( timer );
std::cerr << "Map AO to vertices ... "; std::cerr.flush();
timer.reset();
timer.start();
float** vertex_ao = new float*[ scene.num_instances ];
for (size_t i = 0; i < scene.num_instances; ++i ) {
vertex_ao[i] = new float[ scene.meshes[scene.instances[i].mesh_index].num_vertices ];
}
bake::mapAOToVertices( scene, &num_samples_per_instance[0], ao_samples, &ao_values[0], config.filter_mode, config.regularization_weight, vertex_ao );
printTimeElapsed( timer );
if (!config.output_filename.empty())
{
std::cerr << "Save vertex ao ... "; std::cerr.flush();
timer.reset();
timer.start();
bool saved = save_results(config.output_filename.c_str(), scene, vertex_ao);
printTimeElapsed(timer);
if (saved){
std::cerr << "Saved vertex ao to: " << config.output_filename << std::endl;
}
else{
std::cerr << "Failed to save vertex ao to: " << config.output_filename << std::endl;
}
}
if (config.use_viewer){
//
// Visualize results
//
std::cerr << "Launch viewer ... \n" << std::endl;
bake::view(scene.meshes, scene.num_meshes, scene.instances, scene.num_instances, vertex_ao, scene_bbox_min, scene_bbox_max);
}
for (size_t i = 0; i < scene.num_instances; ++i) {
delete [] vertex_ao[i];
}
delete [] vertex_ao;
destroy_ao_samples( ao_samples );
delete scene_memory;
return 1;
}
