// ViewImage.cpp: implementation of the CViewImage class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "ViewTransformation.h"
#include "ViewImage.h"
#include "Matrix.h"
#include "math.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CViewImage::CViewImage()
{
    m_pdImageRGBD = NULL;
}

CViewImage::~CViewImage()
{  
	if (m_pdImageRGBD!=NULL)
		delete m_pdImageRGBD;

}

int CViewImage::GetImageWidth()
{
	return m_iWidth;
}

int CViewImage::GetImageHeight()
{
	return m_iHeight;
}

CViewImage::CViewImage(const char *datafilename)
{
	m_FileName = datafilename;
	m_iWidth = INPUTIMAGESIZE;
	m_iHeight = INPUTIMAGESIZE;

	FILE *fp;

	fp = fopen(datafilename,"r");
	if(fp ==NULL){
		TRACE("can't open datafile %s!",datafilename);
	}else{

	fscanf(fp,"%lf",&m_dBWXmin);
	fscanf(fp,"%lf",&m_dBWXmax);
	fscanf(fp,"%lf",&m_dBWYmin);
	fscanf(fp,"%lf",&m_dBWYmax);
	fscanf(fp,"%lf",&m_dBWZmin);
	fscanf(fp,"%lf",&m_dBWZmax);

	fscanf(fp,"%lf",&m_dGZmin);
	fscanf(fp,"%lf",&m_dGZmax);
	fscanf(fp,"%lf",&m_dZunk);

	fscanf(fp,"%lf",&m_dBPXmin);
	fscanf(fp,"%lf",&m_dBPXmax);
	fscanf(fp,"%lf",&m_dBPYmin);
	fscanf(fp,"%lf",&m_dBPYmax);

	fscanf(fp,"%lf",&m_dPMax);

	fscanf(fp,"%lf",&m_dCAM[0]);
	fscanf(fp,"%lf",&m_dCAM[1]);
	fscanf(fp,"%lf",&m_dCAM[2]);

	fscanf(fp,"%lf",&m_dPMatrix[0][2]);
	fscanf(fp,"%lf",&m_dPMatrix[1][2]);
	fscanf(fp,"%lf",&m_dPMatrix[2][2]);
//	m_dPMatrix[2][2] = -m_dPMatrix[2][2];

	fscanf(fp,"%lf",&m_dPMatrix[0][0]);
	fscanf(fp,"%lf",&m_dPMatrix[1][0]);
	fscanf(fp,"%lf",&m_dPMatrix[2][0]);
	
	fscanf(fp,"%lf",&m_dPMatrix[0][1]);
	fscanf(fp,"%lf",&m_dPMatrix[1][1]);
	fscanf(fp,"%lf",&m_dPMatrix[2][1]);
    
	m_pdImageRGBD = new double[m_iHeight*m_iWidth*RGBD];

	double *p;
	
	for(int i = 0;i<INPUTIMAGESIZE;i++)
		for(int j=0;j<INPUTIMAGESIZE;j++)
		{
			int xindex;
			int yindex;
             		 
			fscanf(fp,"%d",&xindex);
			fscanf(fp,"%d",&yindex);

		
			p = m_pdImageRGBD+yindex*m_iWidth*RGBD+xindex*RGBD;

			fscanf(fp,"%lf",&p[D]);
		//	p[D] = -p[D];

			fscanf(fp,"%lf",&p[R]);
			fscanf(fp,"%lf",&p[G]);
			fscanf(fp,"%lf",&p[B]);



		}

	fclose(fp);

	}
}

double * CViewImage::GetImageRGBDptr()
{
	return m_pdImageRGBD;
}



void CViewImage::StoreToBMP(const char *imagefile)
{
	FILE *fp;
	
	if ( ( fp = fopen( imagefile, "wb" ) ) == NULL ) 
	{
		TRACE( "can't open imagefile %s!", imagefile );
		return;
	}

	BITMAPFILEHEADER fileheader;
	BITMAPINFOHEADER infoheader;

	int offset = ( m_iWidth * RGB ) % 4;
	if ( offset != 0 ) 
		offset = 4 - offset;

	fileheader.bfType = 19778;//BM;
	fileheader.bfSize = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER )
		+ ( m_iWidth * RGB + offset ) * m_iHeight;
	fileheader.bfReserved1 = 0;
	fileheader.bfReserved2 = 0;
	fileheader.bfOffBits = sizeof( BITMAPFILEHEADER ) + sizeof( BITMAPINFOHEADER );	
	fwrite( &fileheader, sizeof( BITMAPFILEHEADER ), 1, fp );

	infoheader.biSize = sizeof( BITMAPINFOHEADER ); 
    infoheader.biWidth = m_iWidth; 
    infoheader.biHeight = m_iHeight; 
    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 );
	
	double *row = m_pdImageRGBD;
	int dr = m_iWidth * RGBD;
	
	unsigned char *buffer = new unsigned char[m_iWidth * RGB + offset];
	memset( buffer, 0, m_iWidth * RGB + offset );

	int r, c;
	for ( r = 0; r < m_iHeight; r++ )
	{	
		unsigned char *b = buffer;
		double *p = row;
		for ( c = 0; c < m_iWidth; c++ )
		{
		
				b[B] = (unsigned char)p[R];
				b[G] = (unsigned char)p[G];
				b[R] = (unsigned char)p[B];
		

			p += RGBD;
			b += RGB;
		}		
		fwrite( buffer, m_iWidth * RGB + offset, 1, fp );

		row += dr;
	}		
	delete[] buffer;

	fclose( fp );

}

