2380 lines
58 KiB
C++
2380 lines
58 KiB
C++
#include "stdafx.h"
|
|
//#include "resource.h"
|
|
#include "KTCADUtilityEx.h"
|
|
#include "KTCadUtility.h"
|
|
#include "KTTempTol.h"
|
|
#include "KTCADSysVar.h"
|
|
#include "KTSetting.h"
|
|
#include "EarThwormDef.h"
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[]=__FILE__;
|
|
#define new DEBUG_NEW
|
|
#endif
|
|
|
|
const double WALLMAXWIDTH = 800.0;
|
|
|
|
#ifndef RT_MANIFEST
|
|
#define RT_MANIFEST MAKEINTRESOURCE(24)
|
|
#endif //RT_MANIFEST
|
|
|
|
template <class K> BOOL CopyObject(const K &src, K &dest)
|
|
{
|
|
AcDbDeepCloneFiler filer;
|
|
BOOL bRet=FALSE;
|
|
if(src.dwgOutFields(&filer)==Acad::eOk)
|
|
{
|
|
filer.seek(0L,0);
|
|
bRet=(dest.dwgInFields(&filer)==Acad::eOk);
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
KTCADUtilityEx::KTCADUtilityEx()
|
|
{
|
|
}
|
|
|
|
KTCADUtilityEx::~KTCADUtilityEx()
|
|
{
|
|
}
|
|
|
|
int KTCADUtilityEx::DoubleCompare(const double& dArg1, const double& dArg2)
|
|
{
|
|
double dValue = dArg1 - dArg2;
|
|
if (fabs(dValue) < 1.e-5)
|
|
return 0;
|
|
else
|
|
return (dValue < 0.0 ? -1 : 1);
|
|
}
|
|
|
|
// 通过一墙线，在给定点附近取得另一墙线和轴线, 1有另一墙线，2墙线轴线都有
|
|
struct KTWallSortData{AcDbObjectId idEnt; AcGePoint3d ptIns; AcGeVector3d vecDir; BOOL bRadius;};
|
|
|
|
int KTCADUtilityEx::GetWallParamByWallLine(AcDbObjectId& idCur,const AcGePoint3d& ptTest,
|
|
AcDbObjectId& idOth,AcDbObjectId& idAxis)
|
|
{
|
|
typedef CSortPair<double, KTWallSortData, DoubleCompare> CWallSortPair;
|
|
KTTempTol tol(1.e-6);
|
|
|
|
BOOL bRadius;
|
|
AcGePoint3d pt;
|
|
AcGeVector3d vec;
|
|
|
|
AcDbCurve* pCurve = NULL;
|
|
AcDbEntity* pEnt = NULL;
|
|
|
|
acdbOpenAcDbEntity(pEnt,idCur,AcDb::kForRead);
|
|
if (pEnt == NULL) return 0;
|
|
|
|
pCurve = AcDbCurve::cast(pEnt);
|
|
if (pCurve == NULL)
|
|
{
|
|
pEnt->close();
|
|
return 0;
|
|
}
|
|
|
|
pCurve->getClosestPointTo(ptTest, pt);
|
|
if (pCurve->isKindOf(AcDbLine::desc()))
|
|
{
|
|
bRadius = FALSE;
|
|
AcDbLine* pLineT = AcDbLine::cast(pCurve);
|
|
vec = pLineT->endPoint() - pLineT->startPoint();
|
|
vec.rotateBy(PI/2.0, ((AcDbLine*)pCurve)->normal());
|
|
}
|
|
else if (pCurve->isKindOf(AcDbArc::desc()))
|
|
{
|
|
bRadius = TRUE;
|
|
vec = pt - ((AcDbArc*)pCurve)->center();
|
|
}
|
|
else if (pCurve->isKindOf(AcDbCircle::desc()))
|
|
{
|
|
bRadius = TRUE;
|
|
vec = pt - ((AcDbCircle*)pCurve)->center();
|
|
}
|
|
else
|
|
{
|
|
pEnt->close();
|
|
return 0;
|
|
}
|
|
pEnt->close();
|
|
|
|
vec.normalize();
|
|
|
|
AcGePoint3d pt1, pt2;
|
|
pt1 = pt + vec * WALLMAXWIDTH;
|
|
pt2 = pt - vec * WALLMAXWIDTH;
|
|
|
|
CString sLayerWall,sTemp;
|
|
KTSetting::GetLayerName(_T("LAY_WALL"),sLayerWall,sTemp);
|
|
|
|
struct resbuf res1,res2;
|
|
res1.restype = 0;
|
|
res1.resval.rstring = (bRadius ? _tcsdup(_T("ARC,CIRCLE")) : _tcsdup(_T("LINE")));
|
|
res2.restype = 8;
|
|
res2.resval.rstring = (LPTSTR)(LPCTSTR)sLayerWall;
|
|
res1.rbnext = &res2;
|
|
res2.rbnext = NULL;
|
|
|
|
struct resbuf resF,resFT;
|
|
resF.restype = RT3DPOINT;
|
|
resF.resval.rpoint[0] = pt1.x;
|
|
resF.resval.rpoint[1] = pt1.y;
|
|
resF.resval.rpoint[2] = pt1.z;
|
|
resFT.restype = RT3DPOINT;
|
|
resFT.resval.rpoint[0] = pt2.x;
|
|
resFT.resval.rpoint[1] = pt2.y;
|
|
resFT.resval.rpoint[2] = pt2.z;
|
|
resF.rbnext = &resFT;
|
|
resFT.rbnext = NULL;
|
|
|
|
AcDbObjectIdArray arIdEnts;
|
|
ads_name ssSet,ent;
|
|
acedSSGet(_T("F"),&resF,NULL,&res1,ssSet);
|
|
|
|
AcDbObjectId idT;
|
|
Adesk::Int32 lLen = 0;
|
|
acedSSLength(ssSet,&lLen);
|
|
|
|
for (long i = 0;i < lLen;i++)
|
|
{
|
|
acedSSName(ssSet,i,ent);
|
|
if (Acad::eOk == acdbGetObjectId(idT,ent))
|
|
{
|
|
arIdEnts.append(idT);
|
|
}
|
|
}
|
|
acedSSFree(ssSet);
|
|
if (arIdEnts.length() == 0) return 0;
|
|
|
|
int nFoundAt = -1;
|
|
arIdEnts.find(idCur,nFoundAt);
|
|
|
|
if (nFoundAt != -1)
|
|
arIdEnts.removeAt(nFoundAt);
|
|
|
|
// 排序数据
|
|
AcArray<CWallSortPair> arWallSort;
|
|
|
|
CWallSortPair data;
|
|
AcDbLine line(pt1, pt2);
|
|
lLen = arIdEnts.length();
|
|
AcDbObjectId idTemp;
|
|
|
|
for (long l = 0l; l < lLen; l++)
|
|
{
|
|
idTemp = arIdEnts.at(l);
|
|
pCurve = NULL;
|
|
pEnt = NULL;
|
|
|
|
acdbOpenAcDbEntity(pEnt,idTemp,AcDb::kForRead);
|
|
if (pEnt == NULL)
|
|
continue;
|
|
|
|
pCurve = AcDbCurve::cast(pEnt);
|
|
if (pCurve == NULL)
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (bRadius)
|
|
{
|
|
if (pCurve->isKindOf(AcDbArc::desc()))
|
|
{
|
|
if (!vec.isParallelTo(pt - ((AcDbArc*)pCurve)->center()))
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
}
|
|
else if (pCurve->isKindOf(AcDbCircle::desc()))
|
|
{
|
|
if (!vec.isParallelTo(pt - ((AcDbCircle*)pCurve)->center()))
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pCurve->isKindOf(AcDbLine::desc()))
|
|
{
|
|
AcDbLine* pLineT = AcDbLine::cast(pCurve);
|
|
if (pLineT != NULL)
|
|
{
|
|
AcGeVector3d vcTemp = pLineT->endPoint() - pLineT->startPoint();
|
|
if (!vec.isPerpendicularTo(vcTemp))
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
}
|
|
|
|
AcGePoint3dArray arpt;
|
|
if (line.intersectWith(pCurve, AcDb::kOnBothOperands, arpt) != Acad::eOk || arpt.length() <= 0)
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
data.compare = pt.distanceTo(arpt[0]);
|
|
if (data.compare < 1.e-3)
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
data.value.idEnt = idTemp;
|
|
data.value.ptIns = arpt[0];
|
|
arWallSort.append(data);
|
|
|
|
pEnt->close();
|
|
}
|
|
|
|
int iLen = arWallSort.length();
|
|
if (iLen <= 0)
|
|
return 0;
|
|
QuickSort(arWallSort.asArrayPtr(), iLen);
|
|
|
|
idOth = arWallSort[0].value.idEnt;
|
|
pt1 = arWallSort[0].value.ptIns;
|
|
|
|
CString sLayerAxis;
|
|
KTSetting::GetLayerName(_T("LAY_AXIS"),sLayerAxis,sTemp);
|
|
|
|
res1.restype = 0;
|
|
res1.resval.rstring = (bRadius ? _tcsdup(_T("ARC,CIRCLE")) : _tcsdup(_T("LINE")));
|
|
res2.restype = 8;
|
|
res2.resval.rstring = (LPTSTR)(LPCTSTR)sLayerAxis;
|
|
res1.rbnext = &res2;
|
|
res2.rbnext = NULL;
|
|
|
|
resF.restype = RT3DPOINT;
|
|
resF.resval.rpoint[0] = pt.x;
|
|
resF.resval.rpoint[1] = pt.y;
|
|
resF.resval.rpoint[2] = pt.z;
|
|
resFT.restype = RT3DPOINT;
|
|
resFT.resval.rpoint[0] = pt1.x;
|
|
resFT.resval.rpoint[1] = pt1.y;
|
|
resFT.resval.rpoint[2] = pt1.z;
|
|
resF.rbnext = &resFT;
|
|
resFT.rbnext = NULL;
|
|
|
|
arIdEnts.setLogicalLength(0);
|
|
acedSSGet(_T("F"),&resF,NULL,&res1,ssSet);
|
|
|
|
lLen = 0;
|
|
acedSSLength(ssSet,&lLen);
|
|
|
|
for (int i = 0;i < lLen;i++)
|
|
{
|
|
acedSSName(ssSet,i,ent);
|
|
if (Acad::eOk == acdbGetObjectId(idT,ent))
|
|
{
|
|
arIdEnts.append(idT);
|
|
}
|
|
}
|
|
acedSSFree(ssSet);
|
|
|
|
arWallSort.setLogicalLength(0);
|
|
line.setStartPoint(pt);
|
|
line.setEndPoint(pt1);
|
|
lLen = arIdEnts.length();
|
|
|
|
for (int l = 0l; l < lLen; l++)
|
|
{
|
|
idTemp = arIdEnts.at(l);
|
|
pEnt = NULL;
|
|
|
|
acdbOpenAcDbEntity(pEnt,idTemp,AcDb::kForRead);
|
|
if (pEnt == NULL)
|
|
continue;
|
|
|
|
pCurve = AcDbCurve::cast(pEnt);
|
|
if (pCurve == NULL)
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
if (bRadius)
|
|
{
|
|
if (pCurve->isKindOf(AcDbArc::desc()))
|
|
{
|
|
if (!vec.isParallelTo(pt - ((AcDbArc*)pCurve)->center()))
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
}
|
|
else if (pCurve->isKindOf(AcDbCircle::desc()))
|
|
{
|
|
if (!vec.isParallelTo(pt - ((AcDbCircle*)pCurve)->center()))
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pCurve->isKindOf(AcDbLine::desc()))
|
|
{
|
|
AcDbLine* pLineT = AcDbLine::cast(pCurve);
|
|
if (pLineT != NULL)
|
|
{
|
|
AcGeVector3d vcTemp = pLineT->endPoint() - pLineT->startPoint();
|
|
if (!vec.isPerpendicularTo(vcTemp))
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
}
|
|
|
|
AcGePoint3dArray arpt;
|
|
if (line.intersectWith(pCurve, AcDb::kOnBothOperands, arpt) != Acad::eOk || arpt.length() <= 0)
|
|
continue;
|
|
|
|
data.compare = fabs(pt.distanceTo(arpt[0]) - pt1.distanceTo(arpt[0]));
|
|
data.value.idEnt = idTemp;
|
|
data.value.ptIns = arpt[0];
|
|
arWallSort.append(data);
|
|
|
|
pEnt->close();
|
|
}
|
|
|
|
iLen = arWallSort.length();
|
|
if (iLen <= 0)
|
|
return 1;
|
|
|
|
QuickSort(arWallSort.asArrayPtr(), iLen);
|
|
|
|
idAxis = arWallSort[0].value.idEnt;
|
|
|
|
if (arWallSort[0].compare + 0.01 < pt.distanceTo(pt1))
|
|
return 2;
|
|
else
|
|
return 1;
|
|
}
|
|
|
|
// 将一组点在指定的方向上排序
|
|
void KTCADUtilityEx::SortPointByDirect(AcGePoint3dArray& arpt, const AcGeVector3d& vecDir)
|
|
{
|
|
// 排序数据
|
|
typedef CSortPair<double, AcGePoint3d, DoubleCompare> CPointSortPair;
|
|
AcArray<CPointSortPair> arPointSort;
|
|
|
|
AcDbXline xline;
|
|
xline.setBasePoint(arpt[0]);
|
|
xline.setUnitDir(vecDir);
|
|
|
|
AcGePoint3d pt;
|
|
CPointSortPair data;
|
|
int iLen = arpt.length();
|
|
int i = 0;
|
|
for (i = 0; i < iLen; i++)
|
|
{
|
|
xline.getClosestPointTo(arpt[i], pt);
|
|
xline.getParamAtPoint(pt, data.compare);
|
|
data.value = arpt[i];
|
|
arPointSort.append(data);
|
|
}
|
|
|
|
iLen = arPointSort.length();
|
|
QuickSort(arPointSort.asArrayPtr(), iLen);
|
|
|
|
arpt.setLogicalLength(0);
|
|
for (i = 0; i < iLen; i++)
|
|
{
|
|
arpt.append(arPointSort[i].value);
|
|
}
|
|
}
|
|
|
|
// 根据给定的曲线实体，搜索与他相交的平行线的线组中最外的边界实体
|
|
struct CAxisCurveData {ads_name adsEnt; AcGePoint3d ptInt; AcGeVector3d vecRef; AcGeVector3d vecDir;};
|
|
int KTCADUtilityEx::FindMaxBoundAxis(ads_name& entTest, ads_name& ent1, ads_name& ent2, ads_point& pt1, ads_point& pt2)
|
|
{
|
|
// 排序数据
|
|
typedef CSortPair<double, CAxisCurveData, DoubleCompare> CAxisSortPair;
|
|
AcArray<CAxisSortPair> arParamName;
|
|
|
|
// 查找与给定曲线相交的曲线
|
|
AcDbObjectId idEntTest;
|
|
acdbGetObjectId(idEntTest,entTest);
|
|
OPENOBJ_BEGIN(idEntTest, AcDb::kForRead, AcDbCurve, pCurve);
|
|
if (pCurve == NULL)
|
|
return 0;
|
|
|
|
CString sLayer,sTemp;
|
|
KTSetting::InitLayer(_T("LAY_AXIS"));
|
|
KTSetting::GetLayerName(_T("LAY_AXIS"),sLayer,sTemp);
|
|
|
|
ads_name ssSet,ent;
|
|
struct resbuf* pResbuf = acutBuildList(RTDXF0, _T("LINE,ARC,CIRCLE"), 8, sLayer, 0);
|
|
if (RTNORM != acedSSGet(_T("X"),NULL,NULL,pResbuf,ssSet))
|
|
{
|
|
acutRelRb(pResbuf);
|
|
return 0;
|
|
}
|
|
acutRelRb(pResbuf);
|
|
|
|
CAxisSortPair data;
|
|
int i, iLen;
|
|
Adesk::Int32 lLen = 0;
|
|
AcDbObjectId idT;
|
|
acedSSLength(ssSet,&lLen);
|
|
|
|
long l = 0l;
|
|
for (l = 0l; l < lLen; l++)
|
|
{
|
|
AcGePoint3dArray arpt;
|
|
|
|
acedSSName(ssSet,l,ent);
|
|
acdbGetObjectId(idT,ent);
|
|
|
|
OPENOBJ_BEGIN(idT, AcDb::kForRead, AcDbCurve, pCurve1);
|
|
if (pCurve1 == NULL)
|
|
continue;
|
|
|
|
if (pCurve1->visibility() == AcDb::kInvisible)
|
|
{
|
|
pCurve1->close();
|
|
continue;
|
|
}
|
|
|
|
if (pCurve->intersectWith(pCurve1, AcDb::kExtendBoth, arpt) != Acad::eOk || (iLen = arpt.length()) <= 0)
|
|
continue;
|
|
// 找到真正交点，防止刚好相交的边界线无法得到
|
|
for (i = 0; i < iLen; i++)
|
|
{
|
|
pCurve1->getClosestPointTo(arpt[i], data.value.ptInt);
|
|
if (arpt[i].distanceTo(data.value.ptInt) > 1.e-6)
|
|
continue;
|
|
pCurve->getClosestPointTo(arpt[i], data.value.ptInt);
|
|
if (arpt[i].distanceTo(data.value.ptInt) > 1.e-6)
|
|
continue;
|
|
break;
|
|
}
|
|
if (i >= iLen)
|
|
continue;
|
|
// 取出交点处给定曲线法向量
|
|
if (pCurve->isKindOf(AcDbLine::desc()))
|
|
{
|
|
data.value.vecRef = ((AcDbLine*)pCurve)->endPoint() - ((AcDbLine*)pCurve)->startPoint();
|
|
data.value.vecRef.rotateBy(PI/2.0, ((AcDbLine*)pCurve)->normal());
|
|
}
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// 取出交点处曲线切向量
|
|
if (pCurve1->isKindOf(AcDbLine::desc()))
|
|
data.value.vecDir = ((AcDbLine*)pCurve1)->endPoint() - ((AcDbLine*)pCurve1)->startPoint();
|
|
else
|
|
{
|
|
continue;
|
|
}
|
|
|
|
// 取出交点在给定曲线上参数值
|
|
pCurve->getParamAtPoint(data.value.ptInt, data.compare);
|
|
CopyMemory(&data.value.adsEnt, (long*)ssSet[l], sizeof(ads_name));
|
|
arParamName.append(data);
|
|
OPENOBJ_END();
|
|
}
|
|
acedSSFree(ssSet);
|
|
OPENOBJ_END();
|
|
|
|
|
|
int iLen = arParamName.length();
|
|
if (iLen <= 0)
|
|
return 0;
|
|
|
|
// 取出与给定曲线垂直的曲线组
|
|
AcArray<CAxisSortPair> arPerpendicular;
|
|
int i = 0;
|
|
for (i = 0; i < iLen; i++)
|
|
{
|
|
if (arParamName[i].value.vecRef.isParallelTo(arParamName[i].value.vecDir))
|
|
arPerpendicular.append(arParamName[i]);
|
|
}
|
|
int iSelLen = arPerpendicular.length();
|
|
if (iSelLen > 1)
|
|
{
|
|
QuickSort(arPerpendicular.asArrayPtr(), iSelLen);
|
|
ads_name_set(arPerpendicular[0].value.adsEnt,ent1);
|
|
ads_name_set(arPerpendicular[iSelLen-1].value.adsEnt,ent2);
|
|
ads_point_set(asDblArray(arPerpendicular[0].value.ptInt),pt1);
|
|
ads_point_set(asDblArray(arPerpendicular[iSelLen-1].value.ptInt),pt2);
|
|
return 1;
|
|
}
|
|
|
|
// 取出平行曲线组
|
|
AcArray<CAxisSortPair> arParallel;
|
|
int j = 0;
|
|
for (j = 0; j < iLen; j++)
|
|
{
|
|
for (i = j+1; i < iLen; i++)
|
|
{
|
|
if (arParamName[i].value.vecDir.isParallelTo(arParamName[j].value.vecDir))
|
|
arParallel.append(arParamName[i]);
|
|
}
|
|
if (arParallel.length() > 0)
|
|
{
|
|
arParallel.append(arParamName[j]);
|
|
break;
|
|
}
|
|
}
|
|
iSelLen = arParallel.length();
|
|
if (iSelLen > 1)
|
|
{
|
|
QuickSort(arParallel.asArrayPtr(), iSelLen);
|
|
ads_name_set(arParallel[0].value.adsEnt,ent1);
|
|
ads_name_set(arParallel[iSelLen-1].value.adsEnt,ent2);
|
|
ads_point_set(asDblArray(arParallel[0].value.ptInt),pt1);
|
|
ads_point_set(asDblArray(arParallel[iSelLen-1].value.ptInt),pt2);
|
|
return 2;
|
|
}
|
|
|
|
// 取出最外侧的夹角线
|
|
QuickSort(arParamName.asArrayPtr(), iLen);
|
|
ads_name_set(arParamName[0].value.adsEnt,ent1);
|
|
ads_name_set(arParamName[iLen-1].value.adsEnt,ent2);
|
|
ads_point_set(asDblArray(arParamName[0].value.ptInt),pt1);
|
|
ads_point_set(asDblArray(arParamName[iLen-1].value.ptInt),pt2);
|
|
return 3;
|
|
}
|
|
|
|
// 返回给定线关系类型:0--无关线，1--平行线
|
|
int KTCADUtilityEx::GetAxisRelationShip(ads_name ent1, ads_name ent2)
|
|
{
|
|
AcDbObjectId id1,id2;
|
|
acdbGetObjectId(id1,ent1);
|
|
acdbGetObjectId(id2,ent2);
|
|
|
|
OPENOBJ_BEGIN(id1, AcDb::kForRead, AcDbCurve, pCurve1);
|
|
OPENOBJ_BEGIN(id2, AcDb::kForRead, AcDbCurve, pCurve2);
|
|
if (pCurve1 == NULL || pCurve2 == NULL)
|
|
return 0;
|
|
|
|
if (pCurve1->isKindOf(AcDbLine::desc()) && pCurve2->isKindOf(AcDbLine::desc()))
|
|
{
|
|
AcGePoint3d pt1, pt2, pt3, pt4, pt5, pt6;
|
|
pt1 = ((AcDbLine*)pCurve1)->startPoint();
|
|
pt2 = ((AcDbLine*)pCurve1)->endPoint();
|
|
pt3 = ((AcDbLine*)pCurve2)->startPoint();
|
|
pt4 = ((AcDbLine*)pCurve2)->endPoint();
|
|
AcGeVector3d vec1, vec2;
|
|
vec1 = pt2 - pt1;
|
|
vec2 = pt4 - pt3;
|
|
BOOL bCollinear = ((pt4 - pt1).isParallelTo(pt3 - pt1) || (pt4 - pt2).isParallelTo(pt3 - pt2));
|
|
if (vec1.isParallelTo(vec2) && !bCollinear) // 平行且不重合直线
|
|
return 1;
|
|
else
|
|
return 2;
|
|
}
|
|
OPENOBJ_END();
|
|
OPENOBJ_END();
|
|
return 0;
|
|
}
|
|
|
|
int KTCADUtilityEx::SortParallelAxisLine(AcDbObjectIdArray& ssResult)
|
|
{
|
|
// 取得垂直平行线的向量
|
|
AcGePoint3d pt;
|
|
AcGeVector3d vec;
|
|
int lLen = ssResult.length();
|
|
for (int l = 0; l < lLen; l++)
|
|
{
|
|
OPENOBJ_BEGIN(ssResult[l], AcDb::kForRead, AcDbLine, pLine);
|
|
if (pLine == NULL)
|
|
continue;
|
|
pt = pLine->startPoint();
|
|
vec = pLine->endPoint() - pt;
|
|
vec.rotateBy(PI/2.0, pLine->normal());
|
|
if (vec.length() > 1.e-6)
|
|
break;
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
// 排序数据
|
|
typedef CSortPair<double, AcDbObjectId, DoubleCompare> CAxisSortPair;
|
|
AcArray<CAxisSortPair> arParamName;
|
|
CAxisSortPair data;
|
|
|
|
// 从左边到右边，从下边到上边排序
|
|
double dAngle = ads_angle(asDblArray(CKTCadUtility::Wcs2Ucs(pt)),
|
|
asDblArray(CKTCadUtility::Wcs2Ucs(pt + vec)));
|
|
if (dAngle > PI * 3.0 / 4.0 && dAngle <= PI * 7.0 / 4.0)
|
|
vec.negate();
|
|
|
|
AcDbXline xline;
|
|
xline.setBasePoint(pt); xline.setUnitDir(vec);
|
|
for (int l = 0; l < lLen; l++)
|
|
{
|
|
OPENOBJ_BEGIN(ssResult[l], AcDb::kForRead, AcDbLine, pLine);
|
|
AcGePoint3dArray arpt;
|
|
if (xline.intersectWith(pLine, AcDb::kExtendBoth, arpt) != Acad::eOk || arpt.length() <= 0)
|
|
continue;
|
|
xline.getClosestPointTo(arpt[0], pt, Adesk::kTrue);
|
|
xline.getParamAtPoint(pt, data.compare);
|
|
data.value = ssResult[l];
|
|
arParamName.append(data);
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
int iLen = arParamName.length();
|
|
QuickSort(arParamName.asArrayPtr(), iLen);
|
|
|
|
ssResult.setLogicalLength(0);
|
|
for (int i = 0; i < iLen; i++)
|
|
{
|
|
ssResult.append(arParamName[i].value);
|
|
}
|
|
return iLen;
|
|
}
|
|
|
|
// 取得一个块引用属性
|
|
BOOL KTCADUtilityEx::GetAttribute(AcDbBlockReference* pRef, LPCTSTR pszTag, CString& sValue)
|
|
{
|
|
AcDbObjectIterator* pIT = pRef->attributeIterator();
|
|
if (pIT == NULL)
|
|
return FALSE;
|
|
|
|
BOOL bFind = FALSE;
|
|
LPTSTR pszTemp = NULL;
|
|
AcDbObjectId id;
|
|
for (pIT->start(); !pIT->done(); pIT->step())
|
|
{
|
|
id = pIT->objectId();
|
|
if (!id.isValid())
|
|
continue;
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbAttribute, pAttr);
|
|
if (pAttr == NULL)
|
|
continue;
|
|
pszTemp = pAttr->tag();
|
|
if (_tcscmp(pszTemp, pszTag) == 0)
|
|
{
|
|
acutDelString(pszTemp);
|
|
pszTemp = pAttr->textString();
|
|
sValue = pszTemp;
|
|
acutDelString(pszTemp);
|
|
bFind = TRUE;
|
|
break;
|
|
}
|
|
acutDelString(pszTemp);
|
|
OPENOBJ_END();
|
|
}
|
|
DELETE_PTR(pIT);
|
|
return bFind;
|
|
}
|
|
|
|
CString KTCADUtilityEx::GetNewAxisLabel(CString sLabel, BOOL bPostfix, int iStep)
|
|
{
|
|
if (sLabel.IsEmpty())
|
|
return sLabel;
|
|
|
|
CString sLabelCharSet = _T("ABCDEFGHJKLMNPQRSTUVWXYabcdefghjklmnpqrstuvwxy");
|
|
|
|
int iFind;
|
|
CString sRet;
|
|
int iLen = sLabel.GetLength() - 1;
|
|
if (bPostfix)
|
|
{
|
|
int i(iLen);
|
|
for (i = iLen; i >= 0 && _istdigit(sLabel[i]); i--) ;
|
|
if (i == iLen) // 是字母
|
|
{
|
|
iFind = sLabelCharSet.Find(sLabel[i]);
|
|
if (iFind < 0)
|
|
sRet = sLabel;
|
|
else
|
|
{
|
|
iFind += iStep;
|
|
if (iFind < 0)
|
|
iFind = 0;
|
|
if (iFind >= sLabelCharSet.GetLength())
|
|
iFind = sLabelCharSet.GetLength() - 1;
|
|
sRet.Format(_T("%s%c"), sLabel.Left(i), sLabelCharSet[iFind]);
|
|
}
|
|
}
|
|
else // 是数字
|
|
{
|
|
i++;
|
|
sRet.Format(_T("%s%d"), sLabel.Left(i), _ttoi(sLabel.Mid(i)) + iStep);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int i(0);
|
|
for (i = 0; i <= iLen && _istdigit(sLabel[i]); i++) ;
|
|
if (i == 0) // 是字母
|
|
{
|
|
iFind = sLabelCharSet.Find(sLabel[i]);
|
|
if (iFind < 0)
|
|
sRet = sLabel;
|
|
else
|
|
{
|
|
iFind += iStep;
|
|
if (iFind < 0)
|
|
iFind = 0;
|
|
if (iFind >= sLabelCharSet.GetLength())
|
|
iFind = sLabelCharSet.GetLength() - 1;
|
|
sRet.Format(_T("%c%s"), sLabelCharSet[iFind], sLabel.Mid(i+1));
|
|
}
|
|
}
|
|
else // 是数字
|
|
{
|
|
sRet.Format(_T("%d%s"), _ttoi(sLabel.Left(i)) + iStep, sLabel.Mid(i));
|
|
}
|
|
}
|
|
return sRet;
|
|
}
|
|
|
|
AcDbObjectId KTCADUtilityEx::InsertBlock(LPCTSTR pszFileName, LPCTSTR pszSrcName, LPCTSTR pszDestName, AcDbDatabase* pDb, BOOL bReplace)
|
|
{
|
|
AcDbObjectId id;
|
|
|
|
CString sBlkName = pszDestName;
|
|
if (sBlkName.IsEmpty())
|
|
{
|
|
sBlkName = pszFileName;
|
|
int iFind = sBlkName.ReverseFind(_T('\\')) + 1;
|
|
if (iFind > 0)
|
|
sBlkName = sBlkName.Mid(iFind);
|
|
iFind = sBlkName.ReverseFind(_T('.'));
|
|
if (iFind >= 0)
|
|
sBlkName = sBlkName.Left(iFind);
|
|
}
|
|
|
|
if (pDb == NULL)
|
|
pDb = acdbCurDwg();
|
|
|
|
AcDbBlockTable* pBT = NULL;
|
|
pDb->getBlockTable(pBT, AcDb::kForRead);
|
|
if (pBT == NULL)
|
|
return id;
|
|
if (pBT->has(sBlkName))
|
|
{
|
|
pBT->getAt(sBlkName, id);
|
|
if (bReplace)
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForWrite, AcDbBlockTableRecord, pBTR);
|
|
if (pBTR == NULL)
|
|
{
|
|
pBT->close();
|
|
return id;
|
|
}
|
|
pBTR->erase();
|
|
pBTR->close();
|
|
OPENOBJ_END();
|
|
}
|
|
else
|
|
{
|
|
pBT->close();
|
|
return id;
|
|
}
|
|
|
|
}
|
|
pBT->close();
|
|
|
|
CString sPath;
|
|
KTSetting::GetKTPsPath(sPath);
|
|
|
|
CString fullFile = sPath + _T("Support\\Cells\\") + pszFileName;
|
|
|
|
AcDbDatabase db(Adesk::kFalse);
|
|
if (db.readDwgFile(fullFile) != Acad::eOk)
|
|
return id;
|
|
|
|
if (pszSrcName != NULL && _tcslen(pszSrcName) > 0)
|
|
pDb->insert(id, pszSrcName, sBlkName, &db);
|
|
else
|
|
pDb->insert(id, sBlkName, &db);
|
|
|
|
return id;
|
|
}
|
|
|
|
// 取得平行线标注初始参数
|
|
BOOL KTCADUtilityEx::GetParallelAxisLineInitParam(const AcGePoint3d& ptPick, AcDbObjectId& entBL, AcDbObjectId& entTR, BOOL bCrossSelect,
|
|
AcGePoint3d& ptCurStart, AcGePoint3d& ptCurEnd, AcGePoint3d& ptOthStart, AcGePoint3d& ptOthEnd,
|
|
AcGeVector3d& vecCur, AcGeVector3d& vecOth)
|
|
{
|
|
OPENOBJ_BEGIN(entBL, AcDb::kForRead, AcDbLine, pLine1);
|
|
OPENOBJ_BEGIN(entTR, AcDb::kForRead, AcDbLine, pLine2);
|
|
if (pLine1 == NULL || pLine2 == NULL)
|
|
return FALSE;
|
|
|
|
// 求开始方向
|
|
AcGeVector3d vec = pLine1->endPoint() - pLine1->startPoint();
|
|
vec.rotateBy(PI/2.0, pLine1->normal());
|
|
AcDbXline line;
|
|
line.setBasePoint(ptPick);
|
|
line.setUnitDir(vec);
|
|
AcGePoint3dArray arpt1;
|
|
if (line.intersectWith(pLine1, AcDb::kExtendArg, arpt1) != Acad::eOk || arpt1.length() <= 0)
|
|
return FALSE;
|
|
AcGePoint3dArray arpt2;
|
|
if (line.intersectWith(pLine2, AcDb::kExtendArg, arpt2) != Acad::eOk || arpt2.length() <= 0)
|
|
return FALSE;
|
|
double dLen1 = arpt1[0].distanceTo(ptPick);
|
|
double dLen2 = arpt2[0].distanceTo(ptPick);
|
|
// 从左到右,从下往上
|
|
if (bCrossSelect || dLen1 < dLen2)
|
|
{
|
|
if (ptPick.distanceTo(pLine1->startPoint()) < ptPick.distanceTo(pLine1->endPoint()))
|
|
{
|
|
ptCurStart = pLine1->startPoint();
|
|
ptOthStart = pLine1->endPoint();
|
|
}
|
|
else
|
|
{
|
|
ptCurStart = pLine1->endPoint();
|
|
ptOthStart = pLine1->startPoint();
|
|
}
|
|
vec = ptCurStart - ptOthStart;
|
|
vec.rotateBy(PI/2.0, pLine1->normal());
|
|
line.setBasePoint(ptCurStart);
|
|
line.setUnitDir(vec);
|
|
AcGePoint3dArray arpt3;
|
|
if (line.intersectWith(pLine2, AcDb::kExtendArg, arpt3) != Acad::eOk || arpt3.length() <= 0)
|
|
return FALSE;
|
|
ptCurEnd = arpt3[0];
|
|
line.setBasePoint(ptOthStart);
|
|
line.setUnitDir(vec);
|
|
AcGePoint3dArray arpt4;
|
|
if (line.intersectWith(pLine2, AcDb::kExtendArg, arpt4) != Acad::eOk || arpt4.length() <= 0)
|
|
return FALSE;
|
|
ptOthEnd = arpt4[0];
|
|
|
|
vecCur = ptCurStart - ptOthStart;
|
|
vecCur.normalize();
|
|
vecOth = -vecCur;
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
if (ptPick.distanceTo(pLine2->startPoint()) < ptPick.distanceTo(pLine2->endPoint()))
|
|
{
|
|
ptCurStart = pLine2->startPoint();
|
|
ptOthStart = pLine2->endPoint();
|
|
}
|
|
else
|
|
{
|
|
ptCurStart = pLine2->endPoint();
|
|
ptOthStart = pLine2->startPoint();
|
|
}
|
|
vec = ptCurStart - ptOthStart;
|
|
vec.rotateBy(PI/2.0, pLine2->normal());
|
|
line.setBasePoint(ptCurStart);
|
|
line.setUnitDir(vec);
|
|
AcGePoint3dArray arpt3;
|
|
if (line.intersectWith(pLine1, AcDb::kExtendArg, arpt3) != Acad::eOk || arpt3.length() <= 0)
|
|
return FALSE;
|
|
ptCurEnd = arpt3[0];
|
|
line.setBasePoint(ptOthStart);
|
|
line.setUnitDir(vec);
|
|
AcGePoint3dArray arpt4;
|
|
if (line.intersectWith(pLine1, AcDb::kExtendArg, arpt4) != Acad::eOk || arpt4.length() <= 0)
|
|
return FALSE;
|
|
ptOthEnd = arpt4[0];
|
|
|
|
vecCur = ptCurStart - ptOthStart;
|
|
vecCur.normalize();
|
|
vecOth = -vecCur;
|
|
return TRUE;
|
|
}
|
|
OPENOBJ_END();
|
|
OPENOBJ_END();
|
|
return FALSE;
|
|
}
|
|
|
|
AcGePoint3d KTCADUtilityEx::GetCenterPoint(const AcGePoint3d& pt1, const AcGePoint3d& pt2)
|
|
{
|
|
return AcGePoint3d((pt1.x + pt2.x) / 2.0, (pt1.y + pt2.y) / 2.0, (pt1.z + pt2.z) / 2.0);
|
|
}
|
|
|
|
// 求由点和向量给定的直线是否和给定的曲线相交
|
|
BOOL KTCADUtilityEx::IsLinesIntersect(const AcGePoint3d& ptBase, const AcGeVector3d& vecDir, AcDbObjectId& ent)
|
|
{
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbCurve, pCurve);
|
|
if (pCurve == NULL)
|
|
return FALSE;
|
|
|
|
AcDbXline xline;
|
|
xline.setBasePoint(ptBase);
|
|
xline.setUnitDir(vecDir);
|
|
AcGePoint3dArray arpt;
|
|
if (xline.intersectWith(pCurve, AcDb::kExtendArg, arpt) != Acad::eOk || arpt.length() <= 0)
|
|
return FALSE;
|
|
|
|
AcGePoint3d pt;
|
|
pCurve->getClosestPointTo(arpt[0], pt);
|
|
return (pt == arpt[0]);
|
|
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
// 求两平行线间的距离
|
|
double KTCADUtilityEx::GetParallelAxisLineInterval(AcDbObjectId& ent1, AcDbObjectId& ent2)
|
|
{
|
|
OPENOBJ_BEGIN(ent1, AcDb::kForRead, AcDbLine, pLine1);
|
|
OPENOBJ_BEGIN(ent2, AcDb::kForRead, AcDbLine, pLine2);
|
|
if (pLine1 == NULL || pLine2 == NULL)
|
|
return 0.0;
|
|
|
|
AcGeVector3d vec = pLine1->endPoint() - pLine1->startPoint();
|
|
vec.rotateBy(PI/2.0, pLine1->normal());
|
|
|
|
AcDbXline xline;
|
|
xline.setBasePoint(pLine1->startPoint());
|
|
xline.setUnitDir(vec);
|
|
|
|
AcGePoint3dArray arpt1;
|
|
if (xline.intersectWith(pLine1, AcDb::kExtendArg, arpt1) != Acad::eOk || arpt1.length() <= 0)
|
|
return 0.0;
|
|
AcGePoint3dArray arpt2;
|
|
if (xline.intersectWith(pLine2, AcDb::kExtendArg, arpt2) != Acad::eOk || arpt2.length() <= 0)
|
|
return 0.0;
|
|
|
|
return arpt1[0].distanceTo(arpt2[0]);
|
|
OPENOBJ_END();
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
DxfList::DxfList(AcDbObjectId id)
|
|
{
|
|
ads_name adsName;
|
|
acdbGetAdsName(adsName, id);
|
|
m_pCur = m_pBuf = acdbEntGet(adsName);
|
|
}
|
|
|
|
DxfList::DxfList(ads_name sName)
|
|
{
|
|
m_pCur = m_pBuf = acdbEntGet(sName);
|
|
}
|
|
DxfList::~DxfList()
|
|
{
|
|
if(m_pBuf != NULL)
|
|
acutRelRb(m_pBuf);
|
|
}
|
|
|
|
bool DxfList::isNull()
|
|
{
|
|
return m_pBuf == NULL;
|
|
}
|
|
|
|
const resbuf* DxfList::getDxfField(AcDb::DxfCode nCode)
|
|
{
|
|
if (m_pBuf == NULL)
|
|
return NULL;
|
|
|
|
resbuf* pBuf = m_pBuf;
|
|
for (; pBuf!=NULL; pBuf=pBuf->rbnext)
|
|
{
|
|
if (pBuf->restype == nCode)
|
|
{
|
|
m_pCur = pBuf;
|
|
return pBuf;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
const resbuf* DxfList::NextDxfField(AcDb::DxfCode nCode)
|
|
{
|
|
if (m_pCur == NULL)
|
|
return NULL;
|
|
|
|
m_pCur = m_pCur->rbnext;
|
|
for (; m_pCur!=NULL; m_pCur=m_pCur->rbnext)
|
|
{
|
|
if (m_pCur->restype == nCode)
|
|
{
|
|
return m_pCur;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
AcDbObjectId KTCADUtilityEx::AppendAttribute(AcDbBlockReference* pRef, LPCTSTR pszTag, LPCTSTR pszValue)
|
|
{
|
|
AcDbObjectId id;
|
|
|
|
OPENOBJ_BEGIN(pRef->blockTableRecord(), AcDb::kForRead, AcDbBlockTableRecord, pBTR);
|
|
if (pBTR == NULL)
|
|
return id;
|
|
|
|
AcDbBlockTableRecordIterator* pIT = NULL;
|
|
pBTR->newIterator(pIT);
|
|
if (pIT == NULL)
|
|
return id;
|
|
|
|
AcGePoint3d pt;
|
|
|
|
BOOL bReadOnly;
|
|
AcDbEntity* pEnt;
|
|
AcDbAttribute* pAttr;
|
|
AcDbAttributeDefinition* pAttDef;
|
|
for (pIT->start(); !pIT->done(); pIT->step())
|
|
{
|
|
if (pIT->getEntity(pEnt, AcDb::kForRead) != Acad::eOk)
|
|
continue;
|
|
|
|
pAttDef = AcDbAttributeDefinition::cast(pEnt);
|
|
if (pAttDef == NULL || pAttDef->isConstant())
|
|
{
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
|
|
LPTSTR pszTemp = pAttDef->tag();
|
|
if (_tcscmp(pszTemp, pszTag) != 0)
|
|
{
|
|
acutDelString(pszTemp);
|
|
pEnt->close();
|
|
continue;
|
|
}
|
|
acutDelString(pszTemp);
|
|
|
|
bReadOnly = (!pRef->isWriteEnabled());
|
|
if (bReadOnly && pRef->upgradeOpen() != Acad::eOk)
|
|
{
|
|
pEnt->close();
|
|
break;
|
|
}
|
|
|
|
pAttr = new AcDbAttribute(pAttDef->position(), pszValue, pszTag, pAttDef->textStyle());
|
|
pAttr->setPropertiesFrom(pAttDef);
|
|
pAttr->setHeight(pAttDef->height());
|
|
pAttr->setRotation(pAttDef->rotation());
|
|
|
|
pAttr->setHorizontalMode(pAttDef->horizontalMode());
|
|
pAttr->setVerticalMode(pAttDef->verticalMode());
|
|
pt = pAttDef->alignmentPoint();
|
|
pAttr->setAlignmentPoint(pt);
|
|
AcGeMatrix3d mat = pRef->blockTransform();
|
|
pAttr->transformBy(mat);
|
|
|
|
DxfList dxfList(pRef->blockTableRecord());
|
|
const resbuf* pBuf = dxfList.getDxfField(AcDb::kDxfBlockName) ;
|
|
|
|
if(pBuf != NULL)
|
|
{
|
|
int nRes1 = _tcscmp(pBuf->resval.rstring,_T("_AXISO1"));
|
|
int nRes2 = _tcscmp(pBuf->resval.rstring,_T("_AXISO2"));
|
|
|
|
if(nRes1==0 || nRes2==0)
|
|
{
|
|
double dAng = (pRef->rotation());
|
|
dAng = CKTCadUtility::Wcs2Ucs(dAng);
|
|
AcGeVector3d vec = CKTCadUtility::GetUcsYAxis();
|
|
vec.rotateBy(dAng,CKTCadUtility::GetUcsZAxis());
|
|
double dScale = 100.0;
|
|
|
|
double dHeight = 4.0 * dScale;
|
|
AcGeVector3d offset ;
|
|
if(nRes1 ==0)offset = vec*dHeight;
|
|
else offset = -vec*dHeight;
|
|
|
|
mat.setToRotation(-dAng,CKTCadUtility::GetUcsZAxis(),pRef->position()-offset);
|
|
pAttr->transformBy(mat);
|
|
}
|
|
}
|
|
|
|
pAttDef->close();
|
|
pRef->appendAttribute(id, pAttr);
|
|
pAttr->close();
|
|
|
|
if (bReadOnly)
|
|
pRef->downgradeOpen();
|
|
break;
|
|
}
|
|
DELETE_PTR(pIT);
|
|
return id;
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
AcDbObjectId KTCADUtilityEx::CreateGroup(const AcDbObjectIdArray& aridObj,
|
|
LPCTSTR pszGroupName, bool bSelectable,
|
|
BOOL* bOver, AcDbDatabase* pDb)
|
|
{
|
|
BOOL bAnonymous = (pszGroupName == NULL || _tcslen(pszGroupName) <= 0);
|
|
|
|
if (pDb == NULL)
|
|
pDb = acdbCurDwg();
|
|
|
|
AcDbObjectId id;
|
|
AcDbDictionary* pDict = NULL;
|
|
Acad::ErrorStatus es;
|
|
if ( Acad::eOk != (es = pDb->getGroupDictionary(pDict, AcDb::kForRead) ) )
|
|
{
|
|
return AcDbObjectId::kNull;
|
|
}
|
|
|
|
if (!bAnonymous && pDict->has(pszGroupName))
|
|
{
|
|
pDict->getAt(pszGroupName, id);
|
|
AcDbObject* pObj = NULL;
|
|
if (bOver != NULL && (*bOver) && acdbOpenObject(pObj, id, AcDb::kForWrite) == Acad::eOk && pObj != NULL)
|
|
{
|
|
pObj->erase();
|
|
pObj->close();
|
|
}
|
|
else
|
|
{
|
|
if (bOver != NULL)
|
|
*bOver = FALSE;
|
|
|
|
if (pObj != NULL)
|
|
pObj->close();
|
|
|
|
pDict->close();
|
|
|
|
return id;
|
|
}
|
|
}
|
|
|
|
if (pDict->upgradeOpen() != Acad::eOk)
|
|
{
|
|
pDict->close();
|
|
return AcDbObjectId::kNull;
|
|
}
|
|
|
|
if (aridObj.length() == 0)
|
|
{
|
|
pDict->close();
|
|
return AcDbObjectId::kNull;
|
|
}
|
|
|
|
AcDbGroup* pGroup = new AcDbGroup;
|
|
ASSERT(pGroup != NULL);
|
|
|
|
pDict->setAt(_T("*A"), pGroup, id);
|
|
pDict->close();
|
|
pDict->downgradeOpen();
|
|
ASSERT(!id.isNull());
|
|
|
|
pGroup->setSelectable(bSelectable);
|
|
if (bAnonymous)
|
|
pGroup->setAnonymous();
|
|
else
|
|
pGroup->setName((LPTSTR)pszGroupName);
|
|
|
|
Acad::ErrorStatus e = pGroup->append(aridObj);
|
|
|
|
pGroup->close();
|
|
|
|
return id;
|
|
}
|
|
|
|
// 余弦定律求三角形顶角
|
|
static double GetTriangleAngle(const AcGePoint3d ptC, const AcGePoint3d ptA, const AcGePoint3d ptB)
|
|
{
|
|
double dA = ptC.distanceTo(ptB);
|
|
double dB = ptC.distanceTo(ptA);
|
|
double dC = ptA.distanceTo(ptB);
|
|
return acos((dA * dA + dB * dB - dC * dC) / (2.0 * dA * dB));
|
|
}
|
|
|
|
// 海伦公式求三角形面积
|
|
static double GetTriangleArea(const AcGePoint3d ptA, const AcGePoint3d ptB, const AcGePoint3d ptC)
|
|
{
|
|
double dA = ptC.distanceTo(ptB);
|
|
double dB = ptC.distanceTo(ptA);
|
|
double dC = ptA.distanceTo(ptB);
|
|
double dS = (dA + dB + dC) / 2.0;
|
|
double dAll = dS * (dS - dA) * (dS - dB) * (dS - dC);
|
|
return (dAll > 0.0 ? sqrt(dAll) : 0.0);
|
|
}
|
|
|
|
int KTCADUtilityEx::IsPointInPoly(int nvert, float *vertx, float *verty, float testx, float testy)
|
|
{
|
|
int i, j, c = 0;
|
|
for (i = 0, j = nvert-1; i < nvert; j = i++)
|
|
{
|
|
if ( ( ( verty[i] > testy) != (verty[j] > testy)) &&
|
|
(testx < (vertx[j] - vertx[i]) * (testy - verty[i]) / (verty[j] - verty[i]) + vertx[i]) )
|
|
c = !c;
|
|
}
|
|
return c;
|
|
}
|
|
|
|
// 判断点是否在边界线内，边界点必须连续
|
|
BOOL KTCADUtilityEx::IsPointInBoundary(const AcGePoint3d& ptTest, const AcGePoint3d& pt1, const AcGePoint3d& pt2, const AcGePoint3d& pt3, const AcGePoint3d& pt4)
|
|
{
|
|
float* pvertx = new float[4];
|
|
float* pverty = new float[4];
|
|
int nvert = 4;
|
|
|
|
pvertx[0] = (float)(pt1.x);
|
|
pvertx[1] = (float)(pt2.x);
|
|
pvertx[2] = (float)(pt3.x);
|
|
pvertx[3] = (float)(pt4.x);
|
|
|
|
pverty[0] = (float)(pt1.y);
|
|
pverty[1] = (float)(pt2.y);
|
|
pverty[2] = (float)(pt3.y);
|
|
pverty[3] = (float)(pt4.y);
|
|
|
|
float ftestX = (float)(ptTest.x);
|
|
float ftestY = (float)(ptTest.y);
|
|
|
|
int nFlag = IsPointInPoly(nvert,pvertx,pverty,ftestX,ftestY);
|
|
|
|
delete [] pvertx;
|
|
delete [] pverty;
|
|
|
|
return nFlag > 0 ? TRUE : FALSE;
|
|
}
|
|
|
|
static AcGePoint3d Min(const AcGePoint3d& pt1,const AcGePoint3d& pt2)
|
|
{
|
|
return AcGePoint3d(__min(pt1.x,pt2.x),__min(pt1.y,pt2.y),__min(pt1.z,pt2.z));
|
|
}
|
|
|
|
static AcGePoint3d Max(const AcGePoint3d& pt1,const AcGePoint3d& pt2)
|
|
{
|
|
return AcGePoint3d(__max(pt1.x,pt2.x),__max(pt1.y,pt2.y),__max(pt1.z,pt2.z));
|
|
}
|
|
|
|
BOOL KTCADUtilityEx::IsPointInBoundary(const AcGePoint3d& ptTest, const AcGePoint3d& pt1, const AcGePoint3d& pt2)
|
|
{
|
|
AcGePoint3d ptMin = Min(pt1, pt2);
|
|
AcGePoint3d ptMax = Max(pt1, pt2);
|
|
return (!(ptTest.x < ptMin.x || ptTest.x > ptMax.x
|
|
|| ptTest.y < ptMin.y || ptTest.y > ptMax.y
|
|
|| ptTest.z < ptMin.z || ptTest.z > ptMax.z));
|
|
}
|
|
|
|
BOOL KTCADUtilityEx::BreakCurve(AcDbObjectId& ent, const AcGePoint3d& pt1, const AcGePoint3d& pt2,
|
|
AcDbObjectIdArray& arid, const AcGePoint3d* ptHit)
|
|
{
|
|
OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbCurve, pCurve);
|
|
if (pCurve == NULL)
|
|
return FALSE;
|
|
|
|
BOOL bClosed = (pCurve->isClosed() && ptHit != NULL);
|
|
|
|
AcGePoint3d ptStart, ptEnd;
|
|
pCurve->getStartPoint(ptStart);
|
|
pCurve->getEndPoint(ptEnd);
|
|
|
|
AcGePoint3dArray arpt;
|
|
if (pt1 != ptStart && pt1 != ptEnd)
|
|
arpt.append(pt1);
|
|
if (bClosed && *ptHit != ptStart && *ptHit != ptEnd)
|
|
arpt.append(*ptHit);
|
|
if (pt2 != ptStart && pt2 != ptEnd)
|
|
arpt.append(pt2);
|
|
|
|
AcDbVoidPtrArray arpCurve;
|
|
if (arpt.length() <= 0 || pCurve->getSplitCurves(arpt, arpCurve) != Acad::eOk)
|
|
return FALSE;
|
|
|
|
BOOL bDelete;
|
|
double dDist;
|
|
AcDbObjectId id;
|
|
AcDbCurve* pSub;
|
|
struct resbuf* rb = pCurve->xData();
|
|
|
|
int iLen = arpCurve.length();
|
|
int i = 0;
|
|
for (i = 0; i < iLen; i++)
|
|
{
|
|
pSub = (AcDbCurve*)arpCurve[i];
|
|
if (pSub == NULL)
|
|
continue;
|
|
|
|
pSub->getStartPoint(ptStart);
|
|
pSub->getEndPoint(ptEnd);
|
|
|
|
dDist = 0.0;
|
|
pSub->getDistAtPoint(ptEnd, dDist);
|
|
|
|
bDelete = FALSE;
|
|
if (dDist < 0.1)
|
|
{
|
|
bDelete = TRUE;
|
|
}
|
|
else if (bClosed)
|
|
{
|
|
if (ptStart == pt1 && ptEnd == *ptHit || ptStart == *ptHit && ptEnd == pt1
|
|
|| ptStart == pt2 && ptEnd == *ptHit || ptStart == *ptHit && ptEnd == pt2)
|
|
bDelete = TRUE;
|
|
}
|
|
else if (ptStart == pt1 && ptEnd == pt2 || ptStart == pt2 && ptEnd == pt1)
|
|
{
|
|
bDelete = TRUE;
|
|
}
|
|
|
|
if (bDelete)
|
|
{
|
|
DELETE_PTR(pSub);
|
|
continue;
|
|
}
|
|
|
|
pSub->setPropertiesFrom(pCurve);
|
|
pSub->setXData(rb);
|
|
CKTCadUtility::AddToBlockTableRecord(id,pSub);
|
|
pSub->close();
|
|
arid.append(id);
|
|
}
|
|
|
|
if (iLen > 0 && pCurve->upgradeOpen() == Acad::eOk)
|
|
pCurve->erase();
|
|
OPENOBJ_END();
|
|
return TRUE;
|
|
}
|
|
|
|
int KTCADUtilityEx::WallParamAngleSortCompare(double* arg1, double* arg2)
|
|
{
|
|
int iRet = KTCADUtilityEx::DoubleCompare(arg1[0], arg2[0]);
|
|
if (iRet == 0)
|
|
iRet = KTCADUtilityEx::DoubleCompare(arg1[1], arg2[1]);
|
|
return iRet;
|
|
}
|
|
|
|
double KTCADUtilityEx::GetBulge(const AcGePoint3d& ptStart, const AcGePoint3d& ptEnd, double dRadius, BOOL bClockWise)
|
|
{
|
|
double dLen = ptStart.distanceTo(ptEnd);
|
|
if (dLen > 2.0 * dRadius)
|
|
return (bClockWise ? -1.0 : 1.0);
|
|
|
|
double dBulge = tan(acos(1 - (dLen * dLen) / (2.0 * dRadius * dRadius)) / 4.0);
|
|
return (bClockWise ? -dBulge : dBulge);
|
|
}
|
|
|
|
BOOL KTCADUtilityEx::IsPointAtSameSide(const AcGePlane& plane, const AcGePoint3d& pt1, const AcGePoint3d& pt2)
|
|
{
|
|
if (plane.isOn(pt1) || plane.isOn(pt2))
|
|
return 1;
|
|
|
|
AcGePoint3d ptPrj1 = pt1.project(plane, plane.normal());
|
|
AcGePoint3d ptPrj2 = pt2.project(plane, plane.normal());
|
|
if ((pt1 - ptPrj1).isCodirectionalTo(pt2 - ptPrj2))
|
|
return 2;
|
|
|
|
return 0;
|
|
}
|
|
|
|
double KTCADUtilityEx::GetBulge(const AcGePoint3d& ptStart, const AcGePoint3d& ptEnd, const AcGePoint3d& ptSample)
|
|
{
|
|
if (ptStart == ptEnd)
|
|
return 0.0;
|
|
if (ptStart == ptSample || ptEnd == ptSample)
|
|
return 1.0;
|
|
|
|
AcGeVector3d vec = ptEnd - ptStart;
|
|
vec.normalize();
|
|
vec.rotateBy(vec.angleTo(ptSample - ptStart), CKTCadUtility::GetUcsZAxis());
|
|
|
|
AcGeCircArc3d arc(ptStart, ptSample, ptEnd);
|
|
AcGePlane plane(ptStart, (ptEnd - ptStart).rotateBy(PI/2.0, CKTCadUtility::GetUcsZAxis()));
|
|
|
|
double dLen = ptStart.distanceTo(ptEnd);
|
|
double dAngle = acos(1 - (dLen * dLen) / (2.0 * arc.radius() * arc.radius()));
|
|
if (IsPointAtSameSide(plane, arc.center(), ptSample))
|
|
dAngle = PI * 2.0 - dAngle;
|
|
|
|
double dBulge = tan(dAngle / 4.0);
|
|
AcGePoint3d ptTmp = ptStart + vec * ptSample.distanceTo(ptStart);
|
|
|
|
return ((ptTmp == ptSample) ? -dBulge : dBulge);
|
|
}
|
|
|
|
static void FreeBuffer(int n,AcDbVoidPtrArray& arEntPtrs)
|
|
{
|
|
AcDbEntity* pEnt = NULL;
|
|
while(arEntPtrs.length() > n )
|
|
{
|
|
pEnt = (AcDbEntity*)arEntPtrs.last();
|
|
if (pEnt != NULL)
|
|
{
|
|
pEnt->erase();
|
|
pEnt->close();
|
|
arEntPtrs.removeLast();
|
|
DELETE_PTR(pEnt);
|
|
}
|
|
}
|
|
}
|
|
|
|
AcDbArc* KTCADUtilityEx::FormatArc(const AcGePoint3d& ptGe1,const AcGePoint3d& ptGe2,const AcGePoint3d& ptGe3)
|
|
{
|
|
AcDbArc* pArcThis = NULL;
|
|
AcGeCircArc3d cirArc3d;
|
|
cirArc3d.set(ptGe1,ptGe2,ptGe3);
|
|
|
|
AcGeVector3d vtNorm = cirArc3d.normal();
|
|
if (vtNorm.isParallelTo(AcGeVector3d::kZAxis))
|
|
{
|
|
if (!vtNorm.isCodirectionalTo(AcGeVector3d::kZAxis))
|
|
{
|
|
vtNorm.negate();//相反
|
|
}
|
|
}
|
|
|
|
AcDbCircle cir;
|
|
cir.setCenter(cirArc3d.center());
|
|
cir.setRadius(cirArc3d.radius());
|
|
cir.setNormal(vtNorm);
|
|
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(ptGe1);
|
|
arPts.append(ptGe3);
|
|
|
|
AcDbVoidPtrArray arCurPtrs;
|
|
cir.getSplitCurves(arPts,arCurPtrs);
|
|
|
|
double dPara = 0.0;
|
|
AcDbCurve* pCurve = NULL;
|
|
for (int j = 0;j < arCurPtrs.length();j++)
|
|
{
|
|
pCurve = (AcDbCurve*)arCurPtrs.at(j);
|
|
if (pCurve != NULL)
|
|
{
|
|
if (Acad::eOk == pCurve->getParamAtPoint(ptGe2,dPara))//中点在圆弧上
|
|
{
|
|
AcDbArc* pArc = AcDbArc::cast(pCurve);
|
|
if (pArc != NULL)
|
|
{
|
|
pArcThis = pArc;
|
|
arCurPtrs.removeAt(j);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
FreeBuffer(0,arCurPtrs);
|
|
return pArcThis;
|
|
}
|
|
|
|
AcDbArc* KTCADUtilityEx::FormatArc(const AcGeVector3d& vtMaj,const AcGeVector3d& vtMin,const AcGePoint3d& ptMid,AcGePoint3d& ptFr,double dSweepAngle,double dR,double dRatio,BOOL bdRisL)
|
|
{
|
|
AcGeVector3d vtLast = vtMaj;
|
|
vtLast.negate();
|
|
vtLast.normalize();
|
|
|
|
AcGeVector3d vtNext = vtMin;
|
|
vtNext.normalize();
|
|
|
|
if (vtLast.isParallelTo(vtNext))
|
|
return NULL;
|
|
|
|
double dAngle = 0, dRR = 0, dL = 0, dX = 0;
|
|
dAngle = dSweepAngle;
|
|
|
|
if (bdRisL)
|
|
{
|
|
dL = dR / cos(0.5 * dAngle);
|
|
dX = dL * sin(0.5 * dAngle);
|
|
dRR = dR;
|
|
}
|
|
else
|
|
{
|
|
dRR = dR * dRatio;
|
|
dL = dRR / cos( 0.5 * dAngle);
|
|
dX = dL * sin( 0.5 * dAngle);
|
|
}
|
|
|
|
AcGeVector3d vtHalf = vtLast + vtNext;
|
|
vtHalf.normalize();
|
|
|
|
AcGeVector3d vtNorm = vtLast.crossProduct(vtNext);
|
|
AcGePoint3d ptCen = ptMid + dL * vtHalf;
|
|
|
|
ptFr = ptMid + dX * vtLast;
|
|
|
|
AcGeVector3d vt1 = vtHalf;
|
|
vt1.negate();
|
|
vt1.rotateBy(dAngle / 2.0,vtNorm);
|
|
|
|
vt1.normalize();
|
|
AcGePoint3d pt1 = ptCen + vt1 * dR;
|
|
|
|
vt1 = vtHalf;
|
|
vt1.negate();
|
|
vt1.rotateBy(-dAngle / 2.0,vtNorm);
|
|
vt1.normalize();
|
|
|
|
AcGePoint3d pt2 = ptCen + vt1 * dR;
|
|
|
|
AcDbCircle cir1;
|
|
cir1.setCenter(ptCen);
|
|
cir1.setRadius(dRR);
|
|
cir1.setNormal(vtNorm);
|
|
|
|
cir1.getClosestPointTo(pt1,pt1);
|
|
cir1.getClosestPointTo(pt2,pt2);
|
|
|
|
AcGePlane plan;
|
|
plan.set(ptCen,vtNorm);
|
|
|
|
AcGePoint3dArray arPts;
|
|
arPts.append(pt1);arPts.append(pt2);
|
|
AcDbVoidPtrArray arArcPtrs;
|
|
cir1.getSplitCurves(arPts,arArcPtrs);
|
|
|
|
AcDbLine ln;
|
|
ln.setStartPoint(ptCen);
|
|
ln.setEndPoint(ptMid);
|
|
|
|
KTTempTol tol(1.e-3);
|
|
AcGePoint3dArray arPts1,arPts2;
|
|
AcDbArc* pArcElbow = NULL;
|
|
if (arArcPtrs.length() == 2)
|
|
{
|
|
AcDbArc* pArc1 = (AcDbArc* )arArcPtrs.first();
|
|
AcDbArc* pArc2 = (AcDbArc* )arArcPtrs.last();
|
|
|
|
pArc1->intersectWith(&ln,AcDb::kOnBothOperands,arPts1);
|
|
pArc2->intersectWith(&ln,AcDb::kOnBothOperands,arPts2);
|
|
|
|
AcDbObjectId id;
|
|
if (!arPts1.isEmpty())
|
|
{
|
|
pArcElbow = pArc1;
|
|
DELETE_PTR(pArc2);
|
|
}
|
|
else//ptmid 距离 pArc2近
|
|
{
|
|
pArcElbow = pArc2;
|
|
DELETE_PTR(pArc1);
|
|
}
|
|
}
|
|
return pArcElbow;
|
|
}
|
|
|
|
AcDbCurve* KTCADUtilityEx::ConvertBoundCurve(const AcDbVoidPtrArray& arpCurve,
|
|
AcDbVoidPtrArray& arpResult)
|
|
{
|
|
if (arpCurve.length() <= 0)
|
|
return NULL;
|
|
|
|
AcDbCurve* pRetCurve = NULL;
|
|
|
|
AcDbVoidPtrArray arpEnt(arpCurve);
|
|
AcDbCurve* pCurve = (AcDbCurve*)arpEnt.first();
|
|
ASSERT(pCurve != NULL && pCurve->isKindOf(AcDbCurve::desc()));
|
|
arpEnt.removeFirst();
|
|
arpResult.append(pCurve);
|
|
if (pCurve->isClosed())
|
|
{
|
|
pRetCurve = (AcDbCurve*)pCurve->isA()->create();
|
|
CopyObject(*pCurve, *pRetCurve); // 复杂实体可能需要Deepclone
|
|
return pRetCurve;
|
|
}
|
|
|
|
AcGePoint3d ptStart, ptEnd;
|
|
pCurve->getStartPoint(ptStart);
|
|
pCurve->getEndPoint(ptEnd);
|
|
|
|
AcGePlane plane;
|
|
AcGePoint3d pt3d;
|
|
AcDbPolyline* pPline = NULL;
|
|
double dParam1, dParam2;
|
|
AcGeVector3d vtNorm;
|
|
|
|
if (pCurve->isKindOf(AcDbLine::desc()))
|
|
{
|
|
vtNorm = ((AcDbLine *)pCurve)->normal();
|
|
plane.set(AcGePoint3d::kOrigin, ((AcDbLine*)pCurve)->normal());
|
|
pPline = new AcDbPolyline;
|
|
ASSERT(pPline != NULL);
|
|
pPline->setNormal(plane.normal());
|
|
pPline->addVertexAt(0, ptStart.convert2d(plane));
|
|
pPline->addVertexAt(1, ptEnd.convert2d(plane));
|
|
}
|
|
else if (pCurve->isKindOf(AcDbArc::desc()))
|
|
{
|
|
vtNorm = ((AcDbArc *)pCurve)->normal();
|
|
plane.set(AcGePoint3d::kOrigin, ((AcDbArc*)pCurve)->normal());
|
|
pPline = new AcDbPolyline;
|
|
ASSERT(pPline != NULL);
|
|
pPline->setNormal(plane.normal());
|
|
pCurve->getStartParam(dParam1);
|
|
pCurve->getEndParam(dParam2);
|
|
pCurve->getPointAtParam((dParam1 + dParam2) / 2.0, pt3d);
|
|
|
|
pPline->addVertexAt(0, ptStart.convert2d(plane),
|
|
KTCADUtilityEx::GetBulge(ptStart, ptEnd, pt3d));
|
|
pPline->addVertexAt(1, ptEnd.convert2d(plane));
|
|
|
|
AcGePoint3d pt3dT;
|
|
pPline->getClosestPointTo(pt3d,pt3dT);
|
|
|
|
//校正
|
|
pt3dT.z = pt3d.z;
|
|
if (pt3d.distanceTo(pt3dT) < 1.e-3)//认为相等
|
|
{
|
|
}
|
|
else
|
|
{
|
|
pPline->removeVertexAt(0);
|
|
pPline->removeVertexAt(0);
|
|
|
|
pPline->addVertexAt(0, ptStart.convert2d(plane),
|
|
-KTCADUtilityEx::GetBulge(ptStart, ptEnd, pt3d));
|
|
pPline->addVertexAt(1, ptEnd.convert2d(plane));
|
|
}
|
|
}
|
|
else if (pCurve->isKindOf(AcDbPolyline::desc()))
|
|
{
|
|
vtNorm = ((AcDbPolyline *)pCurve)->normal();
|
|
plane.set(AcGePoint3d::kOrigin, ((AcDbPolyline*)pCurve)->normal());
|
|
pPline = new AcDbPolyline;
|
|
ASSERT(pPline != NULL);
|
|
CopyObject((const AcDbPolyline&)*pCurve, *pPline);
|
|
}
|
|
else if (pCurve->isKindOf(AcDb2dPolyline::desc()))
|
|
{
|
|
AcDbPolyline* pPl = new AcDbPolyline;
|
|
if ( Acad::eOk == pPl->convertFrom((AcDbEntity*&)pCurve,Adesk::kFalse) )
|
|
{
|
|
pPline = pPl;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pRetCurve = (AcDbCurve*)pCurve->isA()->create();
|
|
CopyObject(*pCurve, *pRetCurve);
|
|
return pRetCurve;
|
|
}
|
|
|
|
pRetCurve = pPline;
|
|
|
|
int iLen;
|
|
double dBulge;
|
|
AcGePoint2d pt2d;
|
|
AcGePoint3d pt1, pt2;
|
|
int n, iNum, iIndex;
|
|
while ((iLen = arpEnt.length()) >= 0)
|
|
{
|
|
int i = 0;
|
|
for (i = 0; i < iLen; i++)
|
|
{
|
|
pCurve = (AcDbCurve*)arpEnt[i];
|
|
ASSERT(pCurve != NULL);
|
|
pCurve->getStartPoint(pt1);
|
|
pCurve->getEndPoint(pt2);
|
|
if (pt1.distanceTo(ptStart) < 1.e-1)
|
|
{
|
|
if (pCurve->isKindOf(AcDbLine::desc()))
|
|
{
|
|
pPline->addVertexAt(0, pt2.convert2d(plane));
|
|
}
|
|
else if (pCurve->isKindOf(AcDbArc::desc()))
|
|
{
|
|
pCurve->getStartParam(dParam1);
|
|
pCurve->getEndParam(dParam2);
|
|
pCurve->getPointAtParam((dParam1 + dParam2) / 2.0, pt3d);
|
|
pPline->addVertexAt(0, pt2.convert2d(plane),
|
|
KTCADUtilityEx::GetBulge(pt2, pt1, pt3d));
|
|
}
|
|
else if (pCurve->isKindOf(AcDbPolyline::desc()))
|
|
{
|
|
iNum = ((AcDbPolyline*)pCurve)->numVerts() - 1;
|
|
for (n = 0; n < iNum; n++)
|
|
{
|
|
((AcDbPolyline*)pCurve)->getBulgeAt(n, dBulge);
|
|
((AcDbPolyline*)pCurve)->getPointAt(n+1, pt2d);
|
|
pPline->addVertexAt(0, pt2d, -dBulge);
|
|
}
|
|
}
|
|
ptStart = pt2;
|
|
arpEnt.removeAt(i);
|
|
arpResult.append(pCurve);
|
|
break;
|
|
}
|
|
else if (pt1.distanceTo(ptEnd) < 1.e-1)
|
|
{
|
|
iIndex = pPline->numVerts();
|
|
if (pCurve->isKindOf(AcDbLine::desc()))
|
|
{
|
|
pPline->setBulgeAt(iIndex - 1,0.0);//?????
|
|
pPline->addVertexAt(iIndex, pt2.convert2d(plane));
|
|
}
|
|
else if (pCurve->isKindOf(AcDbArc::desc()))
|
|
{
|
|
pCurve->getStartParam(dParam1);
|
|
pCurve->getEndParam(dParam2);
|
|
pCurve->getPointAtParam((dParam1 + dParam2) / 2.0, pt3d);
|
|
|
|
pPline->setBulgeAt(iIndex-1, KTCADUtilityEx::GetBulge(pt1, pt2, pt3d));
|
|
pPline->addVertexAt(iIndex, pt2.convert2d(plane),0.0);
|
|
}
|
|
else if (pCurve->isKindOf(AcDbPolyline::desc()))
|
|
{
|
|
iNum = ((AcDbPolyline*)pCurve)->numVerts();
|
|
((AcDbPolyline*)pCurve)->getBulgeAt(0, dBulge);
|
|
pPline->setBulgeAt(iIndex-1, dBulge);
|
|
for (n = 1; n < iNum; n++, iIndex++)
|
|
{
|
|
((AcDbPolyline*)pCurve)->getBulgeAt(n, dBulge);
|
|
((AcDbPolyline*)pCurve)->getPointAt(n, pt2d);
|
|
pPline->addVertexAt(iIndex, pt2d, dBulge);
|
|
}
|
|
}
|
|
ptEnd = pt2;
|
|
arpEnt.removeAt(i);
|
|
arpResult.append(pCurve);
|
|
break;
|
|
}
|
|
else if (pt2.distanceTo(ptStart) < 1.e-1)
|
|
{
|
|
if (pCurve->isKindOf(AcDbLine::desc()))
|
|
{
|
|
pPline->addVertexAt(0, pt1.convert2d(plane));
|
|
}
|
|
else if (pCurve->isKindOf(AcDbArc::desc()))
|
|
{
|
|
pCurve->getStartParam(dParam1);
|
|
pCurve->getEndParam(dParam2);
|
|
pCurve->getPointAtParam((dParam1 + dParam2) / 2.0, pt3d);
|
|
pPline->addVertexAt(0, pt1.convert2d(plane),
|
|
KTCADUtilityEx::GetBulge(pt1, pt2, pt3d));
|
|
}
|
|
else if (pCurve->isKindOf(AcDbPolyline::desc()))
|
|
{
|
|
iNum = ((AcDbPolyline*)pCurve)->numVerts() - 2;
|
|
for (n = iNum; n >= 0; n--)
|
|
{
|
|
((AcDbPolyline*)pCurve)->getBulgeAt(n, dBulge);
|
|
((AcDbPolyline*)pCurve)->getPointAt(n, pt2d);
|
|
pPline->addVertexAt(0, pt2d, dBulge);
|
|
}
|
|
}
|
|
ptStart = pt1;
|
|
arpEnt.removeAt(i);
|
|
arpResult.append(pCurve);
|
|
break;
|
|
}
|
|
else if (pt2.distanceTo(ptEnd) < 1.e-1)
|
|
{
|
|
iIndex = pPline->numVerts();
|
|
if (pCurve->isKindOf(AcDbLine::desc()))
|
|
{
|
|
pPline->addVertexAt(iIndex, pt1.convert2d(plane));
|
|
}
|
|
else if (pCurve->isKindOf(AcDbArc::desc()))
|
|
{
|
|
pCurve->getStartParam(dParam1);
|
|
pCurve->getEndParam(dParam2);
|
|
pCurve->getPointAtParam((dParam1 + dParam2) / 2.0, pt3d);
|
|
pPline->setBulgeAt(iIndex-1, KTCADUtilityEx::GetBulge(pt2, pt1, pt3d));
|
|
pPline->addVertexAt(iIndex, pt1.convert2d(plane));
|
|
}
|
|
else if (pCurve->isKindOf(AcDbPolyline::desc()))
|
|
{
|
|
iNum = ((AcDbPolyline*)pCurve)->numVerts() - 2;
|
|
((AcDbPolyline*)pCurve)->getBulgeAt(iNum, dBulge);
|
|
pPline->setBulgeAt(iIndex-1, -dBulge);
|
|
for (n = iNum; n > 0; n--, iIndex++)
|
|
{
|
|
((AcDbPolyline*)pCurve)->getBulgeAt(n-1, dBulge);
|
|
((AcDbPolyline*)pCurve)->getPointAt(n, pt2d);
|
|
pPline->addVertexAt(iIndex, pt2d, -dBulge);
|
|
}
|
|
((AcDbPolyline*)pCurve)->getPointAt(n, pt2d);
|
|
pPline->addVertexAt(iIndex, pt2d);
|
|
}
|
|
ptEnd = pt1;
|
|
arpEnt.removeAt(i);
|
|
arpResult.append(pCurve);
|
|
break;
|
|
}
|
|
}
|
|
if (i >= iLen) break;
|
|
}
|
|
pPline->setClosed(ptStart == ptEnd);
|
|
return pRetCurve;
|
|
}
|
|
|
|
BOOL KTCADUtilityEx::GetIntsectCurves(AcDbBlockReference* pRef, AcDbObjectIdArray& arRes)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL KTCADUtilityEx::IsConnectToOther(const AcGePoint3d& pt, double dExt,
|
|
AcDbObjectId idEntT, const struct resbuf* pRb)
|
|
{
|
|
AcGePoint3d pt1, pt2;
|
|
AcDbObjectId idEnt;
|
|
ads_name ent;
|
|
acdbGetAdsName(ent,idEntT);
|
|
|
|
OPENOBJ_BEGIN(idEntT, AcDb::kForRead, AcDbCurve, pCurve);
|
|
if (pCurve == NULL)
|
|
return FALSE;
|
|
pCurve->getStartPoint(pt1);
|
|
pCurve->getEndPoint(pt2);
|
|
OPENOBJ_END();
|
|
|
|
AcGePoint3d ptNode;
|
|
if (pt.distanceTo(pt1) < pt.distanceTo(pt2))
|
|
ptNode = pt1;
|
|
else
|
|
ptNode = pt2;
|
|
|
|
struct resbuf* pRb2 = acutBuildList(RTDXF0, _T("LINE,ARC,LWPOLYLINE"), 0);
|
|
if (pRb == NULL) pRb = pRb2;
|
|
|
|
ads_name ssSet;
|
|
{
|
|
pt1 = pt2 = CKTCadUtility::Wcs2Ucs(ptNode);
|
|
pt1.x -= dExt;
|
|
pt1.y -= dExt;
|
|
pt2.x += dExt;
|
|
pt2.y += dExt;
|
|
|
|
if (RTNORM == acedSSGet(_T("C"),asDblArray(pt1), asDblArray(pt2), pRb,ssSet))
|
|
{
|
|
acutRelRb(pRb2);
|
|
return FALSE;
|
|
}
|
|
acedSSDel(ent,ssSet);
|
|
}
|
|
|
|
acutRelRb(pRb2);
|
|
Adesk::Int32 lLen = 0;
|
|
acedSSLength(ssSet,&lLen);
|
|
long l = 0l;
|
|
for (l = 0l; l < lLen; l++)
|
|
{
|
|
acedSSName(ssSet,l,ent);
|
|
acdbGetObjectId(idEnt,ent);
|
|
|
|
OPENOBJ_BEGIN(idEnt, AcDb::kForRead, AcDbCurve, pCurve1);
|
|
if (pCurve1 == NULL)
|
|
continue;
|
|
pCurve1->getStartPoint(pt1);
|
|
pCurve1->getEndPoint(pt2);
|
|
if (ptNode == pt1 || ptNode == pt2)
|
|
return TRUE;
|
|
OPENOBJ_END();
|
|
}
|
|
acedSSFree(ssSet);
|
|
return FALSE;
|
|
}
|
|
|
|
AcDbObjectId KTCADUtilityEx::Connect2CurveNearPt(const AcGePoint3d& pt, AcDbObjectId ent1, AcDbObjectId ent2)
|
|
{
|
|
AcDbObjectId id;
|
|
OPENOBJ_BEGIN(ent1, AcDb::kForRead, AcDbCurve, pCurve1);
|
|
OPENOBJ_BEGIN(ent2, AcDb::kForRead, AcDbCurve, pCurve2);
|
|
if (pCurve1 == NULL || pCurve2 == NULL)
|
|
return id;
|
|
|
|
AcDbCurve* pNewCurve = Connect2CurveNearPt(pt, pCurve1, pCurve2);
|
|
if (pNewCurve != NULL)
|
|
{
|
|
CKTCadUtility::AddToBlockTableRecord(id,pNewCurve);
|
|
pNewCurve->close();
|
|
if (pCurve1->upgradeOpen() == Acad::eOk)
|
|
pCurve1->erase();
|
|
if (pCurve2->upgradeOpen() == Acad::eOk)
|
|
pCurve2->erase();
|
|
|
|
return id;
|
|
}
|
|
|
|
OPENOBJ_END();
|
|
OPENOBJ_END();
|
|
return id;
|
|
}
|
|
|
|
// 将两圆弧点在圆周上排序, 返回1为整圆,2为重弧, 3为单弧，4为在两弧小角处合并排序，5为在两弧大角处合并排序
|
|
BOOL KTCADUtilityEx::Sort2ArcPoint(const AcGePoint3d& ptOrg, const AcGePoint3d& pt1S, const AcGePoint3d& pt1E, const AcGePoint3d& pt1,
|
|
const AcGePoint3d& pt2S, const AcGePoint3d& pt2E, const AcGePoint3d& pt2, AcGePoint3dArray& arpt,
|
|
BOOL bJointAtMinAngle)
|
|
{
|
|
double dRadius = 1000.0;
|
|
AcGePoint3d ptA1S = ptOrg + (pt1S - ptOrg).normal() * dRadius;
|
|
AcGePoint3d ptA1E = ptOrg + (pt1E - ptOrg).normal() * dRadius;
|
|
AcGePoint3d ptA1 = ptOrg + (pt1 - ptOrg).normal() * dRadius;
|
|
AcGePoint3d ptA2S = ptOrg + (pt2S - ptOrg).normal() * dRadius;
|
|
AcGePoint3d ptA2E = ptOrg + (pt2E - ptOrg).normal() * dRadius;
|
|
AcGePoint3d ptA2 = ptOrg + (pt2 - ptOrg).normal() * dRadius;
|
|
|
|
AcGeCircArc3d geArc1(ptA1S, ptA1, ptA1E);
|
|
AcGeCircArc3d geArc2(ptA2S, ptA2, ptA2E);
|
|
|
|
if (GetBulge(geArc1.startPoint(), geArc1.endPoint(), ptA1) < 0.0)
|
|
geArc1.reverseParam();
|
|
if (GetBulge(geArc2.startPoint(), geArc2.endPoint(), ptA2) < 0.0)
|
|
geArc2.reverseParam();
|
|
|
|
AcGePoint3d pt1Sp = geArc1.startPoint();
|
|
AcGePoint3d pt1Ep = geArc1.endPoint();
|
|
AcGePoint3d pt2Sp = geArc2.startPoint();
|
|
AcGePoint3d pt2Ep = geArc2.endPoint();
|
|
|
|
int iType = 0;
|
|
AcGeCircArc3d geArc;
|
|
if (geArc1.isOn(pt2Sp))
|
|
{
|
|
if (geArc1.isOn(pt2Ep))
|
|
{
|
|
if (geArc1.paramOf(pt2Sp) > geArc1.paramOf(pt2Ep))
|
|
{
|
|
iType = 1;
|
|
geArc.set(geArc1.center(), geArc1.normal(), geArc1.radius());
|
|
}
|
|
else
|
|
{
|
|
iType = 2;
|
|
geArc = geArc1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iType = 3;
|
|
geArc.set(pt1Sp, pt1Ep, pt2Ep);
|
|
}
|
|
}
|
|
else if (geArc1.isOn(pt2Ep))
|
|
{
|
|
if (geArc1.isOn(pt2Sp))
|
|
{
|
|
if (geArc1.paramOf(pt2Sp) > geArc1.paramOf(pt2Ep))
|
|
{
|
|
iType = 1;
|
|
geArc.set(geArc1.center(), geArc1.normal(), geArc1.radius());
|
|
}
|
|
else
|
|
{
|
|
iType = 2;
|
|
geArc = geArc1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iType = 3;
|
|
geArc.set(pt2Sp, pt1Sp, pt1Ep);
|
|
}
|
|
}
|
|
else if (geArc2.isOn(pt1Sp))
|
|
{
|
|
if (geArc2.isOn(pt1Ep))
|
|
{
|
|
if (geArc2.paramOf(pt1Sp) > geArc2.paramOf(pt1Ep))
|
|
{
|
|
iType = 1;
|
|
geArc.set(geArc2.center(), geArc2.normal(), geArc2.radius());
|
|
}
|
|
else
|
|
{
|
|
iType = 2;
|
|
geArc = geArc2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iType = 3;
|
|
geArc.set(pt2Sp, pt2Ep, pt1Ep);
|
|
}
|
|
}
|
|
else if (geArc2.isOn(pt1Ep))
|
|
{
|
|
if (geArc2.isOn(pt1Sp))
|
|
{
|
|
if (geArc2.paramOf(pt1Sp) > geArc2.paramOf(pt1Ep))
|
|
{
|
|
iType = 1;
|
|
geArc.set(geArc2.center(), geArc2.normal(), geArc2.radius());
|
|
}
|
|
else
|
|
{
|
|
iType = 2;
|
|
geArc = geArc2;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iType = 3;
|
|
geArc.set(pt1Sp, pt2Sp, pt2Ep);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
iType = (bJointAtMinAngle ? 4 : 5);
|
|
double dAngle1 = (pt2Sp - ptOrg).angleTo(pt1Ep - ptOrg, geArc1.normal());
|
|
double dAngle2 = (pt1Sp - ptOrg).angleTo(pt2Ep - ptOrg, geArc1.normal());
|
|
if (dAngle1 < 0.0)
|
|
dAngle1 += PI * 2.0;
|
|
if (dAngle2 < 0.0)
|
|
dAngle2 += PI * 2.0;
|
|
if (bJointAtMinAngle && dAngle1 < dAngle2 || !bJointAtMinAngle && dAngle1 > dAngle2)
|
|
{
|
|
geArc.set(pt1Sp, pt1Ep, pt2Ep);
|
|
}
|
|
else
|
|
{
|
|
geArc.set(pt2Sp, pt2Ep, pt1Ep);
|
|
}
|
|
}
|
|
|
|
// 排序数据
|
|
typedef CSortPair<double, AcGePoint3d, DoubleCompare> CPointSortPair;
|
|
AcArray<CPointSortPair> arPointSort;
|
|
|
|
CPointSortPair data;
|
|
data.compare = geArc.paramOf(ptA1S);
|
|
data.value = pt1S;
|
|
arPointSort.append(data);
|
|
data.compare = geArc.paramOf(ptA1E);
|
|
data.value = pt1E;
|
|
arPointSort.append(data);
|
|
data.compare = geArc.paramOf(ptA2S);
|
|
data.value = pt2S;
|
|
arPointSort.append(data);
|
|
data.compare = geArc.paramOf(ptA2E);
|
|
data.value = pt2E;
|
|
arPointSort.append(data);
|
|
|
|
int iLen = arPointSort.length();
|
|
QuickSort(arPointSort.asArrayPtr(), iLen);
|
|
|
|
arpt.setLogicalLength(0);
|
|
int i = 0;
|
|
for (i = 0; i < iLen; i++)
|
|
{
|
|
arpt.append(arPointSort[i].value);
|
|
}
|
|
|
|
return iType;
|
|
}
|
|
|
|
AcDbCurve* KTCADUtilityEx::Connect2CurveNearPt(const AcGePoint3d& pt, AcDbCurve* pCurve1, AcDbCurve* pCurve2)
|
|
{
|
|
ASSERT(pCurve1 != NULL && pCurve2 != NULL);
|
|
|
|
AcDbCurve* pNewCurve = NULL;
|
|
|
|
AcGePoint3d pt1Start, pt1End, pt2Start, pt2End;
|
|
pCurve1->getStartPoint(pt1Start);
|
|
pCurve1->getEndPoint(pt1End);
|
|
pCurve2->getStartPoint(pt2Start);
|
|
pCurve2->getEndPoint(pt2End);
|
|
|
|
if (pCurve1->isKindOf(AcDbLine::desc()) && pCurve2->isKindOf(AcDbLine::desc()))
|
|
{
|
|
// 求重合且方向相反的直线，并将其连成一条直线
|
|
AcGeVector3d vec1 = pt1Start - pt1End;
|
|
if (vec1.isParallelTo(pt2Start - pt2End))
|
|
{
|
|
AcGeVector3d vec2 = pt1Start - pt2Start;
|
|
if (vec2.isZeroLength() || vec2.isParallelTo(vec1))
|
|
{
|
|
AcGePoint3dArray arpt;
|
|
arpt.append(pt1Start);
|
|
arpt.append(pt1End);
|
|
arpt.append(pt2Start);
|
|
arpt.append(pt2End);
|
|
SortPointByDirect(arpt, pt1End - pt1Start);
|
|
//
|
|
AcDbLine* pLine = new AcDbLine(arpt[0], arpt[3]);
|
|
ASSERT(pLine != NULL);
|
|
pLine->setPropertiesFrom(pCurve1);
|
|
struct resbuf* rb = pCurve1->xData();
|
|
if (rb != NULL)
|
|
{
|
|
pLine->setXData(rb);
|
|
acutRelRb(rb);
|
|
}
|
|
pNewCurve = pLine;
|
|
}
|
|
}
|
|
}
|
|
else if (pCurve1->isKindOf(AcDbArc::desc()) && pCurve2->isKindOf(AcDbArc::desc()))
|
|
{
|
|
// 求重合且方向相反的圆弧，并将其连成一个圆弧
|
|
AcGePoint3d ptCenter1, ptCenter2;
|
|
ptCenter1 = ((AcDbArc*)pCurve1)->center();
|
|
ptCenter2 = ((AcDbArc*)pCurve2)->center();
|
|
if (ptCenter1 == ptCenter2)
|
|
{
|
|
if (fabs(((AcDbArc*)pCurve1)->radius() - ((AcDbArc*)pCurve2)->radius()) < 0.1)
|
|
{
|
|
AcGePoint3d ptArc1, ptArc2;
|
|
double dParam1, dParam2;
|
|
((AcDbArc*)pCurve1)->getStartParam(dParam1);
|
|
((AcDbArc*)pCurve1)->getEndParam(dParam2);
|
|
((AcDbArc*)pCurve1)->getPointAtParam((dParam1 + dParam2) / 2.0, ptArc1);
|
|
((AcDbArc*)pCurve2)->getStartParam(dParam1);
|
|
((AcDbArc*)pCurve2)->getEndParam(dParam2);
|
|
((AcDbArc*)pCurve2)->getPointAtParam((dParam1 + dParam2) / 2.0, ptArc2);
|
|
|
|
AcGePoint3d ptNear;
|
|
pCurve1->getClosestPointTo(pt, ptNear, Adesk::kTrue);
|
|
|
|
AcGePoint3dArray arpt1, arpt2;
|
|
int iType = Sort2ArcPoint(ptCenter1, pt1Start, pt1End, ptArc1, pt2Start, pt2End, ptArc2, arpt1, TRUE);
|
|
BOOL bFullCircle = (iType == 1);
|
|
|
|
AcGeCircArc3d arc(arpt1[0], ptArc1, arpt1[3]);
|
|
if (iType > 2)
|
|
{
|
|
if (iType == 3)
|
|
{
|
|
AcGePoint3d ptMid = arc.evalPoint((arc.paramOf(arc.startPoint()) + arc.paramOf(arc.endPoint())) / 2.0);
|
|
arpt2.append(ptMid);
|
|
arpt2.append(arpt1[3]);
|
|
arpt2.append(arpt1[0]);
|
|
arpt2.append(ptMid);
|
|
}
|
|
else
|
|
Sort2ArcPoint(ptCenter1, pt1Start, pt1End, ptArc1, pt2Start, pt2End, ptArc2, arpt2, FALSE);
|
|
|
|
if (ptNear.distanceTo(arpt1[0]) + ptNear.distanceTo(arpt1[3])
|
|
< ptNear.distanceTo(arpt2[0]) + ptNear.distanceTo(arpt2[3]))
|
|
{
|
|
bFullCircle = (arpt2[0].distanceTo(arpt2[3]) < 0.1
|
|
&& (arpt2[0].distanceTo(arpt2[1]) > 0.1 || arpt2[0].distanceTo(arpt2[2]) > 0.1));
|
|
if (!bFullCircle)
|
|
arc.set(arpt2[0], ptArc2, arpt2[3]);
|
|
}
|
|
else
|
|
{
|
|
bFullCircle = (arpt1[0].distanceTo(arpt1[3]) < 0.1
|
|
&& (arpt1[0].distanceTo(arpt1[1]) > 0.1 || arpt1[0].distanceTo(arpt1[2]) > 0.1));
|
|
if (!bFullCircle)
|
|
arc.set(arpt1[0], ptArc1, arpt1[3]);
|
|
}
|
|
}
|
|
|
|
if (bFullCircle)
|
|
{
|
|
pNewCurve = new AcDbCircle(arc.center(), arc.normal(), arc.radius());
|
|
}
|
|
else
|
|
{
|
|
AcGeVector3d vec;
|
|
acdbEcs2Wcs(asDblArray(AcGeVector3d::kXAxis), asDblArray(vec), asDblArray(arc.normal()), true);
|
|
dParam1 = vec.angleTo(arc.startPoint() - arc.center(), arc.normal());
|
|
dParam2 = vec.angleTo(arc.endPoint() - arc.center(), arc.normal());
|
|
|
|
pNewCurve = new AcDbArc(arc.center(), arc.normal(), arc.radius(), dParam1, dParam2);
|
|
}
|
|
|
|
ASSERT(pNewCurve != NULL);
|
|
pNewCurve->setPropertiesFrom(pCurve1);
|
|
|
|
struct resbuf* rb = pCurve1->xData();
|
|
if (rb != NULL)
|
|
{
|
|
pNewCurve->setXData(rb);
|
|
acutRelRb(rb);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (pNewCurve != NULL)
|
|
return pNewCurve;
|
|
|
|
// 求相交曲线，并将其延长到交点
|
|
AcGePoint3dArray arpt;
|
|
if (pCurve1->intersectWith(pCurve2, AcDb::kExtendBoth, arpt) != Acad::eOk || arpt.length() <= 0)
|
|
return NULL;
|
|
|
|
typedef CSortPair<double, AcGePoint3d, DoubleCompare> CGePtSortPair;
|
|
AcArray<CGePtSortPair> arptPair;
|
|
CGePtSortPair data;
|
|
|
|
// 求得与给定点最近的交点
|
|
int iLen = arpt.length();
|
|
int i = 0;
|
|
for (i = 0; i < iLen; i++)
|
|
{
|
|
data.compare = pt.distanceTo(arpt[i]);
|
|
data.value = arpt[i];
|
|
arptPair.append(data);
|
|
}
|
|
if (iLen > 1)
|
|
{
|
|
QuickSort(arptPair.asArrayPtr(), iLen);
|
|
}
|
|
AcGePoint3d ptInt = arptPair[0].value;
|
|
|
|
BOOL bUpgrade = FALSE;
|
|
if (pCurve1->isWriteEnabled() || (bUpgrade = (pCurve1->upgradeOpen() == Acad::eOk)))
|
|
{
|
|
AcGePoint3d ptArc;
|
|
pCurve1->getClosestPointTo(ptInt, ptArc);
|
|
if (ptInt.distanceTo(ptArc) < 0.1) // 点在圆弧上
|
|
{
|
|
double dParam = 0.0;
|
|
pCurve1->getParamAtPoint(ptArc, dParam);
|
|
if (ptInt.distanceTo(pt1Start) < ptInt.distanceTo(pt1End))
|
|
{
|
|
if (pCurve1->isKindOf(AcDbLine::desc()))
|
|
((AcDbLine*)pCurve1)->setStartPoint(ptInt);
|
|
else if (pCurve1->isKindOf(AcDbArc::desc()))
|
|
((AcDbArc*)pCurve1)->setStartAngle(dParam);
|
|
}
|
|
else
|
|
{
|
|
if (pCurve1->isKindOf(AcDbLine::desc()))
|
|
((AcDbLine*)pCurve1)->setEndPoint(ptInt);
|
|
else if (pCurve1->isKindOf(AcDbArc::desc()))
|
|
((AcDbArc*)pCurve1)->setEndAngle(dParam);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ptInt.distanceTo(pt1Start) < ptInt.distanceTo(pt1End))
|
|
{
|
|
if (pCurve1->isKindOf(AcDbLine::desc()))
|
|
((AcDbLine*)pCurve1)->setStartPoint(ptInt);
|
|
else if (pCurve1->isKindOf(AcDbArc::desc()))
|
|
pCurve1->extend(Adesk::kTrue, ptInt);
|
|
}
|
|
else
|
|
{
|
|
if (pCurve1->isKindOf(AcDbLine::desc()))
|
|
((AcDbLine*)pCurve1)->setEndPoint(ptInt);
|
|
else if (pCurve1->isKindOf(AcDbArc::desc()))
|
|
pCurve1->extend(Adesk::kFalse, ptInt);
|
|
}
|
|
}
|
|
if (bUpgrade)
|
|
pCurve1->downgradeOpen();
|
|
}
|
|
|
|
bUpgrade = FALSE;
|
|
if (pCurve2->isWriteEnabled() || (bUpgrade = (pCurve2->upgradeOpen() == Acad::eOk)))
|
|
{
|
|
AcGePoint3d ptArc;
|
|
pCurve2->getClosestPointTo(ptInt, ptArc);
|
|
if (ptInt.distanceTo(ptArc) < 0.1) // 点在圆弧上
|
|
{
|
|
double dParam = 0.0;
|
|
pCurve2->getParamAtPoint(ptArc, dParam);
|
|
if (ptInt.distanceTo(pt2Start) < ptInt.distanceTo(pt2End))
|
|
{
|
|
if (pCurve2->isKindOf(AcDbLine::desc()))
|
|
((AcDbLine*)pCurve2)->setStartPoint(ptInt);
|
|
else if (pCurve2->isKindOf(AcDbArc::desc()))
|
|
((AcDbArc*)pCurve2)->setStartAngle(dParam);
|
|
}
|
|
else
|
|
{
|
|
if (pCurve2->isKindOf(AcDbLine::desc()))
|
|
((AcDbLine*)pCurve2)->setEndPoint(ptInt);
|
|
else if (pCurve2->isKindOf(AcDbArc::desc()))
|
|
((AcDbArc*)pCurve2)->setEndAngle(dParam);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (ptInt.distanceTo(pt2Start) < ptInt.distanceTo(pt2End))
|
|
{
|
|
if (pCurve2->isKindOf(AcDbLine::desc()))
|
|
((AcDbLine*)pCurve2)->setStartPoint(ptInt);
|
|
else if (pCurve2->isKindOf(AcDbArc::desc()))
|
|
pCurve2->extend(Adesk::kTrue, ptInt);
|
|
}
|
|
else
|
|
{
|
|
if (pCurve2->isKindOf(AcDbLine::desc()))
|
|
((AcDbLine*)pCurve2)->setEndPoint(ptInt);
|
|
else if (pCurve2->isKindOf(AcDbArc::desc()))
|
|
pCurve2->extend(Adesk::kFalse, ptInt);
|
|
}
|
|
}
|
|
if (bUpgrade)
|
|
pCurve2->downgradeOpen();
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
BOOL KTCADUtilityEx::IsCurveAreParallel(AcDbObjectId& ent1, AcDbObjectId& ent2)
|
|
{
|
|
OPENOBJ_BEGIN(ent1, AcDb::kForRead, AcDbCurve, pCurve1);
|
|
OPENOBJ_BEGIN(ent2, AcDb::kForRead, AcDbCurve, pCurve2);
|
|
if (pCurve1 == NULL || pCurve2 == NULL)
|
|
return FALSE;
|
|
|
|
double dRadius1;
|
|
AcGePoint3d pt1;
|
|
AcGeVector3d vec1;
|
|
BOOL bLine1 = pCurve1->isKindOf(AcDbLine::desc());
|
|
if (bLine1)
|
|
{
|
|
pt1 = ((AcDbLine*)pCurve1)->startPoint();
|
|
vec1 = ((AcDbLine*)pCurve1)->endPoint() - pt1;
|
|
}
|
|
else if (pCurve1->isKindOf(AcDbArc::desc()))
|
|
{
|
|
dRadius1 = ((AcDbArc*)pCurve1)->radius();
|
|
pt1 = ((AcDbArc*)pCurve1)->center();
|
|
}
|
|
else if (pCurve1->isKindOf(AcDbCircle::desc()))
|
|
{
|
|
dRadius1 = ((AcDbCircle*)pCurve1)->radius();
|
|
pt1 = ((AcDbCircle*)pCurve1)->center();
|
|
}
|
|
else
|
|
return FALSE;
|
|
|
|
double dRadius2;
|
|
AcGePoint3d pt2;
|
|
AcGeVector3d vec2;
|
|
BOOL bLine2 = pCurve2->isKindOf(AcDbLine::desc());
|
|
if (bLine2)
|
|
{
|
|
pt2 = ((AcDbLine*)pCurve2)->startPoint();
|
|
vec2 = ((AcDbLine*)pCurve2)->endPoint() - pt2;
|
|
}
|
|
else if (pCurve2->isKindOf(AcDbArc::desc()))
|
|
{
|
|
dRadius2 = ((AcDbArc*)pCurve2)->radius();
|
|
pt2 = ((AcDbArc*)pCurve2)->center();
|
|
}
|
|
else if (pCurve2->isKindOf(AcDbCircle::desc()))
|
|
{
|
|
dRadius2 = ((AcDbCircle*)pCurve2)->radius();
|
|
pt2 = ((AcDbCircle*)pCurve2)->center();
|
|
}
|
|
else
|
|
return FALSE;
|
|
|
|
if (bLine1 && bLine2)
|
|
return (vec1.isParallelTo(vec2) && pt1 != pt2 && !vec1.isParallelTo(pt1-pt2));
|
|
else
|
|
return (pt1 == pt2 && fabs(dRadius1 - dRadius2) > 0.1);
|
|
|
|
OPENOBJ_END();
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
BOOL KTCADUtilityEx::EraseColumn(ads_name ent)
|
|
{
|
|
return TRUE;
|
|
} |