#include "stdafx.h"
#include "RoadElevStyle.h"
static int g_iSelPrecision = 0;
namespace
{
#if ADS <= 18
double _ttof(LPCTSTR psz)
{
	if (!psz) return .0;
	USES_CONVERSION;
	return atof(W2A(psz));
}
#endif
}
double CRoadElevStyle::m_dRoadGrade = 0.0;
int CRoadElevStyle::m_iRoadGradePrecision = 1;//坡度精度 add tyj 20160906
double CRoadElevStyle::m_dStartElevation = 0.0;
double CRoadElevStyle::m_dEndElevation = 0.0;
double CRoadElevStyle::m_dRoadLenth =0.0;

XPoint CRoadElevStyle::m_ptProjectStart (0,0,0);
XPoint CRoadElevStyle::m_ptProjectend (0, 0, 0);
XPoint CRoadElevStyle::m_ptElevStart (0, 0, 0);
XPoint CRoadElevStyle::m_ptElevEnd (0, 0, 0);
XPoint CRoadElevStyle::m_ptBaselineStart (0, 0, 0);
XPoint CRoadElevStyle::m_ptBaseLineEnd (0, 0, 0);
bool CRoadElevStyle::m_bsingleElev = false;
bool CRoadElevStyle::m_bSelectRoadLine = false;
CRoadElevStyle::CRoadElevStyle()
{
}


CRoadElevStyle::~CRoadElevStyle()
{
}

int CRoadElevStyle::SelectStyle(TDbSymbElevation *pSymbElevEnt)
{
	PickSet ssElevation(SS_FREE);
	TRBList rbFilter(acutBuildList(RTDXF0, _T("ATS_ELEVATION"), NULL));
	int iRetCode;
	iRetCode = SelectEntities(_T("\n请选择道路基准标高<退出>："), ssElevation, rbFilter);
	if (iRetCode == RTNORM)//选择道路基准标高
	{
		if (!JudgeSelectRoadElevation(ssElevation))//判断选择的道路标高是否满足规定的个数
			return kRetContinue;
		TDbSymbElevation *pNewElev = GetFirstElevEnty(ssElevation);//克隆第一个标高实体
		g_iSelPrecision = pNewElev->IsPrec2()?0:1;		// 当前精度
		PickSet ssRoadBaseLine(SS_FREE);
		XPoly2D roadBaseLine;
		int nRet = SelectRoadBaseLine(ssRoadBaseLine, roadBaseLine);
		if (1 == nRet)//选择了道路基准线
		{
			m_bSelectRoadLine = true;
			if (!JudgeElevationOnRoadCenter(roadBaseLine, ssElevation))//取得投影点
			{
				ssRoadBaseLine.Redraw(4);//重绘刷新
				return kRetEsc;
			}
			do 
			{
				TRoadElevJig jig(roadBaseLine, pNewElev, FALSE, TRUE);
				jig.SetKeyword(_T("M"));
				jig.SetPrompt(_T("\n请点取标注位置或[修改标高(M)]<退出>: "));
				int iRet = jig.doIt();
				if (iRet == RTNORM)
				{
					TDbSymbElevation *pNewElev2 = new TDbSymbElevation();
					ASSERT(pNewElev2);
					pNewElev2 = (TDbSymbElevation *)pNewElev->clone();
					AddToModelSpace(pNewElev2);
				}
				else if (iRet == RTKWORD)
				{
					TRBList rbFilter(acutBuildList(RTDXF0, _T("ATS_ELEVATION"), NULL));
					PickSet ssElevation(SS_FREE);
					int iRetCode;
					if (RTNORM != SelectEntities(_T("\n请选择待修改的标高标注<退出>："), ssElevation, rbFilter))
					{
						delete pNewElev;
						ssRoadBaseLine.Redraw(4);//重绘刷新
						return kRetEsc;
					}
					else
					{
						AutoMendElev(ssElevation, roadBaseLine, roadBaseLine.Length() - 1);
						delete pNewElev;
						ssRoadBaseLine.Redraw(4);//重绘刷新
						return kRetEsc;
					}
				}
				else
				{
					ssRoadBaseLine.Redraw(4);//重绘刷新
					return kRetEsc;
				}
			} while (1);
		}
		if (0 == nRet)//没有选择道路基准线,直线计算
		{
			m_bSelectRoadLine = false;
			//jig, XPolyLine = pt1 - pt2;沿着这个线进行标注
			//生成
			if (!GetDefaultLine(ssElevation, roadBaseLine))
			{
				ssRoadBaseLine.Redraw(4);
				return kRetEsc;
			}
			do 
			{
				TRoadElevJig jig(roadBaseLine, pNewElev, false, false);
				jig.SetKeyword(_T("` M"));
				jig.SetPrompt(_T("\n请点取标注位置或[修改标高(M)]<退出>: "));
				int iRet = jig.doIt();
				if (iRet == RTNORM)
				{
					TDbSymbElevation *pNewElev2 = new TDbSymbElevation();
					ASSERT(pNewElev2);
					pNewElev2 = (TDbSymbElevation *)pNewElev->clone();
					AddToModelSpace(pNewElev2);
				}
				else if (iRet == RTKWORD)
				{
					TRBList rbFilter(acutBuildList(RTDXF0, _T("ATS_ELEVATION"), NULL));
					PickSet ssElevation(SS_FREE);
					int iRetCode;
					if (RTNORM != SelectEntities(_T("\n请选择待修改的标高标注<退出>："), ssElevation, rbFilter))
					{
						delete pNewElev;
						return kRetEsc;
					}
					else
					{
						AutoMendElev(ssElevation, roadBaseLine, roadBaseLine.Length() - 1);
						delete pNewElev;
						return kRetEsc;
					}
				}
				else
				{
					delete pNewElev;
					return kRetEsc;
				}
			} while (1);
		}
		if (-1 == nRet)
			return kRetEsc;
		ssRoadBaseLine.Redraw(4);//重绘刷新
	}
	else
	{
		return  kRetEsc;
	}
	return kRetContinue;
}


