2577 lines
64 KiB
C++
2577 lines
64 KiB
C++
// DuanSlopeRoofDlg.cpp : implementation file
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
|
|
#include "DuanSlopeRoofDlg.h"
|
|
#include "resource.h"
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
BOOL GetIntersect(XLine &xLine1,const TDbDualSlopeRoof *pDualSlopeRoof,BOOL &m_bFlag1,XPoly3D &poly);
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CDuanSlopeRoofDlg dialog
|
|
void GetRoofAllPoly(AcDbObjectId id, DList<X3DFace> &lstFace);
|
|
BOOL GetIntPoint(AcDbCurve *projLine,AcGePoint3d ptStart,AcGePoint3d ptEnd,AcGePoint3d &ptInt);
|
|
BOOL GetIntSectPoly(DList<X3DFace> &lstFace,XLine xLine,XPoly3D &poly);
|
|
void ColumnAlignSlopeRoof(TDbColumn *pColumn,DList<X3DFace> &lstFace);
|
|
void GetIntSectPoint(DList<X3DFace> &lstFace,XLine xLine,XPoly3D &poly);
|
|
BOOL GetEndIntSectPoint(DList<X3DFace> &lstFace,XLine xLine,XPoint &start,XPoint &end,BOOL bWall=TRUE);
|
|
//modified by whl on 070129,屋顶高度去檐板厚
|
|
CDuanSlopeRoofDlg::CDuanSlopeRoofDlg(CWnd* pParent /*=NULL*/)
|
|
: CAcUiDialog(CDuanSlopeRoofDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CDuanSlopeRoofDlg)
|
|
/*m_dElevation = 2500.0;
|
|
m_dHeight = 3000.0;*/
|
|
// [11/9/2007 nsh]
|
|
//初始化适应米单位绘图
|
|
m_dElevation =_AS_SYS_UNIT(2500.0);
|
|
m_dHeight =_AS_SYS_UNIT (3000.0);
|
|
//------------------------------------
|
|
m_dLpojiao = 30.0;
|
|
m_dRpojiao = 30.0;
|
|
|
|
m_bXiandinggaodu = FALSE;
|
|
m_bFlag = FALSE;
|
|
m_pRoof = NULL;
|
|
//}}AFX_DATA_INIT
|
|
m_bbFlag = FALSE;
|
|
}
|
|
CDuanSlopeRoofDlg::CDuanSlopeRoofDlg(TDbDualSlopeRoof *pRoof,CWnd* pParent)
|
|
: CAcUiDialog(CDuanSlopeRoofDlg::IDD, pParent)
|
|
{
|
|
m_pRoof = pRoof;
|
|
m_dElevation = m_pRoof->GetElevation();
|
|
/*m_dHeight = 3000.0;*/
|
|
// [11/9/2007 nsh]
|
|
//初始化适应米单位绘图
|
|
m_dHeight =_AS_SYS_UNIT(3000.0);
|
|
//----------------------------
|
|
m_dLpojiao = (m_pRoof->GetAngleLeft()*180.0) / PI;
|
|
m_dRpojiao = (m_pRoof->GetAngleRight()*180.0) / PI;
|
|
m_bXiandinggaodu = FALSE;
|
|
m_bFlag = TRUE;
|
|
m_bbFlag = FALSE;
|
|
}
|
|
// [2/20/2008 nsh]
|
|
//------------------------begin--------------------
|
|
CDuanSlopeRoofDlg::CDuanSlopeRoofDlg(BOOL bForTSun,CWnd* pParent)
|
|
: CAcUiDialog(bForTSun?CDuanSlopeRoofDlg::IDD2:CDuanSlopeRoofDlg::IDD, pParent)
|
|
{
|
|
//{{AFX_DATA_INIT(CDuanSlopeRoofDlg)
|
|
/*m_dElevation = 2500.0;
|
|
m_dHeight = 3000.0;*/
|
|
// [11/9/2007 nsh]
|
|
//初始化适应米单位绘图
|
|
m_dElevation =_AS_SYS_UNIT(27000.0);// [2/27/2008 nsh]
|
|
m_dHeight =_AS_SYS_UNIT (3000.0);
|
|
//------------------------------------
|
|
m_dLpojiao = 30.0;
|
|
m_dRpojiao = 30.0;
|
|
|
|
m_bXiandinggaodu = FALSE;
|
|
m_bFlag = FALSE;
|
|
m_pRoof = NULL;
|
|
//}}AFX_DATA_INIT
|
|
m_bbFlag = FALSE;
|
|
}
|
|
//-------------------------end---------------------
|
|
void CDuanSlopeRoofDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CAcUiDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CDuanSlopeRoofDlg)
|
|
DDX_Text(pDX, IDC_EDIT_ELEVATION, m_dElevation);
|
|
DDX_Text(pDX, IDC_EDIT_HEIGHT, m_dHeight);
|
|
DDX_Text(pDX, IDC_EDIT_LPOJIAO, m_dLpojiao);
|
|
DDX_Text(pDX, IDC_EDIT_RPOJIAO, m_dRpojiao);
|
|
DDX_Check(pDX, IDC_CHECK_XIANDINGJIAODU, m_bXiandinggaodu);
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
|
|
BEGIN_MESSAGE_MAP(CDuanSlopeRoofDlg, CAcUiDialog)
|
|
//{{AFX_MSG_MAP(CDuanSlopeRoofDlg)
|
|
ON_BN_CLICKED(IDC_CHECK_XIANDINGJIAODU, OnCheckXiandingjiaodu)
|
|
ON_EN_CHANGE(IDC_EDIT_ELEVATION, OnChangeEditElevation)
|
|
ON_EN_KILLFOCUS(IDC_EDIT_LPOJIAO, OnChangeEditLpojiao)
|
|
ON_EN_KILLFOCUS(IDC_EDIT_RPOJIAO, OnChangeEditRpojiao)
|
|
ON_EN_KILLFOCUS(IDC_EDIT_HEIGHT, OnChangeEditHeight)
|
|
ON_BN_CLICKED(IDC_BT_CANKAOBIAOGAO, OnBtCankaobiaogao)
|
|
ON_WM_CTLCOLOR()
|
|
ON_WM_DESTROY()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CDuanSlopeRoofDlg message handlers
|
|
|
|
BOOL CDuanSlopeRoofDlg::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
if (m_bFlag)
|
|
{
|
|
m_ptFirst = m_pRoof->GetRidgeStart();
|
|
m_ptSecond = m_pRoof->GetRidgeEnd();
|
|
}
|
|
m_ctrlPreview.SubclassDlgItem(IDC_STATIC_PRE,this);
|
|
m_ctrlPreview.SetOrbitFlag(OBF_ZOOM|OBF_PAN|OBF_ORBIT);
|
|
|
|
//modify by xlc on 081223
|
|
if (m_bXiandinggaodu)
|
|
{
|
|
GetDlgItem(IDC_EDIT_LPOJIAO)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_EDIT_RPOJIAO)->EnableWindow(FALSE);
|
|
}
|
|
else
|
|
{
|
|
GetDlgItem(IDC_EDIT_HEIGHT)->EnableWindow(FALSE);
|
|
}
|
|
// ywb 090904 判断是否日照软件
|
|
if (g_bIsSunProduct)
|
|
{
|
|
CWnd* pBtn = GetDlgItem(IDC_BT_CANKAOBIAOGAO);
|
|
assert(pBtn != NULL);
|
|
pBtn->ShowWindow(SW_HIDE);
|
|
|
|
SetWindowText(_T("人字坡顶"));
|
|
}
|
|
|
|
PreView();
|
|
UpdateData(FALSE);
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
void CDuanSlopeRoofDlg::GetLowRandL(XPoly2D &poly)
|
|
{
|
|
XLine xLine(m_ptFirst,m_ptSecond);
|
|
|
|
//add by xlc on 090108
|
|
xLine.SetElevation(0);
|
|
poly.SetElevation(0);
|
|
|
|
XPoint pt;
|
|
double dLowLeft = 0.0,dLowRight = 0.0;
|
|
for (long i = 0;i < poly.Length();i++)
|
|
{
|
|
pt = *poly[i];
|
|
double dTemp;
|
|
if (!xLine.OnWhichSide(pt))
|
|
{
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dLowLeft-0.0) <= 1E-6)
|
|
{
|
|
dLowLeft = dTemp;
|
|
}
|
|
else if (dLowLeft < dTemp)
|
|
{
|
|
dLowLeft = dTemp;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dLowRight-0.0) <= 1E-6)
|
|
{
|
|
dLowRight = dTemp;
|
|
}
|
|
else if (dLowRight < dTemp)
|
|
{
|
|
dLowRight = dTemp;
|
|
}
|
|
}
|
|
}
|
|
if (fabs(dLowLeft-0.0) <= 1E-6)
|
|
{
|
|
double dTempLow = 0.0;
|
|
for (long i = 0;i < m_pXpoly.Length();i++)
|
|
{
|
|
pt = *poly[i];
|
|
double dTemp;
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dTempLow-0.0) <= 1E-6)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
else if (dTempLow > dTemp)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
}
|
|
dLowRight = dLowRight - dTempLow;
|
|
{
|
|
//double dTemp = (m_dHeight - 200) / dLowRight;
|
|
double dTemp = m_dHeight / dLowRight;
|
|
|
|
dTemp = atan(dTemp);
|
|
m_dLpojiao =m_dRpojiao = (dTemp * 180.0) / PI;
|
|
}
|
|
}
|
|
else if (fabs(dLowRight-0.0) <= 1E-6)
|
|
{
|
|
double dTempLow = 0.0;
|
|
for (long i = 0;i < m_pXpoly.Length();i++)
|
|
{
|
|
pt = *poly[i];
|
|
double dTemp;
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dTempLow-0.0) <= 1E-6)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
else if (dTempLow > dTemp)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
}
|
|
dLowLeft = dLowLeft - dTempLow;
|
|
{
|
|
//double dTemp = (m_dHeight - 200) / dLowLeft;
|
|
double dTemp = m_dHeight/ dLowLeft;
|
|
|
|
dTemp = atan(dTemp);
|
|
m_dRpojiao = m_dLpojiao = (dTemp * 180.0) / PI;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double dTemp;
|
|
{
|
|
//dTemp = (m_dHeight - 200) / dLowLeft;
|
|
dTemp = m_dHeight / dLowLeft;
|
|
|
|
dTemp = atan(dTemp);
|
|
m_dLpojiao = (dTemp * 180.0) / PI;
|
|
}
|
|
{
|
|
//dTemp = (m_dHeight - 200) / dLowRight;
|
|
dTemp = m_dHeight / dLowRight;
|
|
|
|
dTemp = atan(dTemp);
|
|
m_dRpojiao = (dTemp * 180.0) / PI;
|
|
}
|
|
}
|
|
}
|
|
void CDuanSlopeRoofDlg::PreView()
|
|
{
|
|
AcDbBlockTable *pBlockTab=NULL;
|
|
VERIFY(dbPreview.getSymbolTable(pBlockTab, AcDb::kForWrite)==Acad::eOk);
|
|
AcDbBlockTableRecord *pMspace = new AcDbBlockTableRecord;
|
|
pMspace->setName(_T("*U"));
|
|
pBlockTab->add(pMspace);
|
|
pBlockTab->close();
|
|
|
|
double dLSlant;
|
|
double dRSlant;
|
|
if (m_bXiandinggaodu)
|
|
{
|
|
if (!m_bFlag)
|
|
GetLowRandL(m_pXpoly);
|
|
else
|
|
{
|
|
XPoly2D poly;
|
|
m_pRoof->GetPolyPath(poly);
|
|
GetLowRandL(poly);
|
|
}
|
|
}
|
|
|
|
dLSlant = m_dLpojiao;
|
|
dRSlant = m_dRpojiao;
|
|
CString str;
|
|
str.Format(_T("%.2f"),m_dLpojiao);
|
|
m_dLpojiao = _tstof(LPCTSTR(str));
|
|
str.Format(_T("%.2f"),m_dRpojiao);
|
|
m_dRpojiao = _tstof(LPCTSTR(str));
|
|
UpdateData(FALSE);
|
|
|
|
if (dLSlant > 89.999 || dRSlant > 89.9999)
|
|
{
|
|
AfxMessageBox(_T("\n坡度范围为0~90度!"));
|
|
}
|
|
double elev=m_dElevation;
|
|
if (elev < 1E-6)
|
|
{
|
|
if (fabs(elev - 0.0) <=1E-6);
|
|
else
|
|
{
|
|
AfxMessageBox(_T("\n标高不能小于0"));
|
|
}
|
|
}
|
|
if (!m_bFlag)
|
|
{
|
|
if (m_pXpoly.PathArea()>0)
|
|
{//确保逆时针
|
|
m_pXpoly.Reverse();
|
|
}
|
|
m_pXpoly.Compress();
|
|
m_pXpoly.SetElevation(0);
|
|
|
|
TDbDualSlopeRoof *pRoof = new TDbDualSlopeRoof;
|
|
pRoof->SetPolyPath(m_pXpoly);
|
|
pRoof->SetRidge(m_ptFirst,m_ptSecond);
|
|
pRoof->SetEqualAngle(Adesk::kFalse);
|
|
pRoof->SetAngle(dLSlant*PI/180,dRSlant*PI/180);
|
|
m_pRoof = pRoof;
|
|
}
|
|
else
|
|
{
|
|
if (m_pRoof->upgradeOpen()!=Acad::eOk)
|
|
return ;
|
|
m_pRoof->assertWriteEnabled();
|
|
m_pRoof->SetElevation(0);
|
|
m_pRoof->SetEqualAngle(Adesk::kFalse);
|
|
m_pRoof->SetAngle(dLSlant*PI/180,dRSlant*PI/180);
|
|
m_pRoof->downgradeOpen();
|
|
}
|
|
|
|
AcDbVoidPtrArray entSet;
|
|
XExplodeStream dc(entSet);
|
|
XPoint ptRidge2 = m_pRoof->GetRidgeEnd(),ptRidge1 = m_pRoof->GetRidgeStart();
|
|
XPoint vt = ptRidge2 - ptRidge1;
|
|
vt.Normalize();
|
|
vt.Scale(5E6);
|
|
XCurveSegment line(ptRidge1-vt,ptRidge2+vt,0);
|
|
line.SetElevation(0);
|
|
|
|
DList<XPoly2D> lstLeft,lstRight;
|
|
m_pRoof->Split(lstLeft,lstRight);
|
|
AcGeVector3d vtAxis=(ptRidge2-ptRidge1).AsAcGeVector3d();
|
|
{
|
|
AcGeVector3d vt(AcGeVector3d::kZAxis);
|
|
vt.rotateBy(-m_pRoof->GetAngleLeft(),vtAxis);
|
|
AcGePlane planeLeft(XPoint(ptRidge1.x,ptRidge1.y,m_pRoof->GetElevation()),vt);
|
|
double a,b,c,d;
|
|
planeLeft.getCoefficients(a,b,c,d);
|
|
for(long i=0;i<lstLeft.Length();i++)
|
|
{
|
|
XPoly2D* pPoly=lstLeft[i];
|
|
XPoly2D poly1=*pPoly;
|
|
for(long j=0;j<pPoly->Length();j++)
|
|
{
|
|
XPoint *pPt=(*pPoly)[j];
|
|
pPt->z=-1*(a*pPt->x+b*pPt->y+d)/c;
|
|
|
|
//modify by xlc on 090120 檐板厚可调
|
|
//poly1[j]->z=pPt->z-_AS_SYS_UNIT(200) ;// [11/14/2007 nsh]
|
|
poly1[j]->z=pPt->z-m_pRoof->GetSlabThick() ;
|
|
}
|
|
dc.SetColor(3);
|
|
dc.DrawShell(*pPoly,DList<XPoly2D>());
|
|
|
|
for(long k=0;k<poly1.TotalSegments();k++)
|
|
{
|
|
XCurveSegment e0,e1;
|
|
pPoly->Nth(k,e0);
|
|
poly1.Nth(k,e1);
|
|
X3DFace face;
|
|
face.SetFlag(0);
|
|
face.GetVertex(0)=e1.StartPoint();
|
|
face.GetVertex(1)=e1.EndPoint();
|
|
face.GetVertex(2)=e0.EndPoint();
|
|
face.GetVertex(3)=e0.StartPoint();
|
|
|
|
e0.SetElevation(0);
|
|
int nRet0=line.HitTest2d(e0.StartPoint());
|
|
int nRet1=line.HitTest2d(e0.EndPoint());
|
|
if (nRet0==1||nRet0==2||nRet1==1||nRet1==2||lstRight.Length()==0)
|
|
dc.DrawFace(face);
|
|
}
|
|
|
|
poly1.Reverse();
|
|
dc.DrawShell(poly1,DList<XPoly2D>());
|
|
}
|
|
}
|
|
{
|
|
AcGeVector3d vt(AcGeVector3d::kZAxis);
|
|
vt.rotateBy(m_pRoof->GetAngleRight(),vtAxis);
|
|
AcGePlane planeRight(XPoint(ptRidge1.x,ptRidge1.y,m_pRoof->GetElevation()),vt);
|
|
double a,b,c,d;
|
|
planeRight.getCoefficients(a,b,c,d);
|
|
for(long i=0;i<lstRight.Length();i++)
|
|
{
|
|
XPoly2D* pPoly=lstRight[i];
|
|
XPoly2D poly1=*pPoly;
|
|
for(long j=0;j<pPoly->Length();j++)
|
|
{
|
|
XPoint *pPt=(*pPoly)[j];
|
|
pPt->z=-1*(a*pPt->x+b*pPt->y+d)/c;
|
|
|
|
//modify by xlc on 090120 檐板厚可调
|
|
//poly1[j]->z=pPt->z-_AS_SYS_UNIT(200);
|
|
poly1[j]->z=pPt->z-m_pRoof->GetSlabThick();
|
|
}
|
|
dc.SetColor(6);
|
|
dc.DrawShell(*pPoly,DList<XPoly2D>());
|
|
|
|
for(long k=0;k<poly1.TotalSegments();k++)
|
|
{
|
|
XCurveSegment e0,e1;
|
|
pPoly->Nth(k,e0);
|
|
poly1.Nth(k,e1);
|
|
X3DFace face;
|
|
face.SetFlag(0);
|
|
face.GetVertex(0)=e1.StartPoint();
|
|
face.GetVertex(1)=e1.EndPoint();
|
|
face.GetVertex(2)=e0.EndPoint();
|
|
face.GetVertex(3)=e0.StartPoint();
|
|
|
|
e0.SetElevation(0);
|
|
int nRet0=line.HitTest2d(e0.StartPoint());
|
|
int nRet1=line.HitTest2d(e0.EndPoint());
|
|
if (nRet0==1||nRet0==2||nRet1==1||nRet1==2||lstLeft.Length()==0)
|
|
dc.DrawFace(face);
|
|
}
|
|
|
|
poly1.Reverse();
|
|
dc.DrawShell(poly1,DList<XPoly2D>());
|
|
}
|
|
}
|
|
for(long i=0;i<entSet.length();i++)
|
|
{
|
|
AcDbEntity *pEnt = (AcDbEntity*)entSet[i];
|
|
//modify by xlc on 090916 2010平台线型等属性信息导致预览无法显示
|
|
#if ADS<18
|
|
pMspace->appendAcDbEntity(pEnt);
|
|
pEnt->close();
|
|
#else
|
|
AcDbEntity *pClone=(AcDbEntity*)pEnt->clone();
|
|
delete pEnt;
|
|
pClone->setDatabaseDefaults(&dbPreview);
|
|
pMspace->appendAcDbEntity(pClone);
|
|
pClone->recordGraphicsModified();
|
|
pClone->close();
|
|
#endif
|
|
}
|
|
XPoint ptMax,ptMin;
|
|
XPoint ptCenter;
|
|
double x,y;
|
|
int nOldMode=DocGetDrawMode();
|
|
DocSetDrawMode(DRAW_3D);
|
|
m_pRoof->GetExtents(ptMin,ptMax);
|
|
DocSetDrawMode(nOldMode);
|
|
y = ptMax.z - ptMin.z;
|
|
ptCenter.x = (ptMax.x + ptMin.x) / 2;
|
|
ptCenter.y = (ptMax.y + ptMin.y) / 2;
|
|
ptCenter.z = (ptMax.z + ptMin.z) / 2;
|
|
|
|
XPoint pt0=m_pRoof->GetRidgeStart(),pt1=m_pRoof->GetRidgeEnd();
|
|
if (!m_bFlag)
|
|
m_pRoof->close();
|
|
XVector3D vtNormal=pt0-pt1;
|
|
|
|
//modified by whl on 070129,解决预览显示不全的问题
|
|
vtNormal.Scale(0.51);
|
|
XPoint ptView=ptCenter+vtNormal;
|
|
AcGeMatrix3d mat;
|
|
vtNormal.Reverse();
|
|
mat.setToWorldToPlane(vtNormal.AsAcGeVector3d());
|
|
vtNormal.TransformBy(mat);
|
|
ptMin.TransformBy(mat);
|
|
ptMax.TransformBy(mat);
|
|
x = fabs(ptMax.x - ptMin.x)*1.1;
|
|
|
|
//add by xlc on 070720
|
|
y = fabs(ptMax.z - ptMin.z);
|
|
|
|
y*=1.1;
|
|
{
|
|
AcGePoint3d ptPosition,ptTarget;
|
|
if (m_ctrlPreview.view() != NULL)
|
|
ptPosition = m_ctrlPreview.view()->position(), ptTarget = m_ctrlPreview.view()->target();
|
|
m_ctrlPreview.clearAll();
|
|
m_ctrlPreview.init(true);
|
|
|
|
//modify by xlc on 090806 R18移植
|
|
#if ADS<18
|
|
m_ctrlPreview.view()->setMode(AcGsView::kWireframe);
|
|
#else
|
|
m_ctrlPreview.view()->setVisualStyle(AcGiVisualStyle::k3DWireframe);
|
|
#endif
|
|
|
|
if (m_bbFlag==FALSE)
|
|
{
|
|
if (m_ptViewAuto.AsAcGePoint3d()!=ptPosition||m_ptTargeAuto.AsAcGePoint3d()!=ptTarget)
|
|
m_bbFlag=TRUE;
|
|
}
|
|
|
|
if (!m_bbFlag)
|
|
{
|
|
m_ctrlPreview.view()->setView(ptView.AsAcGePoint3d(),ptCenter.AsAcGePoint3d(),
|
|
AcGeVector3d(0.0, 0.0, 1.0),x,y);
|
|
m_ptViewAuto=ptView;
|
|
m_ptTargeAuto=pt0;
|
|
}
|
|
else
|
|
{
|
|
m_ctrlPreview.view()->setView(ptPosition,ptTarget,AcGeVector3d(0.0, 0.0, 1.0),x,y);
|
|
}
|
|
m_ctrlPreview.view()->add(pMspace,m_ctrlPreview.model());
|
|
m_ctrlPreview.Invalidate();
|
|
}
|
|
pMspace->close();
|
|
}
|
|
void CDuanSlopeRoofDlg::OnCheckXiandingjiaodu()
|
|
{
|
|
UpdateData();
|
|
if (m_bXiandinggaodu)
|
|
{
|
|
GetDlgItem(IDC_EDIT_HEIGHT)->EnableWindow(TRUE);
|
|
GetDlgItem(IDC_EDIT_LPOJIAO)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_EDIT_RPOJIAO)->EnableWindow(FALSE);
|
|
}
|
|
else
|
|
{
|
|
GetDlgItem(IDC_EDIT_HEIGHT)->EnableWindow(FALSE);
|
|
GetDlgItem(IDC_EDIT_LPOJIAO)->EnableWindow(TRUE);
|
|
GetDlgItem(IDC_EDIT_RPOJIAO)->EnableWindow(TRUE);
|
|
}
|
|
UpdateData(FALSE);
|
|
PreView();
|
|
}
|
|
|
|
void CDuanSlopeRoofDlg::OnChangeEditElevation()
|
|
{
|
|
UpdateData();
|
|
//PreView();
|
|
}
|
|
|
|
void CDuanSlopeRoofDlg::OnChangeEditLpojiao()
|
|
{
|
|
double d = m_dLpojiao;
|
|
UpdateData();
|
|
if (m_dLpojiao > 89.999)
|
|
{
|
|
AfxMessageBox(_T("\n坡度范围为0~90度!"));
|
|
m_dLpojiao = d;
|
|
UpdateData(FALSE);
|
|
}
|
|
PreView();
|
|
}
|
|
|
|
void CDuanSlopeRoofDlg::OnChangeEditRpojiao()
|
|
{
|
|
double d = m_dRpojiao;
|
|
UpdateData();
|
|
if (m_dRpojiao > 89.9999)
|
|
{
|
|
AfxMessageBox(_T("\n坡度范围为0~90度!"));
|
|
m_dRpojiao = d;
|
|
UpdateData(FALSE);
|
|
}
|
|
PreView();
|
|
}
|
|
|
|
void CDuanSlopeRoofDlg::OnChangeEditHeight()
|
|
{
|
|
UpdateData();
|
|
PreView();
|
|
}
|
|
|
|
HBRUSH CDuanSlopeRoofDlg::OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor)
|
|
{
|
|
HBRUSH hbr = CDialog::OnCtlColor(pDC, pWnd, nCtlColor);
|
|
|
|
// TODO: Change any attributes of the DC here
|
|
int nID=pWnd->GetDlgCtrlID();
|
|
if (nID==IDC_STATIC_L)
|
|
pDC->SetTextColor(acdbGetRGB(3));
|
|
else if (nID==IDC_STATIC_R)
|
|
pDC->SetTextColor(acdbGetRGB(6));
|
|
// TODO: Return a different brush if the default is not desired
|
|
return hbr;
|
|
}
|
|
|
|
void CDuanSlopeRoofDlg::OnBtCankaobiaogao()
|
|
{
|
|
if (!m_pRoof->isWriteEnabled())
|
|
if (m_pRoof->upgradeOpen()!=Acad::eOk)
|
|
return;
|
|
|
|
m_pRoof->SetElevation(m_dElevation);
|
|
m_pRoof->downgradeOpen();
|
|
ads_redraw(NULL,NULL);
|
|
RBList rbMask(RTDXF0, _T("TCH_WALL"), NULL);
|
|
Entity ent;
|
|
ShowWindow(SW_HIDE);
|
|
BeginEditorCommand();
|
|
int nRetCode = SelectEntity(_T("\n请选择墙:"), ent, rbMask);
|
|
CompleteEditorCommand();
|
|
if (nRetCode!=RTNORM)
|
|
return;
|
|
{
|
|
BOOL m_bFlag1 = FALSE,m_bFlag2 = FALSE;
|
|
XPoly3D poly;
|
|
XPoly3D poly1;
|
|
XDbObject obj(ent,AcDb::kForRead);
|
|
TDbWall *pWall = TDbWall::cast(obj.m_pObject);
|
|
if (!pWall)
|
|
return;
|
|
|
|
XCurveSegment lCurveSegment,rCurveSegment;
|
|
pWall->GetSideCurve(lCurveSegment,rCurveSegment,0.0,TRUE);
|
|
XLine xLine1(lCurveSegment.StartPoint(),lCurveSegment.EndPoint());
|
|
|
|
//modify by xlc on 070517
|
|
/*double dTemp;
|
|
if (fabs(xLine1.StartPoint().y - xLine1.EndPoint().y) > 1E-6 && fabs(xLine1.StartPoint().x - xLine1.EndPoint().x) > 1E-6)
|
|
{
|
|
dTemp = 1.0 / xLine1.Direction();
|
|
dTemp = -dTemp;
|
|
}
|
|
else if (fabs(xLine1.StartPoint().x - xLine1.EndPoint().x) <= 1E-6)
|
|
dTemp = 0.0;
|
|
else
|
|
dTemp = PI / 2.0;
|
|
XLine xLine(xLine1.StartPoint(),dTemp);
|
|
AcGePlane wallPlane(xLine1.StartPoint(),xLine.Direction3d());
|
|
// XPlane LeftTempPlane,RightTempPLane;
|
|
TDbDualSlopeRoof *pDualSlopeRoof = m_pRoof;
|
|
if (!pDualSlopeRoof)
|
|
return;
|
|
AcGeVector3d vtAxis=(pDualSlopeRoof->GetRidgeEnd()-pDualSlopeRoof->GetRidgeStart()).AsAcGeVector3d();
|
|
AcGeVector3d vt1(AcGeVector3d::kZAxis);
|
|
vt1.rotateBy(-pDualSlopeRoof->GetAngleLeft(),vtAxis);
|
|
AcGePlane LeftPlane(XPoint(pDualSlopeRoof->GetRidgeStart().x,pDualSlopeRoof->GetRidgeStart().y,pDualSlopeRoof->GetElevation() - 200),vt1);
|
|
AcGeVector3d vt2(AcGeVector3d::kZAxis);
|
|
vt2.rotateBy(pDualSlopeRoof->GetAngleRight(),vtAxis);
|
|
AcGePlane RightPLane(XPoint(pDualSlopeRoof->GetRidgeStart().x,pDualSlopeRoof->GetRidgeStart().y,pDualSlopeRoof->GetElevation() - 200),vt2);
|
|
AcGeLine3d xLineLeft,xLineRight;
|
|
if (!wallPlane.intersectWith(LeftPlane,xLineLeft))
|
|
return;
|
|
if (!wallPlane.intersectWith(RightPLane,xLineRight))
|
|
return;
|
|
AcGePoint3d pt;
|
|
Adesk::Boolean bHasThirdPt1=xLineLeft.intersectWith(xLineRight,pt);
|
|
AcGePoint3d point = pt;
|
|
XLine xLineTemp;
|
|
xLineTemp.StartPoint() = pt = xLine1.StartPoint();
|
|
pt.z += 1000;
|
|
xLineTemp.EndPoint() = pt;
|
|
AcGePoint3d ptTemp1,ptTemp2;
|
|
AcGeLine3d acgeLine(AcGePoint3d(xLineTemp.StartPoint().x,xLineTemp.StartPoint().y,xLineTemp.StartPoint().z),
|
|
AcGePoint3d(xLineTemp.EndPoint().x,xLineTemp.EndPoint().y,xLineTemp.EndPoint().z));
|
|
if (!LeftPlane.intersectWith(acgeLine,ptTemp1))
|
|
return;
|
|
if (!RightPLane.intersectWith(acgeLine,ptTemp2))
|
|
return;
|
|
if (ptTemp1.z < ptTemp2.z)
|
|
poly.AppendNode(ptTemp1);
|
|
else
|
|
poly.AppendNode(ptTemp2);
|
|
if (bHasThirdPt1)
|
|
poly.AppendNode(point);
|
|
else
|
|
m_bFlag1 = TRUE;
|
|
pt = xLineTemp.StartPoint() = xLine1.EndPoint();
|
|
pt.z += 1000;
|
|
xLineTemp.EndPoint() = pt;
|
|
AcGeLine3d acgeLine1(AcGePoint3d(xLineTemp.StartPoint().x,xLineTemp.StartPoint().y,xLineTemp.StartPoint().z),
|
|
AcGePoint3d(xLineTemp.EndPoint().x,xLineTemp.EndPoint().y,xLineTemp.EndPoint().z));
|
|
LeftPlane.intersectWith(acgeLine1,ptTemp1);
|
|
RightPLane.intersectWith(acgeLine1,ptTemp2);
|
|
if (ptTemp1.z < ptTemp2.z)
|
|
poly.AppendNode(ptTemp1);
|
|
else
|
|
poly.AppendNode(ptTemp2);
|
|
{
|
|
int n = poly.Length();
|
|
poly.Compress();
|
|
if (poly.Length() != n)
|
|
{
|
|
m_bFlag1 = TRUE;
|
|
bHasThirdPt1 = FALSE;
|
|
}
|
|
}
|
|
if (bHasThirdPt1)
|
|
{
|
|
AcGeVector3d v1 = poly[1]->AsAcGePoint3d() - poly[0]->AsAcGePoint3d(),v2 = poly[1]->AsAcGePoint3d() - poly[2]->AsAcGePoint3d();
|
|
AcGeVector3d vt = poly[2]->AsAcGePoint3d() - poly[0]->AsAcGePoint3d();
|
|
double d1 = v1.angleTo(vt);
|
|
vt = poly[0]->AsAcGePoint3d() - poly[2]->AsAcGePoint3d();
|
|
double d2 =v2.angleTo(vt);
|
|
if (d1 > PI/2.0 || d2 > PI/2.0 || fabs(d1 - PI/2.0)<= 1E-2 || fabs(d2 - PI/2.0)<= 1E-2)
|
|
{
|
|
poly.Remove(1);
|
|
m_bFlag1 = TRUE;
|
|
}
|
|
}
|
|
xLine1.SetPoints(rCurveSegment.StartPoint(),rCurveSegment.EndPoint());
|
|
if (fabs(xLine1.StartPoint().y - xLine1.EndPoint().y) > 1E-6 && fabs(xLine1.StartPoint().x - xLine1.EndPoint().x) > 1E-6)
|
|
{
|
|
dTemp = 1.0 / xLine1.Direction();
|
|
dTemp = -dTemp;
|
|
}
|
|
else if (fabs(xLine1.StartPoint().x - xLine1.EndPoint().x) <= 1E-6)
|
|
dTemp = 0.0;
|
|
else
|
|
dTemp = PI / 2.0;
|
|
XLine xLine0(xLine1.StartPoint(),dTemp);
|
|
AcGePlane wallPlane0(xLine1.StartPoint(),xLine0.Direction3d());
|
|
if (!wallPlane0.intersectWith(LeftPlane,xLineLeft))
|
|
return;
|
|
if (!wallPlane0.intersectWith(RightPLane,xLineRight))
|
|
return;
|
|
Adesk::Boolean bHasThirdPt2=xLineLeft.intersectWith(xLineRight,pt);
|
|
point = pt;
|
|
xLineTemp.StartPoint() = pt = xLine1.StartPoint();
|
|
pt.z += 1000;
|
|
xLineTemp.EndPoint() = pt;
|
|
AcGeLine3d acgeLine2(AcGePoint3d(xLineTemp.StartPoint().x,xLineTemp.StartPoint().y,xLineTemp.StartPoint().z),
|
|
AcGePoint3d(xLineTemp.EndPoint().x,xLineTemp.EndPoint().y,xLineTemp.EndPoint().z));
|
|
if (!LeftPlane.intersectWith(acgeLine2,ptTemp1))
|
|
return;
|
|
if (!RightPLane.intersectWith(acgeLine2,ptTemp2))
|
|
return;
|
|
if (ptTemp1.z < ptTemp2.z)
|
|
poly1.AppendNode(ptTemp1);
|
|
else
|
|
poly1.AppendNode(ptTemp2);
|
|
if (bHasThirdPt2)
|
|
poly1.AppendNode(point);
|
|
else
|
|
m_bFlag2 = TRUE;
|
|
pt = xLineTemp.StartPoint() = xLine1.EndPoint();
|
|
pt.z += 1000;
|
|
xLineTemp.EndPoint() = pt;
|
|
AcGeLine3d acgeLine3(AcGePoint3d(xLineTemp.StartPoint().x,xLineTemp.StartPoint().y,xLineTemp.StartPoint().z),
|
|
AcGePoint3d(xLineTemp.EndPoint().x,xLineTemp.EndPoint().y,xLineTemp.EndPoint().z));
|
|
if (!LeftPlane.intersectWith(acgeLine3,ptTemp1))
|
|
return;
|
|
if (!RightPLane.intersectWith(acgeLine3,ptTemp2))
|
|
return;
|
|
if (ptTemp1.z < ptTemp2.z)
|
|
poly1.AppendNode(ptTemp1);
|
|
else
|
|
poly1.AppendNode(ptTemp2);
|
|
{
|
|
int n = poly1.Length();
|
|
poly1.Compress();
|
|
if (poly1.Length() != n)
|
|
{
|
|
m_bFlag2 = TRUE;
|
|
bHasThirdPt2 = FALSE;
|
|
}
|
|
}
|
|
if (bHasThirdPt2)
|
|
{
|
|
AcGeVector3d v1 = poly1[1]->AsAcGePoint3d() - poly1[0]->AsAcGePoint3d(),v2 = poly1[1]->AsAcGePoint3d() - poly1[2]->AsAcGePoint3d();
|
|
AcGeVector3d vt = poly1[2]->AsAcGePoint3d()- poly1[0]->AsAcGePoint3d();
|
|
double d1 = v1.angleTo(vt);
|
|
vt = poly1[0]->AsAcGePoint3d() - poly1[2]->AsAcGePoint3d();
|
|
double d2 =v2.angleTo(vt);
|
|
if (d1 > PI/2.0 || d2 > PI/2.0 || fabs(d1 - PI/2.0)<= 1E-2 || fabs(d2 - PI/2.0)<= 1E-2)
|
|
{
|
|
poly1.Remove(1);
|
|
m_bFlag2 = TRUE;
|
|
}
|
|
}*/
|
|
TDbDualSlopeRoof *pDualSlopeRoof = m_pRoof;
|
|
if (!pDualSlopeRoof)
|
|
return;
|
|
if (!GetIntersect(xLine1,pDualSlopeRoof,m_bFlag1,poly))
|
|
{
|
|
return;
|
|
}
|
|
|
|
xLine1.SetPoints(rCurveSegment.StartPoint(),rCurveSegment.EndPoint());//右边线
|
|
if (!GetIntersect(xLine1,pDualSlopeRoof,m_bFlag2,poly1))
|
|
{
|
|
return;
|
|
}
|
|
|
|
|
|
XPoly3D poly3d;
|
|
if (poly[0]->z < poly1[0]->z)
|
|
poly3d.AppendNode(*poly[0]);
|
|
else
|
|
poly3d.AppendNode(*poly1[0]);
|
|
if (!m_bFlag1 && !m_bFlag2)
|
|
{
|
|
if (poly[1]->z < poly1[1]->z)
|
|
poly3d.AppendNode(*poly[1]);
|
|
else
|
|
poly3d.AppendNode(*poly1[1]);
|
|
if (poly[2]->z < poly1[2]->z)
|
|
poly3d.AppendNode(*poly[2]);
|
|
else
|
|
poly3d.AppendNode(*poly1[2]);
|
|
}
|
|
else if (!m_bFlag1 && m_bFlag2)
|
|
{
|
|
poly3d.AppendNode(*poly[1]);
|
|
poly3d.AppendNode(*poly[2]);
|
|
}
|
|
else if (m_bFlag1 && !m_bFlag2)
|
|
{
|
|
poly3d.AppendNode(*poly1[1]);
|
|
poly3d.AppendNode(*poly1[2]);
|
|
}
|
|
else
|
|
{
|
|
if (poly[1]->z < poly1[1]->z)
|
|
poly3d.AppendNode(*poly[1]);
|
|
else
|
|
poly3d.AppendNode(*poly1[1]);
|
|
}
|
|
double dForNextUse = poly3d[0]->z;
|
|
if (poly3d[1]->z < dForNextUse)
|
|
dForNextUse = poly3d[1]->z;
|
|
if (!m_bFlag1 || !m_bFlag2)
|
|
{
|
|
if (poly3d[2]->z < dForNextUse)
|
|
dForNextUse = poly3d[2]->z;
|
|
}
|
|
|
|
//modify by xlc on 090108
|
|
//add by xlc on 070720
|
|
//修改限定标高精度
|
|
// if (m_bXiandinggaodu)
|
|
// {
|
|
// m_dElevation = m_dHeight + (pWall->GetHeight() + pWall->GetElevation()) + _AS_SYS_UNIT(200);// [11/13/2007 nsh]
|
|
// }
|
|
// else
|
|
|
|
{
|
|
double d = dForNextUse - (pWall->GetHeight() + pWall->GetElevation());
|
|
m_dElevation = m_dElevation - d;
|
|
}
|
|
CString str;
|
|
str.Format(_T("%.2f"),m_dElevation);
|
|
m_dElevation = _tstof(LPCTSTR(str));
|
|
}
|
|
UpdateData(FALSE);
|
|
if (m_pRoof->upgradeOpen()==Acad::eOk)
|
|
{
|
|
m_pRoof->SetElevation(0.0);
|
|
m_pRoof->downgradeOpen();
|
|
}
|
|
PreView();
|
|
ShowWindow(SW_SHOW);
|
|
}
|
|
//双坡屋顶
|
|
void DualSlopeRoof()
|
|
{
|
|
Entity ent;
|
|
RBList rbMask(RTDXF0, _T("POLYLINE,LWPOLYLINE"), 70, 1, NULL);
|
|
if (SelectEntity(_T("\n请选择一封闭的多段线<退出>:"), ent, rbMask)==RTNORM)
|
|
{
|
|
XPoly2D poly(ent);
|
|
if (!!poly)
|
|
{
|
|
XPoint ptFirst,ptSecond;
|
|
if (acedGetPoint(NULL,_T("\n请输入屋脊线的起点<退出>:"),ptFirst)!=RTNORM||
|
|
acedGetPoint(ptFirst,_T("\n请输入屋脊线的终点<退出>:"),ptSecond)!=RTNORM)
|
|
return;
|
|
|
|
//add by whl on 070608
|
|
ptFirst=Ucs2Wcs(ptFirst);
|
|
ptSecond=Ucs2Wcs(ptSecond);
|
|
|
|
CAcModuleResourceOverride vTemp;
|
|
CDuanSlopeRoofDlg dlg;
|
|
dlg.m_pXpoly = poly;
|
|
dlg.m_ptFirst = ptFirst;
|
|
dlg.m_ptSecond = ptSecond;
|
|
while(dlg.DoModal() == IDOK)
|
|
{
|
|
double dLSlant;
|
|
double dRSlant;
|
|
if (dlg.m_bXiandinggaodu)
|
|
{
|
|
XLine xLine(ptFirst,ptSecond);
|
|
|
|
//modify by xlc on 090108
|
|
xLine.SetElevation(0);
|
|
poly.SetElevation(0);
|
|
|
|
XPoint pt;
|
|
double dLowLeft = 0.0,dLowRight = 0.0;
|
|
for (long i = 0;i < poly.Length();i++)
|
|
{
|
|
pt = *poly[i];
|
|
double dTemp;
|
|
if (!xLine.OnWhichSide(pt))
|
|
{
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dLowLeft-0.0) <= 1E-6)
|
|
{
|
|
dLowLeft = dTemp;
|
|
}
|
|
else if (dLowLeft < dTemp)
|
|
{
|
|
dLowLeft = dTemp;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dLowRight-0.0) <= 1E-6)
|
|
{
|
|
dLowRight = dTemp;
|
|
}
|
|
else if (dLowRight < dTemp)
|
|
{
|
|
dLowRight = dTemp;
|
|
}
|
|
}
|
|
}
|
|
if (fabs(dLowLeft-0.0) <= 1E-6)
|
|
{
|
|
double dTempLow = 0.0;
|
|
for (long i = 0;i < poly.Length();i++)
|
|
{
|
|
pt = *poly[i];
|
|
double dTemp;
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dTempLow-0.0) <= 1E-6)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
else if (dTempLow > dTemp)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
}
|
|
dLowRight = dLowRight - dTempLow;
|
|
{
|
|
//double dTemp = (dlg.m_dHeight- 200) / dLowRight;
|
|
double dTemp = dlg.m_dHeight / dLowRight;
|
|
|
|
dTemp = atan(dTemp);
|
|
dlg.m_dLpojiao =dlg.m_dRpojiao = (dTemp * 180.0) / PI;
|
|
}
|
|
}
|
|
else if (fabs(dLowRight-0.0) <= 1E-6)
|
|
{
|
|
double dTempLow = 0.0;
|
|
for (long i = 0;i < poly.Length();i++)
|
|
{
|
|
pt = *poly[i];
|
|
double dTemp;
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dTempLow-0.0) <= 1E-6)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
else if (dTempLow > dTemp)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
}
|
|
dLowLeft = dLowLeft - dTempLow;
|
|
{
|
|
//double dTemp = (dlg.m_dHeight - 200) / dLowLeft;
|
|
double dTemp = dlg.m_dHeight/ dLowLeft;
|
|
|
|
dTemp = atan(dTemp);
|
|
dlg.m_dRpojiao = dlg.m_dLpojiao = (dTemp * 180.0) / PI;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double dTemp;
|
|
{
|
|
//dTemp = (dlg.m_dHeight - 200) / dLowLeft;
|
|
dTemp = dlg.m_dHeight / dLowLeft;
|
|
|
|
dTemp = atan(dTemp);
|
|
dlg.m_dLpojiao = (dTemp * 180.0) / PI;
|
|
}
|
|
{
|
|
//dTemp = (dlg.m_dHeight - 200) / dLowRight;
|
|
dTemp = dlg.m_dHeight / dLowRight;
|
|
|
|
dTemp = atan(dTemp);
|
|
dlg.m_dRpojiao = (dTemp * 180.0) / PI;
|
|
}
|
|
}
|
|
}
|
|
dLSlant = dlg.m_dLpojiao;
|
|
dRSlant = dlg.m_dRpojiao;
|
|
if (dLSlant > 89.999 || dRSlant > 89.9999)
|
|
{
|
|
adsout << _T("\n坡度范围为0~90度!");
|
|
continue;
|
|
}
|
|
double elev=dlg.m_dElevation;
|
|
if (elev < 1E-6)
|
|
{
|
|
if (fabs(elev - 0.0) <=1E-6);
|
|
else
|
|
{
|
|
adsout << _T("\n标高不能小于0");
|
|
continue;
|
|
}
|
|
}
|
|
ent.Erase();
|
|
if (poly.PathArea()>0)
|
|
{//确保逆时针
|
|
poly.Reverse();
|
|
}
|
|
poly.Compress();
|
|
poly.SetElevation(elev);
|
|
TDbDualSlopeRoof *pRoof = new TDbDualSlopeRoof;
|
|
pRoof->SetPolyPath(poly);
|
|
pRoof->SetRidge(ptFirst,ptSecond);
|
|
pRoof->SetEqualAngle(Adesk::kFalse);
|
|
pRoof->SetAngle(dLSlant*PI/180,dRSlant*PI/180);
|
|
pRoof->SetHeightLim(dlg.m_bXiandinggaodu);
|
|
if (dlg.m_bXiandinggaodu)
|
|
{
|
|
pRoof->SetRoofHeight(dlg.m_dHeight);
|
|
}
|
|
pRoof->AddToMSpace(Adesk::kTrue);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// [2/19/2008 nsh]
|
|
//-------------begin--------------------
|
|
void DualSlopeRoof2()
|
|
{
|
|
Entity ent;
|
|
RBList rbMask(RTDXF0, _T("POLYLINE,LWPOLYLINE"), 70, 1, NULL);
|
|
if (SelectEntity(_T("\n请选择一封闭的多段线<退出>:"), ent, rbMask)==RTNORM)
|
|
{
|
|
XPoly2D poly(ent);
|
|
if (!!poly)
|
|
{
|
|
XPoint ptFirst,ptSecond;
|
|
if (acedGetPoint(NULL,_T("\n请输入屋脊线的起点<退出>:"),ptFirst)!=RTNORM||
|
|
acedGetPoint(ptFirst,_T("\n请输入屋脊线的终点<退出>:"),ptSecond)!=RTNORM)
|
|
return;
|
|
|
|
//add by whl on 070608
|
|
ptFirst=Ucs2Wcs(ptFirst);
|
|
ptSecond=Ucs2Wcs(ptSecond);
|
|
|
|
CAcModuleResourceOverride vTemp;
|
|
// [2/20/2008 nsh]
|
|
//添加Dlg的创建
|
|
CDuanSlopeRoofDlg dlg(TRUE,NULL);
|
|
dlg.m_pXpoly = poly;
|
|
dlg.m_ptFirst = ptFirst;
|
|
dlg.m_ptSecond = ptSecond;
|
|
while(dlg.DoModal() == IDOK)
|
|
{
|
|
double dLSlant;
|
|
double dRSlant;
|
|
if (dlg.m_bXiandinggaodu)
|
|
{
|
|
XLine xLine(ptFirst,ptSecond);
|
|
|
|
// ywb 090916
|
|
xLine.SetElevation(0);
|
|
poly.SetElevation(0);
|
|
XPoint pt;
|
|
double dLowLeft = 0.0,dLowRight = 0.0;
|
|
for (long i = 0;i < poly.Length();i++)
|
|
{
|
|
pt = *poly[i];
|
|
double dTemp;
|
|
if (!xLine.OnWhichSide(pt))
|
|
{
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dLowLeft-0.0) <= 1E-6)
|
|
{
|
|
dLowLeft = dTemp;
|
|
}
|
|
else if (dLowLeft < dTemp)
|
|
{
|
|
dLowLeft = dTemp;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dLowRight-0.0) <= 1E-6)
|
|
{
|
|
dLowRight = dTemp;
|
|
}
|
|
else if (dLowRight < dTemp)
|
|
{
|
|
dLowRight = dTemp;
|
|
}
|
|
}
|
|
}
|
|
if (fabs(dLowLeft-0.0) <= 1E-6)
|
|
{
|
|
double dTempLow = 0.0;
|
|
for (long i = 0;i < poly.Length();i++)
|
|
{
|
|
pt = *poly[i];
|
|
double dTemp;
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dTempLow-0.0) <= 1E-6)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
else if (dTempLow > dTemp)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
}
|
|
dLowRight = dLowRight - dTempLow;
|
|
{
|
|
//double dTemp = (dlg.m_dHeight- 200) / dLowRight;
|
|
double dTemp = dlg.m_dHeight / dLowRight;
|
|
|
|
dTemp = atan(dTemp);
|
|
dlg.m_dLpojiao =dlg.m_dRpojiao = (dTemp * 180.0) / PI;
|
|
}
|
|
}
|
|
else if (fabs(dLowRight-0.0) <= 1E-6)
|
|
{
|
|
double dTempLow = 0.0;
|
|
for (long i = 0;i < poly.Length();i++)
|
|
{
|
|
pt = *poly[i];
|
|
double dTemp;
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dTempLow-0.0) <= 1E-6)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
else if (dTempLow > dTemp)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
}
|
|
dLowLeft = dLowLeft - dTempLow;
|
|
{
|
|
//double dTemp = (dlg.m_dHeight - 200) / dLowLeft;
|
|
double dTemp = dlg.m_dHeight/ dLowLeft;
|
|
|
|
dTemp = atan(dTemp);
|
|
dlg.m_dRpojiao = dlg.m_dLpojiao = (dTemp * 180.0) / PI;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double dTemp;
|
|
{
|
|
//dTemp = (dlg.m_dHeight - 200) / dLowLeft;
|
|
dTemp = dlg.m_dHeight / dLowLeft;
|
|
|
|
dTemp = atan(dTemp);
|
|
dlg.m_dLpojiao = (dTemp * 180.0) / PI;
|
|
}
|
|
{
|
|
//dTemp = (dlg.m_dHeight - 200) / dLowRight;
|
|
dTemp = dlg.m_dHeight / dLowRight;
|
|
|
|
dTemp = atan(dTemp);
|
|
dlg.m_dRpojiao = (dTemp * 180.0) / PI;
|
|
}
|
|
}
|
|
}
|
|
dLSlant = dlg.m_dLpojiao;
|
|
dRSlant = dlg.m_dRpojiao;
|
|
if (dLSlant > 89.999 || dRSlant > 89.9999)
|
|
{
|
|
adsout << _T("\n坡度范围为0~90度!");
|
|
continue;
|
|
}
|
|
double elev=dlg.m_dElevation;
|
|
if (elev < 1E-6)
|
|
{
|
|
if (fabs(elev - 0.0) <=1E-6);
|
|
else
|
|
{
|
|
adsout << _T("\n标高不能小于0");
|
|
continue;
|
|
}
|
|
}
|
|
ent.Erase();
|
|
if (poly.PathArea()>0)
|
|
{//确保逆时针
|
|
poly.Reverse();
|
|
}
|
|
poly.Compress();
|
|
poly.SetElevation(elev);
|
|
TDbDualSlopeRoof *pRoof = new TDbDualSlopeRoof;
|
|
pRoof->SetPolyPath(poly);
|
|
pRoof->SetRidge(ptFirst,ptSecond);
|
|
pRoof->SetEqualAngle(Adesk::kFalse);
|
|
pRoof->SetAngle(dLSlant*PI/180,dRSlant*PI/180);
|
|
|
|
// ywb 090916
|
|
pRoof->SetHeightLim(dlg.m_bXiandinggaodu);
|
|
if (dlg.m_bXiandinggaodu)
|
|
{
|
|
pRoof->SetRoofHeight(dlg.m_dHeight);
|
|
}
|
|
|
|
pRoof->AddToMSpace(Adesk::kTrue);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//--------------end---------------------
|
|
int EditDualSlopeRoof(AcDbObjectId id_DualSlopeRoof)
|
|
{
|
|
XDbObject obj(id_DualSlopeRoof,AcDb::kForRead);
|
|
TDbDualSlopeRoof *pRoof;
|
|
if (!!obj)
|
|
pRoof = TDbDualSlopeRoof::cast(obj.m_pObject);
|
|
if (!pRoof)
|
|
return RTERROR;
|
|
CAcModuleResourceOverride vTemp;
|
|
CWnd *pWnd = acedGetAcadFrame();
|
|
double dLtemp=pRoof->GetAngleLeft(),dRtemp=pRoof->GetAngleRight();
|
|
double dElevation=pRoof->GetElevation();
|
|
|
|
//add by xlc on 081223
|
|
BOOL bHeightLim=pRoof->IsHeightLim();
|
|
double dRoofHeight=pRoof->GetRoofHeight();
|
|
|
|
CDuanSlopeRoofDlg dlg(pRoof,pWnd);
|
|
|
|
//add by xlc on 081223
|
|
dlg.m_bXiandinggaodu=bHeightLim;
|
|
if (bHeightLim)
|
|
{
|
|
XPoint ptFirst,ptSecond;
|
|
ptFirst=pRoof->GetRidgeStart();
|
|
ptSecond=pRoof->GetRidgeEnd();
|
|
|
|
XPoly2D poly;
|
|
pRoof->GetPolyPath(poly);
|
|
poly.SetElevation(0);
|
|
|
|
XLine xLine(ptFirst,ptSecond);
|
|
xLine.SetElevation(0);
|
|
|
|
XPoint pt;
|
|
double dLowLeft = 0.0,dLowRight = 0.0;
|
|
double dHeight=0;
|
|
for (long i = 0;i < poly.Length();i++)
|
|
{
|
|
pt = *poly[i];
|
|
double dTemp;
|
|
if (!xLine.OnWhichSide(pt))
|
|
{
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dLowLeft-0.0) <= 1E-6)
|
|
{
|
|
dLowLeft = dTemp;
|
|
}
|
|
else if (dLowLeft < dTemp)
|
|
{
|
|
dLowLeft = dTemp;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dLowRight-0.0) <= 1E-6)
|
|
{
|
|
dLowRight = dTemp;
|
|
}
|
|
else if (dLowRight < dTemp)
|
|
{
|
|
dLowRight = dTemp;
|
|
}
|
|
}
|
|
}
|
|
if (fabs(dLowLeft-0.0) <= 1E-6)
|
|
{
|
|
double dTempLow = 0.0;
|
|
for (long i = 0;i < poly.Length();i++)
|
|
{
|
|
pt = *poly[i];
|
|
double dTemp;
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dTempLow-0.0) <= 1E-6)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
else if (dTempLow > dTemp)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
}
|
|
dLowRight = dLowRight - dTempLow;
|
|
dHeight=dLowRight*tan(dLtemp);
|
|
}
|
|
else if (fabs(dLowRight-0.0) <= 1E-6)
|
|
{
|
|
double dTempLow = 0.0;
|
|
for (long i = 0;i < poly.Length();i++)
|
|
{
|
|
pt = *poly[i];
|
|
double dTemp;
|
|
dTemp = pt.Distance(&xLine);
|
|
if (fabs(dTempLow-0.0) <= 1E-6)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
else if (dTempLow > dTemp)
|
|
{
|
|
dTempLow = dTemp;
|
|
}
|
|
}
|
|
dLowLeft = dLowLeft - dTempLow;
|
|
dHeight=dLowLeft*tan(dLtemp);
|
|
}
|
|
else
|
|
{
|
|
dHeight=dLowLeft*tan(dLtemp);
|
|
}
|
|
CString str;
|
|
str.Format(_T("%.2f"),dHeight);
|
|
// dlg.m_dHeight = _tstof(LPCTSTR(str));
|
|
dlg.m_dHeight = dRoofHeight;
|
|
}
|
|
|
|
if (dlg.DoModal() ==IDCANCEL)
|
|
{
|
|
if (pRoof->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pRoof->assertWriteEnabled();
|
|
pRoof->SetElevation(dElevation);
|
|
pRoof->SetAngle(dLtemp,dRtemp);
|
|
|
|
//add by xlc on 081223
|
|
pRoof->SetHeightLim(bHeightLim);
|
|
pRoof->SetRoofHeight(dRoofHeight);
|
|
|
|
pRoof->downgradeOpen();
|
|
ads_redraw(NULL,NULL);
|
|
}
|
|
else
|
|
{
|
|
if (pRoof->upgradeOpen()!=Acad::eOk)
|
|
return RTERROR;
|
|
pRoof->assertWriteEnabled();
|
|
pRoof->SetElevation(dlg.m_dElevation);
|
|
|
|
//add by xlc on 081223
|
|
pRoof->SetHeightLim(dlg.m_bXiandinggaodu);
|
|
if (dlg.m_bXiandinggaodu)
|
|
pRoof->SetRoofHeight(dlg.m_dHeight);
|
|
|
|
ads_redraw(NULL,NULL);
|
|
}
|
|
return RTNORM;
|
|
}
|
|
|
|
|
|
//add by cwk on 061210
|
|
//modify by xlc on 070517
|
|
/*void WallAlignRoof()
|
|
{
|
|
RBList rbMask1(RTDXF0, _T("TCH_DUALROOF"), NULL);
|
|
Entity ent;
|
|
int nRetCode=SelectEntity(_T("\n请选择人字屋顶:"), ent, rbMask1);
|
|
if (nRetCode!=RTNORM)
|
|
return;
|
|
RBList rbMask(RTDXF0, _T("TCH_WALL"), NULL);
|
|
PickSet ssWalls(SS_FREE);
|
|
nRetCode=SelectEntities(_T("\n请选择墙:"), ssWalls, rbMask);
|
|
if (nRetCode!=RTNORM)
|
|
return;
|
|
long n = 0;
|
|
do
|
|
{
|
|
BOOL m_bFlag1 = FALSE,m_bFlag2 = FALSE;
|
|
XPoly3D poly;
|
|
XPoly3D poly1;
|
|
XDbObject obj(ssWalls[n],AcDb::kForWrite);
|
|
TDbWall *pWall = TDbWall::cast(obj.m_pObject);
|
|
if (!pWall)
|
|
return;
|
|
XCurveSegment lCurveSegment,rCurveSegment;
|
|
|
|
pWall->GetSideCurve(lCurveSegment,rCurveSegment,0.0,TRUE);
|
|
XLine xLine1(lCurveSegment.StartPoint(),lCurveSegment.EndPoint());
|
|
double dTemp;
|
|
if (fabs(xLine1.StartPoint().y - xLine1.EndPoint().y) > 1E-6 && fabs(xLine1.StartPoint().x - xLine1.EndPoint().x) > 1E-6)
|
|
{
|
|
dTemp = 1.0 / xLine1.Direction();
|
|
dTemp = -dTemp;
|
|
}
|
|
else if (fabs(xLine1.StartPoint().x - xLine1.EndPoint().x) <= 1E-6)
|
|
dTemp = 0.0;
|
|
else
|
|
dTemp = PI / 2.0;
|
|
|
|
XLine xLine(xLine1.StartPoint(),dTemp);
|
|
AcGePlane wallPlane(xLine1.StartPoint(),xLine.Direction3d().AsAcGeVector3d());
|
|
XPlane LeftTempPlane,RightTempPLane;
|
|
XDbObject obj1(ent,AcDb::kForRead);
|
|
TDbDualSlopeRoof *pDualSlopeRoof = TDbDualSlopeRoof::cast(obj1.m_pObject);
|
|
if (!pDualSlopeRoof)
|
|
return;
|
|
|
|
|
|
AcGeVector3d vtAxis=(pDualSlopeRoof->GetRidgeEnd()-pDualSlopeRoof->GetRidgeStart()).AsAcGeVector3d();
|
|
AcGeVector3d vt1(AcGeVector3d::kZAxis);
|
|
vt1.rotateBy(-pDualSlopeRoof->GetAngleLeft(),vtAxis);
|
|
AcGePlane LeftPlane(XPoint(pDualSlopeRoof->GetRidgeStart().x,pDualSlopeRoof->GetRidgeStart().y,pDualSlopeRoof->GetElevation() - 200),vt1);
|
|
AcGeVector3d vt2(AcGeVector3d::kZAxis);
|
|
vt2.rotateBy(pDualSlopeRoof->GetAngleRight(),vtAxis);
|
|
AcGePlane RightPLane(XPoint(pDualSlopeRoof->GetRidgeStart().x,pDualSlopeRoof->GetRidgeStart().y,pDualSlopeRoof->GetElevation() - 200),vt2);
|
|
|
|
AcGeLine3d xLineLeft,xLineRight;
|
|
if (!wallPlane.intersectWith(LeftPlane,xLineLeft))
|
|
{ n++;continue;}
|
|
if (!wallPlane.intersectWith(RightPLane,xLineRight))
|
|
{ n++;continue;}
|
|
AcGePoint3d pt;
|
|
Adesk::Boolean bHasThirdPt1=xLineLeft.intersectWith(xLineRight,pt);
|
|
AcGePoint3d point = pt;
|
|
|
|
XLine xLineTemp;
|
|
xLineTemp.StartPoint() = pt = xLine1.StartPoint();
|
|
pt.z += 100000;
|
|
xLineTemp.EndPoint() = pt;
|
|
AcGePoint3d ptTemp1,ptTemp2;
|
|
|
|
AcGeLine3d acgeLine(AcGePoint3d(xLineTemp.StartPoint().x,xLineTemp.StartPoint().y,xLineTemp.StartPoint().z),
|
|
AcGePoint3d(xLineTemp.EndPoint().x,xLineTemp.EndPoint().y,xLineTemp.EndPoint().z));
|
|
if (!LeftPlane.intersectWith(acgeLine,ptTemp1))
|
|
{ n++;continue;}
|
|
if (!RightPLane.intersectWith(acgeLine,ptTemp2))
|
|
{ n++;continue;}
|
|
if (ptTemp1.z < ptTemp2.z)
|
|
poly.AppendNode(ptTemp1);
|
|
else
|
|
poly.AppendNode(ptTemp2);
|
|
|
|
if (bHasThirdPt1)
|
|
poly.AppendNode(point);
|
|
else
|
|
m_bFlag1 = TRUE;
|
|
|
|
pt = xLineTemp.StartPoint() = xLine1.EndPoint();
|
|
pt.z += 100000;
|
|
xLineTemp.EndPoint() = pt;
|
|
AcGeLine3d acgeLine1(AcGePoint3d(xLineTemp.StartPoint().x,xLineTemp.StartPoint().y,xLineTemp.StartPoint().z),
|
|
AcGePoint3d(xLineTemp.EndPoint().x,xLineTemp.EndPoint().y,xLineTemp.EndPoint().z));
|
|
if (!LeftPlane.intersectWith(acgeLine1,ptTemp1))
|
|
{ n++;continue;}
|
|
if (!RightPLane.intersectWith(acgeLine1,ptTemp2))
|
|
{ n++;continue;}
|
|
if (ptTemp1.z < ptTemp2.z)
|
|
poly.AppendNode(ptTemp1);
|
|
else
|
|
poly.AppendNode(ptTemp2);
|
|
{
|
|
int n = poly.Length();
|
|
poly.Compress(FALSE);
|
|
if (poly.Length() != n)
|
|
{
|
|
m_bFlag1 = TRUE;
|
|
bHasThirdPt1 = FALSE;
|
|
}
|
|
}
|
|
|
|
if (bHasThirdPt1)
|
|
{
|
|
AcGeVector3d v1 = poly[1]->AsAcGePoint3d() - poly[0]->AsAcGePoint3d(),v2 = poly[1]->AsAcGePoint3d() - poly[2]->AsAcGePoint3d();
|
|
AcGeVector3d vt = poly[2]->AsAcGePoint3d() - poly[0]->AsAcGePoint3d();
|
|
double d1 = v1.angleTo(vt);
|
|
vt = poly[0]->AsAcGePoint3d() - poly[2]->AsAcGePoint3d();
|
|
double d2 =v2.angleTo(vt);
|
|
if (d1 > PI/2.0 || d2 > PI/2.0 || fabs(d1 - PI/2.0)<= 1E-6 || fabs(d2 - PI/2.0)<= 1E-6)
|
|
{
|
|
poly.Remove(1);
|
|
m_bFlag1 = TRUE;
|
|
}
|
|
}
|
|
|
|
xLine1.SetPoints(rCurveSegment.StartPoint(),rCurveSegment.EndPoint());
|
|
if (fabs(xLine1.StartPoint().y - xLine1.EndPoint().y) > 1E-6 && fabs(xLine1.StartPoint().x - xLine1.EndPoint().x) > 1E-6)
|
|
{
|
|
dTemp = 1.0 / xLine1.Direction();
|
|
dTemp = -dTemp;
|
|
}
|
|
else if (fabs(xLine1.StartPoint().x - xLine1.EndPoint().x) <= 1E-6)
|
|
dTemp = 0.0;
|
|
else
|
|
dTemp = PI / 2.0;
|
|
|
|
XLine xLine0(xLine1.StartPoint(),dTemp);
|
|
AcGePlane wallPlane0(xLine1.StartPoint(),xLine0.Direction3d());
|
|
if (!wallPlane0.intersectWith(LeftPlane,xLineLeft))
|
|
{ n++;continue;}
|
|
if (!wallPlane0.intersectWith(RightPLane,xLineRight))
|
|
{ n++;continue;}
|
|
Adesk::Boolean bHasThirdPt2=xLineLeft.intersectWith(xLineRight,pt);
|
|
point = pt;
|
|
|
|
xLineTemp.StartPoint() = pt = xLine1.StartPoint();
|
|
pt.z += 100000;
|
|
xLineTemp.EndPoint() = pt;
|
|
AcGeLine3d acgeLine2(AcGePoint3d(xLineTemp.StartPoint().x,xLineTemp.StartPoint().y,xLineTemp.StartPoint().z),
|
|
AcGePoint3d(xLineTemp.EndPoint().x,xLineTemp.EndPoint().y,xLineTemp.EndPoint().z));
|
|
if (!LeftPlane.intersectWith(acgeLine2,ptTemp1))
|
|
{ n++;continue;}
|
|
if (!RightPLane.intersectWith(acgeLine2,ptTemp2))
|
|
{ n++;continue;}
|
|
|
|
if (ptTemp1.z < ptTemp2.z)
|
|
poly1.AppendNode(ptTemp1);
|
|
else
|
|
poly1.AppendNode(ptTemp2);
|
|
|
|
if (bHasThirdPt2)
|
|
poly1.AppendNode(point);
|
|
else
|
|
m_bFlag2 = TRUE;
|
|
|
|
pt = xLineTemp.StartPoint() = xLine1.EndPoint();
|
|
pt.z += 100000;
|
|
xLineTemp.EndPoint() = pt;
|
|
AcGeLine3d acgeLine3(AcGePoint3d(xLineTemp.StartPoint().x,xLineTemp.StartPoint().y,xLineTemp.StartPoint().z),
|
|
AcGePoint3d(xLineTemp.EndPoint().x,xLineTemp.EndPoint().y,xLineTemp.EndPoint().z));
|
|
if (!LeftPlane.intersectWith(acgeLine3,ptTemp1))
|
|
{ n++;continue;}
|
|
if (!RightPLane.intersectWith(acgeLine3,ptTemp2))
|
|
{ n++;continue;}
|
|
if (ptTemp1.z < ptTemp2.z)
|
|
poly1.AppendNode(ptTemp1);
|
|
else
|
|
poly1.AppendNode(ptTemp2);
|
|
{
|
|
int n = poly1.Length();
|
|
poly1.Compress(FALSE);
|
|
if (poly1.Length() != n)
|
|
{
|
|
m_bFlag2 = TRUE;
|
|
bHasThirdPt2 = FALSE;
|
|
}
|
|
}
|
|
|
|
if (bHasThirdPt2)
|
|
{
|
|
AcGeVector3d v1 = poly1[1]->AsAcGePoint3d() - poly1[0]->AsAcGePoint3d(),v2 = poly1[1]->AsAcGePoint3d() - poly1[2]->AsAcGePoint3d();
|
|
AcGeVector3d vt = poly1[2]->AsAcGePoint3d()- poly1[0]->AsAcGePoint3d();
|
|
double d1 = v1.angleTo(vt);
|
|
vt = poly1[0]->AsAcGePoint3d() - poly1[2]->AsAcGePoint3d();
|
|
double d2 =v2.angleTo(vt);
|
|
if (d1 > PI/2.0 || d2 > PI/2.0 || fabs(d1 - PI/2.0)<= 1E-6 || fabs(d2 - PI/2.0)<= 1E-6)
|
|
{
|
|
poly1.Remove(1);
|
|
m_bFlag2 = TRUE;
|
|
}
|
|
}
|
|
XPoly3D poly3d;
|
|
|
|
if (poly[0]->z < poly1[0]->z)
|
|
poly3d.AppendNode(*poly[0]);
|
|
else
|
|
poly3d.AppendNode(*poly1[0]);
|
|
if (!m_bFlag1 && !m_bFlag2)
|
|
{
|
|
if (poly[1]->z < poly1[1]->z)
|
|
poly3d.AppendNode(*poly[1]);
|
|
else
|
|
poly3d.AppendNode(*poly1[1]);
|
|
if (poly[2]->z < poly1[2]->z)
|
|
poly3d.AppendNode(*poly[2]);
|
|
else
|
|
poly3d.AppendNode(*poly1[2]);
|
|
}
|
|
else if (!m_bFlag1 && m_bFlag2)
|
|
{
|
|
poly3d.AppendNode(*poly[1]);
|
|
poly3d.AppendNode(*poly[2]);
|
|
}
|
|
else if (m_bFlag1 && !m_bFlag2)
|
|
{
|
|
poly3d.AppendNode(*poly1[1]);
|
|
poly3d.AppendNode(*poly1[2]);
|
|
}
|
|
else
|
|
{
|
|
if (poly[1]->z < poly1[1]->z)
|
|
poly3d.AppendNode(*poly[1]);
|
|
else
|
|
poly3d.AppendNode(*poly1[1]);
|
|
}
|
|
|
|
double d = poly3d[0]->z;
|
|
if (poly3d[1]->z > d)
|
|
d = poly3d[1]->z;
|
|
if (!m_bFlag1 || !m_bFlag2)
|
|
{
|
|
if (poly3d[2]->z > d)
|
|
d = poly3d[2]->z;
|
|
}
|
|
ads_matrix matTo2d;
|
|
pWall->GetPlanarMatrix(matTo2d);
|
|
poly3d.TransUCS(matTo2d);
|
|
pWall->assertWriteEnabled();
|
|
{
|
|
XPoly2D poly2d;
|
|
poly3d.AsPoly2D(poly2d);
|
|
pWall->SetPolyShape(poly2d);
|
|
}
|
|
if (d > fabs(pWall->GetHeight() - pWall->GetElevation()))
|
|
{
|
|
if (!m_bFlag1 || !m_bFlag2)
|
|
pWall->SetHeight(d - pWall->GetElevation());
|
|
else
|
|
pWall->SetHeight(d - pWall->GetElevation() + 200);
|
|
}
|
|
n++;
|
|
} while(n < ssWalls.Length());
|
|
}*/
|
|
//modify by xlc on 070712
|
|
/*
|
|
void WallAlignRoof()
|
|
{
|
|
RBList rbMask1(RTDXF0, _T("TCH_DUALROOF"), NULL);
|
|
Entity ent;
|
|
int nRetCode=SelectEntity(_T("\n请选择人字屋顶:"), ent, rbMask1);
|
|
if (nRetCode!=RTNORM)
|
|
return;
|
|
RBList rbMask(RTDXF0, _T("TCH_WALL"), NULL);
|
|
PickSet ssWalls(SS_FREE);
|
|
nRetCode=SelectEntities(_T("\n请选择墙:"), ssWalls, rbMask);
|
|
if (nRetCode!=RTNORM)
|
|
return;
|
|
|
|
//modify by xlc on 070517
|
|
XDbObject obj1(ent,AcDb::kForRead);
|
|
TDbDualSlopeRoof *pDualSlopeRoof = TDbDualSlopeRoof::cast(obj1.m_pObject);
|
|
if (!pDualSlopeRoof)
|
|
return;
|
|
|
|
long n = 0;
|
|
do
|
|
{
|
|
BOOL m_bFlag1 = FALSE,m_bFlag2 = FALSE;
|
|
XPoly3D poly;
|
|
XPoly3D poly1;
|
|
XDbObject obj(ssWalls[n],AcDb::kForWrite);
|
|
TDbWall *pWall = TDbWall::cast(obj.m_pObject);
|
|
if (!pWall)
|
|
return;
|
|
|
|
XCurveSegment lCurveSegment,rCurveSegment;//墙左右边线
|
|
pWall->GetSideCurve(lCurveSegment,rCurveSegment,0.0,TRUE);
|
|
|
|
XLine xLine1(lCurveSegment.StartPoint(),lCurveSegment.EndPoint());//左边线
|
|
if (!GetIntersect(xLine1,pDualSlopeRoof,m_bFlag1,poly))
|
|
{
|
|
n++;
|
|
continue;
|
|
}
|
|
|
|
xLine1.SetPoints(rCurveSegment.StartPoint(),rCurveSegment.EndPoint());//右边线
|
|
if (!GetIntersect(xLine1,pDualSlopeRoof,m_bFlag2,poly1))
|
|
{
|
|
n++;
|
|
continue;
|
|
}
|
|
|
|
//add by xlc on 070608
|
|
//墙的两面截面不同
|
|
if (poly.Length() != poly1.Length())
|
|
{
|
|
if (poly.Length() == 3)
|
|
{
|
|
poly.RemoveNode(1);
|
|
m_bFlag1 = TRUE;
|
|
}
|
|
|
|
if (poly1.Length() == 3)
|
|
{
|
|
poly1.RemoveNode(1);
|
|
m_bFlag2 = TRUE;
|
|
}
|
|
}
|
|
|
|
XPoly3D poly3d;//墙立面
|
|
if (poly[0]->z < poly1[0]->z)
|
|
poly3d.AppendNode(*poly[0]);
|
|
else
|
|
poly3d.AppendNode(*poly1[0]);
|
|
if (!m_bFlag1 && !m_bFlag2)
|
|
{
|
|
if (poly[1]->z < poly1[1]->z)
|
|
poly3d.AppendNode(*poly[1]);
|
|
else
|
|
poly3d.AppendNode(*poly1[1]);
|
|
if (poly[2]->z < poly1[2]->z)
|
|
poly3d.AppendNode(*poly[2]);
|
|
else
|
|
poly3d.AppendNode(*poly1[2]);
|
|
}
|
|
else if (!m_bFlag1 && m_bFlag2)
|
|
{
|
|
poly3d.AppendNode(*poly[1]);
|
|
poly3d.AppendNode(*poly[2]);
|
|
}
|
|
else if (m_bFlag1 && !m_bFlag2)
|
|
{
|
|
poly3d.AppendNode(*poly1[1]);
|
|
poly3d.AppendNode(*poly1[2]);
|
|
}
|
|
else
|
|
{
|
|
if (poly[1]->z < poly1[1]->z)
|
|
poly3d.AppendNode(*poly[1]);
|
|
else
|
|
poly3d.AppendNode(*poly1[1]);
|
|
}
|
|
|
|
double d = poly3d[0]->z;
|
|
if (poly3d[1]->z > d)
|
|
d = poly3d[1]->z;
|
|
if (!m_bFlag1 || !m_bFlag2)
|
|
{
|
|
if (poly3d[2]->z > d)
|
|
d = poly3d[2]->z;
|
|
}
|
|
ads_matrix matTo2d;
|
|
pWall->GetPlanarMatrix(matTo2d);
|
|
poly3d.TransUCS(matTo2d);
|
|
pWall->assertWriteEnabled();
|
|
{
|
|
XPoly2D poly2d;
|
|
poly3d.AsPoly2D(poly2d);
|
|
pWall->SetPolyShape(poly2d);
|
|
}
|
|
if (d > fabs(pWall->GetHeight() - pWall->GetElevation()))
|
|
{
|
|
if (!m_bFlag1 || !m_bFlag2)
|
|
pWall->SetHeight(d - pWall->GetElevation());
|
|
else
|
|
pWall->SetHeight(d - pWall->GetElevation() + 1000);
|
|
}
|
|
n++;
|
|
} while(n < ssWalls.Length());
|
|
}
|
|
*/
|
|
|
|
//任意坡顶和柱子都适用
|
|
void WallAlignRoof()
|
|
{
|
|
RBList rbMask1(RTDXF0, _T("TCH_MOUNTROOF,TCH_SLOPEROOF,TCH_CUSPROOF,TCH_DUALROOF,POLYLINE,3DFACE"), NULL);
|
|
PickSet ssRoofs(SS_FREE);
|
|
int nRetCode=SelectEntities(_T("\n请选择屋顶:"), ssRoofs, rbMask1);
|
|
if (nRetCode!=RTNORM)
|
|
return;
|
|
RBList rbMask(RTDXF0, _T("TCH_WALL,TCH_COLUMN"), NULL);
|
|
PickSet ssWalls(SS_FREE);
|
|
nRetCode=SelectEntities(_T("\n请选择墙或柱子:"), ssWalls, rbMask);
|
|
if (nRetCode!=RTNORM)
|
|
return;
|
|
|
|
DList<X3DFace> lstFace;
|
|
long m = 0;
|
|
do
|
|
{
|
|
AcDbObjectId id; //任意屋顶id
|
|
if (acdbGetObjectId(id, ssRoofs[m]) != Acad::eOk)
|
|
{
|
|
m++;
|
|
continue;
|
|
}
|
|
|
|
GetRoofAllPoly(id, lstFace); //获得屋顶的下表面
|
|
m++;
|
|
}while(m < ssRoofs.Length());
|
|
|
|
if (lstFace.Length() < 1)
|
|
return;
|
|
|
|
acedSetStatusBarProgressMeter(_T("正在处理中，请稍候..."),1,ssWalls.Length());
|
|
long n = 0;
|
|
do
|
|
{
|
|
acedSetStatusBarProgressMeterPos(n+1);
|
|
|
|
XPoly3D poly;
|
|
XPoly3D poly1;
|
|
XDbObject obj(ssWalls[n],AcDb::kForWrite);
|
|
TDbWall *pWall = TDbWall::cast(obj.m_pObject);
|
|
|
|
TDbColumn *pColumn = NULL;
|
|
if (!pWall)
|
|
{
|
|
pColumn = TDbColumn::cast(obj.m_pObject);
|
|
if (!pColumn)
|
|
{
|
|
n++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
ColumnAlignSlopeRoof(pColumn,lstFace);
|
|
n++;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
//modify by xlc on 090602 取消弧墙的限制,按直墙算会产生问题！！
|
|
//if (pWall->GetCurveType() != CURVE_LINE)
|
|
//{
|
|
// n++;
|
|
// continue;
|
|
//}
|
|
|
|
XCurveSegment lCurveSegment,rCurveSegment;
|
|
pWall->GetSideCurve(lCurveSegment,rCurveSegment,0.0,TRUE);
|
|
|
|
XPoint ptStart = lCurveSegment.StartPoint();
|
|
XPoint ptEnd = lCurveSegment.EndPoint();
|
|
XLine line(ptStart,ptEnd);
|
|
if (!GetIntSectPoly(lstFace,line,poly)) //墙左边线
|
|
{
|
|
n++;
|
|
continue;
|
|
}
|
|
|
|
ptStart = rCurveSegment.StartPoint();
|
|
ptEnd = rCurveSegment.EndPoint();
|
|
XLine rLine(ptStart,ptEnd);
|
|
if (!GetIntSectPoly(lstFace,rLine,poly1)) //墙右边线
|
|
{
|
|
n++;
|
|
continue;
|
|
}
|
|
|
|
AcGeVector3d dir = rCurveSegment.EndPoint() - rCurveSegment.StartPoint();
|
|
double angle = AcGeVector3d::kXAxis.angleTo(dir,AcGeVector3d::kZAxis);
|
|
AcGeMatrix3d mat = AcGeMatrix3d::rotation(-angle,AcGeVector3d::kZAxis,AcGePoint3d(rCurveSegment.StartPoint()));
|
|
poly.TransformBy(mat);
|
|
poly1.TransformBy(mat);
|
|
|
|
//拟和边线
|
|
XPoly3D poly3d;
|
|
if (poly[0]->z < poly1[0]->z)
|
|
poly3d.AppendNode(*poly[0]);
|
|
else
|
|
poly3d.AppendNode(*poly1[0]);
|
|
|
|
for(int i=1,j=1;i<poly.Length()-1,j<poly1.Length()-1;)
|
|
{
|
|
if (i >= poly.Length()-1 && j >= poly1.Length()-1)
|
|
{
|
|
break;
|
|
}
|
|
else if (fabs(poly[i]->x- poly1[j]->x) < 1e-6)//
|
|
{
|
|
if (poly[i]->z < poly1[j]->z)
|
|
{
|
|
poly3d.AppendNode(*poly[i]);
|
|
}
|
|
else
|
|
{
|
|
poly3d.AppendNode(*poly1[j]);
|
|
}
|
|
i++;
|
|
j++;
|
|
}
|
|
else if (poly[i]->x- poly1[j]->x < 0)
|
|
{
|
|
if ( i >= poly.Length()-1)
|
|
{
|
|
j++;
|
|
continue;
|
|
}
|
|
AcGePoint3d p1(poly[i]->x,poly[i]->y,poly[i]->z);
|
|
AcGePlane plane(p1,AcGeVector3d::kXAxis);
|
|
AcGePoint3d p2(poly1[j-1]->x,poly1[j-1]->y,poly1[j-1]->z);
|
|
AcGePoint3d p3(poly1[j]->x,poly1[j]->y,poly1[j]->z);
|
|
AcGeLine3d tmpLine(p2,p3);
|
|
|
|
AcGePoint3d pt;
|
|
tmpLine.intersectWith(plane,pt);
|
|
if (pt.x < poly1[0]->x || pt.x > poly1[poly1.Length()-1]->x)
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
|
|
if (poly[i]->z < pt.z)
|
|
{
|
|
poly3d.AppendNode(*poly[i]);
|
|
}
|
|
else
|
|
{
|
|
poly3d.AppendNode(pt);
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
else if (poly[i]->x- poly1[j]->x > 0)
|
|
{
|
|
if ( j >= poly1.Length()-1)
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
AcGePoint3d p1(poly1[j]->x,poly1[j]->y,poly1[j]->z);
|
|
AcGePlane plane(p1,AcGeVector3d::kXAxis);
|
|
AcGePoint3d p2(poly[i-1]->x,poly[i-1]->y,poly[i-1]->z);
|
|
AcGePoint3d p3(poly[i]->x,poly[i]->y,poly[i]->z);
|
|
AcGeLine3d tmpLine(p2,p3);
|
|
|
|
AcGePoint3d pt;
|
|
tmpLine.intersectWith(plane,pt);
|
|
|
|
if (pt.x < poly[0]->x || pt.x > poly[poly.Length()-1]->x)
|
|
{
|
|
j++;
|
|
continue;
|
|
}
|
|
|
|
if (poly1[j]->z < pt.z)
|
|
{
|
|
poly3d.AppendNode(*poly1[j]);
|
|
}
|
|
else
|
|
{
|
|
poly3d.AppendNode(pt);
|
|
}
|
|
|
|
j++;
|
|
}
|
|
}
|
|
|
|
if (poly[poly.Length()-1]->z < poly1[poly1.Length()-1]->z)
|
|
poly3d.AppendNode(*poly[poly.Length()-1]);
|
|
else
|
|
poly3d.AppendNode(*poly1[poly1.Length()-1]);
|
|
|
|
AcGeMatrix3d mat1 = AcGeMatrix3d::rotation(angle,AcGeVector3d::kZAxis,AcGePoint3d(rCurveSegment.StartPoint()));
|
|
poly3d.TransformBy(mat1);
|
|
|
|
double d = poly3d[0]->z;
|
|
for(i = 1; i < poly3d.Length(); i++)
|
|
{
|
|
if (poly3d[i]->z > d)
|
|
d = poly3d[i]->z;
|
|
}
|
|
|
|
//modify by xlc on 070801
|
|
BOOL bFlag = TRUE; //墙与屋顶平行
|
|
// if (poly3d.Length() == 2)
|
|
// {
|
|
// if (fabs(poly3d[0]->z - poly3d[1]->z) < 1e-6)
|
|
// bFlag = TRUE;
|
|
// }
|
|
for(i = 1; i < poly3d.Length(); i++)
|
|
{
|
|
if (fabs(poly3d[0]->z - poly3d[i]->z) > 1e-6)
|
|
{
|
|
bFlag = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
ads_matrix matTo2d;
|
|
pWall->GetPlanarMatrix(matTo2d);
|
|
poly3d.TransUCS(matTo2d);
|
|
|
|
pWall->assertWriteEnabled();
|
|
{
|
|
XPoly2D poly2d;
|
|
poly3d.AsPoly2D(poly2d);
|
|
pWall->SetPolyShape(poly2d);
|
|
}
|
|
if (d > fabs(pWall->GetHeight() - pWall->GetElevation()))
|
|
{
|
|
if (bFlag) //墙与屋顶面平行
|
|
pWall->SetHeight(d - pWall->GetElevation());
|
|
else
|
|
pWall->SetHeight(d - pWall->GetElevation() + _AS_SYS_UNIT(400));
|
|
}
|
|
|
|
n++;
|
|
} while(n < ssWalls.Length());
|
|
acedRestoreStatusBar();
|
|
}
|
|
|
|
|
|
//modify by xlc on 070517
|
|
BOOL GetIntersect(XLine &xLine1,const TDbDualSlopeRoof *pDualSlopeRoof,BOOL &m_bFlag1,XPoly3D &poly)
|
|
{
|
|
//modify by xlc on 070608
|
|
//减小计算误差
|
|
/* double dTemp;//墙立面的法向角度
|
|
if (fabs(xLine1.StartPoint().y - xLine1.EndPoint().y) > 1E-6 && fabs(xLine1.StartPoint().x - xLine1.EndPoint().x) > 1E-6)
|
|
{
|
|
dTemp = 1.0 / xLine1.Direction();
|
|
dTemp = -dTemp;
|
|
}
|
|
else if (fabs(xLine1.StartPoint().x - xLine1.EndPoint().x) <= 1E-6)
|
|
dTemp = 0.0;
|
|
else
|
|
dTemp = PI / 2.0;
|
|
|
|
XLine xLine(xLine1.StartPoint(),dTemp);
|
|
AcGePlane wallPlane(xLine1.StartPoint(),xLine.Direction3d().AsAcGeVector3d());*/
|
|
AcGePlane wallPlane(xLine1.StartPoint(),xLine1.EndPoint(),AcGePoint3d(xLine1.StartPoint().x,xLine1.StartPoint().y,xLine1.StartPoint().z + _AS_SYS_UNIT(100.0)));
|
|
|
|
//构造屋顶平面
|
|
AcGeVector3d vtAxis=(pDualSlopeRoof->GetRidgeEnd()-pDualSlopeRoof->GetRidgeStart()).AsAcGeVector3d();
|
|
AcGeVector3d vt1(AcGeVector3d::kZAxis);
|
|
double left=-pDualSlopeRoof->GetAngleLeft();
|
|
vt1.rotateBy(left,vtAxis);
|
|
|
|
//modify by xlc on 090120 檐板厚可调
|
|
//AcGePlane LeftPlane(XPoint(pDualSlopeRoof->GetRidgeStart().x,pDualSlopeRoof->GetRidgeStart().y,pDualSlopeRoof->GetElevation() - _AS_SYS_UNIT(200)),vt1);
|
|
AcGePlane LeftPlane(XPoint(pDualSlopeRoof->GetRidgeStart().x,pDualSlopeRoof->GetRidgeStart().y,pDualSlopeRoof->GetElevation() - pDualSlopeRoof->GetSlabThick()),vt1);
|
|
|
|
AcGeVector3d vt2(AcGeVector3d::kZAxis);
|
|
double right=pDualSlopeRoof->GetAngleRight();
|
|
vt2.rotateBy(right,vtAxis);
|
|
|
|
//modify by xlc on 090120 檐板厚可调
|
|
//AcGePlane RightPLane(XPoint(pDualSlopeRoof->GetRidgeStart().x,pDualSlopeRoof->GetRidgeStart().y,pDualSlopeRoof->GetElevation() -_AS_SYS_UNIT(200)),vt2);
|
|
AcGePlane RightPLane(XPoint(pDualSlopeRoof->GetRidgeStart().x,pDualSlopeRoof->GetRidgeStart().y,pDualSlopeRoof->GetElevation() -pDualSlopeRoof->GetSlabThick()),vt2);
|
|
|
|
//墙与屋顶的交线
|
|
AcGeLine3d xLineLeft,xLineRight;
|
|
if (!wallPlane.intersectWith(LeftPlane,xLineLeft))
|
|
{
|
|
return FALSE;
|
|
}
|
|
if (!wallPlane.intersectWith(RightPLane,xLineRight))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
AcGePoint3d pt;//墙与屋顶交线的交点
|
|
Adesk::Boolean bHasThirdPt1=xLineLeft.intersectWith(xLineRight,pt);
|
|
|
|
AcGePoint3d point = pt;//中间点
|
|
XLine xLineTemp;
|
|
xLineTemp.StartPoint() = pt = xLine1.StartPoint();
|
|
pt.z +=_AS_SYS_UNIT(100000);// [11/15/2007 nsh]
|
|
xLineTemp.EndPoint() = pt;
|
|
|
|
AcGePoint3d ptTemp1,ptTemp2;//墙点与屋顶左右平面的的交点
|
|
AcGeLine3d acgeLine(AcGePoint3d(xLineTemp.StartPoint().x,xLineTemp.StartPoint().y,xLineTemp.StartPoint().z),
|
|
AcGePoint3d(xLineTemp.EndPoint().x,xLineTemp.EndPoint().y,xLineTemp.EndPoint().z));
|
|
if (!LeftPlane.intersectWith(acgeLine,ptTemp1))
|
|
{
|
|
return FALSE;
|
|
}
|
|
if (!RightPLane.intersectWith(acgeLine,ptTemp2))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
if (ptTemp1.z < ptTemp2.z)
|
|
poly.AppendNode(ptTemp1);
|
|
else
|
|
poly.AppendNode(ptTemp2);
|
|
|
|
if (bHasThirdPt1)
|
|
poly.AppendNode(point);
|
|
else
|
|
m_bFlag1 = TRUE;
|
|
|
|
pt = xLineTemp.StartPoint() = xLine1.EndPoint();
|
|
pt.z += _AS_SYS_UNIT(10000);// [11/15/2007 nsh]
|
|
xLineTemp.EndPoint() = pt;
|
|
AcGeLine3d acgeLine1(AcGePoint3d(xLineTemp.StartPoint().x,xLineTemp.StartPoint().y,xLineTemp.StartPoint().z),
|
|
AcGePoint3d(xLineTemp.EndPoint().x,xLineTemp.EndPoint().y,xLineTemp.EndPoint().z));
|
|
if (!LeftPlane.intersectWith(acgeLine1,ptTemp1))
|
|
{
|
|
return FALSE;
|
|
}
|
|
if (!RightPLane.intersectWith(acgeLine1,ptTemp2))
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if (ptTemp1.z < ptTemp2.z)
|
|
poly.AppendNode(ptTemp1);
|
|
else
|
|
poly.AppendNode(ptTemp2);
|
|
{
|
|
int n = poly.Length();
|
|
poly.Compress(FALSE);
|
|
if (poly.Length() != n)
|
|
{
|
|
m_bFlag1 = TRUE;
|
|
bHasThirdPt1 = FALSE;
|
|
}
|
|
}
|
|
|
|
if (bHasThirdPt1)
|
|
{
|
|
AcGeVector3d v1 = poly[1]->AsAcGePoint3d() - poly[0]->AsAcGePoint3d(),v2 = poly[1]->AsAcGePoint3d() - poly[2]->AsAcGePoint3d();
|
|
AcGeVector3d vt = poly[2]->AsAcGePoint3d() - poly[0]->AsAcGePoint3d();
|
|
double d1 = v1.angleTo(vt);
|
|
vt = poly[0]->AsAcGePoint3d() - poly[2]->AsAcGePoint3d();
|
|
double d2 =v2.angleTo(vt);
|
|
|
|
//modify by xlc on 070516
|
|
if (d1 > PI/2.0 || d2 > PI/2.0 || fabs(d1 - PI/2.0)<= 1E-6 || fabs(d2 - PI/2.0)<= 1E-6)
|
|
//if (d1 > PI/2.0 || d2 > PI/2.0 || fabs(d1 - PI/2.0)<= 1E-2 || fabs(d2 - PI/2.0)<= 1E-2)
|
|
{
|
|
poly.Remove(1);
|
|
m_bFlag1 = TRUE;
|
|
}
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
//add by xlc on 070712
|
|
//柱子对齐屋顶
|
|
void ColumnAlignSlopeRoof(TDbColumn *pColumn, //[in]柱子对象
|
|
DList<X3DFace> &lstFace //[in]屋顶面
|
|
)
|
|
{
|
|
XPoly2D polyColu;
|
|
pColumn->GetOutline(polyColu);
|
|
if (pColumn->GetSectionShape() == TColumnData::kCircle)
|
|
{
|
|
polyColu.Disperse(polyColu);
|
|
}
|
|
|
|
double height = 0.0;
|
|
XPoint start,end;
|
|
XLine xLine1(*polyColu[0],*polyColu[polyColu.Length()-1]);
|
|
|
|
//modify by xlc on 080303 解决部分柱子在屋顶面外边
|
|
BOOL bFlag = TRUE; //bFlag为TRUE时，初始化height
|
|
if (GetEndIntSectPoint(lstFace,xLine1,start,end,FALSE)) //获得线端点的投影点
|
|
{
|
|
if (bFlag)
|
|
{
|
|
height = start.z;
|
|
bFlag = FALSE;
|
|
}
|
|
|
|
if (height > end.z)
|
|
height = end.z;
|
|
|
|
XPoly3D poly;
|
|
GetIntSectPoint(lstFace,xLine1,poly); //获得线平面与face平面边线的交点
|
|
|
|
for(int j = 0; j < poly.Length(); j++)
|
|
{
|
|
//modify by xlc on 080303
|
|
if (bFlag)
|
|
{
|
|
height = poly[j]->z;
|
|
bFlag=FALSE;
|
|
continue;
|
|
}
|
|
|
|
if (height > poly[j]->z)
|
|
{
|
|
height = poly[j]->z;
|
|
}
|
|
}
|
|
}
|
|
|
|
for(int i = 0; i < polyColu.Length()-1; i++)
|
|
{
|
|
XPoly3D poly1;
|
|
XLine xLine(*polyColu[i],*polyColu[i+1]);
|
|
GetIntSectPoint(lstFace,xLine,poly1);
|
|
|
|
for(int j = 0; j < poly1.Length(); j++)
|
|
{
|
|
if (height > poly1[j]->z)
|
|
{
|
|
height = poly1[j]->z;
|
|
}
|
|
}
|
|
|
|
//modify by xlc on 080303
|
|
//if (!GetEndIntSectPoint(lstFace,xLine,start,end))
|
|
// return;
|
|
if (!GetEndIntSectPoint(lstFace,xLine,start,end,FALSE))
|
|
continue;
|
|
|
|
if (height > start.z)
|
|
height = start.z;
|
|
if (height > end.z)
|
|
height = end.z;
|
|
}
|
|
|
|
if (height > pColumn->GetElevation())
|
|
{
|
|
pColumn->assertWriteEnabled();
|
|
pColumn->SetHeight(height);
|
|
}
|
|
}
|
|
|
|
//add by xlc on 070712
|
|
//求线与线的交点
|
|
BOOL GetIntPoint(AcDbCurve *projLine,AcGePoint3d ptStart,AcGePoint3d ptEnd,AcGePoint3d &ptInt)
|
|
{
|
|
AcDbLine line(ptStart,ptEnd);
|
|
|
|
AcGePoint3dArray points;
|
|
if (projLine != NULL)
|
|
projLine->intersectWith(&line, AcDb::kOnBothOperands, points);
|
|
|
|
if (points.length() > 0)
|
|
{
|
|
ptInt = points.at(0);
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//add by xlc on 070712
|
|
//获得屋顶向内的面
|
|
void GetRoofAllPoly(AcDbObjectId id, //[in]屋顶对象ID
|
|
DList<X3DFace> &lstFace //[out]屋顶向内的面
|
|
)
|
|
{
|
|
OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pRoof);
|
|
if (pRoof)
|
|
{
|
|
int nFlag = 0; //是否屋顶对象,0:非屋顶对象；1:人字屋顶或攒尖屋顶,矩形屋顶；2:任意屋顶（有内侧缺面）
|
|
BOOL bRoof = FALSE; //是否可视为屋顶
|
|
if (pRoof->isKindOf(TDbDualSlopeRoof::desc())
|
|
|| pRoof->isKindOf(TDbCuspRoof::desc())
|
|
|| pRoof->isKindOf(TDbMountRoof::desc())
|
|
)
|
|
{
|
|
nFlag = 1;
|
|
bRoof = TRUE;
|
|
}
|
|
else if (pRoof->isKindOf(TDbSlopeRoof::desc()))
|
|
{
|
|
nFlag = 2;
|
|
bRoof = TRUE;
|
|
}
|
|
else if (pRoof->isKindOf(AcDbPolyFaceMesh::desc())
|
|
|| pRoof->isKindOf(AcDbPolygonMesh::desc())
|
|
|| pRoof->isKindOf(AcDbFace::desc())
|
|
)
|
|
{
|
|
bRoof = TRUE;
|
|
}
|
|
|
|
if (bRoof)
|
|
{
|
|
TMasterProperties prop;
|
|
AcDbVoidPtrArray entSet;
|
|
int nOldMode=DocGetDrawMode();
|
|
DocSetDrawMode(DRAW_3D);
|
|
if (nFlag == 2)
|
|
{
|
|
AcDbEntity *pEnt = (AcDbEntity*)pRoof->clone();
|
|
if (pEnt)
|
|
{
|
|
double height = _AS_SYS_UNIT(200.0);// [11/15/2007 nsh]
|
|
|
|
AcGeMatrix3d mat;
|
|
mat.setToTranslation(AcGeVector3d(0,0,-height));
|
|
|
|
pEnt->upgradeOpen();
|
|
pEnt->transformBy(mat);
|
|
|
|
InitModel(prop, pEnt, NULL, entSet);
|
|
|
|
delete pEnt;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
InitModel(prop, pRoof, NULL, entSet);
|
|
}
|
|
DocSetDrawMode(nOldMode);
|
|
|
|
int nLen=entSet.length();
|
|
for(int n=0; n<nLen; n++)
|
|
{
|
|
AcDbEntity *pEnt=(AcDbEntity *)entSet[n];
|
|
if (pEnt->isKindOf(AcDbFace::desc()))
|
|
{
|
|
AcDbFace *pFace = AcDbFace::cast(pEnt);
|
|
if (pFace != NULL)
|
|
{
|
|
X3DFace p3DFace(*pFace);
|
|
XVector3D vtNormal = p3DFace.GetNormal();
|
|
|
|
if (fabs(vtNormal.z) < 1.0e-6) //立面
|
|
continue;
|
|
|
|
if (nFlag == 1)
|
|
{
|
|
if (vtNormal.z > 1.0e-6) //人字坡顶或攒尖屋顶向下的面
|
|
continue;
|
|
}
|
|
else if (nFlag == 2)
|
|
{
|
|
if (vtNormal.z < 1.0e-6) //任意坡顶向上的面
|
|
continue;
|
|
}
|
|
|
|
lstFace.Append(new X3DFace(p3DFace));
|
|
}
|
|
}
|
|
}
|
|
ReleaseEntSet(entSet);
|
|
}
|
|
}
|
|
OPENOBJ_END();
|
|
}
|
|
|
|
//add by xlc on 070712
|
|
//获得线段与屋顶面边线的投影交点
|
|
void GetIntSectPoint(DList<X3DFace> &lstFace, //[in]屋顶面
|
|
XLine xLine, //[in]线段
|
|
XPoly3D &poly //[out]投影点数组
|
|
)
|
|
{
|
|
int num = lstFace.Length();
|
|
for(int i = 0; i < lstFace.Length(); i++) //获得直线所在平面与投影面的交点
|
|
{
|
|
AcDbLine line(xLine.StartPoint(),xLine.EndPoint());
|
|
X3DFace face(*lstFace[i]);
|
|
face.MakeBetter();
|
|
AcGePlane roof(AcGePoint3d(face.GetVertex(0)),AcGePoint3d(face.GetVertex(1)),AcGePoint3d(face.GetVertex(2)));
|
|
|
|
AcDbCurve *projLine = NULL; //在face平面上的投影线
|
|
line.getProjectedCurve(roof, AcGeVector3d::kZAxis, projLine);
|
|
|
|
if (projLine != NULL)
|
|
{
|
|
//modify by xlc on 070801 消除隐藏线的影响
|
|
AcGePoint3d ptInt; //平面与face面交线与face边的交点
|
|
//if (GetIntPoint(projLine,AcGePoint3d(face.GetVertex(0)),AcGePoint3d(face.GetVertex(1)),ptInt))
|
|
if (GetIntPoint(projLine,AcGePoint3d(face.GetVertex(0)),AcGePoint3d(face.GetVertex(1)),ptInt) && face.IsVisible(0))
|
|
poly.AppendNode(ptInt);
|
|
|
|
//if (GetIntPoint(projLine,AcGePoint3d(face.GetVertex(1)),AcGePoint3d(face.GetVertex(2)),ptInt))
|
|
if (GetIntPoint(projLine,AcGePoint3d(face.GetVertex(1)),AcGePoint3d(face.GetVertex(2)),ptInt) && face.IsVisible(1))
|
|
poly.AppendNode(ptInt);
|
|
|
|
if (!face.IsTriangle(2))
|
|
{
|
|
//if (GetIntPoint(projLine,AcGePoint3d(face.GetVertex(2)),AcGePoint3d(face.GetVertex(3)),ptInt))
|
|
if (GetIntPoint(projLine,AcGePoint3d(face.GetVertex(2)),AcGePoint3d(face.GetVertex(3)),ptInt) && face.IsVisible(2))
|
|
poly.AppendNode(ptInt);
|
|
//if (GetIntPoint(projLine,AcGePoint3d(face.GetVertex(3)),AcGePoint3d(face.GetVertex(0)),ptInt))
|
|
if (GetIntPoint(projLine,AcGePoint3d(face.GetVertex(3)),AcGePoint3d(face.GetVertex(0)),ptInt) && face.IsVisible(3))
|
|
poly.AppendNode(ptInt);
|
|
}
|
|
else
|
|
{
|
|
//if (GetIntPoint(projLine,AcGePoint3d(face.GetVertex(2)),AcGePoint3d(face.GetVertex(0)),ptInt))
|
|
if (GetIntPoint(projLine,AcGePoint3d(face.GetVertex(2)),AcGePoint3d(face.GetVertex(0)),ptInt) && face.IsVisible(2))
|
|
poly.AppendNode(ptInt);
|
|
}
|
|
delete projLine;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
//add by xlc on 070712
|
|
//获得墙端点在屋顶面上的投影点
|
|
//返回值：TRUE，成功；FALSE，失败
|
|
BOOL GetEndIntSectPoint(DList<X3DFace> &lstFace, //[in]屋顶面
|
|
XLine xLine, //[in]线段
|
|
XPoint &start, //[out]xLine线起点的投影点
|
|
XPoint &end, //[out]xLine线终点的投影点
|
|
BOOL bWall //[in]是否是墙线段
|
|
)
|
|
{
|
|
int posS = 0,posE = 0; //face在链表中的位置
|
|
XPoint ptStart(xLine.StartPoint().x,xLine.StartPoint().y,0),
|
|
ptEnd(xLine.EndPoint().x,xLine.EndPoint().y,0);
|
|
BOOL bFindS = FALSE,bFindE = FALSE; //是否找到起始点所在的face
|
|
|
|
//找墙点所在的face
|
|
for(int i = 0; i < lstFace.Length(); i++)
|
|
{
|
|
AcGePoint3d pt;
|
|
XPoly2D polyFace(1);
|
|
|
|
X3DFace face(*lstFace[i]);
|
|
face.MakeBetter();
|
|
|
|
for(int j = 0; j < 3; j++)
|
|
{
|
|
pt = face.GetVertex(j);
|
|
polyFace.AppendNode(pt);
|
|
}
|
|
if (!face.IsTriangle(2))//四边形
|
|
{
|
|
pt = face.GetVertex(3);
|
|
polyFace.AppendNode(pt);
|
|
}
|
|
|
|
polyFace.SetElevation(0.0); //投影到z=0的平面上
|
|
if (!bFindS)
|
|
{
|
|
if ( (ptStart & polyFace) != PR_OUTSIDE)
|
|
{
|
|
posS = i;
|
|
bFindS = TRUE;
|
|
}
|
|
}
|
|
|
|
if (!bFindE)
|
|
{
|
|
if ( (ptEnd & polyFace) != PR_OUTSIDE)
|
|
{
|
|
posE = i;
|
|
bFindE = TRUE;
|
|
}
|
|
}
|
|
if (bFindS && bFindE)
|
|
break;
|
|
}
|
|
|
|
//墙端点上的face面
|
|
if (bFindS)
|
|
{
|
|
X3DFace pFace(*lstFace[posS]);
|
|
pFace.MakeBetter();
|
|
AcGePlane sPlane(AcGePoint3d(pFace.GetVertex(0)),
|
|
AcGePoint3d(pFace.GetVertex(1)),AcGePoint3d(pFace.GetVertex(2)));
|
|
AcGePoint3d tmp = xLine.StartPoint();
|
|
tmp.z += _AS_SYS_UNIT(1000.0);// [11/15/2007 nsh]
|
|
AcGeLine3d sLine(AcGePoint3d(xLine.StartPoint()),tmp);
|
|
sLine.intersectWith(sPlane,start);
|
|
|
|
//modify by xlc on 080303
|
|
if ((!bWall) && (!bFindE))
|
|
{
|
|
end = xLine.EndPoint();
|
|
end.z=start.z;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!bFindE)
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if (bFindE)
|
|
{
|
|
X3DFace pFace(*lstFace[posE]);
|
|
pFace.MakeBetter();
|
|
|
|
AcGePlane ePlane(AcGePoint3d(pFace.GetVertex(0)),
|
|
AcGePoint3d(pFace.GetVertex(1)),AcGePoint3d(pFace.GetVertex(2)));
|
|
|
|
AcGePoint3d tmp = xLine.EndPoint();
|
|
tmp.z +=_AS_SYS_UNIT(1000.0);// [11/15/2007 nsh]
|
|
AcGeLine3d eLine(AcGePoint3d(xLine.EndPoint()),tmp);
|
|
|
|
eLine.intersectWith(ePlane,end);
|
|
|
|
//modify by xlc on 080303
|
|
if ((!bWall) && (!bFindS))
|
|
{
|
|
start = xLine.StartPoint();
|
|
start.z=end.z;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bWall)
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//add by xlc on 070712
|
|
//墙与屋顶的交线
|
|
BOOL GetIntSectPoly(DList<X3DFace> &lstFace, //[in]屋顶面
|
|
XLine xLine, //[in]墙线
|
|
XPoly3D &poly //[out]交线
|
|
)
|
|
{
|
|
GetIntSectPoint(lstFace,xLine,poly); //获得线段平面在face平面上的交点
|
|
|
|
//删除重合点
|
|
int ptNum = poly.Length();
|
|
for(int i = 0; i < ptNum-1; i++)
|
|
{
|
|
for(int j = i+1;j < ptNum;)
|
|
{
|
|
if (*poly[i] == *poly[j])
|
|
{
|
|
poly.RemoveNode(j);
|
|
ptNum--;
|
|
continue;
|
|
}
|
|
j++;
|
|
}
|
|
}
|
|
|
|
//排序
|
|
Array<XPoint> ptArray; //交点
|
|
if (ptNum > 0)
|
|
{
|
|
ptArray.Realloc(ptNum);
|
|
for(long i = 0; i < ptNum; i++)
|
|
{
|
|
ptArray[i] = *poly[i];
|
|
}
|
|
bool bIncrease = true;
|
|
if (fabs(xLine.StartPoint().x - xLine.EndPoint().x) < 1e-6)
|
|
{
|
|
if (xLine.StartPoint().y - xLine.EndPoint().y > 0)
|
|
bIncrease = false;
|
|
}
|
|
else
|
|
{
|
|
if (xLine.StartPoint().x - xLine.EndPoint().x > 0)
|
|
bIncrease = false;
|
|
}
|
|
ptArray.Arrange(bIncrease); //按墙钱起点到终点的顺序排序
|
|
|
|
for(i = 0; i < ptNum; i++)
|
|
{
|
|
*poly[i] = ptArray[i];
|
|
}
|
|
}
|
|
|
|
//求墙线的起点和终点与face的交点
|
|
XPoint start,end;
|
|
if (!GetEndIntSectPoint(lstFace,xLine,start,end))
|
|
return FALSE;
|
|
|
|
//添加墙的端点
|
|
if (poly.Length() > 0)
|
|
{
|
|
if (start != *poly[0])
|
|
{
|
|
poly.InsertNodeAt(0,start);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
poly.InsertNodeAt(0,start);
|
|
}
|
|
|
|
if (end != *poly[poly.Length()-1])
|
|
{
|
|
poly.AppendNode(end);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CDuanSlopeRoofDlg::DestroyWindow()
|
|
{
|
|
m_ctrlPreview.clearAll();
|
|
return CAcUiDialog::DestroyWindow();
|
|
} |