#include "StdAfx.h"
#include "DxqmDlg.h"
#include "Kingtouch.h"
#include "DXJDDlg.h"
#include "KTSetting.h"
#include "AcLandFormJig.h"
#include "AecDb3dRoad.h"
#include "AecDb3dRoadFitting.h"
#include "HZDLDlg.h"
#include "AcPolylineJig.h"
#include "AecDb3dRoadAxisLine.h"
#include "AecDbRoadJig.h"
#include "KTCadUtility.h"
#include "AecDbRoadLine.h"
#include "CoreTools.h"
#include "KTCADUtilityEx.h"
#include "aecdbwell.h"

#define KEY_LANDFORM _T("LandForm")
#define KEY_LANDFORM_SCALE _T("LandFormScale")

extern double GetElbowL(WPipe::RoadParam* pParam);
extern AcGePoint3d MidPoint(const AcGePoint3d& pt1,const AcGePoint3d& pt2);
bool DLLIMPEXP PickGripMessage(GripMessage& msg);
DLLIMPEXP bool GetDoubleClickEnt(LPCTSTR pszCmd,AcDbObjectId& id);

Acad::ErrorStatus AddToModelSpace(AcDbEntity* pEnt, AcDbDatabase* pDb = NULL, bool bClose = true)
{
	if (pDb == NULL)
		pDb = acdbHostApplicationServices()->workingDatabase();

	Acad::ErrorStatus es;

	AcDbBlockTable* pTbl = NULL;
	if (Acad::eOk == (es = pDb->getBlockTable(pTbl, AcDb::kForRead)))
	{
		AcDbBlockTableRecord* pBTR = NULL;
		if (Acad::eOk == (es = pTbl->getAt(ACDB_MODEL_SPACE, pBTR, AcDb::kForWrite)))
		{
			es = pBTR->appendAcDbEntity(pEnt);
			if (bClose) pEnt->close();

			pBTR->close();
		}
		pTbl->close();
	}
	return es;
}


//测试
void SP_TESTCmdFnc()
{
	ads_point pt1,pt2;
	int nRes = acedGetPoint(NULL,_T("\n拾取起点:"),pt1);
	if (nRes == RTNORM)
	{
		nRes = acedGetPoint(pt1,_T("\n拾取终点:"),pt2);
		if (nRes == RTNORM)
		{
			WPipe::RoadParam rdp;
			memset(&rdp,0,sizeof(WPipe::RoadParam));

			rdp.dSize[0] = 20000;
			rdp.dGrade = 0.0;
			rdp.dRRatio = 1.0;
			rdp.dThick = 1.0;

			AecDb3dRoad* pRoad = new AecDb3dRoad;
			pRoad->SetRoadParam(&rdp);

			ads_point pt11,pt22;
			acdbUcs2Wcs(pt1,pt11,false);
			acdbUcs2Wcs(pt2,pt22,false);

			AecEqui::AecCurveElement el;
			memset(&el,0,sizeof(AecEqui::AecCurveElement));

			el.ptGe[0] = asPnt3d(pt11);
			el.ptGe[1] = asPnt3d(pt22);
			el.ptGe[2] = asPnt3d(pt22);
			
			pRoad->SetCurveSeg(el);
			
			//AcDbObjectId idLayer = KTSetting::InitLayer(_T("LAY_EW_DS"));

			AddToModelSpace(pRoad);
		}
	}
}

//三维地形
void SP_SWDXCmdFnc()
{
	CAcModuleResourceOverride myResources;
	CDxqmDlg dlg;
	if (IDOK == dlg.DoModal() )
	{
		AcGePoint3d pt;
		dlg.GetXYZ(pt);
		struct resbuf* pRb = dlg.GetFilter();

		if(dlg.m_nQmType==0)//网格
		{
		}
		else//三角面
		{
		}
	}
}

int PickLandForm(ads_point pt1)
{
	struct resbuf* pRb = acutBuildList(RTDXF0,_T("AEC_LANDFORM"),0);

	ads_point pt2;
	acdbUcs2Wcs(pt1,pt2,false);

	ads_name ss;
	acedSSGet(_T("X"),NULL,NULL,pRb,ss);

	Adesk::Int32 nLen = 0;
	acedSSLength(ss,&nLen);

	AcGePoint3d ptOn;
	ads_name ent;
	AcDbObjectId id;
	bool bIsInside = false;

	AcDbEntity* pEnt = NULL;
	for (int i = 0;i < nLen;i++)
	{
		acedSSName(ss,i,ent);
		acdbGetObjectId(id,ent);

		if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
		{
			AecDbLandForm* pLF = AecDbLandForm::cast(pEnt);
			if (pLF != NULL)
			{
				if ( pLF->IsPointInSide(asPnt3d(pt2),ptOn) )
				{
					pEnt->close();
					bIsInside = true;
					break;
				}
			}
			pEnt->close();
		}
	}

	acedSSFree(ss);
	acutRelRb(pRb);

	ads_point pt3;
	acdbWcs2Ucs(asDblArray(ptOn),pt3,false);
	if (bIsInside)
	{
		pt1[Z] = pt3[Z];
		return RTNORM;
	}
	return RTNONE;
}

