statbindata.cc

torch tracking code, it is a good code

const char *help = "\
progname: statbindata.cc\n\
code2html: This program reads bindata files (Torch binary dataset format) and computes mean/stdv.\n\
version: Torch3 vision2.0, 2004-2005\n\
(c) Sebastien Marcel ([e-mail])\n";

#include "DiskXFile.h"
#include "ImageGray.h"
#include "FileListCmdOption.h"
#include "CmdLine.h"

using namespace Torch;

int main(int argc, char *argv[])
{
	bool verbose;
	bool savemeanaspgm;
	int n_inputs;
	int width;
	int height;

	FileListCmdOption filelist("filelist", "the list files or one data file");
	filelist.isArgument(true);
	
	CmdLine cmd;
	cmd.setBOption("write log", false);

	//
	cmd.info(help);
	cmd.addText("\nArguments:");
	cmd.addCmdOption(&filelist);
	cmd.addICmdArg("n_inputs", &n_inputs, "number of inputs");
	cmd.addText("\nOptions:");
	cmd.addBCmdOption("-verbose", &verbose, false, "verbose");
	cmd.addBCmdOption("-savepgm", &savemeanaspgm, false, "savemeanaspgm");
	cmd.addICmdOption("-width", &width, 19, "width");
	cmd.addICmdOption("-height", &height, 19, "height");
	cmd.read(argc, argv);
	
	//
	int n_inputs_;
	int n_patterns;
	DiskXFile *pf_in;
		
	real *data = new real [n_inputs];
	real *mean = new real [n_inputs];
	real *stdv = new real [n_inputs];
		
	
	for(int j = 0 ; j < n_inputs ; j++) mean[j] = stdv[j] = 0.0;

	int n_total_patterns = 0;

	real min_mean = 100.0;
	real max_mean = -100.0;
	real min_stdv = 100.0;
	real max_stdv = -100.0;
	
	for(int i = 0 ; i < filelist.n_files ; i++)
	{
		pf_in = new DiskXFile(filelist.file_names[i], "r");
		if((pf_in == NULL) || (pf_in->is_opened == false))
		{
      			error("Opening bindata file %s", filelist.file_names[i]);
      
      			return 0;
		}
	
		pf_in->read(&n_patterns, sizeof(int), 1);
		pf_in->read(&n_inputs_, sizeof(int), 1);

		if(n_inputs_ != n_inputs_)
		{
			delete pf_in;
			error("number of inputs (%d != %d) incorrect in file %s", n_inputs_, n_inputs, filelist.file_names[i]);
		}
	
		if(verbose)
		{
			print("Reading bindata file (%s)\n", filelist.file_names[i]);
			print("   n_inputs = %d\n", n_inputs);
			print("   n_patterns = %d\n", n_patterns);  
		}

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

			real mean_pixel = 0.0;
			real stdv_pixel = 0.0;
			
			for(int j = 0 ; j < n_inputs ; j++)
			{
				real z = data[j];
				mean[j] += z;
				stdv[j] += z*z;

				mean_pixel += z;
				stdv_pixel += z*z;
			}
			mean_pixel /= (real) n_inputs;
			stdv_pixel /= (real) n_inputs;
			stdv_pixel -= mean_pixel*mean_pixel;
			if(stdv_pixel <= 0) stdv_pixel = 1.0;
			else stdv_pixel = sqrt(stdv_pixel);

			if(mean_pixel < min_mean) min_mean = mean_pixel;
			if(mean_pixel > max_mean) max_mean = mean_pixel;
			if(stdv_pixel < min_stdv) min_stdv = stdv_pixel;
			if(stdv_pixel > max_stdv) max_stdv = stdv_pixel;
		}

		n_total_patterns += n_patterns;

		delete pf_in;
	}

	print("Total number of patterns = %d\n", n_total_patterns);
	print("min mean = %g\n", min_mean);
	print("max mean = %g\n", max_mean);
	print("min stdv = %g\n", min_stdv);
	print("max stdv = %g\n", max_stdv);
	
	for(int j = 0 ; j < n_inputs ; j++)
	{
		mean[j] /= (real) n_total_patterns;
		stdv[j] /= (real) n_total_patterns;
		stdv[j] -= mean[j]*mean[j];
		if(stdv[j] <= 0)
		{
			warning("input column %d has a null stdv. Replaced by 1.", j);
			stdv[j] = 1.0;
		}
		else stdv[j] = sqrt(stdv[j]);
	}

	if(savemeanaspgm)
	{
		if(width * height == n_inputs)
		{
			ImageGray *grayimage = new ImageGray(width, height);

			if(max_mean > 1.0)
				grayimage->copyFrom(width, height, mean, "float", 255.0);
			else grayimage->copyFrom(width, height, mean, "float", 1.0);
			grayimage->save("mean.pgm");
			
			delete grayimage;
		}
		else warning("width (%d) x height (%d) != %d, impossible to save the mean as pgm", width, height, n_inputs);
	}
	
	delete [] data;
	delete [] mean;
	delete [] stdv;

	return 0;
}