TDbSymbElevation* CRoadElevStyle::GetFirstElevEnty(const PickSet &ssElevation)
{
	Entity ent = ssElevation[0];
	if (ent.Is(_T("ATS_ELEVATION")))
	{
		OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSymbElevation, pEnt);
		if (pEnt)
		{
			m_ptElevStart = pEnt->GetLocation();//返回的是世界坐标的点
			pEnt->GetElev1(m_dStartElevation);
			CString strTemp = pEnt->GetText();
			if (strTemp.Left(1) == _T("%"))//判断是否有正负号,如果有去掉
				strTemp = strTemp.Right(strTemp.GetLength() - 3);
			m_dStartElevation = _wtof(strTemp);
			TDbSymbElevation *pNewElev = (TDbSymbElevation *)pEnt->clone();
			ASSERT(pNewElev);
			return pNewElev;
		}
		OPENOBJ_END();
	}
}


void CRoadElevStyle::AutoMendElev(PickSet& ssElevation, XPoly2D &RoadBaseLine, int iNum)
{
	XPoint ptStart, ptEnd,ptShort;
	int len = ssElevation.Length();
	for (long i = 0; i < len; i++)
	{
		Entity ent = ssElevation[i];
		if (ent.Is(_T("ATS_ELEVATION")))
		{
			OPENOBJ_BEGIN(ent, AcDb::kForWrite, TDbSymbElevation, pEnt);
			if (pEnt)
			{
				double dMinDis = 1.7976931348623158e+308;;//double类型数据的最大值
				int iN(0);
				for (int j = 0; j < iNum; j++)
				{
// 					TGGeCurveSegment cvSegent;
// 					RoadBaseLine.Nth(j, cvSegent);//取出索引为j的曲段,第j段
// 					TADSGePoint3d ptProject;//投影点
// 					XPoint pt = pEnt->GetLocation();
// 					cvSegent.ProjectToMe(pt, ptProject);//点与哪个曲段近
// 					double len = (AcGePoint3d(ptProject)).distanceTo(pt);//找出原始点与投影点的距离最短的投影点，才为正确的投影点(存在投影到延长线的可能)
// 					if (j == 0)
// 					{
// 						dMin = len;
// 						ptShort = ptProject;
// 					}
// 					if (!dMin)//点就在线上
// 					{
// 						j = iNum/* - 1*/;
// 						ptShort = pt;
// 					}
// 					if (len < dMin)
// 					{
// 						dMin = len;
// 						iN = j;
// 						ptShort = ptProject;
// 					}
					TGGeDirectionCurve curve;
					XPoint ptProjectTemp;
					XPoint pt = pEnt->GetLocation();
					RoadBaseLine.Nth(j, curve);
					curve.ProjectToMe(pt, ptProjectTemp);//第1个参数为原始点，第2个参数为计算好的点
					if (!RoadBaseLine.HitTestOnCurve(ptProjectTemp))//能否投影到曲段上,延长线上
					{
						continue;
					}
					double dMinDisTemp = abs(ptProjectTemp.Distance(pt));
					if (!j)dMinDis = dMinDisTemp;
					if (dMinDisTemp <= dMinDis)
					{
						ptShort = ptProjectTemp;
						dMinDis = dMinDisTemp;
					}
				}
				pEnt->SetText(CalcElevData(RoadBaseLine, ptShort));
				
				pEnt->AddToMSpace(Adesk::kTrue);
			}
			OPENOBJ_END();
		}
	}
}