//地面平整
void SP_DMPZCmdFnc()
{
	CAcModuleResourceOverride myResources;
	CDXJDDlg* pDXJDDlg = new CDXJDDlg;
	pDXJDDlg->Create(CDXJDDlg::IDD,acedGetAcadFrame());
	pDXJDDlg->CenterWindow();
	pDXJDDlg->ShowWindow(SW_SHOW);

	AcDbObjectId idLayer = KTSetting::InitLayer(LAY_EW_DS);

	//默认矩形选择,其他点选范围,给出高程数值
	ads_point pt1,pt,pt2,pt3,pt4;
	AcGePoint3d ptGe,ptGe2,ptGe3,ptGe4;

	while(true)
	{
		acedInitGet(RSG_OTHER,_T("G"));
		int nRes = acedGetPoint(NULL,_T("\n请选择矩形地形第一角点[闭合区域(G)]:"),pt1);
		switch(nRes)
		{
		case RTNORM:
			{
				ads_point_set(pt1,pt2);

				//如果选上地形
				nRes = PickLandForm(pt1);
				if (nRes == RTNORM)
				{
					ptGe.z = pt1[Z];
					acdbUcs2Wcs(pt1,pt,false);
					pt[Z] = ptGe.z;
					ptGe = asPnt3d(pt);
					pDXJDDlg->SetCurEl(ptGe.z);
				}
				else
				{
					acdbUcs2Wcs(pt1,pt,false);
					ptGe = asPnt3d(pt);
					ptGe.z = pDXJDDlg->GetCurEl();
				}

				nRes = acedGetCorner(pt2,_T("\n请选择矩形地形第二点:"),pt1);
				if (nRes == RTNORM)
				{
					nRes = PickLandForm(pt1);
					if (nRes == RTNORM)
					{
						ptGe2.z = pt1[Z];
						acdbUcs2Wcs(pt1,pt,false);
						pt[Z] = ptGe2.z;
						ptGe2 = asPnt3d(pt);
						pDXJDDlg->SetCurEl(ptGe.z);
					}
					else
					{
						acdbUcs2Wcs(pt1,pt,false);
						ptGe2 = asPnt3d(pt);
						ptGe2.z = pDXJDDlg->GetCurEl();
					}

					ads_point_set(pt2,pt3);
					pt3[X] = pt1[X];
					
					acdbUcs2Wcs(pt3,pt,false);
					ptGe3 = asPnt3d(pt);
					ptGe3.z = ptGe.z;

					ads_point_set(pt2,pt4);
					pt4[Y] = pt1[Y];
					acdbUcs2Wcs(pt4,pt,false);
					ptGe4 = asPnt3d(pt);
					ptGe4.z = ptGe.z;
					
					AcGePoint3dArray arPts;
					arPts.append(ptGe);
					arPts.append(ptGe3);
					arPts.append(ptGe2);
					arPts.append(ptGe4);

					AecDbLandForm* pLForm = new AecDbLandForm;
					pLForm->SetPoints(arPts);
					pLForm->setLayer(idLayer);
					AddToModelSpace(pLForm);
				}
				break;
			}
		case RTKWORD:
			{
				//选择四个点
				AcGePoint3dArray arPts;

				AcLandFormJig plJig;
				plJig.SetElDlg(pDXJDDlg);
				if ( plJig.DoIt() )
				{
					AcGePoint3dArray arPts;
					plJig.GetPoints(arPts);

					AecDbLandForm* pLForm = new AecDbLandForm;
					pLForm->SetPoints(arPts);
					pLForm->setLayer(idLayer);
					AddToModelSpace(pLForm);
					break;
				}
				break;
			}
		default:
			{
				delete pDXJDDlg;
				return;
			}
		}
	}
	delete pDXJDDlg;
}

void MaybeAddTeeorCross(WPipe::RoadParam& rp,AcDbCurve* pCurve,AcDbVoidPtrArray& arRoadFitPtrs)
{
}

