#include "ContourExtractData.h"


//----------------------------------------------------------------------
ContourExtractData::ContourExtractData( bool okImagesResults)
  {
    this->imagedata			= NULL;
	imagedataValueResult	= NULL;
	imagedataMaskResult		= NULL;
	this->okImagesResults	= okImagesResults;
	_typeOperation			= 0;
  }

  // ------------------------------------------------------------------------

  ContourExtractData::~ContourExtractData()
  {
  }


//----------------------------------------------------------------------
void ContourExtractData::SetImage( vtkImageData* imagedata)
  {
    this->imagedata			= imagedata;
	if (this->okImagesResults==true){
		InitVtkImagesResult();
	}
  }
//----------------------------------------------------------------------
void ContourExtractData::SetZtoBeAnalys( int z )
  {
	this->zImage			= z;
  }

//------------------------------------------------------------------------
  void ContourExtractData::SetLstManualContourModel( std::vector<manualContourModel*> lstManConMod)
  {
	  this->lstManConMod = lstManConMod;
  }


//------------------------------------------------------------------------
void ContourExtractData::GetMinMaxPoint(int *minPoint, 
										  int *maxPoint, 
										  manualContourModel *manualcontourmodel
										  )
{
	int i;
	//int	np		= manualcontourmodel->GetSizeLstPoints( );  // number of control points // JPRx

// JSTG 26-02-08 ---------------------------------------------------------------------------------------
	//int nps = manualviewbaseecontour->GetNumberOfPointsSpline(); // number of points in the spline
	int nps = manualcontourmodel->GetNumberOfPointsSpline(); // number of points in the spline
//------------------------------------------------------------------------------------------------------
	
// JSTG 26-02-08 ---------------------------------------------------------------------------------------
	//double x,y,z,t;
	double x,y,z;
	//double delta=( double ) ( np  ) / ( double ) ( nps  );
	manualcontourmodel->UpdateSpline();
	for (i=0; i<nps; i++)
	{
		//t= delta * (double)i;
		//manualcontourmodel->GetSplinePoint(t,x,y,z);
		manualcontourmodel->GetSpline_i_Point(i,&x,&y,&z);
		if (x<minPoint[0]){ minPoint[0]=(int)x; }
		if (y<minPoint[1]){ minPoint[1]=(int)y; }
		if (x>maxPoint[0]){ maxPoint[0]=(int)x; }
		if (y>maxPoint[1]){ maxPoint[1]=(int)y; }
	}
//------------------------------------------------------------------------------------------------------
}

//------------------------------------------------------------------------
void ContourExtractData::GetMinMaxPoint_Of_LstManConMod(	int *minPoint, 
											int *maxPoint
										)

{
	int i,size = lstManConMod.size();
	for(i=0 ; i<size ; i++)
	{
		GetMinMaxPoint(minPoint,maxPoint,lstManConMod[i]);
	}
}
//------------------------------------------------------------------------

