#include "stdafx.h"
#include "ParkingAlterDlg.h"
#include "TDbParking.h"

extern XString InitCarBlock();
extern AcDbObjectId FormBlock(AcDbEntity* pEnt,XPoint &pt,AcDbObjectId &idlayer);
//单排布置车位时的编号
extern CString GetTextForSingle(CString &strPrefix, CString &strPostfix, BOOL bIsFirst, int &nNum, int &nNumLength);
//双排时布置车位的编号
extern CString GetTextForDouble(CString &strPrefix, CString &strPostfix, int &nTasksNum, int nNumLength);
extern int CutStrToPreAndnum(CString &strSerialNum, CString &strPrefix, CString &strPostFix, int* nNum);
extern void CutOutArc(TGGeCurveSegment &segSrc, TGGeCurveSegment &segRet, XPoint &ptOnArc, BOOL bIsFromSt);
namespace
{
	enum  DIrecRetCode
	{
		eAllIsArc,
		eLeftStToEnd,
		eRightStToEnd,
		eLeftEndToSt,
		eRightEndToSt,
		eCancle
	};
}
//编号数据
struct ParkingTextData
{
	CString strSerialNum;
	XPoint ptText;
	double dTextHeight;
	AcDbObjectId idText;
	AcDbObjectId idTextStyle;

};
struct ParkingBlockData
{
	XPoint ptBlockCenter;
	AcDbObjectId idBlock;
};
struct ObliqueLineData
{
	XPoly2D polyLine;
	AcDbObjectId idLine;
};
struct PakingSegData
{
	TGGeCurveSegment segPath;
	BOOL bIsDoubleRow;          //是否是双排
	BOOL bIsLeft;               //单排时车位与线的方位
	CString strStartSerial;     //连续车位的起始编号
	CString strEndSerial;       //双排车位的结束编号
	int nParkingNum;            //一组车位的单排车位个数
	double dWidth;              //车位宽度（基于弧布置的车位，dWidth为一个车位的弧长）
	int nAngle;                 
	double dDept;
	int nTextLoc;               //文字位置
	double dTextHeight;         //文字高度
	int nStyle;
	AcDbObjectId idTextStyle;
	int nLeftQMode;             //左边车位所在象限
	int nRightQMode;            //右边车位所在象限
	BOOL BIsCCW;
};
struct OneParking
{
	XPoly2D poly2D;
	ParkingTextData stText;
	BOOL bIsBelongTo;              //是否与其他车位在同一线上
	int m_nStyle;                  //车位样式
	AcDbObjectId idPoly;           //边线ID  用于删除实体
	AcDbObjectId idSlashOrBlock;   //斜线或图块Id
};
//转换弧度
int GetSettingAngle(double dAngle)
{
	int nAngle = 0;
	double dBugle = dAngle * 180 / PI;
	nAngle = dAngle * 180 / PI;
	if (abs(nAngle - dBugle) > 0.5)
	{
		nAngle += 1;
	}
	/*if (abs(dAngle - 0.5 * PI) < 1.0e-6)
	{
		nAngle = 90;
	}
	else if (abs(dAngle - (120 * PI / 180)) < 1.0e-6)
	{
		nAngle = 120;
	}
	else if (abs(dAngle - (60 *PI / 180)) < 1.0e-6)
	{
		nAngle = 60;
	}
	else if (abs(dAngle - 0.75 * PI) < 1.0e-6)
	{
		nAngle = 135;
	}
	else if (abs(dAngle - 0.25 * PI) < 1.0e-6)
	{
		nAngle = 45;
	}
	else if (abs(dAngle - 150 * PI / 180) < 1.0e-6)
	{
		nAngle = 150;
	}
	else if (abs(dAngle - 30 * PI / 180) < 1.0e-6)
	{
		nAngle = 30;
	}*/
	return nAngle;
}
//沿端点延长曲线
void ExtendArc(TGGeCurveSegment &seg, double dLength, BOOL bIsStTo)
{
	XArc arc = seg.GetArc();
	XPoint ptSt, ptEnd, ptCenter, ptThird;
	double dRad, dChordLength;
	dRad = arc.GetRadius();
	double dAngle = abs(dLength) / dRad;
	/*dAngle = 0.5 * (PI - dAngle);*/
	dChordLength = 2 * dRad * cos(dAngle);
	ptCenter = arc.GetCenterPt();
	arc.GetStartPoint(ptSt);
	arc.GetEndPoint(ptEnd);
	AcGeVector3d vec;
	if (bIsStTo)
	{
		vec = ptSt - ptCenter;
	}
	else
	{
		vec = ptEnd - ptCenter;
	}
	if (dLength > 0)
	{		
		if (seg.GetBulge() > 0)
		{
			if (bIsStTo)
			{
				vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
			}
			else
			{
				vec = vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
			}
		}
		else
		{
			if (bIsStTo)
			{
				vec = vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
			}
			else
			{
				vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
			}
		}
		ptThird = ptCenter + dRad * vec / vec.length();
		if (bIsStTo)
		{
			XArc arcTemp(ptThird, ptSt, ptEnd);
			TGGeCurveSegment segtemp;
			segtemp = arcTemp;
			if (seg.GetBulge() > 0)
			{
				seg = segtemp;
			}
			else
			{
				seg.SetStartPoint(ptThird);
				seg.SetEndPoint(ptEnd);
				seg.SetBulge(-segtemp.GetBulge());
			}
		}
		else
		{
			XArc arcTemp(ptSt, ptEnd, ptThird);
			TGGeCurveSegment segtemp;
			segtemp = arcTemp;
			if (seg.GetBulge() > 0)
			{
				seg = segtemp;
			}
			else
			{
				seg.SetStartPoint(ptSt);
				seg.SetEndPoint(ptThird);
				seg.SetBulge(-segtemp.GetBulge());
			}
		}
	}
	else
	{
		if (seg.GetBulge() > 0)
		{
			if (bIsStTo)
			{
				vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
			}
			else
			{
				vec = vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
			}
		}
		else
		{
			if (bIsStTo)
			{
				vec = vec.rotateBy(dAngle, AcGeVector3d::kZAxis);
			}
			else
			{
				vec = vec.rotateBy(-dAngle, AcGeVector3d::kZAxis);
			}
		}
		ptThird = ptCenter + dRad * vec / vec.length();
		if (bIsStTo)
		{
			TGGeCurveSegment segTemp = seg;
			CutOutArc(segTemp, seg, ptThird, FALSE);
			
		}
		else
		{
			TGGeCurveSegment segTemp = seg;
			CutOutArc(segTemp, seg, ptThird, TRUE);
		}
	}
	

}
//沿弧布置车位时，一个车位的弧长
double GetOneParkingArcLength(XArc &arc, double dWidth, double dDept, BOOL bIsInside)
{
	double dArcLength = 0;
	double dRad = arc.GetRadius();
	if (bIsInside)
	{
		AcDbArc *pArc = new AcDbArc(arc.GetCenterPt(), arc.GetRadius(), arc.GetStarAngle(), arc.GetEndAngle());
		TADSGePoint3d ptStart;
		pArc->getStartPoint(ptStart);
		TADSGePoint3d ptEnd;
		pArc->getEndPoint(ptEnd);
		double dMax = ptStart.AsAcGePoint3d().distanceTo(ptEnd);
		TADSGePoint3d ptCenter = pArc->center();
		TADSGePoint3d ptVertex1 = ptStart;
		TADSGePoint3d ptVertex2;
		TADSGePoint3d ptVertex3;
		TADSGePoint3d ptVertex4;
		for (int i=dWidth; i<(int)dMax; i++)
		{
			pArc->getPointAtDist(i,ptVertex2);
			XLine lineBase(ptVertex1,ptVertex2);
			ads_real rAng = lineBase.Direction();
			ads_point pt1;
			ads_point pt2;
			acutPolar(ptVertex1,(rAng+0.5*PI),dDept,pt1);
			acutPolar(ptVertex2,(rAng+0.5*PI),dDept,pt2);

			XLine line1(pt1,pt2);
			XLine line3(ptCenter,ptVertex2);
			XLine line4(ptCenter,ptVertex1);
			line1.Intersection(&line3,ptVertex3);
			line1.Intersection(&line4,ptVertex4);
			//离散计算
			if (fabs(ptVertex3.AsAcGePoint3d().distanceTo(ptVertex4) - dWidth) < 1 )
			{
				AcGeVector3d v1 = ptVertex1 - pArc->center();
				AcGeVector3d v2 = ptVertex2 - pArc->center();
				dArcLength =  v1.angleTo(v2) * dRad;
				break;
			}
		}
	}
	else
	{
		dArcLength = dWidth;
	}
	return dArcLength;

}

