1096 lines
25 KiB
C++
1096 lines
25 KiB
C++
//-----------------------------------------------------------------------------+
|
|
// Copyright (C), 1998-2007, SH Software Co. Ltd.
|
|
// = FileName : XExplodeStream 类
|
|
// = Version : ver2.0
|
|
// = Author : zjq
|
|
// = CreateDate : 2002-09-09
|
|
// = Description: XExplodeStream 定义
|
|
// = Maintainers:
|
|
//
|
|
//-----------------------------------------------------------------------------+
|
|
#include "StdAfx.h"
|
|
#include "XExplodeStream.h"
|
|
#include "XDbObject.h"
|
|
#include "XPathParser.h"
|
|
#include "dbsol3d.h"
|
|
#include "dbregion.h"
|
|
#include "XTrianglePface.h"
|
|
#include "XHoleModel.h"
|
|
#include "DList.h"
|
|
#include "XPolygonEx.h"
|
|
#include "dbhatch.h"
|
|
#include "XGlobalFunc.h"
|
|
#include "XGlobalCurveFunc.h"
|
|
|
|
BOOL XExplodeStream::m_bFullExplode = FALSE;
|
|
BOOL XExplodeStream::m_bExportTch4 = FALSE;
|
|
|
|
XExplodeStream::XExplodeStream(AcDbVoidPtrArray &entArray)
|
|
{
|
|
m_pEntSet = &entArray;
|
|
m_nColor = 256;
|
|
m_bIsDragging = Adesk::kFalse;
|
|
|
|
//add by zjq on 100629 TArch8.5
|
|
m_crColor = AcCmColor();
|
|
}
|
|
|
|
XExplodeStream::~XExplodeStream()
|
|
{
|
|
|
|
}
|
|
|
|
BOOL XExplodeStream::IsFullExplode() const
|
|
{
|
|
return m_bFullExplode;
|
|
}
|
|
|
|
BOOL XExplodeStream::IsExportTch4() const
|
|
{
|
|
return m_bExportTch4;
|
|
}
|
|
|
|
AcDbVoidPtrArray * XExplodeStream::GetEntitySet()
|
|
{
|
|
return m_pEntSet;
|
|
}
|
|
|
|
Adesk::UInt16 XExplodeStream::GetColor() const
|
|
{
|
|
return m_nColor;
|
|
}
|
|
|
|
void XExplodeStream::SetColor(Adesk::UInt16 nColor)
|
|
{
|
|
m_nColor = nColor;
|
|
}
|
|
|
|
//add by zjq on 100629 TArch8.5
|
|
//COLORREF XExplodeStream::GetTrueColor() const
|
|
AcCmColor XExplodeStream::GetTrueColor() const
|
|
{
|
|
return m_crColor;
|
|
}
|
|
|
|
//void XExplodeStream::SetTrueColor(COLORREF crRef)
|
|
void XExplodeStream::SetTrueColor(AcCmColor crRef)
|
|
{
|
|
m_crColor = crRef;
|
|
}
|
|
|
|
// 设置图层，线型，颜色
|
|
void XExplodeStream::SetPropertiesFrom(const AcDbEntity *pEnt)
|
|
{
|
|
ASSERT(pEnt);
|
|
|
|
m_idLinetype = pEnt->linetypeId();
|
|
m_idLayer = pEnt->layerId();
|
|
m_nColor = pEnt->colorIndex();
|
|
|
|
#if ARX > 17
|
|
m_idMaterial = pEnt->materialId();
|
|
#endif
|
|
}
|
|
|
|
// 往集合加入实体, 并设置通用的三个属性
|
|
void XExplodeStream::Append(AcDbEntity *pEnt, BOOL bUseAutoProp)
|
|
{
|
|
ASSERT(m_pEntSet);
|
|
|
|
if (bUseAutoProp && IsAutoProp())
|
|
{
|
|
if (!!m_idLayer)
|
|
{
|
|
pEnt->setLayer(m_idLayer);
|
|
}
|
|
|
|
if (!!m_idLinetype)
|
|
{
|
|
pEnt->setLinetype(m_idLinetype);
|
|
}
|
|
|
|
#if ARX > 17
|
|
if (!!m_idMaterial)
|
|
{
|
|
pEnt->setMaterial(m_idMaterial);
|
|
}
|
|
#endif
|
|
|
|
//modify by zjq on 100629
|
|
//pEnt->setColorIndex(m_nColor);
|
|
if (m_crColor == AcCmColor())
|
|
{
|
|
pEnt->setColorIndex(m_nColor);
|
|
}
|
|
else
|
|
{
|
|
pEnt->setColor(m_crColor);
|
|
}
|
|
}
|
|
|
|
m_pEntSet->append(pEnt);
|
|
}
|
|
|
|
BOOL XExplodeStream::MakeBlockInsert(const XPoint &ptBase)
|
|
{
|
|
if (m_pEntSet->isEmpty())
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
AcDbBlockTableRecord *pBlockTableRec;
|
|
AcDbObjectId blockTableRecordId,EntId;
|
|
AcDbBlockTable *pBlockTable = NULL;
|
|
AcDbBlockReference *pBlk;
|
|
AcDbEntity *pEnt;
|
|
int i;
|
|
|
|
pBlockTableRec = new AcDbBlockTableRecord();
|
|
pBlockTableRec->setName(_T("*U"));
|
|
|
|
acdbCurDwg()->getBlockTable(pBlockTable,AcDb::kForWrite);
|
|
pBlockTable->add(blockTableRecordId, pBlockTableRec);
|
|
pBlockTable->close();
|
|
|
|
pBlockTableRec->setOrigin(ptBase);
|
|
for (i = 0;i < m_pEntSet->length();i++)
|
|
{
|
|
pEnt = (AcDbEntity *)(*m_pEntSet)[i];
|
|
pBlockTableRec->appendAcDbEntity(EntId,pEnt);
|
|
pEnt->close();
|
|
}
|
|
|
|
pBlockTableRec->close();
|
|
|
|
//insert block
|
|
pBlk = new AcDbBlockReference(ptBase,blockTableRecordId);
|
|
if (!!m_idLayer)
|
|
{
|
|
pBlk ->setLayer(m_idLayer);
|
|
}
|
|
|
|
#if ARX > 17
|
|
if (!!m_idMaterial)
|
|
{
|
|
pBlk->setMaterial(m_idMaterial);
|
|
}
|
|
#endif
|
|
|
|
while (!m_pEntSet->isEmpty())
|
|
{
|
|
m_pEntSet->removeAt(0);
|
|
}
|
|
|
|
m_pEntSet->append(pBlk);
|
|
|
|
pBlockTable = NULL;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
void XExplodeStream::DrawEntity(const AcDbEntity &ent)
|
|
{
|
|
AcDbEntity *pEnt = (AcDbEntity *)ent.clone();
|
|
ASSERT(pEnt);
|
|
|
|
m_pEntSet->append(pEnt);
|
|
}
|
|
|
|
void XExplodeStream::Polyline(AcDbPolyline &pline)
|
|
{
|
|
Append((AcDbEntity *)pline.clone());
|
|
}
|
|
|
|
void XExplodeStream::DrawLine(const XLine &ln, double nThickness)
|
|
{
|
|
AcDbLine *line = new AcDbLine(ln.GetStartPoint(), ln.GetEndPoint());
|
|
line->setThickness(nThickness);
|
|
|
|
Append(line);
|
|
}
|
|
|
|
void XExplodeStream::DrawArc(const XArc &ar, double nThickness)
|
|
{
|
|
AcDbArc *pArc = new AcDbArc(ar.GetCenterPt(), ar.GetRadius(), ar.GetStarAngle(), ar.GetEndAngle());
|
|
pArc->setThickness(nThickness);
|
|
|
|
Append(pArc);
|
|
}
|
|
|
|
void XExplodeStream::DrawCircle(const XCircle &cir, double nThickness)
|
|
{
|
|
AcDbCircle *pCir = new AcDbCircle(cir.GetCenterPt(), AcGeVector3d(0,0,1), cir.GetRadius());
|
|
pCir->setThickness(nThickness);
|
|
|
|
Append(pCir);
|
|
}
|
|
|
|
void XExplodeStream::DrawXPoly(const XPoly2D &poly,double nThickness)
|
|
{
|
|
AcDbPolyline *pline = new AcDbPolyline;
|
|
PolyConvert(poly, *pline);
|
|
pline->setThickness(nThickness);
|
|
|
|
Append(pline);
|
|
}
|
|
|
|
const TCHAR * XExplodeStream::Descriptor()
|
|
{
|
|
return _T("XExplodeStream");
|
|
}
|
|
|
|
const TCHAR * XExplodeStream::Desc()
|
|
{
|
|
return Descriptor();
|
|
}
|
|
|
|
Adesk::Boolean XExplodeStream::IsDragging() const
|
|
{
|
|
return m_bIsDragging;
|
|
}
|
|
|
|
void XExplodeStream::SetIsDragging(Adesk::Boolean bDragging)
|
|
{
|
|
m_bIsDragging = bDragging;
|
|
}
|
|
|
|
AcDbObjectId XExplodeStream::GetLineTypeId() const
|
|
{
|
|
return m_idLinetype;
|
|
}
|
|
|
|
AcDbObjectId XExplodeStream::GetMaterialId()const
|
|
{
|
|
return m_idMaterial;
|
|
}
|
|
|
|
Acad::ErrorStatus XExplodeStream::SetLineType(const TCHAR *pltype)
|
|
{
|
|
AcDbObjectId idLineType = GetLinetypeIdFromString(pltype);
|
|
if (!idLineType)
|
|
{
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
m_idLinetype = idLineType;
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus XExplodeStream::SetLineType(AcDbObjectId idLineType)
|
|
{
|
|
m_idLinetype = idLineType;
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus XExplodeStream::SetMaterial(AcDbObjectId idMaterial)
|
|
{
|
|
if (idMaterial.isValid())
|
|
{
|
|
m_idMaterial = idMaterial;
|
|
}
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
// 对polyOutline的方向没有规定
|
|
void XExplodeStream::DrawSolid(const XPoly2D &polyOutline)
|
|
{
|
|
if (polyOutline.Area() < 1E-6)//add by W on 070306
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbHatch *pHatch = NewHatchFromPoly2D(polyOutline, _T("SOLID"), 1.0);
|
|
ASSERT(pHatch);
|
|
|
|
Append(pHatch);
|
|
}
|
|
|
|
|
|
void XExplodeStream::DrawHatch(const XPoly2D &polyOutline, const TCHAR *pszPattern, double nScale)
|
|
{
|
|
if (!pszPattern)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (polyOutline.Area() < 1E-6)//add by W on 070306
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbHatch *pHatch = NewHatchFromPoly2D(polyOutline, pszPattern, nScale);
|
|
if (!pHatch)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Append(pHatch);
|
|
}
|
|
|
|
void XExplodeStream::DrawHatchEx(const XPoly2D &polyOutline, const TCHAR *pszPattern, double nScale,double rotation)
|
|
{
|
|
if (!pszPattern)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (polyOutline.Area() < 1E-6)//add by W on 070306
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbHatch *pHatch = NewHatchFromPoly2D(polyOutline, pszPattern, nScale,rotation);
|
|
if (!pHatch)
|
|
{
|
|
return;
|
|
}
|
|
|
|
Append(pHatch);
|
|
}
|
|
|
|
void XExplodeStream::DrawShell(Adesk::UInt32 nbVertex,
|
|
const AcGePoint3d* pVertexList,
|
|
Adesk::UInt32 faceListSize,
|
|
const Adesk::Int32* pFaceList,
|
|
const AcGiEdgeData* pEdgeData)
|
|
{
|
|
XPolygonEx *pLast = NULL;
|
|
XVector3D vtEcs;
|
|
Adesk::UInt8* visibleArray = pEdgeData ? pEdgeData->visibility() : NULL;
|
|
Adesk::UInt32 j = 0; //面索引
|
|
int nEdgeIndex = 0;
|
|
DList<XHoleModel> lstPolygons;
|
|
XHoleModel *pHoleModel = NULL;
|
|
|
|
while (j < faceListSize)
|
|
{
|
|
Adesk::Int32 nFaceNum = pFaceList[j];
|
|
if (nFaceNum > 0) //外轮廓
|
|
{
|
|
pHoleModel = new XHoleModel;
|
|
lstPolygons.Append(pHoleModel);
|
|
|
|
//XPolygonEx &polyEx1 = pHoleModel->m_outline;
|
|
XPolygonEx &polyEx1 = pHoleModel->GetOutLine();
|
|
for (Adesk::Int32 i = 1; i <= abs(nFaceNum); i++)
|
|
{
|
|
int nVertNum = pFaceList[j + i];
|
|
XPoint ptVert = pVertexList[nVertNum];
|
|
BOOL bVis = TRUE;
|
|
if (visibleArray)
|
|
{
|
|
if (visibleArray[nEdgeIndex] == kAcGiInvisible || visibleArray[nEdgeIndex] == kAcGiSilhouette)
|
|
{
|
|
bVis = FALSE;
|
|
}
|
|
}
|
|
|
|
polyEx1.AppendNode(ptVert, bVis);
|
|
nEdgeIndex++;
|
|
}
|
|
ASSERT(pHoleModel->IsValid());
|
|
}
|
|
else //洞口
|
|
{
|
|
ASSERT(pHoleModel->IsValid());
|
|
XPolygonEx *pHole = new XPolygonEx;
|
|
for (Adesk::Int32 i = 1; i <= abs(nFaceNum); i++)
|
|
{
|
|
int nVertNum = pFaceList[j + i];
|
|
XPoint ptVert = pVertexList[nVertNum];
|
|
BOOL bVis = TRUE;
|
|
if (visibleArray)
|
|
{
|
|
if (visibleArray[nEdgeIndex] == kAcGiInvisible || visibleArray[nEdgeIndex] == kAcGiSilhouette)
|
|
{
|
|
bVis = FALSE;
|
|
}
|
|
}
|
|
|
|
pHole->AppendNode(ptVert, bVis);
|
|
nEdgeIndex++;
|
|
}
|
|
|
|
ASSERT(pHole->Length() >= 3);
|
|
//pHoleModel->m_holes.Append(pHole);
|
|
pHoleModel->AppendHoleList(pHole);
|
|
}
|
|
|
|
j += abs(nFaceNum) + 1;
|
|
}
|
|
|
|
for (int k = 0; k < lstPolygons.Length(); k++)
|
|
{
|
|
XHoleModel *pModel = lstPolygons[k];
|
|
DList<XTriangle> lstTris;
|
|
|
|
if (!pModel->Triangulate(FALSE, lstTris))
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
for (int n = 0; n < lstTris.Length(); n++)
|
|
{
|
|
XTriangle *triangle = lstTris[n];
|
|
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);
|
|
Append(pFace);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// 根据给定的内外边界, 绘制三维外壳
|
|
// 如果有圆弧边界，则必须平行于XY平面
|
|
void XExplodeStream::DrawShell(const XPoly2D &polyOut1, const DList<XPoly2D> &lstPolyIn1)
|
|
{
|
|
int i = 0;
|
|
if (g_bEnableAcis)
|
|
{
|
|
XPoly poly1, poly2;
|
|
((XPoly2D &)polyOut1).MapToPolygon1(poly1, _AS_SYS_UNIT(g_nCirDeviation));
|
|
|
|
ASSERT(poly1.Length() > 2);
|
|
|
|
XHoleModel model;
|
|
for (int k = 0; k < poly1.Length(); k++)
|
|
{
|
|
//model.m_outline.AppendNode(*poly1[k], TRUE);
|
|
model.GetOutLine().AppendNode(*poly1[k], TRUE);
|
|
}
|
|
|
|
for (i = 0; i < lstPolyIn1.Length(); i++)
|
|
{
|
|
((XPoly2D &)lstPolyIn1[i]).MapToPolygon1(poly2, _AS_SYS_UNIT(g_nCirDeviation));
|
|
|
|
XPolygonEx *polyEx2 = new XPolygonEx(poly2);
|
|
//model.m_holes.Append(polyEx2);
|
|
model.AppendHoleList(polyEx2);
|
|
}
|
|
|
|
XTrianglePface lstTris;
|
|
if (model.Triangulate(FALSE, lstTris))
|
|
{
|
|
for (int n = 0; n < lstTris.Length(); n++)
|
|
{
|
|
XTriangle *triangle = lstTris[n];
|
|
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);
|
|
|
|
Append(pFace);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
DList<XCurveSegment> lstSegs;
|
|
ExplodePoly2D(polyOut1, lstSegs);
|
|
|
|
for (i = 0; i < lstPolyIn1.Length(); i++)
|
|
{
|
|
ExplodePoly2D(polyOut1, lstSegs);
|
|
}
|
|
|
|
for (i = 0; i < lstSegs.Length(); i++)
|
|
{
|
|
Append(lstSegs[i]->AsAcDbCurve());
|
|
}
|
|
}
|
|
}
|
|
|
|
// make a 3DSolid
|
|
void XExplodeStream::DrawBody(const XPoly2D &polySrc, const XVector3D &vtOffset)
|
|
{
|
|
DList<XPoly2D> lstPoly;
|
|
DrawBody(polySrc, lstPoly, vtOffset);
|
|
}
|
|
|
|
void XExplodeStream::DrawBody(const XPoly2D &polyOut, const DList<XPoly2D> &lstHoles, const XVector3D &vtOffset)
|
|
{
|
|
if (g_bEnableAcis)
|
|
{
|
|
if (g_bExplodeMesh)
|
|
{
|
|
// 绘制侧面
|
|
for (int i = 0; i < lstHoles.Length(); i++)
|
|
{
|
|
DrawMesh(lstHoles[i], vtOffset);
|
|
}
|
|
|
|
DrawMesh(polyOut, vtOffset);
|
|
|
|
//绘制前台面
|
|
DrawShell(polyOut, lstHoles);
|
|
|
|
//绘制后台面
|
|
XPoly2D polyUp(polyOut);
|
|
for (int i = 0; i < polyUp.Length(); i++)
|
|
{
|
|
*polyUp[i] += vtOffset;
|
|
}
|
|
|
|
DList<XPoly2D> lstHoleUp;
|
|
for (int n = 0; n < lstHoles.Length(); n++)
|
|
{
|
|
XPoly2D *pHole = new XPoly2D(lstHoles[n]);
|
|
for (int j = 0; j < pHole->Length(); j++)
|
|
{
|
|
*(*pHole)[j] += vtOffset;
|
|
}
|
|
|
|
lstHoleUp.Append(pHole);
|
|
}
|
|
|
|
DrawShell(polyUp, lstHoleUp);
|
|
}
|
|
else
|
|
{
|
|
AcDbRegion *regioni = AsRegion(polyOut);
|
|
if (!regioni)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcGeVector3d vtNormalI;
|
|
VERIFY(regioni->getNormal(vtNormalI) == Acad::eOk);
|
|
|
|
double dThickI = vtOffset.Length();
|
|
if (vtNormalI.angleTo(vtOffset) > PI / 2.0)
|
|
{
|
|
dThickI = -dThickI;
|
|
}
|
|
|
|
AcDb3dSolid *solid3di = new AcDb3dSolid();
|
|
VERIFY(solid3di->extrude(regioni, dThickI,0.0) == Acad::eOk);
|
|
delete regioni;
|
|
|
|
for (int n = 0; n < lstHoles.Length(); n++)
|
|
{
|
|
const XPoly2D polyIn = lstHoles[n];
|
|
AcDbRegion *regionj = AsRegion(polyIn);
|
|
if (!regionj)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
AcGeVector3d vtNormalJ;
|
|
VERIFY(regionj->getNormal(vtNormalJ) == Acad::eOk);
|
|
AcDb3dSolid *solid3dj = new AcDb3dSolid();
|
|
double dThickJ = vtOffset.Length();
|
|
if (vtNormalJ.angleTo(vtOffset) > PI / 2.0)
|
|
{
|
|
dThickJ = -dThickJ;
|
|
}
|
|
|
|
VERIFY(solid3dj->extrude(regionj,dThickJ,0.0) == Acad::eOk);
|
|
delete regionj;
|
|
if (solid3di->booleanOper(AcDb::kBoolSubtract,solid3dj) != Acad::eOk)
|
|
{
|
|
delete solid3di;
|
|
delete solid3dj;
|
|
|
|
return;
|
|
}
|
|
|
|
delete solid3dj;
|
|
}
|
|
|
|
if (solid3di->isNull())
|
|
{
|
|
delete solid3di;
|
|
}
|
|
else
|
|
{
|
|
Append(solid3di);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
XPoly2D polyOffsetOut(polyOut);
|
|
DList<XCurveSegment> lstSegs;
|
|
for (int i = 0; i < polyOffsetOut.Length(); i++)
|
|
{
|
|
*polyOffsetOut[i] += vtOffset;
|
|
lstSegs.Append(new XCurveSegment(polyOut[i], *polyOffsetOut[i], 0.0));
|
|
}
|
|
|
|
ExplodePoly2D(polyOut, lstSegs);
|
|
ExplodePoly2D(polyOffsetOut, lstSegs);
|
|
|
|
for (int n = 0; n < lstHoles.Length(); n++)
|
|
{
|
|
XPoly2D polyIn(lstHoles[n]);
|
|
XPoly2D polyOffsetIn(polyIn);
|
|
for (int i = 0; i < polyOffsetIn.Length(); i++)
|
|
{
|
|
*polyOffsetIn[i] += vtOffset;
|
|
lstSegs.Append(new XCurveSegment(*polyIn[i], *polyOffsetIn[i], 0.0));
|
|
}
|
|
|
|
ExplodePoly2D(polyIn, lstSegs);
|
|
ExplodePoly2D(polyOffsetIn, lstSegs);
|
|
}
|
|
|
|
for (int i = 0; i < lstSegs.Length(); i++)
|
|
{
|
|
Append(lstSegs[i]->AsAcDbCurve());
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void XExplodeStream::DrawBody(const XPoly2D &polyOut, const XPoly2D &polyIn, const XVector3D &vtOffset)
|
|
{
|
|
DList<XPoly2D> lstHoles;
|
|
lstHoles.Append(new XPoly2D(polyIn));
|
|
|
|
DrawBody(polyOut, lstHoles, vtOffset);
|
|
}
|
|
|
|
void XExplodeStream::DrawMesh( const Adesk::UInt32 rows,
|
|
const Adesk::UInt32 columns,
|
|
const AcGePoint3d* pVertexList,
|
|
const AcGiEdgeData* pEdgeData)
|
|
{
|
|
for (Adesk::UInt32 m = 0; m < rows - 1; m++)
|
|
{
|
|
for (Adesk::UInt32 n = 0; n < columns - 1; n++)
|
|
{
|
|
int idVertex1 = m * columns + n;
|
|
int idVertex2 = m * columns + n + 1;
|
|
int idVertex3 = (m + 1) * columns + n + 1;
|
|
int idVertex4 = (m + 1) * columns + n;
|
|
Adesk::Boolean bVis1 = Adesk::kTrue, bVis2 = Adesk::kTrue,
|
|
bVis3 = Adesk::kTrue, bVis4 = Adesk::kTrue;
|
|
if (pEdgeData)
|
|
{
|
|
Adesk::UInt8 *pVisArray = pEdgeData->visibility();
|
|
if (pVisArray)
|
|
{
|
|
bVis1 = pVisArray[m * (columns - 1) + n];
|
|
bVis2 = pVisArray[rows * (columns - 1) + m * columns + n + 1];
|
|
bVis3 = pVisArray[(m + 1) * (columns - 1) + n];
|
|
bVis4 = pVisArray[rows * (columns - 1) + m * columns + n];
|
|
}
|
|
}
|
|
|
|
AcDbFace *pFace = new AcDbFace(pVertexList[idVertex1],
|
|
pVertexList[idVertex2], pVertexList[idVertex3], pVertexList[idVertex4],
|
|
bVis1, bVis2, bVis3, bVis4);
|
|
|
|
Append(pFace);
|
|
}
|
|
}
|
|
}
|
|
|
|
// 根据给定的边界和凸起方向, 绘制三维外壳
|
|
void XExplodeStream::DrawMesh(const XPoly2D &polyOut, const XVector3D &vtOffset)
|
|
{
|
|
XPoly poly;
|
|
polyOut.AsOpenPoly1(poly, _AS_SYS_UNIT(g_nCirDeviation)); //变成开口的poly, 如果原先封闭, 则起点复制为终点
|
|
|
|
int nColumn = poly.Length(); //+1;
|
|
int nRow = 2;
|
|
XPoint *ptArray = new XPoint[nColumn*nRow];
|
|
for (int m = 0; m < nRow; m++)
|
|
{
|
|
for (int n = 0; n < nColumn; n++)
|
|
{
|
|
int nBase = m * nColumn;
|
|
ptArray[nBase + n] = *poly[n];
|
|
|
|
if (m == 1)
|
|
{
|
|
ptArray[nBase + n] += vtOffset;
|
|
}
|
|
}
|
|
}
|
|
|
|
AcGePoint3dArray vertexArray;
|
|
for (int i = 0; i < nColumn * nRow; i++)
|
|
{
|
|
vertexArray.append(ptArray[i]);
|
|
}
|
|
|
|
AcDbPolygonMesh mesh(AcDb::kSimpleMesh, nRow, nColumn, vertexArray,
|
|
Adesk::kFalse, Adesk::kFalse);
|
|
|
|
AcDbVoidPtrArray entSet;
|
|
mesh.explode(entSet);
|
|
|
|
int nCount = entSet.length();
|
|
for (int idx = 0; idx < nCount; idx++)
|
|
{
|
|
Append((AcDbEntity *)entSet[idx]);
|
|
}
|
|
|
|
delete [] ptArray;
|
|
}
|
|
|
|
// 显示分别连接两个区域的边缘构成的侧面
|
|
void XExplodeStream::DrawMesh(const XPoly2D &polyRegion1, const XPoly2D &polyRegion2)
|
|
{
|
|
XPoly poly1, poly2;
|
|
polyRegion1.AsOpenPoly(poly1); //变成开口的poly, 如果原先封闭, 则起点复制为终点
|
|
polyRegion2.AsOpenPoly(poly2);
|
|
|
|
if (poly1.Length() != poly2.Length())
|
|
{
|
|
return;
|
|
}
|
|
|
|
int nColumn = poly1.Length(); //+1;
|
|
int nRow = 2;
|
|
XPoint *ptArray = new XPoint[nColumn * nRow];
|
|
|
|
for (int m = 0; m < nRow; m++)
|
|
{
|
|
for (int n = 0; n < nColumn; n++)
|
|
{
|
|
int nBase = m * nColumn;
|
|
if (!m)
|
|
{
|
|
ptArray[nBase + n] = *poly1[n];
|
|
}
|
|
else
|
|
{
|
|
ptArray[nBase + n] = *poly2[n];
|
|
}
|
|
}
|
|
}
|
|
|
|
AcGePoint3dArray vertexArray;
|
|
for (int i = 0; i < nColumn*nRow; i++)
|
|
{
|
|
vertexArray.append(ptArray[i]);
|
|
}
|
|
|
|
AcDbPolygonMesh mesh(AcDb::kSimpleMesh, nRow, nColumn, vertexArray,
|
|
Adesk::kFalse, Adesk::kFalse);
|
|
AcDbVoidPtrArray entSet;
|
|
mesh.explode(entSet);
|
|
|
|
int nCount = entSet.length();
|
|
for (int idx = 0; idx < nCount; idx++)
|
|
{
|
|
Append((AcDbEntity *)entSet[idx]);
|
|
}
|
|
|
|
delete [] ptArray;
|
|
}
|
|
|
|
void XExplodeStream::DrawFace(const X3DFace &face0)
|
|
{
|
|
if (face0.IsPoint() || face0.IsLinear())
|
|
{
|
|
#ifndef NDEBUG
|
|
XGeLib::adsout << _T("\nXExplodeStream: Bad 3dface is skipped!");
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
X3DFace face(face0);
|
|
if (face.IsTriangle(2))
|
|
{
|
|
if (face.GetVertex(0).Distance(face.GetVertex(1)) < _DIST_SNAP)
|
|
{
|
|
face.MoveShift(FALSE);
|
|
}
|
|
else if (face.GetVertex(1).Distance(face.GetVertex(2)) < _DIST_SNAP)
|
|
{
|
|
face.MoveShift(FALSE);
|
|
face.MoveShift(FALSE);
|
|
}
|
|
else if (face.GetVertex(2).Distance(face.GetVertex(3)) < _DIST_SNAP)
|
|
{
|
|
face.MoveShift(TRUE);
|
|
}
|
|
|
|
ASSERT(face.IsTriangle(1));
|
|
}
|
|
|
|
AcDbFace *pDbFace = new AcDbFace(face.GetVertex(0), face.GetVertex(1),
|
|
face.GetVertex(2), face.GetVertex(3),
|
|
((face.GetFlag() & 0x01) == 0),
|
|
((face.GetFlag() & 0x02) == 0),
|
|
((face.GetFlag() & 0x04) == 0),
|
|
((face.GetFlag() & 0x08) == 0));
|
|
Append(pDbFace);
|
|
}
|
|
}
|
|
|
|
void XExplodeStream::DrawText(const TCHAR *pszContent)
|
|
{
|
|
AcDbObjectId idTextStyle = m_idTextStyle;
|
|
if (!idTextStyle)
|
|
{
|
|
XString sTextStyle;
|
|
xg_getvar(_T("TEXTSTYLE"), sTextStyle);
|
|
idTextStyle = GetTextStyleId(sTextStyle);
|
|
}
|
|
|
|
if (!idTextStyle || !pszContent)
|
|
{
|
|
return;
|
|
}
|
|
|
|
XDbObject obj(idTextStyle, AcDb::kForRead);
|
|
if (!obj)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbTextStyleTableRecord *newStyle = AcDbTextStyleTableRecord::cast(obj.m_pObject);
|
|
if (!newStyle)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double nTextSize = m_nHeight;
|
|
if (nTextSize < 1.0E-5)
|
|
{
|
|
nTextSize = newStyle->textSize();
|
|
}
|
|
|
|
if (nTextSize < 1.0E-5)
|
|
{
|
|
xg_getvar(_T("TEXTSIZE"), &nTextSize);
|
|
if (nTextSize < 1.0E-5)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
double nWidthFactor = newStyle->xScale();
|
|
if (m_nControlFlag & EDF_XSCALE) //Modify on 2002/10/13
|
|
{
|
|
nWidthFactor = m_nWidthFactor;
|
|
}
|
|
|
|
//refreshed by W on 050424,原错误：PI/2到3PI/2转角的文字被强制修改为(-PI/2,PI/2)区间
|
|
//AcDbText *pAttrib = new AcDbText(m_ptLocation, pszContent, idTextStyle, nTextSize, XExport::xg_angle(m_nRotation));
|
|
AcDbText *pAttrib = new AcDbText(m_ptLocation, pszContent, idTextStyle, nTextSize, m_nRotation);
|
|
|
|
pAttrib->setHeight(nTextSize);
|
|
pAttrib->setWidthFactor(nWidthFactor);
|
|
|
|
AcDb::TextHorzMode nHMode;
|
|
AcDb::TextVertMode nVMode;
|
|
Adesk::UInt16 nAlignMode = GetTextAlignment(m_align);
|
|
nHMode = (AcDb::TextHorzMode)LOBYTE(nAlignMode);
|
|
nVMode = (AcDb::TextVertMode)HIBYTE(nAlignMode);
|
|
pAttrib->setHorizontalMode(nHMode);
|
|
pAttrib->setVerticalMode(nVMode);
|
|
|
|
pAttrib->setAlignmentPoint(m_ptLocation);
|
|
Append(pAttrib);
|
|
}
|
|
|
|
void XExplodeStream::DrawTextFit(const TCHAR *pszText, XPoint pt1, XPoint pt2, double nTextHeight)
|
|
{
|
|
ASSERT(m_bInitStyle);
|
|
double nTextSize = nTextHeight;
|
|
if (nTextSize < 1.0E-5)
|
|
{
|
|
return;
|
|
}
|
|
|
|
double nOldSize = m_textStyle.textSize();
|
|
m_textStyle.setTextSize(nTextSize);
|
|
|
|
Adesk::Boolean bIncludeSpace = Adesk::kTrue;
|
|
TCHAR *pTypeface = NULL;
|
|
Adesk::Boolean bBold, bItalic;
|
|
#if ARX < 21
|
|
int tmp0, tmp1;
|
|
BOOL bWinFont = (m_textStyle.font(pTypeface, bBold, bItalic, tmp0, tmp1) == Acad::eOk);
|
|
#else
|
|
Autodesk::AutoCAD::PAL::FontUtils::FontPitch tmp0;
|
|
Autodesk::AutoCAD::PAL::FontUtils::FontFamily tmp1;
|
|
Charset charset;
|
|
BOOL bWinFont = (m_textStyle.font(pTypeface, bBold, bItalic, charset, tmp0, tmp1) == Acad::eOk);
|
|
#endif
|
|
if (bWinFont)
|
|
{
|
|
if (!pTypeface || !pTypeface[0])
|
|
{
|
|
bWinFont = FALSE;
|
|
}
|
|
}
|
|
|
|
if (pTypeface)
|
|
{
|
|
delete[] pTypeface;
|
|
}
|
|
|
|
if (bWinFont)
|
|
{
|
|
bIncludeSpace = Adesk::kTrue;
|
|
}
|
|
else
|
|
{
|
|
bIncludeSpace = Adesk::kFalse;
|
|
const TCHAR *pShxFile = m_textStyle.fileName();
|
|
if (pShxFile)
|
|
{
|
|
XPathParser paser(pShxFile);
|
|
_tcsupr(paser.m_sFileName);
|
|
|
|
TCHAR sFilter[] = _T("GBE*,GOTH*,ISO*,SCRIPT*,ROMAN*");
|
|
if (ads_wcmatch(paser.m_sFileName, sFilter) == RTNORM)
|
|
{
|
|
bIncludeSpace = Adesk::kTrue;
|
|
}
|
|
}
|
|
}
|
|
|
|
AcGePoint2d ptExt = m_textStyle.extents(pszText, bIncludeSpace, -1, Adesk::kFalse);
|
|
double nWidth = ptExt[0];
|
|
double nWidthFactor = pt1.Distance2d(pt2) / nWidth;
|
|
m_textStyle.setTextSize(nOldSize);
|
|
|
|
AcDbObjectId idTextStyle = m_idTextStyle;;
|
|
if (!idTextStyle)
|
|
{
|
|
XString sTextStyle;
|
|
xg_getvar(_T("TEXTSTYLE"), sTextStyle);
|
|
idTextStyle = GetTextStyleId(sTextStyle);
|
|
}
|
|
|
|
AcDbText *pAttrib = new AcDbText;
|
|
pAttrib->setHorizontalMode(AcDb::kTextFit);
|
|
pAttrib->setVerticalMode(AcDb::kTextBase);
|
|
pAttrib->setTextStyle(idTextStyle);
|
|
pAttrib->setTextString(pszText);
|
|
pAttrib->setPosition(pt1);
|
|
pAttrib->setAlignmentPoint(pt2);
|
|
pAttrib->setHeight(nTextHeight);
|
|
|
|
//modified by W 051023
|
|
pAttrib->setWidthFactor(nWidthFactor);
|
|
pAttrib->setHorizontalMode(AcDb::kTextFit);
|
|
|
|
//add by W on 060218
|
|
XPoint vt = pt2 - pt1;
|
|
pAttrib->setRotation(vt.AsAcGeVector2d().angle());
|
|
|
|
Append(pAttrib);
|
|
}
|
|
|
|
// 增加一图块
|
|
void XExplodeStream::DrawBlock(const AcDbBlockTableRecord &blockRec, const XPoint &ptInsert, const AcGeScale3d &scales,
|
|
double nRot, BOOL bMakeBlock)
|
|
{
|
|
AcDbObjectId idBlock = blockRec.objectId();
|
|
if (!idBlock)
|
|
{
|
|
return;
|
|
}
|
|
|
|
AcDbBlockReference * pInsert = new AcDbBlockReference(ptInsert, idBlock);
|
|
pInsert->setScaleFactors(scales);
|
|
pInsert->setRotation(nRot);
|
|
|
|
if (bMakeBlock)
|
|
{
|
|
Append(pInsert);
|
|
}
|
|
else
|
|
{
|
|
XMasterProperties prop;
|
|
InitModel(prop, pInsert, NULL, *m_pEntSet);
|
|
delete pInsert;
|
|
}
|
|
}
|
|
|
|
void XExplodeStream::DrawAtomicEntSet(const AcDbVoidPtrArray &entSet, const AcGeMatrix3d &matTrans)
|
|
{
|
|
TCHAR szMatch[256] = _T("AEC_*");
|
|
int nCount = entSet.length();
|
|
for (int i = 0; i < nCount; i++)
|
|
{
|
|
AcDbEntity *pEntity = (AcDbEntity *)entSet[i];
|
|
AcDbPolyline *pline = AsPolyline(pEntity);
|
|
if (pline)
|
|
{
|
|
XPoly2D poly2d;
|
|
PolyConvert(*pline, poly2d);
|
|
|
|
XVector3D vtNormal;
|
|
(AcGeVector3d &)vtNormal = pline->normal();
|
|
double nElev = 0.0;
|
|
AcGeMatrix2d xform2d(matTrans.convertToLocal(vtNormal,nElev));
|
|
ads_matrix mat0 = {
|
|
{xform2d(0,0), xform2d(0,1), 0, xform2d(0,2)},
|
|
{xform2d(1,0), xform2d(1,1), 0, xform2d(1,2)},
|
|
{0,0,1, nElev},
|
|
{0,0,0,1}
|
|
};
|
|
poly2d.TransUCS(mat0);
|
|
|
|
PolyConvert(poly2d, *pline);
|
|
|
|
((AcGeVector3d &)vtNormal).normalize();
|
|
pline->setNormal(vtNormal);
|
|
|
|
Append(pline);
|
|
}
|
|
else
|
|
{
|
|
AcDbEntity *pEntCloned = NULL;
|
|
// ARC,CIRCLE Transform后丢失厚度信息
|
|
Acad::ErrorStatus es = pEntity->getTransformedCopy(matTrans, pEntCloned);
|
|
if (es == Acad::eOk && pEntCloned)
|
|
{
|
|
XString sDxfName;
|
|
sDxfName = pEntCloned->isA()->dxfName();
|
|
if (ads_wcmatch(sDxfName, szMatch) == RTNORM && IsFullExplode())
|
|
{
|
|
pEntCloned->explode(*m_pEntSet);
|
|
delete pEntCloned;
|
|
}
|
|
else
|
|
{
|
|
Append(pEntCloned);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
AcDbObjectId XExplodeStream::GetLayerId() const
|
|
{
|
|
return m_idLayer;
|
|
}
|
|
|
|
|
|
Acad::ErrorStatus XExplodeStream::SetLayer(const AcDbObjectId &id)
|
|
{
|
|
m_idLayer = id;
|
|
|
|
return Acad::eOk;
|
|
}
|
|
|
|
Acad::ErrorStatus XExplodeStream::SetLayer(const TCHAR *pszLayer)
|
|
{
|
|
AcDbObjectId id = GetLayerIdFromString(pszLayer);
|
|
if (!id)
|
|
{
|
|
return Acad::eInvalidInput;
|
|
}
|
|
|
|
return SetLayer(id);
|
|
}
|