//-----------------------------------------------------------------------------+
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
// = FileName	:   TPGeGLine3D.cpp
// = Version	:   ver2.0
// = Author		:   xlc
// = CreateDate	:   2002-09-09
// = Description:   ÀàµÄ¶¨Òå
// = Maintainers: 
//                  
//-----------------------------------------------------------------------------+
#include "StdAfx.h"
#include "TPGeGLine3D.h"
#include "TPGeGLine2D.h"
#include "TGPoint3D.h"
#include "TPGeGLineRay3D.h"
#include "TPGeGLineSeg3D.h"

IMPLEMENT_RUN_TIME_CLASS1(TPGeGLine3D,"TPGeGLine3D",TPGeCurve3D)

TPGeGLine3D::TPGeGLine3D()
{

}

TPGeGLine3D::TPGeGLine3D(const TGVector3D&vt,const TGPoint&pt)
	: TPGeLine3D(vt,pt)
{

}

TPGeGLine3D::TPGeGLine3D(const TGPoint&pt0,const TGPoint&pt1)
	: TPGeLine3D(pt0,pt1)
{

}

TPGeGLine3D::TPGeGLine3D(const TPGeLine3D&line)
	: TPGeLine3D(line)
{

}

TPGeGLine3D::~TPGeGLine3D()
{
	
}


const TPGeLine3D& TPGeGLine3D::GetGeLine() const
{
	return *this;
}

bool TPGeGLine3D::IsClosed() const
{
	return false;
}

bool TPGeGLine3D::IsFinite(bool bStart) const
{
	return false;
}

void TPGeGLine3D::Pa2Pt(double pa,TGPoint&pt) const
{
	TPGeLine3D::Pa2Pt(pa,pt);
}

void TPGeGLine3D::Pt2Pa(const TGPoint&pt,double&pa) const
{
	TPGeLine3D::Pt2Pa(pt,pa);
}

void TPGeGLine3D::Reverse()
{
	TPGeLine3D::Reverse();
}

TGObject2D* TPGeGLine3D::Convert2D() const
{
	return new TPGeGLine2D(TGVector2D(x,y),basePoint);
}

bool TPGeGLine3D::IsValid() const
{
	return TPGeLine3D::IsValid();
}

void TPGeGLine3D::TransformBy(const TGMatrix&matrix)
{
	TPGeLine3D::TransformBy(&matrix);
}

TGObject * TPGeGLine3D::Clone() const
{
	return new TPGeGLine3D(*this);
}

GRelation TPGeGLine3D::HitTest(const TGPoint&pt) const
{
	return TPGeLine3D::HitTest(pt);
}

bool TPGeGLine3D::Intersect(const TGObject&obj,TGObjectList&res) const
{
	if (IS_TYPE(&obj,TPGeGLine3D))
	{
		double pa;
		int ret = TPGeLine3D::Intersect((const TPGeGLine3D&)obj,pa);
		if (ret == INT_NULL)
		{
			return false;
		}
		else if (ret == INT_LINE)
		{
			res << new TPGeGLine3D(*this);
			return true;
		}
		else 
		{
			TGPoint3D *pPt=new TGPoint3D;
			Pa2Pt(pa,*pPt);
			res << pPt;

			return true;
		}
	}
	return obj.Intersect(*this, res);
}

bool TPGeGLine3D::IsInclude(const TGObject&obj) const
{
	switch(obj.GetClassID())
	{
	case CID_GLine3D:
		return IsSameLine((const TPGeGLine3D&)obj,false);
	case CID_GLineRay3D:
		return IsSameLine((const TPGeGLineRay3D&)obj,false);
	case CID_GLineSeg3D:
		return IsSameLine((const TPGeGLineSeg3D&)obj,false);
	default:
		return TPGeCurve3D::IsInclude(obj);
	}
}

TPGeCurve3D* TPGeGLine3D::GetSubCurve(double pa0,double pa1) const
{
	TGPoint pt0,pt1;
	Pa2Pt(pa0,pt0);
	Pa2Pt(pa1,pt1);
	return new TPGeGLineSeg3D(pt0,pt1);
}

void TPGeGLine3D::Split(const TTable<double>&paTable,TGObjectList&res) const
{
	if (paTable.IsEmpty())
	{
		return;
	}

	TGPoint pt0;
	Pa2Pt(paTable.GetAt(0),pt0);
	TGVector3D vt(*this);
	res << new TPGeGLineRay3D(-vt,pt0);
	for (long i = 1;i < paTable.GetLength();i++)
	{
		if (UP_ZERO(paTable.GetAt(i) - paTable.GetAt(i - 1)))
		{
			TGPoint pt1;
			Pa2Pt(paTable.GetAt(i),pt1);
			res << new TPGeGLineSeg3D(pt0,pt1);
			pt0 = pt1;
		}
		res << new TPGeGLineRay3D(vt,pt0);
	}
}