#include "manualViewContour.h"

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

manualViewContour::manualViewContour()
{
	_id_viewPoint_for_text	=	0;
	_mesureScale			=	1;
	_initialConoturModel = new manualContourModel();
}
// ----------------------------------------------------------------------------
manualViewContour::~manualViewContour()
{
	delete _initialConoturModel;
}
// ----------------------------------------------------------------------------

// ----------------------------------------------------------------------------
manualViewContour * manualViewContour :: Clone()
{
	manualViewContour * clone = new manualViewContour();
	CopyAttributesTo(clone);
	return clone;
}

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

void manualViewContour::CopyAttributesTo( manualViewContour * cloneObject)
{
	// Call to Fathers object
	manualViewBaseContour::CopyAttributesTo(cloneObject);

	cloneObject->SetMesureScale(_mesureScale);
}

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

int manualViewContour::GetType() // virtual
{
	return 1;
}

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

void manualViewContour::Save(FILE *pFile)
{
	manualViewBaseContour::Save(pFile);
}

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

void manualViewContour::Open(FILE *pFile)
{
}



// ----------------------------------------------------------------------------
void manualViewContour::RefreshContour() // virtual
{

	int i,np,nps;

//JSTG 25-02-08 --------------------
	//double t,delta, x,y,z;
	double x,y,z;
//----------------------------------

	_manContModel->UpdateSpline();
    np	= GetNumberOfPoints( );
	//nps = GetNumberOfPointsSpline();
    nps = _manContModel->GetNumberOfPointsSpline();
	//delta=( double ) ( np  ) / ( double ) ( nps-1  );		//JSTG 25-02-08


	if ( _pts!=NULL )
	{
		if (np>=2  )
		{
			for( i = 0; i < nps; i++ )
			{
//JSTG 25-02-08 ------------------------------------------------
				//t = delta * (double)i;
				//_manContModel->GetSplinePoint(t,x,y,z);
				_manContModel->GetSpline_i_Point(i,&x,&y,&z);
//--------------------------------------------------------------
	// EED 27 sep 2006
	//			_pts->SetPoint(i, x,y,z );
				_pts->SetPoint(i , x*_spc[0] , y*_spc[1] , z*_spc[2] );


			}// for
		}
		else
		{
				_pts->SetPoint(0, 0 , 0 , 0);
				_pts->SetPoint(1, 0 , 0 , 0);
		} // if
	}
}

// ----------------------------------------------------------------------------
void manualViewContour::RefreshText()  // virtual
{
	if ((_textActor!=NULL) && ( _textActor->GetProperty()->GetOpacity()!=0 )){
		int size = GetNumberOfPoints();
		char text[50];
		char resultText[50];
		strcpy(resultText," ");
		if (size==2)
		{
			strcpy(resultText,"L= ");
			gcvt ( _mesureScale * this->_manContModel->GetPathSize() , 5, text );
			strcat(resultText,text);
		}
		if (size>2)
		{
			if (_manContModel->IfCloseContour()==true)
			{
				strcpy(resultText,"P= ");
				gcvt ( _mesureScale * this->_manContModel->GetPathSize() , 5, text );
				strcat(resultText,text);
				gcvt ( _mesureScale * _mesureScale * this->_manContModel->GetPathArea() , 5, text );
				strcat(resultText,"   A= ");
				strcat(resultText,text);
			} else {
				strcpy(resultText,"L= ");
				gcvt (  _mesureScale * this->_manContModel->GetPathSize() , 5, text );
				strcat(resultText,text);
			}
		}

		_textActor->SetInput(resultText);
		
		if (size>=1){

			int i;
			for (i=0; i<size; i++)
			{
				if (_lstViewPoints[i]->GetPosibleSelected()==true)
				{
					_id_viewPoint_for_text = i;
				}
			}

			int id = _id_viewPoint_for_text;
			double px = _manContModel->GetManualPoint(id)->GetX();
			double py = _manContModel->GetManualPoint(id)->GetY();

			//EED 27 sep 2006
			px=px*_spc[0];
			py=py*_spc[1];

			_textActor->SetPosition(px+GetRange()+1,py);
		}

	}
}

