bindata2blockbindata.cc

torch tracking code, it is a good code

const char *help = "\
progname: bindata2blockbindata.cc\n\
code2html: This program reads a bindata and decomposes it into blocks.\n\
version: Torch3 vision2.0, 2004-2005\n\
(c) Sebastien Marcel ([e-mail])\n";

#include "ImageGray.h"
#include "ipIdentity.h"
#include "ipBlock.h"
#include "DiskXFile.h"
#include "CmdLine.h"

using namespace Torch;

int main(int argc, char *argv[])
{
	char *filename_in;
	int width;
	int height;
	char *filename_out;
	int block_size;
	int block_overlap;
	bool block_to_frame;
	bool verbose;
	bool display;
	bool blocknorm;
	bool unnorm;
	bool norm;
	
	CmdLine cmd;
	cmd.setBOption("write log", false);
	cmd.info(help);
	cmd.addText("\nArguments:");
	cmd.addSCmdArg("imagefile in", &filename_in, "image file in");
	cmd.addICmdArg("width", &width, "width");
	cmd.addICmdArg("height", &height, "height");
	cmd.addSCmdArg("output filename", &filename_out, "output bindata filename");
	cmd.addText("\nBlock decomposition Options:");
	cmd.addBCmdOption("-blocktoframe", &block_to_frame, false, "a block becomes a frame");
	cmd.addICmdOption("-block", &block_size, 8, "block size");
	cmd.addICmdOption("-overlap", &block_overlap, 4, "block overlap");
	cmd.addBCmdOption("-blocknorm", &blocknorm, false, "mean/stdv normalize blocks");
	cmd.addBCmdOption("-unnorm", &unnorm, false, "unnormalize input image");
	cmd.addBCmdOption("-norm", &norm, false, "normalize output image");
	cmd.addText("\nMisc Options:");
	cmd.addBCmdOption("-display", &display, false, "display dct features");
	cmd.addBCmdOption("-verbose", &verbose, false, "verbose");
	cmd.read(argc, argv);
	
	//
	int n_images;
	int image_size;
	DiskXFile *pf_in;
	int n_inputs;
	int n_patterns;
	DiskXFile *pf_out;

	// Load the image
	pf_in = new DiskXFile(filename_in, "r");
	pf_in->read(&n_images, sizeof(int), 1);
	pf_in->read(&image_size, sizeof(int), 1);

	if(image_size != width * height)
		error("Incorrect image size %d != %dx%d.", image_size, width, height);

	Sequence *seqimage = new Sequence(1, image_size);
	
	// feature image machine to apply for each block
		
	int n_block, n_output;
	int rowblocks;
	int colblocks;
	
	// block by block convolution
	ipCore *ip_id = new ipIdentity(block_size, block_size, "gray");
	ipBlock *ip = new ipBlock(width, height, "gray", ip_id, block_size*block_size, block_size, block_overlap);

	n_block = ip->n_block;
        n_output = block_size*block_size;
	rowblocks = colblocks = block_size;
	ip->setBOption("verbose", verbose);

	if(verbose)
	{
		print("-> n_block = %d\n", n_block);
		print("-> n_output = %d\n", n_output);
	}

	//
	pf_out = new DiskXFile(filename_out, "w");
	if(pf_out == NULL)
	{
  		error("Opening bindata file %s", filename_out);      
    		return 0;
	}
	
	//
	int frame_size;
	
	if(block_to_frame)
	{
	  	if(verbose) print("Block to frame: each block becomes a frame.\n");
		
		n_inputs = n_output;
		frame_size = n_inputs;

		n_patterns = n_images * n_block;
	}
	else
	{
		n_inputs = n_block * n_output;
		frame_size = n_inputs;
		n_patterns = n_images;
	}

	if(verbose)
	{
		print("Output file ...\n");
		print("   n_inputs = %d\n", frame_size);
		print("   n_patterns = %d\n", n_patterns);  
	}

	//
	pf_out->write(&n_patterns, sizeof(int), 1);
	pf_out->write(&frame_size, sizeof(int), 1);
	
	//
	real *blocks_mean = NULL;
	real *blocks_stdv = NULL;

	real *data_out = new real [n_inputs];

	for(int p = 0 ; p < n_images ; p++)
	{
	   	pf_in->read(seqimage->frames[0], sizeof(real), image_size);
		
		if(unnorm)
		{
			for(int i = 0 ; i < image_size ; i++)
			{
				int z_ = (int) (seqimage->frames[0][i] * 255.0);

				seqimage->frames[0][i] = z_;
			}
		}

		// Apply the pattern machine to each block of the image
		ip->process(seqimage);

		if(norm)
		{
			for(int b = 0 ; b < n_block ; b++)
			{
				real *src_ = ip->seq_out->frames[b];
				
				for(int i = 0 ; i < n_output ; i++)
					src_[i] /= 255.0;
			}
		}

		if(blocknorm)
		{
			blocks_mean = new real [n_output];
			blocks_stdv = new real [n_output];
			
			for(int i = 0 ; i < n_output ; i++)
			{
				blocks_mean[i] = 0;
				blocks_stdv[i] = 0;
			}
			
			for(int b = 0 ; b < n_block ; b++)
			{
				real *src_ = ip->seq_out->frames[b];
				
				for(int i = 0 ; i < n_output ; i++)
				{
					real z = src_[i];
					blocks_mean[i] += z;
					blocks_stdv[i] += z*z;
				}
			}

			for(int i = 0 ; i < n_output ; i++)
			{
				blocks_mean[i] /= (real) n_block;
				blocks_stdv[i] /= (real) n_block;
				blocks_stdv[i] -= blocks_mean[i]*blocks_mean[i];
				if(blocks_stdv[i] <= 0)
				{
					warning("MeanVarNorm: input column %d has a null stdv. Replaced by 1.", i);
					blocks_stdv[i] = 1.;
				}
				else blocks_stdv[i] = sqrt(blocks_stdv[i]);
			}
			
			for(int b = 0 ; b < n_block ; b++)
			{
				real *src_ = ip->seq_out->frames[b];
				
				for(int i = 0 ; i < n_output ; i++)
					src_[i] = (src_[i] - blocks_mean[i]) / blocks_stdv[i];
			}
		}

		if(block_to_frame)
		{
			for(int b = 0 ; b < n_block ; b++)
			{
			   	int x = (b % rowblocks);
				int y = (b / rowblocks);
				
		   		if(display == true) 
					print("Block %d (%dx%d): ", b, x, y);
			
				real *output_ = ip->seq_out->frames[b];
			
				for(int i = 0 ; i < n_output ; i++)
				{
		   			if(display == true) print("%g ", output_[i]);

		   			data_out[i] = output_[i];
				}

		   		if(display == true) print("\n");
	
				for(int i = 0 ; i <  n_inputs ; i++)
					pf_out->write(&data_out[i], sizeof(real), 1);   
			}
		}
		else
		{
			int j = 0;
		
			for(int b = 0 ; b < n_block ; b++)
			{
		   		if(display == true) print("Block %d: ", b);
			
				real *output_ = ip->seq_out->frames[b];
			
				for(int i = 0 ; i < n_output ; i++)
				{
		   			if(display == true) print("%g ", output_[i]);

		   			data_out[j] = output_[i];
				
					j++;
				}
		   		if(display == true) print("\n");
			}
		
			for(int i = 0 ; i <  n_inputs ; i++)
				pf_out->write(&data_out[i], sizeof(real), 1);   
		}
	}
		
	if(blocknorm)
	{
		delete [] blocks_mean;
		delete [] blocks_stdv;
	}
	
	delete [] data_out;
	delete pf_out;
	delete pf_in;
	

	// Free all
	delete ip_id;
	delete ip;
	delete seqimage;

	return 0;
}