1 // This is brl/bseg/brec/pro/processes/brec_learner_update_processes.cxx
2 #include <bprb/bprb_func_process.h>
3 //:
4 // \file
5 // \brief Processes to update stats of learner instances from training imgs
6 //
7 // \author Ozge Can Ozcanli
8 // \date Jan 22, 2009
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_learner_sptr.h>
19 #include <brec/brec_part_hierarchy_learner.h>
20
21 #include "vil/vil_image_view.h"
22 #include "vil/vil_convert.h"
23
24 //: Constructor
brec_learner_layer0_update_stats_process_cons(bprb_func_process & pro)25 bool brec_learner_layer0_update_stats_process_cons(bprb_func_process& pro)
26 {
27 //inputs
28 bool ok=false;
29 std::vector<std::string> input_types;
30 input_types.emplace_back("brec_part_hierarchy_learner_sptr"); // learner instance
31 input_types.emplace_back("vil_image_view_base_sptr"); // a training image, byte image
32 input_types.emplace_back("vil_image_view_base_sptr"); // a foreground probability img for the input training image, float img with values in [0,1] range
33 // this is the foreground ground-truth mask if available
34 input_types.emplace_back("vil_image_view_base_sptr"); // a bool mask img to designate valid regions in the input image, stats will be collected from the pixels with mask == true
35 // if this pointer is passed as zero, a mask filled with "true" is used (all image is used)
36 input_types.emplace_back("vcl_string"); // output file to save histograms in matlab .m file format
37 ok = pro.set_input_types(input_types);
38 if (!ok) return ok;
39
40 //output
41 std::vector<std::string> output_types;
42 ok = pro.set_output_types(output_types);
43 return ok;
44 }
45
46 //: don't set the third input if it needs to be initialized as a mask filled with "true", just call the init method from Python before running the process
brec_learner_layer0_update_stats_process_init(bprb_func_process & pro)47 bool brec_learner_layer0_update_stats_process_init(bprb_func_process& pro)
48 {
49 // initialize a dummy mask
50 vil_image_view<bool> dummy(10, 10);
51 dummy.fill(true);
52 vil_image_view_base_sptr m_ptr = new vil_image_view<bool>(dummy);
53 pro.set_input(3, new brdb_value_t<vil_image_view_base_sptr>(m_ptr));
54 return true;
55 }
56
brec_learner_layer0_update_stats_process(bprb_func_process & pro)57 bool brec_learner_layer0_update_stats_process(bprb_func_process& pro)
58 {
59 // Sanity check
60 if (pro.n_inputs() < 5) {
61 std::cerr << " brec_learner_layer0_update_stats_process - invalid inputs\n";
62 return false;
63 }
64
65 // get input
66 unsigned i = 0;
67 brec_part_hierarchy_learner_sptr hl = pro.get_input<brec_part_hierarchy_learner_sptr>(i++);
68
69 vil_image_view_base_sptr inp_img = pro.get_input<vil_image_view_base_sptr>(i++);
70 vil_image_view<float> img = *vil_convert_cast(float(), inp_img);
71 if (inp_img->pixel_format() == VIL_PIXEL_FORMAT_BYTE)
72 vil_math_scale_values(img,1.0/255.0);
73
74 vil_image_view_base_sptr inp_prob = pro.get_input<vil_image_view_base_sptr>(i++);
75 vil_image_view<float> prob = *vil_convert_cast(float(), inp_prob);
76 if (inp_prob->pixel_format() == VIL_PIXEL_FORMAT_BOOL) {
77 // just a check to make sure conversion went well
78 float min, max;
79 vil_math_value_range(prob, min, max);
80 std::cout << " input prob map was a byte image, after conversion min value: " << min << " max value: " << max << std::endl;
81 } else if (inp_prob->pixel_format() != VIL_PIXEL_FORMAT_FLOAT) {
82 std::cout << "In brec_learner_update_stats_process::execute() -- ERROR: input prob image is neither BOOL img nor FLOAT img!!\n";
83 return false;
84 }
85
86 vil_image_view_base_sptr inp_mask = pro.get_input<vil_image_view_base_sptr>(i++);
87 vil_image_view<bool> mask_img(img.ni(), img.nj());
88 if (!inp_mask || inp_mask->ni() != img.ni()) { // if mask is passed as zero make a bool img with all pixels true, i.e. use the whole input img
89 mask_img.fill(true);
90 } else {
91 if (inp_mask->pixel_format() != VIL_PIXEL_FORMAT_BOOL) {
92 std::cout << "In brec_learner_update_stats_process::execute() -- ERROR: input mask image is not of type BOOL!!\n";
93 return false;
94 }
95 mask_img = inp_mask;
96 }
97
98 std::string output_file = pro.get_input<std::string>(i++);
99
100 hl->layer0_collect_stats(img, prob, mask_img);
101 hl->print_to_m_file_layer0(output_file);
102
103 return true;
104 }
105
106 //: Constructor
brec_learner_layer0_update_posterior_stats_process_cons(bprb_func_process & pro)107 bool brec_learner_layer0_update_posterior_stats_process_cons(bprb_func_process& pro)
108 {
109 //inputs
110 bool ok=false;
111 std::vector<std::string> input_types;
112 input_types.emplace_back("brec_part_hierarchy_learner_sptr"); // learner instance, assumes the foreground response distribution's parameters have already been fit
113 input_types.emplace_back("vil_image_view_base_sptr"); // a training image, byte image
114 input_types.emplace_back("vil_image_view_base_sptr"); // a foreground probability img for the input training image, float img with values in [0,1] range
115 // this is the foreground ground-truth mask if available
116 input_types.emplace_back("vil_image_view_base_sptr"); // a bool mask img to designate valid regions in the input image, stats will be collected from the pixels with mask == true
117 // if this pointer is passed as zero, a mask filled with "true" is used (all image is used)
118
119 input_types.emplace_back("vil_image_view_base_sptr"); // bg model mean img to construct response models, float img with values in [0,1] range
120 input_types.emplace_back("vil_image_view_base_sptr"); // bg model std dev img to construct response models, float img with values in [0,1] range
121 ok = pro.set_input_types(input_types);
122 if (!ok) return ok;
123
124 //output
125 std::vector<std::string> output_types;
126 ok = pro.set_output_types(output_types);
127 return ok;
128 }
129
brec_learner_layer0_update_posterior_stats_process_init(bprb_func_process & pro)130 bool brec_learner_layer0_update_posterior_stats_process_init(bprb_func_process& pro)
131 {
132 // initialize a dummy mask
133 vil_image_view<bool> dummy(10, 10);
134 dummy.fill(true);
135 vil_image_view_base_sptr m_ptr = new vil_image_view<bool>(dummy);
136 pro.set_input(3, new brdb_value_t<vil_image_view_base_sptr>(m_ptr));
137 return true;
138 }
139
brec_learner_layer0_update_posterior_stats_process(bprb_func_process & pro)140 bool brec_learner_layer0_update_posterior_stats_process(bprb_func_process& pro)
141 {
142 // Sanity check
143 if (pro.n_inputs() < 6) {
144 std::cerr << " brec_learner_layer0_update_stats_process - invalid inputs\n";
145 return false;
146 }
147
148 // get input
149 unsigned i = 0;
150 brec_part_hierarchy_learner_sptr hl = pro.get_input<brec_part_hierarchy_learner_sptr>(i++);
151
152 vil_image_view_base_sptr inp_img = pro.get_input<vil_image_view_base_sptr>(i++);
153
154 vil_image_view<float> img = *vil_convert_cast(float(), inp_img);
155 if (inp_img->pixel_format() == VIL_PIXEL_FORMAT_BYTE)
156 vil_math_scale_values(img,1.0/255.0);
157
158 vil_image_view_base_sptr inp_prob = pro.get_input<vil_image_view_base_sptr>(i++);
159
160 vil_image_view<float> prob = *vil_convert_cast(float(), inp_prob);
161 if (inp_prob->pixel_format() == VIL_PIXEL_FORMAT_BOOL) {
162 // just a check to make sure conversion went well
163 float min, max;
164 vil_math_value_range(prob, min, max);
165 std::cout << " input prob map was a byte image, after conversion min value: " << min << " max value: " << max << std::endl;
166 } else if (inp_prob->pixel_format() != VIL_PIXEL_FORMAT_FLOAT) {
167 std::cout << "In brec_learner_update_posterior_stats_process::execute() -- ERROR: input prob image is neither BOOL img nor FLOAT img!!\n";
168 return false;
169 }
170
171 vil_image_view_base_sptr inp_mask = pro.get_input<vil_image_view_base_sptr>(i++);
172
173 vil_image_view<bool> mask_img(img.ni(), img.nj());
174 if (!inp_mask || inp_mask->ni() != img.ni()) { // if mask is passed as zero make a bool img with all pixels true, i.e. use the whole input img
175 mask_img.fill(true);
176 } else {
177 if (inp_mask->pixel_format() != VIL_PIXEL_FORMAT_BOOL) {
178 std::cout << "In brec_learner_update_posterior_stats_process::execute() -- ERROR: input mask image is not of type BOOL!!\n";
179 return false;
180 }
181 mask_img = inp_mask;
182 }
183
184 vil_image_view_base_sptr inp_mean = pro.get_input<vil_image_view_base_sptr>(i++);
185
186 if (inp_mean->pixel_format() != VIL_PIXEL_FORMAT_FLOAT)
187 return false;
188
189 vil_image_view_base_sptr inp_std_dev = pro.get_input<vil_image_view_base_sptr>(i++);
190
191 if (inp_std_dev->pixel_format() != VIL_PIXEL_FORMAT_FLOAT)
192 return false;
193
194 vil_image_view<float> mean_img(inp_mean);
195 vil_image_view<float> std_dev_img(inp_std_dev);
196
197 hl->layer0_collect_posterior_stats(img, prob, mask_img, mean_img, std_dev_img);
198
199 return true;
200 }
201
202 //: Constructor
brec_learner_layer_n_update_stats_process_cons(bprb_func_process & pro)203 bool brec_learner_layer_n_update_stats_process_cons(bprb_func_process& pro)
204 {
205 //inputs
206 bool ok=false;
207 std::vector<std::string> input_types;
208 input_types.emplace_back("brec_part_hierarchy_learner_sptr"); // learner instance
209 input_types.emplace_back("brec_part_hierarchy_detector_sptr"); // a detector instance
210 input_types.emplace_back("unsigned"); // n: layer id
211 input_types.emplace_back("unsigned"); // k: class id
212 input_types.emplace_back("vcl_string"); // output file to save histograms in matlab .m file format
213 ok = pro.set_input_types(input_types);
214 if (!ok) return ok;
215
216 //output
217 std::vector<std::string> output_types;
218 ok = pro.set_output_types(output_types);
219 return ok;
220 }
221
brec_learner_layer_n_update_stats_process(bprb_func_process & pro)222 bool brec_learner_layer_n_update_stats_process(bprb_func_process& pro)
223 {
224 // Sanity check
225 if (pro.n_inputs() < 4){
226 std::cerr << " brec_learner_layer_n_update_stats_process - invalid inputs\n";
227 return false;
228 }
229
230 //: get input
231 unsigned i = 0;
232 brec_part_hierarchy_learner_sptr hl = pro.get_input<brec_part_hierarchy_learner_sptr>(i++);
233 brec_part_hierarchy_detector_sptr hd = pro.get_input<brec_part_hierarchy_detector_sptr>(i++);
234 auto n = pro.get_input<unsigned>(i++);
235 auto k = pro.get_input<unsigned>(i++);
236 std::string output_file = pro.get_input<std::string>(i++);
237
238 hl->layer_n_collect_stats(hd, n, k);
239 hl->print_to_m_file_layer_n(output_file, k, false);
240
241 return true;
242 }
243