binfacenormalize.cc

torch tracking code, it is a good code

const char *help = "\
progname: binfacenormalize.cc\n\
code2html: This program reads faces in a bindata file and normalize them.\n\
version: Torch3 vision2.0, 2004-2005\n\
(c) Sebastien Marcel ([e-mail])\n";

#include "ipMirror.h"
#include "ipNormBestFitLinear.h"
#include "ipHistoEqual.h"
#include "ipSmoothGaussian3.h"
#include "ipSobel.h"
#include "DiskXFile.h"
#include "CmdLine.h"

using namespace Torch;

int main(int argc, char **argv)
{
	char *filename;
	char *filename_out;
	int width, height;
	float sigma;
	bool mirroradd;
	bool nolinear;
	bool noenhance;
	bool nosmooth;
	bool dosobel;
	real sobel_threshold;
	bool quantize;
	int qmax;
	bool verbose;
	bool norm;
	bool unnorm;
  
	// Construct the command line
  	CmdLine cmd;
	cmd.setBOption("write log", false);
	
  	// Put the help line at the beginning
  	cmd.info(help);

  	cmd.addText("\nArguments:");
  	cmd.addSCmdArg("bindata image filename", &filename, "bindata image filename");
	cmd.addICmdArg("width", &width, "width");
	cmd.addICmdArg("height", &height, "height");
  	cmd.addText("\nOptions:");
	cmd.addSCmdOption("-o", &filename_out, "process.bindata", "bindata output file");
	cmd.addRCmdOption("-sigma", &sigma, 0.25, "Gaussian kernel");
  	cmd.addBCmdOption("-verbose", &verbose, false, "verbose");
	cmd.addBCmdOption("-mirroradd", &mirroradd, false, "mirroradd");
	cmd.addBCmdOption("-nolinear", &nolinear, false, "no linear light correction");
	cmd.addBCmdOption("-noenhance", &noenhance, false, "no enhancement by histogram normalization");
	cmd.addBCmdOption("-nosmooth", &nosmooth, false, "no smoothing");
	cmd.addBCmdOption("-dosobel", &dosobel, false, "apply sobel edge detection");
	cmd.addRCmdOption("-sthreshold", &sobel_threshold, 120, "threshold for Sobel");
	cmd.addBCmdOption("-quantize", &quantize, false, "quantize");
	cmd.addICmdOption("-qmax", &qmax, 64, "qmax levels");
	cmd.addBCmdOption("-norm", &norm, false, "normalize the output");
	cmd.addBCmdOption("-unnorm", &unnorm, false, "unnormalize the input");

	cmd.read(argc, argv);

	if(verbose)
	{
		print("Image info:\n");
		print("   width = %d\n", width);
		print("   height = %d\n", height);
	}


	int n_patterns;
	int n_inputs;

	//
	//
	DiskXFile *file = new DiskXFile(filename, "r");

	file->read(&n_patterns, sizeof(int), 1);
	file->read(&n_inputs, sizeof(int), 1);

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

	if(n_inputs != width * height)
	{
		delete file;
		
		error("Incorrect size provided %d <> %dx%d", n_inputs, width, height);
	}
	
	int P = n_patterns;

	//
	//
	Sequence *input = new Sequence(1, n_inputs);

	//
	//
	DiskXFile *file_out = new DiskXFile(filename_out, "w");
	
	if(mirroradd) n_patterns *= 2;
	file_out->write(&n_patterns, sizeof(int), 1);
	file_out->write(&n_inputs, sizeof(int), 1);

	//
	//
	ipCore *linear = NULL;
	ipCore *enhancing = NULL;
	ipCore *smoothing = NULL;
	ipCore *mirroring = NULL;
	ipCore *sobel = NULL;

	if(!nolinear)
	{
		linear = new ipNormBestFitLinear(width, height, "gray");
		linear->setBOption("verbose", verbose);
	}

	if(!noenhance)
	{
		enhancing = new ipHistoEqual(width, height, "gray");
		enhancing->setBOption("verbose", verbose);
	}

	if(!nosmooth)
	{
		smoothing = new ipSmoothGaussian3(width, height, "gray", sigma);
		smoothing->setBOption("verbose", verbose);
	}

	if(mirroradd)
	{
		mirroring = new ipMirror(width, height, "gray");
		mirroring->setBOption("verbose", verbose);
	}

	if(dosobel)
	{
		sobel = new ipSobel(width, height, "gray");
        	sobel->setBOption("verbose", verbose);
        	sobel->setROption("threshold", sobel_threshold);
	}
	
	Sequence *output = new Sequence(1, n_inputs);
	
	for(int p = 0 ; p < P ; p++)
	{
	   	//
		file->read(input->frames[0], sizeof(real), n_inputs);

		if(unnorm)
			for(int i = 0 ; i < n_inputs ; i++) input->frames[0][i] *= 255.0;

		//
		if(quantize)
			for(int i = 0 ; i < n_inputs ; i++)
			{
				int quantized = (int) (qmax * input->frames[0][i]) / 255;
				input->frames[0][i] = (quantized*255)/qmax;
			}

		output->copy(input);
		
		//
		if(linear != NULL)
		{
			linear->process(output);
			output->copyFrom(linear->seq_out->frames[0]);
		}
		
		//
		if(enhancing != NULL)
		{
			enhancing->process(output);
			output->copyFrom(enhancing->seq_out->frames[0]);
		}
		
		//
		if(smoothing != NULL)
		{
			smoothing->process(output);
			output->copyFrom(smoothing->seq_out->frames[0]);
		}

		if(sobel != NULL)
		{
			sobel->process(output);
			output->copyFrom(sobel->seq_out->frames[2]);
		}
	
		//
		if(norm)
			for(int i = 0 ; i < n_inputs ; i++) output->frames[0][i] /= 255.0;

		file_out->write(output->frames[0], sizeof(real), n_inputs);

		if(mirroradd)
		{
	                mirroring->process(output);

			output->copyFrom(mirroring->seq_out->frames[0]);
		
			file_out->write(output->frames[0], sizeof(real), n_inputs);
		}
	}

	delete input;
	delete output;
	delete file_out;
	delete file;
	if(linear != NULL) delete linear;
	if(enhancing != NULL) delete enhancing;
	if(smoothing != NULL) delete smoothing;
	if(mirroring != NULL) delete mirroring;
	if(dosobel) delete sobel;

	return 0;
}