1223 lines
28 KiB
C++
1223 lines
28 KiB
C++
#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(¶m, 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, ¶m);
|
|
return;
|
|
}
|
|
|
|
AecDb3dRoadFitting* pWFit = AecDb3dRoadFitting::cast(pEnt);
|
|
if (pWFit != NULL) //管件拉伸命令
|
|
{
|
|
AecInterface intf;
|
|
pWFit->AecMInterfaces::GetInterface(msg.ptGrip, intf);
|
|
|
|
WPipe::RoadParam param;
|
|
memset(¶m, 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, ¶m);
|
|
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(¶m1,0,sizeof(WPipe::RoadParam));
|
|
pPipeMaj->GetRoadParam(param1);
|
|
|
|
WPipe::RoadParam param2;
|
|
memset(¶m2,0,sizeof(WPipe::RoadParam));
|
|
pPipeMin->GetRoadParam(param2);
|
|
|
|
//if (fabs(param1.dSize[0] - param2.dSize[0]) < 1.e-3) //==DN
|
|
{
|
|
AecDbRoadJig jig(¶m1);
|
|
AecDbRoadLine pipeLine(&jig);
|
|
pipeLine.SetPipeParam(¶m1);
|
|
|
|
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);
|
|
}
|
|
} |