//-------------------------------------------------------------------------------------------------------+
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
// = FileName	:   TPGeGLine2D 类
// = Version	:   ver2.0
// = Author		:   wlw
// = CreateDate	:   2002-09-09
// = Description:   TPGeGLine2D 定义
// = Maintainers: 
//                  
//-------------------------------------------------------------------------------------------------------+
#include "StdAfx.h"
#include "TPGeGLine2D.h"
#include "TPGeGLine3D.h"
#include "TGPoint2D.h"

IMPLEMENT_RUN_TIME_CLASS1(TPGeGLine2D,"TPGeGLine2D",TPGeCurve2D)

TPGeGLine2D::TPGeGLine2D()
{

}

TPGeGLine2D::TPGeGLine2D(const TGVector2D&vt,const TGPoint&pt):TPGeLine2D(vt,pt)
{

}

TPGeGLine2D::TPGeGLine2D(const TGPoint&pt0,const TGPoint&pt1):TPGeLine2D(pt0,pt1)
{
}

TPGeGLine2D::TPGeGLine2D(const TPGeLine2D&line):TPGeLine2D(line)
{

}

TPGeGLine2D::~TPGeGLine2D()
{
	
}


const TPGeLine2D& TPGeGLine2D::GetGeLine() const
{
	return *this;
}

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

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

void TPGeGLine2D::Pa2Pt(double pa,TGPoint&pt) const
{
	TPGeLine2D::Pa2Pt(pa,pt);
}

void TPGeGLine2D::Pt2Pa(const TGPoint&pt,double&pa) const
{
	TPGeLine2D::Pt2Pa(pt,pa);
}

void   TPGeGLine2D::GetTangent(double pa,TPGeLine2D&line) const
{
	line = *this;line.Normalize();
}

double TPGeGLine2D::Integration(double pa0,double pa1) const
{
	return TPGeLine2D::Integration(pa0,pa1);
}

void TPGeGLine2D::Reverse()
{
	TPGeLine2D::Reverse();
}

bool   TPGeGLine2D::Offset(double offset)
{
	TPGeLine2D::Offset(offset);return true;
}

void   TPGeGLine2D::SetElev(double elev)
{
	basePoint.z = elev;
}

double TPGeGLine2D::GetElev() const
{
	return basePoint.z;
}

bool TPGeGLine2D::IsValid() const
{
	return TPGeLine2D::IsValid();
}

void TPGeGLine2D::TransformBy(const TGMatrix&matrix)
{
	TPGeLine2D::TransformBy(&matrix);
}

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

GRelation TPGeGLine2D::HitTest(const TGPoint&pt) const
{
	return TPGeLine2D::HitTest(pt);
}

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

bool TPGeGLine2D::IsInclude(const TGObject&obj) const
{
	switch(obj.GetClassID())
	{
	case CID_GLine2D:
		return IsSameLine((const TPGeGLine2D&)obj,false);
	case CID_GLineRay2D:
		return IsSameLine((const TPGeGLineRay2D&)obj,false);
	case CID_GLineSeg2D:
		return IsSameLine((const TPGeGLineSeg2D&)obj,false);
	case CID_GCircle2D:
	case CID_GArc2D:
		return false;
	default:
		return TPGeCurve2D::IsInclude(obj);
	}
}

TPGeCurve2D* TPGeGLine2D::GetSubCurve(double pa0,double pa1) const
{
	TGPoint pt0,pt1;
	Pa2Pt(pa0,pt0);
	Pa2Pt(pa1,pt1);
	return new TPGeGLineSeg2D(pt0,pt1);
}

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

	TGPoint pt0;
	Pa2Pt(paTable.GetAt(0),pt0);
	TGVector2D vt(*this);
	res << new TPGeGLineRay2D(-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 TPGeGLineSeg2D(pt0,pt1);
			pt0 = pt1;
		}
	}
	res << new TPGeGLineRay2D(vt,pt0);
}

TGObject3D* TPGeGLine2D::Convert3D() const
{
	return new TPGeGLine3D(TGVector3D(x,y,z),basePoint);
}