def run(self):
        while not self.kill_received:
             # get a task
            try:
                job = self.work_queue.get_nowait()
            except Queue.Empty:
                break
                
            start_time = time.time();    
            
            print("Creating a Scene");
            bvpl_octree_batch.init_process("boxmCreateSceneProcess");
            bvpl_octree_batch.set_input_string(0, job.input_scene_path);
            bvpl_octree_batch.run_process();
            (scene_id, scene_type) = bvpl_octree_batch.commit_output(0);
            scene= dbvalue(scene_id, scene_type);
            
            #Use the save scene in bvxm because boxm rounds to bytes and doesn't work for negative values
#
#            print("Save Scene");
#            bvpl_octree_batch.init_process("boxmSaveOccupancyRawProcess");
#            bvpl_octree_batch.set_input_from_db(0,scene);
#            bvpl_octree_batch.set_input_string(1, job.output_scene_path);
#            bvpl_octree_batch.set_input_unsigned(2,0);
#            bvpl_octree_batch.set_input_unsigned(3,1);
#            bvpl_octree_batch.run_process();
            
            resolution = 0;
            enforce_level = 1;

            print("Convert to regular grid");
            bvpl_octree_batch.init_process("boxmSceneToBvxmGridProcess");
            bvpl_octree_batch.set_input_from_db(0,scene);
            bvpl_octree_batch.set_input_string(1, job.output_scene_path + ".vox");
            bvpl_octree_batch.set_input_unsigned(2, resolution);
            bvpl_octree_batch.set_input_bool(3, enforce_level);
            bvpl_octree_batch.run_process();
            (grid_id, grid_type) = bvpl_octree_batch.commit_output(0);
            grid = dbvalue(grid_id, grid_type);

            print("Save Grid");
            bvpl_octree_batch.init_process("bvxmSaveGridRawProcess");
            bvpl_octree_batch.set_input_from_db(0,grid);
            bvpl_octree_batch.set_input_string(1,job.output_scene_path);
            bvpl_octree_batch.run_process();
            
            print ("Runing time for worker:", self.name)
            print(time.time() - start_time);
Esempio n. 2
0
    def run(self):
        while not self.kill_received:
             # get a task
            try:
                job = self.work_queue.get_nowait()
            except Queue.Empty:
                break

            start_time = time.time()

            print("Adding Errors")
            bvpl_octree_batch.init_process("bvplAddTaylorErrorsProcess")
            bvpl_octree_batch.set_input_from_db(0, job.error_scene)
            bvpl_octree_batch.set_input_double(1, job.fraction)
            bvpl_octree_batch.set_input_int(2, job.block_i)
            bvpl_octree_batch.set_input_int(3, job.block_j)
            bvpl_octree_batch.set_input_int(4, job.block_k)
            bvpl_octree_batch.run_process()
            (id, type) = bvpl_octree_batch.commit_output(0)
            error_val = dbvalue(id, type)
            error = bvpl_octree_batch.get_output_double(id)

            self.result_queue.put(error)

            print("error")
            print(error)

            print("Runing time for worker:", self.name)
            print(time.time() - start_time)
    def run(self):
        while not self.kill_received:
             # get a task
            try:
                job = self.work_queue.get_nowait()
            except Queue.Empty:
                break
            
            start_time = time.time();
            
            bvpl_octree_batch.init_process("bvpl_taylor_global_add_error_process");
            bvpl_octree_batch.set_input_from_db(0,job.global_taylor);
            bvpl_octree_batch.set_input_int(1, job.scene_id);
            bvpl_octree_batch.set_input_int(2, job.block_i);
            bvpl_octree_batch.set_input_int(3, job.block_j);
            bvpl_octree_batch.set_input_int(4, job.block_k);
            bvpl_octree_batch.run_process();
            (id, type) = bvpl_octree_batch.commit_output(0);
            error_val = dbvalue(id, type);
            error = bvpl_octree_batch.get_output_double(id);
            self.result_queue.put(error);
            
            bvpl_octree_batch.clear();
 
            print ("Runing time for worker:", self.name)
            print(time.time() - start_time);