void CViewImage::caculateu2v2(double u1, double v1, double p1[][3], double p2[][3], double cc1[3], double cc2[3], double delta1,double *u2,double *v2)
{

	double a1[3];
	double b1[3];
	double c1[3];
	double a2[2];
	double b2[3];
	double c2[3];
	double c1c2[3];

	double b2c2[3];
	double a2b2[3];
	double c2a2[3];

	double u2w;
	double v2w;
	double w;
	for(int i=0;i<3;i++){
		a1[i] = p1[i][0];
		b1[i] = p1[i][1];
		c1[i] = p1[i][2];

		a2[i] = p2[i][0];
		b2[i] = p2[i][1];
		c2[i] = p2[i][2];
	};
	
	CMatrix matrixitem;

	matrixitem.getvectorcrossproduct(b2,c2,b2c2);
	matrixitem.getvectorcrossproduct(a2,b2,a2b2);
	matrixitem.getvectorcrossproduct(c2,a2,c2a2);

	for(i=0;i<3;i++){
		c1c2[i] = cc1[i]-cc2[i];
	};

	double a1b2c2,b1b2c2,c1b2c2,c1c2b2c2;
	
	a1b2c2 = matrixitem.getdotproduct(a1,b2c2);
	b1b2c2 = matrixitem.getdotproduct(b1,b2c2);
	c1b2c2 = matrixitem.getdotproduct(c1,b2c2);
	c1c2b2c2 = matrixitem.getdotproduct(c1c2,b2c2);
    
	u2w = a1b2c2*u1+b1b2c2*v1+c1b2c2+c1c2b2c2*delta1;

	double a1c2a2,b1c2a2,c1c2a2,c1c2c2a2;
	a1c2a2 = matrixitem.getdotproduct(a1,c2a2);
	b1c2a2 = matrixitem.getdotproduct(b1,c2a2);
	c1c2a2 = matrixitem.getdotproduct(c1,c2a2);
	c1c2c2a2 = matrixitem.getdotproduct(c1c2,c2a2);

	v2w = a1c2a2*u1+b1c2a2*v1+c1c2a2+c1c2c2a2*delta1;

	double a1a2b2,b1a2b2,c1a2b2,c1c2a2b2;
	a1a2b2 =matrixitem.getdotproduct(a1,a2b2);
	b1a2b2 =matrixitem.getdotproduct(b1,a2b2);
	c1a2b2 =matrixitem.getdotproduct(c1,a2b2);
	c1c2a2b2 =matrixitem.getdotproduct(c1c2,a2b2);

	w = a1a2b2*u1+b1a2b2*v1+c1a2b2+c1c2a2b2*delta1;

	ASSERT(fabs(w)>TINY);
	*u2 = u2w/w;
	*v2 = v2w/w;





	

}