void CRoadElevStyle::InputBaseLineGrade()
{
	CString str(_T("")), strTmp(_T("")), strPrompt(_T(""));
	do
	{
		//add tyj 20160906:保证用户输入什么值，下次默认值就为什么值，不会自动取近似值
		switch (m_iRoadGradePrecision)
		{
		case 0:			
				strPrompt.Format(_T("\n请输入道路坡度(正值为上坡)(%%)<%.0f>:"), m_dRoadGrade);
				break;			
		case 1:			
				strPrompt.Format(_T("\n请输入道路坡度(正值为上坡)(%%)<%.1f>:"), m_dRoadGrade);
				break;			
		case 2:			
				strPrompt.Format(_T("\n请输入道路坡度(正值为上坡)(%%)<%.2f>:"), m_dRoadGrade);
				break;			
		case 3:			
				strPrompt.Format(_T("\n请输入道路坡度(正值为上坡)(%%)<%.3f>:"), m_dRoadGrade);
				break;			
		case 4:			
				strPrompt.Format(_T("\n请输入道路坡度(正值为上坡)(%%)<%.4f>:"), m_dRoadGrade);
				break;			
		case 5:			
				strPrompt.Format(_T("\n请输入道路坡度(正值为上坡)(%%)<%.5f>:"), m_dRoadGrade);
				break;			
		default:			
				strPrompt.Format(_T("\n请输入道路坡度(正值为上坡)(%%)<%.6f>:"), m_dRoadGrade);
				break;
		}
		
		int rc = acedGetString(FALSE, strPrompt, str.GetBufferSetLength(1000));
		if (rc == RTNORM)
		{
			str.ReleaseBufferSetLength(1000);
			if (_tcscmp(str, _T("")) == 0)
			{
				//修改 tyj 201609013:解决第二次输入坡度时，使用默认值精度不对
				switch (m_iRoadGradePrecision)
				{
				case 0:			
					strTmp.Format(_T("%.0f"), m_dRoadGrade);
					break;			
				case 1:			
					strTmp.Format(_T("%.1f"), m_dRoadGrade);
					break;			
				case 2:			
					strTmp.Format(_T("%.2f"), m_dRoadGrade);
					break;			
				case 3:			
					strTmp.Format(_T("%.3f"), m_dRoadGrade);
					break;			
				case 4:			
					strTmp.Format(_T("%.4f"), m_dRoadGrade);
					break;			
				case 5:			
					strTmp.Format(_T("%.5f"), m_dRoadGrade);
					break;			
				default:			
					strTmp.Format(_T("%.6f"), m_dRoadGrade);
					break;
				}
			}
			else
			{
				strTmp = str.SpanIncluding(_T("-0123456789."));
				if (strTmp.IsEmpty())
					acutPrintf(_T("\n输入无效，请重新输入数值!"));
			}
		}
		else
			return;
		
	} while (strTmp.IsEmpty());
	int iDecimalPlace = strTmp.Find('.');//小数点存在的位置
	if(iDecimalPlace != -1)
		m_iRoadGradePrecision = strTmp.GetLength() - iDecimalPlace - 1;
	else
		m_iRoadGradePrecision = 0;
	m_dRoadGrade = _ttof(strTmp);
}