Esempio n. 4
0
    def run(self):
        while not self.kill_received:
           # get a task
            try:
                job = self.work_queue.get_nowait()
            except Queue.Empty:
                break

            start_time = time.time()

            print("Creating taylor kernel")
            batch.init_process("bvplLoadTaylorKernelProcess")
            batch.set_input_string(0, job.kernel_path)
            batch.run_process()
            (kernel_id, kernel_type) = batch.commit_output(0)
            kernel = dbvalue(kernel_id, kernel_type)

            print("Running Kernel")
            batch.init_process("bvplBlockKernelOperatorProcess")
            batch.set_input_from_db(0, job.scene)
            batch.set_input_from_db(1, kernel)
            batch.set_input_int(2, job.block_i)
            batch.set_input_int(3, job.block_j)
            batch.set_input_int(4, job.block_k)
            batch.set_input_string(5, "algebraic")
            batch.set_input_string(6, job.output_path)
            batch.run_process()

            print ("Runing time for worker:", self.name)
            print(time.time() - start_time)
Esempio n. 5
0
    def run(self):
        while not self.kill_received:
             # get a task
            try:
                job = self.work_queue.get_nowait()
            except Queue.Empty:
                break

            start_time = time.time()

            print("Creating a Scene")
            bvpl_octree_batch.init_process("boxmCreateSceneProcess")
            bvpl_octree_batch.set_input_string(0, job.input_scene_path)
            bvpl_octree_batch.run_process()
            (scene_id, scene_type) = bvpl_octree_batch.commit_output(0)
            scene = dbvalue(scene_id, scene_type)

            print("Save Scene")
            bvpl_octree_batch.init_process("boxmSaveSceneRawProcess")
            bvpl_octree_batch.set_input_from_db(0, scene)
            bvpl_octree_batch.set_input_string(1, job.output_scene_path)
            bvpl_octree_batch.set_input_unsigned(2, 0)
            bvpl_octree_batch.set_input_unsigned(3, 1)
            bvpl_octree_batch.run_process()

            print ("Runing time for worker:", self.name)
            print(time.time() - start_time)
Esempio n. 6
0
    def run(self):
        while not self.kill_received:
             # get a task
            try:
                job = self.work_queue.get_nowait();
            except Queue.Empty:
                break;

            start_time = time.time();

            print("Adding Errors");
            bvpl_octree_batch.init_process("bvplAddPCAErrorsProcess");
            bvpl_octree_batch.set_input_from_db(0,job.pca_scenes);
            bvpl_octree_batch.set_input_unsigned(1, job.dim);
            bvpl_octree_batch.set_input_double(2,job.fraction);
            bvpl_octree_batch.set_input_int(3, job.block_i);
            bvpl_octree_batch.set_input_int(4, job.block_j)
            bvpl_octree_batch.set_input_int(5, job.block_k)
            bvpl_octree_batch.run_process();
            (id, type) = bvpl_octree_batch.commit_output(0);
            error_val = dbvalue(id, type);
            error = bvpl_octree_batch.get_output_double(id);

            self.result_queue.put(error);

            print("Runing time for worker:", self.name);
            print(time.time() - start_time);
Esempio n. 7
0
    def run(self):
        while not self.kill_received:
           # get a task
            try:
                job = self.work_queue.get_nowait()
            except Queue.Empty:
                break

            start_time = time.time()

            print("Creating a Scene")
            batch.init_process("boxmCreateSceneProcess")
            batch.set_input_string(0, job.input_scene_path)
            batch.run_process()
            (scene_id, scene_type) = batch.commit_output(0)
            scene = dbvalue(scene_id, scene_type)

            print("Save Scene")
            batch.init_process("boxmSaveSceneRawProcess")
            batch.set_input_from_db(0, scene)
            batch.set_input_string(
                1, job.output_scene_path + "_float")
            batch.set_input_unsigned(2, 0)
            batch.set_input_unsigned(3, 1)
            batch.run_process()

#            resolution = 0;
#            enforce_level = 1;

