Exemple #1
0
//-----------------------------------------------------------------------------
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;
}
Exemple #2
0
function main(in mode, io ledgercode, in newaccno0, in newaccount, in sortorder, in params0, out msg) {
	//y2k
	//chartmv.fns must be changed in all places in ABP and ABP2
	var interactive = not SYSTEM.a(33);
	var newaccno = newaccno0.a(1, 1, 1);
	//if newaccno<1,1,2>='' then newaccno<1,1,2>=newaccno<1,1,1>
	var newaccname = newaccount.a(1);
	var params=params0;

	var update = mode == "ADD";
	msg = "";

	//check does not already exist in any ledger
	if (fin.account.read(fin.accounts, "." ^ newaccno)) {
		return 0;
	}
	// msg=''
	//preexist:
	// msg=quote(newaccno):msg:' ACCOUNT NUMBER ALREADY EXISTS'
	// return 0
	// end

	if (fin.account.read(fin.accounts, newaccno)) {
		return 0;
	}
	// msg=' ORIGINAL'
	// goto preexist
	// end

	//make the ledger code
	var origledgercode = ledgercode;
	var origparams = params;
	gosub expandledgercodeparams(ledgercode, params);

	//if chart doesnt exist then walk back through the years
	//zzz should walk back through quarters or periods too but isnt implemented
	//if by period or quarter will work if all periods/quarters exist in one year
	var tt;
	if (not(tt.read(fin.charts, ledgercode))) {
		var targetledgercode = ledgercode;

		//contruct prior year ledgercode
getprevledgercode:
		params.r(1, (addcent(params.a(1)) - 1).substr(-2, 2));
		ledgercode = origledgercode;
		gosub expandledgercodeparams(ledgercode, params);

		//just quit if back to original code after searching backwards through 07-06
		if (ledgercode == targetledgercode) {
			ledgercode = targetledgercode;

		}else{

			//if prior year chart doesnt exist go back to look for another
			var chart;
			if (not(chart.read(fin.charts, ledgercode))) {
				goto getprevledgercode;
			}

			//found previous chart so create new chart

			//change previous year if in chart name
			var tt = chart.a(1);
			tt.swapper(addcent(params.a(1)), addcent(origparams.a(1)));
			tt.swapper(params.a(1), origparams.a(1));
			chart.r(1, tt);

			ledgercode = targetledgercode;
			//zzz should really lock to prevent create unless exclusive
			//but will not really cause a problem probs
			gosub createchart(chart, ledgercode);

		}

	}

	//find the highest numbered ledger within that group
	var chart = "";
	var ledgerno = -1;
	origledgercode = ledgercode;
	var newaccnumber = newaccno;
	if (newaccnumber.match("\"JOB\"0N")) {
		newaccnumber.splicer(1, 3, "");
	}
	if (newaccnumber.match("\"SCH\"0N")) {
		newaccnumber.splicer(1, 3, "");
	}
nextledgerno:
	ledgerno += 1;
	var newledgercode = origledgercode ^ ledgerno.oconv("MD00Z");
	var nextledgerno = ledgerno + 1;
	if (nextledgerno < 2) {
		nextledgerno = 2;
	}
	var nextledgercode = origledgercode ^ nextledgerno;
	if (chart.read(fin.charts, newledgercode)) {

	/*;
			//if numeric account numbers and any account is gt the new account number
			// then this is the ledger
			if num(newaccnumber) then;
				naccs=count(chart<3>,vm)+1;
				for accn=naccs to 1 step -1;
					accno=chart<10,accn>;
					if accno matches '"JOB"0N' then accno[1,3]='';
					if accno matches '"SCH"0N' then accno[1,3]='';
					if accno then;
						if num(accno) and accno>newaccnumber then;
							ledgercode=newledgercode;
							goto foundledger;
							end;
						end;
					next accn;
				end;
	*/

		ledgercode = newledgercode;
		goto nextledgerno;
	}

	//allow for number :1 missing and jump to :2
	if (ledgerno < 2) {
		//ledgerno+=1
		goto nextledgerno;
	}
//foundledger:

	//check that the ledger exists and get the chart
	if (not chart) {
		msg = "Cannot create Account " ^ (DQ ^ (newaccno ^ DQ)) ^ " automatically because|";
		msg ^= "ledger " ^ (DQ ^ (ledgercode ^ DQ)) ^ " must be created first";
		goto exit;
	}

lockit:
	//lock and reread the chart for update
	if (not(lockrecord("CHARTS", fin.charts, ledgercode, 60))) {
		msg = "Cannot create account " ^ (DQ ^ (newaccno ^ DQ)) ^ " automatically because|";
		msg ^= "somebody is updating |" ^ (DQ ^ (chart.a(1) ^ DQ));
		goto exit;
	}
	if (not(chart.read(fin.charts, ledgercode))) {
		chart = "";
	}

	//add new chart if existing is too big

	//if interactive and len(chart)>32000 and newledgercode then
	if (chart.length() > 32000 and newledgercode) {

		//unlock the old chart because we are going to create a new one
		var xx = unlockrecord("CHARTS", fin.charts, ledgercode);

		//switch to the new ledger code
		ledgercode = newledgercode;
		newledgercode = "";

		gosub createchart(chart, ledgercode);

		goto lockit;

	}

	//prevent chartsize exceeding 32KB
	//NB "TOO BIG" is a trigger phrase hard coded in IMPORTX so dont change it
	msg = "THE|" ^ chart.a(1) ^ " (" ^ ledgercode ^ ")|LEDGER IS GETTING TOO BIG";
	msg ^= "||!!! PLEASE OPEN A NEW LEDGER|WITH LEDGER CODE " ^ (DQ ^ (newledgercode ^ DQ)) ^ "|";
	if (chart.length() > 36000) {
		msg.splicer(1, 0, "!CANNOT OPEN NEW ACCOUNT " ^ (DQ ^ (newaccno ^ DQ)) ^ " BECAUSE ");
		msg.swapper("GETTING ", "");
		goto exit;
	}
	//warning if chartsize nearing 32KB
	if (chart.length() > 32000) {
		//if mode='VALIDATE' then call note(msg)
		if (mode == "VALIDATE") {
			goto exit;
		}
	}
	msg = "";

	///
	if (mode == "VALIDATE") {
		goto exit;
	}
	///

	//determine the sort key
	if (sortorder == "NAME") {
		sortkey = newaccname;
	}else{
		sortkey = newaccname;
	}

	//calc the number of lines
	accs = chart.a(4);
	naccs = accs.count(VM) + (accs ne "");
	naccs2 = (chart.a(3)).count(VM) + (chart.a(3) ne "");
	if (naccs2 > naccs) {
		naccs = naccs2;
	}

	//default to the end of the ledger
	vn = naccs + 1;

	//find value number to insert at
	if (sortorder) {

		//insert before the first larger account number or name
		for (var accn = 1; accn <= naccs; ++accn) {

			if (sortorder == "NAME") {
				value = chart.a(3, accn);
			}else{
				value = chart.a(10, accn);
			}

			if (value) {
				if (value.trimf() > sortkey) {

					vn = accn;
					accn = naccs;

					//insert a blank line
					var nn = fin.chartmvfns.dcount(VM);
					for (var ii = 1; ii <= nn; ++ii) {
						var tt = fin.chartmvfns.a(1, ii);
						if (tt) {
							chart.inserter(tt, vn, "");
							}
					};//ii;

				}
			}
		};//accn;

	}

	//update the chart of accounts
	if (vn == 1) {
		indent = "";
	}else{
		//indent like previous line
		var temp = chart.a(3, vn - 1);
		indent = (temp.length() - (temp.trimf()).length()).space();
		//if no account number on previous line then indent by one more
		if (chart.a(4, vn - 1) == "") {
			indent ^= " ";
		}
	}
	chart.r(3, vn, indent ^ newaccname);
	chart.r(4, vn, newaccno);
	chart.r(10, vn, newaccno);
	//terms
	//main currency
	//tax code
	if (newaccount.a(33)) {
		chart.r(33, vn, newaccount.a(33));
	}
	if (newaccount.a(4)) {
		chart.r(7, vn, newaccount.a(4));
	}
	if (newaccount.a(14)) {
		chart.r(14, vn, newaccount.a(14));
	}
	if (update) {
		call cropper(chart);
		chart.write(fin.charts, ledgercode);
	}

	//create the account record
	fin.account = newaccount;
	fin.account.r(2, ledgercode);
	fin.account.r(5, chart.a(6));
	fin.account.r(6, chart.a(2, 1, 2));
	fin.account.r(8, chart.a(9));
	fin.account.r(10, newaccno);
	fin.account.r(23, chart.a(5));
	//account<26>=
	if (update) {
		fin.account.write(fin.accounts, newaccno);
	}

	//create the other account record
	fin.account.r(10, newaccno);
	if (update) {
		fin.account.write(fin.accounts, "." ^ newaccno);
	}

exit:
	/////
	var xx = unlockrecord("CHARTS", fin.charts, ledgercode);

	return 0;

}
Exemple #3
0
QRect CCBuilder::crop()
{
    Cropper cropper(this);
    return cropper.crop();
}