bool CRoadElevStyle::JudgeSelectRoadElevation(PickSet &ss)
{
	int len = ss.Length();
	if (len < 1)
	{
		ads_prompt(_T("\n未选择,请选择!"));
		return false;
	}
	else if (len == 1)
	{
		TRBList rbFilter(acutBuildList(RTDXF0, _T("ATS_ELEVATION"), NULL));
		TEntitySet ent;
		int iRetCode;
		XPoint ptPick;
		INITGET_BEG(0, _T("W"));
		iRetCode = SelectEntity(_T("\n请选择第二个标高或[输入坡度(W)]:"), ent, ptPick, rbFilter);//修正中文输入法输入W，出错
		INITGET_END();
		//nRet = SelectEntity(_T("\n选择参考标高或 [参考当前用户坐标系(T)]<退出>"), Ent, ptPick, mask);
		if (RTNORM == iRetCode)
		{
			AcDbObjectId id = NULL;
			acdbGetObjectId(id, ent);//取第2个标高id存放到选择集中
			ss += id;
			m_bsingleElev = false;
			
			return true;
		}
		else if (RTKWORD == iRetCode)
		{
			m_bsingleElev = true;
			//acutPrintf(_T("W"));
			InputBaseLineGrade();
			return true;
		}
		else
		{
			return false;
		}
	}
	else if (len == 2)
	{
		m_bsingleElev = false;
		return true;
	}
	else if (len > 2)
	{
		ads_prompt(_T("选择超过两个标高,请重新选择!"));
		return false;
	}
	return false;

	
}