void SP_DLCSCmdFnc()
{
	CAcModuleResourceOverride myResources;
	CHZDLDlg dlg;
	if ( IDOK == dlg.DoModal() )
	{
		WPipe::RoadParam rp;
		dlg.GetPipeParam(rp);

		AcPolylineJig plJig;
		plJig.InitStatusRecsForWall(rp.dSize[0], 0.5 * rp.dSize[0]);
		if ( plJig.DoIt() )
		{
			AcDbObjectId idRoadLn = plJig.GetRoadAxisLineId();
			AcDbVoidPtrArray arCurPtrs;

			AcDbEntity* pEnt = NULL;
			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,idRoadLn,AcDb::kForWrite))
			{
				AecDb3dRoadAxisLine* pRoad = AecDb3dRoadAxisLine::cast(pEnt);
				if (pRoad != NULL)
				{
					pRoad->Create3dRoadAxisLine(2.0 * rp.dSize[0],rp.dRRatio);

					pRoad->explode(arCurPtrs);
					pRoad->erase();
					pRoad->close();
				}
				pEnt->close();
			}

			//测试命令
			if (!arCurPtrs.isEmpty())
			{
				AcDbObjectId idLay = KTSetting::InitLayer(LAY_ROAD,false);

				AecEqui::AecCurveElement el;
				memset(&el,0,sizeof(AecEqui::AecCurveElement));

				AcDbVoidPtrArray arRoadFitPtrs;

				AcDbCurve* pCurve = NULL;
				for (int i = 0;i < arCurPtrs.length();i++)
				{
					pCurve = (AcDbCurve*)arCurPtrs.at(i);

					MaybeAddTeeorCross(rp,pCurve,arRoadFitPtrs);

					if (pCurve != NULL)
					{
						if ( AecComplexCurve::MakeElement(el,pCurve) )
						{
							AecDb3dRoad* pRoad = new AecDb3dRoad;
							pRoad->SetRoadParam(&rp);
							pRoad->SetCurveSeg(el);

							pRoad->setLayer(idLay);
							AddToModelSpace(pRoad);
						}

						delete pCurve;
					}
				}

				AcDbEntity* pRoadFit = NULL;
				for (int i = 0;i < arRoadFitPtrs.length();i++)
				{
					pRoadFit = (AcDbEntity*)arRoadFitPtrs.at(i);

					pRoadFit->setLayer(idLay);
					AddToModelSpace(pRoadFit);
				}
			}
		}
	}
}

void SP_RoadAddmdFnc()
{
	GripMessage msg;
	PickGripMessage(msg);

	if (msg.nType >= eCommand0 && msg.nType <= eCommand20)
	{
		AcDbObjectId id = msg.idHost;

		AcDbEntity* pEnt = NULL;
		if (Acad::eOk == acdbOpenObject(pEnt, id, AcDb::kForWrite))
		{
			CString sLayer = pEnt->layer();

			AecDb3dRoad* pPipe = AecDb3dRoad::cast(pEnt);
			if (pPipe != NULL) //管子拉伸命令
			{
				AecInterface intf;
				pPipe->AecMInterfaces::GetInterface(msg.ptGrip, intf);

				if (!pPipe->AecMInterfaces::HasInterface(msg.ptGrip, intf.vtDir))
				{
					//是中间夹点
					AcGeVector3d vtDir = pPipe->EndPoint() - pPipe->StartPoint();
					//vtDir.rotateBy(PI / 2.0, pPipe->normal()); //? Z
					vtDir.rotateBy(PI / 2.0, AcGeVector3d::kZAxis); //? Z
					intf.vtDir = vtDir;
					intf.ptPos = msg.ptGrip;
				}

				//判断是否是管子sta点
				AcGePoint3d ptSta = pPipe->StartPoint();
				if (ptSta.distanceTo(intf.ptPos) < 1.e-1)
				{
					AcGeVector3d vtDir = intf.vtDir;
					vtDir.negate();
					intf.vtDir = vtDir;
				}

				WPipe::RoadParam param;
				memset(&param, 0, sizeof(WPipe::RoadParam));
				pPipe->GetRoadParam(param);
				param.dSize[0] = intf.dSize1;

				param.m_dEl = intf.ptPos.z;
				pEnt->close();

				AecDbRoadJig jig;
				jig.DoIt(&intf, &param);
				return;
			}

			AecDb3dRoadFitting* pWFit = AecDb3dRoadFitting::cast(pEnt);
			if (pWFit != NULL) //管件拉伸命令
			{
				AecInterface intf;
				pWFit->AecMInterfaces::GetInterface(msg.ptGrip, intf);

				WPipe::RoadParam param;
				memset(&param, 0, sizeof(WPipe::RoadParam));
				pWFit->GetRoadParam(param);
				param.dSize[0] = intf.dSize1;

				param.m_dEl = intf.ptPos.z;
				pEnt->close();

				AecDbRoadJig jig;
				jig.DoIt(&intf, &param);
				return;
			}
			pEnt->close();
		}
	}
}

//绘制道路
void SP_HZDLCmdFnc()
{
	AecDbRoadJig jig;
	jig.DoIt(WPipe::eRoad);
}

void DBL_AEC_3DROAD()
{
	AcDbObjectId id;
	bool bIsOk = GetDoubleClickEnt(_T("DBL_AEC_3DROAD"),id);

	if (bIsOk && id.isValid())
	{
		AcDbEntity* pEnt1 = NULL;
		if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, id, AcDb::kForWrite))
		{
			AecDb3dRoad* p3dRoad1 = AecDb3dRoad::cast(pEnt1);
			if (p3dRoad1 != NULL)
			{
				WPipe::RoadParam rp;
				p3dRoad1->GetRoadParam(rp);

				CAcModuleResourceOverride templRc;
				CHZDLDlg drawCnfgDLg;
				drawCnfgDLg.EnableLoadLast(FALSE);
				drawCnfgDLg.SetPipeParam(rp);

				int nRes = drawCnfgDLg.DoModal();
				if (nRes == IDOK)
				{
					drawCnfgDLg.GetPipeParam(rp);
					p3dRoad1->SetRoadParam(&rp);
				}
			}
			else
			{
				acutPrintf(_T("\n选择的实体不是直线道路!"));
			}
			pEnt1->close();
		}
	}
}

