binfacenormalize.cc

 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 (marcel@idiap.ch)\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;
 }