noisebindata.cc

torch tracking code, it is a good code

const char *help = "\
progname: noisebindata.cc\n\
code2html: This program adds random noise to a bindata file.\n\
version: Torch3 vision2.0, 2003-2005\n\
(c) Sebastien Marcel ([e-mail])\n";

#include "DiskXFile.h"
#include "Random.h"
#include "CmdLine.h"

using namespace Torch;

int main(int argc, char *argv[])
{
	char *filename_in;
	char *filename_out;
	int the_seed;
	int dim;
	int P;
	real nmin, nmax;
	bool verbose;
	
	CmdLine cmd;
	cmd.setBOption("write log", false);

	cmd.info(help);
	cmd.addText("\nArguments:");
	cmd.addSCmdArg("filename in", &filename_in, "input bindata filename");
	cmd.addSCmdArg("filename out", &filename_out, "output bindata filename");
	cmd.addText("\nArguments:");
	cmd.addICmdOption("-seed", &the_seed, 9503, "seed");
	cmd.addBCmdOption("-verbose", &verbose, false, "verbose");
	cmd.addRCmdOption("-nmin", &nmin, -0.1, "min random noise");
	cmd.addRCmdOption("-nmax", &nmax, +0.1, "max random noise");
	cmd.addICmdOption("-p", &P, 1, "number of perturbations to generate");
	cmd.addICmdOption("-dim", &dim, -1, "dimension to perturbate");
	cmd.read(argc, argv);

	DiskXFile *file = NULL;
	DiskXFile *fileout = NULL;
  
  	// Reading headers
	int n_patterns;
	int n_inputs;

	file = new DiskXFile(filename_in, "r");
		
	file->read(&n_patterns, sizeof(int), 1);
	file->read(&n_inputs, sizeof(int), 1);

	if(verbose)
	{
		print("Reading bindata file (%s)\n", filename_in);
		print("   n_inputs = %d\n", n_inputs);
		print("   n_patterns = %d\n", n_patterns);  
	}

  	fileout = new DiskXFile(filename_out, "w");
  	if(fileout == NULL)
	{
      		error("Opening BinData file %s", filename_out);
      
      		return 1;
	}

	int n_patterns_ = n_patterns * P;

	fileout->write(&n_patterns_, sizeof(int), 1);
	fileout->write(&n_inputs, sizeof(int), 1);

	if(verbose)
	{
  		print("\n");  
  		print("Writing bindata file :\n");  
  		print("   n_inputs : %d\n", n_inputs);
  		print("   n_patterns : %d\n", n_patterns_);  
        }

	real *input = new real [n_inputs];
	real *output = new real [n_inputs];

	Random::manualSeed(the_seed);

	for(int p = 0 ; p < n_patterns ; p++)
	{		  
		file->read(input, sizeof(real), n_inputs);

		for(int j = 0 ; j < P ; j++)
		{
			for(int i = 0 ; i < n_inputs ; i++)
				if((dim == -1) || (i == dim)) output[i] = input[i] + Random::boundedUniform(nmin, nmax);
				else output[i] = input[i];

			fileout->write(output, sizeof(real), n_inputs);
		}
	}

	delete [] input;
	delete [] output;
	delete fileout;
	delete file;

	return 0;
}