#            print("Convert to regular grid");
#            batch.init_process("boxmSceneToBvxmGridProcess");
#            batch.set_input_from_db(0,scene);
#            batch.set_input_string(1, job.output_scene_path + ".vox");
#            batch.set_input_unsigned(2, resolution);
#            batch.set_input_bool(3, enforce_level);
#            batch.run_process();
#            (grid_id, grid_type) = batch.commit_output(0);
#            grid = dbvalue(grid_id, grid_type);
#
#            print("Save Grid");
#            batch.init_process("bvxmSaveGridRawProcess");
#            batch.set_input_from_db(0,grid);
#            batch.set_input_string(1,job.output_scene_path + ".raw");
#            batch.run_process();

            print ("Runing time for worker:", self.name)
            print(time.time() - start_time)
    def run(self):
        while not self.kill_received:
             # get a task
            try:
                job = self.work_queue.get_nowait()
            except Queue.Empty:
                break
            
            start_time = time.time();
            
            bvpl_octree_batch.init_process("bvplThresholdCornersProcess");
            bvpl_octree_batch.set_input_from_db(0,job.global_taylor);
            bvpl_octree_batch.set_input_from_db(1,job.global_corners);
            bvpl_octree_batch.set_input_int(2, job.scene_id);
            bvpl_octree_batch.set_input_float(3, job.harris_threshold);
            bvpl_octree_batch.set_input_string(4, job.output_path);
            bvpl_octree_batch.run_process();
            
            #Save dristhi raw scene
            drishti_dir = job.output_path + "/drishti";
            if not os.path.isdir(drishti_dir +"/"):
              os.mkdir(drishti_dir +"/");
            path_scene_out = drishti_dir + "/valid_scene";
            
            print("Creating a Scene");
            bvpl_octree_batch.init_process("boxmCreateSceneProcess");
            bvpl_octree_batch.set_input_string(0, job.output_path + "/valid_scene_" + str(job.scene_id) + ".xml");
            bvpl_octree_batch.run_process();
            (id, type) = bvpl_octree_batch.commit_output(0);
            scene= dbvalue(id, type);
             
            
            print("Save Scene");
            bvpl_octree_batch.init_process("boxmSaveSceneRawProcess");
            bvpl_octree_batch.set_input_from_db(0,scene);
            bvpl_octree_batch.set_input_string(1, path_scene_out);
            bvpl_octree_batch.set_input_unsigned(2,0);
            bvpl_octree_batch.set_input_unsigned(3,1);
            bvpl_octree_batch.run_process(); 
            
            
            bvpl_octree_batch.clear();
 
            print ("Runing time for worker:", self.name)
            print(time.time() - start_time);
    def run(self):
        while not self.kill_received:
             # get a task
            try:
                job = self.work_queue.get_nowait()
            except Queue.Empty:
                break
            
            start_time = time.time();
            
            print("Creating Gauss kernel");
            bvpl_octree_batch.init_process("bvpl_create_gauss3d_kernel_process");
            bvpl_octree_batch.set_input_float(0,job.sigma);
            bvpl_octree_batch.set_input_float(1,job.sigma);
            bvpl_octree_batch.set_input_float(2,job.sigma);
            bvpl_octree_batch.set_input_float(3,1.0);
            bvpl_octree_batch.set_input_float(4,0.0);
            bvpl_octree_batch.set_input_float(5,0.0);
            bvpl_octree_batch.set_input_float(6,0.0);
            bvpl_octree_batch.run_process();
            (kernel_id,kernel_type)= bvpl_octree_batch.commit_output(0);
            kernel = dbvalue(kernel_id,kernel_type);


            print("Running Kernel");
            bvpl_octree_batch.init_process("bvplBlockKernelOperatorProcess");
            bvpl_octree_batch.set_input_from_db(0,job.scene);
            bvpl_octree_batch.set_input_from_db(1,kernel);
            bvpl_octree_batch.set_input_int(2, job.block_i);
            bvpl_octree_batch.set_input_int(3, job.block_j)
            bvpl_octree_batch.set_input_int(4, job.block_k)
            bvpl_octree_batch.set_input_string(5,"algebraic");
            bvpl_octree_batch.set_input_string(6, job.output_path);
            bvpl_octree_batch.set_input_double(7, job.cell_length);
            bvpl_octree_batch.run_process();
            
            print ("Runing time for worker:", self.name)
            print(time.time() - start_time);
      
            #output exit code in this case
            #important: having a result queue makes the execute_jobs wait for all jobs in the queue before exiting
            self.result_queue.put(0);
    def run(self):
        while not self.kill_received:
             # get a task
            try:
                job = self.work_queue.get_nowait()
            except Queue.Empty:
                break
            
            start_time = time.time();
            
            print("Creating a Scene");
            bvpl_octree_batch.init_process("boxmCreateSceneProcess");
            bvpl_octree_batch.set_input_string(0,  job.scene_path );
            bvpl_octree_batch.run_process();
            (scene_id, scene_type) = bvpl_octree_batch.commit_output(0);
            scene= dbvalue(scene_id, scene_type);
  
            print("Explore Histogram");
            bvpl_octree_batch.init_process("bvplSceneHistorgramProcess");
            bvpl_octree_batch.set_input_from_db(0,scene);
            bvpl_octree_batch.run_process();
 
            print ("Runing time for worker:", self.name)
            print(time.time() - start_time);
