963 lines
29 KiB
C++
963 lines
29 KiB
C++
#include "stdafx.h"
|
|
#include "ParallelDimStyle.h"
|
|
#include "TParallelDimJig.h"
|
|
#include "actrans.h"
|
|
#include "LayerSiftDlgEx.h"
|
|
#include "TchGlobalFunc.h"
|
|
extern int GetFullOsMode(int nFlagsAdd);
|
|
extern CString g_sSaveFileName; //保存文件名,需要在创建对话框之前进行赋值***********************
|
|
extern CString g_sdefaultLayerName; //默认图层名字符串 _T("ROAD_DOTE\r\nROAD");需要在创建对话框之前进行赋值***********************
|
|
extern CStringArray g_aryLayerName; //默认图层名 需要在创建对话框之前进行赋值***********************
|
|
extern void GetLayerNameByKeyWord(CStringArray& aryLayer, CStringArray &aryKeyWord); //根据指定的图层关键字查找图层名
|
|
extern TARCH_IMPEXP BOOL g_bTextDefaultLayer; // TRUE为使用默认图层
|
|
CParallelDimStyle::CParallelDimStyle(void)
|
|
{
|
|
}
|
|
|
|
|
|
CParallelDimStyle::~CParallelDimStyle(void)
|
|
{
|
|
}
|
|
|
|
void CParallelDimStyle::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(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);
|
|
}
|
|
else
|
|
{
|
|
if (m_lstLayer.IsEmpty())
|
|
{
|
|
AnalysisTgEntToLine(pEntity, lstResult);
|
|
}
|
|
else
|
|
{
|
|
CString strLayer = pEntity->layer();
|
|
if(m_lstLayer.Find(strLayer))
|
|
AnalysisTgEntToLine(pEntity, lstResult);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
pEntity->close();
|
|
}
|
|
delete pBlockIterator;
|
|
}
|
|
void CParallelDimStyle::AnalysisTgEntToLine(const AcDbEntity* pEnt, TDPtrList<TGGeCurveSegment> &lstResult)
|
|
{
|
|
if (pEnt->isKindOf(AcDbLine::desc()))
|
|
{
|
|
AcDbLine *pLine = AcDbLine::cast(pEnt);
|
|
lstResult.Append(new TGGeCurveSegment(pLine->startPoint(), pLine->endPoint(), 0.0));
|
|
}
|
|
else if(pEnt->isKindOf(AcDbArc::desc()))
|
|
{
|
|
AcDbArc *pArc = AcDbArc::cast(pEnt);
|
|
AcGePoint3d ptStart, ptEnd, ptThird;
|
|
pArc->getStartPoint(ptStart);
|
|
pArc->getEndPoint(ptEnd);
|
|
pArc->getPointAtDist(0.5 * (ptStart.distanceTo(ptEnd)), ptThird);
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
*pSeg = TGGeArc(ptStart, ptThird, ptEnd);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
else if(pEnt->isKindOf(AcDbCircle::desc()))
|
|
{
|
|
TEntitySet ent;
|
|
if(acdbGetAdsName(ent.name, pEnt->objectId()) == Acad::eOk)
|
|
{
|
|
TGGePoly2D poly(ent);
|
|
for (int i = 0; i < poly.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
poly.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
}
|
|
}
|
|
else if (pEnt->isKindOf(AcDbPolyline::desc()))
|
|
{
|
|
TEntitySet ent;
|
|
if(acdbGetAdsName(ent.name, pEnt->objectId()) == Acad::eOk)
|
|
{
|
|
TGGePoly2D poly(ent);
|
|
for (int i = 0; i < poly.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
poly.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
}
|
|
}
|
|
else if (pEnt->isKindOf(TDbWall::desc()))
|
|
{
|
|
TGGePoly2D poly;
|
|
TDbWall* pWall = TDbWall::cast(pEnt);
|
|
pWall->GetOutlinePoly1(pWall->GetElevation(), poly);
|
|
for (int i = 0; i < poly.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
poly.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
}
|
|
else if (pEnt->isKindOf(TDbColumn::desc()))
|
|
{
|
|
TGGePoly2D poly;
|
|
TDbColumn* pColumn = TDbColumn::cast(pEnt);
|
|
poly = pColumn->GetOutlinePoly();
|
|
for (int i = 0; i < poly.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
poly.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
}
|
|
else if (pEnt->isKindOf(TDbBalcony::desc()))//阳台
|
|
{
|
|
TGGePoly2D polyOut, polyIn;
|
|
TDbBalcony* pBalcony = TDbBalcony::cast(pEnt);
|
|
polyOut = pBalcony->GetOutline();
|
|
pBalcony->GetPolyIn(polyIn);
|
|
polyIn.SetElevation(0.0);
|
|
polyOut.SetElevation(0.0);
|
|
for (int i = 0; i < polyOut.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
polyOut.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
for (int n = 0; n < polyIn.TotalSegments(); n++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
polyIn.Nth(n, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
}
|
|
else if (pEnt->isKindOf(TDbApron::desc()))
|
|
{
|
|
TGGePoly2D apronPolyIn, apronPolyOut;
|
|
Array<int> aryIndex, aryShow;
|
|
TDbApron* pApron = TDbApron::cast(pEnt);
|
|
pApron->Get2DInPoly(apronPolyIn);
|
|
pApron->Get2DOutPoly(apronPolyOut, aryIndex, aryShow);
|
|
for (int i = 0; i < apronPolyIn.TotalSegments(); ++i)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
apronPolyIn.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
|
|
for (int n = 0; n < apronPolyOut.TotalSegments(); ++n)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
apronPolyOut.Nth(n, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
}
|
|
else if (pEnt->isKindOf(TDbStep::desc()))//台阶
|
|
{
|
|
TGGePoly2D poly;
|
|
TDbStep* pStep = TDbStep::cast(pEnt);
|
|
pStep->GetOutline2d(poly);
|
|
poly.SetElevation(0.0);
|
|
for (int i = 0; i < poly.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
poly.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
}
|
|
else if (pEnt->isKindOf(TDbSlab::desc()))//板
|
|
{
|
|
TGGePoly2D poly;
|
|
TDbSlab* pSLab = TDbSlab::cast(pEnt);
|
|
poly = pSLab->GetOutline();
|
|
for (int i = 0; i < poly.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
poly.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
}
|
|
else if (pEnt->isKindOf(TDbVertSlab::desc()))//竖板
|
|
{
|
|
XPoint ptStart, ptEnd, ptLftSt, ptLeftEnd, ptRightSt, ptRightEnd;
|
|
XLine midLine, leftLine, rightLine;
|
|
TDbVertSlab* pVertSLab = TDbVertSlab::cast(pEnt);
|
|
ptStart = pVertSLab->GetStartPoint();
|
|
ptEnd = pVertSLab->GetEndPoint();
|
|
midLine.SetStartPoint(ptStart);
|
|
midLine.SetEndPoint(ptEnd);
|
|
leftLine = midLine.Offset(0.5 * pVertSLab->GetThickness());
|
|
rightLine = midLine.Offset(-0.5 * pVertSLab->GetThickness());
|
|
leftLine.GetStartPoint(ptLftSt);
|
|
leftLine.GetEndPoint(ptLeftEnd);
|
|
rightLine.GetStartPoint(ptRightSt);
|
|
rightLine.GetEndPoint(ptRightEnd);
|
|
lstResult.Append(new TGGeCurveSegment(ptLftSt, ptLeftEnd, 0.0));
|
|
lstResult.Append(new TGGeCurveSegment(ptRightSt, ptRightEnd, 0.0));
|
|
lstResult.Append(new TGGeCurveSegment(ptLftSt, ptRightSt, 0.0));
|
|
lstResult.Append(new TGGeCurveSegment(ptLeftEnd, ptRightEnd, 0.0));
|
|
}
|
|
else if (pEnt->isKindOf(TDbAscent::desc()))//坡道
|
|
{
|
|
XPoint ptLowLeft, ptLowRight, ptUpLeft, ptUpRight;
|
|
XLine midLine, leftLine, rightLine;
|
|
TDbAscent* pAscent = TDbAscent::cast(pEnt);
|
|
ptLowLeft = pAscent->GetLowLeft2d();
|
|
ptLowRight = pAscent->GetLowRight2d();
|
|
ptUpLeft = pAscent->GetUpLeft2d();
|
|
ptUpRight = pAscent->GetUpRight2d();
|
|
lstResult.Append(new TGGeCurveSegment(ptLowLeft, ptLowRight, 0.0));
|
|
lstResult.Append(new TGGeCurveSegment(ptUpLeft, ptUpRight, 0.0));
|
|
lstResult.Append(new TGGeCurveSegment(ptLowLeft, ptUpLeft, 0.0));
|
|
lstResult.Append(new TGGeCurveSegment(ptLowRight, ptUpRight, 0.0));
|
|
}
|
|
else if (pEnt->isKindOf(TDbOpening::desc()))//窗户
|
|
{
|
|
TGGePoly2D poly;
|
|
TDbOpening* pOpenning = TDbOpening::cast(pEnt);
|
|
pOpenning->m_nQuadrant;
|
|
TADSGePoint3d ptDir;
|
|
TGGeCurveSegment segBayWin;
|
|
if(pOpenning->m_pBayWin)//凸窗
|
|
{
|
|
OPENOBJ_BEGIN(pOpenning->m_nIdOfWall, AcDb::kForRead, TDbWall, pWall);
|
|
if (pWall)
|
|
{
|
|
XPoint ptLoc = pOpenning->m_ptLocation;
|
|
ptLoc.z = pOpenning->m_ptLocation.z;
|
|
double nWallThick = pWall->GetWidth(4);
|
|
double nExtDir = pOpenning->m_nRotation + (pOpenning->m_nQuadrant<2? PI/2.0 : -PI/2.0);
|
|
|
|
ads_polar(ptLoc, nExtDir, 10000, ptDir);
|
|
double dWallInsut = 0.0;
|
|
|
|
int nSide = pWall->OnWhichSide(ptDir);
|
|
if (pWall->IsInsulateOnSide(nSide)) // 得到外保温厚度
|
|
{
|
|
dWallInsut = pWall->GetInsulateThick(nSide);
|
|
}
|
|
|
|
DList<XPoly2D> polyCurves;
|
|
pOpenning->m_pBayWin->GetPolyCurve(ptLoc, nExtDir, pOpenning->m_nWidth, nWallThick, pOpenning->HasLeftSlab(), pOpenning->HasRightSlab(), polyCurves, dWallInsut);
|
|
|
|
if (polyCurves.Length() > 1)
|
|
{
|
|
/*for (int nPolyNum = 0; nPolyNum < polyCurves.Length(); ++nPolyNum)
|
|
{*/
|
|
//最外层轮廓
|
|
XPoly2D polyBay;
|
|
if (polyCurves.Length() >=3)
|
|
{
|
|
polyBay = *polyCurves.GetAt(2);
|
|
polyBay.SetElevation(0.0);
|
|
for (int i = 0; i < polyBay.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
polyBay.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
if (i == 1)
|
|
{
|
|
segBayWin = *pSeg;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((pOpenning->HasLeftSlab() || pOpenning->HasRightSlab()) && pOpenning->m_pBayWin->m_nStyle==XBayWindow::BWS_RECT)
|
|
{
|
|
XPoly2D polyLeft(1),polyRight(1);
|
|
pOpenning->m_pBayWin->GetVertSlabPoly(ptLoc, nExtDir, pOpenning->m_nWidth, nWallThick, pOpenning->m_nProWinSlabWidth, polyLeft, polyRight);
|
|
if (pOpenning->HasLeftSlab())
|
|
{
|
|
polyLeft.SetElevation(0.0);
|
|
for (int i = 0; i < polyLeft.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
polyLeft.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
}
|
|
if (pOpenning->HasRightSlab())
|
|
{
|
|
polyRight.SetElevation(0.0);
|
|
for (int i = 0; i < polyRight.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
polyRight.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
XPoint ptOpeningLeft, ptOpeningRight;
|
|
pOpenning->GetSidePointsOnBase(ptOpeningLeft, ptOpeningRight);
|
|
AcGeVector3d vec = ptOpeningRight - ptOpeningLeft;
|
|
AcGeVector3d vecTemp = vec;
|
|
if (pOpenning->IsDoor())
|
|
{
|
|
if (pOpenning->GetKind() == TOpeningData::OP_DOORWIN)
|
|
{
|
|
XPoint ptSt, ptEnd;
|
|
if(pOpenning->m_nQuadrant == 0 || pOpenning->m_nQuadrant == 3)
|
|
{
|
|
if (pOpenning->m_nQuadrant == 0)
|
|
vec = vec.rotateBy(0.5*PI, AcGeVector3d::kZAxis);
|
|
else
|
|
vec = vec.rotateBy(-0.5*PI, AcGeVector3d::kZAxis);
|
|
|
|
ptSt = ptOpeningRight;
|
|
ptEnd = ptOpeningRight + vec * pOpenning->m_nDoorWidth / vecTemp.length();
|
|
}
|
|
if (pOpenning->m_nQuadrant == 1 || pOpenning->m_nQuadrant == 2)
|
|
{
|
|
if (pOpenning->m_nQuadrant == 1)
|
|
vec = vec.rotateBy(0.5*PI, AcGeVector3d::kZAxis);
|
|
else
|
|
vec = vec.rotateBy(-0.5*PI, AcGeVector3d::kZAxis);
|
|
ptSt = ptOpeningLeft;
|
|
ptEnd = ptOpeningLeft + vec * pOpenning->m_nDoorWidth / vecTemp.length();
|
|
}
|
|
lstResult.Append(new TGGeCurveSegment(ptSt, ptEnd, 0.0));
|
|
}
|
|
else if(pOpenning->GetKind() == TOpeningData::OP_TWODOOR)
|
|
{
|
|
XPoint ptLine1St, ptLine1End, ptLine2St, ptLine2End;
|
|
if(pOpenning->m_nQuadrant == 0 || pOpenning->m_nQuadrant == 3)
|
|
{
|
|
if (pOpenning->m_nQuadrant == 0)
|
|
vec = vec.rotateBy(0.5*PI, AcGeVector3d::kZAxis);
|
|
else
|
|
vec = vec.rotateBy(-0.5*PI, AcGeVector3d::kZAxis);
|
|
|
|
ptLine1St = ptOpeningLeft;
|
|
ptLine1End = ptOpeningLeft + vec * pOpenning->m_nDoorWidth / vecTemp.length();
|
|
|
|
ptLine2St = ptOpeningRight;
|
|
ptLine2End = ptOpeningRight + vec * (pOpenning-> m_nWidth - pOpenning->m_nDoorWidth) / vec.length();
|
|
}
|
|
if (pOpenning->m_nQuadrant == 1 || pOpenning->m_nQuadrant == 2)
|
|
{
|
|
if (pOpenning->m_nQuadrant == 1)
|
|
vec = vec.rotateBy(0.5*PI, AcGeVector3d::kZAxis);
|
|
else
|
|
vec = vec.rotateBy(-0.5*PI, AcGeVector3d::kZAxis);
|
|
ptLine1St = ptOpeningRight;
|
|
ptLine1End = ptOpeningRight + vec * pOpenning->m_nDoorWidth / vecTemp.length();
|
|
|
|
ptLine2St = ptOpeningLeft;
|
|
ptLine2End = ptOpeningLeft + vec * (pOpenning-> m_nWidth - pOpenning->m_nDoorWidth) / vec.length();
|
|
}
|
|
lstResult.Append(new TGGeCurveSegment(ptLine1St, ptLine1End, 0.0));
|
|
lstResult.Append(new TGGeCurveSegment(ptLine2St, ptLine2End, 0.0));
|
|
}
|
|
else if(pOpenning->GetKind() == TOpeningData::OP_DOOR)
|
|
{
|
|
XPoint pt1, pt2, pt3, pt4;
|
|
if(pOpenning->m_nQuadrant == 0 || pOpenning->m_nQuadrant == 3)
|
|
{
|
|
if (pOpenning->m_nQuadrant == 0)
|
|
vec = vec.rotateBy(0.5*PI, AcGeVector3d::kZAxis);
|
|
else
|
|
vec = vec.rotateBy(-0.5*PI, AcGeVector3d::kZAxis);
|
|
pt1 = ptOpeningRight;
|
|
pt2 = pt1 + vec * 0.975 * pOpenning->m_nWidth / vecTemp.length();
|
|
pt4 = pt1 + vecTemp * 0.05 * pOpenning->m_nWidth / (-vec.length());
|
|
pt3 = pt4 + vec * 0.975 * pOpenning->m_nWidth / vecTemp.length();
|
|
|
|
}
|
|
if (pOpenning->m_nQuadrant == 1 || pOpenning->m_nQuadrant == 2)
|
|
{
|
|
if (pOpenning->m_nQuadrant == 1)
|
|
vec = vec.rotateBy(0.5*PI, AcGeVector3d::kZAxis);
|
|
else
|
|
vec = vec.rotateBy(-0.5*PI, AcGeVector3d::kZAxis);
|
|
pt1 = ptOpeningLeft;
|
|
pt2 = pt1 + vec * 0.975 * pOpenning->m_nWidth / vecTemp.length();
|
|
pt4 = pt1 + vecTemp * 0.05 * pOpenning->m_nWidth / vec.length();
|
|
pt3 = pt4 + vec * 0.975 * pOpenning->m_nWidth / vecTemp.length();
|
|
}
|
|
|
|
lstResult.Append(new TGGeCurveSegment(pt1, pt2, 0.0));
|
|
lstResult.Append(new TGGeCurveSegment(pt2, pt3, 0.0));
|
|
//lstResult.Append(new TGGeCurveSegment(pt3, pt4, 0.0));
|
|
lstResult.Append(new TGGeCurveSegment(pt4, pt1, 0.0));
|
|
|
|
}
|
|
}
|
|
pOpenning->GetOutlinePoly(pOpenning->GetElevation(), poly);
|
|
poly.SetElevation(0.0); //z轴相同，才可以判断是否相交
|
|
if(pOpenning->m_pBayWin)//凸窗
|
|
{
|
|
for (int i = 0; i < poly.TotalSegments(); i++)
|
|
{
|
|
XPoint ptOutLine = segBayWin.GetStartPoint();//获取凸窗外轮廓线上的一点
|
|
ptOutLine.z = 0;
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
poly.Nth(i, *pSeg);
|
|
if (i == 1 || i == 3)
|
|
{
|
|
if (OFFSET_LEFT == pSeg->OnWhichSide(ptOutLine))//获取凸窗的外轮廓线
|
|
lstResult.Append(pSeg);
|
|
else
|
|
delete pSeg;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < poly.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
poly.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
}
|
|
}
|
|
else if (pEnt->isKindOf(TDbCornerWin::desc()))//凸窗
|
|
{
|
|
TDbCornerWin* pCornerWin = TDbCornerWin::cast(pEnt);
|
|
double dLen1 = pCornerWin->GetProtrude();
|
|
XPoly2D polyInside(1), polyGlass1(1), polyGlass2(1), polyOutSide(1);
|
|
polyOutSide.SetElevation(0.0);
|
|
polyInside.SetElevation(0.0);
|
|
pCornerWin->GetKeyCurves(polyInside, polyGlass1, polyGlass2, polyOutSide);
|
|
for (int i = 0; i < polyOutSide.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
polyOutSide.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
for (int i = 0; i < polyInside.TotalSegments(); i++)
|
|
{
|
|
TGGeCurveSegment *pSeg = new TGGeCurveSegment;
|
|
polyInside.Nth(i, *pSeg);
|
|
lstResult.Append(pSeg);
|
|
}
|
|
// AcDbPolyline* poly1 = new AcDbPolyline;
|
|
// PolyConvert(polyInside, *poly1);
|
|
// AddToCurrentSpace(poly1, Adesk::kTrue);
|
|
// AcDbPolyline* poly2 = new AcDbPolyline;
|
|
// PolyConvert(polyOutSide, *poly2);
|
|
// AddToCurrentSpace(poly2, Adesk::kTrue);
|
|
// //AcDbPolyline* poly3 = new AcDbPolyline;
|
|
// //PolyConvert(polyGlass1, *poly3);
|
|
// //AddToCurrentSpace(poly3, Adesk::kTrue);
|
|
// //AcDbPolyline* poly4 = new AcDbPolyline;
|
|
// //PolyConvert(polyGlass2, *poly4);
|
|
// //AddToCurrentSpace(poly4, Adesk::kTrue);
|
|
|
|
}
|
|
else if(pEnt->isKindOf(AcDbBlockReference::desc()))
|
|
{
|
|
TDPtrList<TGGeCurveSegment> lstTemp;
|
|
AcDbBlockReference *pInsert = AcDbBlockReference::cast(pEnt);
|
|
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);
|
|
TGGeCurveSegment segForArc;
|
|
TADSGePoint3d ptBase = pRec->origin();
|
|
ads_matrix mat1, mat2;
|
|
ConstructMatrix(ptBase, ptLoc, scale[0], scale[1], scale[2], nRot, mat1);
|
|
Get2DCurveFromBlock(*pRec, mat2, lstTemp);
|
|
AcGeMatrix3d mat= pInsert->blockTransform();
|
|
for (int i = 0; i < lstTemp.Length(); i++)
|
|
{
|
|
TGGeCurveSegment* seg;
|
|
seg = lstTemp.GetAt(i);
|
|
seg->SetStartPoint(mat * seg->StartPoint().AsAcGePoint3d());
|
|
seg->SetEndPoint(mat * seg->EndPoint().AsAcGePoint3d());
|
|
}
|
|
lstResult.Append(new TGGeCurveSegment(GetFirstInterLine(lstTemp, m_segSelLine, segForArc)));
|
|
lstResult.Append(new TGGeCurveSegment(GetLastInterLine(lstTemp, m_segSelLine)));
|
|
}
|
|
}
|
|
|
|
TGGeCurveSegment CParallelDimStyle::GetFirstInterLine(TDPtrList<TGGeCurveSegment> &lstInput, TGGeCurveSegment& ln, TGGeCurveSegment &segForArc)
|
|
{
|
|
TGGeCurveSegment segFirst;
|
|
double minDist=1E10, distTmp = 0, distTmp1 = 0;
|
|
XPoint ptFirst;
|
|
AcGeVector3d vec = ln.GetEndPoint().AsAcGePoint3d() - ln.GetStartPoint().AsAcGePoint3d();
|
|
for(int i=0;i<lstInput.Length();i++)
|
|
{
|
|
TGGeCurveSegment* segItem;
|
|
XPoint ptInt[2];
|
|
segItem = lstInput[i];
|
|
int nInterNum = segItem->Intersection(ln,ptInt[0], ptInt[1]);
|
|
distTmp=abs(ln.StartPoint().Distance2d(ptInt[0]));
|
|
if (nInterNum == 2)
|
|
distTmp1 = abs(ln.StartPoint().Distance2d(ptInt[1]));
|
|
if(nInterNum > 0 && (distTmp <= minDist || (distTmp1 <= minDist && nInterNum == 2)))
|
|
{
|
|
if (distTmp1 > 1.0e-6)
|
|
{
|
|
if (distTmp < distTmp1)
|
|
{
|
|
ptFirst = ptInt[0];
|
|
minDist = distTmp;
|
|
}
|
|
else
|
|
{
|
|
ptFirst = ptInt[1];
|
|
minDist = distTmp1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ptFirst = ptInt[0];
|
|
minDist = distTmp;
|
|
}
|
|
segFirst = *segItem;
|
|
}
|
|
}
|
|
if (abs(segFirst.GetBulge()) > 1.0e-6)
|
|
{
|
|
XPoint ptCenter;
|
|
AcGeVector3d vecPtFirToCenter;
|
|
AcGeVector3d vec = ln.GetEndPoint().AsAcGePoint3d() - ln.GetStartPoint().AsAcGePoint3d();
|
|
ptCenter = segFirst.GetArc().GetCenterPt();
|
|
XLine xLine(ptFirst, ptCenter);
|
|
vecPtFirToCenter = ptFirst.AsAcGePoint3d() - ptCenter.AsAcGePoint3d();
|
|
if(vecPtFirToCenter.dotProduct(vec) < 1.0e-6)
|
|
vecPtFirToCenter = -vecPtFirToCenter;
|
|
XPoint ptStart, ptEnd, ptLnEnd, ptLnStart;
|
|
ln.GetEndPoint(ptLnEnd);
|
|
ln.GetStartPoint(ptLnStart);
|
|
ptEnd = ptFirst + ln.GetLength() * vecPtFirToCenter / vecPtFirToCenter.length();
|
|
ptStart = ptFirst - ln.GetLength() * vecPtFirToCenter / vecPtFirToCenter.length();
|
|
TGGeCurveSegment segDim(ptFirst, ptEnd, 0.0);
|
|
segDim.ProjectToMe(ptLnEnd, ptEnd);
|
|
segDim.ProjectToMe(ptLnStart, ptStart);
|
|
segDim.SetStartPoint(ptStart);
|
|
segDim.SetEndPoint(ptEnd);
|
|
segForArc = segDim;
|
|
}
|
|
return segFirst;
|
|
}
|
|
|
|
TGGeCurveSegment CParallelDimStyle::GetLastInterLine(TDPtrList<TGGeCurveSegment> &lstInput, const TGGeCurveSegment& ln)
|
|
{
|
|
TGGeCurveSegment segLast;
|
|
double maxDist=0, distTmp = 0;
|
|
for(int i=0;i<lstInput.Length();i++)//最近的线作为方向基准
|
|
{
|
|
TGGeCurveSegment* segItem;
|
|
XPoint ptInt[2];
|
|
segItem = lstInput[i];
|
|
int num = segItem->Intersection(ln,ptInt[0], ptInt[1]);
|
|
distTmp=abs(ln.StartPoint().Distance2d(ptInt[0]));
|
|
if(num > 0 && distTmp >= maxDist)
|
|
{
|
|
maxDist = distTmp;
|
|
segLast = *segItem;
|
|
}
|
|
}
|
|
return segLast;
|
|
}
|
|
|
|
void CParallelDimStyle::GetParallelLine(TDPtrList<TGGeCurveSegment> &lstInput, TDPtrList<TGGeCurveSegment> &lstResult, const TGGeCurveSegment& ln)
|
|
{
|
|
AcGeVector3d vtFirst = ln.StartPoint().AsAcGePoint3d() - ln.EndPoint().AsAcGePoint3d();//基准向量
|
|
vtFirst.normalize();
|
|
for(int i=0;i<lstInput.Length();i++)
|
|
{
|
|
TGGeCurveSegment* segTemp;
|
|
segTemp = lstInput[i];
|
|
if (abs(segTemp->GetBulge()) < 1.0e-6)
|
|
{
|
|
AcGeVector3d vtTemp = segTemp->StartPoint().AsAcGePoint3d() - segTemp->EndPoint().AsAcGePoint3d();
|
|
if (vtTemp.isParallelTo(vtFirst) || vtTemp.isParallelTo(-vtFirst))
|
|
{
|
|
lstResult.Append(new TGGeCurveSegment(*lstInput[i]));
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
//判断取得的线是否平行弧线
|
|
void CParallelDimStyle::GetParallelLineForArc(TDPtrList<TGGeCurveSegment> &lstInput, TDPtrList<TGGeCurveSegment> &lstResult, const TGGeCurveSegment& ln)
|
|
{
|
|
XPoint ptCenter;
|
|
TGGeArc tgARC = ln.GetArc();
|
|
tgARC.Center(ptCenter);
|
|
for(int i=0;i<lstInput.Length();i++)
|
|
{
|
|
XPoint pt1;
|
|
TGGeArc tgARC = lstInput[i]->GetArc();
|
|
tgARC.Center(pt1);
|
|
if (pt1.AsAcGePoint3d().isEqualTo(ptCenter.AsAcGePoint3d()))
|
|
{
|
|
lstResult.Append(new TGGeCurveSegment(*lstInput[i]));
|
|
}
|
|
}
|
|
}
|
|
|
|
int CParallelDimStyle::GetInterPt(TDPtrList<TGGeCurveSegment> &lstInterLine, TADSGePointList& lstInterPt, TGGeCurveSegment& segln)
|
|
{
|
|
TGGeCurveSegment segx;
|
|
int nCount=lstInterLine.Length();
|
|
for(int n=0; n<nCount; n++)
|
|
{
|
|
segx=*lstInterLine[n];
|
|
//segx.SetLineFlag(LS_INFINITE);
|
|
XPoint ptInt[2];
|
|
segx.SetElevation(0.0);
|
|
int nIntNum=segx.Intersection(segln, ptInt[0], ptInt[1]);//求交点
|
|
for(int k=0; k<nIntNum; k++)
|
|
{
|
|
if(segln.HitTest2d(ptInt[k]) == 5)
|
|
lstInterPt.NewAppend(ptInt[k]);
|
|
}
|
|
}
|
|
return lstInterPt.Length();
|
|
}
|
|
void CParallelDimStyle::ParallelDimensioning(BOOL bParallelDim)
|
|
{
|
|
XPoint pt1, pt2;
|
|
|
|
int iRet;
|
|
InitLayer(LAY_DIM);
|
|
|
|
if (bParallelDim)
|
|
{
|
|
CStringArray aryLayerName, aryKeyWord;
|
|
aryKeyWord.Add(_T("轴线"));
|
|
GetLayerNameByKeyWord(aryLayerName, aryKeyWord);
|
|
g_aryLayerName.Copy(aryLayerName);
|
|
g_sSaveFileName = _T("LayerFilter_Parallel.txt");
|
|
}
|
|
else
|
|
{
|
|
CStringArray aryLayerName, aryKeyWord;
|
|
aryKeyWord.Add(_T("道路中线"));
|
|
aryKeyWord.Add(_T("道路"));
|
|
GetLayerNameByKeyWord(aryLayerName, aryKeyWord);
|
|
g_aryLayerName.Copy(aryLayerName);
|
|
g_sSaveFileName = _T("LayerFilter_RoadWide.txt");
|
|
}
|
|
CLayerSiftDlgEx dlg(NULL, TRUE);
|
|
dlg.GetSelectLayers(m_lstLayer);
|
|
while(1)
|
|
{
|
|
TDPtrList<TGGeCurveSegment> lstSegs,lstParaLineSegs;
|
|
TGGeCurveSegment segFirst, segx;
|
|
while(1)
|
|
{
|
|
INITGET_BEG(0, _T("S"));
|
|
iRet = ads_getpoint(NULL, _T("\n请选择起点或 [设置图层过滤 (S)]<退出>: "), pt1);
|
|
INITGET_END();
|
|
|
|
if (iRet == RTNORM)
|
|
{
|
|
break;
|
|
}
|
|
else if (iRet == RTKWORD)
|
|
{
|
|
if(dlg.DoModal() == IDOK)
|
|
{
|
|
m_lstLayer.RemoveAll();
|
|
dlg.GetSelectLayers(m_lstLayer);
|
|
}
|
|
continue;
|
|
}
|
|
else
|
|
return;
|
|
}
|
|
if ( ads_getpoint(pt1, _T("\n选择终点<退出>: "), pt2) != RTNORM)
|
|
{
|
|
return;
|
|
}
|
|
// pt1=Wcs2Ucs(pt1);
|
|
// pt2 = Wcs2Ucs(pt2);
|
|
lstParaLineSegs.Reset();
|
|
lstSegs.Reset();
|
|
BOOL bDrawFisrtpt = FALSE;
|
|
TPickEntSet ssDimObj(SS_FREE);
|
|
TGGeLine lineLeft, lineRight, lineSel(pt1, pt2);
|
|
lineSel.SetElevation(0.0);
|
|
lineLeft = lineSel.Offset(1); //左右向外偏移
|
|
lineRight = lineSel.Offset(-1);
|
|
XPoint ptLowLeft,ptLowRight,ptUpRight,ptUpLeft,ptInter;
|
|
double nSpace=100;
|
|
TADSGePoint3d pt1(lineLeft.GetStartPoint()),
|
|
pt2(lineRight.GetStartPoint()),
|
|
pt3(lineRight.GetEndPoint()),
|
|
pt4(lineLeft.GetEndPoint());
|
|
|
|
RBList rbFence=ads_buildlist(RT3DPOINT,&pt1,RT3DPOINT,&pt2,RT3DPOINT,&pt3,RT3DPOINT,&pt4,NULL);
|
|
|
|
RBList dimMask(RTDXF0,// , ATS_CORNER_WINDOW
|
|
_T("POLYLINE,LWPOLYLINE,LINE,ARC,CIRCLE,ATS_WALL,ATS_CORNER_WINDOW,ATS_OPENING,TCH_INSERT,INSERT,ATS_MVINSERT,AEC_BLOCK_INSERT,ATS_COLUMN,ATS_BALCONY,ATS_APRON,ATS_STEP,ATS_SLAB,ATS_VERTSLAB,ATS_ASCENT"), NULL);
|
|
if (ssDimObj.Get(_T("CP"), rbFence, NULL, dimMask) != RTNORM) //选择集
|
|
{
|
|
return;
|
|
}
|
|
int nLength = ssDimObj.Length();
|
|
long n = 0;
|
|
TGGeCurveSegment ln(Ucs2Wcs(pt1), Ucs2Wcs(pt2), 0), segForArc;
|
|
m_segSelLine = ln;//选择线曲段
|
|
ln.SetElevation(0.0);
|
|
ln.SetLineFlag(LS_INFINITE);
|
|
TADSGePointList lstDimPoints;
|
|
for (n; n < ssDimObj.Length(); ++n)
|
|
{
|
|
AcDbEntity* pEntity;
|
|
Entity ssEnt=ssDimObj[n];
|
|
OPENOBJ_BEGIN(ssEnt,AcDb::kForRead,AcDbEntity,pEntity);
|
|
if(pEntity)
|
|
{
|
|
|
|
if (m_lstLayer.IsEmpty())
|
|
{
|
|
AnalysisTgEntToLine(pEntity, lstSegs);
|
|
}
|
|
else
|
|
{
|
|
CString strLayer = pEntity->layer();
|
|
if(m_lstLayer.Find(strLayer))
|
|
AnalysisTgEntToLine(pEntity, lstSegs);
|
|
}
|
|
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
int nInterPtNum = 0;//标注线个数
|
|
segFirst = GetFirstInterLine(lstSegs, ln, segForArc);
|
|
int l = segFirst.GetLength();////////////////////////////
|
|
l = ln.GetLength();
|
|
l = segForArc.GetLength();
|
|
if (abs(segFirst.GetBulge()) < 1.0e-6)
|
|
{
|
|
GetParallelLine(lstSegs, lstParaLineSegs, segFirst);
|
|
l = lstSegs.Length();
|
|
l = lstParaLineSegs.Length();
|
|
nInterPtNum = GetInterPt(lstParaLineSegs, lstDimPoints, ln);
|
|
}
|
|
else
|
|
{
|
|
GetParallelLineForArc(lstSegs, lstParaLineSegs, segFirst);
|
|
l = lstSegs.Length();
|
|
l = lstParaLineSegs.Length();
|
|
nInterPtNum = GetInterPt(lstParaLineSegs, lstDimPoints, segForArc);
|
|
}
|
|
|
|
if(nInterPtNum < 1)
|
|
{
|
|
adsout << _T("\n选中的与第一个对象平行的对象太少, 不能进行平行标注!");
|
|
return;
|
|
}
|
|
TGGeCurveSegment segTemp = segFirst;
|
|
double nDirection=segFirst.Direction(pt1);
|
|
if (segFirst.GetBulge() > 1.0e-6)
|
|
{
|
|
AcGeVector3d vec = lstDimPoints[lstDimPoints.Length()-1]->AsAcGePoint3d() - lstDimPoints[0]->AsAcGePoint3d();
|
|
vec = vec.rotateBy(0.5 * PI, AcGeVector3d::kZAxis);
|
|
double dLength = lstDimPoints[lstDimPoints.Length()-1]->Distance(*lstDimPoints[0]);
|
|
XPoint ptEnd = *lstDimPoints[0] + dLength * vec / vec.length();
|
|
TGGeCurveSegment segDim(*lstDimPoints[0], ptEnd, 0.0);
|
|
segFirst = segDim;
|
|
nDirection = segDim.Direction(pt1);
|
|
}
|
|
XPoint ptEnd = *lstDimPoints[lstDimPoints.Length()-1], ptStart=*lstDimPoints[0];
|
|
TVector3D vt = ptEnd - ptStart;
|
|
XVector3D vtSeg(segFirst.EndPoint().x - segFirst.StartPoint().x, segFirst.EndPoint().y - segFirst.StartPoint().y);
|
|
if((vt*vtSeg).z<0)
|
|
{
|
|
nDirection+=PI/2;
|
|
}
|
|
else
|
|
{
|
|
nDirection-=PI/2;
|
|
}
|
|
TDbDimension2* pdbDim = new TDbDimension2;
|
|
pdbDim->SetDist2DimLine(0.0);
|
|
pdbDim->SetStyleId(InitDimStyle(DS_LINEAR));
|
|
pdbDim->SetLocation(ptStart);
|
|
pdbDim->SetRotation(nDirection);
|
|
double nVal = fabs(vt&XVector3D(cos(nDirection), sin(nDirection)));
|
|
if (segTemp.GetBulge() > 1.0e-6)
|
|
{
|
|
nVal = vt.Length();
|
|
}
|
|
if(nVal<_DIST_SNAP)
|
|
{
|
|
adsout << _T("\n选中的与第一个对象平行的对象太少, 不能进行平行标注!");
|
|
return;
|
|
}
|
|
//尺寸最大距离
|
|
pdbDim->AppendSegment(nVal);
|
|
if(!pdbDim->IsValid())
|
|
return;
|
|
|
|
AcEdJig::DragStatus esjig;
|
|
CTParallelDimJig jig(pdbDim, lstDimPoints);
|
|
esjig = jig.doIt();
|
|
|
|
if (esjig != AcEdJig::kNormal)
|
|
{
|
|
return;
|
|
}
|
|
TDbDimension2 *pDim=(TDbDimension2 *)pdbDim->clone();
|
|
|
|
// sg add 120410，增加布局转角的设置，解决UCS下，文字方向错误的问题
|
|
pDim->SetLayoutRotation(Ucs2Wcs(0.0));
|
|
pDim->getEndPoint(pt1);
|
|
pDim->getStartPoint(ptStart);
|
|
pDim->getEndPoint(ptEnd);
|
|
if(g_nDimAdjust) pDim->AdjustDim(g_nDimAdjust!=2);
|
|
|
|
AcDbObjectId idLayer = idLayer = InitLayer(LAY_S_MARK);
|
|
if (bParallelDim && !g_bTextDefaultLayer)
|
|
idLayer = idLayer = acdbCurDwg()->clayer();
|
|
//获取当前图层
|
|
pDim->setLayer(idLayer);
|
|
AcDbObjectId idDim = AddToModelSpace((TDbEntity *)pDim);
|
|
actrTransactionManager->flushGraphics();
|
|
acedUpdateDisplay();
|
|
TDimParallelArg dimTwo;
|
|
XPushVar<int> osmode(_T("OSMODE"), GetFullOsMode(OS_INT|OS_END));
|
|
XPoint ptBase = Wcs2Ucs(*lstDimPoints[lstDimPoints.Length() - 1]);
|
|
XPoint ptShirr = ptBase;
|
|
XPoint ptOther;
|
|
while(true)
|
|
{
|
|
if(!dimTwo.CanUndo())
|
|
{
|
|
if(XGetPoint(ptShirr, _T("\n请输入其他标注点"), ptOther)== RTNORM)
|
|
{
|
|
ptShirr = ptOther;
|
|
dimTwo.Step(ptOther);
|
|
dimTwo.AddDim(idDim, ptOther);
|
|
}
|
|
else
|
|
return;
|
|
}
|
|
|
|
int nRet2;
|
|
INITGET_BEG(0, _T("U R"));
|
|
nRet2 = acedGetPoint(ptShirr, _T("\n请输入其他标注点或 [参考点(R)/撤消上一标注点(U)]<退出>:"), ptOther);
|
|
INITGET_END();
|
|
|
|
if(nRet2 == RTKWORD)
|
|
{
|
|
XString sKey;
|
|
acedGetInput(sKey);
|
|
if(sKey[0] == _T('R'))
|
|
acedGetPoint(NULL, _T("\n参考点:"), ptShirr);
|
|
else if(sKey[0] == _T('U'))
|
|
{
|
|
dimTwo.Undo(idDim);
|
|
if(dimTwo.CanUndo())
|
|
ptShirr = dimTwo.GetLastPoint();
|
|
else
|
|
ptShirr = ptBase;
|
|
}
|
|
}
|
|
else if(nRet2 == RTNORM)
|
|
{
|
|
ptShirr = ptOther;
|
|
dimTwo.Step(ptOther);
|
|
dimTwo.AddDim(idDim, ptOther);
|
|
}
|
|
else
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
void TDimParallelArg::AddDim(AcDbObjectId idDim, XPoint ptNew)
|
|
{
|
|
ptNew = Ucs2Wcs(ptNew);
|
|
OPENOBJ_BEGIN(idDim, AcDb::kForWrite, TDbDimension2, pDimNew);
|
|
ASSERT(pDimNew);
|
|
pDimNew->AddSegment(ptNew);
|
|
if(g_nDimAdjust)
|
|
pDimNew->AdjustDim(g_nDimAdjust!=2);
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
void TDimParallelArg::RemoveDim(AcDbObjectId idDim, XPoint ptOld)
|
|
{
|
|
ptOld = Ucs2Wcs(ptOld);
|
|
OPENOBJ_BEGIN(idDim, AcDb::kForWrite, TDbDimension2, pDimNew);
|
|
ASSERT(pDimNew);
|
|
pDimNew->FindAndRemoveSegment(ptOld);
|
|
if(g_nDimAdjust) pDimNew->AdjustDim(g_nDimAdjust!=2);
|
|
OPENOBJ_END();
|
|
}
|
|
void TDimParallelArg::Step(XPoint ptNew)
|
|
{
|
|
m_ptStack.Push(ptNew);
|
|
}
|
|
|
|
BOOL TDimParallelArg::CanUndo()
|
|
{
|
|
return m_ptStack.GetDepth() > 0;
|
|
}
|
|
|
|
void TDimParallelArg::Undo(AcDbObjectId idDim)
|
|
{
|
|
XPoint pt;
|
|
m_ptStack.GetTopData(pt);
|
|
if(CanUndo())
|
|
RemoveDim(idDim, pt);
|
|
m_ptStack.GoBack();
|
|
}
|
|
|
|
XPoint TDimParallelArg::GetLastPoint()
|
|
{
|
|
XPoint pt;
|
|
m_ptStack.GetTopData(pt);
|
|
return pt;
|
|
}
|
|
|
|
|
|
|