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)23 bool 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)42 bool 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)78 bool 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)94 bool 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)116 bool 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)132 bool 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)152 bool 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)170 bool 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)190 bool 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)206 bool 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