Esempio n. 11
0
    num_cores = options.num_cores
    fraction = options.fraction

    if not os.path.isdir(model_dir + "/"):
        print "Invalid Model Dir"
        sys.exit(-1)

    if not os.path.isdir(taylor_dir + "/"):
        print "Invalid Taylor Dir"
        sys.exit(-1)

    print("Loading Error Scene")
    bvpl_octree_batch.init_process("boxmCreateSceneProcess")
    bvpl_octree_batch.set_input_string(0,  taylor_dir + "/error_scene.xml")
    bvpl_octree_batch.run_process()
    (scene_id, scene_type) = bvpl_octree_batch.commit_output(0)
    error_scene = dbvalue(scene_id, scene_type)

    # Begin multiprocessing
    work_queue = multiprocessing.Queue()
    job_list = []

    blocks_x = [i for i in range(0, nblocks_x)]
    blocks_y = [i for i in range(0, nblocks_y)]
    blocks_z = [i for i in range(0, nblocks_z)]

    random.shuffle(blocks_x)
    random.shuffle(blocks_y)
    random.shuffle(blocks_y)

    # Enqueue jobs
kernel_list.append("Iy");
kernel_list.append("Iz");
kernel_list.append("Ixx");
kernel_list.append("Iyy");
kernel_list.append("Izz");
kernel_list.append("Ixy");
kernel_list.append("Ixz");
kernel_list.append("Iyz");

blocks_x = 1; blocks_y = 1; blocks_z=1;

print("Creating a Scene");
bvpl_octree_batch.init_process("boxmCreateSceneProcess");
bvpl_octree_batch.set_input_string(0,  model_dir +"/mean_color_scene.xml");
bvpl_octree_batch.run_process();
(scene_id, scene_type) = bvpl_octree_batch.commit_output(0);
scene= dbvalue(scene_id, scene_type);

start = time.time()

#for curr_kernel in range(0, len(kernel_list)):
for curr_kernel in range(0, 1):
    #curr_kernel = 1;
    for i in range(0, blocks_x):
        for j in range(0, blocks_y):
            for k in range(0, blocks_z):
                curr_kernel_path = kernel_path + "/" + kernel_list[curr_kernel]+ ".txt";
                output_path = output_dir + "/" + kernel_list[curr_kernel];
                if not os.path.isdir( output_path + "/"):
                    os.mkdir( output_path + "/");
                    