void SP_DLBXCmdFnc()
{
	//请选择道路左侧边线
	//请选择道路右侧边线
	struct resbuf* pRb = acutBuildList(RTDXF0,_T("LINE,ARC,LWPOLYLINE"),0);

	ads_name ssL,ssR,ent;
	int nRes = CKTCadUtility::SelectEntities(_T("\n请选择道路左侧边线:"),ssL,pRb);
	if (nRes == RTNORM)
	{
		Adesk::Int32 nLen = 0;
		acedSSLength(ssL,&nLen);

		AcDbVoidPtrArray arCrvL;
		AcDbEntity* pEnt = NULL;
		AcDbObjectId id;
		for (int i = 0;i < nLen;i++)
		{
			acedSSName(ssL,i,ent);
			acdbGetObjectId(id,ent);

			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
			{
				AcDbCurve* pCrv = AcDbCurve::cast(pEnt);
				if (pCrv != NULL)
				{
					arCrvL.append((AcDbEntity*)pCrv->clone());
				}
				pEnt->close();
			}
		}
		acedSSFree(ssL);

		AcDbVoidPtrArray arCrvR;
		nRes = CKTCadUtility::SelectEntities(_T("\n请选择道路右侧边线:"),ssR,pRb);
		if (nRes == RTNORM)
		{
			acedSSLength(ssR,&nLen);
			for (int i = 0;i < nLen;i++)
			{
				acedSSName(ssR,i,ent);
				acdbGetObjectId(id,ent);

				if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForRead))
				{
					AcDbCurve* pCrv = AcDbCurve::cast(pEnt);
					if (pCrv != NULL)
					{
						arCrvR.append((AcDbEntity*)pCrv->clone());
					}
					pEnt->close();
				}
			}
		}
	
		AcDbVoidPtrArray arRes;
		AcDbCurve* pL = KTCADUtilityEx::ConvertBoundCurve(arCrvL,arRes);
		if (pL != NULL)
		{
			arRes.removeAll();
			AcDbCurve* pR = KTCADUtilityEx::ConvertBoundCurve(arCrvR,arRes);
			if (pR != NULL)
			{
				AcGePoint3d ptS,pt1,pt2;
				pL->getStartPoint(ptS);

				pR->getStartPoint(pt1);
				pR->getEndPoint(pt2);

				AecEqui::AecCurveElement el1,el2;

				double dL1 = ptS.distanceTo(pt1);
				double dL2 = ptS.distanceTo(pt2);
				if (dL1 < dL2)
				{
					el1.ptGe[0] = ptS;
					el1.ptGe[1] = pt1;
					el1.ptGe[2] = pt1;
				}
				else
				{
					el1.ptGe[0] = ptS;
					el1.ptGe[1] = pt2;
					el1.ptGe[2] = pt2;
				}
				el1.bHided = TRUE;
				el2.bHided = TRUE;
			
				pL->getEndPoint(ptS);
				dL1 = ptS.distanceTo(pt1);
				dL2 = ptS.distanceTo(pt2);
				if (dL1 < dL2)
				{
					el2.ptGe[0] = ptS;
					el2.ptGe[1] = pt1;
					el2.ptGe[2] = pt1;
				}
				else
				{
					el2.ptGe[0] = ptS;
					el2.ptGe[1] = pt2;
					el2.ptGe[2] = pt2;
				}


				AcDbVoidPtrArray arCurPtrs;
				pL->explode(arCurPtrs);
				pR->explode(arCurPtrs);

				AecComplexCurve cmplOut;
				AcDbCurve* pCurve = NULL;
				for (int i = 0;i < arCurPtrs.length();i++)
				{
					pCurve = (AcDbCurve*)arCurPtrs.at(i);
					cmplOut.append(pCurve);
					delete pCurve;
				}
				cmplOut.append(el1);
				cmplOut.append(el2);
			
				//示意
				CAcModuleResourceOverride myResources;
				CHZDLDlg dlg;
				dlg.m_bWIsValid = FALSE;
				if ( IDOK != dlg.DoModal() )
				{
					acutRelRb(pRb);
					delete pL;
					delete pR;
					return;
				}

				WPipe::RoadParam rp;
				dlg.GetPipeParam(rp);

				AcDbExtents ext1,ext2;
				pL->getGeomExtents(ext1);
				pR->getGeomExtents(ext2);
				ext2.addExt(ext1);

				AcGePoint3d ptMid = MidPoint(ext2.minPoint(),ext2.maxPoint());
				ptMid.z = rp.m_dEl;

				AecDb3dRoadFitting* pFit = new AecDb3dRoadFitting;
				pFit->SetRoadParam(&rp);
				pFit->GetSpecialtyData()->SetAt(KEY_MID, ptMid);

				for (int i = 0;i < cmplOut.length();i++)
				{
					cmplOut.atByRef(i).ptGe[0].z = rp.m_dEl;
					cmplOut.atByRef(i).ptGe[1].z = rp.m_dEl;
					cmplOut.atByRef(i).ptGe[2].z = rp.m_dEl;
				}
				pFit->SetMInfRoad(cmplOut);
				//设置图层
				AcDbObjectId idLay = KTSetting::InitLayer(LAY_ROAD);
				pFit->setLayer(idLay);

				CoreTools::AddToModelSpace(pFit);

				delete pL;
				delete pR;
			}
		}
	}
	acutRelRb(pRb);
}