void CViewImage::getmaxminvalue(double x1, double y1, double x2, double y2, double x3, double y3, double *xmin, double *xmax, double *ymin, double *ymax)
{

	double xxmax,xxmin,yymax,yymin;

	xxmax = (x1>x2)? x1:x2;
	xxmax = (x3>xxmax)?x3:xxmax;

	xxmin = (x1<x2)? x1:x2;
	xxmin = (x3<xxmin)?x3:xxmin;

	yymax = (y1>y2)? y1:y2;
	yymax = (y3>yymax)?y3:yymax;

	yymin = (y1<y2)? y1:y2;
	yymin = (y3<yymin)?y3:yymin;
     
	*xmin = xxmin;
	*ymin = yymin;
	*xmax = xxmax;
	*ymax = yymax; 

}
CViewImage::CViewImage(double xangle,double yangle,double zangle,double zoomvalue,CViewImage *pViewSourceImage)
{
	double **xrotatematrix,**yrotatematrix,**zrotatematrix;
	
	xrotatematrix = (double **)malloc(3*sizeof(double *));
	for(int k=0;k<3;k++)
		xrotatematrix[k] = (double*)malloc(3*sizeof(double));

	yrotatematrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		yrotatematrix[k] = (double*)malloc(3*sizeof(double));

	zrotatematrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		zrotatematrix[k] = (double*)malloc(3*sizeof(double));
       
	double * c1c2vector,*eyevector,*WtoOriginVector,*ChangedVector;
	c1c2vector = (double *) malloc(3*sizeof(double));
    eyevector = (double *)malloc(3*sizeof(double));
	WtoOriginVector = (double *) malloc(3*sizeof(double));
    ChangedVector = (double *)malloc(3*sizeof(double));


	double ** P2matrix,**R1matrix,**R2matrix,**P1matrix,**P1inversematrix,**PP2matrix,**RR2matrix;



	P2matrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		P2matrix[k] = (double*)malloc(3*sizeof(double));

	PP2matrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		PP2matrix[k] = (double*)malloc(3*sizeof(double));
	
	P1inversematrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		P1inversematrix[k] = (double*)malloc(3*sizeof(double));

	P1matrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		P1matrix[k] = (double*)malloc(3*sizeof(double));

    R1matrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		R1matrix[k] = (double*)malloc(3*sizeof(double));

	R2matrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		R2matrix[k] = (double*)malloc(3*sizeof(double));

	RR2matrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		RR2matrix[k] = (double*)malloc(3*sizeof(double));


	//initialize
	for(int i = 0;i<3;i++)
		for(int j = 0;j<3;j++){
			xrotatematrix[i][j] = 0.0;
			yrotatematrix[i][j] = 0.0;
			zrotatematrix[i][j] = 0.0;
			P1matrix[i][j] = 0.0;
			P2matrix[i][j] = 0.0;
			P1inversematrix[i][j] = 0.0;
			R1matrix[i][j] = 0.0;
			R2matrix[i][j] = 0.0;
			RR2matrix[i][j] = 0.0;
		};

	for(i =0;i<3;i++){
			c1c2vector[i] = 0.0;
			eyevector[i] = 0.0;
			WtoOriginVector[i]=0.0;
            ChangedVector[i] = 0.0;

		};
	
	//double xangle,yangle,zangle;
	xangle = xangle*2*PIE/360.0;
	yangle = yangle*2*PIE/360.0;
	zangle = zangle*2*PIE/360.0;

    CMatrix MatrixItem;

	

	for( i=0;i<3;i++)
		for( int j=0;j<3;j++){
				P1matrix[i][j] = pViewSourceImage->m_dPMatrix[i][j]; 
				
			};

    for(i=0;i<3;i++)
		for( int j=0;j<3;j++){
			P2matrix[i][j] = P1matrix[i][j];
			
		};

            //caculate p2 =R*p1
			xrotatematrix[0][0] = 1;
			xrotatematrix[1][1] = cos(xangle);
			xrotatematrix[1][2] = -sin(xangle);
			xrotatematrix[2][1] = sin(xangle);
			xrotatematrix[2][2] = cos(xangle);

			yrotatematrix[0][0] = cos(yangle);
			yrotatematrix[0][2] = sin(yangle);
			yrotatematrix[1][1] = 1;
			yrotatematrix[2][0] = -sin(yangle);
			yrotatematrix[2][2] = cos(yangle);

			zrotatematrix[0][0] = cos(zangle);
			zrotatematrix[0][1] = -sin(zangle);
			zrotatematrix[1][0] = sin(zangle);
			zrotatematrix[1][1] = cos(zangle);
			zrotatematrix[2][2] = 1;


            MatrixItem.matrixmultiply(xrotatematrix,yrotatematrix,R1matrix,3,3,3);
			MatrixItem.matrixmultiply(R1matrix,zrotatematrix,R2matrix,3,3,3);

	//		MatrixItem.matrixmultiply(R2matrix,P1matrix,P2matrix,3,3,3);
//          MatrixItem.inversematrix(P2matrix,P2inversematrix,3);

			
			double w3[3];
			w3[0] = (pViewSourceImage->m_dBWXmax+pViewSourceImage->m_dBWXmin)/2.0;
			w3[1] = (pViewSourceImage->m_dBWYmax+pViewSourceImage->m_dBWYmin)/2.0;
			w3[2] = (pViewSourceImage->m_dBWZmax+pViewSourceImage->m_dBWZmin)/2.0;

			WtoOriginVector[0] = pViewSourceImage->m_dCAM[0]-w3[0];
            WtoOriginVector[1] = pViewSourceImage->m_dCAM[1]-w3[1];
			WtoOriginVector[2] = pViewSourceImage->m_dCAM[2]-w3[2];
			MatrixItem.matrixvectormultiply(R2matrix,WtoOriginVector,ChangedVector,3,3);

			for(i=0;i<3;i++){
				ChangedVector[i] = ChangedVector[i]*zoomvalue;
			};

			double cameraposition[3];
			for(i = 0;i<3;i++){
				cameraposition[i]=ChangedVector[i]+w3[i];
			};

			MatrixItem.inversematrix(P1matrix,P1inversematrix,3);
            
			for(i=0;i<3;i++){
				c1c2vector[i] = cameraposition[i]-pViewSourceImage->m_dCAM[i];
			};
		

			MatrixItem.matrixvectormultiply(P1inversematrix,c1c2vector,eyevector,3,3);
		    
			double WValue;
			WValue = eyevector[2];
			double xvalue,yvalue;
			ASSERT(fabs(WValue)>TINY);
			xvalue = eyevector[0]/eyevector[2];
			yvalue = eyevector[1]/eyevector[2];
            
			int size;
			size = INPUTIMAGESIZE-1;
			int xdvalue,ydvalue;
            xdvalue = (int)(xvalue+0.5);
			ydvalue = (int)(yvalue+0.5);

			int zone;
		

			if((xdvalue<0)&&(ydvalue>=size))
				zone = 1;
			if((xdvalue>=0)&&(xdvalue<size)&&(ydvalue>=size))
				zone = 2;
			if((xdvalue>=size)&&(ydvalue>=size))
				zone = 3;
			if((xdvalue<0)&&(ydvalue>=0)&&(ydvalue<size))
				zone = 4;
			if((xdvalue>=0)&&(xdvalue<size)&&(ydvalue>=0)&&(ydvalue<size))
				zone = 5;
			if((xdvalue>=size)&&(ydvalue>=0)&&(ydvalue<size))
				zone = 6;
			if((xdvalue<0)&&(ydvalue<0))
				zone = 7;
			if((xdvalue>=0)&&(xdvalue<size)&&(ydvalue<0))
				zone = 8;
			if((xdvalue>=size)&&(ydvalue<0))
				zone = 9;

			if (WValue<0) zone = -zone;
			

//now collecting data.
			//collecting P2matrix
			//collecting Camera2 value
			for(i =0;i<3;i++){
				m_dCAM[i] = cameraposition[i];
			};

			//caculate P2Matrix;

	/*		for(i=0;i<3;i++)
				for(int j=0;j<3;j++){
					P2matrix[i][j] = P2matrix[i][j]-w3[i];
				};
*/
            MatrixItem.inversematrix(R2matrix,RR2matrix,3);

            MatrixItem.matrixmultiply(RR2matrix,P2matrix,PP2matrix,3,3,3);

/*			for(i=0;i<3;i++)
				for(int j=0;j<3;j++){
					PP2matrix[i][j] = PP2matrix[i][j]+w3[i];
				};
*/
			for( i=0;i<3;i++)
				for(int j=0;j<3;j++)
				{
					m_dPMatrix[i][j] = PP2matrix[i][j];
				};

			m_pdImageRGBD = NULL;
			m_dBWXmin = pViewSourceImage->m_dBWXmin;
			m_dBWXmax = pViewSourceImage->m_dBWXmax;
			m_dBWYmin = pViewSourceImage->m_dBWYmin;
			m_dBWYmax = pViewSourceImage->m_dBWYmax;
	        m_dBWZmin = pViewSourceImage->m_dBWZmin;
			m_dBWZmax = pViewSourceImage->m_dBWZmax;

			m_dGZmin = pViewSourceImage->m_dGZmin;
			m_dGZmax = pViewSourceImage->m_dGZmax;
	        m_dBPXmin=pViewSourceImage->m_dBPXmin;
			m_dBPXmax=pViewSourceImage->m_dBPXmax;
			m_dBPYmin=pViewSourceImage->m_dBPYmin;
			m_dBPYmax=pViewSourceImage->m_dBPYmax;
            m_dPMax = pViewSourceImage->m_dPMax;
			m_dZunk = pViewSourceImage->m_dZunk;


	for(i=0;i<3;i++){
		delete xrotatematrix[i];
		delete yrotatematrix[i];
		delete zrotatematrix[i];
        delete P2matrix[i];
		delete P1matrix[i];
		delete P1inversematrix[i];
		delete R1matrix[i];
		delete R2matrix[i];
		delete PP2matrix[i];
		delete RR2matrix[i];
	};

	delete c1c2vector;
	delete eyevector;
	delete xrotatematrix;
	delete yrotatematrix;
	delete zrotatematrix;
	delete P2matrix;
	delete P1matrix;
	delete P1inversematrix;
	delete R1matrix;
	delete R2matrix;
	delete PP2matrix;
	delete RR2matrix;

	MakeDataComplete(pViewSourceImage,zone,xdvalue,ydvalue);

}
CViewImage::CViewImage(double xangle,double yangle,double zangle,double camera2[3],CViewImage *pViewSourceImage)
{
	
    
    double **xrotatematrix,**yrotatematrix,**zrotatematrix;
	xrotatematrix = (double **)malloc(3*sizeof(double *));
	for(int k=0;k<3;k++)
		xrotatematrix[k] = (double*)malloc(3*sizeof(double));

	yrotatematrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		yrotatematrix[k] = (double*)malloc(3*sizeof(double));

	zrotatematrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		zrotatematrix[k] = (double*)malloc(3*sizeof(double));
       
	double * c1c2vector,*eyevector;
	c1c2vector = (double *) malloc(3*sizeof(double));
    eyevector = (double *)malloc(3*sizeof(double));

	double ** P2matrix,**R1matrix,**R2matrix,**P1matrix,**P1inversematrix;



	P2matrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		P2matrix[k] = (double*)malloc(3*sizeof(double));
	
	P1inversematrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		P1inversematrix[k] = (double*)malloc(3*sizeof(double));

	P1matrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		P1matrix[k] = (double*)malloc(3*sizeof(double));

    R1matrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		R1matrix[k] = (double*)malloc(3*sizeof(double));

	R2matrix = (double **)malloc(3*sizeof(double *));
	for( k=0;k<3;k++)
		R2matrix[k] = (double*)malloc(3*sizeof(double));


	//initialize
	for(int i = 0;i<3;i++)
		for(int j = 0;j<3;j++){
			xrotatematrix[i][j] = 0.0;
			yrotatematrix[i][j] = 0.0;
			zrotatematrix[i][j] = 0.0;
			P1matrix[i][j] = 0.0;
			P2matrix[i][j] = 0.0;
			P1inversematrix[i][j] = 0.0;
			R1matrix[i][j] = 0.0;
			R2matrix[i][j] = 0.0;
		};

	for(i =0;i<3;i++){
			c1c2vector[i] = 0.0;
			eyevector[i] = 0.0;
		};
	
	//double xangle,yangle,zangle;
	xangle = xangle*2*PIE/360.0;
	yangle = yangle*2*PIE/360.0;
	zangle = zangle*2*PIE/360.0;

    CMatrix MatrixItem;

	

	for( i=0;i<3;i++)
		for( int j=0;j<3;j++){
				P1matrix[i][j] = pViewSourceImage->m_dPMatrix[i][j]; 
				
			};
            //caculate p2 =R*p1
			xrotatematrix[0][0] = 1;
			xrotatematrix[1][1] = cos(xangle);
			xrotatematrix[1][2] = -sin(xangle);
			xrotatematrix[2][1] = sin(xangle);
			xrotatematrix[2][2] = cos(xangle);

			yrotatematrix[0][0] = cos(yangle);
			yrotatematrix[0][2] = sin(yangle);
			yrotatematrix[1][1] = 1;
			yrotatematrix[2][0] = -sin(yangle);
			yrotatematrix[2][2] = cos(yangle);

			zrotatematrix[0][0] = cos(zangle);
			zrotatematrix[0][1] = -sin(zangle);
			zrotatematrix[1][0] = sin(zangle);
			zrotatematrix[1][1] = cos(zangle);
			zrotatematrix[2][2] = 1;


            MatrixItem.matrixmultiply(xrotatematrix,yrotatematrix,R1matrix,3,3,3);
			MatrixItem.matrixmultiply(R1matrix,zrotatematrix,R2matrix,3,3,3);

			MatrixItem.matrixmultiply(R2matrix,P1matrix,P2matrix,3,3,3);
//          MatrixItem.inversematrix(P2matrix,P2inversematrix,3);

			MatrixItem.inversematrix(P1matrix,P1inversematrix,3);
            
			for(i=0;i<3;i++){
				c1c2vector[i] = camera2[i]-pViewSourceImage->m_dCAM[i];
			};
		

			MatrixItem.matrixvectormultiply(P1inversematrix,c1c2vector,eyevector,3,3);
		    
			double WValue;
			WValue = eyevector[2];
			double xvalue,yvalue;
			ASSERT(fabs(WValue)>TINY);
			xvalue = eyevector[0]/eyevector[2];
			yvalue = eyevector[1]/eyevector[2];
            
			int size;
			size = INPUTIMAGESIZE-1;
			int xdvalue,ydvalue;
            xdvalue = (int)(xvalue+0.5);
			ydvalue = (int)(yvalue+0.5);

			int zone;
		

			if((xdvalue<0)&&(ydvalue>=size))
				zone = 1;
			if((xdvalue>=0)&&(xdvalue<size)&&(ydvalue>=size))
				zone = 2;
			if((xdvalue>=size)&&(ydvalue>=size))
				zone = 3;
			if((xdvalue<0)&&(ydvalue>=0)&&(ydvalue<size))
				zone = 4;
			if((xdvalue>=0)&&(xdvalue<size)&&(ydvalue>=0)&&(ydvalue<size))
				zone = 5;
			if((xdvalue>=size)&&(ydvalue>=0)&&(ydvalue<size))
				zone = 6;
			if((xdvalue<0)&&(ydvalue<0))
				zone = 7;
			if((xdvalue>=0)&&(xdvalue<size)&&(ydvalue<0))
				zone = 8;
			if((xdvalue>=size)&&(ydvalue<0))
				zone = 9;

			if (WValue<0) zone = -zone;
			

//now collecting data.
			//collecting P2matrix
			//collecting Camera2 value
			for(i =0;i<3;i++){
				m_dCAM[i] = camera2[i];
			};

			for( i=0;i<3;i++)
				for(int j=0;j<3;j++)
				{
					m_dPMatrix[i][j] = P2matrix[i][j];
				};

			m_pdImageRGBD = NULL;
			m_dBWXmin = pViewSourceImage->m_dBWXmin;
			m_dBWXmax = pViewSourceImage->m_dBWXmax;
			m_dBWYmin = pViewSourceImage->m_dBWYmin;
			m_dBWYmax = pViewSourceImage->m_dBWYmax;
	        m_dBWZmin = pViewSourceImage->m_dBWZmin;
			m_dBWZmax = pViewSourceImage->m_dBWZmax;

			m_dGZmin = pViewSourceImage->m_dGZmin;
			m_dGZmax = pViewSourceImage->m_dGZmax;
	        m_dBPXmin=pViewSourceImage->m_dBPXmin;
			m_dBPXmax=pViewSourceImage->m_dBPXmax;
			m_dBPYmin=pViewSourceImage->m_dBPYmin;
			m_dBPYmax=pViewSourceImage->m_dBPYmax;
            m_dPMax = pViewSourceImage->m_dPMax;
			m_dZunk = pViewSourceImage->m_dZunk;


	for(i=0;i<3;i++){
		delete xrotatematrix[i];
		delete yrotatematrix[i];
		delete zrotatematrix[i];
        delete P2matrix[i];
		delete P1matrix[i];
		delete P1inversematrix[i];
		delete R1matrix[i];
		delete R2matrix[i];
	};

	delete c1c2vector;
	delete eyevector;
	delete xrotatematrix;
	delete yrotatematrix;
	delete zrotatematrix;
	delete P2matrix;
	delete P1matrix;
	delete P1inversematrix;
	delete R1matrix;
	delete R2matrix;

	MakeDataComplete(pViewSourceImage,zone,xdvalue,ydvalue);
}