// ----------------------------------------------------------------------------
bool manualViewContour::ifTouchContour(int x,int y,int z){
	
	bool result=false;
	double xx=x;
	double yy=y;
	double zz=z;
	double ppA[3];
	double ppB[3];
	double d1,d2,d3;
	TransfromCoordViewWorld(xx,yy,zz);

//EED 27 sep 2006
	xx = xx * _spc[0];
	yy = yy * _spc[1];
	zz = zz * _spc[2];

    unsigned int i, nps,nps_t;
    nps	  = _sizePointsContour;
	
	if (this->_manContModel->IfCloseContour()==true)
	{
		nps_t = nps;
	} else {
		nps_t = nps-1;
	}

	
	for( i = 0; i < nps_t; i++ ) 
	{
		_pts->GetPoint(i%nps, ppA);
		_pts->GetPoint((i+1)%nps, ppB);
		d1= sqrt( (ppA[0]-xx)*(ppA[0]-xx) + (ppA[1]-yy)*(ppA[1]-yy) + (ppA[2]-zz)*(ppA[2]-zz));
		d2= sqrt( (ppB[0]-xx)*(ppB[0]-xx) + (ppB[1]-yy)*(ppB[1]-yy) + (ppB[2]-zz)*(ppB[2]-zz));
		d3= sqrt( (ppB[0]-ppA[0])*(ppB[0]-ppA[0]) + (ppB[1]-ppA[1])*(ppB[1]-ppA[1]) + (ppB[2]-ppA[2])*(ppB[2]-ppA[2]));

		if (  ((d1+d2)>=d3) &&  ((d1+d2)<=d3*1.3) ) 
		{
			result=true;
			i=nps;
		} 
		
		//EED 25 Sep 2009
		if ((d1<=1) || (d2<=1))
		{
			result=true;
			i=nps;
		}
		
	}
	
	return result;
}

// ----------------------------------------------------------------------------
void manualViewContour::DeletePoint(int id) // virtual
{
	if (_lstViewPoints.size()>2)
	{
		manualViewBaseContour::DeletePoint( id );
	}
}
// ----------------------------------------------------------------------------

void manualViewContour::ClearPoint(int id)
{
	manualViewBaseContour::DeletePoint( id );
}

//-------------------------------------------------------------------
void manualViewContour::SetMesureScale(double mesureScale)
{
	_mesureScale = mesureScale;
}
//-------------------------------------------------------------------
void manualViewContour::InitMove(int x, int y, int z)
{
	_initialConoturModel->DeleteAllPoints();

	manualPoint *mp = NULL;
	double XX=x;
	double YY=y;
	double ZZ=z;
	TransfromCoordViewWorld(XX,YY,ZZ);

	int i, manualPointsSZ = _manContModel->GetSizeLstPoints();
	for ( i=0; i<manualPointsSZ; i++ )
	{
		mp = _manContModel->GetManualPoint( i );
		this->_initialConoturModel->AddPoint( mp->GetX() - XX, mp->GetY() - YY, mp->GetZ() );
	}
}
//-------------------------------------------------------------------
void manualViewContour::MoveContour(int x, int y, int z)
{
	manualPoint *mpOrigin = NULL;
	manualPoint *mpMoving = NULL;
	double XX=x;
	double YY=y;
	double ZZ=z;

	TransfromCoordViewWorld(XX,YY,ZZ);

	int i, manualPointsSZ = _manContModel->GetSizeLstPoints();
	for ( i=0; i<manualPointsSZ; i++ )
	{
		mpOrigin = _manContModel->GetManualPoint( i );
		mpMoving = _initialConoturModel->GetManualPoint(i);
		mpOrigin->SetPoint( mpMoving->GetX()+XX, mpMoving->GetY() + YY, mpMoving->GetZ() );
	}
	UpdateViewPoints();
}
void manualViewContour::MoveContour(int horizontalUnits, int verticalUnits )
{
	manualPoint *mpOrigin = NULL;

	int i, manualPointsSZ = _manContModel->GetSizeLstPoints();
	for ( i=0; i<manualPointsSZ; i++ )
	{
		mpOrigin = _manContModel->GetManualPoint( i );
		mpOrigin->SetPoint( mpOrigin->GetX()+horizontalUnits, mpOrigin->GetY()+verticalUnits, mpOrigin->GetZ() );
	}
	UpdateViewPoints();
}