//添加环岛
void SP_TJHDCmdFnc()
{
	ads_name ent;
	struct resbuf* pRb = acutBuildList(RTDXF0,_T("AEC_ROADFIT"),0);

	int nRes = CKTCadUtility::SelectEntity(_T("\n请选择道路十字、T字交叉路段:"),ent,pRb);
	acutRelRb(pRb);

	if (nRes == RTNORM)
	{
		AcDbObjectId id;
		acdbGetObjectId(id,ent);

		//选择环岛内的闭合曲线
		ads_name ent2;
		pRb = acutBuildList(RTDXF0,_T("LWPOLYLINE,CIRCLE"),0);
		nRes = CKTCadUtility::SelectEntity(_T("\n请选择交叉路段内闭合多义线或圆:"),ent2,pRb);

		if (nRes == RTNORM)
		{
			AcDbObjectId id2;
			acdbGetObjectId(id2,ent2);

			AcDbEntity* pEnt = NULL;
			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt,id,AcDb::kForWrite))
			{
				AecDb3dRoadFitting* pRoadFit = AecDb3dRoadFitting::cast(pEnt);
				if (pRoadFit != NULL)
				{
					AcDbEntity* pEnt2 = NULL;
					if ( Acad::eOk == acdbOpenAcDbEntity(pEnt2,id2,AcDb::kForWrite))
					{
						AcDbPolyline* pPl = AcDbPolyline::cast(pEnt2);
						if (pPl != NULL)
						{
							pRoadFit->SetRoundabout(pPl);
							pPl->erase();
						}

						AcDbCircle* pCir = AcDbCircle::cast(pEnt2);
						if (pCir != NULL)
						{
							AcDbPolyline* pPlT = new AcDbPolyline;
							
							AcGePoint3d pt1 = pCir->center();
							pt1.x += pCir->radius();

							pPlT->addVertexAt(0,pt1.convert2d(AcGePlane::kXYPlane),1.0);

							pt1.x -= 2.0 * pCir->radius();
							pPlT->addVertexAt(1,pt1.convert2d(AcGePlane::kXYPlane),1.0);

							pt1 = pCir->center();
							pt1.x += pCir->radius();

							pPlT->addVertexAt(2,pt1.convert2d(AcGePlane::kXYPlane),0.0);

							pPlT->setClosed(Adesk::kTrue);

							pRoadFit->SetRoundabout(pPlT);
							pCir->erase();

							delete pPlT;
						}
						pEnt2->close();
					}
				}
				pEnt->close();
			}
		}
	}
}

void SP_BJGWCmdFnc()
{
	//选择管线末点加弯头
	ads_name ent1, ent2;

	struct resbuf* pRb = acutBuildList(RTDXF0,_T("AEC_3DROAD"),0);

	int nRes = CKTCadUtility::SelectEntity(_T("\n请选择主向道路:"), ent1, pRb);
	if (nRes == RTNORM)
	{
		nRes = CKTCadUtility::SelectEntity(_T("\n请选择分支道路:"), ent2, pRb);
		if (nRes == RTNORM)
		{
			AcDbObjectId id1, id2;
			acdbGetObjectId(id1, ent1);
			acdbGetObjectId(id2, ent2);

			AcDbEntity* pEnt1 = NULL;
			AcDbEntity* pEnt2 = NULL;

			if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, id1, AcDb::kForWrite))
			{
				if (Acad::eOk == acdbOpenAcDbEntity(pEnt2, id2, AcDb::kForWrite))
				{
					AecDb3dRoad* p3dRoad1 = AecDb3dRoad::cast(pEnt1);
					AecDb3dRoad* p3dRoad2 = AecDb3dRoad::cast(pEnt2);

					WPipe::RoadParam rp1;
					memset(&rp1,0,sizeof(WPipe::RoadParam));
					p3dRoad1->GetRoadParam(rp1);

					WPipe::RoadParam rp2;
					memset(&rp2,0,sizeof(WPipe::RoadParam));
					p3dRoad2->GetRoadParam(rp2);

					//直线
					int nType1 = p3dRoad1->GetCurveSegType();
					int nType2 = p3dRoad2->GetCurveSegType();

					if (nType1 == AecEqui::eLine && nType2 == AecEqui::eLine)
					{
						//判断点在位置
						AcGeLine3d ln1(p3dRoad1->StartPoint(), p3dRoad1->EndPoint());
						AcGeLine3d ln2(p3dRoad2->StartPoint(), p3dRoad2->EndPoint());

						AcGePoint3d ptMid;
						if (ln1.intersectWith(ln2, ptMid) == Adesk::kTrue)
						{
							pEnt1->close();
							pEnt2->close();

							AecDbRoadJig jig(&rp1);
							AecDbRoadLine pipeLine(&jig);
							pipeLine.SetPipeParam(&rp1);

							pipeLine.AddElbow(id1, ptMid, id2);
							acutRelRb(pRb);

							return;
						}
					}
					else
					{
						acutPrintf(_T("\n请选择两条直线道路!"));
					}
					pEnt2->close();
				}
				pEnt1->close();
			}
		}
	}
	acutRelRb(pRb);
}

