// SingleImage.cpp: implementation of the CSingleImage class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "SingleViewModeling.h"
#include "SingleImage.h"
#include "Matrix.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
/*
	CSingleImage(void ) { m_pdSingleImage = NULL };
	CSingleImage(const char* imagefile);
	virtual ~CSingleImage();
	GLuint GetTexName(void) const {return m_guiTexName;}

	int GetWidth( void )		const { return m_iWidth; }
	int GetHeight( void )		const { return m_iHeight; }
	CString GetImageFileName(void) const{return m_ImageFileName;}

	void Load( const char * imagefile );
	void Store( const char * imagefile );
	void GenTexture( void );
*/
CSingleImage::CSingleImage(const char* imagefile)
{
	Load(imagefile);
	GenTexture( );

	for(int i=0;i<3;i++){
		m_Vx[i]=0;
		m_Vy[i]=0;
		m_Vz[i]=0;
		m_lScale[i] = 0;
		m_l[i] = 0;
	};
	a = 0;
	b = 0;
	x0 = 0;
	y0 = 0;
	A = 0;
    m_maxid = -1;
	m_ViewPointListptr.RemoveAll( );
	m_TextureImageListptr.RemoveAll( );
	
	
    for(i=0;i<3;i++)
		for(int j=0;j<3;j++){
			HMatrix[i][j] = 0;
			HStandardMatrix[i][j] = 0;
		};


}
CSingleImage::~CSingleImage()
{
	if(m_pbSingleImage!=NULL)
		delete m_pbSingleImage;
	::glDeleteTextures( 1, &m_guiTexName );

	m_ViewPointListptr.RemoveAll( );
	m_TextureImageListptr.RemoveAll( );
	
	

}

void CSingleImage::Load( const char * imagefile )
{
	FILE *fp;
	
	if ( ( fp = fopen( imagefile, "rb" ) ) == NULL ) 
	{
		TRACE( "can't open imagefile %s!", imagefile );
		return;
	}

	BITMAPFILEHEADER fileheader;	
	BITMAPINFOHEADER infoheader;

	fread( &fileheader, sizeof( BITMAPFILEHEADER ), 1, fp );
	if ( fileheader.bfOffBits != sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER ) )
		return;

	fread( &infoheader, sizeof( BITMAPINFOHEADER ), 1, fp );
	if ( infoheader.biSize != sizeof( BITMAPINFOHEADER )
		|| infoheader.biPlanes != 1
		|| infoheader.biBitCount != 24 
		|| infoheader.biCompression != BI_RGB /* not compressed */ )
	{
		TRACE( "the iamgeformat is not 24bit uncompressed bitmap!" );
		return;
	}
	
	m_iHeight = infoheader.biHeight;
	m_iWidth = infoheader.biWidth;
	m_pbSingleImage = new unsigned char[m_iHeight * m_iWidth * RGB];

	int offset = ( m_iWidth * RGB ) % 4;
	if ( offset != 0 ) 
		offset = 4 - offset;

	unsigned char *row;
	int dr;
	if ( m_iHeight > 0 )
	{
		row = m_pbSingleImage;
		dr = m_iWidth * RGB;		
	}
	else
	{
		m_iHeight = -m_iHeight;
		row = m_pbSingleImage + ( m_iHeight - 1 ) * m_iWidth * RGB;
		dr = -m_iWidth * RGB;	
	}


	
	unsigned char *buffer = new unsigned char[m_iWidth * RGB];
	int r, c;
	for ( r = 0; r < m_iHeight; r++ )
	{
		
		
		fread( buffer, m_iWidth * RGB, 1, fp );

		unsigned char *b = buffer;
		unsigned char *p = row;
		for ( c = 0; c < m_iWidth; c++ )
		{
			
	
			p[R] = b[B];
			p[G] = b[G];
			p[B] = b[R];
						
			p += RGB;
			b += RGB;
		}
		fseek( fp, offset, SEEK_CUR );
		row += dr;
	}		
	delete[] buffer;
    int isclose =fclose(fp);
	if(isclose!=0) ::AfxMessageBox("The image is not properly colsed....,too bad!");
}