void AddSerialNumForArc(XPoint &ptCenter, TDbParking &dbPark, CString &strSerialNum, PakingSegData* pSegData)
{
	XPoint ptText = dbPark.GetPtText();
	double angle = ads_angle(XPoint(ptCenter), XPoint(ptText));
	if (ptText.y < ptCenter.y)
		angle += 0.5 * PI;
	else
		angle -= 0.5 * PI;
	TDbText* text = new TDbText;
	text->SetText(strSerialNum);
	text->SetHeight(pSegData->dTextHeight);
	text->SetRotation(angle); 	
	text->SetLocation(dbPark.GetPtText());
	if (pSegData->idTextStyle.isValid())
		text->SetStyleId(pSegData->idTextStyle);
	else
		text->SetStyleId(acdbCurDwg()->textstyle());
	text->setLayer(::InitLayer(LAY_PKNG_SING));
	text->SetAlignment(XExplodeDraw::kMiddleCenter);
	AddToCurrentSpace(text, Adesk::kTrue);
}

void AddSerialNum(TDbParking &dbPark, CString &strSerialNum, AcGeVector3d &VectorOffet, PakingSegData *pSegData, int nSize = 1)
{
	AcGeVector3d vec = AcGeVector3d(1, 0, 0);
	TDbText* text = new TDbText;
	text->SetText(strSerialNum);
	text->SetHeight(pSegData->dTextHeight);
	int nAngle = pSegData->nAngle;
	double dangle = vec.angleTo(VectorOffet);
	if (pSegData->dWidth > pSegData->dDept)
	{
		if ((vec.angleTo(VectorOffet) > 0.5 * PI))
		{
			if (nSize == -1)
			{
				if (nAngle == 90)
				{
					text->SetRotation(dbPark.GetRotAngle()); 
				}
				else
				{
					text->SetRotation(dbPark.GetRotAngle() + PI); 
				}
			}
			else
			{
				if (nAngle == 90)
				{
					text->SetRotation(dbPark.GetRotAngle() + PI); 
				}
				else
				{
					text->SetRotation(dbPark.GetRotAngle() + PI); 
				}
			}
		}
		else
		{
			if (nSize == -1)
			{
				if (nAngle == 90)
				{
					text->SetRotation(dbPark.GetRotAngle() + PI);
				}
				else
				{
					text->SetRotation(dbPark.GetRotAngle());
				}
			}
			else
			{
				if (nAngle == 90)
				{
					text->SetRotation(dbPark.GetRotAngle());
				}
				else
				{
					text->SetRotation(dbPark.GetRotAngle());
				}
			}

		}
	}
	else
	{
		if ((vec.angleTo(VectorOffet) > 0.5 * PI))
		{
			if (nSize == -1)
			{
				if (nAngle == 90)
				{
					text->SetRotation(dbPark.GetRotAngle()); 
				}
				else
				{
					text->SetRotation(dbPark.GetRotAngle() + PI + nAngle*PI/180); 
				}
			}
			else
			{
				if (nAngle == 90)
				{
					text->SetRotation(dbPark.GetRotAngle() + PI); 
				}
				else
				{
					text->SetRotation(dbPark.GetRotAngle() + PI  + (90 - nAngle)*PI/180); 
				}
			}
		}
		else
		{
			if (nSize == -1)
			{
				if (nAngle == 90)
				{
					text->SetRotation(dbPark.GetRotAngle() + PI);
				}
				else
				{
					text->SetRotation(dbPark.GetRotAngle() + nAngle*PI/180);
				}
			}
			else
			{
				if (nAngle == 90)
				{
					text->SetRotation(dbPark.GetRotAngle());
				}
				else
				{
					text->SetRotation(dbPark.GetRotAngle() + (90 - nAngle)*PI/180);
				}
			}

		}
	}
	text->SetLocation(dbPark.GetPtText());
	if (pSegData->idTextStyle.isValid())
		text->SetStyleId(pSegData->idTextStyle);
	else
		text->SetStyleId(acdbCurDwg()->textstyle());
	text->setLayer(::InitLayer(LAY_PKNG_SING));
	text->SetAlignment(XExplodeDraw::kMiddleCenter);
	AddToCurrentSpace(text, Adesk::kTrue);
}
void GetParkInfo(AcGeVector3d &outVector,int &ioutNum,double &doutAngl,
				 TGGeCurveSegment &segBase,int angle, double iWidth, double iHeight,int iSize,int iIndex)
{
	AcGeVector3d vec(0,0,0);
	double dRoateAngle = 0;
	int iNum = 0;
	if (segBase.GetLength() < 0)
	{
		return ;
	}
	//圆弧
	if (abs(segBase.GetBulge()) > 1.0e-6)
	{
		XArc arc = segBase.GetArc();
		//圆弧外侧
		AcDbArc* pArc = new AcDbArc(arc.GetCenterPt(), arc.GetRadius(), arc.GetStarAngle(), arc.GetEndAngle());
		if (iSize == -1)
		{
			TADSGePoint3d ptVertex1;
			pArc->getStartPoint(ptVertex1);
			TADSGePoint3d ptVertex2;
			pArc->getPointAtDist(iWidth,ptVertex2);
			vec = ptVertex2 - ptVertex1;

			TADSGePoint3d ptEnd;
			pArc->getEndPoint(ptEnd);
			AcGeVector3d v1 = ptVertex1 - pArc->center();
			AcGeVector3d v2 = ptVertex2 - pArc->center();
			AcGeVector3d v3 = ptEnd - pArc->center();

			dRoateAngle = v1.angleTo(v2);
			iNum = v1.angleTo(v3)/dRoateAngle;
		}
		//圆弧内侧
		else if (iSize == 1)
		{
			TADSGePoint3d ptStart;
			pArc->getStartPoint(ptStart);
			TADSGePoint3d ptEnd;
			pArc->getEndPoint(ptEnd);
			double dMax = ptStart.AsAcGePoint3d().distanceTo(ptEnd);
			TADSGePoint3d ptCenter = pArc->center();

			TADSGePoint3d ptVertex1 = ptStart;
			TADSGePoint3d ptVertex2;
			TADSGePoint3d ptVertex3;
			TADSGePoint3d ptVertex4;
			for (int i=iWidth; i<(int)dMax; i++)
			{
				pArc->getPointAtDist(i,ptVertex2);
				XLine lineBase(ptVertex1,ptVertex2);
				ads_real rAng = lineBase.Direction();
				ads_point pt1;
				ads_point pt2;
				acutPolar(ptVertex1,(rAng+iSize*0.5*PI),iHeight,pt1);
				acutPolar(ptVertex2,(rAng+iSize*0.5*PI),iHeight,pt2);

				XLine line1(pt1,pt2);
				XLine line3(ptCenter,ptVertex2);
				XLine line4(ptCenter,ptVertex1);
				line1.Intersection(&line3,ptVertex3);
				line1.Intersection(&line4,ptVertex4);
				//离散计算
				if (fabs(ptVertex3.AsAcGePoint3d().distanceTo(ptVertex4) - iWidth) < 1 )
				{
					vec = ptVertex2 - ptVertex1;

					AcGeVector3d v1 = ptVertex1 - pArc->center();
					AcGeVector3d v2 = ptVertex2 - pArc->center();
					AcGeVector3d v3 = ptEnd - pArc->center();

					dRoateAngle = v1.angleTo(v2);
					iNum = v1.angleTo(v3)/dRoateAngle;
					break;
				}
			}
		}
	}
	else
	{
		TADSGePoint3d ptStart;
		ptStart = segBase.GetStartPoint();
		TADSGePoint3d ptEnd;
		ptEnd = segBase.GetEndPoint();
		XLine lineBase(ptStart,ptEnd);
		ads_real rAngBase = lineBase.Direction();

		ads_point ptads4;
		acutPolar(ptStart,(rAngBase + angle * PI / 180),iHeight,ptads4);
		TADSGePoint3d ptVertex4 = ptads4;

		TADSGePoint3d ptVertex2;
		ads_point pt20;
		ads_point pt30;
		XLine line14(ptStart,ptVertex4);
		ads_real rAng14 = line14.Direction();
		acutPolar(ptStart,(rAng14-0.5 * PI),iWidth,pt20);
		acutPolar(ptVertex4,(rAng14-0.5 * PI),iWidth,pt30);
		XLine line23(pt20,pt30);
		ads_point pt2;
		acutPolar(ptStart,(rAngBase),100,pt2);
		XLine line2(ptStart,pt2);
		line23.Intersection(&line2,ptVertex2);

		vec = ptVertex2 - ptStart;
		double d = vec.length();
		double dLength = (ptStart.AsAcGePoint3d().distanceTo(ptEnd));
		iNum = (ptStart.AsAcGePoint3d().distanceTo(ptEnd))/vec.length();
	}
	outVector = vec;
	ioutNum = iNum;
	doutAngl = dRoateAngle;
}
//将边线、斜线、图块、编号归并到各个车位
void AnalysisParkingToGroup(TDPtrList<ObliqueLineData> &lstPoly, TDPtrList<ObliqueLineData> &lstSingleSlash, TDPtrList<ObliqueLineData> &lstDoubleSlash, TDPtrList<ParkingBlockData> &lstPtBlock, TDPtrList<ParkingTextData> &lstText, TDPtrList<OneParking> &lstParking, double length)
{
	for (int i = 0; i < lstPoly.Length(); ++i)
	{
		double dDept = 0;
		ObliqueLineData* lineData;
		XPoint ptSt, ptEnd, ptMid;
		XPoly2D polyFrame;		
		lineData = lstPoly.GetAt(i);
		/*if (lineData->idLine.isValid())
		{
			OPENOBJ_BEGIN(lineData->idLine, AcDb::kForWrite, AcDbPolyline, pPoly)
				if (pPoly)
				{
					pParkingData->idPoly = pPoly->objectId();
				}
				OPENOBJ_END()
		}*/
		polyFrame = lineData->polyLine;
		OneParking* pParkingData = new OneParking;
		pParkingData->m_nStyle = 0;
		pParkingData->poly2D = polyFrame;
		pParkingData->bIsBelongTo = FALSE;
		pParkingData->m_nStyle = 0;
		pParkingData->idPoly = lineData->idLine;
		ptSt = *polyFrame.GetPointListAt(0);
		ptEnd = *polyFrame.GetPointListAt(1);
		dDept = ptEnd.Distance(*polyFrame.GetPointListAt(2));
		dDept = dDept + 0.8 * length * DocGetPScale();
		XLine line(ptSt, ptEnd);
		AcGeVector3d vec;
		AcGeVector3d vecText;
		if (abs(polyFrame.GetPointListAt(0)->Distance(*polyFrame.GetPointListAt(1)) - polyFrame.GetPointListAt(2)->Distance(*polyFrame.GetPointListAt(3))) > 1.0e-6)
		{
			vec = ptEnd - ptSt;		
			if (line.OnWhichSide(*polyFrame.GetPointListAt(2)))
			{
				vec = vec.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
			}
			else
			{
				vec = vec.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
			}
		}
		else
		{
			vec = *polyFrame.GetPointListAt(2) - *polyFrame.GetPointListAt(1);
			vecText = ptEnd - ptSt;		
			if (line.OnWhichSide(*polyFrame.GetPointListAt(2)))
			{
				vecText = vecText.rotateBy(-0.5 * PI, AcGeVector3d::kZAxis);
			}
			else
			{
				vecText = vecText.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
			}
		}	
		ptMid = line.MidPoint();
		XLine lineMid(ptMid, ptMid + dDept * vec / vec.length());
		XLine line34(*polyFrame.GetPointListAt(2), *polyFrame.GetPointListAt(3));
		XLine lineText(line34.MidPoint(), line34.MidPoint() + 0.8 * length * DocGetPScale() * vecText / vecText.length());
		for (int k = 0; k < lstText.Length(); ++k)
		{
			ParkingTextData stText;
			stText = *lstText.GetAt(k);
			int nFlag = lineMid.HitTest2d(stText.ptText);
			int nTextFlag = lineText.HitTest2d(stText.ptText);
			if (((nFlag >= 3) && (nFlag <= 5)) || ((nTextFlag == 5) || (nTextFlag == 7) || (nTextFlag == 4)))
			{
				/*if (stText.idText.isValid())
				{
					AcDbEntity* pEntity;
					OPENOBJ_BEGIN(stText.idText, AcDb::kForWrite, AcDbEntity, pEntity)
						if (pEntity)
						{
							pEntity->erase();
						}
						OPENOBJ_END()
				}*/
				pParkingData->stText = stText;
				break;
			}
		}
		for (int i = 0; i < lstSingleSlash.Length(); i++)
		{
			ObliqueLineData slashData = *lstSingleSlash.GetAt(i);
			XPoly2D polySlash = slashData.polyLine;
			TGGeCurveSegment seg;
			polySlash.Nth(0, seg);
			ptMid = seg.MidPoint();
			int nFlag = lineMid.HitTest2d(ptMid);
			if (lineMid.HitTest2d(ptMid) == 5)
			{
				/*if (slashData.idLine.isValid())
				{
					OPENOBJ_BEGIN(slashData.idLine, AcDb::kForWrite, AcDbPolyline, pPoly)
						if (pPoly)
						{
							pPoly->erase();
						}
						OPENOBJ_END()
				}*/
				pParkingData->m_nStyle = 1;
				pParkingData->idSlashOrBlock = slashData.idLine;
				lstSingleSlash.Remove(i);
				break;
			}
		}
		XLine lineHead(*polyFrame.GetPointListAt(2), *polyFrame.GetPointListAt(3));
		for (int i = 0; i < lstDoubleSlash.Length(); i++)
		{
			ObliqueLineData slashData = *lstDoubleSlash.GetAt(i);
			XPoly2D polySlash = slashData.polyLine;
			int nFlag = lineHead.HitTest2d(*polySlash.GetPointListAt(1));
			if (lineHead.HitTest2d(*polySlash.GetPointListAt(1)) == 5)
			{
				/*if (slashData.idLine.isValid())
				{
				OPENOBJ_BEGIN(slashData.idLine, AcDb::kForWrite, AcDbPolyline, pPoly)
				if (pPoly)
				{
				pPoly->erase();
				}
				OPENOBJ_END()
				}		*/
				pParkingData->m_nStyle = 2;
				pParkingData->idSlashOrBlock = slashData.idLine;
				lstDoubleSlash.Remove(i);
				break;
			}
		}
		
		for (int i = 0; i < lstPtBlock.Length(); i++)
		{
			ParkingBlockData pStblockData = *lstPtBlock.GetAt(i);
			if ((lineMid.HitTest2d(pStblockData.ptBlockCenter) == 5))
			{
				/*if (pStblockData.idBlock.isValid())
				{
					OPENOBJ_BEGIN(pStblockData.idBlock, AcDb::kForWrite, AcDbBlockReference, pBlock)
						if (pBlock)
						{
							pBlock->erase();
						}
						OPENOBJ_END()
				}			*/
				pParkingData->m_nStyle = 3;
				pParkingData->idSlashOrBlock = pStblockData.idBlock;
				lstPtBlock.Remove(i);
				break;
			}
		}
		lstParking.Append(pParkingData);
	}
}
void DrawParkingForArc(PakingSegData* pSegData, double dWidth, double dDept, XString &sBlockName, AcDbObjectId &idlayer)
{
	AcGeVector3d baseVector(AcGeVector3d(0,0,0));
	int iNum = 0;
	double dAngl = 0, dOffset = 0;
	BOOL bIsDrawText = FALSE;
	XArc arc = pSegData->segPath.GetArc();
	if (!pSegData->strStartSerial.IsEmpty())
	{
		bIsDrawText = TRUE;
	}
	if (bIsDrawText)
	{
		switch (pSegData->nTextLoc)
		{
		case 0:
			dOffset = /*dDept*/ + 0.8 * pSegData->dTextHeight * DocGetPScale();
			break;
		case 1:
			dOffset = /*dDept */- 0.8 * pSegData->dTextHeight * DocGetPScale();
			break;
		case 2:
			dOffset = -0.5 * dDept;
			break;
		}
	}
	CString strPrefix, strPostfix, strNum;
	int nNumLength, nStNum, nEndNum, nTasksNum, nDoubleMax;
	BOOL bIsFirst = TRUE;
	if (bIsDrawText)
	{
		bIsDrawText = TRUE;
		nNumLength = CutStrToPreAndnum(pSegData->strStartSerial, strPrefix, strPostfix, &nStNum);
		if (!pSegData->strEndSerial.IsEmpty())
		{
			CString str1, str2;
			CutStrToPreAndnum(pSegData->strEndSerial, str1, str2, &nTasksNum);
		}
	}
	XPoint ptStart, ptCenter;
	ptStart= pSegData->segPath.GetStartPoint();
	ptCenter = arc.GetCenterPt();
	//弧双排
	if(pSegData->bIsDoubleRow)
	{
		
		GetParkInfo(baseVector,iNum,dAngl,pSegData->segPath,pSegData->nAngle,dWidth,dDept,1,0);	
		if (bIsDrawText)
		{
			if (!pSegData->strEndSerial.IsEmpty())
			{
				CString str1, str2;
				CutStrToPreAndnum(pSegData->strEndSerial, str1, str2, &nTasksNum);
			}
			else
			{
				nTasksNum = iNum + nStNum;
			}
		}
		
		for (int i=0;i<iNum;i++)
		{
			TDbParking *pParking = new TDbParking(sBlockName);
			pParking->SetTextOffset(dOffset);
			pParking->Fill(ptCenter, ptStart,baseVector,dWidth,dDept,1,pSegData->nStyle);
			ptStart+=baseVector;
			if (bIsDrawText)
			{
				AddSerialNumForArc(ptCenter, *pParking, GetTextForSingle(strPrefix, strPostfix, bIsFirst, nStNum, nNumLength), pSegData);
				bIsFirst = FALSE;
			}
			
			baseVector.rotateBy(dAngl,AcGeVector3d(0,0,1));
			XPoint pt = pParking->GetBasePt();
			AcDbObjectId id = FormBlock(pParking,pt,idlayer);
		}

		ptStart= pSegData->segPath.GetStartPoint();
		GetParkInfo(baseVector,iNum,dAngl,pSegData->segPath,pSegData->nAngle,dWidth,dDept,-1,0);
		
		if (bIsDrawText)
		{
			if (pSegData->strEndSerial.IsEmpty())
			{
				nTasksNum = nTasksNum + iNum;
				nDoubleMax = nTasksNum + 1;
			}
		}
		for (int j=0;j<iNum;j++)
		{
			TDbParking *pParking = new TDbParking(sBlockName);
			pParking->SetTextOffset(dOffset);
			pParking->Fill(ptCenter, ptStart,baseVector,dWidth,dDept,-1,pSegData->nStyle);
			ptStart+=baseVector;
			if (bIsDrawText)
			{
				CString strTemp = strPrefix;
				AddSerialNumForArc(ptCenter, *pParking, GetTextForDouble(strTemp, strPostfix, nTasksNum, nNumLength), pSegData);
				bIsFirst = FALSE;
				if (j == iNum - 1)
				{
					pSegData->strStartSerial = GetTextForDouble(strTemp, strPostfix, nDoubleMax, nNumLength);
				}
			}
			baseVector.rotateBy(dAngl,AcGeVector3d(0,0,1));
			XPoint pt = pParking->GetBasePt();
			AcDbObjectId id = FormBlock(pParking,pt,idlayer);
		}
	}
	//弧单排
	else
	{
		int iSize = 1;
		if (pSegData->BIsCCW)
		{
			if (!pSegData->bIsLeft)
			{
				iSize = -1;
			}
		}
		else
		{
			if (!pSegData->bIsLeft)
			{
				iSize = -1;
			}
		}
		
		GetParkInfo(baseVector,iNum,dAngl,pSegData->segPath,pSegData->nAngle,dWidth,dDept,iSize,0);
		for (int i=0;i<iNum;i++)
		{
			TDbParking *pParking = new TDbParking(sBlockName);
			pParking->SetTextOffset(dOffset);
			pParking->Fill(ptCenter,TADSGePoint3d(ptStart),baseVector,dWidth,dDept,iSize,pSegData->nStyle);
			ptStart+=baseVector;
			if (bIsDrawText)
			{
				AddSerialNumForArc(ptCenter, *pParking, GetTextForSingle(strPrefix, strPostfix, bIsFirst, nStNum, nNumLength), pSegData);
				if (i == iNum - 1)
				{
					pSegData->strStartSerial = GetTextForSingle(strPrefix, strPostfix, bIsFirst, nStNum, nNumLength);
				}
				bIsFirst = FALSE;
			}		
			baseVector.rotateBy(dAngl,AcGeVector3d(0,0,1));
			XPoint pt = pParking->GetBasePt();
			AcDbObjectId id = FormBlock(pParking,pt,idlayer);
		}

	}
}
void DrawParkingForLine(PakingSegData* pSegData, double dWidth, double dDept, XString &sBlockName, AcDbObjectId &idlayer)
{
	AcGeVector3d baseVector(AcGeVector3d(0,0,0));
	int iNum = 0;
	double dAngl = 0, dOffset = 0;
	BOOL bIsDrawText = FALSE;
	//直线段单排
	if (!pSegData->strStartSerial.IsEmpty())
	{
		bIsDrawText = TRUE;
	}
	if (bIsDrawText)
	{
		switch (pSegData->nTextLoc)
		{
		case 0:
			dOffset = /*dDept +*/ 0.8 * pSegData->dTextHeight * DocGetPScale();
			break;
		case 1:
			dOffset = /*dDept*/ - 0.8 * pSegData->dTextHeight * DocGetPScale();
			break;
		case 2:
			dOffset = -0.5 * dDept;
			break;
		}
	}
	CString strPrefix, strPostfix, strNum;
	int nNumLength, nStNum, nEndNum, nTasksNum, nDoubleMax;
	BOOL bIsFirst = TRUE;
	nNumLength = CutStrToPreAndnum(pSegData->strStartSerial, strPrefix, strPostfix, &nStNum);
	if(!pSegData->bIsDoubleRow)
	{		
		
		XPoint ptStart, ptend;
		ptStart = pSegData->segPath.GetStartPoint();
		ptend = pSegData->segPath.GetEndPoint();
		XLine line(ptStart, ptend);
		GetParkInfo(baseVector,iNum,dAngl,pSegData->segPath,pSegData->nAngle,dWidth,dDept,1,0);
		
		//哪一侧
		int iSize = 1;
		if (!pSegData->bIsLeft)
		{
			iSize = -1;
		}
		for(int i=0;i<iNum;i++)
		{
			TDbParking *pParking = new TDbParking(sBlockName);
			pParking->SetTextOffset(dOffset);
			pParking->Fill(TADSGePoint3d((ptStart+i*baseVector)),baseVector,pSegData->nAngle,dWidth,dDept,1,pSegData->nStyle,pSegData->nLeftQMode);
			XPoint pt = pParking->GetBasePt();
			if (bIsDrawText)
			{
				AddSerialNum(*pParking, GetTextForSingle(strPrefix, strPostfix, bIsFirst, nStNum, nNumLength), baseVector, pSegData, iSize);
				if (i == iNum - 1)
				{
					pSegData->strStartSerial = GetTextForSingle(strPrefix, strPostfix, bIsFirst, nStNum, nNumLength);
				}
				bIsFirst = FALSE;
			}
			AcDbObjectId id = FormBlock(pParking,pt,idlayer);
			
		}
	}
	else
	{
		
		AcGePoint3d ptStart;
		ptStart = pSegData->segPath.GetStartPoint();
		GetParkInfo(baseVector,iNum,dAngl,pSegData->segPath,pSegData->nAngle,dWidth,dDept,1,0);
		if (bIsDrawText)
		{		
			CString str1, str2;
			if (!pSegData->strEndSerial.IsEmpty())
			{
				CutStrToPreAndnum(pSegData->strEndSerial, str1, str2, &nTasksNum);
			}
			else
			{
				nTasksNum = nStNum + 2 * iNum - 1;
				nDoubleMax = nTasksNum + 1;
			}
		}
		for(int i=0;i<iNum;i++)
		{
			TDbParking *pParking = new TDbParking(sBlockName);
			pParking->SetTextOffset(dOffset);
			pParking->Fill(TADSGePoint3d((ptStart+i*baseVector)),baseVector,pSegData->nAngle,dWidth,dDept,1,pSegData->nStyle,pSegData->nLeftQMode);
			XPoint pt = pParking->GetBasePt();
			if (bIsDrawText)
			{
				AddSerialNum(*pParking, GetTextForSingle(strPrefix, strPostfix, bIsFirst, nStNum, nNumLength), baseVector, pSegData);
			}	
			AcDbObjectId id = FormBlock(pParking,pt,idlayer);
			TDbParking *pParking1 = new TDbParking(sBlockName);
			pParking1->SetTextOffset(dOffset);
			pParking1->Fill(TADSGePoint3d((ptStart+i*baseVector)),baseVector,pSegData->nAngle,dWidth,dDept,1,pSegData->nStyle,pSegData->nRightQMode);
			XPoint pt1 = pParking1->GetBasePt();
			CString strTemp = strPrefix;
			if (bIsDrawText)
			{
				AddSerialNum(*pParking1, GetTextForDouble(strTemp, strPostfix, nTasksNum, nNumLength), baseVector, pSegData);
				if (i == iNum - 1)
				{
					pSegData->strStartSerial = GetTextForDouble(strTemp, strPostfix, nDoubleMax, nNumLength);
				}
			}
			AcDbObjectId id1 = FormBlock(pParking1,pt1,idlayer);
			bIsFirst = FALSE;
		}
	}
}
void ChangeParking(CParkingAlterDlg* pDlg, TDPtrList<PakingSegData> &lstSegParking, DIrecRetCode eChangeDirec)
{
	AcDbObjectId idLayer = InitLayer(LAY_PKNG_TSRP);
	XString sName = InitCarBlock();
	double dWidth = 0, dDept = 0;
	XPoint ptSt, ptEnd;
	double dMoveLength = 0;
	CString strSerial = _T("");
	if (pDlg->IsRefromSerial())
	{
		strSerial = pDlg->GetStartSerialNum();
	}
	for (int i = 0; i < lstSegParking.Length(); ++i)
	{
		PakingSegData* pSegData = lstSegParking.GetAt(i);
		dWidth = pSegData->dWidth;
		dDept = pSegData->dDept;
		if (!strSerial.IsEmpty())
		{
			if (pSegData->strStartSerial.IsEmpty())
			{
				if (DocGetMeterUnitDraw())
				{
					pSegData->dTextHeight = 1;
				}
				else
				{
					pSegData->dTextHeight = 10;
				}	
				pSegData->nTextLoc = 0;
			}
			pSegData->strStartSerial = strSerial;
			pSegData->strEndSerial = _T("");
		}
		if (pDlg->IsChangeDept())
		{
			dDept = pDlg->GetParkingDept();
		}
		if (pDlg->IsResetSerial())
		{
			pSegData->nTextLoc = pDlg->SerialLoc();
		}
		if (pDlg->IsChangeWidth())
		{
			
			if (abs(pSegData->segPath.GetBulge()) > 1.0e-6)
			{
				double dLength;
				if (pSegData->bIsLeft)
				{
					dLength = GetOneParkingArcLength(pSegData->segPath.GetArc(), pDlg->GetParkingWidth(), dDept, TRUE);
				}
				else
				{
					dLength = GetOneParkingArcLength(pSegData->segPath.GetArc(), pDlg->GetParkingWidth(), dDept, FALSE);
				}
				dMoveLength = 0.5 * (dLength - pSegData->dWidth) * pSegData->nParkingNum;	
			}
			else
			{
				dWidth = pDlg->GetParkingWidth() / sin(pSegData->nAngle * PI / 180);
				dMoveLength = 0.5 * (dWidth - pSegData->dWidth) * pSegData->nParkingNum;
			}
			pSegData->dWidth = pDlg->GetParkingWidth();
		}
		
		if (abs(pSegData->segPath.GetBulge()) > 1.0e-6)
		{
			if (pDlg->IsChangeWidth())
			{
				if (pDlg->WidthChangeDirec())
				{
					if ((eChangeDirec == eLeftStToEnd) || (eChangeDirec == eRightStToEnd))
					{
						ExtendArc(pSegData->segPath, 2 * dMoveLength + 0.5 * dWidth, FALSE);
					}
					else
					{
						ExtendArc(pSegData->segPath, 2 * dMoveLength + 0.5 * dWidth, TRUE);

					}
				}
				else
				{
					ExtendArc(pSegData->segPath, dMoveLength, TRUE);
					ExtendArc(pSegData->segPath, dMoveLength + 0.5 * dWidth, FALSE);
				}
			}	
			if (pDlg->IsChangeDept())
			{
				if (pDlg->DeptChangeDirec())
				{
					if (!pSegData->bIsDoubleRow)
					{
						if ((eChangeDirec == eLeftStToEnd) || (eChangeDirec == eLeftEndToSt))
						{
							if (!pSegData->bIsLeft)
							{
								pSegData->segPath = pSegData->segPath.Offset(-(dDept - pSegData->dDept), LS_INFINITE);
							}
						}
						else
						{
							if (pSegData->bIsLeft)
							{
								pSegData->segPath = pSegData->segPath.Offset((dDept - pSegData->dDept), LS_INFINITE);
							}
						}
					}	
					else
					{
						if ((eChangeDirec == eLeftStToEnd) || (eChangeDirec == eLeftEndToSt))
						{
							pSegData->segPath = pSegData->segPath.Offset(-(dDept - pSegData->dDept), LS_INFINITE);
						}
						else
						{
							pSegData->segPath = pSegData->segPath.Offset((dDept - pSegData->dDept), LS_INFINITE);
						}
					}
				}
				else
				{
					if ((eChangeDirec == eLeftStToEnd) || (eChangeDirec == eLeftEndToSt))
					{
						if (!pSegData->bIsLeft)
						{
							pSegData->segPath = pSegData->segPath.Offset(-0.5 * (dDept - pSegData->dDept), LS_INFINITE);
						}
						else
						{
							pSegData->segPath = pSegData->segPath.Offset(0.5 * (dDept - pSegData->dDept), LS_INFINITE);
						}
					}
					else
					{
						if (pSegData->bIsLeft)
						{
							pSegData->segPath = pSegData->segPath.Offset(0.5 * (dDept - pSegData->dDept), LS_INFINITE);
						}
						else
						{
							pSegData->segPath = pSegData->segPath.Offset(-0.5 * (dDept - pSegData->dDept), LS_INFINITE);
						}
					}
				}
			}
			DrawParkingForArc(pSegData, pDlg->GetParkingWidth(), dDept, sName, idLayer);
		}
		else
		{
			ptSt = pSegData->segPath.GetStartPoint();
			ptEnd = pSegData->segPath.GetEndPoint();
			AcGeVector3d vec = ptEnd - ptSt;
			if (pDlg->IsChangeWidth())
			{
				if (pDlg->WidthChangeDirec())
				{
					if ((eChangeDirec == eLeftStToEnd) || (eChangeDirec == eRightStToEnd))
					{
						ptEnd = ptEnd + 2 * dMoveLength * vec / vec.length();
					}
					else
					{
						ptSt = ptSt - 2 * dMoveLength * vec / vec.length();
					}	
					pSegData->segPath.SetStartPoint(ptSt);
					pSegData->segPath.SetEndPoint(ptEnd);
				}
				else
				{
					ptSt = ptSt - dMoveLength * vec / vec.length();
					ptEnd = ptEnd + dMoveLength * vec / vec.length();
					pSegData->segPath.SetStartPoint(ptSt);
					pSegData->segPath.SetEndPoint(ptEnd);
				}
			}	
			if (pDlg->IsChangeDept())
			{
				if (pDlg->DeptChangeDirec())
				{
					if (!pSegData->bIsDoubleRow)
					{
						if ((eChangeDirec == eLeftStToEnd) || (eChangeDirec == eLeftEndToSt))
						{
							if (!pSegData->bIsLeft)
							{
								pSegData->segPath = pSegData->segPath.Offset(-(dDept - pSegData->dDept), LS_INFINITE);
							}
						}
						else
						{
							if (pSegData->bIsLeft)
							{
								pSegData->segPath = pSegData->segPath.Offset((dDept - pSegData->dDept), LS_INFINITE);
							}
						}
					}	
					else
					{
						if ((eChangeDirec == eLeftStToEnd) || (eChangeDirec == eLeftEndToSt))
						{
							pSegData->segPath = pSegData->segPath.Offset(-(dDept - pSegData->dDept), LS_INFINITE);
						}
						else
						{
							pSegData->segPath = pSegData->segPath.Offset((dDept - pSegData->dDept), LS_INFINITE);
						}
					}
				}
				else
				{
					if ((eChangeDirec == eLeftStToEnd) || (eChangeDirec == eLeftEndToSt))
					{
						if (!pSegData->bIsDoubleRow)
						{
							if (!pSegData->bIsLeft)
							{
								pSegData->segPath = pSegData->segPath.Offset(-0.5 * (dDept - pSegData->dDept), LS_INFINITE);
							}
							else
							{
								pSegData->segPath = pSegData->segPath.Offset(0.5 * (dDept - pSegData->dDept), LS_INFINITE);
							}
						}					
					}
					else
					{
						if (!pSegData->bIsDoubleRow)
						{
							if (pSegData->bIsLeft)
							{
								pSegData->segPath = pSegData->segPath.Offset(0.5 * (dDept - pSegData->dDept), LS_INFINITE);
							}
							else
							{
								pSegData->segPath = pSegData->segPath.Offset(-0.5 * (dDept - pSegData->dDept), LS_INFINITE);
							}
						}
						
					}
				}
			}
			DrawParkingForLine(pSegData, pDlg->GetParkingWidth(), dDept, sName, idLayer);
		}
		if (pDlg->IsRefromSerial())
		{
			strSerial = pSegData->strStartSerial;
		}
	}
}
//判断是否是双排
void PolyIsOnSeg(TDPtrList<OneParking> &lstParking, PakingSegData* pSegData, int &nParkingNum)
{
	XPoint ptSt, ptEnd;
	ptSt = pSegData->segPath.GetStartPoint();
	ptEnd = pSegData->segPath.GetEndPoint();
	for (int i = 0; i < lstParking.Length(); ++i)
	{
		OneParking* pParkingData;
		pParkingData = lstParking.GetAt(i);
		if (!pParkingData->bIsBelongTo)
		{
			int nFlagSt = pSegData->segPath.HitTest2d(*pParkingData->poly2D.GetPointListAt(0));
			int nFlagEnd = pSegData->segPath.HitTest2d(*pParkingData->poly2D.GetPointListAt(1));
			if (((nFlagSt >= 3) && (nFlagSt <= 5)) || ((nFlagEnd >= 3) && (nFlagEnd <= 5)))
			{
				if (pParkingData->stText.strSerialNum > pSegData->strEndSerial)
				{
					pSegData->strEndSerial = pParkingData->stText.strSerialNum;
				}
				if ((pSegData->segPath.GetBulge()) < 1.0e-6)
				{
					AcGeVector3d vecBase = *pParkingData->poly2D.GetPointListAt(1) - *pParkingData->poly2D.GetPointListAt(0);
					AcGeVector3d vec = *pParkingData->poly2D.GetPointListAt(2) - *pParkingData->poly2D.GetPointListAt(1);
					int nAngle = GetSettingAngle(vecBase.angleTo(vec));
					if (nAngle > 90)          //确定第二排车位的象限
					{
						if (ptEnd.x > ptSt.x)
						{
							if (pSegData->bIsLeft)
								pSegData->nRightQMode = 2;
							else
								pSegData->nRightQMode = 3;
						}
						else
						{
							if (pSegData->bIsLeft)
								pSegData->nRightQMode = 2;
							else
								pSegData->nRightQMode = 3;	
						}
					}
					else if(nAngle < 90)
					{
						if (ptEnd.x > ptSt.x)
						{
							if (pSegData->bIsLeft)
								pSegData->nRightQMode = 1;
							else
								pSegData->nRightQMode = 0;
						}
						else
						{
							if (pSegData->bIsLeft)
								pSegData->nRightQMode = 1;
							else
								pSegData->nRightQMode = 0;
						}
					}
					else
					{
						if (ptEnd.x > ptSt.x)
						{
							if (pSegData->bIsLeft)
								pSegData->nRightQMode = 1;
							else
								pSegData->nRightQMode = 0;
						}
						else
						{
							if (pSegData->bIsLeft)
								pSegData->nRightQMode = 0;
							else
								pSegData->nRightQMode = 1;
						}
					}
					if (nAngle < pSegData->nAngle)
					{
						pSegData->nAngle = nAngle;
					}
				}
				pSegData->bIsDoubleRow = TRUE;
				pParkingData->bIsBelongTo = TRUE;
			}
		}
		else
		{
			nParkingNum++;
		}
	}
}
//获取车位基线、车位样式等
void AnalysisParkingToSeg(TDPtrList<OneParking> &lstParking, TDPtrList<PakingSegData> &lstSegParking)
{
	int nlength;
	TDPtrList<OneParking> lstParkingTmp;
	while (lstParking.Length() > 0)
	{
		XPoint ptStart, ptEnd, ptMid;
		CString strSerialNum;
		double dTailWidth = 0, dHeadWidth = 0, dDept = 0, dTrapezoidDept;
		OneParking parkingDataRight, parkingDataLeft;
		parkingDataLeft = parkingDataRight = *lstParking.GetAt(0);
		ptStart = *parkingDataRight.poly2D.GetPointListAt(0);
		ptEnd = *parkingDataRight.poly2D.GetPointListAt(1);
		dHeadWidth = (*parkingDataRight.poly2D.GetPointListAt(2)).Distance(*parkingDataRight.poly2D.GetPointListAt(3));
		dTailWidth = (ptStart.Distance(ptEnd));
		TGGeCurveSegment segChord(ptStart, ptEnd, 0);
		if (abs(dHeadWidth - dTailWidth) > 1.0e-6)
		{
			dDept = abs(segChord.GetDist2Me(*parkingDataRight.poly2D.GetPointListAt(2)));
		}
		else
		{
			dDept = abs(parkingDataRight.poly2D.GetPointListAt(1)->Distance(*parkingDataRight.poly2D.GetPointListAt(2)));
		}
		lstParking.GetAt(0)->bIsBelongTo = TRUE;
		PakingSegData* pPsegData = new PakingSegData;
		pPsegData->strStartSerial = parkingDataLeft.stText.strSerialNum;
		pPsegData->bIsDoubleRow = FALSE;
		pPsegData->bIsLeft = TRUE;
		pPsegData->nAngle = 0;
		pPsegData->dTextHeight = parkingDataRight.stText.dTextHeight;
		pPsegData->nStyle = parkingDataRight.m_nStyle;
		pPsegData->idTextStyle = parkingDataRight.stText.idTextStyle;
		pPsegData->BIsCCW = TRUE;
		XLine baseLine(ptStart, ptEnd);
		ptMid = baseLine.MidPoint();
		
		if (baseLine.OnWhichSide(*parkingDataRight.poly2D.GetPointListAt(2)))
		{
			pPsegData->bIsLeft = FALSE;
		}
		nlength = lstParking.Length();
		for (int n = 0; n < nlength; ++n)
		{
			OneParking* pParkingDataSec;
			pParkingDataSec = lstParking.GetAt(n);
			if (!pParkingDataSec->stText.strSerialNum.IsEmpty())
			{
				if (!pPsegData->strStartSerial.IsEmpty())
				{
					if (pParkingDataSec->stText.strSerialNum < pPsegData->strStartSerial)
					{
						pPsegData->strStartSerial = pParkingDataSec->stText.strSerialNum;
					}
				}
				else
				{
					pPsegData->strStartSerial = pParkingDataSec->stText.strSerialNum;
				}
				
			}
			
			if (*parkingDataRight.poly2D.GetPointListAt(1) == *pParkingDataSec->poly2D.GetPointListAt(0))
			{
				parkingDataRight = *pParkingDataSec;
				pParkingDataSec->bIsBelongTo = TRUE;
				XLine line12(*parkingDataRight.poly2D.GetPointListAt(0), *parkingDataRight.poly2D.GetPointListAt(1));
				if (!parkingDataRight.stText.strSerialNum.IsEmpty())
				{
					double dLength = parkingDataRight.stText.ptText.Distance(line12.MidPoint());
					if (dLength > dDept)
					{
						pPsegData->nTextLoc = 0;
					}
					else if(abs(dLength - 0.5 * dDept) < 1.0e-6)
					{
						pPsegData->nTextLoc = 2;
					}
					else
					{
						pPsegData->nTextLoc = 1;
					}
					pPsegData->dTextHeight = parkingDataRight.stText.dTextHeight;
				}
			}
			else if (*parkingDataLeft.poly2D.GetPointListAt(0) == *pParkingDataSec->poly2D.GetPointListAt(1))
			{
				
				parkingDataLeft = *pParkingDataSec;
				pParkingDataSec->bIsBelongTo = TRUE;
				XLine line12(*parkingDataLeft.poly2D.GetPointListAt(0), *parkingDataLeft.poly2D.GetPointListAt(1));
				if (!parkingDataLeft.stText.strSerialNum.IsEmpty())
				{
					double dLength = parkingDataLeft.stText.ptText.Distance(line12.MidPoint());
					if (dLength > dDept)
					{
						pPsegData->nTextLoc = 0;
					}
					else if(abs(dLength - 0.5 * dDept) < 1.0e-6)
					{
						pPsegData->nTextLoc = 2;
					}
					else
					{
						pPsegData->nTextLoc = 1;
					}
					pPsegData->dTextHeight = parkingDataLeft.stText.dTextHeight;
				}
			}
		}	
		ptStart = *parkingDataLeft.poly2D.GetPointListAt(0);
		ptEnd = *parkingDataRight.poly2D.GetPointListAt(1);
		if (abs(dHeadWidth - dTailWidth) > 1.0e-6)
		{
			
			XArc arc(ptStart, *parkingDataLeft.poly2D.GetPointListAt(1), ptEnd);
			XLine line(ptStart, ptEnd);
			int nFlag = line.OnWhichSide(*parkingDataLeft.poly2D.GetPointListAt(1));
			pPsegData->segPath = arc;
			if(pPsegData->segPath.OnWhichSide(*parkingDataLeft.poly2D.GetPointListAt(2)))
			{
				pPsegData->bIsLeft = FALSE;
			}
			else
			{
				pPsegData->bIsLeft = TRUE;
			}
			if (line.OnWhichSide(*parkingDataLeft.poly2D.GetPointListAt(1)))
			{
			
			}
			else
			{
				pPsegData->BIsCCW = FALSE;
				/*TGGeCurveSegment seg;
				seg = arc;
				double dBugle = seg.GetBulge();
				pPsegData->segPath.SetStartPoint(ptStart);
				pPsegData->segPath.SetEndPoint(ptEnd);
				pPsegData->segPath.SetBulge(-dBugle);*/
			}
			double dRad = arc.GetRadius();
			pPsegData->dWidth = dRad * acos((2 * dRad * dRad - dTailWidth * dTailWidth) / (2 * dRad * dRad));
		}
		else
		{

			pPsegData->dWidth = dTailWidth;
			AcGeVector3d vecBase = *parkingDataLeft.poly2D.GetPointListAt(1) - *parkingDataLeft.poly2D.GetPointListAt(0);
			AcGeVector3d vec = *parkingDataLeft.poly2D.GetPointListAt(3) - *parkingDataLeft.poly2D.GetPointListAt(0);
			AcGeVector3d vecStToE = ptEnd - ptStart;
			
			pPsegData->nAngle = GetSettingAngle(vecBase.angleTo(vec));
			if (pPsegData->nAngle > 90)
			{
				if (ptEnd.x > ptStart.x)
				{
					if (pPsegData->bIsLeft)
						pPsegData->nLeftQMode = 3;
					else
						pPsegData->nLeftQMode = 2;
				}
				else
				{
					if (pPsegData->bIsLeft)
						pPsegData->nLeftQMode = 3;
					else
						pPsegData->nLeftQMode = 2;
				}
				pPsegData->nAngle -= 90;
			}
			else if(pPsegData->nAngle < 90)
			{
				if (ptEnd.x > ptStart.x)
				{
					if (pPsegData->bIsLeft)
						pPsegData->nLeftQMode = 0;
					else
						pPsegData->nLeftQMode = 1;
				}
				else
				{
					if (pPsegData->bIsLeft)
						pPsegData->nLeftQMode = 0;
					else
						pPsegData->nLeftQMode = 1;
				}
			}
			else
			{
				if (ptEnd.x > ptStart.x)
				{
					if (pPsegData->bIsLeft)
						pPsegData->nLeftQMode = 0;
					else
						pPsegData->nLeftQMode = 1;
				}
				else
				{
					if (pPsegData->bIsLeft)
						pPsegData->nLeftQMode = 1;
					else
						pPsegData->nLeftQMode = 0;
				}
			}
			pPsegData->segPath.SetStartPoint(ptStart);
			pPsegData->segPath.SetEndPoint(ptEnd);
			
		}
		int nParkingNum = 0;
		PolyIsOnSeg(lstParking, pPsegData, nParkingNum);
		
		TDPtrList<OneParking> lstTemp;
		lstTemp.copyFrom(lstParking);
		lstParking.Reset();
		for (int k = 0; k < lstTemp.Length(); ++k)
		{
			if (!lstTemp.GetAt(k)->bIsBelongTo)
			{
				OneParking* pParkingData = new OneParking;
				OneParking* pTmp = lstTemp.GetAt(k);
				pParkingData->poly2D = pTmp->poly2D;
				pParkingData->stText = pTmp->stText;
				pParkingData->bIsBelongTo = FALSE;
				pParkingData->m_nStyle = pTmp->m_nStyle;
				pParkingData->idPoly = pTmp->idPoly;
				pParkingData->idSlashOrBlock = pTmp->idSlashOrBlock;
				lstParking.Append(pParkingData);
			}
			else
			{
				OneParking* pParkingData = new OneParking;
				OneParking* pTmp = lstTemp.GetAt(k);
				pParkingData->poly2D = pTmp->poly2D;
				pParkingData->stText = pTmp->stText;
				pParkingData->bIsBelongTo = TRUE;
				pParkingData->m_nStyle = pTmp->m_nStyle;
				pParkingData->idPoly = pTmp->idPoly;
				pParkingData->idSlashOrBlock = pTmp->idSlashOrBlock;
				lstParkingTmp.Append(pParkingData);
			}
		}
		lstTemp.Reset();
		ptStart = *parkingDataLeft.poly2D.GetPointListAt(0);
		ptEnd = *parkingDataRight.poly2D.GetPointListAt(1);
		double dNum = 0;
		if ((pPsegData->segPath.GetBulge()) > 1.0e-6)
		{
			dNum = (pPsegData->segPath.GetBulge()) / (2 * asin(0.5 * dTailWidth / pPsegData->segPath.GetArc().GetRadius()));
		}
		else
		{
			dNum = ptStart.Distance(ptEnd) / dTailWidth;
		}
		
		pPsegData->dDept = dDept;
		pPsegData->nParkingNum = nParkingNum;	
		lstSegParking.Append(pPsegData);
	}
	lstParking.copyFrom(lstParkingTmp);
	lstParkingTmp.Reset();
}
//删除原有实体
void DeleteEnt(TDPtrList<OneParking> &lstParking)
{
	for (int i = 0; i < lstParking.Length(); ++i)
	{
		OneParking* pTmp = lstParking.GetAt(i);
		if (pTmp->bIsBelongTo)
		{
			if (pTmp->stText.idText.isValid())
			{
				AcDbEntity* pEntity;
				OPENOBJ_BEGIN(pTmp->stText.idText, AcDb::kForWrite, AcDbEntity, pEntity)
				if (pEntity)
				{
					pEntity->erase();
				}
				OPENOBJ_END()
			}
			if (pTmp->idPoly.isValid())
			{
				AcDbEntity* pEntity;
				OPENOBJ_BEGIN(pTmp->idPoly, AcDb::kForWrite, AcDbEntity, pEntity)
				if (pEntity)
				{
					pEntity->erase();
				}
				OPENOBJ_END()
			}
			if (pTmp->idSlashOrBlock.isValid())
			{
				AcDbEntity* pEntity;
				OPENOBJ_BEGIN(pTmp->idSlashOrBlock, AcDb::kForWrite, AcDbEntity, pEntity)
				if (pEntity)
				{
					pEntity->erase();
				}
				OPENOBJ_END()
			}
		}
	}
}
void SortParkingSeg(TDPtrList<PakingSegData> &lstSegParking)
{
	
}
//确定车位伸缩方向
DIrecRetCode SelectChangeDirec(PakingSegData &segData)
{
	DIrecRetCode nRetCode = eLeftStToEnd;
	TGGeCurveSegment segBase;
	XPoint pt, ptMid;
	segBase = segData.segPath;
	
	if (!segData.bIsDoubleRow)
	{
		double dOffset = 0.5 * segData.dDept;
		if (abs(segBase.GetBulge()) < 1.0e-6)
		{
			dOffset = dOffset * sin(segData.nAngle * PI / 180);
		}
		if (segData.bIsLeft)
		{
			segBase = segBase.Offset(-dOffset, LS_INFINITE);
		}
		else
		{
			segBase = segBase.Offset(dOffset, LS_INFINITE);
		}
	}	
	int iRet = RTNORM;
	ptMid = segBase.MidPoint();
	AcGeVector3d vec = segBase.GetEndPoint() - segBase.GetStartPoint();
	if (!segData.bIsDoubleRow)
	{
		if (abs(segBase.GetBulge()) < 1.0e-6)
		{
			if ((segData.nLeftQMode == 2) || (segData.nLeftQMode == 3))
			{
				ptMid = ptMid - (0.5 * segData.dDept * sin(segData.nAngle * PI / 180) + 0.25 * segData.dWidth) * vec / vec.length(); 
			}
			else
			{
				ptMid = ptMid + (0.5 * segData.dDept * sin(segData.nAngle * PI / 180) - 0.25 * segData.dWidth) * vec / vec.length(); 
			}
		}	
	}
	else
	{
		ptMid = ptMid - 0.25 * segData.dWidth * vec / vec.length(); 
	}
	iRet = ads_getpoint(ptMid, _T("\n请点取发生变化的一侧<退出>: "), pt);
	if (iRet == RTNORM)
	{
		if (abs(segBase.GetBulge()) > 1.0e-6)
		{		
			XLine lineRadial(ptMid, segBase.GetArc().GetCenterPt());
			if (segBase.OnWhichSide(pt))
			{
				if (lineRadial.OnWhichSide(pt))
				{
					nRetCode = eRightStToEnd;
				}
				else
				{
					nRetCode = eRightEndToSt;
				}
			}
			else
			{
				if (lineRadial.OnWhichSide(pt))
				{
					nRetCode = eLeftStToEnd;
				}
				else
				{
					nRetCode = eLeftEndToSt;
				}
			}
		}
		else
		{
			if (segBase.OnWhichSide(pt))
			{
				if (segBase.GetStartPoint().x > segBase.GetEndPoint().x)
				{
					if (pt.x > ptMid.x)
					{
						nRetCode = eRightEndToSt;
					}
					else
					{
						nRetCode = eRightStToEnd;
					}
				}
				else
				{
					if (pt.x > ptMid.x)
					{
						nRetCode = eRightStToEnd;
					}
					else
					{
						nRetCode = eRightEndToSt;
					}
				}
			}
			else
			{
				if (segBase.GetStartPoint().x > segBase.GetEndPoint().x)
				{
					if (pt.x > ptMid.x)
					{
						nRetCode = eLeftEndToSt;
					}
					else
					{
						nRetCode = eLeftStToEnd;
					}
				}
				else
				{
					if (pt.x > ptMid.x)
					{
						nRetCode = eLeftStToEnd;
					}
					else
					{
						nRetCode = eLeftEndToSt;
					}
				}
			}
		}	
	}
	else
	{
		nRetCode = eCancle;
	}
	return nRetCode;
}
void ParkingAlterCmd()
{

	//非模态对话框
	CParkingAlterDlg dlg(acedGetAcadFrame());
	dlg.Create(IDD_DLG_PARKING_ALTER);
	dlg.ShowWindow(SW_SHOW);
	while (true)
	{
		TDPtrList<ObliqueLineData> lstPoly, lstSingleSlash, lstDoubleSlash;
		TDPtrList<ParkingTextData> lstText;
		TDPtrList<OneParking> lstParking;
		TDPtrList<PakingSegData> lstSegParking;
		TDPtrList<ParkingBlockData> lstPtBlock;
		PickSet ss(SS_FREE);
		RBList rbMark(RTDXF0, _T("POLYLINE,LWPOLYLINE,TCH_TEXT,TCH_INSERT,INSERT,TCH_MVINSERT,TCH_BLOCK_INSERT"),NULL);
		int nRetCode=SelectEntities(_T("\n请选择需要修改的停车位<退出>:"), ss, rbMark);
		if (nRetCode != RTNORM) // 命令结束
		{
			dlg.DestroyWindow();
			return;
		}
		long n = ss.Length() - 1;
		double length = 0;
		for (n; n >= 0; --n)
		{
			AcDbEntity* pEntity;
			CString strlay;
			Entity ssEnt=ss[n];
			OPENOBJ_BEGIN(ssEnt,AcDb::kForWrite,AcDbEntity,pEntity);
			if(pEntity)
			{
				strlay = pEntity->layer();
				if (pEntity->isKindOf(TDbText::desc()))
				{	
					if (!strlay.CompareNoCase(LAY_PKNG_SING))
					{
						TDbText* pText = TDbText::cast(pEntity);
						ParkingTextData* stText = new ParkingTextData;
						stText->strSerialNum = _T("");
						stText->strSerialNum = pText->GetText();
						stText->ptText = pText->GetLocation();
						stText->dTextHeight = pText->GetHeight();
						if(stText->dTextHeight > length)
							length = stText->dTextHeight;
						stText->idTextStyle = pText->GetStyleId();
						stText->idText = pEntity->objectId();
						lstText.Append(stText);
					}
				}
				else if(pEntity->isKindOf(AcDbBlockReference::desc()))
				{
					AcDbBlockReference* pBlock = AcDbBlockReference::cast(pEntity);
					ParkingBlockData* blockData = new ParkingBlockData;
					blockData->ptBlockCenter = XPoint(pBlock->position());
					blockData->idBlock = pEntity->objectId();
					lstPtBlock.Append(blockData);
				}
				else
				{
					if(!strlay.CompareNoCase(_T("PKNG-TSRP")))
					{
						AcDbPolyline* poly = AcDbPolyline::cast(pEntity);
						XPoly2D poly2D;
						PolyConvert(*poly, poly2D);
						ObliqueLineData* polyData = new ObliqueLineData;
						polyData->polyLine = poly2D;
						polyData->idLine = pEntity->objectId();
						if (poly2D.TotalSegments() == 1)
						{	
							lstSingleSlash.Append(polyData);
						}
						else if(poly2D.TotalSegments() == 2)
						{
							lstDoubleSlash.Append(polyData);
						}
						else if(poly2D.TotalSegments() == 4)
						{
							lstPoly.Append(polyData);
						}
					}
				}
			}
			OPENOBJ_END();
		}
		AnalysisParkingToGroup(lstPoly, lstSingleSlash, lstDoubleSlash, lstPtBlock, lstText, lstParking, length);
		AnalysisParkingToSeg(lstParking, lstSegParking);
		DIrecRetCode nRet = eLeftStToEnd;
		if ((dlg.IsChangeWidth() && dlg.WidthChangeDirec()) || (dlg.IsChangeDept() && dlg.DeptChangeDirec()))
		{
			nRet = SelectChangeDirec(*lstSegParking.GetAt(0));
			if (nRet == eCancle)
			{
				continue;
			}
		}
		DeleteEnt(lstParking);
		ChangeParking(&dlg, lstSegParking, nRet);
	}
}