int ContourExtractData::AnalisisContourInside(int x, 
					    int y, 
					    manualContourModel *manualcontourmodel
					    )
{
	int result	= 0;
	int i;
	//int	np		= manualcontourmodel->GetSizeLstPoints( );  // number of control points // JPRx

// JSTG 26-02-08 ---------------------------------------------------------------------------------------
	//int nps = manualviewbaseecontour->GetNumberOfPointsSpline(); // number of points in the spline
	int nps = manualcontourmodel->GetNumberOfPointsSpline(); // number of points in the spline
	//double x1,y1,z1,x2,y2,z2,t;
	double x1,y1,z1,x2,y2,z2;
	double xx1, yy1,xx2, yy2;
	//double delta=( double ) ( np  ) / ( double ) ( nps  );
	manualcontourmodel->UpdateSpline();
//------------------------------------------------------------------------------------------------------
	double d;
	bool ok;
//	if (np>=2)
//	{
// JSTG 26-02-08 ---------------------------------------------------------------------------------------
		nps--;
		//manualcontourmodel->GetSplinePoint(0,x1,y1,z1);
		manualcontourmodel->GetSpline_i_Point(0,&x1,&y1,&z1);
		for (i=1; i<=nps; i++)
		{
			ok=false;
			//t= delta * (double)(i%nps);
			//manualcontourmodel->GetSplinePoint(t,x2,y2,z2);
			manualcontourmodel->GetSpline_i_Point(i,&x2,&y2,&z2);
//------------------------------------------------------------------------------------------------------
			//by triangle similarity
			if ( ((y1<y2)&&(y>=y1)&&(y<y2)) || ((y1>y2)&&(y<=y1)&&(y>y2)) )
			{
				if (y1<y2) { xx1=x1; yy1=y1; xx2=x2; yy2=y2;} else { xx1=x2; yy1=y2; xx2=x1; yy2=y1; } 
				d = ( fabs(xx2-xx1)*(y-yy1) ) / (yy2-yy1) ;
				if (  ((xx1<xx2)&&(x<(xx1+d)))  ||  ((xx1>xx2)&&(x<(xx1-d)))  ) { result++; }
			} // if
			x1=x2; y1=y2; z1=z2;
		} // for i
//	} //if
	return result;
}

//------------------------------------------------------------------------


bool ContourExtractData::isInside(int x, int y, int typeOperation)
{
	bool result				= false;
	int numberLeft			= 0;
	int i,size				= this->lstManConMod.size();
	int numberInside        = 0;

	int ext[6];
	imagedata->GetExtent(ext);

	if ((x>=0) && (x<=ext[1]) && (y>=0) && (y<=ext[3]))
	{

		if (typeOperation==0)  // AND  Intersection
		{
			for (i=0;i<size;i++)
			{
				numberLeft =  AnalisisContourInside(x,y, lstManConMod[i] );
				if ( (numberLeft % 2) ==1){         numberInside++;  }
			}
			if ( numberInside == (size) ){ result=true; }
		} // AND  Intersection


		if (typeOperation==1)  // OR  All
		{
			for (i=0;i<size;i++)
			{
				numberLeft =  AnalisisContourInside(x,y, lstManConMod[i] );
				if ( (numberLeft % 2) ==1){ result=true;  }
			}
		} // OR  All

		if (typeOperation==2)  // XOR  crown
		{
			for (i=0;i<size;i++)
			{
				numberLeft = numberLeft + AnalisisContourInside(x,y, lstManConMod[i] );
			}
			if ( numberLeft % 2 ==1){ 	result = true;  } 
		}// XOR  crown



	}

	return result;
}

//------------------------------------------------------------------------

double ContourExtractData::GetDataValue(int x, int y, int z)
{
//	wxVtk2DBaseView *wxvtk2dbaseview = (wxVtk2DBaseView*)wxvtkbaseview;
//	int z = (int)wxvtk2dbaseview->GetVtkBaseData()->GetZ();
	//JSTG 13-03-08-----
//EED OJO avec JS	_zz = z;
	//------------------
	double result;
	void *p;
	p = imagedata->GetScalarPointer(x,y,z);

	if (imagedata->GetScalarType()==VTK_CHAR)
	{
		char *pp = (char*)p;
		result = (double)(*pp);
	}
	else if (imagedata->GetScalarType()==VTK_SIGNED_CHAR)
	{
		signed char *pp = (signed char*)p;
		result = (double)(*pp);
	}
	else if (imagedata->GetScalarType()==VTK_UNSIGNED_CHAR)
	{
		unsigned char *pp = (unsigned char*)p;
		result = (double)(*pp);
	}
	else if (imagedata->GetScalarType()==VTK_SHORT)
	{
		short *pp = (short*)p;
		result = (double)(*pp);
	}
	else if (imagedata->GetScalarType()==VTK_UNSIGNED_SHORT)
	{
		unsigned short *pp = (unsigned short*)p;
		result = (double)(*pp);
	}
	else if (imagedata->GetScalarType()==VTK_INT)
	{
		int *pp = (int*)p;
		result = (double)(*pp);
	}
	else if (imagedata->GetScalarType()==VTK_UNSIGNED_INT)
	{
		unsigned int *pp = (unsigned int*)p;
		result = (double)(*pp);
	}
	else if (imagedata->GetScalarType()==VTK_LONG)
	{
		long *pp = (long*)p;
		result = (double)(*pp);
	}
	else if (imagedata->GetScalarType()==VTK_UNSIGNED_LONG)
	{
		unsigned long *pp = (unsigned long*)p;
		result = (double)(*pp);
	}
	else if (imagedata->GetScalarType()==VTK_FLOAT)
	{	
		float *pp = (float*)p;
		result = (double)(*pp);
	}
	else if (imagedata->GetScalarType()==VTK_DOUBLE)
	{
		double *pp = (double*)p;
		result = (double)(*pp);
	}

	return result;
}