void CSingleImage::GenTexture(void)
{
	GLubyte *pixels = new GLubyte[m_iHeight * m_iWidth * RGB];

	GLubyte *x = pixels;
	unsigned char *p = m_pbSingleImage;

	int r, c;
	for ( r = 0; r < m_iHeight; r++ )
	{
		for ( c = 0; c < m_iWidth; c++ )
		{
			x[R] = p[R];
			x[G] = p[G];
			x[B] = p[B];

			
			p += RGB;
			x += RGB;
		}	
	}	

	::glPixelStorei( GL_UNPACK_ALIGNMENT, 1 );

	::glGenTextures( 1, &m_guiTexName );
	::glBindTexture( GL_TEXTURE_2D, m_guiTexName );
	::glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP );
	::glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP );
	::glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
	::glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR );
	::gluBuild2DMipmaps( GL_TEXTURE_2D, GL_RGB, m_iWidth, m_iHeight, GL_RGB, GL_UNSIGNED_BYTE, pixels );
	::glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL );

	delete[] pixels;

}

void CSingleImage::StoreTextureImage(const char *imagefile, unsigned char *ptextureimageptr, int width, int height)
{

	FILE *fp;
	
	if ( ( fp = fopen( imagefile, "wb" ) ) == NULL ) 
	{
		TRACE( "can't open imagefile %s!", imagefile );
		return;
	}

	BITMAPFILEHEADER fileheader;
	BITMAPINFOHEADER infoheader;

	int offset = (width * RGB ) % 4;
	if ( offset != 0 ) 
		offset = 4 - offset;

	fileheader.bfType = 19778;//BM;
	fileheader.bfSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER )
		+ ( width * RGB + offset ) * height;
	fileheader.bfReserved1 = 0;
	fileheader.bfReserved2 = 0;
	fileheader.bfOffBits = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER );	
	fwrite( &fileheader, sizeof( BITMAPFILEHEADER ), 1, fp );

	infoheader.biSize = sizeof( BITMAPINFOHEADER ); 
    infoheader.biWidth = width; 
    infoheader.biHeight = height; 
    infoheader.biPlanes = 1; 
    infoheader.biBitCount = 24;
    infoheader.biCompression = BI_RGB; 
    infoheader.biSizeImage = 0; 
    infoheader.biXPelsPerMeter = 0; 
    infoheader.biYPelsPerMeter = 0; 
    infoheader.biClrUsed = 0; 
    infoheader.biClrImportant = 0; 
	fwrite( &infoheader, sizeof( BITMAPINFOHEADER ), 1, fp );
	
	unsigned char  *row = ptextureimageptr;
	int dr = width * RGB;
	
	unsigned char *buffer = new unsigned char[width * RGB + offset];
	memset( buffer, 0, width * RGB + offset );

	int r, c;
	for ( r = 0; r < height; r++ )
	{	
		unsigned char *b = buffer;
		unsigned char *p = row;
		for ( c = 0; c < width; c++ )
		{
		
				b[B] = (unsigned char)p[R];
				b[G] = (unsigned char)p[G];
				b[R] = (unsigned char)p[B];
		

			p += RGB;
			b += RGB;
		}		
		fwrite( buffer, width * RGB + offset, 1, fp );

		row += dr;
	}		
	delete[] buffer;

	fclose( fp );

}