int CRoadElevStyle::SelectRoadBaseLine(PickSet &ssRoadBaseLine, XPoly2D &pRoadBaseLine)
{
		PickSet ssSelect;
		TRBList rbFilter(acutBuildList(RTDXF0, _T("POLYLINE,LWPOLYLINE,LINE,ARC"), NULL));
		int nReturnValue;
		if (m_bsingleElev)
			nReturnValue = SelectEntities(_T("\n请选择道路基准线: "), ssSelect, rbFilter);
		else
			nReturnValue = SelectEntities(_T("\n请选择道路基准线<两标高点间按直线计算>: "), ssSelect, rbFilter);
		if (RTNORM == nReturnValue)
		{
			ssRoadBaseLine = ssSelect;
// 			ssRoadBaseLine += ssSelect;
// 			ssRoadBaseLine.Redraw(3);
		}
		else
		{
			return 0;
		}
/*	}*/

	if (ssRoadBaseLine.Length() == 0)
		return 0;

	if (!JudgeRoadBaseLineIsContinue(ssRoadBaseLine, pRoadBaseLine))//判断选择道路基准线是否连续
	{
		ads_prompt(_T("\n所选道路基准线不连续,请检查！"));
		return -1;
	}
	else
	{
		return kRetEsc;
	}
}
//计算生成的标高数据,m_ptProjectStart为点A, m_ptProjectend为点B, ptSelect为点C，以A点为基点进行计算
CString CRoadElevStyle::CalcElevData(XPoly2D &RoadBaseLine, XPoint ptSelect)
{
	// 获取AC距离
	double dLen(0.0);
	if (m_bSelectRoadLine)
		dLen = abs((RoadBaseLine.PathDistance2d(m_ptProjectStart) - RoadBaseLine.PathDistance2d(ptSelect)));
	else
	{
		dLen = (m_ptProjectStart.Distance(ptSelect));
		AcGeVector3d vecAC = ptSelect - m_ptProjectStart;
		AcGeVector3d vecAB = m_ptProjectend - m_ptProjectStart;
		if (abs(vecAC.angleTo(vecAB)) > 1E-6)// 判断点C，在基点A左侧还是右侧，如果左侧，则AC距离为负
			dLen = 0 - dLen;
	}

	// 根据不同情况获取标高点
	double dNewElev(0.0);

	// 点取一个标高点
	if (m_bsingleElev)
	{
		double dGrade = abs(m_dRoadGrade);
		double dTmp = (dGrade / 100 + (dGrade - (dGrade / 100) * 100))*dLen;
		if (m_dRoadGrade > 0)
		{
			if (!DocGetMeterUnitDraw())
				dNewElev = (dTmp / 1000 + (dTmp - (dTmp / 1000) * 1000)) + m_dStartElevation;
			else
				dNewElev = (dTmp + m_dStartElevation);
		}
		else
		{
			if (!DocGetMeterUnitDraw())
				dNewElev = m_dStartElevation - (dTmp / 1000 + (dTmp - (dTmp / 1000) * 1000));
			else
				dNewElev = m_dStartElevation - dTmp;
		}
	}
	else //点取两个标高点
	{
		double dElev = abs(m_dStartElevation - m_dEndElevation);
		//选择道路中心线
		if (m_bSelectRoadLine)
		{
			double dTmp = RoadBaseLine.PathDistance2d(m_ptProjectStart) - RoadBaseLine.PathDistance2d(m_ptProjectend);//+-方向
			if (m_dStartElevation < m_dEndElevation)
			{
				if (dTmp > 0)
				{
					if ((RoadBaseLine.PathDistance2d(ptSelect) - RoadBaseLine.PathDistance2d(m_ptProjectStart)) < 0)
						dNewElev = (dElev / m_dRoadLenth + (dElev - (dElev / m_dRoadLenth)*m_dRoadLenth)) * dLen + m_dStartElevation;
					else
						dNewElev = m_dStartElevation - (dElev / m_dRoadLenth + (dElev - (dElev / m_dRoadLenth)*m_dRoadLenth)) * dLen;
				}
				else
				{
					if ((RoadBaseLine.PathDistance2d(ptSelect) - RoadBaseLine.PathDistance2d(m_ptProjectStart)) > 0)
						dNewElev = (dElev / m_dRoadLenth + (dElev - (dElev / m_dRoadLenth)*m_dRoadLenth)) * dLen + m_dStartElevation;
					else
						dNewElev = m_dStartElevation - (dElev / m_dRoadLenth + (dElev - (dElev / m_dRoadLenth)*m_dRoadLenth)) * dLen;
				}
			}
			else if (m_dStartElevation > m_dEndElevation)//
			{
				if (dTmp > 0)
				{
					if ((RoadBaseLine.PathDistance2d(ptSelect) - RoadBaseLine.PathDistance2d(m_ptProjectStart)) >0)
						dNewElev = (dElev / m_dRoadLenth + (dElev - (dElev / m_dRoadLenth)*m_dRoadLenth)) * dLen + m_dStartElevation;
					else
						dNewElev = m_dStartElevation - (dElev / m_dRoadLenth + (dElev - (dElev / m_dRoadLenth)*m_dRoadLenth)) * dLen;
				}
				else
				{
					if ((RoadBaseLine.PathDistance2d(ptSelect) - RoadBaseLine.PathDistance2d(m_ptProjectStart)) < 0)
						dNewElev = (dElev / m_dRoadLenth + (dElev - (dElev / m_dRoadLenth)*m_dRoadLenth)) * dLen + m_dStartElevation;
					else
						dNewElev = m_dStartElevation - (dElev / m_dRoadLenth + (dElev - (dElev / m_dRoadLenth)*m_dRoadLenth)) * dLen;
				}
			}
			else
				dNewElev = m_dStartElevation;
		}
		else //未选择道路中心线，按标高点连线自动生成
		{
			m_dRoadLenth = m_ptProjectStart.Distance(m_ptProjectend); //L
			dNewElev = dLen / m_dRoadLenth * (m_dEndElevation - m_dStartElevation) + m_dStartElevation;
		}
	}

	//基准标高
	CString strRet(_T(""));
	if (g_iSelPrecision)
	{
		strRet.Format(_T("%.3f"), dNewElev);
	}
	else
		strRet.Format(_T("%.2f"), dNewElev);
	
	return strRet;
}

