//**************************************************************************
//
//      CSE 486 Project #1
//      By Anirudh Modi (anirudh@bart.aero.psu.edu) on 1/29/99-Fri
//	 & Jim Geis (geis@cse.psu.edu)
//	 & Howard Elikan (elikan@cse.psu.edu)
//
//**************************************************************************
//	Running time of algorithm -> O[width x height]
//**************************************************************************
// 	Have implemented the following ->
//		1. Smoothening of histogram to determine minima/maxima
//		2. Basic image operations (+, -, =)
//		3. There is no memory leak
//**************************************************************************
#include <iostream.h>
#include <fstream.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include "image.h"
//**************************************************************************
void modify (GrayImage *image);
int CompareMoments (GrayImage *I1, int c1, GrayImage *I2, int c2);
//**************************************************************************
int main (int argc, char *argv[])
{
if (argc != 2) 
	{
	 cerr << "Syntax: " << argv[0] << " <pbm-image-file>" << endl;
	 exit(-1);
	}

GrayImage image;
char name[50];

image.ReadFromFile(argv[1]);		// Read the image file

image.Histogram( );
image.printHistogram("histogram.out");
image.smoothenHistogram( );
image.printHistogram("histogram1.out");
image.calcHistogramPeaks( );
image.printHistogramPeaks("histpeaks.out");

GrayImage image2(image.width, image.height, image.numLevels);

cout << "Number of minimas = " << image.numMinHist << endl;

for (int i = 0; i < image.numMinHist-1; i++)
	{
	 GrayImage dummy;
	 dummy = image;
	 int m1 = image.getHistMinima(i+1);
	 int m2 = image.getHistMinima(i+2);
	 dummy.Threshold(m1, m2);
	 dummy.ConvertToBinary( );
	 sprintf(name,"%s.peak%d",argv[1],i+1);
	 if (dummy.Area(0) - dummy.numpixels/2 >= 0 && dummy.p[0][0] == 0)
		{
		 cout << "Found background....";
		 dummy.ReverseBinary( );
		 int N = dummy.LabelComponents( );
		 cout << N << " components labeled." << endl;
		 for (int k = 1; k <= N; k++)
			{
	 		 dummy.InvariantMoments(k);
	 		 dummy.MinBoundRectangle(k);
			 dummy.Elongation(k);
			}
		}
	 else
		{
		 dummy.LabelComponents( );
		}
	  
//	 dummy.WriteToFile(name);
	 dummy.WriteLabelsToFile(name);
	 image2 = image2 + dummy;
	}
sprintf(name,"%s.sumofpeaks",argv[1]);
image2.WriteToFile(name);
image2 = image - image2;
sprintf(name,"%s.diff",argv[1]);
image2.WriteToFile(name);

//modify(&image);
//sprintf(name,"%s.modified",argv[1]);
//image.WriteToFile(name);    // Write modified image

cout << "Program done." << endl;
}
//**************************************************************************
void modify (GrayImage *image)
{
for (int i = 0; i < image->width; i++)
	for (int j = 0; j < image->height; j++)
		image->p[i][j] = (unsigned char) 
			(image->p[i][j]*1.0*
			pow(tan(image->p[i][j]*1.0/255.0*3.14159),1));
}
//**************************************************************************