//弯头连接
void SP_WTLJCmdFnc()
{
	//选择管线末点加弯头
	ads_name ent1, ent2;

	struct resbuf* pRb = acutBuildList(RTDXF0,_T("AEC_3DROAD"),0);

	int nRes = CKTCadUtility::SelectEntity(_T("\n请选择主向道路:"), ent1, pRb);
	if (nRes == RTNORM)
	{
		nRes = CKTCadUtility::SelectEntity(_T("\n请选择分支道路:"), ent2, pRb);
		if (nRes == RTNORM)
		{
			AcDbObjectId id1, id2;
			acdbGetObjectId(id1, ent1);
			acdbGetObjectId(id2, ent2);

			AcDbEntity* pEnt1 = NULL;
			AcDbEntity* pEnt2 = NULL;

			if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, id1, AcDb::kForWrite))
			{
				if (Acad::eOk == acdbOpenAcDbEntity(pEnt2, id2, AcDb::kForWrite))
				{
					AecDb3dRoad* p3dRoad1 = AecDb3dRoad::cast(pEnt1);
					AecDb3dRoad* p3dRoad2 = AecDb3dRoad::cast(pEnt2);

					WPipe::RoadParam rp1;
					memset(&rp1,0,sizeof(WPipe::RoadParam));
					p3dRoad1->GetRoadParam(rp1);

					WPipe::RoadParam rp2;
					memset(&rp2,0,sizeof(WPipe::RoadParam));
					p3dRoad2->GetRoadParam(rp2);

					//直线
					int nType1 = p3dRoad1->GetCurveSegType();
					int nType2 = p3dRoad2->GetCurveSegType();

					if (nType1 == AecEqui::eLine && nType2 == AecEqui::eLine)
					{
						if ( fabs(rp1.dSize[0] - rp2.dSize[0]) > 1.e-1)//变径
						{
							//判断点在位置
							AcGeLine3d ln1(p3dRoad1->StartPoint(), p3dRoad1->EndPoint());
							AcGeLine3d ln2(p3dRoad2->StartPoint(), p3dRoad2->EndPoint());

							AcGePoint3d ptMid;
							if (ln1.intersectWith(ln2, ptMid) == Adesk::kTrue)
							{
								pEnt1->close();
								pEnt2->close();

								AecDbRoadJig jig(&rp1);
								AecDbRoadLine pipeLine(&jig);
								pipeLine.SetPipeParam(&rp1);

								pipeLine.AddElbowEx(id1, ptMid, id2);
								acutRelRb(pRb);

								return;
							}
						}
						else
						{
							//判断点在位置
							AcGeLine3d ln1(p3dRoad1->StartPoint(), p3dRoad1->EndPoint());
							AcGeLine3d ln2(p3dRoad2->StartPoint(), p3dRoad2->EndPoint());

							AcGePoint3d ptMid;
							if (ln1.intersectWith(ln2, ptMid) == Adesk::kTrue)
							{
								pEnt1->close();
								pEnt2->close();

								AecDbRoadJig jig(&rp1);
								AecDbRoadLine pipeLine(&jig);
								pipeLine.SetPipeParam(&rp1);

								pipeLine.AddElbow(id1, ptMid, id2);
								acutRelRb(pRb);

								return;
							}
						}
					}
					else
					{
						acutPrintf(_T("\n请选择两条直线道路!"));
					}
					pEnt2->close();
				}
				pEnt1->close();
			}
		}
	}
	acutRelRb(pRb);
}