bool CRoadElevStyle::JudgeRoadBaseLineIsContinue(const PickSet &ssRoadBaseLine, XPoly2D &roadBaseLine2d)
{
	
	XPoly2D NewroadBaseLine2d;
	XPoly2D poly2d;
	int nRoadLen = ssRoadBaseLine.Length();
	int iNum = nRoadLen;
	AcDbObjectId entid;
	if (nRoadLen == 1)//只有选择一个，正确不需要在判断
	{
		Entity ent = ssRoadBaseLine[0];//取选择集第一个实体
		/*XCurveSegment cv(ent);*/
		/*cv.AsPoly2D(roadBaseLine2d);*/
		roadBaseLine2d = XPoly2D(ent);//转为2D
		return true;
	}
	int nFirstPoly(0), nSecondPoly(0);
	int nInterNum = 0;

	//add begin by zjt 20160929
	//////////////////////////////////////////////////////////////////////////多个选择判断
	TGGePoly2D pPoly2D;
	Entity ent = ssRoadBaseLine[0];
	XCurveSegment cvFirst(ent);//曲线
	cvFirst.AsPoly2D(pPoly2D);//转换为TGGePoly2D
	AcGePoint3d ptStart, ptEnd;
	ptStart = pPoly2D.GetPointListAt(0)->AsAcGePoint3d();//获取曲线中首点的坐标
	ptEnd = pPoly2D.GetPointListAt(pPoly2D.Length() - 1)->AsAcGePoint3d();//获取曲线最后一点的坐标
	AcGePoint3d ptHead, ptTail;

	for (int nEndpt = 0; nEndpt < nRoadLen; ++nEndpt)
	{
		for (int n = 0; n < nRoadLen; ++n)
		{
			if (n == nEndpt)
				continue;
			TGGePoly2D poly2dTemp(ssRoadBaseLine[n]);
			ptHead = poly2dTemp.GetPointListAt(0)->AsAcGePoint3d();
			ptTail = poly2dTemp.GetPointListAt(poly2dTemp.Length() - 1)->AsAcGePoint3d();

			if (ptStart.isEqualTo(ptHead) || ptStart.isEqualTo(ptTail)) //判断第一根线的起点是否与其他实体有重合
			{
				roadBaseLine2d.InsertNodeAt(nInterNum, ptStart, cvFirst.GetBulge());
				++nInterNum;
				roadBaseLine2d.InsertNodeAt(nInterNum, ptEnd, 0);
				break;
			}
			else if (ptEnd.isEqualTo(ptHead) || ptEnd.isEqualTo(ptTail)) //判断第一根线的终点是否与其他实体有重合
			{
				roadBaseLine2d.InsertNodeAt(nInterNum, ptStart, cvFirst.GetBulge());
				++nInterNum;
				roadBaseLine2d.InsertNodeAt(nInterNum, ptEnd, 0);
				break;
			}
		}
		if (nInterNum == 0)
		{
			return false;
		}
		if (nInterNum == 1)
		{
			break;
		}
	}
	for (int num = 0; num < nRoadLen - 1; ++num)
	{
		for (int i = 1; i < nRoadLen; ++i)
		{
			if (i == nFirstPoly || i == nSecondPoly) //判断如果已经添加过该实体的断点则跳过该实体
				continue;
			TGGePoly2D poly2dTemp;
			Entity ent = ssRoadBaseLine[i]; //遍历实体
			XCurveSegment cv(ent);
			cv.AsPoly2D(poly2dTemp);//转为2D
			ptHead = poly2dTemp.GetPointListAt(0)->AsAcGePoint3d(); //当前实体的起点
			ptTail = poly2dTemp.GetPointListAt(poly2dTemp.Length() - 1)->AsAcGePoint3d(); //当前实体的终点
			if (ptStart.isEqualTo(ptHead))
			{
				++nInterNum;
				ptStart = ptTail;
				roadBaseLine2d.InsertNodeAt(0, ptStart, -cv.GetBulge()); //添加点
				nFirstPoly = i; //记录已经添加过的点所属实体的位置
				break;
			}
			else if (ptStart.isEqualTo(ptTail))
			{
				++nInterNum;
				ptStart = ptHead;
				roadBaseLine2d.InsertNodeAt(0, ptStart, cv.GetBulge());
				nFirstPoly = i;
				break;
			}
			if (ptEnd.isEqualTo(ptHead))
			{
				roadBaseLine2d.SetBulge(nInterNum, cv.GetBulge());
				++nInterNum;
				ptEnd = ptTail;
				roadBaseLine2d.InsertNodeAt(nInterNum, ptEnd, 0);
				nSecondPoly = i;
				break;
			}
			else if (ptEnd.isEqualTo(ptTail))
			{
				roadBaseLine2d.SetBulge(nInterNum, -cv.GetBulge());
				++nInterNum;
				ptEnd = ptHead;
				roadBaseLine2d.InsertNodeAt(nInterNum, ptEnd, 0);
				nSecondPoly = i;
				break;
			}
		}
	}
	if (nInterNum == nRoadLen)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//add end

//判断标高点是否在墙上
bool CRoadElevStyle::JudgeElevationOnRoadCenter(const XPoly2D &roadBaseLine2d, const PickSet &ssElevation)
{
	XPoint ptStart, ptEnd;
	int len = ssElevation.Length();
	for (long i = 0; i < len; i++)
	{
		Entity ent = ssElevation[i];
		if (ent.Is(_T("ATS_ELEVATION")))
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSymbElevation, pEnt);
			if (pEnt)
			{
				if (i == 0)
				{
					ptStart = pEnt->GetLocation();//返回的是世界坐标的点
					pEnt->GetElev1(m_dStartElevation);
					CString strTemp = pEnt->GetText();
					if (strTemp.Left(1) == _T("%"))//判断是否有正负号,如果有去掉
						strTemp = strTemp.Right(strTemp.GetLength() - 3);
					m_dStartElevation = _wtof(strTemp);
					

				}
				else
				{
					ptEnd = pEnt->GetLocation();
					pEnt->GetElev1(m_dEndElevation);
					CString strTemp = pEnt->GetText();
					if (strTemp.Left(1) == _T("%"))//判断是否有正负号,如果有去掉
						strTemp = strTemp.Right(strTemp.GetLength() - 3);
					m_dEndElevation = _wtof(strTemp);
				}
			}
			OPENOBJ_END();
		}
	}
	//获取标高投影点
	len = roadBaseLine2d.Length() - 1;
	bool bStartOnLine = false, bEndOnLine = false;
	double dMinDis = 1.7976931348623158e+308;;
	TADSGePoint3d ptHead, ptTail;
	BOOL bStart(false), bEnd(false);//在路线连续的情况下判断是否将标高的两端选中
	for (int i = 0; i < len; ++i)
	{
		TGGeDirectionCurve curve;
		XPoint ptProjectTemp;
		roadBaseLine2d.Nth(i, curve);
		ptHead = curve.GetStartPoint();//判断是否将起点标高的所在位置加入
		if (ptHead == ptStart)
			bStart = true;
		curve.ProjectToMe(ptStart, ptProjectTemp);
		if (!roadBaseLine2d.HitTestOnCurve(ptProjectTemp))//延长线
		{
			continue;
		}
		double dMinDisTemp = abs(ptProjectTemp.Distance(ptStart));
		if (dMinDisTemp < dMinDis)
		{
			dMinDis = dMinDisTemp;
			m_ptProjectStart = ptProjectTemp;
			bStartOnLine = true;
		}
	}

	dMinDis = 1.7976931348623158e+308;;
	for (int i = 0; i < len; ++i)
	{
		TGGeDirectionCurve curve;
		XPoint ptProjectTemp;
		roadBaseLine2d.Nth(i, curve);
		ptTail = curve.GetEndPoint();//判断是否将终点标高的所在位置加入
		if (ptTail == ptEnd)
			bEnd = true;
		curve.ProjectToMe(ptEnd, ptProjectTemp);
		if (!roadBaseLine2d.HitTestOnCurve(ptProjectTemp))
		{
			continue;
		}
		double dMinDisTemp = abs(ptProjectTemp.Distance(ptEnd));
		if (dMinDisTemp < dMinDis)
		{
			dMinDis = dMinDisTemp;
			m_ptProjectend = ptProjectTemp;
			bEndOnLine = true;
		}
	}
	if (m_bsingleElev)
		bEndOnLine = true;
	//投影点间的道路长度
	m_dRoadLenth = abs(roadBaseLine2d.PathDistance2d(m_ptProjectStart) - roadBaseLine2d.PathDistance2d(m_ptProjectend));
	if (!bStartOnLine)
	{
		acutPrintf(_T("\n该标高位置超出标注范围！"));
		return false;
	}
	else if (!bEndOnLine)
	{
		acutPrintf(_T("\n该标高位置超出标注范围！"));
		return false;
	}
	if ((!bStart) && (!bEnd))
	{
		acutPrintf(_T("\n该标高位置超出标注范围！"));
		return false;
	}
	return true;
}