void CViewImage::MakeDataComplete(CViewImage * pViewSourceImage, int zone,int xdvalue, int ydvalue)
{

	double pp1[3][3];
	double pp2[3][3];
	double cc1[3];
	double cc2[3];

	double *imageRGBDptr;
	imageRGBDptr = pViewSourceImage->GetImageRGBDptr( );
	
	for(int i = 0;i<3;i++)
		for(int j= 0;j<3;j++)
		{
		    pp1[i][j] = pViewSourceImage->m_dPMatrix[i][j];
		    pp2[i][j] = m_dPMatrix[i][j];
        };

	for( i= 0;i<3;i++)
	{
		cc1[i] = pViewSourceImage->m_dCAM[i];
		cc2[i] = m_dCAM[i];
		
	};



	double x_dmin,y_dmin,x_dmax,y_dmax;

	int x_imin,y_imin,x_imax,y_imax;

    GetMinMaxValueofWarpedImage(pp1,pp2,cc1,cc2,imageRGBDptr, &x_dmin, &x_dmax, &y_dmin, &y_dmax);

	x_imin = (int)(x_dmin-1);
	y_imin = (int)(y_dmin-1);

	x_imax = (int)(x_dmax+1);
	y_imax = (int)(y_dmax+1);

	int width,height;
	width = x_imax-x_imin+1;
	height = y_imax-y_imin+1;
	//collecting data for DESTIMAGE
	m_iWidth = width;
	m_iHeight = height;

	double * newimageRGBDptr;

	newimageRGBDptr = new double[width*height*RGBD];

	m_pdImageRGBD = newimageRGBDptr;

	double *ptr;

	//initialize
	for( i = 0;i<width;i++)
		for(int j=0;j<height;j++)
		{
			
		
			ptr = m_pdImageRGBD+j*m_iWidth*RGBD+i*RGBD;

		    ptr[R] = 0;
			ptr[G] = 0;
			ptr[B] = 0;
		    ptr[D] = 1;


		}



	switch(zone){
	case 1: Case1Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case 2: Case2Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case 3: Case3Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case 4: Case4Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case 5: Case5Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case 6: Case6Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case 7: Case7Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case 8: Case8Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case 9: Case9Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
	case -1: CaseN1Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case -2: CaseN2Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case -3: CaseN3Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case -4: CaseN4Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case -5: CaseN5Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case -6: CaseN6Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case -7: CaseN7Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case -8: CaseN8Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;
    case -9: CaseN9Warp(pViewSourceImage,xdvalue,ydvalue,x_imin,y_imin);
		    break;

    default: AfxMessageBox("Wrong Zone id");

    
	}
	


}