//三通连接
void SP_STLJCmdFnc()
{
	ads_name ent1;
	struct resbuf* pRb = acutBuildList(RTDXF0,_T("AEC_3DROAD"),0);

	int nRes = CKTCadUtility::SelectEntity(_T("\n请选择主向道路:"),ent1,pRb);
	if (nRes == RTNORM)
	{
		ads_name ent2;
		nRes = CKTCadUtility::SelectEntity(_T("\n请选择分支道路:"),ent2,pRb);
		if (nRes == RTNORM)
		{
			AcDbObjectId id1;
			acdbGetObjectId(id1, ent1);

			AcDbObjectId id2;
			acdbGetObjectId(id2, ent2);

			AcDbEntity* pEnt1 = NULL;
			if ( Acad::eOk == acdbOpenAcDbEntity(pEnt1,id1,AcDb::kForWrite) )
			{
				AcDbEntity* pEnt2 = NULL;
				if ( Acad::eOk == acdbOpenAcDbEntity(pEnt2,id2,AcDb::kForWrite) )
				{
					AecDb3dRoad* p3dRoad1 = AecDb3dRoad::cast(pEnt1);
					if (p3dRoad1 != NULL)
					{
						AecDb3dRoad* p3dRoad2 = AecDb3dRoad::cast(pEnt2);
						if (p3dRoad2 != NULL)
						{
							int nType1 = p3dRoad1->GetCurveSegType();
							int nType2 = p3dRoad2->GetCurveSegType();

							if (nType1 == AecEqui::eLine && nType2 == AecEqui::eLine)
							{
								AcGeLine3d ln1(p3dRoad1->StartPoint(), p3dRoad1->EndPoint());
								AcGeLine3d ln2(p3dRoad2->StartPoint(), p3dRoad2->EndPoint());

								AcGePoint3d ptMid, ptTemp1, ptTemp2;
								if (ln1.intersectWith(ln2, ptMid)) //相交
								{
									WPipe::RoadParam rp1;
									memset(&rp1,0,sizeof(WPipe::RoadParam));
									p3dRoad1->GetRoadParam(rp1);

									WPipe::RoadParam rp2;
									memset(&rp2,0,sizeof(WPipe::RoadParam));
									p3dRoad2->GetRoadParam(rp2);

									AcGeVector3d vtMaj = p3dRoad1->EndPoint() - p3dRoad1->StartPoint();
									AcGeVector3d vtMin = p3dRoad2->EndPoint() - p3dRoad2->StartPoint();
									vtMaj.normalize();
									vtMin.normalize();

									double dL = 0.0,dS = 0.0;
									BOOL bAddTee = TRUE;

									AecDbRoadJig jig(&rp1);
									AecDbRoadLine pipeLine(&jig);
									pipeLine.SetPipeParam(&rp2);

									while(true)
									{
										dL = 2.0 * GetElbowL(&rp1);
										dS = 2.0 * GetElbowL(&rp2);

										//也可能加弯头,ptMid的两头有一在管子外
										AcGePoint3d ptTemp1 = ptMid + vtMaj * dL;
										AcGePoint3d ptTemp2 = ptMid - vtMaj * dL;

										AcGeLineSeg3d lineGe(p3dRoad1->StartPoint(), p3dRoad1->EndPoint());
										
										if (!lineGe.isOn(ptTemp1) || !lineGe.isOn(ptTemp2))
										{
											bAddTee = FALSE;
											rp1.dRRatio -= 0.3;//每次减去300mm
											rp2.dRRatio -= 0.3;

											if (rp1.dRRatio < 0)
											{
												pEnt2->close();
												pEnt1->close();
												acutRelRb(pRb);
												acutPrintf(_T("\n自适应曲率半径的情况下,此处无法添加三通!"));
												return;
											}
											
											pipeLine.SetPipeParam(&rp2);
										}
										else
										{
											bAddTee = TRUE;
										}

										if (bAddTee)
										{
											break;
										}
									}
									
									if (bAddTee)
									{
										SHacedCommand(RTSTR,_T("_undo"),RTSTR,_T("BE"),RTNONE);
										int nPos = 1;//落在末端附近
										double dDis1 = ptMid.distanceTo(p3dRoad2->StartPoint());
										double dDis2 = ptMid.distanceTo(p3dRoad2->EndPoint());
										if (dDis1 < dDis2)
											nPos = 0; //落在开始端

										//对方断为两个管子
										pipeLine.SplitWPipe(ptMid, dL, p3dRoad1);

										if (nPos == 1)
											vtMin.negate();

										//改变this管子的位置
										pEnt2->close();
										AcGePoint3d ptGe = ptMid + dS * vtMin;
										pipeLine.ModifyWPipe(ptGe, id2, nPos);
										pipeLine.AddTee(p3dRoad1, dL, ptMid, dS, vtMin);
										pEnt1->close();
										
										SHacedCommand(RTSTR,_T("_undo"),RTSTR,_T("E"),RTNONE);
										return;
									}
									else
									{
										pEnt2->close();
										pEnt1->close();
										acutRelRb(pRb);
										return;
									}
								}
								else
								{
									acutPrintf(_T("\n两道路不在同一平面!无法加三通!"));
								}
							}
							else
							{
								acutPrintf(_T("\n道路必须是直线道路才可三通连接!"));
							}
						}
					}
					pEnt2->close();
				}
				pEnt1->close();
			}
		}
	}
	acutRelRb(pRb);
}