//获取默认的直线
bool CRoadElevStyle::GetDefaultLine(const PickSet ssElevation, XPoly2D &polyDefalutLine)
{
	XPoint ptStart, ptEnd;
	int len = ssElevation.Length();
	if (len != 2)
		return false;

	for (long i = 0; i < len; i++)
	{
		Entity ent = ssElevation[i];
		if (ent.Is(_T("ATS_ELEVATION")))
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbSymbElevation, pEnt);
			if (pEnt)
			{
				if (i == 0)
				{
					ptStart = pEnt->GetLocation();//返回的是世界坐标的点
					pEnt->GetElev1(m_dStartElevation);
					CString strTemp = pEnt->GetText();
					if (strTemp.Left(1) == _T("%"))//判断是否有正负号,如果有去掉
						strTemp = strTemp.Right(strTemp.GetLength() - 3);
					m_dStartElevation = _wtof(strTemp);
				}
				else
				{
					ptEnd = pEnt->GetLocation();
					pEnt->GetElev1(m_dEndElevation);
					CString strTemp = pEnt->GetText();
					if (strTemp.Left(1) == _T("%"))//判断是否有正负号,如果有去掉
						strTemp = strTemp.Right(strTemp.GetLength() - 3);
					m_dEndElevation = _wtof(strTemp);
				}
			}
			OPENOBJ_END();
		}
	}
	polyDefalutLine.AppendPointListAt(new TADSGePoint3d(ptStart));
	polyDefalutLine.AppendBugle(0.0);
	polyDefalutLine.AppendPointListAt(new TADSGePoint3d(ptEnd));
	polyDefalutLine.AppendBugle(0.0);
	polyDefalutLine.SetFlag(0);
	m_ptProjectStart = ptStart;
	m_ptProjectend = ptEnd;
	return true;
}