void CViewImage::StoreImageWidth(int width)
{
	m_iWidth = width;

}

void CViewImage::StoreImageHeight(int height)
{
	m_iHeight = height;

}

void CViewImage::StoreImagePtr(double *imageptr)
{

	if(m_pdImageRGBD!= NULL) delete m_pdImageRGBD;
	m_pdImageRGBD = imageptr;

}

void CViewImage::WarpDirection45(CViewImage *pSourceImageView, int cxmin, int cymin, int cxmax, int cymax,int x_imin,int y_imin)
{

	if((cxmin!=cxmax)&&(cymin!=cymax)){
		for(int i=cxmin;i<cxmax;i++)
			for(int j=cymin;j<cymax;j++){
				WarpPriorityTriangle( i, j,i+1,j,i,j+1,x_imin, y_imin, pSourceImageView);
				WarpPriorityTriangle(i,j+1,i+1,j,i+1,j+1,x_imin, y_imin, pSourceImageView);

			

			};

	}else{
	};


}

void CViewImage::WarpDirection135(CViewImage *pSourceImageView, int cxmin, int cymin, int cxmax, int cymax,int x_imin,int y_imin)
{

	if((cxmin!=cxmax)&&(cymin!=cymax)){
		for(int i=cxmax;i>cxmin;i--)
			for(int j=cymin;j<cymax;j++){
				WarpPriorityTriangle( i, j,i-1,j,i,j+1,x_imin, y_imin, pSourceImageView);
				WarpPriorityTriangle(i-1,j,i,j+1,i-1,j+1,x_imin, y_imin, pSourceImageView);

			

			};

	}else{
	};
}