//添加四通
void SP_TJSTCmdFnc()
{
	ads_name ent1;
	struct resbuf* pRb = acutBuildList(RTDXF0,_T("AEC_3DROAD"),0);

	int nRes = CKTCadUtility::SelectEntity(_T("\n请选择主向道路:"),ent1,pRb);
	if (nRes == RTNORM)
	{
		ads_name ent2;
		nRes = CKTCadUtility::SelectEntity(_T("\n请选择分支道路:"),ent2,pRb);
		if (nRes == RTNORM)
		{
			AcDbObjectId id1;
			acdbGetObjectId(id1, ent1);

			AcDbObjectId id2;
			acdbGetObjectId(id2, ent2);

			AcDbEntity* pEnt1 = NULL;
			if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, id1, AcDb::kForWrite))
			{
				AecDb3dRoad* pPipeMaj = AecDb3dRoad::cast(pEnt1);
				if (pPipeMaj != NULL)
				{
					AcDbEntity* pEnt2 = NULL;
					if (Acad::eOk == acdbOpenAcDbEntity(pEnt2, id2, AcDb::kForWrite))
					{
						AecDb3dRoad* pPipeMin = AecDb3dRoad::cast(pEnt2);
						if (pPipeMin != NULL)
						{
							int nType1 = pPipeMaj->GetCurveSegType();
							int nType2 = pPipeMin->GetCurveSegType();

							if (nType1 == AecEqui::eLine && nType2 == AecEqui::eLine)
							{
								AcGeLine3d ln1(pPipeMaj->StartPoint(), pPipeMaj->EndPoint());
								AcGeLine3d ln2(pPipeMin->StartPoint(), pPipeMin->EndPoint());

								AcGeVector3d vtMaj = pPipeMaj->EndPoint() - pPipeMaj->StartPoint();
								AcGeVector3d vtMin = pPipeMin->EndPoint() - pPipeMin->StartPoint();
								vtMaj.normalize();
								vtMin.normalize();

								AcGePoint3d ptMid, ptTemp1, ptTemp2;
								if (ln1.intersectWith(ln2, ptMid)) //相交
								{

									WPipe::RoadParam param1;
									memset(&param1,0,sizeof(WPipe::RoadParam));
									pPipeMaj->GetRoadParam(param1);

									WPipe::RoadParam param2;
									memset(&param2,0,sizeof(WPipe::RoadParam));
									pPipeMin->GetRoadParam(param2);

									//if (fabs(param1.dSize[0] - param2.dSize[0]) < 1.e-3) //==DN
									{
										AecDbRoadJig jig(&param1);
										AecDbRoadLine pipeLine(&jig);
										pipeLine.SetPipeParam(&param1);

										pEnt1->close();
										pEnt2->close();

										SHacedCommand(RTSTR,_T("_undo"),RTSTR,_T("BE"),RTNONE);
										pipeLine.AddCross(id1, ptMid, id2);
										SHacedCommand(RTSTR,_T("_undo"),RTSTR,_T("E"),RTNONE);

										return;
									}
								}
								else
								{
									acutPrintf(_T("\n两道路不在同一平面!无法加四通!"));
								}
							}
							else
							{
								acutPrintf(_T("\n道路必须是直线道路才可四通连接!"));
							}
						}
						pEnt2->close();
					}
				}
				pEnt1->close();
			}
		}
	}
	acutRelRb(pRb);
}

void SP_DTLJCmdFnc()
{
	CAcModuleResourceOverride myResources;
	CHZDLDlg dlg;
	dlg.m_bWIsValid = FALSE;
	if ( IDOK == dlg.DoModal() )
	{
		WPipe::RoadParam rp;
		dlg.GetPipeParam(rp);

		ads_name ent1;
		struct resbuf* pRb = acutBuildList(RTDXF0,_T("LWPOLYLINE"),0);

		int nRes = CKTCadUtility::SelectEntity(_T("\n请选择闭合曲线:"),ent1,pRb);
		if (nRes == RTNORM)
		{
			AcDbObjectId id1;
			acdbGetObjectId(id1, ent1);

			AcDbEntity* pEnt1 = NULL;
			if (Acad::eOk == acdbOpenAcDbEntity(pEnt1, id1, AcDb::kForWrite))
			{
				AcDbPolyline* pPipeMaj = AcDbPolyline::cast(pEnt1);
				if (pPipeMaj != NULL)
				{
					AcDbVoidPtrArray arCurPtrs;
					pPipeMaj->explode(arCurPtrs);

					AecComplexCurve cmplOut;

					AcDbCurve* pCurve = NULL;
					for (int i = 0;i < arCurPtrs.length();i++)
					{
						pCurve = (AcDbCurve*)arCurPtrs.at(i);
						cmplOut.append(pCurve);
						delete pCurve;
					}

					AcDbExtents ext;
					pPipeMaj->getGeomExtents(ext);
					AcGePoint3d ptMid = MidPoint(ext.minPoint(),ext.maxPoint());
					ptMid.z = rp.m_dEl;

					AecDb3dRoadFitting* pFit = new AecDb3dRoadFitting;
					pFit->SetRoadParam(&rp);
					pFit->GetSpecialtyData()->SetAt(KEY_MID, ptMid);

					for (int i = 0;i < cmplOut.length();i++)
					{
						cmplOut.atByRef(i).ptGe[0].z = rp.m_dEl;
						cmplOut.atByRef(i).ptGe[1].z = rp.m_dEl;
						cmplOut.atByRef(i).ptGe[2].z = rp.m_dEl;
					}
					pFit->SetMInfRoad(cmplOut);
					//设置图层
					AcDbObjectId idLay = KTSetting::InitLayer(LAY_ROAD);
					pFit->setLayer(idLay);

					CoreTools::AddToModelSpace(pFit);
				}
				pEnt1->close();
			}
		}
	}
}

void SP_CRSJ()
{
	ads_point adsPt = {.0, .0, .0};
	AcGePoint3d pt;
	while (acedGetPoint(adsPt, _T("\n选择一点："), adsPt) == RTNORM)
	{
		pt = asPnt3d(adsPt);
		CoreTools::UCS2WCS(pt, pt);
		AecDbWell *pWell = new AecDbWell();
		//pWell->SetCircleWellData(pt, 50, 10., 5000., 600.);
		pWell->SetRectWellData(pt, 50, 10., 5000., 600., 600.);
		CoreTools::AddToModelSpace(pWell);
	}
}