//------------------------------------------------------------------------

void ContourExtractData::PutVtkImageDataResultValue( int x, int y, int z, double value )
{
	unsigned short *pValue;
	unsigned short *pMask;
	pValue	= (unsigned short *)imagedataValueResult->GetScalarPointer(x,y,z);
	pMask	= (unsigned short *)imagedataMaskResult->GetScalarPointer(x,y,z);
	*pMask	= 255;
	*pValue = (unsigned short)value;
}

//------------------------------------------------------------------------
void ContourExtractData::ResetImageResult(int z)
{
	if (okImagesResults==true)
	{
		unsigned short *pValue;
		unsigned short *pMask;
		pValue	= (unsigned short *)imagedataValueResult->GetScalarPointer(0,0,z);
		pMask	= (unsigned short *)imagedataMaskResult->GetScalarPointer(0,0,z);
		
		int ext[6];
		imagedataValueResult->GetExtent(ext);

		int i,size = (ext[1]-ext[0]+1) * (ext[3]-ext[2]+1); 
		for(i=0; i<size; i++)
		{
			*pMask	= 0;
			*pValue = 0;
			pMask++;
			pValue++;
		}// for
	} // if
}


//------------------------------------------------------------------------
void ContourExtractData::CalculateImageResult()
{
	if (okImagesResults==true)
	{
		ResetImageResult(zImage);

		int minPoint[2];
		int maxPoint[2];
		int i,j;
		double value;

		minPoint[0] = 999999;
		minPoint[1] = 999999;
		maxPoint[0] = -999999;
		maxPoint[1] = -999999;

		GetMinMaxPoint_Of_LstManConMod(minPoint,maxPoint);
		for (j=minPoint[1]; j<maxPoint[1]; j++)
		{
			for (i=minPoint[0]; i<maxPoint[0]; i++)
			{
				if (isInside(i,j,_typeOperation)==true)
				{
					value = GetDataValue(i,j,zImage);
					PutVtkImageDataResultValue(i,j,zImage,  value );
				} // if
			} // for i
		} // for j


		imagedataValueResult->Modified();
		imagedataMaskResult->Modified();
	}

}

//------------------------------------------------------------------------
void ContourExtractData::GetValuesInsideCrown(std::vector<double> *pLstValue,
												std::vector<double> *pLstValuePosX,
												std::vector<double> *pLstValuePosY,
												std::vector<double> *pLstValuePosZ)
{
	pLstValue->clear();
	pLstValuePosX->clear();
	pLstValuePosY->clear();
	pLstValuePosZ->clear();

//	if (okImagesResults==true)
//	{
//		ResetImageResult(zImage);
//	}

	int minPoint[2];
	int maxPoint[2];
	int i,j;
	double value;


	minPoint[0] = 999999;
	minPoint[1] = 999999;
	maxPoint[0] = -999999;
	maxPoint[1] = -999999;

	GetMinMaxPoint_Of_LstManConMod(minPoint,maxPoint);


	for (j=minPoint[1]; j<maxPoint[1]; j++)
	{
		for (i=minPoint[0]; i<maxPoint[0]; i++)
		{
			if (isInside(i,j,_typeOperation)==true)
			{
				value = GetDataValue(i,j,zImage);

// Borrame
//				if (okImagesResults==true){
//					PutVtkImageDataResultValue(i,j,zImage,  value );
//				}

				pLstValue		-> push_back( value );
				pLstValuePosX	-> push_back( i );
				pLstValuePosY	-> push_back( j );
				pLstValuePosZ	-> push_back( -1 );
			} // if
		} // for
	} // for


// Borrame
//	if (this->okImagesResults==true){
//		imagedataValueResult->Modified();
//		imagedataMaskResult->Modified();
//	}


}

