TEMPLATE_HEADER void STORAGE::resize(){ size_t newsize = resizer(table_size); DataStorer ** newtable = new DataStorer*[newsize]; typename DataStorer::iterator it; for (int i = 0; i < table_size; i++) { if( table[i] != 0 ){ for (it = table[i]->begin(); it != table[i]->end(); it++) { push( it->second.k, it->second.d, newtable, newsize); } delete table[i]; table[i] = 0; } } delete [] table; table = newtable; table_size = newsize; updatePerfMeasure(); }
int main(int argc, const char** argv) { RectResizer resizer(*ORIG_SIZE, *NEW_SIZE); Segment scan(resizer.resize(cv::Rect(63, 112, 107, 48)), "SCAN", " "); Segment hold(resizer.resize(cv::Rect(170, 108, 111, 51)), "HOLD", " "); scan.setThreshold(0.01); hold.setThreshold(0.01); Digit* d[NUM_OF_DIGITS]; d[0] = new Digit(resizer.resize(cv::Rect(45, 182, 112, 214))); d[1] = new Digit(resizer.resize(cv::Rect(156, 182, 112, 214))); d[2] = new Digit(resizer.resize(cv::Rect(272, 182, 103, 214))); d[3] = new Digit(resizer.resize(cv::Rect(419, 179, 105, 214))); cv::Mat image; /* //From pictures for (int im = 1; im < argc; im++) { image = readImage(argc, argv, im); readData(image, d, scan, hold); printData(d, scan, hold); showImage(image, d, scan, hold); cv::waitKey(0); } */ cv::VideoCapture cap; openCamera(cap, argc, argv); bool paused = false; cv::Mat frame; for (;;) { if (!paused) { cap >> frame; if (frame.empty()) { break; } } frame.copyTo(image); readData(image, d, scan, hold); printData(d, scan, hold); showImage(image, d, scan, hold); char c = (char) cv::waitKey(10); if (c == 27) break; switch (c) { case 'p': paused = !paused; break; default: ; } }
//----------------------------------------------------------------------------- bool test_image_io(const std::string filename, const main_params& mp, const cropper_params& rp, const resizer_params& sp, const augmenter_params& ap) { int transform_idx = 0; int mean_extractor_idx = -1; unsigned int num_bytes = mp.m_num_bytes; // size of image in bytes lbann::cv_process pp; { // Initialize the image processor if (rp.m_is_set) { // If cropper parameters are given // Setup a cropper std::unique_ptr<lbann::cv_cropper> cropper(new(lbann::cv_cropper)); cropper->set(rp.m_crop_sz.first, rp.m_crop_sz.second, rp.m_rand_center, rp.m_roi_sz, rp.m_adaptive_interpolation); pp.add_transform(std::move(cropper)); num_bytes = rp.m_crop_sz.first * rp.m_crop_sz.second * 3; transform_idx ++; } if (sp.m_is_set) { // If resizer parameters are given // Setup a cropper std::unique_ptr<lbann::cv_resizer> resizer(new(lbann::cv_resizer)); resizer->set(sp.m_width, sp.m_height, rp.m_adaptive_interpolation); pp.add_transform(std::move(resizer)); num_bytes = sp.m_width * sp.m_height * 3; transform_idx ++; } if (ap.m_is_set) { // Set up an augmenter std::unique_ptr<lbann::cv_augmenter> augmenter(new(lbann::cv_augmenter)); augmenter->set(ap.m_hflip, ap.m_vflip, ap.m_rot, ap.m_hshift, ap.m_vshift, ap.m_shear); pp.add_transform(std::move(augmenter)); transform_idx ++; } if (mp.m_enable_colorizer) { // Set up a colorizer std::unique_ptr<lbann::cv_colorizer> colorizer(new(lbann::cv_colorizer)); pp.add_transform(std::move(colorizer)); transform_idx ++; } if (mp.m_enable_decolorizer) { // Set up a colorizer std::unique_ptr<lbann::cv_decolorizer> decolorizer(new(lbann::cv_decolorizer)); pp.add_transform(std::move(decolorizer)); transform_idx ++; } if (mp.m_enable_mean_extractor) { // set up a mean extractor mean_extractor_idx = transform_idx; std::unique_ptr<lbann::cv_mean_extractor> mean_extractor(new(lbann::cv_mean_extractor)); if (rp.m_is_set) mean_extractor->set(rp.m_crop_sz.first, rp.m_crop_sz.second, 3, mp.m_mean_batch_size); else mean_extractor->set(mp.m_mean_batch_size); pp.add_transform(std::move(mean_extractor)); transform_idx ++; } if (!mp.is_normalizer_off()) { // Set up a normalizer if (mp.is_channel_wise_normalizer()) { std::unique_ptr<lbann::cv_normalizer> normalizer(new(lbann::cv_normalizer)); normalizer->z_score(true); pp.add_normalizer(std::move(normalizer)); } else { std::unique_ptr<lbann::cv_subtractor> normalizer(new(lbann::cv_subtractor)); #if 0 cv::Mat img_to_sub = cv::imread(mp.m_mean_image_name); if (img_to_sub.empty()) { std::cout << mp.m_mean_image_name << " does not exist" << std::endl; return false; } normalizer->set_mean(img_to_sub); #else std::vector<lbann::DataType> mean = {0.40625, 0.45703, 0.48047}; normalizer->set_mean(mean); std::vector<lbann::DataType> stddev = {0.3, 0.5, 0.3}; normalizer->set_stddev(stddev); #endif pp.add_normalizer(std::move(normalizer)); } transform_idx ++; } } // Load an image bytestream into memory std::vector<unsigned char> buf; bool ok = lbann::load_file(filename, buf); if (!ok) { std::cout << "Failed to load" << std::endl; return false; } int width = 0; int height = 0; int type = 0; ::Mat Images; ::Mat Image_v; // matrix view Images.Resize(((num_bytes==0)? 1: num_bytes), 2); // minibatch size_t img_begin = 0; size_t img_end = buf.size(); for (unsigned int i=0; i < mp.m_num_iter; ++i) { // This has nothing to do with the image type but only to create view on a block of bytes using InputBuf_T = lbann::cv_image_type<uint8_t>; // Construct a zero copying view to a portion of a preloaded data buffer const cv::Mat inbuf(1, (img_end - img_begin), InputBuf_T::T(1), &(buf[img_begin])); if (num_bytes == 0) { ok = lbann::image_utils::import_image(inbuf, width, height, type, pp, Images); num_bytes = Images.Height(); El::View(Image_v, Images, El::IR(0, num_bytes), El::IR(0, 1)); } else { El::View(Image_v, Images, El::IR(0, num_bytes), El::IR(0, 1)); //ok = lbann::image_utils::import_image(buf, width, height, type, pp, Image_v); ok = lbann::image_utils::import_image(inbuf, width, height, type, pp, Image_v); } if (!ok) { std::cout << "Failed to import" << std::endl; return false; } //if ((i%3 == 0u) && (mp.m_enable_mean_extractor)) { // dynamic_cast<lbann::cv_mean_extractor*>(pp.get_transform(mean_extractor_idx))->reset(); //} } // Print out transforms const unsigned int num_transforms = pp.get_num_transforms(); const std::vector<std::unique_ptr<lbann::cv_transform> >& transforms = pp.get_transforms(); for(unsigned int i=0u; i < num_transforms; ++i) { std::cout << std::endl << "------------ transform " << i << "-------------" << std::endl; std::cout << *transforms[i] << std::endl; } if (mp.m_enable_mean_extractor) { // Extract the mean of images cv::Mat mean_image; mean_image = dynamic_cast<lbann::cv_mean_extractor*>(pp.get_transform(mean_extractor_idx))->extract<uint16_t>(); cv::imwrite("mean.png", mean_image); } // Export the unnormalized image const std::string ext = lbann::get_ext_name(filename); std::vector<unsigned char> outbuf; ok = lbann::image_utils::export_image(ext, outbuf, width, height, type, pp, Image_v); write_file("copy." + ext, outbuf); return ok; }