Esempio n. 13
0
    num_cores = options.num_cores
    dimension = options.dimension

    if not os.path.isdir(model_dir + "/"):
        print "Invalid Model Dir"
        sys.exit(-1)

    if not os.path.isdir(pca_dir + "/"):
        print "Invalid PCA Dir"
        sys.exit(-1)

    print("Loading Data Scene")
    batch.init_process("boxmCreateSceneProcess")
    batch.set_input_string(0,  model_dir + "/mean_color_scene.xml")
    batch.run_process()
    (scene_id, scene_type) = batch.commit_output(0)
    data_scene = dbvalue(scene_id, scene_type)

    # Load pca scenes
    pca_feature_dim = 125
    print("Loading PCA Error Scenes")
    batch.init_process("bvplLoadPCAErrorSceneProcess")
    batch.set_input_from_db(0, data_scene)
    batch.set_input_string(1, pca_dir)
    batch.set_input_unsigned(
        2, pca_feature_dim)  # dimension pca feature
    batch.run_process()
    (id, type) = batch.commit_output(0)
    pca_scenes = dbvalue(id, type)

    print("Loading PCA Info")
  scene_blocks =[];
  
  parse_taylor_info(taylor_info_file, scene_blocks);
  
  print "Scene Blocks:"
  print scene_blocks

  
  #Begin multiprocessing
 
  start_time = time.time();

  bvpl_octree_batch.init_process("bvplLoadGlobaltaylorProcess");
  bvpl_octree_batch.set_input_string(0,taylor_dir);
  bvpl_octree_batch.run_process();
  (id, type) = bvpl_octree_batch.commit_output(0);
  global_taylor = dbvalue(id, type);
  
  #Enqueue jobs
  i = 0;
  #for s_idx in range (1, len(scene_blocks)):
  for s_idx in [0,4,5,8,10,11,14,17]:
      job_list=[];
      nblocks = scene_blocks[s_idx];
      for block_i in range (0, nblocks[1]):
          for block_j in range (0, nblocks[2]):
              for block_k in range (0, nblocks[3]):
                  current_job = taylor_project_job(global_taylor, s_idx, block_i, block_j, block_k);
                  job_list.append(current_job);
                  i= i+1;          
                              
  
  #Begin multiprocessing
  job_list=[];
  start_time = time.time();

  print("Creating Gauss kernel");
  bvpl_octree_batch.init_process("bvpl_create_gauss3d_kernel_process");
  bvpl_octree_batch.set_input_float(0,sigma);
  bvpl_octree_batch.set_input_float(1,sigma);
  bvpl_octree_batch.set_input_float(2,sigma);
  bvpl_octree_batch.set_input_float(3,1.0); #axis of rotation - irrelevant for isotropic gaussian
  bvpl_octree_batch.set_input_float(4,0.0);
  bvpl_octree_batch.set_input_float(5,0.0);
  bvpl_octree_batch.set_input_float(6,0.0); #rotation about axis of rotation ;)
  bvpl_octree_batch.run_process();
  (kernel_id,kernel_type)= bvpl_octree_batch.commit_output(0);
  kernel = dbvalue(kernel_id,kernel_type);


  #Enqueue jobs
  if(len(model_dirs)==len(output_dirs)==len(lengths)==len(scene_blocks) ):
      
    for scene_id in range (14, len(scene_blocks)):
        
        if not os.path.isdir(output_dirs[scene_id] +"/"):
            os.mkdir(output_dirs[scene_id] +"/");
            
        if not os.path.isdir(output_dirs[scene_id] +"/drishti/"):
            os.mkdir(output_dirs[scene_id] +"/drishti/");
        
        print("Creating a Scene");
Esempio n. 16
0
min_y = 0;
max_y = 0;
min_z = 0;
max_z = 0;

axes_x=[-1.0,0.0,0.0];
axes_y=[0.0,-1.0,0.0];
axes_z=[0.0,0.0,-1.0];

angle =  0.0;

print("Creating a Scene");
bvpl_octree_batch.init_process("boxmCreateSceneProcess");
bvpl_octree_batch.set_input_string(0,  model_dir +"/gaussf1_scene.xml");
bvpl_octree_batch.run_process();
(scene_id, scene_type) = bvpl_octree_batch.commit_output(0);
scene= dbvalue(scene_id, scene_type);

for i in range(0,len(output_dirs)) :

  output_dir = output_dirs[i];
  axis_x = axes_x[i];
  axis_y = axes_y[i];
  axis_z = axes_z[i];
  
  if not os.path.isdir( output_dir + "/"):
    os.mkdir( output_dir + "/");

  print("Creating 3D edge kernel");
  bvpl_octree_batch.init_process("bvplCreateEdge3dKernelProcess");
  bvpl_octree_batch.set_input_int(0,min_x);