void CSingleImage::GenerateImageTexture(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4, int width, int height, const char *imagefilename)
{

		double **a,**transform;
	//	double par[8];
		double xy[8];
		double u[4];
		double v[4];
		double x[4];
		double y[4];



		a = (double **)malloc(8*sizeof(double *));
		for(int k=0;k<8;k++)
			a[k] = (double*)malloc(8*sizeof(double));

		transform = (double **)malloc(3*sizeof(double *));
		for(k=0;k<3;k++)
			transform[k] = (double*)malloc(3*sizeof(double));

		u[0] = 0;
		u[1] = width-1;
		u[2] = width-1;
		u[3] = 0;
		 
		v[0] = 0;
		v[1] = 0;
		v[2] = height-1;
		v[3] = height-1;

		x[0] = x1;
		x[1] = x2;
		x[2] = x3;
		x[3] = x4;

		y[0] = y1;
		y[1] = y2;
		y[2] = y3;
		y[3] = y4;

		for(int i=0;i<4;i++){
			a[i][0] = u[i];
			a[i+4][0] = 0;

			a[i][1] = v[i];
			a[i+4][1] = 0;

			a[i][2] = 1;
			a[i+4][2] = 0;

			a[i][3] = 0;
			a[i+4][3] = u[i];

			a[i][4] = 0;
			a[i+4][4] = v[i];

			a[i][5] = 0;
			a[i+4][5] = 1;

			a[i][6] = -u[i]*x[i];
			a[i+4][6] = -u[i]*y[i];

			a[i][7] = -v[i]*x[i];
			a[i+4][7] = -v[i]*y[i];

			xy[i] = x[i];
			xy[i+4] = y[i];

		};

		CMatrix MatrixItem;
		MatrixItem.getequationanswer(a,xy,8);


        transform[2][2] = 1;
		for( i = 0;i<3;i++)
			for(int j = 0;j<3;j++){
				if((i==2)&&(j==2)){
				//transform[i][j] = xy[i*3+j];
				}else{
				 transform[i][j] = xy[i*3+j];
				};
			};

        unsigned char * pImageBuffer = new unsigned char[width*height*RGB];
		for( i=0;i<width;i++)
			for(int j=0;j<height;j++){
				double xyvector[3];
				double uvvector[3];
				uvvector[0] = i;
				uvvector[1] = j;
				uvvector[2] = 1;
				MatrixItem.matrixvectormultiply(transform,uvvector,xyvector,3,3);
				double xvalue;
				double yvalue;
				xvalue = xyvector[0]/xyvector[2];
				yvalue = xyvector[1]/xyvector[2];
                unsigned char rgb[3];
				BOOL isvalid = GetImageValue(rgb,xvalue,yvalue);
				if(isvalid){
					unsigned char *ptr;
					ptr = &pImageBuffer[j*width*RGB+i*RGB];
					ptr[R] = rgb[R];
					ptr[G] = rgb[G];
					ptr[B] = rgb[B];

				};
			};
             
			StoreTextureImage(imagefilename,pImageBuffer,width,height);

		for( k=0;k<8;k++)
			delete a[k];

	
		for(k=0;k<3;k++)
			delete transform[k];
		delete a;
		delete transform;
         //for(
}		 

BOOL CSingleImage::GetRealImageValue(int x, int y, unsigned char *rgb)
{
	unsigned char *p;
	BOOL isvaluevalid = FALSE;
	if((x>=0)&&(x<m_iWidth)&&(y>=0)&&(y<m_iHeight)){
		p = &m_pbSingleImage[y*m_iWidth*RGB+x*RGB];
		rgb[R] = p[R];
		rgb[G] = p[G];
		rgb[B] = p[B];
	

		isvaluevalid = TRUE;
	}
	return isvaluevalid;

}

BOOL CSingleImage::GetImageValue(unsigned char *rgb, double x, double y)
{
	BOOL isvaluevalid=FALSE;

    CMatrix CaculateMatrix;
	if((x>=0)&&(x<m_iWidth)&&(y>=0)&&(y<m_iHeight)){
		
		isvaluevalid = TRUE;		
		
		int x0,y0,x1,y1;
		x0 = (int)(x);
		y0 = (int)(y);
		x1 = x0+1;
		y1 = y0+1;

		double dx,dy;
		dx = x-x0;
		dy = y-y0;

		unsigned char p00[RGB];
		unsigned char p01[RGB];
		unsigned char p11[RGB];
		unsigned char p10[RGB];
        
		BOOL isvalid=FALSE;
		
		isvalid = GetRealImageValue(x0,y0,p00);
		if(!isvalid) isvaluevalid = FALSE;
		
		isvalid = GetRealImageValue(x0,y1,p01);
        if(!isvalid) isvaluevalid = FALSE;

		isvalid = GetRealImageValue(x1,y1,p11);
		if(!isvalid) isvaluevalid = FALSE;
		
		isvalid = GetRealImageValue(x1,y0,p10);
        if(!isvalid) isvaluevalid = FALSE;

		if(isvaluevalid){
			rgb[R] =(unsigned char) (CaculateMatrix.ibilinearinterpolation(dx,dy,p00[R],p10[R],p01[R],p11[R])+0.5);
			rgb[G] =(unsigned char) (CaculateMatrix.ibilinearinterpolation(dx,dy,p00[G],p10[G],p01[G],p11[G])+0.5);
	    	rgb[B] =(unsigned char) (CaculateMatrix.ibilinearinterpolation(dx,dy,p00[B],p10[B],p01[B],p11[B])+0.5);
		   	
		};

		
	};
	return isvaluevalid;
}

int CSingleImage::GetIndex(int pointid)
{

	int size;
	size = m_ViewPointListptr.GetSize();
	//BOOL Isfind= FALSE;
    int index = -1;
	for(int i=0;i<size;i++){
		if(m_ViewPointListptr[i]->m_pointid==pointid){
	//		Isfind = TURE:
		    index = i;
		};
	};

	return index;

}