//------------------------------------------------------------------------

vtkImageData *ContourExtractData::GetVtkImageValueResult()
{
	return imagedataValueResult;
}
//------------------------------------------------------------------------
vtkImageData *ContourExtractData::GetVtkImageMaskResult()
{
	return imagedataMaskResult;
}
// ------------------------------------------------------------------------
void ContourExtractData::InitVtkImagesResult()
{
	  int ext[6];
	  int newDim[3];
	  double spc[3];
	  int scalartype;

	  imagedata->GetSpacing(spc);
	  imagedata->GetExtent(ext);
	  newDim[0]=ext[1]-ext[0]+1;
	  newDim[1]=ext[3]-ext[2]+1;
	  newDim[2]=ext[5]-ext[4]+1;
	  scalartype = imagedata->GetScalarType();

	  if (imagedataValueResult!=NULL)
	  {
		  imagedataValueResult->Delete();
	  }
	  imagedataValueResult = vtkImageData::New();
//	  imagedataValueResult->SetScalarType(scalartype);
	  imagedataValueResult->SetScalarTypeToUnsignedShort();
	  imagedataValueResult->SetSpacing(spc);
	  imagedataValueResult->SetDimensions( newDim );
	  imagedataValueResult->AllocateScalars();

	  if (imagedataMaskResult!=NULL)
	  {
		  imagedataMaskResult->Delete();
	  }
	  imagedataMaskResult  = vtkImageData::New();
//	  imagedataMaskResult->SetScalarType(scalartype);
	  imagedataMaskResult->SetScalarTypeToUnsignedShort();
	  imagedataMaskResult->SetSpacing(spc);
	  imagedataMaskResult->SetDimensions( newDim );
	  imagedataMaskResult->AllocateScalars();
}



//------------------------------------------------------------------------
void ContourExtractData::Statistics( std::vector<double> *inputLstValue, 
									int     grayRangeMin,
									int     grayRangeMax,
									int		*rCountRange, 
									int		*rsize, 
									double	*rmin, 
									double	*rmax,
									double	*raverage,
									double	*rstandardeviation)
{
	  double min				= 0;
	  double max				= 0;
	  double average			= 0;
	  double standardeviation	= 0;
	  double acum				= 0;
	  int	 size				= 0;
	  int	 countRange			= 0;
	  double ng;

	  if (inputLstValue!=NULL)
	  {
		size=inputLstValue->size();
		if (size>0){
	       max=(*inputLstValue)[0];
		   min=(*inputLstValue)[0];
     // Average , countRange
			int i;
			for ( i=0; i<size; i++ )
			{
				ng=(*inputLstValue)[i];
				acum = acum + ng;
				if (max<ng) max=ng;		// Max
				if (min>ng) min=ng;     // Min
				if ((ng>=grayRangeMin) && (ng<=grayRangeMax)) countRange++;  // countRange
			}
			average = acum / size;

	  // Standar Deviation
			acum=0;
			double tmp;
  			for ( i=0; i<size; i++ )
			{
                tmp = (*inputLstValue)[i] - average;
				acum = acum + tmp*tmp;
			}
			standardeviation = sqrt(acum/size);

		}
	  }

	  // OUTPUT
		*rsize				= size; 
		*rCountRange		= countRange;
		*rmin				= min; 
		*rmax				= max;
		*raverage			= average;
		*rstandardeviation	= standardeviation;
}

//------------------------------------------------------------------------
void ContourExtractData::SetTypeOperation(int type)
{
	_typeOperation=type;
}