bindata2pcalda.cc

torch tracking code, it is a good code

const char *help = "\
progname: bindata2pcalda.cc\n\
code2html: This program reads a bindata file, a PCA model and a LDA model and projects patterns into them.\n\
version: Torch3 vision2.0, 2003-2005\n\
(c) Sebastien Marcel ([e-mail])\n";

#include "ImageGray.h"
#include "PCAMachine.h"
#include "LDAMachine.h"
#include "CmdLine.h"

using namespace Torch;

int main(int argc, char *argv[])
{
	char *bindata_filename;
	char *pca_filename;
	char *lda_filename;
	int n_input;
	char *filename_out;
	real variance_pca;
	int n_output_pca;
	real variance_lda;
	int n_output_lda;
	bool verbose;
	int verbose_level;
	bool norm_d_mean;
	CmdLine cmd;
	cmd.setBOption("write log", false);
	
	cmd.info(help);
	cmd.addText("\nArguments:");
	cmd.addSCmdArg("bindata filename", &bindata_filename, "bindata filename");
	cmd.addSCmdArg("pca filename", &pca_filename, "PCA model filename");
	cmd.addSCmdArg("lda filename", &lda_filename, "LDA model filename");
	cmd.addICmdArg("n_input", &n_input, "number of inputs");
	cmd.addText("\nOptions:");
	cmd.addSCmdOption("-o", &filename_out, "pcalda.bindata", "bindata output file");
	cmd.addRCmdOption("-variancepca", &variance_pca, 0.95, "variance (-1 => 100\%)");
	cmd.addICmdOption("-noutputpca", &n_output_pca, -1, "number of outputs for PCA");
	cmd.addRCmdOption("-variancelda", &variance_lda, 0.95, "variance (-1 => 100\%)");
	cmd.addICmdOption("-noutputlda", &n_output_lda, -1, "number of outputs for LDA");
	cmd.addBCmdOption("-dnorm", &norm_d_mean, false, "norm d mean");
	cmd.addBCmdOption("-verbose", &verbose, false, "verbose");
	cmd.addICmdOption("-verbose_level", &verbose_level, 1, "level of verbose");
	cmd.read(argc, argv);

	if(verbose == false) verbose_level = 0;

	//
	PCAMachine *pca_machine = NULL;
	pca_machine = new PCAMachine(n_input);

	if(verbose_level >= 1)
		print("Loading PCA model: %s ...\n", pca_filename);

	DiskXFile *file = NULL;
	file = new DiskXFile(pca_filename, "r");
	pca_machine->loadXFile(file);
	delete file;
	   
	//
	pca_machine->setIOption("verbose_level", verbose_level);
	pca_machine->setROption("variance", variance_pca);
	pca_machine->init();

	if(variance_pca <= 0.0 || n_output_pca <= 0) n_output_pca = pca_machine->n_outputs;
	if(n_output_pca > 0) pca_machine->n_outputs = n_output_pca; 

	//
	LDAMachine *lda_machine = NULL;
	lda_machine = new LDAMachine(n_output_pca, norm_d_mean);

	if(verbose_level >= 1)
		print("Loading LDA model: %s ...\n", lda_filename);

	file = NULL;
	file = new DiskXFile(lda_filename, "r");
	lda_machine->loadXFile(file);
	delete file;

	//
	lda_machine->setIOption("verbose_level", verbose_level);
	lda_machine->setROption("variance", variance_lda);
	lda_machine->init();

	if(variance_lda <= 0.0 || n_output_lda <= 0) n_output_lda = lda_machine->n_outputs;
	if(n_output_lda > 0) lda_machine->n_outputs = n_output_lda; 

	//
	int dimIn;
	int n_patterns;

	DiskXFile *pf = NULL;
	pf = new DiskXFile(bindata_filename, "r");

	pf->read(&n_patterns, sizeof(int), 1);
	pf->read(&dimIn, sizeof(int), 1);

	if(verbose_level >= 1)
	{
		print("n_inputs : %d\n", dimIn);
		print("n_patterns : %d\n", n_patterns);  
	}

	if(n_input > dimIn)
	{
		error("Number of inputs specified (%d) bigger than into the file (%d)", n_input, dimIn);
	   
		delete pf;

		return 0;
	}


	//
	float *realinput = NULL;
        Sequence *seq;

        realinput = new float [n_input];
        seq = new Sequence(&realinput, 1, n_input);	

	//
	DiskXFile *pfOutput = NULL;
	pfOutput = new DiskXFile(filename_out, "w");
	
	//
	if(verbose_level >= 1)
		print("Projection bindata file into PCAxLDA space (%d -> %d) ...\n", n_input, n_output_lda);

	int P = n_patterns;

	pfOutput->write(&P, sizeof(int), 1);
	pfOutput->write(&n_output_lda, sizeof(int), 1);

	for(int p = 0 ; p < P ; p++)
	{
	   	//
	  	for(int i = 0 ; i < n_input ; i++)
			pf->read(&realinput[i], sizeof(float), 1);   

		//
		pca_machine->forward(seq);
		lda_machine->forward(pca_machine->outputs);
			
		float *machine_output = lda_machine->outputs->frames[0];

		//
		float data;
		for(int i = 0 ; i < n_output_lda ; i++)
		{
		   	data = machine_output[i];

			pfOutput->write(&data, sizeof(float), 1);   
		}
	}

	//
	delete pf;
	delete pfOutput;
	
	//
	delete seq;
	delete [] realinput;
	delete pca_machine;
	delete lda_machine;
	

	
  	return 0;
}