1 // This is brl/bseg/brec/pro/processes/brec_hierarchy_processes.cxx 2 #include <bprb/bprb_func_process.h> 3 //: 4 // \file 5 // \brief Processes to create/save/load instances of part hierarchies. 6 // 7 // \author Ozge Can Ozcanli 8 // \date Dec 26, 2008 9 // 10 // \verbatim 11 // Modifications 12 // Ozge C. Ozcanli - Feb 03, 2009 - converted process-class to functions which is the new design for bprb processes. 13 // \endverbatim 14 15 #include <brdb/brdb_value.h> 16 #include <bprb/bprb_parameters.h> 17 18 #include <brec/brec_part_hierarchy_builder.h> 19 #include <brec/brec_part_hierarchy.h> 20 21 //: Constructor 22 // create hierarchy process may use the builder class or create an empty one to be passed to training processes to learn the hierarchy brec_create_hierarchy_process_cons(bprb_func_process & pro)23bool brec_create_hierarchy_process_cons(bprb_func_process& pro) 24 { 25 //inputs 26 bool ok=false; 27 std::vector<std::string> input_types; 28 input_types.emplace_back("bool"); // if true creates an empty hierarchy otherwise returns an instance created by the builder class for the given detector id 29 input_types.emplace_back("unsigned"); // detector id for the type of structure to be recognized (if using builder class, otherwise not-used) 30 input_types.emplace_back("vcl_string"); // name of the hierarchy 31 ok = pro.set_input_types(input_types); 32 if (!ok) return ok; 33 34 //output 35 std::vector<std::string> output_types; 36 output_types.emplace_back("brec_part_hierarchy_sptr"); // output hierarchy 37 ok = pro.set_output_types(output_types); 38 return ok; 39 } 40 41 brec_create_hierarchy_process(bprb_func_process & pro)42bool brec_create_hierarchy_process(bprb_func_process& pro) 43 { 44 // Sanity check 45 if (pro.n_inputs() < 3) { 46 std::cerr << "brec_create_hierarchy_process - invalid inputs\n"; 47 return false; 48 } 49 50 // get input 51 unsigned i = 0; 52 bool create_empty = pro.get_input<bool>(i++); 53 auto d_id = pro.get_input<unsigned>(i++); 54 std::string name = pro.get_input<std::string>(i++); 55 56 brec_part_hierarchy_sptr h; 57 if (create_empty) { 58 h = new brec_part_hierarchy(); 59 h->set_name(name); 60 } else { 61 switch (d_id) { 62 case 0: { h = brec_part_hierarchy_builder::construct_detector_roi1_0(); } break; 63 case 1: { h = brec_part_hierarchy_builder::construct_detector_roi1_1(); } break; 64 case 2: { h = brec_part_hierarchy_builder::construct_detector_roi1_2(); } break; 65 case 3: { h = brec_part_hierarchy_builder::construct_detector_roi1_3(); } break; 66 case 4: { h = brec_part_hierarchy_builder::construct_detector_roi1_4(); } break; 67 case 100: { h = brec_part_hierarchy_builder::construct_test_detector(); } break; 68 default: { std::cout << "In brec_create_hierarchy_process::execute() -- Unrecognized detector type!!\n"; return false; } 69 } 70 } 71 72 pro.set_output_val<brec_part_hierarchy_sptr>(0, h); 73 74 return true; 75 } 76 77 //: Constructor brec_load_hierarchy_process_cons(bprb_func_process & pro)78bool brec_load_hierarchy_process_cons(bprb_func_process& pro) 79 { 80 //inputs 81 bool ok=false; 82 std::vector<std::string> input_types; 83 input_types.emplace_back("vcl_string"); // name of xml file 84 ok = pro.set_input_types(input_types); 85 if (!ok) return ok; 86 87 //output 88 std::vector<std::string> output_types; 89 output_types.emplace_back("brec_part_hierarchy_sptr"); // h 90 ok = pro.set_output_types(output_types); 91 return ok; 92 } 93 brec_load_hierarchy_process(bprb_func_process & pro)94bool brec_load_hierarchy_process(bprb_func_process& pro) 95 { 96 // Sanity check 97 if (pro.n_inputs() < 1) { 98 std::cerr << " brec_load_hierarchy_process - invalid inputs\n"; 99 return false; 100 } 101 102 // get input 103 unsigned i = 0; 104 std::string name = pro.get_input<std::string>(i++); 105 106 brec_part_hierarchy_sptr h = new brec_part_hierarchy(); 107 std::ifstream is(name.c_str()); 108 h->read_xml(is); 109 is.close(); 110 111 pro.set_output_val<brec_part_hierarchy_sptr>(0, h); 112 113 return true; 114 } 115 brec_save_hierarchy_process_cons(bprb_func_process & pro)116bool brec_save_hierarchy_process_cons(bprb_func_process& pro) 117 { 118 //inputs 119 bool ok=false; 120 std::vector<std::string> input_types; 121 input_types.emplace_back("brec_part_hierarchy_sptr"); // h 122 input_types.emplace_back("vcl_string"); // name of output xml file 123 ok = pro.set_input_types(input_types); 124 if (!ok) return ok; 125 126 //output 127 std::vector<std::string> output_types; 128 ok = pro.set_output_types(output_types); 129 return ok; 130 } 131 brec_save_hierarchy_process(bprb_func_process & pro)132bool brec_save_hierarchy_process(bprb_func_process& pro) 133 { 134 // Sanity check 135 if (pro.n_inputs() < 2) { 136 std::cerr << " brec_load_hierarchy_process - invalid inputs\n"; 137 return false; 138 } 139 140 // get input 141 unsigned i = 0; 142 brec_part_hierarchy_sptr h = pro.get_input<brec_part_hierarchy_sptr>(i++); 143 std::string name = pro.get_input<std::string>(i++); 144 145 std::ofstream os(name.c_str()); 146 h->write_xml(os); 147 os.close(); 148 149 return true; 150 } 151 brec_draw_hierarchy_process_cons(bprb_func_process & pro)152bool brec_draw_hierarchy_process_cons(bprb_func_process& pro) 153 { 154 //inputs 155 bool ok=false; 156 std::vector<std::string> input_types; 157 input_types.emplace_back("brec_part_hierarchy_sptr"); // h 158 input_types.emplace_back("vcl_string"); // name of output ps file 159 input_types.emplace_back("float"); // drawing radius for the primitive parts, this radius is doubled as we go up in the hierarchy 160 input_types.emplace_back("int"); // number of samples to sample from edge distributions 161 ok = pro.set_input_types(input_types); 162 if (!ok) return ok; 163 164 //output 165 std::vector<std::string> output_types; 166 ok = pro.set_output_types(output_types); 167 return ok; 168 } 169 brec_draw_hierarchy_process(bprb_func_process & pro)170bool brec_draw_hierarchy_process(bprb_func_process& pro) 171 { 172 // Sanity check 173 if (pro.n_inputs() < 4) { 174 std::cerr << " brec_load_hierarchy_process - invalid inputs\n"; 175 return false; 176 } 177 178 // get input 179 unsigned i = 0; 180 brec_part_hierarchy_sptr h = pro.get_input<brec_part_hierarchy_sptr>(i++); 181 std::string name = pro.get_input<std::string>(i++); 182 auto drawing_radius = pro.get_input<float>(i++); 183 int N = pro.get_input<int>(i++); 184 185 h->draw_to_ps(N, name, drawing_radius); 186 187 return true; 188 } 189 brec_set_hierarchy_model_dir_process_cons(bprb_func_process & pro)190bool brec_set_hierarchy_model_dir_process_cons(bprb_func_process& pro) 191 { 192 //inputs 193 bool ok=false; 194 std::vector<std::string> input_types; 195 input_types.emplace_back("brec_part_hierarchy_sptr"); // h 196 input_types.emplace_back("vcl_string"); // model dir 197 ok = pro.set_input_types(input_types); 198 if (!ok) return ok; 199 200 //output 201 std::vector<std::string> output_types; 202 ok = pro.set_output_types(output_types); 203 return ok; 204 } 205 brec_set_hierarchy_model_dir_process(bprb_func_process & pro)206bool brec_set_hierarchy_model_dir_process(bprb_func_process& pro) 207 { 208 // Sanity check 209 if (pro.n_inputs() < 2) { 210 std::cerr << " brec_set_hierarchy_model_dir_process - invalid inputs\n"; 211 return false; 212 } 213 214 // get input 215 unsigned i = 0; 216 brec_part_hierarchy_sptr h = pro.get_input<brec_part_hierarchy_sptr>(i++); 217 std::string name = pro.get_input<std::string>(i++); 218 h->set_model_dir(name); 219 return true; 220 } 221