4389 lines
105 KiB
C++
4389 lines
105 KiB
C++
//-------------------------------------------------------------------------------------------------------+
|
||
// Copyright (C), 1998-2007, Beijing Tangent Software Co. Ltd.
|
||
// = FileName : 导出全局函数头文件
|
||
// = Version : ver2.0
|
||
// = Author : lfy
|
||
// = CreateDate : 2002-09-09
|
||
// = Description: 全局函数的声明
|
||
// = Maintainers:
|
||
//
|
||
//-------------------------------------------------------------------------------------------------------+
|
||
|
||
#include "StdAfx.h"
|
||
#include "TchGlobalFunc.h"
|
||
#include "TGGePoly.h"
|
||
#include "TGGeCircle.h"
|
||
#include "TGGeRectAngle.h"
|
||
#include "TGGiScreenDrawStream.h"
|
||
#include "TPushAcadVar.h"
|
||
#include "TPushMemVar.h"
|
||
#include "TSearchRegionFromCurve.h"
|
||
#include "TSearchRegionFromCurve.h"
|
||
#include "TGGeRegion.h"
|
||
#include "TAcDbObjectPtr.h"
|
||
#include "TDPtrStack.h"
|
||
#include "TAcDbBlockTableRecPtr.h"
|
||
//#include "TGGeDirectionCurve.h"
|
||
#include "TGGeCurveSegUniqueEx.h"
|
||
#include "TGGeCurveSegunique.h"
|
||
#include "TTempGeTol.h"
|
||
#include "TConfigBase.h"
|
||
#include "TGGeHoleModel.h"
|
||
#include "TEntityBase.h"
|
||
|
||
#include "TchGlobalFunc.h"
|
||
#include "TchGlobalCurveFunc.h"
|
||
#include "TchPrivateGlobalFunc.h"
|
||
|
||
#if ADS > 15
|
||
#include "AcStatusBar.h"
|
||
#include "TDbGrip.h"
|
||
#include "TDbGripDistDim.h"
|
||
#include "TDbGripAngleDim.h"
|
||
#include "TDbGripRadiusDim.h"
|
||
#endif
|
||
|
||
#include "TGGeCurveInline.h"
|
||
|
||
static int CompareDouble(const double *p1, const double *p2)
|
||
{
|
||
if (*p1 > *p2)
|
||
return 1;
|
||
return -1;
|
||
}
|
||
|
||
static int CompareDouble(double x1, double x2)
|
||
{
|
||
if (fabs(x1 - x2) < _DIST_SNAP)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
if (x1 < x2)
|
||
{
|
||
return -1;
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
static void GetPolyRect(const TADSGePoint3d &ptCorn1, double nAngle, const TADSGePoint3d &ptCorn2, TGGePoly2D &poly)
|
||
{
|
||
poly.Reset();
|
||
poly.SetFlag(1);
|
||
|
||
TADSGePoint3d pt1, pt2;
|
||
|
||
TGGeLine lnSide1(ptCorn1, nAngle);
|
||
TGGeLine lnSide2(ptCorn2, nAngle + PI / 2.0);
|
||
lnSide1.Intersection(&lnSide2, pt1);
|
||
|
||
TGGeLine lnSide3(ptCorn1, nAngle + PI / 2.0);
|
||
TGGeLine lnSide4(ptCorn2, nAngle);
|
||
lnSide3.Intersection(&lnSide4, pt2);
|
||
|
||
poly.AppendNode(ptCorn1);
|
||
poly.AppendNode(pt1);
|
||
poly.AppendNode(ptCorn2);
|
||
poly.AppendNode(pt2);
|
||
}
|
||
|
||
static TGGePoly2D g_polyRect;
|
||
static double g_nRot;
|
||
static TADSGePoint3d g_ptCorn1;
|
||
|
||
#if ADS > 22
|
||
static bool MouseMoveMonitor(MSG* msg)
|
||
#else
|
||
static BOOL MouseMoveMonitor(MSG* msg)
|
||
#endif
|
||
{
|
||
if (!acdbCurDwg())
|
||
{
|
||
return FALSE;
|
||
}
|
||
BOOL bRet = FALSE;
|
||
switch (msg->message)
|
||
{
|
||
case WM_MOUSEMOVE:
|
||
{
|
||
CPoint ptClient = msg->pt;
|
||
acedGetAcadDwgView()->ScreenToClient(&ptClient);
|
||
int nVpNum = acedGetWinNum(ptClient.x, ptClient.y);
|
||
int nCurVp = 0;
|
||
VERIFY(TGGetVar(_T("CVPORT"), &nCurVp) == RTNORM);
|
||
if (nVpNum == nCurVp)
|
||
{
|
||
TADSGePoint3d ptDwgWcs, ptDwgDcs;
|
||
BOOL nRetCode = TRUE;
|
||
if (acedCoordFromPixelToWorld(nVpNum, ptClient, ptDwgWcs))
|
||
{
|
||
TGGiScreenDrawStream dc(-1);
|
||
if (g_polyRect.Length())
|
||
{
|
||
dc << g_polyRect;
|
||
}
|
||
|
||
TADSGePoint3d ptDwgUcs = Wcs2Ucs(ptDwgWcs);
|
||
ptDwgUcs.z = g_ptCorn1.z;
|
||
GetPolyRect(g_ptCorn1, g_nRot, ptDwgUcs, g_polyRect);
|
||
dc << g_polyRect;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
default: break;
|
||
}
|
||
return bRet;
|
||
}
|
||
|
||
static int GetRectAngle(const TADSGePoint3d &ptCorn1, double nAngle, TADSGePoint3d &ptCorn2)
|
||
{
|
||
int nRet = RTNORM;
|
||
g_polyRect.Reset();
|
||
g_polyRect.SetFlag(1);
|
||
g_nRot = nAngle;
|
||
g_ptCorn1 = ptCorn1;
|
||
acedRegisterFilterWinMsg(MouseMoveMonitor);
|
||
nRet = ads_getpoint(NULL, _T(""), ptCorn2);
|
||
acedRemoveFilterWinMsg(MouseMoveMonitor);
|
||
g_polyRect.Reset();
|
||
ads_redraw(NULL, 0);
|
||
return nRet;
|
||
}
|
||
|
||
int TchExport2::GetRectAngleStatic(const TADSGePoint3d &ptCorn1, double nAngle, TADSGePoint3d &ptCorn2)
|
||
{
|
||
return GetRectAngle(ptCorn1, nAngle, ptCorn2);
|
||
}
|
||
|
||
int TchExport2::GetCornerPoint(const TADSGePoint3d &ptCorn1, const TCHAR *pszMsg, TADSGePoint3d &ptCorn2)
|
||
{
|
||
if (pszMsg)
|
||
{
|
||
TchGeLib::adsout << pszMsg;
|
||
}
|
||
return GetRectAngle(ptCorn1, 0.0, ptCorn2);
|
||
}
|
||
|
||
TGGeShape* TchExport2::GetShape(const Point& pickPt)
|
||
{
|
||
TPushAcadVar<int> vOsMode(_T("OSMODE"), 0);
|
||
|
||
TEntitySet eL, entPline;
|
||
eL.GetLast();
|
||
if (SHads_command(RTSTR, _T("-BOUNDARY"), RTPOINT, &pickPt, RTSTR, _T(""), RTNONE) == RTNORM)
|
||
{
|
||
TEntitySet entNew;
|
||
entNew.GetLast();
|
||
if (entNew == eL)
|
||
{
|
||
NULL;
|
||
}
|
||
else
|
||
{
|
||
entPline = entNew;
|
||
}
|
||
}
|
||
if (!entPline)
|
||
{
|
||
return NULL;
|
||
}
|
||
else
|
||
{
|
||
TGGeShape* presult;
|
||
TGGePoly* pPoly = new TGGePoly(entPline);
|
||
ads_point ptcen;
|
||
double dw, dh;
|
||
if (pPoly->Length() == 2)
|
||
{
|
||
presult = new TGGeCircle(*(*pPoly)[0], *(*pPoly)[1]);
|
||
}
|
||
else if (pPoly->IsRectAngle(ptcen, &dw, &dh))
|
||
{
|
||
presult = new TGGeRectAngle(ptcen, dw, dh);
|
||
}
|
||
else
|
||
{
|
||
presult = NULL;
|
||
}
|
||
entPline.Delete();
|
||
|
||
TPickEntSet ss(SS_FREE);
|
||
TRBList fence = pPoly->Fence();
|
||
if (ss.Get(_T("F"), fence) == RTNORM)
|
||
{
|
||
ads_redraw(NULL, 0);
|
||
}
|
||
if (presult)
|
||
{
|
||
delete pPoly;
|
||
return presult;
|
||
}
|
||
return pPoly;
|
||
}
|
||
return NULL;
|
||
}
|
||
|
||
Acad::ErrorStatus TchExport2::ExplodeBlockRef(AcDbBlockTableRecord &blockRec, ads_matrix matForInsert, TDPtrList<AcDbEntity> &entSet)
|
||
{
|
||
AcGeMatrix3d mat;
|
||
memcpy(&mat, matForInsert, sizeof(ads_matrix));
|
||
|
||
AcDbBlockTableRecordIterator* pBlockIterator;
|
||
Acad::ErrorStatus es = blockRec.newIterator(pBlockIterator, Adesk::kTrue, Adesk::kFalse);
|
||
ASSERT(es == Acad::eOk);
|
||
|
||
for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step())
|
||
{
|
||
AcDbEntity *pEntity;
|
||
es = pBlockIterator->getEntity(pEntity, AcDb::kForRead, Adesk::kTrue);
|
||
ASSERT(es == Acad::eOk);
|
||
|
||
if (pEntity->visibility() == AcDb::kInvisible)
|
||
{
|
||
pEntity->close();
|
||
continue;
|
||
}
|
||
|
||
if (pEntity->isKindOf(AcDbLine::desc()))
|
||
{
|
||
//显示LINE
|
||
AcDbLine *pLine = AcDbLine::cast(pEntity);
|
||
AcGePoint3d ptStart = pLine->startPoint(), ptEnd = pLine->endPoint();
|
||
ptStart.transformBy(mat);
|
||
ptEnd.transformBy(mat);
|
||
entSet.Append(new AcDbLine(ptStart, ptEnd));
|
||
}
|
||
else if (pEntity->isKindOf(AcDbArc::desc()))
|
||
{
|
||
AcDbArc *pArc = AcDbArc::cast(pEntity);
|
||
TADSGePoint3d ptCen;
|
||
(AcGePoint3d &)ptCen = pArc->center();
|
||
TGGeArc ar(ptCen, pArc->radius(), pArc->startAngle(), pArc->endAngle());
|
||
TADSGePoint3d ptStart, ptEnd, ptMid;
|
||
ar.GetStartPoint(ptStart);
|
||
ar.GetEndPoint(ptEnd);
|
||
ar.MidPoint(ptMid);
|
||
((AcGePoint3d &)ptStart).transformBy(mat);
|
||
((AcGePoint3d &)ptEnd).transformBy(mat);
|
||
((AcGePoint3d &)ptMid).transformBy(mat);
|
||
TGGeArc arNew(ptStart, ptMid, ptEnd);
|
||
entSet.Append(new AcDbArc(arNew.GetCenterPt(), arNew.GetRadius(), arNew.GetStarAngle(), arNew.GetEndAngle()));
|
||
}
|
||
else
|
||
{
|
||
AcDbEntity *pEntCopy = NULL;
|
||
if (pEntity->getTransformedCopy(mat, pEntCopy) == Acad::eOk && pEntCopy)
|
||
{
|
||
entSet.Append(pEntCopy);
|
||
}
|
||
}
|
||
|
||
pEntity->close();
|
||
}
|
||
delete pBlockIterator;
|
||
return Acad::eOk;
|
||
}
|
||
|
||
// 由二维曲线, 求若干个最外边界轮廓线
|
||
int TchExport2::GetExternalBoundaryFromCurves(const TDPtrList<TGGeCurveSegment> &lstSegs, TDPtrList<TGGePoly2D> &lstPolys)
|
||
{
|
||
if (!lstSegs.Length())
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
TDPtrList<TGGeCurveSegment> ss;
|
||
for (int i = 0; i < lstSegs.Length(); i++)
|
||
{
|
||
TGGeCurveSegment seg = lstSegs[i];
|
||
seg.SetElevation(0.0);
|
||
ss.Append(new TGGeCurveSegment(seg));
|
||
}
|
||
|
||
if (ss.Length())
|
||
{
|
||
RemoveDupCurves(ss);
|
||
IntersectCurves(ss, _DIST_SNAP);
|
||
|
||
lstPolys.Reset();
|
||
SearchOutRegions(ss, lstPolys);
|
||
|
||
if (!!lstPolys)
|
||
{
|
||
return RTNORM;
|
||
}
|
||
}
|
||
return RTERROR;
|
||
}
|
||
|
||
//extern int CompareDouble(const double *p1, const double *p2);
|
||
void TchExport2::IntersectCurves(TDPtrList<TGGeCurveSegment> &lstCurves, double dPrec)
|
||
{
|
||
TDPtrList<TGGeCurveSegment> ss1;
|
||
int nCount = lstCurves.Length();
|
||
for (int nn = 0; nn < nCount; nn++)
|
||
{
|
||
TGGeCurveSegment *pSeg = lstCurves[nn];
|
||
if (!pSeg->Is(CURVE_CIRCLE) && pSeg->GetLength() > _DIST_SNAP)
|
||
{
|
||
TGGeCurveSegment *pNewSeg = new TGGeCurveSegment(*pSeg);
|
||
pNewSeg->SetLineFlag(LS_FINITE);
|
||
ss1.Append(pNewSeg);
|
||
}
|
||
}
|
||
|
||
int len1 = ss1.Length();
|
||
if (g_bEchoSearch)
|
||
{
|
||
acedSetStatusBarProgressMeter(_T("求交线"), 0, len1);
|
||
}
|
||
|
||
int nStep = len1 / 100;
|
||
if (nStep < 1)
|
||
{
|
||
nStep = 1;
|
||
}
|
||
TDPtrList<double> *lstDistArray = new TDPtrList<double>[len1];
|
||
for (nn = 0; nn < len1 - 1; nn++)
|
||
{
|
||
if (g_bEchoSearch && nStep>1 && !(nn%nStep))
|
||
{
|
||
acedSetStatusBarProgressMeterPos(nn);
|
||
}
|
||
TGGeCurveSegment &line1 = *ss1[nn];
|
||
|
||
for (int kk = nn + 1; kk < len1; kk++)
|
||
{
|
||
TGGeCurveSegment &line2 = *ss1[kk];
|
||
TADSGePoint3d ptInt[2];
|
||
int nInt = line1.Intersection(line2, ptInt[0], ptInt[1]);
|
||
for (int mm = 0; mm < nInt; mm++)
|
||
{
|
||
double nDist1 = line1.PathDistance(ptInt[mm]);
|
||
double nDist2 = line2.PathDistance(ptInt[mm]);
|
||
if (nDist1 < -_DIST_SNAP || nDist2 < -_DIST_SNAP)
|
||
{
|
||
#ifndef NDEBUG
|
||
TchGeLib::adsout << _T("\nError found");
|
||
#endif
|
||
}
|
||
else
|
||
{
|
||
if (nDist1 > _DIST_SNAP)
|
||
{
|
||
lstDistArray[nn].Append(new double(nDist1));
|
||
}
|
||
if (nDist2 > _DIST_SNAP)
|
||
{
|
||
lstDistArray[kk].Append(new double(nDist2));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
lstCurves.Reset();
|
||
for (nn = 0; nn < len1; nn++)
|
||
{
|
||
TDPtrList<double> &lstDistSeg = lstDistArray[nn];
|
||
TGGeCurveSegment &line1 = *ss1[nn];
|
||
double nDist0 = line1.GetLength();
|
||
lstDistSeg.QuickSort(CompareDouble);
|
||
lstDistSeg.Append(new double(nDist0));
|
||
TADSGePoint3d &ptStart = line1.StartPoint();
|
||
TADSGePoint3d ptS = ptStart;
|
||
for (int kk = 0; kk < lstDistSeg.Length(); kk++)
|
||
{
|
||
TADSGePointDir2d ptE;
|
||
line1.Polar(*lstDistSeg[kk], ptE);
|
||
if (ptS.Distance2d(ptE) > _DIST_SNAP)
|
||
{
|
||
TGGeCurveSegment *pSeg = new TGGeCurveSegment(line1);
|
||
pSeg->SetPoints(ptS, ptE);
|
||
lstCurves.Append(pSeg);
|
||
}
|
||
ptS = ptE;
|
||
}
|
||
}
|
||
|
||
delete[] lstDistArray;
|
||
if (g_bEchoSearch)
|
||
{
|
||
acedRestoreStatusBar();
|
||
}
|
||
}
|
||
|
||
void TchExport2::RemoveDupCurves(TDPtrList<TGGeCurveSegment> &lstCurves)
|
||
{
|
||
TDPtrList<TGGeCurveSegment> lstLines, lstCirArcs;
|
||
ASSERT(lstCurves.GetDelFlag() != FALSE);
|
||
lstCurves.SetDelFlag(FALSE);
|
||
int nCount = lstCurves.Length();
|
||
for (int i = 0; i < nCount; i++)
|
||
{
|
||
TGGeCurveSegment *pSeg = lstCurves[i];
|
||
if (pSeg->Is(CURVE_LINE))
|
||
{
|
||
lstLines.Append(pSeg);
|
||
}
|
||
else
|
||
{
|
||
lstCirArcs.Append(pSeg);
|
||
}
|
||
}
|
||
lstCurves.Reset();
|
||
lstCurves.SetDelFlag(TRUE);
|
||
|
||
{
|
||
TPushMemVar<BOOL> vTemp(g_bEchoSearch, FALSE);
|
||
_RemoveDupCurves(lstCirArcs);
|
||
|
||
lstCirArcs.SetDelFlag(FALSE);
|
||
nCount = lstCirArcs.Length();
|
||
for (i = 0; i < nCount; i++)
|
||
{
|
||
lstCurves.Append(lstCirArcs[i]);
|
||
}
|
||
}
|
||
|
||
TdRemoveDupCurves(lstLines, FALSE, FALSE);
|
||
lstLines.SetDelFlag(FALSE);
|
||
nCount = lstLines.Length();
|
||
for (i = 0; i < nCount; i++)
|
||
{
|
||
lstCurves.Append(lstLines[i]);
|
||
}
|
||
}
|
||
|
||
// 由二维曲线, 求最外边界轮廓线
|
||
int TchExport2::GetExternalBoundaryFromCurves(const TDPtrList<TGGeCurveSegment> &ss, TGGePoly2D &polyOutline)
|
||
{
|
||
TDPtrList<TGGeCurveSegment> lstSegs;
|
||
for (int i = 0; i < ss.Length(); i++)
|
||
{
|
||
TGGeCurveSegment seg = ss[i];
|
||
seg.SetElevation(0.0);
|
||
lstSegs.Append(new TGGeCurveSegment(seg));
|
||
}
|
||
|
||
RemoveDupCurves(lstSegs);
|
||
IntersectCurves(lstSegs, _DIST_SNAP);
|
||
|
||
TSearchRegionFromCurve aSearch;
|
||
try
|
||
{
|
||
aSearch.InitStart(lstSegs);
|
||
}
|
||
catch (...)
|
||
{
|
||
TchGeLib::adsout << /*UMSG*/_T("\n发生例外情况!");
|
||
return RTERROR;
|
||
}
|
||
|
||
TGGeRegion *pExt = aSearch.SearchRegions();
|
||
if (pExt)
|
||
{
|
||
pExt->CenterPoly2D(polyOutline);
|
||
polyOutline.Compress();
|
||
return RTNORM;
|
||
}
|
||
return RTERROR;
|
||
}
|
||
|
||
// 用区域裁剪实体
|
||
void TchExport2::ClipEntitiesByPoly(TGGePoly2D & polyOutline, TPickEntSet &ssBack)
|
||
{
|
||
TPickEntSet ssBackInsert(SS_FREE), ssIn(SS_FREE), ssOut(SS_FREE), ssEdge(SS_FREE);
|
||
ssBackInsert += ssBack;
|
||
ssBackInsert.BaseFilter(TRBList(RTDXF0, _T("POLYLINE,LWPOLYLINE,INSERT,AEC_BLOCK_INSERT"), NULL));
|
||
ssBack -= ssBackInsert;
|
||
|
||
// 裁剪曲线
|
||
PolyClip(ssBack, polyOutline, ssIn, ssOut, ssEdge);
|
||
if (ssIn.Length())
|
||
{
|
||
ssIn.Erase();
|
||
}
|
||
if (ssEdge.Length())
|
||
{
|
||
ssEdge.Erase();
|
||
}
|
||
|
||
// 裁剪图块
|
||
long lCount = ssBackInsert.Length();
|
||
for (long idx = 0L; idx < lCount; idx++)
|
||
{
|
||
TEntitySet entBack = ssBackInsert[idx];
|
||
|
||
TPickEntSet ss(SS_FREE);
|
||
BOOL bBlock = FALSE;
|
||
if (entBack.Is(_T("AEC_BLOCK_INSERT")) || entBack.Is(_T("INSERT")))
|
||
{
|
||
TchExport::GetCurveFromInsert2D(entBack, ss);
|
||
bBlock = TRUE;
|
||
}
|
||
else//多段线
|
||
{
|
||
ss.IncludeBegin();
|
||
|
||
OPENOBJ_BEGIN(entBack, AcDb::kForRead, AcDbEntity, pEntity)
|
||
if (pEntity != NULL)
|
||
{
|
||
AcDbVoidPtrArray entSet;
|
||
pEntity->explode(entSet);
|
||
for (long i = 0; i < entSet.length(); i++)
|
||
{
|
||
AcDbEntity*pNewEnt = (AcDbEntity*)entSet[i];
|
||
if (TchExport::AddToCurrentSpace(pNewEnt, Adesk::kTrue) == AcDbObjectId::kNull)
|
||
{
|
||
delete pNewEnt;
|
||
}
|
||
}
|
||
}
|
||
OPENOBJ_END();
|
||
|
||
ss.IncludeEnd();
|
||
}
|
||
|
||
if (ss.Length()>0)
|
||
{
|
||
TPickEntSet ssIn(SS_FREE), ssOut(SS_FREE), ssEdge(SS_FREE);
|
||
PolyClip(ss, polyOutline, ssIn, ssOut, ssEdge);
|
||
if (ssOut.Length() > 0)//裁剪发生
|
||
{
|
||
if (ssIn.Length() > 0)
|
||
{
|
||
ssIn.Erase();
|
||
}
|
||
if (ssEdge.Length() > 0)
|
||
{
|
||
ssEdge.Erase();
|
||
}
|
||
|
||
if (bBlock)
|
||
{
|
||
TADSGePoint3d ptInsert;
|
||
entBack.GetData(10, &ptInsert);
|
||
TCString sNewBlockName(256);
|
||
if (ssOut.MakeAnonymous(ptInsert, sNewBlockName, FALSE) == RTNORM)
|
||
{
|
||
OPENOBJ_BEGIN(entBack, AcDb::kForWrite, AcDbBlockReference, pInsert);
|
||
if (pInsert)
|
||
{
|
||
pInsert->setBlockTableRecord(GetBlockIdFromString(sNewBlockName));
|
||
pInsert->setScaleFactors(AcGeScale3d(1.0, 1.0, 1.0));
|
||
pInsert->setRotation(0.0);
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
entBack.Erase();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ss.Erase();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
int TchExport2::GetClipBoundary(TGGePoly2D &poly2d)
|
||
{
|
||
const TCHAR *szPrompts[2] = { _T("\n矩形的第一个角点或 [多边形裁剪(P)]<退出>:"),
|
||
_T("\n多边形的第一点或 [矩形裁剪(R)]<退出>:") };
|
||
const TCHAR *szKeywords[2] = { _T("P"), _T("R") };
|
||
int nClipType = 0;
|
||
|
||
TADSGePoint3d ptStart;
|
||
while (1)
|
||
{
|
||
TchGeLib::adsout << szPrompts[nClipType];
|
||
int nCode;
|
||
INITGET_BEG(0, szKeywords[nClipType]);
|
||
nCode = ads_getpoint(NULL, _T(""), ptStart);
|
||
INITGET_END();
|
||
if (nCode == RTKWORD)
|
||
{
|
||
nClipType = 1 - nClipType;
|
||
}
|
||
else
|
||
{
|
||
if (nCode == RTNORM)
|
||
{
|
||
break;
|
||
}
|
||
else
|
||
{
|
||
return nCode;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (nClipType == 0)
|
||
{
|
||
TADSGePoint3d ptOther;
|
||
int nCode = GetCornerPoint(ptStart, _T("\n另一个角点<退出>:"), ptOther);
|
||
if (nCode != RTNORM)
|
||
{
|
||
return nCode;
|
||
}
|
||
TGGeRectAngle rect(ptStart, ptOther);
|
||
rect.AsPoly2D(poly2d);
|
||
}
|
||
else
|
||
{
|
||
TADSGePoint3d pt2;
|
||
TGGiScreenDrawStream dc;
|
||
dc.m_nDrawMode = 1;
|
||
TDPtrStack<TADSGePoint3d> aStack;
|
||
aStack.Push(new TADSGePoint3d(ptStart));
|
||
while (1)
|
||
{
|
||
TADSGePoint3d &ptFrom = *aStack.Top();
|
||
if (aStack.Length() >= 3)
|
||
{
|
||
TchGeLib::adsout << _T("\n下一点或 [回退(U)]<封闭>: ");
|
||
}
|
||
else
|
||
{
|
||
TchGeLib::adsout << _T("\n下一点或 [回退(U)]<退出>: ");
|
||
}
|
||
int rc;
|
||
INITGET_BEG(0, _T("U"));
|
||
rc = ads_getpoint(ptFrom, _T(""), pt2);
|
||
INITGET_END();
|
||
if (rc == RTCAN)
|
||
{
|
||
aStack.Reset();
|
||
return rc;
|
||
}
|
||
else if (rc == RTKWORD)
|
||
{
|
||
if (*aStack.Top() != ptStart)
|
||
{// Not on first state
|
||
TADSGePoint3d *pPt2 = aStack.Pop();
|
||
TADSGePoint3d *pPt1 = aStack.Top();
|
||
dc.SetColor(-1);
|
||
dc << TGGeLine(*pPt1, *pPt2);
|
||
delete pPt2;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (rc == RTNONE)
|
||
{
|
||
if (aStack.Length() < 3)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
else
|
||
{
|
||
pt2 = ptStart;
|
||
}
|
||
}
|
||
|
||
TGGeLine ln(*aStack.Top(), pt2);
|
||
if (ln.GetLength() > _DIST_SNAP)
|
||
{
|
||
dc.SetColor(7);
|
||
dc << ln;
|
||
if (!(rc == RTNONE))
|
||
{
|
||
aStack.Push(new TADSGePoint3d(pt2));
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
poly2d.Reset();
|
||
TADSGePoint3d *ptCur = NULL;
|
||
while ((ptCur = aStack.Pop()) != NULL)
|
||
{
|
||
poly2d.AppendNode(*ptCur);
|
||
delete ptCur;
|
||
}
|
||
poly2d.Compress();
|
||
if (!poly2d || poly2d.Length() < 3)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
}
|
||
return RTNORM;
|
||
}
|
||
|
||
// 从块表中取所有的曲线: 包括LINE,ARC,CIRCLE,POLYLINE,LWPOLYLINE,以及在INSERT中的前述实体
|
||
void TchExport2::Get2DCurveFromBlock(AcDbBlockTableRecord &blockRec, ads_matrix matForInsert, TDPtrList<TGGeCurveSegment> &lstResult)
|
||
{
|
||
AcGeMatrix3d mat;
|
||
memcpy(&mat, matForInsert, sizeof(ads_matrix));
|
||
|
||
AcDbBlockTableRecordIterator* pBlockIterator = NULL;
|
||
Acad::ErrorStatus es = blockRec.newIterator(pBlockIterator, Adesk::kTrue, Adesk::kFalse);
|
||
ASSERT(es == Acad::eOk && !!pBlockIterator);
|
||
|
||
for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step())
|
||
{
|
||
AcDbEntity *pEntity;
|
||
es = pBlockIterator->getEntity(pEntity, AcDb::kForRead, Adesk::kTrue);
|
||
ASSERT(es == Acad::eOk);
|
||
if (pEntity->visibility() == AcDb::kInvisible)
|
||
{
|
||
pEntity->close();
|
||
continue;
|
||
}
|
||
|
||
if (pEntity->isKindOf(AcDbLine::desc()))
|
||
{
|
||
//显示LINE
|
||
AcDbLine *pLine = AcDbLine::cast(pEntity);
|
||
TADSGePoint3d ptStart = pLine->startPoint(), ptEnd = pLine->endPoint();
|
||
ptStart.TransformBy(matForInsert);
|
||
ptEnd.TransformBy(matForInsert);
|
||
lstResult.Append(new TGGeCurveSegment(ptStart, ptEnd, 0.0));
|
||
}
|
||
else if (pEntity->isKindOf(AcDbArc::desc()))
|
||
{
|
||
AcDbArc *pArc = AcDbArc::cast(pEntity);
|
||
TADSGePoint3d ptCen;
|
||
(AcGePoint3d &)ptCen = pArc->center();
|
||
TGGeArc ar(ptCen, pArc->radius(), pArc->startAngle(), pArc->endAngle());
|
||
TADSGePoint3d ptStart, ptEnd, ptMid;
|
||
ar.GetStartPoint(ptStart);
|
||
ar.GetEndPoint(ptEnd);
|
||
ar.MidPoint(ptMid);
|
||
((AcGePoint3d &)ptStart).transformBy(mat);
|
||
((AcGePoint3d &)ptEnd).transformBy(mat);
|
||
((AcGePoint3d &)ptMid).transformBy(mat);
|
||
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
||
*pSeg = TGGeArc(ptStart, ptMid, ptEnd);
|
||
lstResult.Append(pSeg);
|
||
}
|
||
else if (pEntity->isKindOf(AcDbCircle::desc()))
|
||
{ //圆的变换为近似, 不变半径
|
||
AcDbCircle *pCir = AcDbCircle::cast(pEntity);
|
||
TADSGePoint3d ptCen = pCir->center();
|
||
ptCen.TransformBy(matForInsert);
|
||
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
||
*pSeg = TGGeCircle(ptCen, pCir->radius());
|
||
lstResult.Append(pSeg);
|
||
}
|
||
else if (pEntity->isKindOf(AcDbPolyline::desc()) || pEntity->isKindOf(AcDb2dPolyline::desc()))
|
||
{
|
||
AcDbPolyline pline;
|
||
TEntitySet ent;
|
||
acdbGetAdsName(ent.name, pEntity->objectId());
|
||
if (!(!ent))
|
||
{
|
||
TGGePoly2D poly(ent);
|
||
if (!poly)
|
||
{
|
||
;
|
||
}
|
||
else
|
||
{
|
||
poly.TransUCS(matForInsert);
|
||
for (int i = 0; i < poly.TotalSegments(); i++)
|
||
{
|
||
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
||
poly.Nth(i, *pSeg);
|
||
lstResult.Append(pSeg);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else if (pEntity->isKindOf(AcDbBlockReference::desc()))
|
||
{ //嵌套图块
|
||
AcDbBlockReference *pInsert = AcDbBlockReference::cast(pEntity);
|
||
ASSERT(pInsert);
|
||
TADSGePoint3d ptLoc = pInsert->position();
|
||
double nRot = pInsert->rotation();
|
||
AcGeScale3d scale = pInsert->scaleFactors();
|
||
AcDbObjectId idBlock = pInsert->blockTableRecord();
|
||
TAcDbObjectPtr objBlock(idBlock, AcDb::kForRead);
|
||
ASSERT(!!objBlock);
|
||
AcDbBlockTableRecord *pRec = AcDbBlockTableRecord::cast(objBlock.m_pObject);
|
||
ASSERT(pRec);
|
||
TADSGePoint3d ptBase = pRec->origin();
|
||
ads_matrix mat1, mat2;
|
||
ConstructMatrix(ptBase, ptLoc, scale[0], scale[1], scale[2], nRot, mat1);
|
||
SetToProductMatrix(matForInsert, mat1, mat2);
|
||
Get2DCurveFromBlock(*pRec, mat2, lstResult);
|
||
}
|
||
|
||
pEntity->close();
|
||
}
|
||
delete pBlockIterator;
|
||
}
|
||
|
||
// 由二维图块提取二维曲线段
|
||
int TchExport2::GetCurveFromInsert2D(TEntitySet &ent, TDPtrList<TGGeCurveSegment> &lstSegs)
|
||
{
|
||
if (!ent.Is(_T("INSERT")) && !ent.Is(_T("AEC_BLOCK_INSERT")) && !ent.Is(_T("ATS_MVINSERT")))
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
ads_matrix mat;
|
||
GetInsertMatrix(ent, mat);
|
||
TCString sBlockName(256);
|
||
int nCode = (ent.Is(_T("ATS_MVINSERT")) ? 1 : 2);
|
||
VERIFY(ent.GetData(nCode, (TCHAR *)sBlockName) == RTNORM);
|
||
TAcDbBlockTableRecPtr rec(sBlockName, AcDb::kForRead);
|
||
ASSERT(!!rec);
|
||
|
||
Get2DCurveFromBlock(*rec.m_pBlockTableRec, mat, lstSegs);
|
||
return RTNORM;
|
||
}
|
||
|
||
// 有若干线搜索区域
|
||
int TchExport2::SearchOutRegions(const TDPtrList<TGGeCurveSegment> &lstSeg1In, TDPtrList<TGGePoly2D> &lstDest)
|
||
{
|
||
TSearchRegionFromCurve aSearch;
|
||
try
|
||
{
|
||
aSearch.InitStart(lstSeg1In);
|
||
}
|
||
catch (...)
|
||
{
|
||
TchGeLib::adsout << /*UMSG*/_T("\n发生例外情况!");
|
||
return RTERROR;
|
||
}
|
||
|
||
|
||
if (aSearch.SearchRegions())
|
||
{
|
||
TDPtrList<int> lstOut;
|
||
if (aSearch.GetOutsideRegions1(lstOut) && !!lstOut)
|
||
{
|
||
for (int n = 0; n < lstOut.Length(); n++)
|
||
{
|
||
TGGePoly2D *pNewPoly = new TGGePoly2D(1);
|
||
VERIFY(aSearch.m_regions[*lstOut[n]]->CenterPoly2D(*pNewPoly) == RTNORM);
|
||
pNewPoly->Compress();
|
||
lstDest.Append(pNewPoly);
|
||
}
|
||
}
|
||
}
|
||
return RTNORM;
|
||
}
|
||
|
||
// 把Poly2D分解为若干段曲线
|
||
void TchExport2::ExplodePoly2D(const TGGePoly2D &poly, TDPtrList<TGGeCurveSegment> &lstSegs)
|
||
{
|
||
for (int i = 0; i < poly.TotalSegments(); i++)
|
||
{
|
||
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
||
poly.Nth(i, *pSeg);
|
||
lstSegs.Append(pSeg);
|
||
}
|
||
}
|
||
|
||
// 把XPoly2D转换成AcDbPolyline
|
||
void TchExport2::PolyConvert(const TGGePoly2D &poly, AcDbPolyline &pline)
|
||
{
|
||
pline.assertWriteEnabled(); //支持UNDO
|
||
|
||
AcGeVector3d vtNormal = pline.normal();
|
||
double nThick = pline.thickness();
|
||
double nWidth = 0;
|
||
|
||
Acad::ErrorStatus es = pline.getConstantWidth(nWidth);
|
||
pline.reset(Adesk::kFalse, 0);
|
||
|
||
for (int i = 0; i < poly.Length(); i++)
|
||
{
|
||
pline.addVertexAt(i, poly[i].AsAcGePoint2d(), tan(poly.GetBulge(i) / 4));
|
||
}
|
||
|
||
pline.setClosed(poly.IsClosed());
|
||
if (poly.Length())
|
||
{
|
||
pline.setElevation(poly[0].z);
|
||
}
|
||
|
||
pline.setNormal(vtNormal);
|
||
pline.setThickness(nThick);
|
||
if (es == Acad::eOk)
|
||
{
|
||
pline.setConstantWidth(nWidth);
|
||
}
|
||
}
|
||
|
||
// 把AcDbPolyline转换成XPoly2D
|
||
void TchExport2::PolyConvert(const AcDbPolyline &pline, TGGePoly2D &poly)
|
||
{
|
||
poly.Reset();
|
||
|
||
for (Adesk::UInt16 i = 0; i < pline.numVerts(); i++)
|
||
{
|
||
AcGePoint2d ptVert;
|
||
double nBulge = 0.0;
|
||
pline.getPointAt(i, ptVert);
|
||
pline.getBulgeAt(i, nBulge);
|
||
|
||
TADSGePoint3d pt;
|
||
pt = ptVert;
|
||
nBulge = atan(nBulge) * 4;
|
||
poly.AppendNode(pt, nBulge);
|
||
}
|
||
|
||
if (pline.isClosed())
|
||
{
|
||
poly.SetFlag(poly.GetFlag() | 0x01);
|
||
}
|
||
else
|
||
{
|
||
poly.SetFlag(0);
|
||
}
|
||
|
||
poly.SetElevation(pline.elevation());
|
||
}
|
||
|
||
// 支持3D
|
||
AcDbRegion* TchExport2::AsRegion(const TGGePoly2D &poly)
|
||
{
|
||
if (!poly.IsClosed())
|
||
{
|
||
return NULL;
|
||
}
|
||
|
||
TGGePoly2D polyCopy(1);
|
||
poly.Disperse1(polyCopy, _AS_SYS_UNIT(g_nCirDeviation));
|
||
|
||
AcDbVoidPtrArray curveSegments;
|
||
for (int j = 0; j<polyCopy.Length(); j++)
|
||
{
|
||
TGGeCurveSegment seg;
|
||
polyCopy.Nth(j, seg);
|
||
if (seg.GetLength()>_DIST_SNAP)
|
||
{
|
||
curveSegments.append(new AcDbLine(seg.GetStartPoint(), seg.GetEndPoint()));
|
||
}
|
||
}
|
||
|
||
AcDbVoidPtrArray regions;
|
||
if (AcDbRegion::createFromCurves(curveSegments, regions) == Acad::eOk && regions.length() > 0)
|
||
{
|
||
AcDbRegion *regioni = (AcDbRegion *)regions[0];
|
||
regions.removeAt(0);
|
||
|
||
TchExport::ReleaseEntSet(regions);
|
||
TchExport::ReleaseEntSet(curveSegments);
|
||
return regioni;
|
||
}
|
||
|
||
TchExport::ReleaseEntSet(curveSegments);
|
||
return NULL;
|
||
}
|
||
|
||
int TchExport2::FindNearestEdge(const TGGePoly2D &poly, const TADSGePoint3d &ptEdge)
|
||
{
|
||
int nEdge = -1;
|
||
double nNearDist = 0.0;
|
||
for (int i = 0; i < poly.TotalSegments(); i++)
|
||
{
|
||
TGGeCurveSegment seg;
|
||
poly.Nth(i, seg);
|
||
TADSGePoint3d ptOnEdge;
|
||
if (seg.ProjectToMe(ptEdge, ptOnEdge) == RTNORM && (ptOnEdge&seg) == PR_INSIDE)
|
||
{
|
||
double nDist = ptEdge.Distance2d(ptOnEdge);
|
||
if (nEdge == -1)
|
||
{
|
||
nEdge = i;
|
||
nNearDist = nDist;
|
||
}
|
||
else if (nDist < nNearDist)
|
||
{
|
||
nEdge = i;
|
||
nNearDist = nDist;
|
||
}
|
||
}
|
||
}
|
||
return nEdge;
|
||
}
|
||
|
||
|
||
AcDbHatch * TchExport2::NewHatchFromPoly2D(const TGGePoly2D &poly)
|
||
{
|
||
ASSERT(poly.IsClosed());
|
||
|
||
AcGeDoubleArray bulges;
|
||
AcGePoint2dArray vertices;
|
||
|
||
int nVert = poly.Length();
|
||
|
||
AcDbHatch *pHatch = new AcDbHatch();
|
||
pHatch->setAssociative(Adesk::kFalse);
|
||
pHatch->setPattern(AcDbHatch::kPreDefined, _T("SOLID"));
|
||
pHatch->setHatchStyle(AcDbHatch::kNormal);
|
||
bulges.setPhysicalLength(0).setLogicalLength(nVert + 1);
|
||
vertices.setPhysicalLength(0).setLogicalLength(nVert + 1);
|
||
|
||
for (int i = 0; i < nVert; i++)
|
||
{
|
||
vertices[i] = poly[i];
|
||
bulges[i] = tan(poly.GetBulge(i) / 4);
|
||
}
|
||
vertices[i] = vertices[0];
|
||
bulges[i] = bulges[0];
|
||
|
||
pHatch->appendLoop(AcDbHatch::kExternal | AcDbHatch::kPolyline | AcDbHatch::kDerived, vertices, bulges);
|
||
pHatch->evaluateHatch(true);
|
||
|
||
return pHatch;
|
||
}
|
||
|
||
AcDbHatch * TchExport2::NewHatchFromPoly2D(const TGGePoly2D &poly, const TCHAR *pszPattern0, double nScl)
|
||
{
|
||
TCString sPattern;
|
||
sPattern = pszPattern0;
|
||
TCHAR *pScale = sPattern.StrChr(_T(':'));
|
||
if (pScale)
|
||
{
|
||
*pScale = EOS;
|
||
pScale++;
|
||
double nScaleAdd = _tstof(pScale);
|
||
if (nScaleAdd > 1.0E-6)
|
||
{
|
||
nScl *= nScaleAdd;
|
||
}
|
||
}
|
||
|
||
AcGeDoubleArray bulges;
|
||
AcGePoint2dArray vertices;
|
||
|
||
int nVert = poly.Length();
|
||
|
||
AcDbHatch *pHatch = new AcDbHatch();
|
||
pHatch->setAssociative(Adesk::kFalse);
|
||
pHatch->setPatternScale(nScl);
|
||
pHatch->setHatchStyle(AcDbHatch::kNormal);
|
||
if (pHatch->setPattern(AcDbHatch::kPreDefined, sPattern) != Acad::eOk)
|
||
{
|
||
delete pHatch;
|
||
return NULL;
|
||
}
|
||
|
||
bulges.setPhysicalLength(0).setLogicalLength(nVert + 1);
|
||
vertices.setPhysicalLength(0).setLogicalLength(nVert + 1);
|
||
|
||
for (int i = 0; i < nVert; i++)
|
||
{
|
||
vertices[i] = poly[i];
|
||
bulges[i] = tan(poly.GetBulge(i) / 4);
|
||
}
|
||
vertices[i] = vertices[0];
|
||
bulges[i] = bulges[0];
|
||
|
||
pHatch->appendLoop(AcDbHatch::kExternal | AcDbHatch::kPolyline | AcDbHatch::kDerived, vertices, bulges);
|
||
Acad::ErrorStatus es;
|
||
if ((es = pHatch->evaluateHatch(true)) != Acad::eOk)
|
||
{
|
||
delete pHatch;
|
||
return NULL;
|
||
}
|
||
|
||
return pHatch;
|
||
}
|
||
|
||
namespace
|
||
{
|
||
void GetLineSeg2dArray(const TGGePoly2D &poly, AcGeVoidPointerArray &edgeptrs, AcGeIntArray &edgetypes)
|
||
{
|
||
if (!poly.Length()) return;
|
||
|
||
TGGePoly2D _poly(poly);
|
||
|
||
TGGeCurveSegment seg;
|
||
if (!_poly.IsClosed())
|
||
{
|
||
_poly.AppendNode(*_poly[0]);
|
||
}
|
||
|
||
int len = poly.Length();
|
||
|
||
for (int i = 0; i < len; ++i)
|
||
{
|
||
_poly.Nth(i, seg);
|
||
edgeptrs.append(new AcGeLineSeg2d(seg.GetStartPoint().AsAcGePoint2d(), seg.GetEndPoint().AsAcGePoint2d()));
|
||
if (seg.Is(CURVE_ARC))
|
||
edgetypes.append(AcDbHatch::kCirArc);
|
||
else if (seg.Is(CURVE_LINE))
|
||
edgetypes.append(AcDbHatch::kLine);
|
||
}
|
||
}
|
||
}
|
||
|
||
AcDbHatch* TchExport2::NewHatchFromPoly2D(const TGGeHatch &hatch)
|
||
{
|
||
TCString sPattern;
|
||
sPattern = hatch.GetHatchName();
|
||
double nScl = hatch.GetHatchScale();
|
||
TCHAR *pScale = sPattern.StrChr(_T(':'));
|
||
if (pScale)
|
||
{
|
||
*pScale = EOS;
|
||
pScale++;
|
||
double dScaleAdd = _tstof(pScale);
|
||
if (dScaleAdd > 1.0E-6)
|
||
{
|
||
nScl *= dScaleAdd;
|
||
}
|
||
}
|
||
|
||
AcDbHatch *pHatch = new AcDbHatch();
|
||
pHatch->setAssociative(Adesk::kFalse);
|
||
pHatch->setPatternScale(nScl);
|
||
pHatch->setPatternAngle(hatch.GetHatchRotation());
|
||
pHatch->setHatchStyle(AcDbHatch::kNormal);
|
||
if (pHatch->setPattern(AcDbHatch::kPreDefined, sPattern) != Acad::eOk)
|
||
{
|
||
delete pHatch;
|
||
return NULL;
|
||
}
|
||
|
||
const std::vector<TGGePoly2D> polys = hatch.GetPolys();
|
||
|
||
for (size_t i = 0; i < polys.size(); ++i)
|
||
{
|
||
|
||
const TGGePoly2D &Poly = polys[i];
|
||
AcGeVoidPointerArray edgeptrs;
|
||
AcGeIntArray edgetypes;
|
||
GetLineSeg2dArray(Poly, edgeptrs, edgetypes);
|
||
pHatch->appendLoop(AcDbHatch::kExternal, edgeptrs, edgetypes);
|
||
}
|
||
|
||
if (pHatch->evaluateHatch(true) != Acad::eOk)
|
||
{
|
||
delete pHatch;
|
||
return NULL;
|
||
}
|
||
|
||
return pHatch;
|
||
}
|
||
|
||
AcDbHatch * TchExport2::NewHatchFromPoly2D(const TGGePoly2D &poly, const TCHAR *pszPattern0, double nScl, double rotation)
|
||
{
|
||
TCString sPattern;
|
||
sPattern = pszPattern0;
|
||
TCHAR *pScale = sPattern.StrChr(_T(':'));
|
||
if (pScale)
|
||
{
|
||
*pScale = EOS;
|
||
pScale++;
|
||
double dScaleAdd = _tstof(pScale);
|
||
if (dScaleAdd > 1.0E-6)
|
||
{
|
||
nScl *= dScaleAdd;
|
||
}
|
||
}
|
||
|
||
AcGeDoubleArray bulges;
|
||
AcGePoint2dArray vertices;
|
||
|
||
int nVert = poly.Length();
|
||
|
||
AcDbHatch *pHatch = new AcDbHatch();
|
||
pHatch->setAssociative(Adesk::kFalse);
|
||
pHatch->setPatternScale(nScl);
|
||
pHatch->setPatternAngle(rotation);
|
||
pHatch->setHatchStyle(AcDbHatch::kNormal);
|
||
if (pHatch->setPattern(AcDbHatch::kPreDefined, sPattern) != Acad::eOk)
|
||
{
|
||
delete pHatch;
|
||
return NULL;
|
||
}
|
||
|
||
bulges.setPhysicalLength(0).setLogicalLength(nVert + 1);
|
||
vertices.setPhysicalLength(0).setLogicalLength(nVert + 1);
|
||
|
||
for (int i = 0; i < nVert; i++)
|
||
{
|
||
vertices[i] = poly[i];
|
||
bulges[i] = tan(poly.GetBulge(i) / 4);
|
||
}
|
||
vertices[i] = vertices[0];
|
||
bulges[i] = bulges[0];
|
||
|
||
pHatch->appendLoop(AcDbHatch::kExternal | AcDbHatch::kPolyline | AcDbHatch::kDerived, vertices, bulges);
|
||
Acad::ErrorStatus es;
|
||
if ((es = pHatch->evaluateHatch(true)) != Acad::eOk)
|
||
{
|
||
delete pHatch;
|
||
return NULL;
|
||
}
|
||
|
||
return pHatch;
|
||
}
|
||
|
||
Acad::ErrorStatus TchExport2::ReadPoly2D(AcDbDwgFiler *pFiler, TGGePoly2D &poly)
|
||
{
|
||
Adesk::UInt8 bIsClosed = 0;
|
||
pFiler->readItem(&bIsClosed);
|
||
Adesk::UInt16 nVertexCount = 0;
|
||
pFiler->readItem(&nVertexCount);
|
||
poly.Reset();
|
||
poly.SetFlag(bIsClosed);
|
||
for (Adesk::UInt16 i = 0; i < nVertexCount; i++)
|
||
{
|
||
AcGePoint2d pt;
|
||
double bulge;
|
||
pFiler->readItem(&pt);
|
||
pFiler->readItem(&bulge);
|
||
poly.AppendNode(TADSGePoint3d(pt[0], pt[1], 0.0), bulge);
|
||
}
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
Acad::ErrorStatus TchExport2::WritePoly2D(AcDbDwgFiler *pFiler, const TGGePoly2D &poly)
|
||
{
|
||
pFiler->writeItem((Adesk::UInt8)poly.GetFlag());
|
||
Adesk::UInt16 nVertexCount = poly.Length();
|
||
pFiler->writeItem(nVertexCount);
|
||
for (Adesk::UInt16 i = 0; i < nVertexCount; i++)
|
||
{
|
||
pFiler->writeItem(poly[i].AsAcGePoint2d());
|
||
pFiler->writeItem(poly.GetBulge(i));
|
||
}
|
||
return pFiler->filerStatus();
|
||
}
|
||
|
||
int TchExport2::_SplitPoly2D(const TGGePoly2D &poly, const TADSGePoint3d &pt1, const TADSGePoint3d &pt2, TGGePoly2D &res1, TGGePoly2D &res2)
|
||
{
|
||
ASSERT(poly.IsClosed());
|
||
TADSGePoint3d ptBreak[2] = { pt1, pt2 };
|
||
TADSGePoint3d ptOnPoly[2] = { pt1, pt2 };
|
||
int nBreakIndex[2] = { -1, -1 };
|
||
double minDist[2] = { -1.0, -1.0 };
|
||
|
||
int nSeg = poly.TotalSegments();
|
||
for (int i = 0; i < nSeg; i++)
|
||
{
|
||
TGGeCurveSegment seg;
|
||
poly.Nth(i, seg);
|
||
for (int n = 0; n < 2; n++)
|
||
{
|
||
TADSGePoint3d ptPrj;
|
||
if (seg.ProjectToMe(ptBreak[n], ptPrj) == RTNORM)
|
||
{
|
||
int nPrFlag = (ptPrj&seg);
|
||
if (nPrFlag == PR_INSIDE || nPrFlag == PR_ONPT1 || nPrFlag == PR_ONPT2)
|
||
{
|
||
double nDist = ads_distance(ptBreak[n], ptPrj);
|
||
if (minDist[n] < -1.0E-3)
|
||
{
|
||
minDist[n] = nDist;
|
||
nBreakIndex[n] = i;
|
||
ptOnPoly[n] = ptPrj;
|
||
}
|
||
else if (nDist < minDist[n])
|
||
{
|
||
minDist[n] = nDist;
|
||
nBreakIndex[n] = i;
|
||
ptOnPoly[n] = ptPrj;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (nBreakIndex[0] < 0 || nBreakIndex[1] < 0)
|
||
{
|
||
return RTERROR; //找不到切断点
|
||
}
|
||
|
||
int minIndex, maxIndex;
|
||
TADSGePoint3d ptMin, ptMax;
|
||
if (nBreakIndex[0] == nBreakIndex[1])
|
||
{
|
||
//在同一段，靠近起点为小，靠近终点为大
|
||
TGGeDirectionCurve cvTemp;
|
||
poly.Nth(nBreakIndex[0], cvTemp);
|
||
double nDist0 = cvTemp.PathDistance(ptOnPoly[0]);
|
||
double nDist1 = cvTemp.PathDistance(ptOnPoly[1]);
|
||
if (fabs(nDist0 - nDist1) < _DIST_SNAP)
|
||
{
|
||
return RTERROR; //重合
|
||
}
|
||
minIndex = nBreakIndex[0];
|
||
maxIndex = nBreakIndex[1];
|
||
if (nDist0 < nDist1)
|
||
{
|
||
ptMin = ptOnPoly[0];
|
||
ptMax = ptOnPoly[1];
|
||
}
|
||
else
|
||
{
|
||
ptMin = ptOnPoly[1];
|
||
ptMax = ptOnPoly[0];
|
||
}
|
||
}
|
||
else if (nBreakIndex[0] < nBreakIndex[1])
|
||
{
|
||
minIndex = nBreakIndex[0];
|
||
maxIndex = nBreakIndex[1];
|
||
ptMin = ptOnPoly[0];
|
||
ptMax = ptOnPoly[1];
|
||
}
|
||
else
|
||
{
|
||
minIndex = nBreakIndex[1];
|
||
maxIndex = nBreakIndex[0];
|
||
ptMin = ptOnPoly[1];
|
||
ptMax = ptOnPoly[0];
|
||
}
|
||
|
||
// 取得res1
|
||
for (i = minIndex; i <= maxIndex; i++)
|
||
{
|
||
TGGeDirectionCurve seg;
|
||
poly.Nth(i, seg);
|
||
if (i == minIndex)
|
||
{
|
||
// get ptBreak->ptEnd
|
||
if (ads_distance(ptMin, seg.GetEndPoint()) < _DIST_SNAP)
|
||
{
|
||
continue; //忽略这一段
|
||
}
|
||
double nBulge = 0.0;
|
||
if (seg.IsMinusArc())
|
||
{
|
||
TGGeArc ar = seg.GetArc();
|
||
ar.SetAngleByPoints(seg.GetEndPoint(), ptMin);
|
||
nBulge = -ar.Bulge();
|
||
}
|
||
else
|
||
{
|
||
seg.SetPoints(ptMin, seg.GetEndPoint());
|
||
nBulge = seg.GetBulge();
|
||
}
|
||
res1.AppendNode(ptMin, nBulge);
|
||
}
|
||
if (i == maxIndex)
|
||
{
|
||
// get ptStart->ptBreak
|
||
if (ads_distance(ptMax, seg.GetStartPoint()) < _DIST_SNAP)
|
||
{
|
||
res1.AppendNode(ptMax, 0.0);
|
||
continue; //忽略这一段
|
||
}
|
||
double nBulge = 0.0;
|
||
if (seg.IsMinusArc())
|
||
{
|
||
TGGeArc ar = seg.GetArc();
|
||
ar.SetAngleByPoints(ptMax, seg.StartPoint());
|
||
nBulge = -ar.Bulge();
|
||
}
|
||
else
|
||
{
|
||
seg.SetPoints(seg.StartPoint(), ptMax);
|
||
nBulge = seg.GetBulge();
|
||
}
|
||
res1.AppendNode(seg.StartPoint(), nBulge);
|
||
res1.AppendNode(ptMax, 0.0);
|
||
}
|
||
if (i != minIndex && i != maxIndex)
|
||
{
|
||
res1.AppendNode(seg.StartPoint(), seg.GetBulge());
|
||
}
|
||
}
|
||
|
||
// 取得res2
|
||
for (i = maxIndex; i <= minIndex + nSeg; i++)
|
||
{
|
||
int idx = TchExport::DePeriod(nSeg, i);
|
||
TGGeDirectionCurve seg;
|
||
poly.Nth(idx, seg);
|
||
|
||
if (idx == maxIndex)
|
||
{
|
||
// get ptBreak->ptEnd
|
||
if (ads_distance(ptMax, seg.GetEndPoint()) < _DIST_SNAP)
|
||
{
|
||
continue; //忽略这一段
|
||
}
|
||
double nBulge = 0.0;
|
||
if (seg.IsMinusArc())
|
||
{
|
||
TGGeArc ar = seg.GetArc();
|
||
ar.SetAngleByPoints(seg.GetEndPoint(), ptMax);
|
||
nBulge = -ar.Bulge();
|
||
}
|
||
else
|
||
{
|
||
seg.SetPoints(ptMax, seg.GetEndPoint());
|
||
nBulge = seg.GetBulge();
|
||
}
|
||
res2.AppendNode(ptMax, nBulge);
|
||
}
|
||
if (idx == minIndex)
|
||
{
|
||
// get ptStart->ptBreak
|
||
if (ads_distance(ptMin, seg.GetStartPoint()) < _DIST_SNAP)
|
||
{
|
||
res2.AppendNode(ptMin, 0.0);
|
||
continue;
|
||
}
|
||
double nBulge = 0.0;
|
||
if (seg.IsMinusArc())
|
||
{
|
||
TGGeArc ar = seg.GetArc();
|
||
ar.SetAngleByPoints(ptMin, seg.StartPoint());
|
||
nBulge = -ar.Bulge();
|
||
}
|
||
else
|
||
{
|
||
seg.SetPoints(seg.StartPoint(), ptMin);
|
||
nBulge = seg.GetBulge();
|
||
}
|
||
res2.AppendNode(seg.StartPoint(), nBulge);
|
||
res2.AppendNode(ptMin, 0.0);
|
||
}
|
||
if (i != minIndex && i != maxIndex)
|
||
{
|
||
res2.AppendNode(seg.StartPoint(), seg.GetBulge());
|
||
}
|
||
}
|
||
return RTNORM;
|
||
}
|
||
|
||
int TchExport2::SplitPoly2D(const TGGePoly2D &poly, const TADSGePoint3d &pt1, const TADSGePoint3d &pt2, TGGePoly2D &res1, TGGePoly2D &res2)
|
||
{
|
||
ASSERT(poly.IsClosed());
|
||
|
||
AcDbPolyline pline;
|
||
TADSGePoint3d ptOnCurve1, ptOnCurve2;
|
||
TchExport2::PolyConvert(poly, pline);
|
||
|
||
if (pline.getClosestPointTo(pt1, ptOnCurve1) != Acad::eOk || pline.getClosestPointTo(pt2, ptOnCurve2) != Acad::eOk)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
// ARX的SplitCurve有错误，因此自己编写
|
||
int nIndex1 = poly.HitTestOnCurve(ptOnCurve1);
|
||
int nIndex2 = poly.HitTestOnCurve(ptOnCurve2);
|
||
if (!nIndex1 || !nIndex2)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
|
||
int nPeriod = poly.Length();
|
||
if (nIndex1 > 0 && nIndex2 > 0)
|
||
{ //顶点到顶点
|
||
int nVert1 = nIndex1 - 1;
|
||
int nVert2 = nIndex2 - 1;
|
||
if (nVert1 == nVert2)
|
||
{
|
||
return RTERROR;
|
||
}
|
||
// nVert1到nVert2
|
||
int nTo = (nVert2 > nVert1) ? nVert2 : nVert2 + nPeriod;
|
||
for (int iVert = nVert1; iVert <= nTo; iVert++)
|
||
{
|
||
int idx = TchExport::DePeriod(nPeriod, iVert);
|
||
res1.AppendNode(poly[idx], poly.GetBulge(idx));
|
||
}
|
||
// nVert2到nVert1
|
||
nTo = (nVert1 > nVert2) ? nVert1 : nVert1 + nPeriod;
|
||
for (iVert = nVert2; iVert <= nTo; iVert++)
|
||
{
|
||
int idx = TchExport::DePeriod(nPeriod, iVert);
|
||
res2.AppendNode(poly[idx], poly.GetBulge(idx));
|
||
}
|
||
}
|
||
else if (nIndex1 < 0 && nIndex2 < 0)
|
||
{ // 边到边
|
||
int nEdge1 = abs(nIndex1) - 1;
|
||
int nEdge2 = abs(nIndex2) - 1;
|
||
|
||
// Edge1到Edge2
|
||
TGGeDirectionCurve seg;
|
||
if (nEdge1 == nEdge2)
|
||
{
|
||
poly.Nth(nEdge1, seg);
|
||
if (seg.PathDistance(ptOnCurve1) > seg.PathDistance(ptOnCurve2) && seg.Is(CURVE_ARC))//add by w on 070302,解决两点在同一弧边的问题
|
||
{
|
||
seg.SetPoints(ptOnCurve2, ptOnCurve1);
|
||
seg.Reverse();
|
||
}
|
||
else
|
||
{
|
||
seg.SetPoints(ptOnCurve1, ptOnCurve2);
|
||
}
|
||
|
||
res1.AppendNode(seg.StartPoint(), seg.GetBulge());
|
||
res1.AppendNode(seg.EndPoint(), 0.0);
|
||
}
|
||
else
|
||
{
|
||
// 第一段
|
||
poly.Nth(nEdge1, seg);
|
||
seg.SetPoints(ptOnCurve1, seg.GetEndPoint());
|
||
res1.AppendNode(seg.StartPoint(), seg.GetBulge());
|
||
|
||
// 中间段
|
||
int nToEdge = (nEdge2 > nEdge1) ? nEdge2 : nEdge2 + nPeriod;
|
||
for (int iVert = nEdge1 + 1; iVert <= nToEdge - 1; iVert++)
|
||
{
|
||
int idx = TchExport::DePeriod(nPeriod, iVert);
|
||
res1.AppendNode(poly[idx], poly.GetBulge(idx));
|
||
}
|
||
|
||
// 最后一段
|
||
poly.Nth(nEdge2, seg);
|
||
seg.SetPoints(seg.StartPoint(), ptOnCurve2);
|
||
res1.AppendNode(seg.StartPoint(), seg.GetBulge());
|
||
|
||
// 最后一点
|
||
res1.AppendNode(ptOnCurve2, 0.0);
|
||
}
|
||
|
||
// Edge2到Edge1
|
||
// 第一段
|
||
poly.Nth(nEdge2, seg);
|
||
seg.SetPoints(ptOnCurve2, seg.EndPoint());
|
||
res2.AppendNode(seg.StartPoint(), seg.GetBulge());
|
||
// 中间段
|
||
int nToEdge = (nEdge1 > nEdge2) ? nEdge1 : nEdge1 + nPeriod;
|
||
for (int iVert = nEdge2 + 1; iVert <= nToEdge - 1; iVert++)
|
||
{
|
||
int idx = TchExport::DePeriod(nPeriod, iVert);
|
||
res2.AppendNode(poly[idx], poly.GetBulge(idx));
|
||
}
|
||
// 最后一段
|
||
poly.Nth(nEdge1, seg);
|
||
seg.SetPoints(seg.StartPoint(), ptOnCurve1);
|
||
res2.AppendNode(seg.StartPoint(), seg.GetBulge());
|
||
// 最后一点
|
||
res2.AppendNode(ptOnCurve1, 0.0);
|
||
}
|
||
else if (nIndex1 > 0 && nIndex2 < 0)
|
||
{ //顶点到边
|
||
int nVert1 = nIndex1 - 1;
|
||
int nEdge2 = abs(nIndex2) - 1;
|
||
// nVert1到Edge2
|
||
TGGeDirectionCurve seg;
|
||
// 中间段
|
||
int nToEdge = (nEdge2 >= nVert1) ? nEdge2 : nEdge2 + nPeriod;
|
||
for (int iVert = nVert1; iVert <= nToEdge - 1; iVert++)
|
||
{
|
||
int idx = TchExport::DePeriod(nPeriod, iVert);
|
||
res1.AppendNode(poly[idx], poly.GetBulge(idx));
|
||
}
|
||
|
||
// 最后一段
|
||
poly.Nth(nEdge2, seg);
|
||
seg.SetPoints(seg.StartPoint(), ptOnCurve2);
|
||
res1.AppendNode(seg.StartPoint(), seg.GetBulge());
|
||
|
||
// 最后一点
|
||
res1.AppendNode(ptOnCurve2, 0.0);
|
||
|
||
// Edge2到nVert1
|
||
// 第一段
|
||
poly.Nth(nEdge2, seg);
|
||
seg.SetPoints(ptOnCurve2, seg.EndPoint());
|
||
res2.AppendNode(seg.StartPoint(), seg.GetBulge());
|
||
// 中间段
|
||
nToEdge = (nVert1 >= nEdge2) ? nVert1 : nVert1 + nPeriod;
|
||
for (iVert = nEdge2 + 1; iVert <= nVert1 - 1; iVert++)
|
||
{
|
||
int idx = TchExport::DePeriod(nPeriod, iVert);
|
||
res2.AppendNode(poly[idx], poly.GetBulge(idx));
|
||
}
|
||
// 最后一点
|
||
res2.AppendNode(ptOnCurve1, 0.0);
|
||
}
|
||
else
|
||
{ // 边到顶点
|
||
int nEdge1 = abs(nIndex1) - 1;
|
||
int nVert2 = nIndex2 - 1;
|
||
|
||
// nEdge1到nVert2
|
||
TGGeDirectionCurve seg;
|
||
// 第一段
|
||
poly.Nth(nEdge1, seg);
|
||
seg.SetPoints(ptOnCurve1, seg.EndPoint());
|
||
res1.AppendNode(seg.StartPoint(), seg.GetBulge());
|
||
|
||
// 中间段
|
||
int nToEdge = (nVert2 > nEdge1) ? nVert2 : nVert2 + nPeriod;
|
||
for (int iVert = nEdge1 + 1; iVert <= nToEdge - 1; iVert++)
|
||
{
|
||
int idx = TchExport::DePeriod(nPeriod, iVert);
|
||
res1.AppendNode(poly[idx], poly.GetBulge(idx));
|
||
}
|
||
// 最后一点
|
||
res1.AppendNode(ptOnCurve2, 0.0);
|
||
|
||
// nVert2到nEdge1
|
||
if (nEdge1 == nVert2)
|
||
{
|
||
poly.Nth(nEdge1, seg);
|
||
seg.SetPoints(ptOnCurve2, ptOnCurve1);
|
||
res1.AppendNode(seg.StartPoint(), seg.GetBulge());
|
||
res1.AppendNode(seg.EndPoint(), 0.0);
|
||
}
|
||
else
|
||
{
|
||
// 中间段
|
||
int nToEdge = (nEdge1 > nVert2) ? nEdge1 : nEdge1 + nPeriod;
|
||
for (int iVert = nVert2; iVert <= nToEdge - 1; iVert++)
|
||
{
|
||
int idx = TchExport::DePeriod(nPeriod, iVert);
|
||
res2.AppendNode(poly[idx], poly.GetBulge(idx));
|
||
}
|
||
// 最后一段
|
||
poly.Nth(nEdge1, seg);
|
||
seg.SetPoints(seg.StartPoint(), ptOnCurve1);
|
||
res2.AppendNode(seg.StartPoint(), seg.GetBulge());
|
||
//最后一点
|
||
res2.AppendNode(ptOnCurve1, 0.0);
|
||
}
|
||
}
|
||
return RTNORM;
|
||
}
|
||
|
||
void TchExport2::SplitPoly2D(const TGGePoly2D &poly, AcDbVoidPtrArray &entSet)
|
||
{
|
||
for (int i = 0; i < poly.TotalSegments(); i++)
|
||
{
|
||
TGGeCurveSegment cv;
|
||
if (poly.Nth(i, cv) == RTNORM)
|
||
{
|
||
if (cv.Is(CURVE_LINE))
|
||
{
|
||
TGGeLine ln = cv.GetLine();
|
||
entSet.append(new AcDbLine(ln.GetStartPoint(), ln.GetEndPoint()));
|
||
}
|
||
else if (cv.Is(CURVE_ARC))
|
||
{
|
||
TGGeArc ar = cv.GetArc();
|
||
entSet.append(new AcDbArc(ar.GetCenterPt(), ar.GetRadius(), ar.GetStarAngle(), ar.GetEndAngle()));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 把区域分解为曲线段
|
||
void TchExport2::Region2Curves(const AcDbRegion *pClone, TDPtrList<TGGeCurveSegment>&lstSegs)
|
||
{
|
||
AcDbVoidPtrArray entSet;
|
||
pClone->explode(entSet);
|
||
int nLen = entSet.length();
|
||
for (int j = 0; j < nLen; j++)
|
||
{
|
||
AcDbEntity *pEnt = (AcDbEntity *)entSet[j];
|
||
AcRxClass *pClass = pEnt->isA();
|
||
if (pClass == AcDbLine::desc())
|
||
{
|
||
AcDbLine *pLine = (AcDbLine *)pEnt;
|
||
lstSegs.Append(new TGGeCurveSegment(TADSGePoint3d(pLine->startPoint()), TADSGePoint3d(pLine->endPoint()), 0.0, LS_FINITE));
|
||
}
|
||
else if (pClass == AcDbArc::desc())
|
||
{
|
||
AcDbArc *pLine = (AcDbArc *)pEnt;
|
||
TADSGePoint3d ptCen;
|
||
(AcGePoint3d &)ptCen = pLine->center();
|
||
TVector3D vtNormal;
|
||
(AcGeVector3d &)vtNormal = pLine->normal();
|
||
ptCen = Wcs2Ecs(ptCen, vtNormal);
|
||
TGGeArc ar(ptCen, pLine->radius(), pLine->startAngle(), pLine->endAngle());
|
||
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
||
*pSeg = ar;
|
||
lstSegs.Append(pSeg);
|
||
}
|
||
else if (pClass == AcDbPolyline::desc())
|
||
{
|
||
TGGePoly2D polyTemp;
|
||
TchExport2::PolyConvert(*(AcDbPolyline *)pEnt, polyTemp);
|
||
TchExport2::ExplodePoly2D(polyTemp, lstSegs);
|
||
}
|
||
else if (pClass = AcDbRegion::desc())
|
||
{
|
||
TchExport2::Region2Curves((AcDbRegion *)pEnt, lstSegs);
|
||
}
|
||
}
|
||
TchExport::ReleaseEntSet(entSet);
|
||
}
|
||
|
||
int TchExport2::HandleCurveInters(TPickEntSet &ss, double dPrec)
|
||
{
|
||
//_angSnap = 0.001; _DIST_SNAP = 0.1; // for Debug
|
||
TPickEntSet ssNew(SS_FREE | SS_CREATE), ssCir(SS_FREE | SS_CREATE), ssDel(SS_FREE | SS_CREATE);
|
||
|
||
TGGeCurveSegUniqueEx::minLen = dPrec;
|
||
ssNew.IncludeBegin();
|
||
|
||
TGGeCurveSegUniqueEx::GlobalCurveList.Reset();
|
||
long len = ss.Length();
|
||
TDPtrList<TGGeCurveSegUniqueEx> &curves = TGGeCurveSegUniqueEx::GlobalCurveList;
|
||
for (long i = 0; i < len; i++)
|
||
{
|
||
TEntitySet e1 = ss[i];
|
||
TGGeCurveSegUniqueEx * curve = new TGGeCurveSegUniqueEx(e1);
|
||
if (curve->GetLength() < _DIST_SNAP)
|
||
{
|
||
delete curve;
|
||
ssDel += ss[i];
|
||
}
|
||
else
|
||
{
|
||
curves.Append(curve);
|
||
}
|
||
}
|
||
|
||
len = curves.Length();
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
TGGeCurveSegUniqueEx *curve = curves[(int)i];
|
||
curve->DivideToSegments();
|
||
if (curve->Update() == RTNORM && curve->Is(CURVE_CIRCLE))
|
||
{
|
||
ssCir += curve->acadEnt;
|
||
}
|
||
}
|
||
|
||
ssNew.IncludeEnd();
|
||
|
||
ss -= ssDel;
|
||
ss -= ssCir;
|
||
ss += ssNew;
|
||
TGGeCurveSegUniqueEx::GlobalCurveList.Reset();
|
||
ssDel.Erase();
|
||
ads_redraw(NULL, 0);
|
||
return RTNORM;
|
||
}
|
||
|
||
// 连接桥的确定有问题
|
||
// 新的桥接算法
|
||
// 2D only
|
||
int TchExport2::ConnectPolygon(const TGGePolygonEx &poly1, const TGGePolygonEx &poly2, const TGGePolyDist &polyDist, TGGePolygonEx &res)
|
||
{
|
||
ASSERT(poly1.Length() > 1 && poly2.Length() > 1);
|
||
|
||
int nIndex1 = polyDist.nIndex1;
|
||
int num1 = poly1.Length();
|
||
int nIndex2 = polyDist.nIndex2; //poly2与pt最近的顶点
|
||
int num2 = poly2.Length();
|
||
res.Reset();
|
||
|
||
BOOL bOnVertex1 = FALSE, bOnVertex2 = FALSE;
|
||
if (polyDist.ptLocation1.Distance2d(poly1.GetVertex(polyDist.nIndex1)) < _DIST_SNAP)
|
||
{
|
||
bOnVertex1 = TRUE;
|
||
}
|
||
else if (polyDist.ptLocation1.Distance2d(poly1.GetVertex(polyDist.nIndex1 + 1)) < _DIST_SNAP)
|
||
{
|
||
bOnVertex1 = TRUE;
|
||
nIndex1++;
|
||
}
|
||
|
||
if (polyDist.ptLocation2.Distance2d(poly2.GetVertex(polyDist.nIndex2)) < _DIST_SNAP)
|
||
{
|
||
bOnVertex2 = TRUE;
|
||
}
|
||
else if (polyDist.ptLocation2.Distance2d(poly2.GetVertex(polyDist.nIndex2 + 1)) < _DIST_SNAP)
|
||
{
|
||
bOnVertex2 = TRUE;
|
||
nIndex2++;
|
||
}
|
||
|
||
int j = 0, i = 0;
|
||
if (bOnVertex1)
|
||
{
|
||
for (j = nIndex1; j < nIndex1 + num1; j++)
|
||
{
|
||
res.AppendNode(poly1.GetVertex(j), poly1.IsVisible(j));
|
||
}
|
||
res.AppendNode(poly1.GetVertex(nIndex1), FALSE);
|
||
}
|
||
else
|
||
{
|
||
res.AppendNode(polyDist.ptLocation1, poly1.IsVisible(nIndex1));
|
||
for (j = nIndex1 + 1; j <= nIndex1 + num1; j++)
|
||
{
|
||
res.AppendNode(poly1.GetVertex(j), poly1.IsVisible(j));
|
||
}
|
||
res.AppendNode(polyDist.ptLocation1, FALSE);
|
||
}
|
||
|
||
if (bOnVertex2)
|
||
{
|
||
for (i = nIndex2; i < nIndex2 + num2; i++)
|
||
{
|
||
res.AppendNode(poly2.GetVertex(i), poly2.IsVisible(i));
|
||
}
|
||
res.AppendNode(poly2.GetVertex(nIndex2), FALSE);
|
||
}
|
||
else
|
||
{
|
||
res.AppendNode(polyDist.ptLocation2, poly2.IsVisible(nIndex2));
|
||
for (i = nIndex2 + 1; i <= nIndex2 + num2; i++)
|
||
{
|
||
res.AppendNode(poly2.GetVertex(i), poly2.IsVisible(i));
|
||
}
|
||
res.AppendNode(polyDist.ptLocation2, FALSE);
|
||
}
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
int TchExport2::ConnectPolygon(const TGGePolygonEx &poly1, const TGGePolygonEx &poly2, TGGePolygonEx &res)
|
||
{
|
||
ASSERT(poly1.Length() > 1 && poly2.Length() > 1);
|
||
|
||
int nIndex1 = 0;
|
||
int num1 = poly1.Length();
|
||
int nIndex2 = 0; //poly2与pt最近的顶点
|
||
double dMinDist = 0.0;
|
||
int num2 = poly2.Length();
|
||
for (int j = 0; j < num1; j++)
|
||
{
|
||
TADSGePoint3d pt = poly1[j];
|
||
for (int i = 0; i < num2; i++)
|
||
{
|
||
double dDist = pt.Distance(poly2[i]);
|
||
if (i == 0 && j == 0)
|
||
{
|
||
dMinDist = dDist;
|
||
}
|
||
else if (dDist < dMinDist)
|
||
{
|
||
dMinDist = dDist;
|
||
nIndex2 = i;
|
||
nIndex1 = j;
|
||
}
|
||
}
|
||
}
|
||
|
||
res.Reset();
|
||
for (j = nIndex1; j < nIndex1 + num1; j++)
|
||
{
|
||
res.AppendNode(poly1.GetVertex(j), poly1.IsVisible(j));
|
||
}
|
||
res.AppendNode(poly1.GetVertex(nIndex1), FALSE);
|
||
|
||
for (int i = nIndex2; i < nIndex2 + num2; i++)
|
||
{
|
||
res.AppendNode(poly2.GetVertex(i), poly2.IsVisible(i));
|
||
}
|
||
res.AppendNode(poly2.GetVertex(nIndex2), FALSE);
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
void TchExport2::IntersectCurvesEx(TDPtrList<TGGeCurveSegment> &lstCurves, double dPrec)
|
||
{
|
||
TGGeCurveSegunique::minLen = dPrec;
|
||
TGGeCurveSegunique::GlobalCurveList.Reset();
|
||
|
||
int len = lstCurves.Length();
|
||
for (int i = 0; i < len; i++)
|
||
{
|
||
TGGeCurveSegment &e1 = *lstCurves[i];
|
||
if (e1.GetLength() < max(_DIST_SNAP, dPrec))
|
||
{
|
||
continue;
|
||
}
|
||
TGGeCurveSegunique::GlobalCurveList.Append(new TGGeCurveSegunique(e1));
|
||
}
|
||
|
||
len = TGGeCurveSegunique::GlobalCurveList.Length();
|
||
if (g_bEchoSearch)
|
||
{
|
||
TCString sMsg(256);
|
||
sMsg << _T("对") << len << _T("条线进行处理交线");
|
||
acedSetStatusBarProgressMeter(sMsg, 0, len);
|
||
}
|
||
int nStep = len / 100;
|
||
if (nStep < 1)
|
||
{
|
||
nStep = 1;
|
||
}
|
||
|
||
lstCurves.Reset();
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
if (g_bEchoSearch && !(i%nStep))
|
||
{
|
||
acedSetStatusBarProgressMeterPos(i);
|
||
}
|
||
|
||
TGGeCurveSegunique *curve = TGGeCurveSegunique::GlobalCurveList[i];
|
||
curve->DivideToSegments();
|
||
TGGePoly2D poly;
|
||
curve->segments.AsPoly2D(poly);
|
||
for (int n = 0; n<poly.TotalSegments(); n++)
|
||
{
|
||
TGGeCurveSegment seg;
|
||
poly.Nth(n, seg);
|
||
if (seg.GetLength() > max(_DIST_SNAP, dPrec))
|
||
{
|
||
lstCurves.Append(new TGGeCurveSegment(seg));
|
||
}
|
||
}
|
||
}
|
||
|
||
TGGeCurveSegunique::GlobalCurveList.Reset();
|
||
if (g_bEchoSearch)
|
||
{
|
||
acedRestoreStatusBar();
|
||
}
|
||
}
|
||
|
||
// poly的坐标为当前UCS下的坐标
|
||
// ss1--inside; ss2--outside
|
||
// Status: Only use in WCS
|
||
int TchExport2::PolyClip(const TDPtrList<TGGeCurveSegment> &ss, TGGePoly2D &poly, TDPtrList<TGGeCurveSegment> &ss1, TDPtrList<TGGeCurveSegment> &ss2)
|
||
{
|
||
int len = ss.Length();
|
||
for (int i = 0; i < len; i++)
|
||
{
|
||
TGGeCurveSegment seg = ss[i];
|
||
seg.SetElevation(poly[0]->z); // Z坐标相等
|
||
|
||
TPointList pts(seg.GetStartPoint(), seg.GetEndPoint(), seg.GetBulge());
|
||
::Intersect(seg, poly, pts); // 先求出所有的交点,并排序
|
||
int listLen = pts.Length();
|
||
|
||
if (pts.curveType == CURVE_CIRCLE)
|
||
{
|
||
if (listLen <= 2)
|
||
{ // circle, but not cut to arcs
|
||
TADSGePoint3d mpt = seg.GetCircle().GetCenterPt();
|
||
if ((mpt&poly) == PR_INSIDE)
|
||
{
|
||
ss1.Append(new TGGeCurveSegment(ss[i]));
|
||
}
|
||
else
|
||
{
|
||
ss2.Append(new TGGeCurveSegment(ss[i]));
|
||
}
|
||
continue;
|
||
}
|
||
|
||
for (int i = 1; i < listLen; i++)
|
||
{
|
||
TADSGePoint3d pt2;
|
||
if (i == listLen - 1) pt2 = *pts[1];
|
||
else pt2 = *pts[i + 1];
|
||
TGGeArc arcSeg(pts.center, ads_distance(pts.center, *pts[i]), ads_angle(pts.center, *pts[i]), ads_angle(pts.center, pt2));
|
||
TADSGePoint3d mpt;
|
||
arcSeg.MidPoint(mpt);
|
||
TGGeCurveSegment *pCurve = new TGGeCurveSegment;
|
||
*pCurve = arcSeg;
|
||
if ((mpt&poly) == PR_INSIDE)
|
||
{
|
||
ss1.Append(pCurve);
|
||
}
|
||
else
|
||
{
|
||
ss2.Append(pCurve);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (int j = 0; j < listLen - 1; j++)
|
||
{ // arc and line
|
||
TADSGePoint3d &pt1 = *pts[j];
|
||
TADSGePoint3d &pt2 = *pts[j + 1];
|
||
if (pts.curveType == CURVE_LINE)
|
||
{
|
||
TGGeLine lineSeg(pt1, pt2);
|
||
TADSGePoint3d mpt = lineSeg.MidPoint();
|
||
TGGeCurveSegment *pCurve = new TGGeCurveSegment;
|
||
*pCurve = lineSeg;
|
||
if ((mpt & poly) == PR_INSIDE)
|
||
{
|
||
ss1.Append(pCurve);
|
||
}
|
||
else
|
||
{
|
||
ss2.Append(pCurve);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TGGeArc arcSeg(pts.center, ads_distance(pts.center, pt1), ads_angle(pts.center, pt1), ads_angle(pts.center, pt2));
|
||
TADSGePoint3d mpt;
|
||
arcSeg.MidPoint(mpt);
|
||
TADSGePoint3d cen = arcSeg.GetCenterPt();
|
||
TGGeCurveSegment *pCurve = new TGGeCurveSegment;
|
||
*pCurve = arcSeg;
|
||
if ((mpt&poly) == PR_INSIDE)
|
||
{
|
||
ss1.Append(pCurve);
|
||
}
|
||
else
|
||
{
|
||
ss2.Append(pCurve);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
// poly的坐标为当前UCS下的坐标
|
||
// ss1--inside; ss2--outside; ssOnEdge--On Edge
|
||
int TchExport2::PolyClip(const TDPtrList<TGGeCurveSegment> &ss, const TGGePoly2D &poly1, TDPtrList<TGGeCurveSegment> &ss1, TDPtrList<TGGeCurveSegment> &ss2, TDPtrList<TGGeCurveSegment> &ssOnEdge)
|
||
{
|
||
TGGePoly2D &poly = (TGGePoly2D &)poly1;
|
||
ASSERT(!!poly);
|
||
int len = ss.Length();
|
||
for (int i = 0; i < len; i++)
|
||
{
|
||
TGGeCurveSegment seg = ss[i];
|
||
seg.SetElevation(poly[0]->z); // Z坐标相等
|
||
|
||
TPointList pts(seg.GetStartPoint(), seg.GetEndPoint(), seg.GetBulge());
|
||
::Intersect(seg, poly, pts); // 先求出所有的交点,并排序
|
||
int listLen = pts.Length();
|
||
|
||
if (pts.curveType == CURVE_CIRCLE)
|
||
{
|
||
if (listLen <= 2)
|
||
{ // circle, but not cut to arcs
|
||
TADSGePoint3d mpt = seg.GetCircle().GetCenterPt();
|
||
if ((mpt&poly) == PR_INSIDE)
|
||
{
|
||
ss1.Append(new TGGeCurveSegment(ss[i]));
|
||
}
|
||
else
|
||
{
|
||
ss2.Append(new TGGeCurveSegment(ss[i]));
|
||
}
|
||
continue;
|
||
}
|
||
|
||
for (int i = 1; i < listLen; i++)
|
||
{
|
||
TADSGePoint3d pt2;
|
||
if (i == listLen - 1)
|
||
{
|
||
pt2 = *pts[1];
|
||
}
|
||
else
|
||
{
|
||
pt2 = *pts[i + 1];
|
||
}
|
||
|
||
TGGeArc arcSeg(pts.center, ads_distance(pts.center, *pts[i]), ads_angle(pts.center, *pts[i]), ads_angle(pts.center, pt2));
|
||
TADSGePoint3d mpt;
|
||
arcSeg.MidPoint(mpt);
|
||
|
||
TGGeCurveSegment *pCurve = new TGGeCurveSegment;
|
||
*pCurve = arcSeg;
|
||
|
||
int nPrFlag = (mpt&poly);
|
||
if (nPrFlag == PR_INSIDE)
|
||
{
|
||
ss1.Append(pCurve);
|
||
}
|
||
else if (nPrFlag == PR_OUTSIDE)
|
||
{
|
||
ss2.Append(pCurve);
|
||
}
|
||
else
|
||
{
|
||
ssOnEdge.Append(pCurve);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
for (int j = 0; j < listLen - 1; j++)
|
||
{ // arc and line
|
||
TADSGePoint3d &pt1 = *pts[j];
|
||
TADSGePoint3d &pt2 = *pts[j + 1];
|
||
if (pts.curveType == CURVE_LINE)
|
||
{
|
||
TGGeLine lineSeg(pt1, pt2);
|
||
TADSGePoint3d mpt = lineSeg.MidPoint();
|
||
TGGeCurveSegment *pCurve = new TGGeCurveSegment;
|
||
*pCurve = lineSeg;
|
||
|
||
int nPrFlag = (mpt&poly);
|
||
if (nPrFlag == PR_INSIDE)
|
||
{
|
||
ss1.Append(pCurve);
|
||
}
|
||
else if (nPrFlag == PR_OUTSIDE)
|
||
{
|
||
ss2.Append(pCurve);
|
||
}
|
||
else
|
||
{
|
||
ssOnEdge.Append(pCurve);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TGGeArc arcSeg(pts.center, ads_distance(pts.center, pt1), ads_angle(pts.center, pt1), ads_angle(pts.center, pt2));
|
||
TADSGePoint3d mpt;
|
||
arcSeg.MidPoint(mpt);
|
||
TADSGePoint3d cen = arcSeg.GetCenterPt();
|
||
TGGeCurveSegment *pCurve = new TGGeCurveSegment;
|
||
*pCurve = arcSeg;
|
||
int nPrFlag = (mpt&poly);
|
||
if (nPrFlag == PR_INSIDE)
|
||
{
|
||
ss1.Append(pCurve);
|
||
}
|
||
else if (nPrFlag == PR_OUTSIDE)
|
||
{
|
||
ss2.Append(pCurve);
|
||
}
|
||
else
|
||
{
|
||
ssOnEdge.Append(pCurve);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
// poly的坐标为当前UCS下的坐标
|
||
// ss1--inside; ss2--OnEdge and Outside
|
||
// Status: Only use in WCS
|
||
int TchExport2::PolyClip(TPickEntSet &ss, TGGePoly2D &poly, TPickEntSet &ss1, TPickEntSet &ss2)
|
||
{
|
||
TRBList mask(RTDXF0, _T("ARC,LINE,CIRCLE"), NULL);
|
||
ss.BaseFilter(mask);
|
||
long len = ss.Length();
|
||
for (long i = 0; i < len; i++)
|
||
{
|
||
TEntitySet ent = ss[i];
|
||
TGGeCurveSegment seg(ent);
|
||
seg.SetElevation(poly[0]->z); // Z坐标相等
|
||
|
||
TPointList pts(seg.GetStartPoint(), seg.GetEndPoint(), seg.GetBulge());
|
||
::Intersect(seg, poly, pts); // 先求出所有的交点,并排序
|
||
int listLen = pts.Length();
|
||
|
||
TEntitySet entRef = ent;
|
||
if (pts.curveType == CURVE_CIRCLE)
|
||
{
|
||
if (listLen <= 2)
|
||
{ // circle, but not cut to arcs
|
||
TADSGePoint3d mpt = seg.GetCircle().GetCenterPt();
|
||
if ((mpt&poly) == PR_INSIDE)
|
||
{
|
||
ss1 += ent;
|
||
}
|
||
else
|
||
{
|
||
ss2 += ent;
|
||
}
|
||
continue;
|
||
}
|
||
// 圆被裁为弧
|
||
TCHAR lay[80] = _T("0");
|
||
entRef.GetData(8, lay);
|
||
for (int i = 1; i < listLen; i++)
|
||
{
|
||
TADSGePoint3d pt2;
|
||
if (i == listLen - 1) pt2 = *pts[1];
|
||
else pt2 = *pts[i + 1];
|
||
TGGeArc arcSeg(pts.center, ads_distance(pts.center, *pts[i]), ads_angle(pts.center, *pts[i]),
|
||
ads_angle(pts.center, pt2));
|
||
TADSGePoint3d mpt;
|
||
arcSeg.MidPoint(mpt);
|
||
if (arcSeg.Make(lay) == RTNORM)
|
||
{
|
||
TEntitySet eL;
|
||
eL.GetLast();
|
||
if ((mpt&poly) == PR_INSIDE)
|
||
{
|
||
ss1 += eL;
|
||
}
|
||
else
|
||
{
|
||
ss2 += eL;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else for (int j = 0; j < listLen - 1; j++)
|
||
{ // arc and line
|
||
TADSGePoint3d &pt1 = *pts[j];
|
||
TADSGePoint3d &pt2 = *pts[j + 1];
|
||
if (pts.curveType == CURVE_LINE)
|
||
{
|
||
TGGeLine lineSeg(pt1, pt2);
|
||
TADSGePoint3d mpt = lineSeg.MidPoint();
|
||
if (lineSeg.MakeEntity(&entRef) == RTNORM)
|
||
{
|
||
TEntitySet eL;
|
||
eL.GetLast();
|
||
if ((mpt&poly) == PR_INSIDE)
|
||
{
|
||
ss1 += eL;
|
||
}
|
||
else
|
||
{
|
||
ss2 += eL;
|
||
}
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
TGGeArc arcSeg(pts.center, ads_distance(pts.center, pt1), ads_angle(pts.center, pt1), ads_angle(pts.center, pt2));
|
||
TADSGePoint3d mpt;
|
||
arcSeg.MidPoint(mpt);
|
||
TADSGePoint3d cen = arcSeg.GetCenterPt();
|
||
if (arcSeg.MakeEntity(&entRef) == RTNORM)
|
||
{
|
||
TEntitySet eL;
|
||
eL.GetLast();
|
||
if ((mpt&poly) == PR_INSIDE)
|
||
{
|
||
ss1 += eL;
|
||
}
|
||
else
|
||
{
|
||
ss2 += eL;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
ent.Delete();
|
||
}
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
// poly的坐标为当前UCS下的坐标
|
||
// ss1--inside; ss2--outSide, ss3--OnEdge
|
||
// Status: Only use in WCS
|
||
int TchExport2::PolyClip(TPickEntSet &ss, TGGePoly2D &poly, TPickEntSet &ss1, TPickEntSet &ss2, TPickEntSet &ss3)
|
||
{
|
||
TRBList mask(RTDXF0, _T("ARC,LINE,CIRCLE"), NULL);
|
||
ss.BaseFilter(mask);
|
||
long len = ss.Length();
|
||
for (long i = 0; i < len; i++)
|
||
{
|
||
TEntitySet ent = ss[i];
|
||
TGGeCurveSegment seg(ent);
|
||
seg.SetElevation(poly[0]->z); // Z坐标相等
|
||
|
||
TPointList pts(seg.GetStartPoint(), seg.GetEndPoint(), seg.GetBulge());
|
||
::Intersect(seg, poly, pts); // 先求出所有的交点,并排序
|
||
int listLen = pts.Length();
|
||
|
||
TEntitySet entRef = ent;
|
||
if (pts.curveType == CURVE_CIRCLE)
|
||
{
|
||
if (listLen <= 2)
|
||
{ // circle, but not cut to arcs
|
||
TADSGePoint3d mpt = seg.GetCircle().GetCenterPt();
|
||
if ((mpt&poly) == PR_INSIDE)
|
||
{
|
||
ss1 += ent;
|
||
}
|
||
else
|
||
{
|
||
ss2 += ent;
|
||
}
|
||
continue;
|
||
}
|
||
// 圆被裁为弧
|
||
TCHAR lay[80] = _T("0");
|
||
entRef.GetData(8, lay);
|
||
for (int i = 1; i < listLen; i++)
|
||
{
|
||
TADSGePoint3d pt2;
|
||
if (i == listLen - 1)
|
||
{
|
||
pt2 = *pts[1];
|
||
}
|
||
else
|
||
{
|
||
pt2 = *pts[i + 1];
|
||
}
|
||
|
||
TGGeArc arcSeg(pts.center, ads_distance(pts.center, *pts[i]), ads_angle(pts.center, *pts[i]), ads_angle(pts.center, pt2));
|
||
TADSGePoint3d mpt;
|
||
arcSeg.MidPoint(mpt);
|
||
if (arcSeg.Make(lay) == RTNORM)
|
||
{
|
||
TEntitySet eL;
|
||
eL.GetLast();
|
||
int nPrFlag = (mpt&poly);
|
||
if (nPrFlag == PR_INSIDE)
|
||
{
|
||
ss1 += eL;
|
||
}
|
||
else if (nPrFlag == PR_OUTSIDE)
|
||
{
|
||
ss2 += eL;
|
||
}
|
||
else
|
||
{
|
||
ss3 += eL;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else for (int j = 0; j < listLen - 1; j++)
|
||
{ // arc and line
|
||
TADSGePoint3d &pt1 = *pts[j];
|
||
TADSGePoint3d &pt2 = *pts[j + 1];
|
||
if (pts.curveType == CURVE_LINE)
|
||
{
|
||
TGGeLine lineSeg(pt1, pt2);
|
||
TADSGePoint3d mpt = lineSeg.MidPoint();
|
||
|
||
if (lineSeg.MakeEntity(&entRef) == RTNORM)
|
||
{
|
||
TEntitySet eL;
|
||
eL.GetLast();
|
||
int nPrFlag = (mpt&poly);
|
||
if (nPrFlag == PR_INSIDE)
|
||
{
|
||
ss1 += eL;
|
||
}
|
||
else if (nPrFlag == PR_OUTSIDE)
|
||
{
|
||
ss2 += eL;
|
||
}
|
||
else
|
||
{
|
||
ss3 += eL;
|
||
}
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
TGGeArc arcSeg(pts.center, ads_distance(pts.center, pt1), ads_angle(pts.center, pt1), ads_angle(pts.center, pt2));
|
||
TADSGePoint3d mpt;
|
||
arcSeg.MidPoint(mpt);
|
||
|
||
TADSGePoint3d cen = arcSeg.GetCenterPt();
|
||
if (arcSeg.MakeEntity(&entRef) == RTNORM)
|
||
{
|
||
TEntitySet eL;
|
||
eL.GetLast();
|
||
|
||
int nPrFlag = (mpt&poly);
|
||
if (nPrFlag == PR_INSIDE)
|
||
{
|
||
ss1 += eL;
|
||
}
|
||
else if (nPrFlag == PR_OUTSIDE)
|
||
{
|
||
ss2 += eL;
|
||
}
|
||
else
|
||
{
|
||
ss3 += eL;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
ent.Delete();
|
||
}
|
||
|
||
return RTNORM;
|
||
}
|
||
|
||
// 把区域分解为逆时针排列的XPoly2D
|
||
void TchExport2::Region2TGGePoly2D(const AcDbRegion *pClone, TGGePoly2D &poly2D)
|
||
{
|
||
// sg add 091119，临时将精确度改为g_globleSnap
|
||
TTempGeTol globleTol(g_globleSnap);
|
||
|
||
// 清空
|
||
poly2D.Reset();
|
||
|
||
// 将区域分解
|
||
Acad::ErrorStatus es = Acad::eOk;
|
||
AcDbVoidPtrArray arpCurve;
|
||
if ((es = pClone->explode(arpCurve)) != Acad::eOk)
|
||
{
|
||
return;
|
||
}
|
||
|
||
int nLen = arpCurve.length();
|
||
if (nLen < 1)
|
||
{
|
||
TchExport::ReleaseEntSet(arpCurve);
|
||
return;
|
||
}
|
||
|
||
// 求由一组曲线组成的边界，返回polyline线
|
||
AcDbVoidPtrArray arpResult;
|
||
AcDbCurve* pBound = ConvertCurves2Loops(arpCurve, arpResult);
|
||
if (pBound == NULL)
|
||
{
|
||
TchExport::ReleaseEntSet(arpCurve);
|
||
return;
|
||
}
|
||
|
||
AcRxClass *pClass = pBound->isA();
|
||
if (pClass == AcDbPolyline::desc())
|
||
{
|
||
// 将AcDbPolyline转化为XPoly2D
|
||
TchExport2::PolyConvert(*(AcDbPolyline *)pBound, poly2D);
|
||
}
|
||
|
||
TchExport::ReleaseEntSet(arpCurve);
|
||
if (pBound != NULL)
|
||
{
|
||
delete pBound;
|
||
}
|
||
|
||
// 设置闭合
|
||
poly2D.SetFlag(1);
|
||
}
|
||
|
||
// 布尔运算，与PolyBoolOper函数接口不变，但使用AcDbRegion::booleanOper函数，内部计算时，将标高设置为0
|
||
void TchExport2::RegionBoolOper(const TGGePoly2D &poly1, const TGGePoly2D &poly2, TDPtrList<TGGePoly2D> &lstResult, AcDb::BoolOperType operation)
|
||
{
|
||
// sg add 091119，临时将精确度改为g_globleSnap
|
||
TTempGeTol globleTol(g_globleSnap);
|
||
|
||
// 清空
|
||
lstResult.Reset();
|
||
|
||
TGGePoly2D pline1 = poly1,
|
||
pline2 = poly2;
|
||
|
||
// 强制设置PLine封闭
|
||
pline1.SetFlag(1);
|
||
pline2.SetFlag(1);
|
||
|
||
// 强制将标高设置为0
|
||
pline1.SetElevation(0.0);
|
||
pline2.SetElevation(0.0);
|
||
|
||
// 将PLine转化为Region
|
||
AcDbRegion *pRegion1 = pline1.AsRegion(),
|
||
*pRegion2 = pline2.AsRegion();
|
||
|
||
if (pRegion1 != NULL && pRegion2 != NULL)
|
||
{
|
||
// 对两区域进行布尔运算
|
||
if (pRegion1->booleanOper(operation, pRegion2) == Acad::eOk)
|
||
{
|
||
// 把区域分解为逆时针排列的XPoly2D
|
||
TGGePoly2D *pNewPoly = new TGGePoly2D(1);
|
||
TchExport2::Region2TGGePoly2D(pRegion1, *pNewPoly);
|
||
|
||
if (pNewPoly->Length() > 0)
|
||
{
|
||
lstResult.Append(pNewPoly);
|
||
}
|
||
else
|
||
{
|
||
delete pNewPoly;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (pRegion1 != NULL)
|
||
{
|
||
delete pRegion1;
|
||
}
|
||
|
||
if (pRegion2 != NULL)
|
||
{
|
||
delete pRegion2;
|
||
}
|
||
}
|
||
|
||
|
||
// 8.0先解决角度不大于MIN_PL_ANGEL的情况
|
||
// 自动处理封闭的XPoly2D，只处理外轮廓线
|
||
// 若某段长度不大于MIN_PL_DISTANCE，或者相临两段夹角不大于MIN_PL_ANGEL度，则自动减点
|
||
inline void TchExport2::AutoDelExPoly2DPt(TGGePoly2D &poly)
|
||
{
|
||
int nLen = poly.Length(); // 总点数
|
||
if (nLen < 3)
|
||
{
|
||
return;
|
||
}
|
||
|
||
TGGePoly2D dest(1); // 设置闭合
|
||
double dAngle = 0.0, // 以当前点为顶点，前后点连线为边的夹角
|
||
dBulge = 0.0; // 当前点应该有的Bulge值
|
||
|
||
BOOL bAdd2Dest = TRUE; // 标记是否将当前点添加到dest中
|
||
int nPrev(0), nNext(0); // 前、后点标号
|
||
TADSGePoint3d ptCur, ptPrev, ptNext;
|
||
|
||
for (int i = 0; i < nLen; i++)
|
||
{
|
||
bAdd2Dest = TRUE; // 标记是否将当前点添加到dest中
|
||
|
||
// 封闭路径，周期查找
|
||
nPrev = TchExport::DePeriod(nLen, i - 1);
|
||
nNext = TchExport::DePeriod(nLen, i + 1);
|
||
|
||
ptCur = *poly[i]; // 当前点
|
||
ptPrev = *poly[nPrev]; // 前一点
|
||
ptNext = *poly[nNext]; // 后一点
|
||
|
||
dBulge = poly.GetBulge(i); // 默认取当前点的Bulge值
|
||
|
||
AcGeVector3d vec1 = ptPrev.AsAcGePoint3d() - ptCur.AsAcGePoint3d(),
|
||
vec2 = ptNext.AsAcGePoint3d() - ptCur.AsAcGePoint3d();
|
||
|
||
dAngle = vec1.angleTo(vec2); // 角度在[0，PI]范围内
|
||
if (dAngle < MIN_PL_ANGEL + _angSnap) // 角度不大于1
|
||
{
|
||
double dPrevBulge = poly.GetBulge(nPrev);
|
||
if (fabs(dBulge) < _angSnap && fabs(dPrevBulge) < _angSnap)
|
||
{
|
||
bAdd2Dest = FALSE;
|
||
continue;
|
||
}
|
||
}
|
||
|
||
// 将当前点添加到dest中
|
||
if (bAdd2Dest)
|
||
{
|
||
dest.AppendNode(ptCur, dBulge);
|
||
}
|
||
}
|
||
|
||
poly.Reset();
|
||
poly = dest;
|
||
}
|
||
|
||
void TchExport2::GetGripPoints(const TGGePoly2D &poly, AcGePoint3dArray &gripPoints)
|
||
{
|
||
int nVertexCount = poly.Length();
|
||
for (int i = 0; i < nVertexCount; i++)
|
||
{
|
||
const TADSGePoint3d &pt = poly[i];
|
||
gripPoints.append(pt);
|
||
}
|
||
//边上的夹点
|
||
int nEdgeNum = poly.TotalSegments();
|
||
for (i = 0; i < nEdgeNum; i++)
|
||
{
|
||
TGGeCurveSegment seg;
|
||
poly.Nth(i, seg);
|
||
TADSGePoint3d ptMid = seg.MidPoint();
|
||
gripPoints.append(ptMid);
|
||
}
|
||
}
|
||
|
||
Acad::ErrorStatus TchExport2::MoveGripPointsAt(TGGePoly2D &poly, const AcDbIntArray& indices, const AcGeVector3d& offset)
|
||
{
|
||
int nVertexCount = poly.Length();
|
||
|
||
TADSGePoint3d vtOffset = *(TADSGePoint3d *)&offset;
|
||
vtOffset.z = 0;
|
||
|
||
for (int i = 0; i < indices.length(); i++)
|
||
{
|
||
int idx = indices[i];
|
||
if (idx < nVertexCount)
|
||
{ // Move vertex
|
||
*poly[idx] += vtOffset;
|
||
continue;
|
||
}
|
||
// Move Edge or Shape
|
||
int nEdgeIndex = idx - nVertexCount;
|
||
int nTotalEdge = poly.TotalSegments();
|
||
if (nEdgeIndex >= nTotalEdge)
|
||
{
|
||
return Acad::eInvalidInput;
|
||
}
|
||
|
||
//移动边
|
||
TGGeDirectionCurve cv;
|
||
poly.Nth(nEdgeIndex, cv);
|
||
ASSERT(!!cv);
|
||
if (cv.Is(CURVE_LINE))
|
||
{ // Move
|
||
TGGeLine ln = cv.GetLine();
|
||
ln.SetStartPoint(ln.GetStartPoint() + vtOffset);
|
||
ln.SetEndPoint(ln.GetEndPoint() + vtOffset);
|
||
ln.SetLineFlag(LS_INFINITE);
|
||
TGGeDirectionCurve prevSeg, nextSeg;
|
||
int nPrev = nEdgeIndex - 1, nNext = nEdgeIndex + 1;
|
||
if (poly.IsClosed())
|
||
{
|
||
nPrev = TchExport::DePeriod(nTotalEdge, nPrev);
|
||
nNext = TchExport::DePeriod(nTotalEdge, nNext);
|
||
}
|
||
|
||
TADSGePoint3d ptStart, ptEnd;
|
||
BOOL bUpdateIt = TRUE;
|
||
//更新起点
|
||
if (nPrev >= 0 && nPrev < nTotalEdge)
|
||
{
|
||
poly.Nth(nPrev, prevSeg);
|
||
prevSeg.SetLineFlag(LS_INFINITE);
|
||
TADSGePoint3d ptInt[2];
|
||
int nIntNum = prevSeg.Intersection(ln, ptInt[0], ptInt[1]);
|
||
if (nIntNum == 1)
|
||
{
|
||
ptStart = ptInt[0];
|
||
}
|
||
else if (nIntNum == 2)
|
||
{
|
||
ptStart = TGGeLine(ptInt[0], ptInt[1]).NearPoint(ln.GetStartPoint());
|
||
}
|
||
else
|
||
{
|
||
bUpdateIt = FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ptStart = *poly[nEdgeIndex] + vtOffset;
|
||
}
|
||
|
||
// 更新下一点
|
||
if (nNext >= 0 && nNext < nTotalEdge)
|
||
{
|
||
poly.Nth(nNext, nextSeg);
|
||
nextSeg.SetLineFlag(LS_INFINITE);
|
||
TADSGePoint3d ptInt[2];
|
||
int nIntNum = nextSeg.Intersection(ln, ptInt[0], ptInt[1]);
|
||
if (nIntNum == 1)
|
||
{
|
||
ptEnd = ptInt[0];
|
||
}
|
||
else if (nIntNum == 2)
|
||
{
|
||
ptEnd = TGGeLine(ptInt[0], ptInt[1]).NearPoint(ln.GetEndPoint());
|
||
}
|
||
else
|
||
{
|
||
bUpdateIt = FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ptEnd = *poly[nEdgeIndex + 1] + vtOffset;
|
||
}
|
||
|
||
if (bUpdateIt)
|
||
{
|
||
double nPrevBulge = 0.0, nNextBulge = 0.0;
|
||
if (fabs(prevSeg.GetBulge()) > 1.0E-5)
|
||
{
|
||
TGGeArc prevArc = prevSeg.GetArc();
|
||
double nAngBeg = ads_angle(prevArc.GetCenterPt(), prevSeg.GetStartPoint());
|
||
double nAngEnd = ads_angle(prevArc.GetCenterPt(), ptStart);
|
||
if (prevSeg.IsMinusArc())
|
||
{
|
||
nPrevBulge = -TchExport::AngleRangeTo2PI(nAngBeg - nAngEnd);
|
||
}
|
||
else
|
||
{
|
||
nPrevBulge = TchExport::AngleRangeTo2PI(nAngEnd - nAngBeg);
|
||
}
|
||
}
|
||
if (fabs(nextSeg.GetBulge()) > 1.0E-5)
|
||
{
|
||
TGGeArc nextArc = nextSeg.GetArc();
|
||
double nAngBeg = ads_angle(nextArc.GetCenterPt(), ptEnd);
|
||
double nAngEnd = ads_angle(nextArc.GetCenterPt(), nextSeg.GetEndPoint());
|
||
if (nextSeg.IsMinusArc())
|
||
{
|
||
nNextBulge = -TchExport::AngleRangeTo2PI(nAngBeg - nAngEnd);
|
||
}
|
||
else
|
||
{
|
||
nNextBulge = TchExport::AngleRangeTo2PI(nAngEnd - nAngBeg);
|
||
}
|
||
}
|
||
|
||
*poly[nEdgeIndex] = ptStart;
|
||
if (nNext >= 0 && nNext < poly.Length())
|
||
{
|
||
*poly[nNext] = ptEnd;
|
||
poly.SetBulge(nNext, nNextBulge);
|
||
}
|
||
if (nPrev >= 0 && nPrev < poly.Length())
|
||
{
|
||
poly.SetBulge(nPrev, nPrevBulge);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{ // Change Arc Segment--bulge
|
||
TADSGePoint3d ptMid = cv.MidPoint();
|
||
TADSGePoint3d ptMidNew = ptMid + vtOffset;
|
||
TGGeArc arNew(cv.GetStartPoint(), ptMidNew, cv.GetEndPoint());
|
||
if (!!arNew)
|
||
{ //新的弧有效
|
||
TGGeCurveSegment cvLine(cv.GetStartPoint(), cv.GetEndPoint(), 0.0);
|
||
int nSideOld = cvLine.OnWhichSide(ptMid);
|
||
int nSideNew = cvLine.OnWhichSide(ptMidNew);
|
||
double dSignal = cv.GetBulge() / fabs(cv.GetBulge());
|
||
if (nSideOld == nSideNew)
|
||
{
|
||
poly.SetBulge(nEdgeIndex, dSignal * arNew.Bulge());
|
||
}
|
||
else
|
||
{
|
||
poly.SetBulge(nEdgeIndex, -dSignal * arNew.Bulge());
|
||
}
|
||
}
|
||
}
|
||
}
|
||
poly.Compress(false);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
inline void TchExport2::GetGripPoints(const TGGePoly2D &poly, const AcGeVector3d &normal, AcGePoint3dArray &gripPoints)
|
||
{
|
||
int nVertexCount = poly.Length();
|
||
for (int i = 0; i < nVertexCount; i++)
|
||
{
|
||
const TADSGePoint3d &pt = poly[i];
|
||
gripPoints.append(Ecs2Wcs(pt, normal).AsAcGePoint3d());
|
||
}
|
||
//边上的夹点
|
||
int nEdgeNum = poly.TotalSegments();
|
||
for (i = 0; i < nEdgeNum; i++)
|
||
{
|
||
TGGeCurveSegment seg;
|
||
poly.Nth(i, seg);
|
||
TADSGePoint3d ptMid = seg.MidPoint();
|
||
gripPoints.append(Ecs2Wcs(ptMid, normal).AsAcGePoint3d());
|
||
}
|
||
}
|
||
|
||
Acad::ErrorStatus TchExport2::MoveGripPointsAt(TGGePoly2D &polyPath,
|
||
const AcGeVector3d &vtNormal,
|
||
const AcDbIntArray& indices,
|
||
const AcGeVector3d& offset)
|
||
{
|
||
int nVertexCount = polyPath.Length();
|
||
|
||
TADSGePoint3d vtOffset = Wcs2Ecs(*(TADSGePoint3d *)&offset, vtNormal);
|
||
for (int i = 0; i < indices.length(); i++)
|
||
{
|
||
int idx = indices[i];
|
||
if (idx < nVertexCount)
|
||
{ // Move vertex
|
||
*polyPath[idx] += vtOffset;
|
||
}
|
||
else
|
||
{ // Move Edge or Shape
|
||
TGGePoly2D poly2d(polyPath);
|
||
poly2d.SetElevation(0.0);
|
||
|
||
int nEdgeIndex = idx - nVertexCount;
|
||
int nTotalEdge = poly2d.TotalSegments();
|
||
if (nEdgeIndex < nTotalEdge)
|
||
{ //移动边
|
||
TGGeDirectionCurve cv;
|
||
poly2d.Nth(nEdgeIndex, cv);
|
||
ASSERT(!!cv);
|
||
if (cv.Is(CURVE_LINE))
|
||
{ // Move
|
||
TGGeLine ln = cv.GetLine();
|
||
ln.SetStartPoint(ln.GetStartPoint() + vtOffset);
|
||
ln.SetEndPoint(ln.GetEndPoint() + vtOffset);
|
||
ln.SetLineFlag(LS_INFINITE);
|
||
TGGeDirectionCurve prevSeg, nextSeg;
|
||
int nPrev = nEdgeIndex - 1, nNext = nEdgeIndex + 1;
|
||
if (poly2d.IsClosed())
|
||
{
|
||
nPrev = TchExport::DePeriod(nTotalEdge, nPrev);
|
||
nNext = TchExport::DePeriod(nTotalEdge, nNext);
|
||
}
|
||
|
||
TADSGePoint3d ptStart, ptEnd;
|
||
BOOL bUpdateIt = TRUE;
|
||
//更新起点
|
||
if (nPrev >= 0 && nPrev < nTotalEdge)
|
||
{
|
||
poly2d.Nth(nPrev, prevSeg);
|
||
prevSeg.SetLineFlag(LS_INFINITE);
|
||
TADSGePoint3d ptInt[2];
|
||
int nIntNum = prevSeg.Intersection(ln, ptInt[0], ptInt[1]);
|
||
if (nIntNum == 1)
|
||
{
|
||
ptStart = ptInt[0];
|
||
}
|
||
else if (nIntNum == 2)
|
||
{
|
||
ptStart = TGGeLine(ptInt[0], ptInt[1]).NearPoint(ln.GetStartPoint());
|
||
}
|
||
else
|
||
{
|
||
bUpdateIt = FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ptStart = *poly2d[nEdgeIndex] + vtOffset;
|
||
}
|
||
|
||
// 更新下一点
|
||
if (nNext >= 0 && nNext < nTotalEdge)
|
||
{
|
||
poly2d.Nth(nNext, nextSeg);
|
||
nextSeg.SetLineFlag(LS_INFINITE);
|
||
TADSGePoint3d ptInt[2];
|
||
int nIntNum = nextSeg.Intersection(ln, ptInt[0], ptInt[1]);
|
||
if (nIntNum == 1)
|
||
{
|
||
ptEnd = ptInt[0];
|
||
}
|
||
else if (nIntNum == 2)
|
||
{
|
||
ptEnd = TGGeLine(ptInt[0], ptInt[1]).NearPoint(ln.GetEndPoint());
|
||
}
|
||
else
|
||
{
|
||
bUpdateIt = FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ptEnd = *poly2d[nEdgeIndex + 1] + vtOffset;
|
||
}
|
||
|
||
if (bUpdateIt)
|
||
{
|
||
double nPrevBulge = 0.0, nNextBulge = 0.0;
|
||
if (fabs(prevSeg.GetBulge()) > 1.0E-5)
|
||
{
|
||
TGGeArc prevArc = prevSeg.GetArc();
|
||
double nAngBeg = ads_angle(prevArc.GetCenterPt(), prevSeg.GetStartPoint());
|
||
double nAngEnd = ads_angle(prevArc.GetCenterPt(), ptStart);
|
||
if (prevSeg.IsMinusArc())
|
||
{
|
||
nPrevBulge = -TchExport::AngleRangeTo2PI(nAngBeg - nAngEnd);
|
||
}
|
||
else
|
||
{
|
||
nPrevBulge = TchExport::AngleRangeTo2PI(nAngEnd - nAngBeg);
|
||
}
|
||
}
|
||
if (fabs(nextSeg.GetBulge()) > 1.0E-5)
|
||
{
|
||
TGGeArc nextArc = nextSeg.GetArc();
|
||
double nAngBeg = ads_angle(nextArc.GetCenterPt(), ptEnd);
|
||
double nAngEnd = ads_angle(nextArc.GetCenterPt(), nextSeg.GetEndPoint());
|
||
if (nextSeg.IsMinusArc())
|
||
{
|
||
nNextBulge = -TchExport::AngleRangeTo2PI(nAngBeg - nAngEnd);
|
||
}
|
||
else
|
||
{
|
||
nNextBulge = TchExport::AngleRangeTo2PI(nAngEnd - nAngBeg);
|
||
}
|
||
}
|
||
|
||
*poly2d[nEdgeIndex] = ptStart;
|
||
if (nNext >= 0 && nNext < poly2d.Length())
|
||
{
|
||
*poly2d[nNext] = ptEnd;
|
||
poly2d.SetBulge(nNext, nNextBulge);
|
||
}
|
||
if (nPrev >= 0 && nPrev < poly2d.Length())
|
||
{
|
||
poly2d.SetBulge(nPrev, nPrevBulge);
|
||
}
|
||
|
||
}
|
||
|
||
}
|
||
else
|
||
{ // Change Arc Segment--bulge
|
||
TADSGePoint3d ptMid = cv.MidPoint();
|
||
TADSGePoint3d ptMidNew = ptMid + vtOffset;
|
||
TGGeArc arNew(cv.GetStartPoint(), ptMidNew, cv.GetEndPoint());
|
||
if (!!arNew)
|
||
{ //新的弧有效
|
||
TGGeCurveSegment cvLine(cv.GetStartPoint(), cv.GetEndPoint(), 0.0);
|
||
int nSideOld = cvLine.OnWhichSide(ptMid);
|
||
int nSideNew = cvLine.OnWhichSide(ptMidNew);
|
||
double dSignal = cv.GetBulge() / fabs(cv.GetBulge());
|
||
if (nSideOld == nSideNew)
|
||
{
|
||
poly2d.SetBulge(nEdgeIndex, dSignal * arNew.Bulge());
|
||
}
|
||
else
|
||
{
|
||
poly2d.SetBulge(nEdgeIndex, -dSignal * arNew.Bulge());
|
||
}
|
||
}
|
||
}
|
||
|
||
for (int n = 0; n < poly2d.Length(); n++)
|
||
{
|
||
poly2d[n]->z = polyPath[n]->z;
|
||
}
|
||
polyPath = poly2d;
|
||
}
|
||
}
|
||
}
|
||
polyPath.Compress(false);
|
||
return Acad::eOk;
|
||
}
|
||
|
||
inline Acad::ErrorStatus TchExport2::GetGripText(const TGGePoly2D&poly, int idx, CString &cs)
|
||
{
|
||
Acad::ErrorStatus es = Acad::eNotApplicable;
|
||
|
||
int nVertexCount = poly.Length();
|
||
if (idx < nVertexCount)
|
||
{ // Move vertex
|
||
cs.Format(_T("移动第%d个顶点"), idx + 1);
|
||
es = Acad::eOk;
|
||
}
|
||
else
|
||
{ // Move Edge or Shape
|
||
int nEdgeIndex = idx - nVertexCount;
|
||
int nTotalEdge = poly.TotalSegments();
|
||
if (nEdgeIndex < nTotalEdge)
|
||
{ //移动边
|
||
cs.Format(_T("移动第%d条边"), nEdgeIndex + 1);
|
||
es = Acad::eOk;
|
||
}
|
||
}
|
||
return es;
|
||
}
|
||
|
||
#if ADS>15
|
||
void TchExport2::CreateGrip(TEntityBase* pThis, TGGePoly2D& poly, int iFirst)
|
||
{
|
||
TGGePoly2D&m_polyBase = poly;
|
||
//节点
|
||
for (long i = 0; i < m_polyBase.Length(); i++)
|
||
{
|
||
if (m_polyBase.IsClosed() || i > 0)//有前段
|
||
{
|
||
bool bPreArc = fabs(m_polyBase.GetBulge((i - 1 + m_polyBase.Length()) % m_polyBase.Length())) > 1E-5;//前段是否为弧段
|
||
if (!bPreArc)//直段
|
||
{
|
||
pThis->GetGrip(i + iFirst)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimResultantLength));//长度
|
||
}
|
||
else//弧段
|
||
{
|
||
pThis->GetGrip(i + iFirst)->AppendDim(new TDbGripAngleDim(AcDbDimData::kDimResultantAngle));//包络角度[0,360)
|
||
}
|
||
}
|
||
|
||
if (m_polyBase.IsClosed() || i < m_polyBase.Length() - 1)//有后段
|
||
{
|
||
bool bNextArc = fabs(m_polyBase.GetBulge(i % m_polyBase.Length())) > 1E-5;//后段的是否为弧段
|
||
if (!bNextArc)//直段
|
||
{
|
||
pThis->GetGrip(i + iFirst)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimResultantLength));//长度
|
||
}
|
||
else//弧段
|
||
{
|
||
pThis->GetGrip(i + iFirst)->AppendDim(new TDbGripAngleDim(AcDbDimData::kDimResultantAngle));//包络角度[0,360)
|
||
}
|
||
}
|
||
|
||
if (m_polyBase.IsClosed() || i > 0)//有前段
|
||
{
|
||
bool bPreArc = fabs(m_polyBase.GetBulge((i - 1 + m_polyBase.Length()) % m_polyBase.Length())) > 1E-5;//前段是否为弧段
|
||
if (!bPreArc)//直段
|
||
{
|
||
pThis->GetGrip(i + iFirst)->AppendDim(new TDbGripAngleDim(AcDbDimData::kDimResultantAngle));//角度[0,180]
|
||
}
|
||
else//弧段
|
||
{
|
||
pThis->GetGrip(i + iFirst)->AppendDim(new TDbGripAngleDim(AcDbDimData::kDimResultantAngle));//前弧终止角度[0,180]
|
||
}
|
||
}
|
||
|
||
if (m_polyBase.IsClosed() || i < m_polyBase.Length() - 1)//有后段
|
||
{
|
||
bool bNextArc = fabs(m_polyBase.GetBulge(i % m_polyBase.Length())) > 1E-5;//后段的是否为弧段
|
||
if (!bNextArc)//直段
|
||
{
|
||
pThis->GetGrip(i + iFirst)->AppendDim(new TDbGripAngleDim(AcDbDimData::kDimResultantAngle));//角度[0,180]
|
||
}
|
||
else//弧段
|
||
{
|
||
pThis->GetGrip(i + iFirst)->AppendDim(new TDbGripAngleDim(AcDbDimData::kDimResultantAngle));//后弧起始角度[0,180]
|
||
}
|
||
}
|
||
}
|
||
|
||
//边中点
|
||
for (i = 0; i < m_polyBase.TotalSegments(); i++)
|
||
{
|
||
bool bArc = fabs(m_polyBase.GetBulge(i)) > 1E-5;//是否弧边
|
||
long iSeg = i + m_polyBase.Length();
|
||
if (bArc)
|
||
{
|
||
pThis->GetGrip(iSeg + iFirst)->AppendDim(new TDbGripRadiusDim(AcDbDimData::kDimRadius));//半径
|
||
pThis->GetGrip(iSeg + iFirst)->AppendDim(new TDbGripAngleDim(AcDbDimData::kDimResultantAngle));//包络角度[0,360)
|
||
}
|
||
else
|
||
{
|
||
pThis->GetGrip(iSeg + iFirst)->AppendDim(new TDbGripDistDim(AcDbDimData::kDimDeltaLength, false));//偏移
|
||
}
|
||
}
|
||
}
|
||
|
||
Acad::ErrorStatus TchExport2::EntityToDim(TEntityBase* pThis, TGGePoly2D polyPath, long iGrip, long iDim, int iFirst)
|
||
{
|
||
TDbGripDim *pDim = pThis->GetGripDim(iGrip, iDim);
|
||
if (pDim == NULL)
|
||
{
|
||
return Acad::eInvalidInput;
|
||
}
|
||
|
||
iGrip -= iFirst;
|
||
TGGePoly2D m_polyBase;
|
||
AcGeVector3d normal;
|
||
pThis->GetPathPoly(m_polyBase, normal);
|
||
TADSGePoint3d ptLow, ptUp;
|
||
polyPath.GetExtend(ptLow, ptUp);
|
||
//中点
|
||
if (iGrip >= polyPath.Length())
|
||
{
|
||
int nPos = iGrip - polyPath.Length();
|
||
TGGeDirectionCurve seg;
|
||
polyPath.Nth(nPos, seg);
|
||
bool bArc = fabs(polyPath.GetBulge(nPos)) > 1E-5;//是否为弧段
|
||
if (!bArc)//直段
|
||
{
|
||
switch (iDim)
|
||
{
|
||
case 0:
|
||
{
|
||
TDbGripDistDim* pDistDim = (TDbGripDistDim*)pDim;
|
||
TGGeDirectionCurve seg1;
|
||
m_polyBase.Nth(nPos, seg1);
|
||
|
||
TADSGePoint3d pt;
|
||
seg1.ProjectToMe(seg.MidPoint().AsAcGePoint3d(), pt);
|
||
pDistDim->SetData(pt.AsAcGePoint3d(), seg.MidPoint().AsAcGePoint3d(), 0);
|
||
}
|
||
break;
|
||
default:
|
||
return Acad::eNotImplementedYet;
|
||
}
|
||
}
|
||
else//弧段
|
||
{
|
||
switch (iDim)
|
||
{
|
||
case 0:
|
||
{
|
||
TDbGripRadiusDim* pRadiusDim = (TDbGripRadiusDim*)pDim;
|
||
pRadiusDim->SetData(seg.GetArc().GetCenterPt().AsAcGePoint3d(), seg.MidPoint().AsAcGePoint3d());
|
||
}
|
||
break;
|
||
case 1:
|
||
{
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
if (seg.GetBulge() < 0)
|
||
{
|
||
seg.Reverse();
|
||
}
|
||
pAngleDim->SetData(seg);
|
||
}
|
||
break;
|
||
default:
|
||
return Acad::eNotImplementedYet;
|
||
}
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
// 端点
|
||
bool bPre = polyPath.IsClosed() || iGrip > 0;
|
||
int nPre = (iGrip - 1 + polyPath.Length()) % polyPath.Length();
|
||
|
||
TGGeDirectionCurve segPre;
|
||
polyPath.Nth(nPre, segPre);
|
||
|
||
AcGeVector2d vtPre = segPre.Direction3d().AsAcGeVector2d();
|
||
bool bPreArc = fabs(polyPath.GetBulge(nPre)) > 1E-5;//前段是否为弧段
|
||
|
||
bool bNext = polyPath.IsClosed() || iGrip < polyPath.Length() - 1;
|
||
int nNext = iGrip % polyPath.Length();
|
||
|
||
TGGeDirectionCurve segNext;
|
||
polyPath.Nth(nNext, segNext);
|
||
|
||
AcGeVector2d vtNext = segNext.Direction3d().AsAcGeVector2d();
|
||
bool bNextArc = fabs(polyPath.GetBulge(nNext)) > 1E-5;//后段的是否为弧段
|
||
|
||
if (bPre && bNext)
|
||
{// 有前段有后段
|
||
switch (iDim)
|
||
{
|
||
case 0:
|
||
{
|
||
if (!bPreArc)//长度
|
||
{
|
||
TDbGripDistDim* pDistDim = (TDbGripDistDim*)pDim;
|
||
double dGrip = vtPre.angle() - vtNext.angle();
|
||
if (dGrip < -1E-6)
|
||
{
|
||
dGrip += 2 * PI;
|
||
}
|
||
|
||
if (dGrip > 0 && dGrip < PI)
|
||
{
|
||
segPre.Reverse();
|
||
}
|
||
pDistDim->SetData(segPre.GetStartPoint().AsAcGePoint3d(), segPre.GetEndPoint().AsAcGePoint3d());
|
||
}
|
||
else//包络角度
|
||
{
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
if (segPre.GetBulge() < 0)
|
||
{
|
||
segPre.Reverse();
|
||
}
|
||
pAngleDim->SetData(segPre);
|
||
}
|
||
}
|
||
break;
|
||
case 1:
|
||
{
|
||
if (!bNextArc)//长度
|
||
{
|
||
TDbGripDistDim* pDistDim = (TDbGripDistDim*)pDim;
|
||
double dGrip = vtPre.angle() - vtNext.angle();
|
||
if (dGrip < -1E-6)
|
||
{
|
||
dGrip += 2 * PI;
|
||
}
|
||
|
||
if (dGrip > 0 && dGrip < PI)
|
||
{
|
||
segNext.Reverse();
|
||
}
|
||
pDistDim->SetData(segNext.GetStartPoint().AsAcGePoint3d(), segNext.GetEndPoint().AsAcGePoint3d());
|
||
}
|
||
else//包络角度
|
||
{
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
if (segNext.GetBulge() < 0)
|
||
{
|
||
segNext.Reverse();
|
||
}
|
||
pAngleDim->SetData(segNext);
|
||
}
|
||
}
|
||
break;
|
||
case 2:
|
||
{
|
||
if (!bPreArc)//角度
|
||
{
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
TADSGePoint3d ptEnd = segPre.GetStartPoint() + TADSGePoint3d(1000, 0, 0);
|
||
pAngleDim->SetData(segPre.GetStartPoint().AsAcGePoint3d(), segPre.GetEndPoint().AsAcGePoint3d(), ptEnd.AsAcGePoint3d());
|
||
}
|
||
else//前弧终止角度
|
||
{
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
TGGeArc arc = segPre.GetArc();
|
||
TADSGePoint3d ptHorz = arc.GetCenterPt() + TADSGePoint3d(arc.GetRadius(), 0, 0);
|
||
pAngleDim->SetData(arc.GetCenterPt().AsAcGePoint3d(), segPre.GetEndPoint().AsAcGePoint3d(), ptHorz.AsAcGePoint3d());
|
||
}
|
||
}
|
||
break;
|
||
case 3:
|
||
{
|
||
if (!bNextArc)//角度
|
||
{
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
TADSGePoint3d ptEnd = segNext.GetEndPoint() + TADSGePoint3d(1000, 0, 0);
|
||
pAngleDim->SetData(segNext.GetEndPoint().AsAcGePoint3d(), segNext.GetStartPoint().AsAcGePoint3d(), ptEnd.AsAcGePoint3d());
|
||
}
|
||
else//前弧终止角度
|
||
{
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
TGGeArc arc = segNext.GetArc();
|
||
TADSGePoint3d ptHorz = arc.GetCenterPt() + TADSGePoint3d(arc.GetRadius(), 0, 0);
|
||
pAngleDim->SetData(arc.GetCenterPt().AsAcGePoint3d(), segNext.GetStartPoint().AsAcGePoint3d(), ptHorz.AsAcGePoint3d());
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
return Acad::eNotImplementedYet;
|
||
}
|
||
}
|
||
else if (bPre && !bNext)
|
||
{// 有前段无后段
|
||
switch (iDim)
|
||
{
|
||
case 0:
|
||
{
|
||
if (!bPreArc)
|
||
{//长度
|
||
TDbGripDistDim* pDistDim = (TDbGripDistDim*)pDim;
|
||
if (segPre.Direction3d().y >= 0)
|
||
{
|
||
pDistDim->SetData(segPre.GetEndPoint().AsAcGePoint3d(), segPre.GetStartPoint().AsAcGePoint3d());
|
||
}
|
||
else
|
||
{
|
||
pDistDim->SetData(segPre.GetStartPoint().AsAcGePoint3d(), segPre.GetEndPoint().AsAcGePoint3d());
|
||
}
|
||
}
|
||
else
|
||
{//包络角度
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
if (segPre.GetBulge() < 0)
|
||
{
|
||
segPre.Reverse();
|
||
}
|
||
pAngleDim->SetData(segPre);
|
||
}
|
||
}
|
||
break;
|
||
case 1:
|
||
{
|
||
if (!bPreArc)
|
||
{//角度
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
TADSGePoint3d ptEnd = segPre.GetStartPoint() + TADSGePoint3d(1000, 0, 0);
|
||
pAngleDim->SetData(segPre.GetStartPoint().AsAcGePoint3d(), segPre.GetEndPoint().AsAcGePoint3d(), ptEnd.AsAcGePoint3d());
|
||
}
|
||
else
|
||
{//后弧起始角度
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
TGGeArc arc = segPre.GetArc();
|
||
TADSGePoint3d ptHorz = arc.GetCenterPt() + TADSGePoint3d(arc.GetRadius(), 0, 0);
|
||
pAngleDim->SetData(arc.GetCenterPt().AsAcGePoint3d(), segPre.GetEndPoint().AsAcGePoint3d(), ptHorz.AsAcGePoint3d());
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
return Acad::eNotImplementedYet;
|
||
}
|
||
}
|
||
else if (!bPre && bNext)
|
||
{// 无前段有后段
|
||
switch (iDim)
|
||
{
|
||
case 0:
|
||
{
|
||
if (!bNextArc)
|
||
{//长度
|
||
TDbGripDistDim* pDistDim = (TDbGripDistDim*)pDim;
|
||
if (segNext.Direction3d().y >= 0)
|
||
{
|
||
pDistDim->SetData(segNext.GetEndPoint().AsAcGePoint3d(), segNext.GetStartPoint().AsAcGePoint3d());
|
||
}
|
||
else
|
||
{
|
||
pDistDim->SetData(segNext.GetStartPoint().AsAcGePoint3d(), segNext.GetEndPoint().AsAcGePoint3d());
|
||
}
|
||
}
|
||
else
|
||
{//包络角度
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
if (segNext.GetBulge() < 0)
|
||
{
|
||
segNext.Reverse();
|
||
}
|
||
pAngleDim->SetData(segNext);
|
||
}
|
||
}
|
||
break;
|
||
case 1:
|
||
{
|
||
if (!bNextArc)
|
||
{//角度
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
TADSGePoint3d ptEnd = segNext.GetEndPoint() + TADSGePoint3d(1000, 0, 0);
|
||
pAngleDim->SetData(segNext.GetEndPoint().AsAcGePoint3d(), segNext.GetStartPoint().AsAcGePoint3d(), ptEnd.AsAcGePoint3d());
|
||
}
|
||
else
|
||
{//后弧起始角度
|
||
TDbGripAngleDim* pAngleDim = (TDbGripAngleDim*)pDim;
|
||
TGGeArc arc = segNext.GetArc();
|
||
TADSGePoint3d ptHorz = arc.GetCenterPt() + TADSGePoint3d(arc.GetRadius(), 0, 0);
|
||
pAngleDim->SetData(arc.GetCenterPt().AsAcGePoint3d(), segNext.GetStartPoint().AsAcGePoint3d(), ptHorz.AsAcGePoint3d());
|
||
}
|
||
}
|
||
break;
|
||
default:
|
||
return Acad::eNotImplementedYet;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return Acad::eNotImplementedYet;
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
|
||
Acad::ErrorStatus TchExport2::DimToEntity(TEntityBase* pThis, TGGePoly2D &m_polyBase, long iGrip, long iDim, double newValue, const AcGeVector3d& offset, int iFirst)
|
||
{
|
||
AcGePoint3d ptNew = pThis->GetGripPoint(iGrip) + offset;
|
||
|
||
iGrip -= iFirst;
|
||
//中点
|
||
if (iGrip >= m_polyBase.Length())
|
||
{
|
||
int nPos = iGrip - m_polyBase.Length();
|
||
bool bArc = fabs(m_polyBase.GetBulge(nPos)) > 1E-5;//是否为弧段
|
||
if (!bArc)//直段
|
||
{
|
||
switch (iDim)
|
||
{
|
||
case 0://偏移
|
||
{
|
||
TGGePoly2D poly2d(m_polyBase);
|
||
poly2d.SetElevation(0.0);
|
||
|
||
int nTotalEdge = poly2d.TotalSegments();
|
||
TGGeDirectionCurve seg;
|
||
poly2d.Nth(nPos, seg);
|
||
|
||
AcGeVector3d vtOffset = offset;
|
||
vtOffset.normalize();
|
||
|
||
double dAngle = vtOffset.angleTo(seg.Direction3d().AsAcGeVector3d());
|
||
vtOffset *= newValue / sin(dAngle);
|
||
|
||
if (seg.OnWhichSide(ptNew) == 0)
|
||
{//左边
|
||
newValue *= -1;
|
||
}
|
||
|
||
TGGeLine ln = seg.GetLine();
|
||
ln = ln.Offset(newValue);
|
||
ln.SetLineFlag(LS_INFINITE);
|
||
|
||
TGGeDirectionCurve prevSeg, nextSeg;
|
||
int nPrev = nPos - 1;
|
||
int nNext = nPos + 1;
|
||
|
||
if (poly2d.IsClosed())
|
||
{
|
||
nPrev = TchExport::DePeriod(nTotalEdge, nPrev);
|
||
nNext = TchExport::DePeriod(nTotalEdge, nNext);
|
||
}
|
||
|
||
TADSGePoint3d ptStart, ptEnd;
|
||
BOOL bUpdateIt = TRUE;
|
||
//更新起点
|
||
if (nPrev >= 0 && nPrev < nTotalEdge)
|
||
{
|
||
poly2d.Nth(nPrev, prevSeg);
|
||
prevSeg.SetLineFlag(LS_INFINITE);
|
||
|
||
TADSGePoint3d ptInt[2];
|
||
int nIntNum = prevSeg.Intersection(ln, ptInt[0], ptInt[1]);
|
||
if (nIntNum == 1)
|
||
{
|
||
ptStart = ptInt[0];
|
||
}
|
||
else if (nIntNum == 2)
|
||
{
|
||
ptStart = TGGeLine(ptInt[0], ptInt[1]).NearPoint(ln.GetStartPoint());
|
||
}
|
||
else
|
||
{
|
||
bUpdateIt = FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ptStart = *poly2d[nPos] + vtOffset;
|
||
}
|
||
|
||
// 更新下一点
|
||
if (nNext >= 0 && nNext < nTotalEdge)
|
||
{
|
||
poly2d.Nth(nNext, nextSeg);
|
||
nextSeg.SetLineFlag(LS_INFINITE);
|
||
|
||
TADSGePoint3d ptInt[2];
|
||
int nIntNum = nextSeg.Intersection(ln, ptInt[0], ptInt[1]);
|
||
if (nIntNum == 1)
|
||
{
|
||
ptEnd = ptInt[0];
|
||
}
|
||
else if (nIntNum == 2)
|
||
{
|
||
ptEnd = TGGeLine(ptInt[0], ptInt[1]).NearPoint(ln.GetEndPoint());
|
||
}
|
||
else
|
||
{
|
||
bUpdateIt = FALSE;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
ptEnd = *poly2d[nPos + 1] + vtOffset;
|
||
}
|
||
|
||
if (bUpdateIt)
|
||
{
|
||
double nPrevBulge = 0.0, nNextBulge = 0.0;
|
||
if (fabs(prevSeg.GetBulge()) > 1.0E-5)
|
||
{
|
||
TGGeArc prevArc = prevSeg.GetArc();
|
||
double nAngBeg = ads_angle(prevArc.GetCenterPt(), prevSeg.GetStartPoint());
|
||
double nAngEnd = ads_angle(prevArc.GetCenterPt(), ptStart);
|
||
if (prevSeg.IsMinusArc())
|
||
{
|
||
nPrevBulge = -TchExport::AngleRangeTo2PI(nAngBeg - nAngEnd);
|
||
}
|
||
else
|
||
{
|
||
nPrevBulge = TchExport::AngleRangeTo2PI(nAngEnd - nAngBeg);
|
||
}
|
||
}
|
||
if (fabs(nextSeg.GetBulge()) > 1.0E-5)
|
||
{
|
||
TGGeArc nextArc = nextSeg.GetArc();
|
||
double nAngBeg = ads_angle(nextArc.GetCenterPt(), ptEnd);
|
||
double nAngEnd = ads_angle(nextArc.GetCenterPt(), nextSeg.GetEndPoint());
|
||
if (nextSeg.IsMinusArc())
|
||
{
|
||
nNextBulge = -TchExport::AngleRangeTo2PI(nAngBeg - nAngEnd);
|
||
}
|
||
else
|
||
{
|
||
nNextBulge = TchExport::AngleRangeTo2PI(nAngEnd - nAngBeg);
|
||
}
|
||
}
|
||
|
||
*poly2d[nPos] = ptStart;
|
||
if (nNext >= 0 && nNext < poly2d.Length())
|
||
{
|
||
*poly2d[nNext] = ptEnd;
|
||
poly2d.SetBulge(nNext, nNextBulge);
|
||
}
|
||
if (nPrev >= 0 && nPrev < poly2d.Length())
|
||
{
|
||
poly2d.SetBulge(nPrev, nPrevBulge);
|
||
}
|
||
|
||
for (int n = 0; n < poly2d.Length(); n++)
|
||
{
|
||
poly2d[n]->z = m_polyBase[n]->z;
|
||
}
|
||
|
||
m_polyBase = poly2d;
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
TGGeDirectionCurve seg;
|
||
m_polyBase.Nth(nPos, seg);
|
||
switch (iDim)
|
||
{
|
||
case 0://半径
|
||
{
|
||
TGGeCurveSegment line(seg.GetStartPoint(), seg.GetEndPoint(), 0);
|
||
double len = line.GetLength();
|
||
if (newValue < 0.5 * len)
|
||
{
|
||
return Acad::eInvalidInput;
|
||
}
|
||
|
||
newValue = 2.0 * asin(len* 0.5 / newValue);
|
||
TADSGePoint3d ptMid = seg.MidPoint();
|
||
if (ptMid.Distance2d(ptNew) > len / 2)
|
||
{
|
||
newValue = 2.0 * PI - newValue;
|
||
}
|
||
}
|
||
case 1://包络角
|
||
{
|
||
seg.SetBulge(0);
|
||
if (seg.OnWhichSide(ptNew) == 0)
|
||
{//左边
|
||
newValue *= -1;
|
||
}
|
||
|
||
m_polyBase.SetBulge(nPos, newValue);
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
return Acad::eOk;
|
||
}
|
||
|
||
// 端点
|
||
bool bPre = m_polyBase.IsClosed() || iGrip > 0;
|
||
int nPre = (iGrip - 1 + m_polyBase.Length()) % m_polyBase.Length();
|
||
TGGeDirectionCurve segPre;
|
||
m_polyBase.Nth(nPre, segPre);
|
||
|
||
bool bPreArc = fabs(m_polyBase.GetBulge(nPre)) > 1E-5;//前段是否为弧段
|
||
|
||
bool bNext = m_polyBase.IsClosed() || iGrip < m_polyBase.Length() - 1;
|
||
int nNext = iGrip % m_polyBase.Length();
|
||
TGGeDirectionCurve segNext;
|
||
m_polyBase.Nth(nNext, segNext);
|
||
|
||
bool bNextArc = fabs(m_polyBase.GetBulge(nNext)) > 1E-5;//后段的是否为弧段
|
||
|
||
if (bPre && bNext)
|
||
{// 有前段有后段
|
||
switch (iDim)
|
||
{
|
||
case 0:
|
||
{
|
||
if (!bPreArc)//长度
|
||
{
|
||
if (newValue > 1E-6)
|
||
{
|
||
TADSGePoint3d vt = segPre.Direction3d();
|
||
AcGeVector3d vt1 = ptNew - segPre.GetStartPoint().AsAcGePoint3d();
|
||
if (vt.AsAcGeVector3d().dotProduct(vt1) > 0)
|
||
{
|
||
vt *= newValue;
|
||
}
|
||
else
|
||
{
|
||
vt *= -newValue;
|
||
}
|
||
*m_polyBase[nPre + 1] = segPre.GetStartPoint() + vt;
|
||
}
|
||
}
|
||
else//包络角度
|
||
{
|
||
TGGeArc arc = segPre.GetArc();
|
||
if (segPre.GetBulge() < 0)
|
||
{
|
||
arc.SetStarAngle(arc.GetEndAngle() - newValue);
|
||
arc.GetStartPoint(segPre.StartPoint());
|
||
arc.GetEndPoint(segPre.EndPoint());
|
||
|
||
m_polyBase.SetBulge(nPre, -arc.Bulge());
|
||
*m_polyBase[nPre + 1] = segPre.GetStartPoint();
|
||
}
|
||
else
|
||
{
|
||
arc.SetEndAngle(arc.GetStarAngle() + newValue);
|
||
arc.GetStartPoint(segPre.StartPoint());
|
||
arc.GetEndPoint(segPre.EndPoint());
|
||
m_polyBase.SetBulge(nPre, arc.Bulge());
|
||
*m_polyBase[nPre + 1] = segPre.GetEndPoint();
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case 1:
|
||
{
|
||
if (!bNextArc)
|
||
{//长度
|
||
if (newValue > 1E-6)
|
||
{
|
||
TADSGePoint3d vt = segNext.Direction3d();
|
||
AcGeVector3d vt1 = ptNew - segNext.GetEndPoint().AsAcGePoint3d();
|
||
if (vt.AsAcGeVector3d().dotProduct(vt1) > 0)
|
||
{
|
||
vt *= newValue;
|
||
}
|
||
else
|
||
{
|
||
vt *= -newValue;
|
||
}
|
||
*m_polyBase[nNext] = segNext.GetEndPoint() + vt;
|
||
}
|
||
}
|
||
else
|
||
{//包络角度
|
||
TGGeArc arc = segNext.GetArc();
|
||
if (segNext.GetBulge() < 0)
|
||
{
|
||
arc.SetEndAngle(arc.GetStarAngle() + newValue);
|
||
arc.GetStartPoint(segNext.StartPoint());
|
||
arc.GetEndPoint(segNext.EndPoint());
|
||
m_polyBase.SetBulge(nNext, -arc.Bulge());
|
||
*m_polyBase[nNext] = segNext.GetEndPoint();
|
||
}
|
||
else
|
||
{
|
||
arc.SetStarAngle(arc.GetEndAngle() - newValue);
|
||
arc.GetStartPoint(segNext.StartPoint());
|
||
arc.GetEndPoint(segNext.EndPoint());
|
||
m_polyBase.SetBulge(nNext, arc.Bulge());
|
||
*m_polyBase[nNext] = segNext.GetStartPoint();
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case 2:
|
||
{
|
||
if (!bPreArc)
|
||
{//角度
|
||
AcGeVector3d vt1 = ptNew - segPre.GetStartPoint().AsAcGePoint3d();
|
||
if (vt1.y < 0)
|
||
{
|
||
newValue *= -1;
|
||
}
|
||
|
||
TADSGePoint3d vt2(segPre.GetLength(), 0, 0);
|
||
vt2.Rotate(newValue);
|
||
*m_polyBase[nPre + 1] = segPre.GetStartPoint() + vt2;
|
||
}
|
||
else
|
||
{//前弧终止角度
|
||
TGGeArc arc = segPre.GetArc();
|
||
if (ptNew.y < arc.GetCenterPt().y)
|
||
{
|
||
newValue = 2.0 * PI - newValue;
|
||
}
|
||
|
||
if (segPre.GetBulge() < 0)
|
||
{
|
||
arc.SetStarAngle(newValue);
|
||
arc.GetStartPoint(segPre.StartPoint());
|
||
arc.GetEndPoint(segPre.EndPoint());
|
||
m_polyBase.SetBulge(nPre, -arc.Bulge());
|
||
}
|
||
else
|
||
{
|
||
arc.SetEndAngle(newValue);
|
||
arc.GetStartPoint(segPre.StartPoint());
|
||
arc.GetEndPoint(segPre.EndPoint());
|
||
m_polyBase.SetBulge(nPre, arc.Bulge());
|
||
}
|
||
*m_polyBase[nPre + 1] = segPre.GetEndPoint();
|
||
}
|
||
}
|
||
break;
|
||
case 3:
|
||
{
|
||
if (!bNextArc)
|
||
{//角度
|
||
AcGeVector3d vt1 = ptNew - segNext.GetEndPoint().AsAcGePoint3d();
|
||
if (vt1.y < 0)
|
||
{
|
||
newValue *= -1;
|
||
}
|
||
|
||
TADSGePoint3d vt2(segNext.GetLength(), 0, 0);
|
||
vt2.Rotate(newValue);
|
||
*m_polyBase[nNext] = segNext.GetEndPoint() + vt2;
|
||
}
|
||
else
|
||
{//后弧起始角度
|
||
TGGeArc arc = segNext.GetArc();
|
||
if (ptNew.y < arc.GetCenterPt().y)
|
||
{
|
||
newValue = 2.0 * PI - newValue;
|
||
}
|
||
|
||
if (segNext.GetBulge() < 0)
|
||
{
|
||
arc.SetEndAngle(newValue);
|
||
arc.GetStartPoint(segNext.StartPoint());
|
||
arc.GetEndPoint(segNext.EndPoint());
|
||
m_polyBase.SetBulge(nNext, -arc.Bulge());
|
||
}
|
||
else
|
||
{
|
||
arc.SetStarAngle(newValue);
|
||
arc.GetStartPoint(segNext.StartPoint());
|
||
arc.GetEndPoint(segNext.EndPoint());
|
||
m_polyBase.SetBulge(nNext, arc.Bulge());
|
||
}
|
||
*m_polyBase[nNext] = segNext.GetStartPoint();
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
else if (bPre && !bNext)
|
||
{// 有前段无后段
|
||
switch (iDim)
|
||
{
|
||
case 0:
|
||
{
|
||
if (!bPreArc)//长度
|
||
{
|
||
if (newValue > 1E-6)
|
||
{
|
||
TADSGePoint3d vt = segPre.Direction3d();
|
||
AcGeVector3d vt1 = ptNew - segPre.GetStartPoint().AsAcGePoint3d();
|
||
if (vt.AsAcGeVector3d().dotProduct(vt1) > 0)
|
||
{
|
||
vt *= newValue;
|
||
}
|
||
else
|
||
{
|
||
vt *= -newValue;
|
||
}
|
||
*m_polyBase[nPre + 1] = segPre.GetStartPoint() + vt;
|
||
}
|
||
}
|
||
else//包络角度
|
||
{
|
||
TGGeArc arc = segPre.GetArc();
|
||
if (segPre.GetBulge() < 0)
|
||
{
|
||
arc.SetStarAngle(arc.GetEndAngle() - newValue);
|
||
arc.GetStartPoint(segPre.StartPoint());
|
||
arc.GetEndPoint(segPre.EndPoint());
|
||
m_polyBase.SetBulge(nPre, -arc.Bulge());
|
||
*m_polyBase[nPre + 1] = segPre.GetStartPoint();
|
||
}
|
||
else
|
||
{
|
||
arc.SetEndAngle(arc.GetStarAngle() + newValue);
|
||
arc.GetStartPoint(segPre.StartPoint());
|
||
arc.GetEndPoint(segPre.EndPoint());
|
||
m_polyBase.SetBulge(nPre, arc.Bulge());
|
||
*m_polyBase[nPre + 1] = segPre.GetEndPoint();
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case 1:
|
||
{
|
||
if (!bPreArc)
|
||
{//角度
|
||
AcGeVector3d vt1 = ptNew - segPre.GetStartPoint().AsAcGePoint3d();
|
||
if (vt1.y < 0)
|
||
{
|
||
newValue *= -1;
|
||
}
|
||
|
||
TADSGePoint3d vt2(segPre.GetLength(), 0, 0);
|
||
vt2.Rotate(newValue);
|
||
*m_polyBase[nPre + 1] = segPre.GetStartPoint() + vt2;
|
||
}
|
||
else
|
||
{//前弧终止角度
|
||
TGGeArc arc = segPre.GetArc();
|
||
if (ptNew.y < arc.GetCenterPt().y)
|
||
{
|
||
newValue = 2.0 * PI - newValue;
|
||
}
|
||
if (segPre.GetBulge() < 0)
|
||
{
|
||
arc.SetStarAngle(newValue);
|
||
arc.GetStartPoint(segPre.StartPoint());
|
||
arc.GetEndPoint(segPre.EndPoint());
|
||
m_polyBase.SetBulge(nPre, -arc.Bulge());
|
||
}
|
||
else
|
||
{
|
||
arc.SetEndAngle(newValue);
|
||
arc.GetStartPoint(segPre.StartPoint());
|
||
arc.GetEndPoint(segPre.EndPoint());
|
||
m_polyBase.SetBulge(nPre, arc.Bulge());
|
||
}
|
||
*m_polyBase[nPre + 1] = segPre.GetEndPoint();
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
else if (!bPre && bNext)
|
||
{// 无前段有后段
|
||
switch (iDim)
|
||
{
|
||
case 0:
|
||
{
|
||
if (!bNextArc)
|
||
{//长度
|
||
if (newValue > 1E-6)
|
||
{
|
||
TADSGePoint3d vt = segNext.Direction3d();
|
||
AcGeVector3d vt1 = ptNew - segNext.GetEndPoint().AsAcGePoint3d();
|
||
if (vt.AsAcGeVector3d().dotProduct(vt1) > 0)
|
||
{
|
||
vt *= newValue;
|
||
}
|
||
else
|
||
{
|
||
vt *= -newValue;
|
||
}
|
||
*m_polyBase[nNext] = segNext.GetEndPoint() + vt;
|
||
}
|
||
}
|
||
else
|
||
{//包络角度
|
||
TGGeArc arc = segNext.GetArc();
|
||
if (segNext.GetBulge() < 0)
|
||
{
|
||
arc.SetEndAngle(arc.GetStarAngle() + newValue);
|
||
arc.GetStartPoint(segNext.StartPoint());
|
||
arc.GetEndPoint(segNext.EndPoint());
|
||
m_polyBase.SetBulge(nNext, -arc.Bulge());
|
||
*m_polyBase[nNext] = segNext.GetEndPoint();
|
||
}
|
||
else
|
||
{
|
||
arc.SetStarAngle(arc.GetEndAngle() - newValue);
|
||
arc.GetStartPoint(segNext.StartPoint());
|
||
arc.GetEndPoint(segNext.EndPoint());
|
||
m_polyBase.SetBulge(nNext, arc.Bulge());
|
||
*m_polyBase[nNext] = segNext.GetStartPoint();
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case 1:
|
||
{
|
||
if (!bNextArc)
|
||
{//角度
|
||
AcGeVector3d vt1 = ptNew - segNext.GetEndPoint().AsAcGePoint3d();
|
||
if (vt1.y < 0)
|
||
{
|
||
newValue *= -1;
|
||
}
|
||
|
||
TADSGePoint3d vt2(segNext.GetLength(), 0, 0);
|
||
vt2.Rotate(newValue);
|
||
*m_polyBase[nNext] = segNext.GetEndPoint() + vt2;
|
||
}
|
||
else
|
||
{//后弧起始角度
|
||
TGGeArc arc = segNext.GetArc();
|
||
if (ptNew.y < arc.GetCenterPt().y)
|
||
{
|
||
newValue = 2.0 * PI - newValue;
|
||
}
|
||
if (segNext.GetBulge() < 0)
|
||
{
|
||
arc.SetEndAngle(newValue);
|
||
arc.GetStartPoint(segNext.StartPoint());
|
||
arc.GetEndPoint(segNext.EndPoint());
|
||
m_polyBase.SetBulge(nNext, -arc.Bulge());
|
||
}
|
||
else
|
||
{
|
||
arc.SetStarAngle(newValue);
|
||
arc.GetStartPoint(segNext.StartPoint());
|
||
arc.GetEndPoint(segNext.EndPoint());
|
||
m_polyBase.SetBulge(nNext, arc.Bulge());
|
||
}
|
||
*m_polyBase[nNext] = segNext.GetStartPoint();
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
|
||
return Acad::eOk;
|
||
}
|
||
#endif
|
||
|
||
|
||
// 区域的布尔运算
|
||
Adesk::Boolean TchExport2::PolyBoolOper(const TGGePoly2D &poly1, const TGGePoly2D & poly2, TDPtrList<TGGePoly2D> & poly, AcDb::BoolOperType operation)
|
||
{
|
||
int nRetCode = RTERROR;
|
||
|
||
if (TchPrivate::GetGlobalConfigBase() != NULL)
|
||
{
|
||
nRetCode = TchPrivate::GetGlobalConfigBase()->BoolOper(operation, (LPVOID)&poly1, (LPVOID)&poly2, (LPVOID)&poly);
|
||
}
|
||
|
||
return (nRetCode == RTNORM ? Adesk::kTrue : Adesk::kFalse);
|
||
}
|
||
|
||
// 区域的并集
|
||
void TchExport2::Union(const TDPtrList<TGGePoly2D> &lstSourcePolies, const TDPtrList<TGGePoly2D> &lstClipPolies, TDPtrList<TGGePoly2D> &lstResultPolies)
|
||
{
|
||
//return;//lfy---
|
||
|
||
TDPtrList<TGGePoly2D> lstSource, lstDest, *pSource = NULL, *pDest = NULL;
|
||
pSource = &lstSource;
|
||
pDest = &lstDest;
|
||
for (int i = 0; i < lstSourcePolies.Length(); i++)
|
||
{
|
||
lstSource.Append(new TGGePoly2D(lstSourcePolies[i]));
|
||
}
|
||
int nPiceNum = lstClipPolies.Length();
|
||
int nStep = nPiceNum / 100;
|
||
if (nStep < 1)
|
||
{
|
||
nStep = 1;
|
||
}
|
||
if (g_bEchoSearch && nStep > 1)
|
||
{
|
||
acedSetStatusBarProgressMeter(_T("求并集"), 0, nPiceNum);
|
||
}
|
||
for (i = 0; i < lstClipPolies.Length(); i++)
|
||
{
|
||
if (g_bEchoSearch && nStep>1 && !(i%nStep))
|
||
{
|
||
acedSetStatusBarProgressMeterPos(i);
|
||
}
|
||
const TGGePoly2D &polyClip = lstClipPolies[i];
|
||
pDest->Reset();
|
||
for (int j = 0; j < pSource->Length(); j++)
|
||
{
|
||
TGGePoly2D &polySrc = *(*pSource)[j];
|
||
if (TchPrivate::GetGlobalConfigBase() != NULL)
|
||
{
|
||
TchPrivate::GetGlobalConfigBase()->BoolOper(AcDb::kBoolUnite, (LPVOID)&polySrc, (LPVOID)&polyClip, (LPVOID)pDest);
|
||
}
|
||
|
||
//Union(polySrc, polyClip, *pDest);
|
||
}
|
||
Exchange(pSource, pDest);
|
||
}
|
||
if (g_bEchoSearch && nStep > 1)
|
||
{
|
||
acedRestoreStatusBar();
|
||
}
|
||
for (i = 0; i < pSource->Length(); i++)
|
||
{
|
||
TGGePoly2D *pPoly = new TGGePoly2D(*(*pSource)[i]);
|
||
pPoly->Compress();
|
||
lstResultPolies.Append(pPoly);
|
||
}
|
||
}
|
||
|
||
// 区域的减法
|
||
void TchExport2::Subtract(const TDPtrList<TGGePoly2D> &lstSourcePolies, const TDPtrList<TGGePoly2D> &lstClipPolies, TDPtrList<TGGePoly2D> &lstResultPolies)
|
||
{
|
||
//return;//lfy---
|
||
TDPtrList<TGGePoly2D> lstSource, lstDest, *pSource = NULL, *pDest = NULL;
|
||
pSource = &lstSource;
|
||
pDest = &lstDest;
|
||
for (int i = 0; i < lstSourcePolies.Length(); i++)
|
||
{
|
||
lstSource.Append(new TGGePoly2D(lstSourcePolies[i]));
|
||
}
|
||
|
||
for (i = 0; i < lstClipPolies.Length(); i++)
|
||
{
|
||
const TGGePoly2D &polyClip = lstClipPolies[i];
|
||
pDest->Reset();
|
||
for (int j = 0; j < pSource->Length(); j++)
|
||
{
|
||
TGGePoly2D &polySrc = *(*pSource)[j];
|
||
|
||
if (TchPrivate::GetGlobalConfigBase() != NULL)
|
||
{
|
||
TchPrivate::GetGlobalConfigBase()->BoolOper(AcDb::kBoolSubtract, (LPVOID)&polySrc, (LPVOID)&polyClip, (LPVOID)pDest);
|
||
}
|
||
|
||
//Subtract(polySrc, polyClip, *pDest);
|
||
}
|
||
Exchange(pSource, pDest);
|
||
}
|
||
for (i = 0; i < pSource->Length(); i++)
|
||
{
|
||
TGGePoly2D *pPoly = new TGGePoly2D(*(*pSource)[i]);
|
||
pPoly->Compress();
|
||
lstResultPolies.Append(pPoly);
|
||
}
|
||
}
|
||
|
||
// 区域的减法
|
||
void TchExport2::Intersect(const TDPtrList<TGGePoly2D> &lstSourcePolies, const TDPtrList<TGGePoly2D> &lstClipPolies, TDPtrList<TGGePoly2D> &lstResultPolies)
|
||
{
|
||
//return;//lfy---
|
||
TDPtrList<TGGePoly2D> lstSource, lstDest, *pSource = NULL, *pDest = NULL;
|
||
pSource = &lstSource;
|
||
pDest = &lstDest;
|
||
for (int i = 0; i < lstSourcePolies.Length(); i++)
|
||
{
|
||
lstSource.Append(new TGGePoly2D(lstSourcePolies[i]));
|
||
}
|
||
|
||
for (i = 0; i < lstClipPolies.Length(); i++)
|
||
{
|
||
const TGGePoly2D &polyClip = lstClipPolies[i];
|
||
pDest->Reset();
|
||
for (int j = 0; j < pSource->Length(); j++)
|
||
{
|
||
TGGePoly2D &polySrc = *(*pSource)[j];
|
||
if (TchPrivate::GetGlobalConfigBase() != NULL)
|
||
{
|
||
TchPrivate::GetGlobalConfigBase()->BoolOper(AcDb::kBoolIntersect, (LPVOID)&polySrc, (LPVOID)&polyClip, (LPVOID)pDest);
|
||
}
|
||
|
||
//TchExport2::Intersect(polySrc, polyClip, *pDest);
|
||
}
|
||
Exchange(pSource, pDest);
|
||
}
|
||
for (i = 0; i < pSource->Length(); i++)
|
||
{
|
||
TGGePoly2D *pPoly = new TGGePoly2D(*(*pSource)[i]);
|
||
pPoly->Compress();
|
||
lstResultPolies.Append(pPoly);
|
||
}
|
||
}
|
||
|
||
void TchExport2::InitModel(const TMasterProperties &prop, const AcDbEntity *pEntity,
|
||
AcGeMatrix3d *pMatTran, AcDbVoidPtrArray &entSet3dface)
|
||
{
|
||
TCHAR szMatch[256] = _T("TCH_*");
|
||
|
||
TMasterProperties subProp(prop);
|
||
subProp.SetFrom(pEntity);
|
||
if (pEntity->isKindOf(AcDbFace::desc()))
|
||
{
|
||
AcDbFace *pFace = (AcDbFace *)pEntity->clone();
|
||
ASSERT(pFace);
|
||
if (pMatTran)
|
||
{
|
||
if (pFace->transformBy(*pMatTran) != Acad::eOk)
|
||
{
|
||
AcGePoint3d ptArray[4];
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
pFace->getVertexAt(i, ptArray[i]);
|
||
ptArray[i].transformBy(*pMatTran);
|
||
pFace->setVertexAt(i, ptArray[i]);
|
||
}
|
||
}
|
||
}
|
||
subProp.SetTo(pFace);
|
||
entSet3dface.append(pFace);
|
||
}
|
||
else if (pEntity->isKindOf(AcDbPolyFaceMesh::desc()) || pEntity->isKindOf(AcDbPolygonMesh::desc()))
|
||
{
|
||
AcDbVoidPtrArray entSet1;
|
||
VERIFY(pEntity->explode(entSet1) == Acad::eOk);
|
||
InitModel(subProp, entSet1, pMatTran, entSet3dface);
|
||
TchExport::ReleaseEntSet(entSet1);
|
||
}
|
||
else if (pEntity->isKindOf(AcDbBlockReference::desc()))
|
||
{
|
||
AcDbBlockReference *pInsert = AcDbBlockReference::cast(pEntity);
|
||
ASSERT(pInsert);
|
||
AcGeMatrix3d matNew = BlockTransform(pInsert);
|
||
if (pMatTran)
|
||
{
|
||
matNew.preMultBy(*pMatTran);
|
||
}
|
||
AcDbObjectId idBlock = pInsert->blockTableRecord();
|
||
OPENOBJ_BEGIN(idBlock, AcDb::kForRead, AcDbBlockTableRecord, pBlockTableRecord);
|
||
if (pBlockTableRecord)
|
||
{
|
||
AcDbBlockTableRecordIterator *pBlockIterator = NULL;
|
||
VERIFY(pBlockTableRecord->newIterator(pBlockIterator) == Acad::eOk && pBlockIterator);
|
||
for (pBlockIterator->start(); !pBlockIterator->done(); pBlockIterator->step())
|
||
{
|
||
AcDbEntity *pEntNew = NULL;
|
||
if (pBlockIterator->getEntity(pEntNew, AcDb::kForRead) != Acad::eOk || !pEntNew)
|
||
{
|
||
continue;
|
||
}
|
||
if (pEntNew->visibility() == AcDb::kVisible)
|
||
{
|
||
TchExport2::InitModel(subProp, pEntNew, &matNew, entSet3dface);
|
||
}
|
||
pEntNew->close();
|
||
}
|
||
delete pBlockIterator;
|
||
}
|
||
OPENOBJ_END();
|
||
}
|
||
else if (ads_wcmatch(pEntity->isA()->dxfName(), szMatch) == RTNORM)
|
||
{ // TCH 在2000i/20002下，上华对象的分解由于调用了Region的运算导致出错有问题
|
||
AcDbVoidPtrArray entSet1;
|
||
if (pEntity->explode(entSet1) == Acad::eOk)
|
||
{
|
||
TchExport2::InitModel(subProp, entSet1, pMatTran, entSet3dface);
|
||
TchExport::ReleaseEntSet(entSet1);
|
||
}
|
||
}
|
||
else if (_tcsicmp(pEntity->isA()->dxfName(), _T("3DSOLID")) == 0 || _tcsicmp(pEntity->isA()->dxfName(), _T("REGION")) == 0 ||
|
||
_tcsicmp(pEntity->isA()->dxfName(), _T("3DBODY")) == 0)
|
||
{
|
||
AcDbVoidPtrArray entSet;
|
||
ExplodeAcis(pEntity, entSet);
|
||
TchExport2::InitModel(subProp, entSet, pMatTran, entSet3dface);
|
||
TchExport::ReleaseEntSet(entSet);
|
||
}
|
||
else if (_tcsicmp(pEntity->isA()->dxfName(), _T("SOLID")) == 0)
|
||
{ //二维物体
|
||
AcDbSolid *pClone = (AcDbSolid *)pEntity->clone();
|
||
ASSERT(pClone);
|
||
if (pMatTran)
|
||
{
|
||
if (pClone->transformBy(*pMatTran) != Acad::eOk)
|
||
{
|
||
AcGePoint3d ptArray[4];
|
||
for (int i = 0; i < 4; i++)
|
||
{
|
||
pClone->getPointAt(i, ptArray[i]);
|
||
ptArray[i].transformBy(*pMatTran);
|
||
pClone->setPointAt(i, ptArray[i]);
|
||
}
|
||
}
|
||
}
|
||
subProp.SetTo(pClone);
|
||
entSet3dface.append(pClone);
|
||
}
|
||
else if (pEntity->isA() == AcDbLine::desc())
|
||
{
|
||
AcDbLine *pLine = (AcDbLine *)pEntity->clone();
|
||
ASSERT(pLine);
|
||
if (pMatTran)
|
||
{
|
||
if (pLine->transformBy(*pMatTran) != Acad::eOk)
|
||
{
|
||
AcGePoint3d pt1 = pLine->startPoint();
|
||
AcGePoint3d pt2 = pLine->endPoint();
|
||
AcGeVector3d vt = pLine->normal();
|
||
AcGeVector3d vtNormal = vt;
|
||
vt *= pLine->thickness();
|
||
pt1.transformBy(*pMatTran);
|
||
pt2.transformBy(*pMatTran);
|
||
vt.transformBy(*pMatTran);
|
||
vtNormal.transformBy(*pMatTran);
|
||
if (vt.length() > _DIST_SNAP)
|
||
{
|
||
AcDbFace *pFace = new AcDbFace(pt1, pt2, pt2 + vt, pt1 + vt);
|
||
subProp.SetTo(pFace);
|
||
entSet3dface.append(pFace);
|
||
delete pLine;
|
||
}
|
||
else
|
||
{
|
||
pLine->setStartPoint(pt1);
|
||
pLine->setEndPoint(pt2);
|
||
pLine->setThickness(0.0);
|
||
vtNormal.normalize();
|
||
pLine->setNormal(vtNormal);
|
||
subProp.SetTo(pLine);
|
||
entSet3dface.append(pLine);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
subProp.SetTo(pLine);
|
||
entSet3dface.append(pLine);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
AcGeVector3d vt = pLine->normal();
|
||
AcGeVector3d vtNormal = vt;
|
||
vt *= pLine->thickness();
|
||
AcGePoint3d pt1 = pLine->startPoint();
|
||
AcGePoint3d pt2 = pLine->endPoint();
|
||
if (vt.length() > _DIST_SNAP)
|
||
{
|
||
AcDbFace *pFace = new AcDbFace(pt1, pt2, pt2 + vt, pt1 + vt);
|
||
subProp.SetTo(pFace);
|
||
entSet3dface.append(pFace);
|
||
delete pLine;
|
||
}
|
||
else
|
||
{
|
||
pLine->setStartPoint(pt1);
|
||
pLine->setEndPoint(pt2);
|
||
pLine->setThickness(0.0);
|
||
vtNormal.normalize();
|
||
pLine->setNormal(vtNormal);
|
||
subProp.SetTo(pLine);
|
||
entSet3dface.append(pLine);
|
||
}
|
||
}
|
||
|
||
}
|
||
else
|
||
{ //拉伸的曲线
|
||
AcDbPolyline *pline = AsPolyline(pEntity);
|
||
if (pline)
|
||
{
|
||
if (pline->thickness() > _DIST_SNAP)
|
||
{
|
||
// 没有消除圆弧折线化后的不可见边
|
||
double nThick = pline->thickness();
|
||
TGGePoly2D poly;
|
||
TchExport2::PolyConvert(*pline, poly);
|
||
|
||
if (poly.IsClosed() && poly.PathArea() > 0.0)
|
||
{
|
||
poly.Reverse(); //确保逆时针
|
||
}
|
||
TVector3D vtNormal;
|
||
AcGeVector3d vt = pline->normal();
|
||
(AcGeVector3d &)vtNormal = vt;
|
||
|
||
double nWidth = 0.0;
|
||
if (pline->getConstantWidth(nWidth) != Acad::eOk)
|
||
{
|
||
nWidth = 0.0;
|
||
}
|
||
if (nWidth > _DIST_SNAP)
|
||
{
|
||
TGGePoly2D poly1, poly2;
|
||
poly.Offset(-nWidth / 2, poly1);
|
||
poly.Offset(nWidth / 2, poly2);
|
||
ThickPoly2Face(subProp, poly1, vtNormal, nThick, entSet3dface, pMatTran);
|
||
ThickPoly2Face(subProp, poly2, vtNormal, nThick, entSet3dface, pMatTran);
|
||
|
||
if (poly.IsClosed())
|
||
{
|
||
poly1.SetFlag(0);
|
||
poly2.SetFlag(0);
|
||
poly1.AppendNode(*poly1.Head());
|
||
poly2.AppendNode(*poly2.Head());
|
||
}
|
||
TGGePoly2D poly3(poly1);
|
||
poly2.Reverse();
|
||
for (int n = 0; n < poly2.Length(); n++)
|
||
{
|
||
poly3.AppendNode(*poly2[n], poly2.GetBulge(n));
|
||
}
|
||
TGGePoly polygon;
|
||
poly3.AsOpenPoly1(polygon, _AS_SYS_UNIT(g_nCirDeviation));
|
||
|
||
TDPtrList<TGGeTriangle> lstTris[2];
|
||
|
||
TGGeHoleModel model;
|
||
for (int k = 0; k < polygon.Length(); k++)
|
||
{
|
||
//model.m_outline.AppendNode(*polygon[k], TRUE);
|
||
model.GetOutLine().AppendNode(*poly1[k], TRUE);
|
||
}
|
||
model.Triangulate(FALSE, lstTris[0]);
|
||
|
||
TADSGePoint3d vtN = vtNormal;
|
||
vtN *= nThick;
|
||
for (n = 0; n < lstTris[0].Length(); n++)
|
||
{
|
||
TGGeTriangle *pTri = lstTris[0][n];
|
||
TGGeTriangle *pTri1 = new TGGeTriangle(*pTri);
|
||
pTri1->vertex1 += vtN;
|
||
pTri1->vertex2 += vtN;
|
||
pTri1->vertex3 += vtN;
|
||
lstTris[1].Append(pTri1);
|
||
}
|
||
for (int ii = 0; ii < 2; ii++)
|
||
{
|
||
for (int jj = 0; jj < lstTris[ii].Length(); jj++)
|
||
{
|
||
TGGeTriangle *triangle = lstTris[ii][jj];
|
||
triangle->vertex1 = Ecs2Wcs(triangle->vertex1, vtNormal);
|
||
triangle->vertex2 = Ecs2Wcs(triangle->vertex2, vtNormal);
|
||
triangle->vertex3 = Ecs2Wcs(triangle->vertex3, vtNormal);
|
||
Adesk::Boolean bSide1 = !(triangle->m_nFlag&SIDE1_INVISIBLE);
|
||
Adesk::Boolean bSide2 = !(triangle->m_nFlag&SIDE2_INVISIBLE);
|
||
Adesk::Boolean bSide3 = !(triangle->m_nFlag&SIDE3_INVISIBLE);
|
||
AcDbFace *pFace = new AcDbFace(triangle->vertex1, triangle->vertex2,
|
||
triangle->vertex3, triangle->vertex1, bSide1, bSide2, bSide3);
|
||
subProp.SetTo(pFace);
|
||
entSet3dface.append(pFace);
|
||
}
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
ThickPoly2Face(subProp, poly, vtNormal, nThick, entSet3dface, pMatTran);
|
||
}
|
||
delete pline;
|
||
}
|
||
else
|
||
{
|
||
if (!pMatTran)
|
||
{
|
||
subProp.SetTo(pline);
|
||
entSet3dface.append(pline);
|
||
}
|
||
else if (pline->transformBy(*pMatTran) == Acad::eOk)
|
||
{
|
||
subProp.SetTo(pline);
|
||
entSet3dface.append(pline);
|
||
}
|
||
else
|
||
{
|
||
TGGePoly2D poly2d, polyDest;
|
||
TchExport2::PolyConvert(*pline, poly2d);
|
||
|
||
poly2d.Disperse1(polyDest, _AS_SYS_UNIT(g_nCirDeviation));
|
||
AcGeVector3d vtNormal = pline->normal();
|
||
TVector3D vtN(vtNormal[0], vtNormal[1], vtNormal[2]);
|
||
TGroups gv(vtN), g0(0);
|
||
polyDest.TransUCS((const resbuf *)&gv, (const resbuf *)&g0);
|
||
|
||
ads_matrix mat;
|
||
AsAdsMatrix(*pMatTran, mat);
|
||
polyDest.TransUCS(mat);
|
||
|
||
int nSeg = polyDest.TotalSegments();
|
||
for (int iSeg = 0; iSeg < nSeg; iSeg++)
|
||
{
|
||
TGGeCurveSegment ln;
|
||
polyDest.Nth(iSeg, ln);
|
||
AcDbCurve *pCurve = ln.AsAcDbCurve();
|
||
subProp.SetTo(pCurve);
|
||
entSet3dface.append(pCurve);
|
||
}
|
||
delete pline;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
void TchExport2::InitModel(const TMasterProperties &prop, const AcDbVoidPtrArray &entSet, AcGeMatrix3d *pMatTran, AcDbVoidPtrArray &entSet3dface)
|
||
{
|
||
int nCount = entSet.length();
|
||
for (int i = 0; i < nCount; i++)
|
||
{
|
||
AcDbEntity *pEntity = (AcDbEntity *)entSet[i];
|
||
TchExport2::InitModel(prop, pEntity, pMatTran, entSet3dface);
|
||
}
|
||
}
|
||
|
||
int TchExport2::SearchRegions(const TDPtrList<TGGeCurveSegment> &lstSeg1In, TDPtrList<TGGePoly2D> &lstDest)
|
||
{
|
||
try
|
||
{
|
||
TSearchRegionFromCurve aSearch;
|
||
aSearch.InitStart(lstSeg1In);
|
||
if (aSearch.SearchRegions())
|
||
{
|
||
aSearch.RemoveDupRegions();
|
||
for (int n = 0; n < aSearch.m_regions.Length(); n++)
|
||
{
|
||
TGGePoly2D *pNewPoly = new TGGePoly2D(1);
|
||
if (aSearch.m_regions[n]->CenterPoly2D(*pNewPoly) == RTNORM)
|
||
{
|
||
lstDest.Append(pNewPoly);
|
||
}
|
||
else
|
||
{
|
||
delete pNewPoly;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch (...)
|
||
{
|
||
if (g_bEchoSearch)
|
||
{
|
||
TchGeLib::adsout << /*UMSG*/_T("\n发生例外情况!");
|
||
}
|
||
return RTERROR;
|
||
}
|
||
|
||
return RTNORM;
|
||
}
|