void CViewImage::WarpDirection225(CViewImage *pSourceImageView, int cxmin, int cymin, int cxmax, int cymax,int x_imin,int y_imin)
{

	if((cxmin!=cxmax)&&(cymin!=cymax)){
		for(int i=cxmax;i>cxmin;i--)
			for(int j=cymax;j>cymin;j--){
				WarpPriorityTriangle( i, j,i-1,j,i,j-1,x_imin, y_imin, pSourceImageView);
				WarpPriorityTriangle(i-1,j,i,j-1,i-1,j-1,x_imin, y_imin, pSourceImageView);

			

			};

	}else{
	};
}

void CViewImage::WarpDirection315(CViewImage *pSourceImageView, int cxmin, int cymin, int cxmax, int cymax,int x_imin,int y_imin)
{

	if((cxmin!=cxmax)&&(cymin!=cymax)){
		for(int i=cxmin;i<cxmax;i++)
			for(int j=cymax;j>cymin;j--){
				WarpPriorityTriangle( i, j,i,j-1,i+1,j,x_imin, y_imin, pSourceImageView);
				WarpPriorityTriangle(i,j-1,i+1,j,i+1,j-1,x_imin, y_imin, pSourceImageView);

			

			};

	}else{
	};
}

void CViewImage::WarpPriorityTriangle(int x1, int y1, int x2, int y2, int x3, int y3, int x_imin, int y_imin, CViewImage *pSourceImageView)
{

	double pp1[3][3];
	double pp2[3][3];
	double cc1[3];
	double cc2[3];

	double *imageRGBDptr;
	imageRGBDptr = pSourceImageView->GetImageRGBDptr( );
	
	for(int i = 0;i<3;i++)
		for(int j= 0;j<3;j++)
		{
		    pp1[i][j] = pSourceImageView->m_dPMatrix[i][j];
		    pp2[i][j] = m_dPMatrix[i][j];
        };

	for( i= 0;i<3;i++)
	{
		cc1[i] = pSourceImageView->m_dCAM[i];
		cc2[i] = m_dCAM[i];
		
	};

	double * p;
	double D1,D2,D3;
	double R1,R2,R3;
	double G1,G2,G3;
	double B1,B2,B3;

	double Xdest1,Ydest1;
	double Xdest2,Ydest2;
	double Xdest3,Ydest3;

	double  Triangleminx,Trianglemaxx,Triangleminy,Trianglemaxy;

	
	p = imageRGBDptr+y1*INPUTIMAGESIZE*RGBD+x1*RGBD;
	R1 = p[R];
	G1 = p[G];
	B1 = p[B];
	D1 = p[D];

	p = imageRGBDptr+y2*INPUTIMAGESIZE*RGBD+x2*RGBD;
	R2 = p[R];
	G2 = p[G];
	B2 = p[B];
	D2 = p[D];

	p = imageRGBDptr+y3*INPUTIMAGESIZE*RGBD+x3*RGBD;
	R3 = p[R];
	G3 = p[G];
	B3 = p[B];
	D3 = p[D];



    caculateu2v2(x1,y1,pp1,pp2,cc1,cc2,D1,&Xdest1,&Ydest1);
	caculateu2v2(x2,y2,pp1,pp2,cc1,cc2,D2,&Xdest2,&Ydest2);
	caculateu2v2(x3,y3,pp1,pp2,cc1,cc2,D3,&Xdest3,&Ydest3);

	CMatrix matrixcaculate;
	BOOL IsValidTriangle;
	IsValidTriangle  = matrixcaculate.isvalidtriangle(Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
    if(IsValidTriangle){
		getmaxminvalue(Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3,&Triangleminx,&Trianglemaxx,&Triangleminy,&Trianglemaxy);
	    int drawstate=0;
		BOOL IsFinish=FALSE;
		if((!IsFinish)&&(fabs(Xdest1-Triangleminx)<TINY)&&(fabs(Ydest1-Triangleminy)<TINY)){
			drawstate =0;
			IsFinish = TRUE;
		};
		if((!IsFinish)&&(fabs(Xdest1-Triangleminx)<TINY)&&(fabs(Ydest1-Trianglemaxy)<TINY)){
			drawstate =1;
			IsFinish = TRUE;
		};
		if((!IsFinish)&&(fabs(Xdest1-Trianglemaxx)<TINY)&&(fabs(Ydest1-Triangleminy)<TINY)){
			drawstate =2;
			IsFinish = TRUE;
		};
		if((!IsFinish)&&(fabs(Xdest1-Trianglemaxx)<TINY)&&(fabs(Ydest1-Trianglemaxy)<TINY)){
			drawstate =3;
			IsFinish = TRUE;
		};

		if((!IsFinish)&&(fabs(Xdest1-Triangleminx)<TINY)){
			drawstate =0;
			IsFinish = TRUE;
		};

		if((!IsFinish)&&(fabs(Xdest1-Trianglemaxx)<TINY)){
			drawstate =2;
			IsFinish = TRUE;
		};
		if((!IsFinish)&&(fabs(Ydest1-Triangleminy)<TINY)){
			drawstate =2;
			IsFinish = TRUE;
		};
		if((!IsFinish)&&(fabs(Ydest1-Trianglemaxy)<TINY)){
			drawstate =3;
			IsFinish = TRUE;
		};
		
		
		int squarexmin,squarexmax,squareymin,squareymax;



		squarexmin = (int)(Triangleminx-0.5);
		squareymin = (int)(Triangleminy-0.5);
		squarexmax = (int)(Trianglemaxx+1);
		squareymax = (int)(Trianglemaxy+1);

		

		if (drawstate==0){
			for(int m=squarexmin;m<=squarexmax;m++)
			for(int n=squareymin;n<=squareymax;n++)
			{
				BOOL IsInTriangle=FALSE;
				
				IsInTriangle = matrixcaculate.IsPointInTriangle(m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
				if(IsInTriangle){
					double RR,GG,BB;
					RR =matrixcaculate.getaveragevalue(R1,R2,R3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
					GG =matrixcaculate.getaveragevalue(G1,G2,G3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
					BB =matrixcaculate.getaveragevalue(B1,B2,B3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);

					if((RR>=0)&&(GG>=0)&&(BB>=0)){			
					double *pp;
					if(((n-y_imin)<=(m_iHeight-1))&&((m-x_imin)<=(m_iWidth-1))&&((n-y_imin)>=0)&&((m-x_imin)>=0)){
					pp = m_pdImageRGBD+(n-y_imin)*m_iWidth*RGBD+(m-x_imin)*RGBD;
                    pp[R] = RR;
					pp[G] = GG;
					pp[B] = BB;
					};
					}else{};


				}else{
				};

			}
		}else if (drawstate==1){

			for(int m=squarexmin;m<=squarexmax;m++)
			for(int n=squareymax;n>=squareymin;n--)
			{
				BOOL IsInTriangle=FALSE;
				
				IsInTriangle = matrixcaculate.IsPointInTriangle(m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
				if(IsInTriangle){
					double RR,GG,BB;
					RR =matrixcaculate.getaveragevalue(R1,R2,R3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
					GG =matrixcaculate.getaveragevalue(G1,G2,G3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
					BB =matrixcaculate.getaveragevalue(B1,B2,B3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);

					if((RR>=0)&&(GG>=0)&&(BB>=0)){			
					double *pp;
					if(((n-y_imin)<=(m_iHeight-1))&&((m-x_imin)<=(m_iWidth-1))&&((n-y_imin)>=0)&&((m-x_imin)>=0)){
					pp = m_pdImageRGBD+(n-y_imin)*m_iWidth*RGBD+(m-x_imin)*RGBD;
                    pp[R] = RR;
					pp[G] = GG;
					pp[B] = BB;
                    }
					}else{};


				}else{
				};

			}
		}else if (drawstate==2){
			for(int m=squarexmax;m>=squarexmin;m--)
			for(int n=squareymin;n<=squareymax;n++)
			{
				BOOL IsInTriangle=FALSE;
				
				IsInTriangle = matrixcaculate.IsPointInTriangle(m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
				if(IsInTriangle){
					double RR,GG,BB;
					RR =matrixcaculate.getaveragevalue(R1,R2,R3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
					GG =matrixcaculate.getaveragevalue(G1,G2,G3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
					BB =matrixcaculate.getaveragevalue(B1,B2,B3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);

					if((RR>=0)&&(GG>=0)&&(BB>=0)){			
					double *pp;
				   if(((n-y_imin)<=(m_iHeight-1))&&((m-x_imin)<=(m_iWidth-1))&&((n-y_imin)>=0)&&((m-x_imin)>=0)){
					pp = m_pdImageRGBD+(n-y_imin)*m_iWidth*RGBD+(m-x_imin)*RGBD;
                    pp[R] = RR;
					pp[G] = GG;
					pp[B] = BB;
				   }
					}else{};


				}else{
				};

			}
		}else if (drawstate==3){

			for(int m=squarexmax;m>=squarexmin;m--)
			for(int n=squareymax;n>=squareymin;n--)
			{
				BOOL IsInTriangle=FALSE;
				
				IsInTriangle = matrixcaculate.IsPointInTriangle(m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
				if(IsInTriangle){
					double RR,GG,BB;
					RR =matrixcaculate.getaveragevalue(R1,R2,R3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
					GG =matrixcaculate.getaveragevalue(G1,G2,G3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
					BB =matrixcaculate.getaveragevalue(B1,B2,B3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);

					if((RR>=0)&&(GG>=0)&&(BB>=0)){			
					double *pp;
				  if(((n-y_imin)<=(m_iHeight-1))&&((m-x_imin)<=(m_iWidth-1))&&((n-y_imin)>=0)&&((m-x_imin)>=0)){
					pp = m_pdImageRGBD+(n-y_imin)*m_iWidth*RGBD+(m-x_imin)*RGBD;
                    pp[R] = RR;
					pp[G] = GG;
					pp[B] = BB;
				  }
					}else{};


				}else{
				};

			}
		};
		/*for(int m=squarexmin;m<=squarexmax;m++)
			for(int n=squareymin;n<=squareymax;n++)
			{
				BOOL IsInTriangle=FALSE;
				
				IsInTriangle = matrixcaculate.IsPointInTriangle(m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
				if(IsInTriangle){
					double RR,GG,BB;
					RR =matrixcaculate.getaveragevalue(R1,R2,R3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
					GG =matrixcaculate.getaveragevalue(G1,G2,G3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);
					BB =matrixcaculate.getaveragevalue(B1,B2,B3,m,n,Xdest1,Ydest1,Xdest2,Ydest2,Xdest3,Ydest3);

					if((RR>=0)&&(GG>=0)&&(BB>=0)){			
					double *pp;
					pp = m_pdImageRGBD+(n-y_imin)*m_iWidth*RGBD+(m-x_imin)*RGBD;
                    pp[R] = RR;
					pp[G] = GG;
					pp[B] = BB;

					}else{};


				}else{
				};

			};*/
	}else{
	/*	int xxdest1,yydest1,xxdest2,yydest2,xxdest3,yydest3;

		xxdest1 = (int)(Xdest1+0.5);
		yydest1 = (int)(Ydest1+0.5);

		xxdest2 = (int)(Xdest2+0.5);
		yydest2 = (int)(Ydest2+0.5);

		xxdest3 = (int)(Xdest3+0.5);
		yydest3 = (int)(Ydest3+0.5);

		

		double *pp;
		pp = m_pdImageRGBD+(yydest1-y_imin)*m_iWidth*RGBD+(xxdest1-x_imin)*RGBD;
        pp[R] = R1;
		pp[G] = G1;
		pp[B] = B1;


		pp = m_pdImageRGBD+(yydest2-y_imin)*m_iWidth*RGBD+(xxdest2-x_imin)*RGBD;
        pp[R] = R2;
		pp[G] = G2;
		pp[B] = B2;

		pp = m_pdImageRGBD+(yydest3-y_imin)*m_iWidth*RGBD+(xxdest3-x_imin)*RGBD;
        pp[R] = R3;
		pp[G] = G3;
		pp[B] = B3;


*/
	
	};
	

	
}

void CViewImage::Case1Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	
	WarpDirection135(pViewSourceImage, 0,0,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::Case2Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	WarpDirection45(pViewSourceImage, 0,0,xdvalue,INPUTIMAGESIZE-1,x_imin, y_imin);
	
	WarpDirection135(pViewSourceImage, xdvalue,0,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::Case3Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	
	WarpDirection45(pViewSourceImage, 0,0,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::Case4Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	WarpDirection225(pViewSourceImage, 0,ydvalue,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);
	
	WarpDirection135(pViewSourceImage, 0,0,INPUTIMAGESIZE-1,ydvalue,x_imin, y_imin);

}

void CViewImage::Case5Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	WarpDirection45(pViewSourceImage, 0,0,xdvalue,ydvalue,x_imin, y_imin);
	
	WarpDirection135(pViewSourceImage, xdvalue,0,INPUTIMAGESIZE-1,ydvalue,x_imin, y_imin);

	WarpDirection225(pViewSourceImage, xdvalue,ydvalue,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);
	
	WarpDirection315(pViewSourceImage, 0,ydvalue,xdvalue,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::Case6Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	WarpDirection315(pViewSourceImage, 0,ydvalue,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);
	
	WarpDirection45(pViewSourceImage, 0,0,INPUTIMAGESIZE-1,ydvalue,x_imin, y_imin);

}

void CViewImage::Case7Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	
	WarpDirection225(pViewSourceImage, 0,0,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::Case8Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	
	WarpDirection225(pViewSourceImage, xdvalue,0,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);
	WarpDirection315(pViewSourceImage, 0,0,xdvalue,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::Case9Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	
	WarpDirection315(pViewSourceImage, 0,0,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::CaseN1Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	
	WarpDirection315(pViewSourceImage, 0,0,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::CaseN2Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	WarpDirection225(pViewSourceImage, 0,0,xdvalue,INPUTIMAGESIZE-1,x_imin, y_imin);
	
	WarpDirection315(pViewSourceImage, xdvalue,0,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::CaseN3Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	
	WarpDirection225(pViewSourceImage, 0,0,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::CaseN4Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	WarpDirection45(pViewSourceImage, 0,ydvalue,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);
	
	WarpDirection315(pViewSourceImage, 0,0,INPUTIMAGESIZE-1,ydvalue,x_imin, y_imin);

}

void CViewImage::CaseN5Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	WarpDirection225(pViewSourceImage, 0,0,xdvalue,ydvalue,x_imin, y_imin);
	
	WarpDirection315(pViewSourceImage, xdvalue,0,INPUTIMAGESIZE-1,ydvalue,x_imin, y_imin);

	WarpDirection45(pViewSourceImage, xdvalue,ydvalue,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);
	
	WarpDirection135(pViewSourceImage, 0,ydvalue,xdvalue,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::CaseN6Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	WarpDirection135(pViewSourceImage, 0,ydvalue,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);
	
	WarpDirection225(pViewSourceImage, 0,0,INPUTIMAGESIZE-1,ydvalue,x_imin, y_imin);

}

void CViewImage::CaseN7Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	
	WarpDirection45(pViewSourceImage, 0,0,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::CaseN8Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	
	WarpDirection45(pViewSourceImage, xdvalue,0,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);
	WarpDirection135(pViewSourceImage, 0,0,xdvalue,INPUTIMAGESIZE-1,x_imin, y_imin);

}

void CViewImage::CaseN9Warp(CViewImage* pViewSourceImage,int xdvalue,int ydvalue,int x_imin,int y_imin)
{

	
	WarpDirection135(pViewSourceImage, 0,0,INPUTIMAGESIZE-1,INPUTIMAGESIZE-1,x_imin, y_imin);

}


void CViewImage::GetMinMaxValueofWarpedImage(double p1[3][3],double p2[3][3],double *c1,double *c2,double *imageptr, double *minx, double *maxx, double *miny, double *maxy)
{

	double *p ;
    double minxx,minyy,maxxx,maxyy;
	double x,y;
	double delta;
	minxx = 0.0;
	minyy = 0.0;
	maxxx = 0.0;
	maxyy = 0.0;
 
	
	int i;
	for(i=0;i<INPUTIMAGESIZE;i++){
      p = imageptr+i*RGBD;
	  delta= p[D];
	  caculateu2v2(i,0,p1,p2,c1,c2,delta,&x,&y);
	  if(x<minxx) minxx = x;
	  if(x>maxxx) maxxx = x;
	  if(y<minyy) minyy = y;
	  if(y>maxyy) maxyy = y;
		
	};

	for(i=0;i<INPUTIMAGESIZE;i++){
      p = imageptr+i*INPUTIMAGESIZE*RGBD;
	  delta= p[D];
	  caculateu2v2(0,i,p1,p2,c1,c2,delta,&x,&y);
	  if(x<minxx) minxx = x;
	  if(x>maxxx) maxxx = x;
	  if(y<minyy) minyy = y;
	  if(y>maxyy) maxyy = y;
		
	};

   for(i=0;i<INPUTIMAGESIZE;i++){
      p = imageptr+(INPUTIMAGESIZE-1)*INPUTIMAGESIZE*RGBD+i*RGBD;
	  delta= p[D];
	  caculateu2v2(i,INPUTIMAGESIZE-1,p1,p2,c1,c2,delta,&x,&y);
	  if(x<minxx) minxx = x;
	  if(x>maxxx) maxxx = x;
	  if(y<minyy) minyy = y;
	  if(y>maxyy) maxyy = y;
		
	};

    for(i=0;i<INPUTIMAGESIZE;i++){
      p = imageptr+i*INPUTIMAGESIZE*RGBD+(INPUTIMAGESIZE-1)*RGBD;
	  delta= p[D];
	  caculateu2v2(INPUTIMAGESIZE-1,i,p1,p2,c1,c2,delta,&x,&y);
	  if(x<minxx) minxx = x;
	  if(x>maxxx) maxxx = x;
	  if(y<minyy) minyy = y;
	  if(y>maxyy) maxyy = y;
		
	};


    *minx = minxx;
	*maxx = maxxx;
	*miny = minyy;
	*maxy = maxyy;


}
