//------------------------------------------------------------------------+
// Copyright (C), 1998-2011, Beijing Tangent Software Co. Ltd.
// = FileName	:   TDbStruBeam类
// = Version	:   ver1.0
// = Author		:   cet
// = CreateDate	:   2011-05-27
// = Description:   梁对象类实现
// = Maintainers: 
//                  
//------------------------------------------------------------------------+

#include "stdafx.h"
#ifdef TASD
#include "TDbStruBeam.h"
#include "TAsdKeyDefine.h"
#include "TBaseWallIntegrateTool.h"
#include "TDbStruFloorSlab.h"
#include "TConfigInfo.h"
#include "TAssocMsgContainer.h"
#include "TDbStruSelfBase.h"

extern void AddMsg(const TAssocMsg& assocMsg);
extern bool g_bModifyAgain;

const Adesk::UInt8 TDbStruBeam::g_nVersion = 1;
ACRX_DXF_DEFINE_MEMBERS(ATSStruBeam, ATSBaseWall, AcDb::kDHL_CURRENT,
						AcDb::kMReleaseCurrent, 1, ATS_STRUBEAM,
						"ATS_STRUBEAM图形无法解析, 请下载上华软件|网址: www.shanghuasoft.com");
IMPLEMENT_TENTBASE(TDbStruBeam);

#define BEAMCOLOR 5	
#define AMBEAMCOLOR 4
#define CPBEAMCOLOR 2
#define TRANBEAMCOLOR 3
#define REDCOLOR 1

static bool AscCompare(TCombForceData& param1, TCombForceData& param2)
{
	if (param1.m_dForce - param2.m_dForce < g_fZero)
	{
		return false;
	}

	return true;
}

TDbStruBeam::TDbStruBeam()
{

} 

TDbStruBeam::~TDbStruBeam()
{

}

Acad::ErrorStatus TDbStruBeam::dwgInFields (AcDbDwgFiler* pFiler)
{
	assertWriteEnabled();
	Acad::ErrorStatus es = TDbBaseWall::dwgInFields(pFiler);
	if (es != Acad::eOk)
	{
		return es;
	}

	Adesk::UInt8  nVer;
	pFiler->readItem(&nVer);
	if(nVer > g_nVersion)			// Version is too new
	{
		return Acad::eMakeMeProxy;
	}
	
	pFiler->readItem(&m_idLayerDim);
	pFiler->readItem(&m_idLayerNum);
	pFiler->readItem(&m_idLayerMark);
	pFiler->readItem(&m_idLayerText);
	pFiler->readItem(&m_idLayerRBar);
	pFiler->readItem(&m_idLayerRBarU);
	pFiler->readItem(&m_idLayerRBarO);
	pFiler->readItem(&m_idLayerRealArea);
	pFiler->readItem(&m_idLayerCalDefl);
	pFiler->readItem(&m_idLayerCalCrk);
	pFiler->readItem(&m_idLayerForce);
	pFiler->readItem(&m_idLayerCalcArea);
	pFiler->readItem(&m_idLayerLoad);
	pFiler->readItem(&m_idLayerLoadL);
	pFiler->readItem(&m_idLayerLoadC);
	pFiler->readItem(&m_idTextStyle);
	pFiler->readItem(&m_idTextStyleRB);

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbStruBeam::dwgOutFields(AcDbDwgFiler* pFiler) const
{
	assertReadEnabled();
	Acad::ErrorStatus es = TDbBaseWall::dwgOutFields(pFiler);
	if (es != Acad::eOk)
	{
		return es;
	}

	pFiler->writeItem(g_nVersion);
	pFiler->writeItem(m_idLayerDim);
	pFiler->writeItem(m_idLayerNum);
	pFiler->writeItem(m_idLayerMark);
	pFiler->writeItem(m_idLayerText);
	pFiler->writeItem(m_idLayerRBar);
	pFiler->writeItem(m_idLayerRBarU);
	pFiler->writeItem(m_idLayerRBarO);
	pFiler->writeItem(m_idLayerRealArea);
	pFiler->writeItem(m_idLayerCalDefl);
	pFiler->writeItem(m_idLayerCalCrk);
	pFiler->writeItem(m_idLayerForce);
	pFiler->writeItem(m_idLayerCalcArea);
	pFiler->writeItem(m_idLayerLoad);
	pFiler->writeItem(m_idLayerLoadL);
	pFiler->writeItem(m_idLayerLoadC);
	pFiler->writeItem(m_idTextStyle);
	pFiler->writeItem(m_idTextStyleRB);

	return pFiler->filerStatus();
}

Acad::ErrorStatus TDbStruBeam::subGetOsnapPoints( AcDb::OsnapMode osnapMode, INT_PTR gsSelectionMark, const AcGePoint3d& pickPoint, const AcGePoint3d& lastPoint, const AcGeMatrix3d& viewXform, AcGePoint3dArray& snapPoints, AcDbIntArray& geomIds ) const
{
	assertReadEnabled();
	return TDbBaseWall::subGetOsnapPoints(osnapMode, gsSelectionMark, pickPoint, lastPoint, viewXform, snapPoints, geomIds);
}

Acad::ErrorStatus TDbStruBeam::subTransformBy( const AcGeMatrix3d& xform )
{
	assertWriteEnabled();
	Acad::ErrorStatus nRet = TDbBaseWall::subTransformBy(xform);
	
	// 拖拽结束时发送消息
	if (objectId() && g_bMonitorDbAction)
	{
		TAssocMsg msg;
		msg.SetMethod(TAssocMsg::kTransform);		
		msg.SetMatrix(xform);
		msg.SetAssocId(objectId());

		AddMsg(msg);
	}
	return nRet;
}

Acad::ErrorStatus TDbStruBeam::subGetGripPoints( AcGePoint3dArray& gripPoints, AcDbIntArray& osnapModes, AcDbIntArray& geomIds ) const
{
	assertReadEnabled();
	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	gripPoints.append(ptS);
	gripPoints.append(ptE);
	
	double dBulge = 0.0;
	GetAt(KEY_BULGE, dBulge);
	TADSGePoint3d ptStart = ptS, ptEnd = ptE, ptMid;
	if (fabs(dBulge) < g_fZero) // 直线
	{
		Midpoint(ptStart, ptE, ptMid);
	}
	else // 弧线
	{
		TGGeArc arc(ptStart, ptEnd, dBulge);
		ptMid = arc.MidPoint();
	}
	gripPoints.append(ptMid);

	return Acad::eOk;
}

Acad::ErrorStatus TDbStruBeam::subGetStretchPoints( AcGePoint3dArray& stretchPoints ) const
{
	assertReadEnabled();

	AcDbIntArray osnapModes;
	AcDbIntArray geomIds;
	return subGetGripPoints(stretchPoints, osnapModes, geomIds);
}

Acad::ErrorStatus TDbStruBeam::subMoveGripPointsAt( const AcDbIntArray& indices, const AcGeVector3d& offset )
{
	if (GetCtrlToggle()) 
	{
		SingleMove(indices, offset); // 单独移动
	} 
	else
	{
		AssociateMove(indices, offset); // 关联移动
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruBeam::subMoveStretchPointsAt( const AcDbIntArray& indices, const AcGeVector3d& offset )
{
	return subMoveGripPointsAt(indices, offset);
}

Acad::ErrorStatus TDbStruBeam::subGetClassID( CLSID* pClsid ) const
{
#if (ADS >= 17)
	assertReadEnabled();
#endif
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruBeam::subDeepClone( AcDbObject* pOwner, AcDbObject*& pClonedObject, AcDbIdMapping& idMap, Adesk::Boolean isPrimary ) const
{
	assertReadEnabled();
	return TDbBaseWall::subDeepClone(pOwner, pClonedObject, idMap, isPrimary);
}

Acad::ErrorStatus TDbStruBeam::subWblockClone( AcRxObject* pOwner, AcDbObject*& pClonedObject, AcDbIdMapping& idMap, Adesk::Boolean isPrimary ) const
{
	assertReadEnabled();
	return TDbBaseWall::subWblockClone(pOwner, pClonedObject, idMap, isPrimary);
}

Acad::ErrorStatus TDbStruBeam::subIntersectWith( const AcDbEntity* ent, AcDb::Intersect intType, AcGePoint3dArray& points, INT_PTR thisGsMarker /*= 0*/, INT_PTR otherGsMarker /*= 0*/ ) const
{
	return TDbBaseWall::subIntersectWith(ent, intType, points, thisGsMarker, otherGsMarker);
}

Acad::ErrorStatus TDbStruBeam::subIntersectWith( const AcDbEntity* ent, AcDb::Intersect intType, const AcGePlane& projPlane, AcGePoint3dArray& points, INT_PTR thisGsMarker /*= 0*/, INT_PTR otherGsMarker /*= 0*/ ) const
{
	return TDbBaseWall::subIntersectWith(ent, intType, projPlane, points, thisGsMarker, otherGsMarker);
}

Acad::ErrorStatus TDbStruBeam::GetGripText( int i, CString &cs ) const
{
	Acad::ErrorStatus es=Acad::eOk;
	bool bArc = true;
	double dBulge = 0.0;
	GetAt(KEY_BULGE, dBulge);
	if (fabs(dBulge) < g_angleZero) // 直线
	{
		;bArc = false;
	}

	if (GetCtrlToggle()) // 单独移动
	{
		switch(i) 
		{
		case 0:
			{	
				cs=_T("改变位置");
				break;
			}
		case 1:
			{
				cs=_T("改变位置");
				break;
			}
		case 2:
			{
				if (bArc)
				{
					cs=_T("改变位置");
				} 
				else
				{
					cs=_T("独立平行移动");
				}
				break;
			}
		default:
			es=Acad::eInvalidInput;
			break;
		}
	} 
	else  // 关联移动
	{
		switch(i) 
		{
		case 0:
			{
				if (bArc)
				{
					cs=_T("沿弧伸缩");
				} 
				else
				{
					cs=_T("沿梁方向拉伸缩短");
				}
				break;
			}
		case 1:
			{
				if (bArc)
				{
					cs=_T("沿弧伸缩");
				} 
				else
				{
					cs=_T("沿梁方向拉伸缩短");
				}
				break;
			}
		case 2:
			{
				if (bArc)
				{
					cs=_T("改变半径");
				} 
				else
				{
					cs=_T("关联平行移动");
				}
				break;
			}
		default:
			es=Acad::eInvalidInput;
			break;
		}
	}
	return es;
}

Acad::ErrorStatus TDbStruBeam::ExplodeOrDraw3d( TGGiExplodeDrawBase &dc ) const
{
	assertReadEnabled();

	if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0)
	{
		AcGiCommonDraw *dcCommon = ((XAcGiViewDraw &)dc).GetCommonDraw();
		if (!dcCommon->context()->isPlotGeneration())
		{
			if(DocGetShowNo()&& DocGetBeamShowNo())
			{
				DrawCellNo(dc);			// 显示单元编号
			}

			if(DocGetShowRG()&& DocGetBeamShowRG())
			{
				DrawRG(dc);				// 显示刚域
			}
		}
	}

	//modify by xlc on 120112荷载显示控制
	//add by wjx on 111219 显示梁荷载
	//if (DocGetShowLoadPara())
  	if((DocGetBeamShowLoad() && g_nLoadDrawMode == BYOBJLOAD)|| g_nLoadDrawMode == BEAMLOAD)
  
  	{
		DrawBeamLoad3D(dc);
  	}

	// 单线绘制样式
	if (!g_bDetailMode)
	{
		TGGeCurveSegment seg;
		GetBaseLine(seg);
		dc << seg;
		return Acad::eOk;
	}
	
	// 双线绘制样式
	AcGePoint3d ptShapeBase;
	if (!GetBasePoint(ptShapeBase))
	{
		return Acad::eInvalidInput; 
	}

	AcGeVector3d vtNormal = AcGeVector3d::kZAxis;
	TGGePoly2D polyShape, polyBase;
	GetSection2d(polyShape); // 截面外轮廓线
	GetPolyBase(polyBase);   // 基线

	TGGePoly2D poly2d(polyBase);
	TDPtrList<TGGePoly2D> lstPolys; 
	TDPtrList<Adesk::UInt8> lstColVis;

	poly2d.SetElevation(0.0);
	{
		TVector3D vtOff = *polyShape[0]-ptShapeBase;
		TGGePoly2D polyNew;
		poly2d.Offset(vtOff.x, polyNew);
		if(polyNew.Length()!=poly2d.Length())
		{
			return Acad::eInvalidInput;
		}
		polyNew.SetElevation(vtOff.y);
		lstPolys.Append(new TGGePoly2D(polyNew));
		lstColVis.Append(new Adesk::UInt8(TRUE));
	}

	for(int i=0; i<polyShape.TotalSegments(); i++) 
	{
		TGGeDirectionCurve cv;
		polyShape.Nth(i, cv);
		if(cv.Is(CURVE_LINE))
		{
			TVector3D vtOff=cv.EndPoint()-ptShapeBase;
			TGGePoly2D polyNew;
			poly2d.Offset(vtOff.x, polyNew);
			if(polyNew.Length()!=poly2d.Length())
			{
				return Acad::eInvalidInput;
			}
			polyNew.SetElevation(vtOff.y);
			lstPolys.Append(new TGGePoly2D(polyNew));
			lstColVis.Append(new Adesk::UInt8(TRUE));
		}
		else 
		{
			double intAng=cv.GetBulge();
			int nDiv=30;
			if(cv.Is(CURVE_ARC))
			{
				nDiv=GetCirDivNum(cv.GetArc().GetRadius(), _AS_SYS_UNIT(g_nCirDeviation));
			}

			int nStep=AS_INT(fabs(intAng)/PI/2.0*nDiv);  // how much section
			double dDistStep=cv.GetLength()/nStep;
			for(int j=0; j<nStep; j++) 
			{
				TADSGePointDir2d ptE;
				cv.Polar(dDistStep*(j+1), ptE);
				TVector3D vtOff=(TADSGePoint3d &)ptE - ptShapeBase;
				TGGePoly2D polyNew;
				poly2d.Offset(vtOff.x, polyNew);
				if(polyNew.Length()!=poly2d.Length())
				{
					return Acad::eInvalidInput;
				}
				polyNew.SetElevation(vtOff.y);
				lstPolys.Append(new TGGePoly2D(polyNew));
				lstColVis.Append(new Adesk::UInt8(j==nStep-1));
			}
		}
	}

	int nVertex=polyBase.Length();
	for(i=0; i<lstPolys.Length(); i++)
	{
		TGGePoly2D &rPoly=*lstPolys[i];
		for(int j=0; j<nVertex; j++) 
		{
			rPoly[j]->z += polyBase[j]->z;
		}
	}


	int nTotalSeg=polyBase.TotalSegments();
	for(int n=0; n<nTotalSeg; n++) 
	{
		TDPtrList<TGGeDirectionCurve> lstCurves;
		for(int j=0; j<lstPolys.Length(); j++) 
		{
			TGGeDirectionCurve *pCurve=new TGGeDirectionCurve;
			lstPolys[j]->Nth(n, *pCurve);
			lstCurves.Append(pCurve);
		}

		TGGeDirectionCurve mSeg;
		poly2d.Nth(n, mSeg);

		int nDiv=30;
		if(mSeg.Is(CURVE_ARC))
		{
			nDiv=GetCirDivNum(mSeg.GetArc().GetRadius(), _AS_SYS_UNIT(g_nCirDeviation));
		}
		int nStep=AS_INT(fabs(mSeg.GetBulge())/PI/2.0*nDiv);  // how much section
		if(nStep<=0) nStep=1;
		int nCol=lstCurves.Length();
		int nRow=nStep+1;
		TADSGePoint3d *ptArray=new TADSGePoint3d[nCol*nRow];
		for(int col=0; col<nCol; col++) 
		{
			TGGeDirectionCurve &segThis=*lstCurves[col];
			TGGeDirectionCurve seg2d=segThis;
			seg2d.SetElevation(segThis.StartPoint().z);
			double nElevStep=(segThis.EndPoint().z - segThis.StartPoint().z)/nStep;
			double nDistStep=seg2d.GetLength()/nStep;

			for(int row=0; row<nRow; row++) 
			{
				TADSGePointDir2d ptDir2d;
				seg2d.Polar(nDistStep*row, ptDir2d);
				ptDir2d.z += nElevStep*row;
				ptArray[row*nCol+col]=ptDir2d;
			}
		}

		// 设置边的可见性
		int nEdgeNum=nRow*(nCol-1)+nCol*(nRow-1);
		Adesk::UInt8 *pVisArray=new Adesk::UInt8[nEdgeNum];
		for(int k=0; k<nEdgeNum; k++)
		{
			pVisArray[k]=kAcGiVisible;
		}

		for(k=1; k<nRow-1; k++)		//除首末行外,其余各行的边均不可见
		{
			for(int j=0; j<nCol-1; j++)
			{
				pVisArray[k*(nCol-1)+j] = kAcGiInvisible;
			}
		}

		int nIndexBase=nRow*(nCol-1);
		for(col=0; col<nCol; col++) 
		{
			Adesk::UInt8 bVis=*lstColVis[col];
			for(int row=0; row<nRow-1; row++) 
			{
				pVisArray[nIndexBase+col*(nRow-1)+row]=bVis;
			}
		}

		int nVertexNum=nCol*nRow;
		for(k=0; k<nVertexNum; k++)
		{
			ptArray[k]=Ecs2Wcs(ptArray[k], vtNormal);
		}

		AcGiEdgeData edgeInfo;
		edgeInfo.setVisibility(pVisArray);
		dc.DrawMesh(nRow, nCol, (AcGePoint3d *)ptArray, &edgeInfo);

		if(n==0 && !poly2d.IsClosed() && polyShape.IsClosed()) 
		{
			TGGePoly2D polyTemp1(1);
			for(col=0; col<nCol-1; col++)
			{
				polyTemp1.AppendNode(ptArray[col]);
			}
			dc.DrawShell(polyTemp1, TDPtrList<TGGePoly2D>());
		}
		if(n==nTotalSeg-1 && !poly2d.IsClosed() && polyShape.IsClosed())
		{
			TGGePoly2D polyTemp2(1);
			for(col=0; col<nCol-1; col++)
			{
				polyTemp2.AppendNode(ptArray[(nRow-1)*nCol+col]);
			}
			dc.DrawShell(polyTemp2, TDPtrList<TGGePoly2D>());
		}

		delete []pVisArray;
		delete []ptArray;
	}

	return Acad::eOk;
}

Acad::ErrorStatus TDbStruBeam::ExplodeOrDraw2d( TGGiExplodeDrawBase &dc ) const
{
	assertReadEnabled();

	// modify by wjx on 111230 由于绘制简图时不需要绘制双线图
	if(g_bDetailMode)
	{	
		AcDbObjectId idOwner = ownerId();

		int nMatTyp = MAT_CONCRETE;
		GetAt(KEY_MATTYP, nMatTyp);

		BOOL bHatch = FALSE;					//是否填充
		BOOL bThick = FALSE;					//是否加粗
		CString sHatchType = _T("SOLID");		//填充样式
		switch (nMatTyp)
		{
		case MAT_CONCRETE:						//混凝土梁
			bHatch = DocGetConBeamHatch();
			bThick = DocGetConBeamThick();
			sHatchType = DocGetConBeamHPatte();
			break;
		case MAT_STEEL:							//钢梁
			bHatch = DocGetStlBeamHatch();
			bThick = DocGetStlBeamThick();
			sHatchType = DocGetStlBeamHPatte();
			break;
		}

		//梁不填充
		// 填充
		int nHatchType = 0;
		GetAt(KEY_HATCH, nHatchType);
		if(nHatchType == 0 && DocGetIsSolidFill() && bHatch
			|| nHatchType == 1)
		{
			TGGePoly2D poly;
			GetPoly2dBehindIntegrate(poly); // 端点融合后生成的闭合poly2d
			if (poly.HasArcSegment())
			{
				TGGePoly2D poly2;
				poly.Disperse(poly2);
				poly.Reset();
				poly = poly2;
			}
			poly.SetElevation(0.0);

			// 添加填充裁剪线
			std::vector<TGGePoly2D> vecPoly;
			GetClipedPoly2d(vecPoly);
			int nNum = 0;
			std::vector<TGGePoly2D>::iterator it;
			for (it = vecPoly.begin(); it != vecPoly.end(); it++)
			{
				++nNum;
				it->SetElevation(0.0);
				dc.PushClip(*it);
			}

			if (_tcsicmp(sHatchType, _T("SOLID")) == 0) 
			{
				dc << TGGeSolid(poly);
			}
			else
			{
				dc << TGGeHatch(poly, sHatchType, GetPScale());
			}

			// 删除填充裁剪线
			while(nNum > 0)
			{
				--nNum;
				dc.PopClip();
			}
		}

		int i = 0;
		long iClipCount = 0;		//独基裁剪边界计数
		TGGePoly2D poly;			//独基边界
		for (i = 0; i < m_arAssocZIds.length(); i++)
		{
			OPENOBJ_BEGIN(m_arAssocZIds[i], AcDb::kForRead, TDbStruSelfBase, pEnt);
			if (pEnt)
			{
				poly = pEnt->GetOutline();
				poly.SetElevation(0);

				dc.PushClip(poly);
				iClipCount++;
			}
			OPENOBJ_END();
		}

		// 加粗
		if (DocGetIsLineWeight() && bThick) 
		{
			DrawWeightLine2d(dc);
		}

		// 双线绘制样式
		TBaseWallLine bwlThis;
		GetThisBaseWallLine(bwlThis);

		// 梁与柱融合
		TDbColumn *pStruColumn = NULL;
		for (i = 0; i < m_arColumnIds.length(); i++)
		{
			acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
			if (pStruColumn != NULL)
			{
				TGGePoly2D poly2d;
				pStruColumn->GetOutline(poly2d);
				pStruColumn->Close();
				poly2d.SetElevation(0.0);
				TBaseWallIntegrateTool::Integrate(bwlThis, poly2d);
			}
		}

		// 梁与梁融合
		TDPtrList<TBaseWallLine> arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE;
		GetAssocBaseWallLine(arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE);
		// 起点融合
		TBaseWallIntegrateTool::IntegrateAtTail(true, bwlThis, arBaseWallLinesS);
		// 终点融合
		TBaseWallIntegrateTool::IntegrateAtTail(false, bwlThis, arBaseWallLinesE);
		// 梁内融合
		for (i = 0; i < arBaseWallLinesM.Length(); i++)
		{
			TBaseWallIntegrateTool::Integrate(bwlThis,*arBaseWallLinesM[i]);
		}

 		// 绘制边线
 		TGGeVisibilityPoly2D left, right; 
 		left = bwlThis.GetLeftLine();
 		right = bwlThis.GetRightLine();
 		AcDbObjectIdArray idArr;
 		GetCoverSlab(idArr);
 		if (idArr.length() > 0) // 有板
 		{
 			DrawBeamLine2dForCoverSlab(dc, left);
 			DrawBeamLine2dForCoverSlab(dc, right);
 		}
 		else
 		{
 			DrawBaseWall2d(dc, left, true);
 			DrawBaseWall2d(dc, right, false);
 		}
 
 		// 处理端点封口
 		bool bLinkColumn = IsLinkColumn(true);
 		int nLen = arBaseWallLinesS.Length();
 		if (bLinkColumn && nLen == 0) // 起始端只连着柱子
 		{
 			DrawSideLine2d(true, dc);
 		}
 		else if (!bLinkColumn && nLen == 0) // 起始端未连接梁和柱子
 		{
 			if (!(left.GetVisibleAt(0) == AcDb::kInvisible && right.GetVisibleAt(0) == AcDb::kInvisible))
 			{
 				dc << TGGeLine(*left[0], *right[0]);
 			}
 		}
 		else if (!bLinkColumn && nLen == 1) // 起始端只连接着一根梁
 		{
 			AcDbObjectId id;
 			GetWallId(true, id);
 			DrawSideLine2d(true, id, bwlThis, dc);
 		}
 
 		bLinkColumn = IsLinkColumn(false);
 		nLen = arBaseWallLinesE.Length();
 		if (bLinkColumn && nLen == 0) // 终止端只连着柱子
 		{
 			DrawSideLine2d(false, dc);
 		}
 		else if (!bLinkColumn && nLen == 0) // 终止端未连接梁和柱子
 		{
 			if (!(left.GetVisibleAt(left.Length() - 2) == AcDb::kInvisible && right.GetVisibleAt(right.Length() - 2) == AcDb::kInvisible))
 			{
 				dc << TGGeLine(*left[left.Length() - 1], *right[right.Length() - 1]);
 			}
 		}
 		else if (!bLinkColumn && nLen == 1) // 终止端只连接着一根梁
 		{
 			AcDbObjectId id;
 			GetWallId(false, id);
 			DrawSideLine2d(false, id, bwlThis, dc);
 		}

		while (iClipCount > 0)
		{
			dc.PopClip();
			iClipCount--;
		}
 	}
 	else									// 绘制简图
 	{
		DrawStruBeam(dc);
 	}

	// 显示梁尺寸
	if (_tcscmp(dc.Desc(), XAcGiViewDraw::Descriptor())==0)
	{
		AcGiCommonDraw *dcCommon = ((XAcGiViewDraw &)dc).GetCommonDraw();
		if (!dcCommon->context()->isPlotGeneration())
		{
			if(DocGetShowBH() && DocGetBeamShowBH())
			{
				DrawBH(dc);		
			}
		}
	}

	// 显示构件编号
	if(DocGetBeamShowCL())
	{
		DrawClab(dc);			
	}

	// add by xlc on 120112荷载显示控制
	// 显示梁荷载信息
 	//if(DocGetShowLoadPara())
  	if((DocGetBeamShowLoad() && g_nLoadDrawMode == BYOBJLOAD)|| g_nLoadDrawMode == BEAMLOAD)
   	{
		DrawBeamLoad(dc);
   	}

	if(g_nGraph == FORCE_M)
	{
		DrawMGraph(dc);
	}
	else if(g_nGraph == FORCE_S)
	{
		DrawSGraph(dc);
	}

	//显示配筋面积,配筋率
	DrawReinGragh(dc);
	
	if (g_bShowCrack)
	{//显示裂缝图
		DrawCrackGraph(dc);
	}

	if (g_bShowDef)
	{//显示挠度图
		DrawDeflectGraph(dc);
	}
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruBeam::GetExtents2d( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
{
	TGGePoly2D poly2d;
	GetPoly2D(poly2d); 
	poly2d.GetExtend(ptLow, ptUp);
	ptLow.z = 0.0;
	ptUp.z = 0.0;
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruBeam::GetExtents( TADSGePoint3d &ptLow, TADSGePoint3d &ptUp ) const
{
	GetExtents2d(ptLow, ptUp);
	AcGePoint3d ptS,ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);

	double dH = 0.0; // 总高
	GetTotalHeight(dH);
	ptLow.z = ptS.z > ptE.z ? ptE.z - dH : ptS.z - dH;
	ptUp.z = ptS.z > ptE.z ? ptS.z : ptE.z;
	return Acad::eOk;
}

void TDbStruBeam::GetTips( TDPtrList<TObjInfoUnit> &lstInfo ) const
{

}

const TCHAR * TDbStruBeam::GetDefaultLayer() const
{
	return LAY_S_BEAM_PLAN_LINE;
}

BOOL TDbStruBeam::IsValid() const
{
	assertReadEnabled();
	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	double dWidth = 0.0;
	GetAt(KEY_SUMB, dWidth);
	
	if (fabs(ptS.z - ptE.z) < _DIST_SNAP && dWidth > 0)
	{
		return true;
	}
	
	return false;
}

int TDbStruBeam::GetCtrlToggleIndex() const
{
	return 9;
}

void TDbStruBeam::CopyPropertiesFrom( AcDbEntity *pSrcEntity, unsigned gMatchFlag )
{
	assertWriteEnabled();
	TDbBaseWall::CopyPropertiesFrom(pSrcEntity, gMatchFlag);
	TDbStruBeam *pBeam = TDbStruBeam::cast(pSrcEntity);
	if(pBeam != NULL)
	{
		CopyData(pBeam);

		if(database() == NULL ||
			pSrcEntity->database() == NULL ||
			database() == pSrcEntity->database())
		{
			m_idLayerDim = pBeam->m_idLayerDim;
			m_idLayerNum = pBeam->m_idLayerNum;
			m_idLayerMark = pBeam->m_idLayerMark;
			m_idLayerText = pBeam->m_idLayerText;
			m_idLayerRBar = pBeam->m_idLayerRBar;
			m_idLayerRBarU = pBeam->m_idLayerRBarU;
			m_idLayerRBarO = pBeam->m_idLayerRBarO;
			m_idLayerRealArea = pBeam->m_idLayerRealArea;
			m_idLayerCalDefl = pBeam->m_idLayerCalDefl;
			m_idLayerCalCrk = pBeam->m_idLayerCalCrk;
			m_idLayerForce = pBeam->m_idLayerForce;
			m_idLayerCalcArea = pBeam->m_idLayerCalcArea;
			m_idLayerLoad = pBeam->m_idLayerLoad;
			m_idLayerLoadL = pBeam->m_idLayerLoadL;
			m_idLayerLoadC = pBeam->m_idLayerLoadC;
			m_idTextStyle = pBeam->m_idTextStyle;
			m_idTextStyleRB = pBeam->m_idTextStyleRB;
		}
	}
}

TEntityBase::DrawType TDbStruBeam::GetDrawType() const
{
	assertReadEnabled();
	return TEntityBase::k2Dand3D;
}

bool TDbStruBeam::GetStandardFaceBody( AcDbVoidPtrArray& arFacePtrs ) const
{
	return true;
}

bool TDbStruBeam::GetSafeProtectedSpace( AcDbVoidPtrArray& arFacePtrs ) const
{
	return true;
}

bool TDbStruBeam::GetSection( const AcDbFace &face, const AcGeVector3d& vtPlaneSecDir, std::vector<TObjSectionRecord> &sectionRecords, AcDbVoidPtrArray& arFillPtrs ) const
{
	return true;
}

CString TDbStruBeam::GetXml(const AcGeMatrix3d& mat) const
{
	TXmlTree xmlTree;
	POSITION posRoot = xmlTree.Insert(_T("ATS_STRUBEAM"), NULL, NULL);
	{
		xmlTree.SetAttribute(posRoot, _T("name"), _T("梁"));
		xmlTree.SetAttribute(posRoot, _T("comment"), _T("上华对象名称"));		
	}

	CString strText;
	POSITION posItem1 = xmlTree.Insert(_T("Object_ID"), posRoot, NULL);
	{
		xmlTree.SetAttribute(posItem1, _T("name"), _T("对象编号"));
		xmlTree.SetAttribute(posItem1, _T("comment"), _T("当前对象的句柄"));
		strText.Format(_T("%ld"), objectId());
		xmlTree.SetItemText(posItem1, strText);
	}

	POSITION posItem = NULL;
	POSITION posItem2 = xmlTree.Insert(_T("Link_Beam"),posRoot, posItem1);
	{ 
		xmlTree.SetAttribute(posItem2, _T("name"), _T("连接梁"));

		for (int i = 0; i < m_arAssocBWallIds.length(); i++)
		{
			posItem = xmlTree.Insert(_T("Link_ID"), posItem2, posItem);
			xmlTree.SetAttribute(posItem, _T("name"), _T("梁句柄"));
			strText.Format(_T("%ld"), m_arAssocBWallIds[i]);
			xmlTree.SetItemText(posItem, strText);
		}
	}

	POSITION posItem3 = xmlTree.Insert(_T("Link_Colu"),posRoot, posItem2);
	{ 
		xmlTree.SetAttribute(posItem3, _T("name"), _T("连接柱"));

		for (int i = 0; i < m_arColumnIds.length(); i++)
		{
			posItem = xmlTree.Insert(_T("Link_ID"), posItem3, posItem);
			xmlTree.SetAttribute(posItem, _T("name"), _T("柱句柄"));
			strText.Format(_T("%ld"), m_arColumnIds[i]);
			xmlTree.SetItemText(posItem, strText);
		}
	}
	AcGePoint3d pts,pte;
	double dBulge;
	POSITION posItem4 = xmlTree.Insert(_T("Baseline"), posRoot, posItem3);
	{
		xmlTree.SetAttribute(posItem4, _T("name"), _T("基线参数"));
		
		GetAt(KEY_START, pts);
		GetAt(KEY_END, pte);
		GetAt(KEY_BULGE, dBulge);

		posItem = NULL;
		posItem = xmlTree.Insert(_T("Start_point"), posItem4, posItem);
		{			
			TADSGePoint3d ptTransformBy = pts;
			ptTransformBy.TransformBy(mat);

			xmlTree.SetAttribute(posItem, _T("name"), _T("起始点"));		
			strText.Format(_T("%f,%f,%f"), ptTransformBy.x, ptTransformBy.y, ptTransformBy.z);
			xmlTree.SetItemText(posItem, strText);
		}

		posItem = xmlTree.Insert(_T("End_point"), posItem4, posItem);
		{
			TADSGePoint3d ptTransformBy = pte;
			ptTransformBy.TransformBy(mat);

			xmlTree.SetAttribute(posItem, _T("name"), _T("结束点"));
			strText.Format(_T("%f,%f,%f"), ptTransformBy.x, ptTransformBy.y, ptTransformBy.z);
			xmlTree.SetItemText(posItem, strText);
		}

		posItem = xmlTree.Insert(_T("Central_ang"), posItem4, posItem);
		{
			xmlTree.SetAttribute(posItem, _T("name"), _T("圆心角"));
			strText.Format(_T("%f"), dBulge);
			xmlTree.SetItemText(posItem, strText);
		}
	}

	int nVal;
	POSITION posItem5 = xmlTree.Insert(_T("Material"), posRoot, posItem4);
	{
		xmlTree.SetAttribute(posItem5, _T("name"), _T("梁材料"));
		xmlTree.SetAttribute(posItem5, _T("comment"), _T("梁使用的材料"));
		
		CString strText;
		GetAt(KEY_MATTYP, nVal);
		switch(nVal)
		{
		case MAT_CONCRETE:
			strText = _T("混凝土");
			break;
		case MAT_STEEL:
			strText = _T("钢材");
			break;
		default:
			;
		}
		xmlTree.SetItemText(posItem5, strText);
	}
	POSITION posItem6 = xmlTree.Insert(_T("Height"), posRoot, posItem5);
	{
		xmlTree.SetAttribute(posItem6, _T("name"), _T("高度参数"));

		posItem = NULL;
		posItem = xmlTree.Insert(_T("Top_height"), posItem6, posItem);
		{
			xmlTree.SetAttribute(posItem, _T("name"), _T("顶标高"));
			xmlTree.SetAttribute(posItem, _T("comment"), _T("梁顶的相对标高"));
			strText.Format(_T("%f"), pts.z);
			xmlTree.SetItemText(posItem, strText);
		}
	}

	POSITION posItem7 = xmlTree.Insert(_T("AxisAngle"), posRoot, posItem6);
	{
		xmlTree.SetAttribute(posItem7, _T("name"), _T("轴转角"));

		double dAngle(0);
		GetAt(KEY_AXANG,dAngle);
		strText.Format(_T("%f"), dAngle);
		xmlTree.SetItemText(posItem7, strText);
	}

	POSITION posItem8 = xmlTree.Insert(_T("Property"), posRoot, posItem7);
	{
		xmlTree.SetAttribute(posItem8, _T("name"), _T("截面特性"));
		xmlTree.SetAttribute(posItem8, _T("comment"), _T("截面特性"));

		POSITION posItem9 = NULL;
		nVal = 0;
		GetAt(KEY_SECTYP, nVal);

		double dB = 0.0, dH = 0.0, dU = 0.0, dT = 0.0, dD = 0.0, dF = 0.0, dAngle = 0.0;
		switch(nVal)
		{
		case ST_RECT:
			{
				GetAt(KEY_B, dB);
				GetAt(KEY_H, dH);
				xmlTree.SetItemText(posItem8, _T("矩形"));
				posItem9 = xmlTree.Insert(_T("Rect"), posItem8, NULL);
				{
					xmlTree.SetAttribute(posItem9, _T("name"), _T("矩形参数"));
					xmlTree.SetAttribute(posItem9, _T("comment"), _T("用于矩形梁"));

					posItem = xmlTree.Insert(_T("Width"), posItem9, NULL);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("截面宽度"));
						strText.Format(_T("%f"), dB);
						xmlTree.SetItemText(posItem, strText);
					}
					posItem = xmlTree.Insert(_T("Width"), posItem9, posItem);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("截面高度"));
						strText.Format(_T("%f"), dH);
						xmlTree.SetItemText(posItem, strText);
					}
				}
			}
			break;
		case ST_IBEAM:
			{
				GetAt(KEY_B,dB);
				GetAt(KEY_H,dH);
				GetAt(KEY_U,dU);
				GetAt(KEY_T,dT);
				GetAt(KEY_D,dD);
				GetAt(KEY_F,dF);
				xmlTree.SetItemText(posItem8, _T("工字形"));
				posItem9 = xmlTree.Insert(_T("IBeam"), posItem8, NULL);
				{
					xmlTree.SetAttribute(posItem9, _T("name"), _T("工字形参数"));
					xmlTree.SetAttribute(posItem9, _T("comment"), _T("用于工字形梁"));

					posItem = xmlTree.Insert(_T("B"), posItem9, NULL);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("腹板厚度"));
						strText.Format(_T("%f"), dB);
						xmlTree.SetItemText(posItem, strText);
					}
					posItem = xmlTree.Insert(_T("H"), posItem9, posItem);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("截面总高度"));
						strText.Format(_T("%f"), dH);
						xmlTree.SetItemText(posItem, strText);
					}
					posItem = xmlTree.Insert(_T("U"), posItem9, posItem);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("上翼缘宽度"));
						strText.Format(_T("%f"), dU);
						xmlTree.SetItemText(posItem, strText);
					}
					posItem = xmlTree.Insert(_T("T"), posItem9, posItem);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("上翼缘厚度"));
						strText.Format(_T("%f"), dT);
						xmlTree.SetItemText(posItem, strText);
					}
					posItem = xmlTree.Insert(_T("D"), posItem9, posItem);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("下翼缘宽度"));
						strText.Format(_T("%f"), dD);
						xmlTree.SetItemText(posItem, strText);
					}
					posItem = xmlTree.Insert(_T("F"), posItem9, posItem);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("下翼缘厚度"));
						strText.Format(_T("%f"), dF);
						xmlTree.SetItemText(posItem, strText);
					}
				}
			}
			break;
		case ST_CIRCLE:
			{
				GetAt(KEY_B, dB);
				xmlTree.SetItemText(posItem8, _T("圆形"));
				posItem9 = xmlTree.Insert(_T("Circle"), posItem8, NULL);
				{
					xmlTree.SetAttribute(posItem9, _T("name"), _T("圆形参数"));
					xmlTree.SetAttribute(posItem9, _T("comment"), _T("用于圆形梁"));

					posItem = xmlTree.Insert(_T("Diameter"), posItem9, NULL);
					{
						xmlTree.SetAttribute(posItem, _T("name"), _T("截面直径"));
						strText.Format(_T("%f"), dB);
						xmlTree.SetItemText(posItem, strText);
					}
				}
			}
			break;
		default:
			break;
		}
	}

	CString strBase = TEntityBase::GetXml(mat);
	CString strXml = xmlTree.GetXml();
	int nIndex = strXml.Find(_T("<Object_ID"));
	strXml.Insert(nIndex, strBase);

	return strXml;
}

void TDbStruBeam::PostAssocMsg( TAssocMsg assocMsg ) const
{

}

void TDbStruBeam::ReceiveAssocMsg( TAssocMsg assocMsg )
{
	assertWriteEnabled();
	
	TDbBaseWall::ReceiveAssocMsg(assocMsg);
}

void TDbStruBeam::MakeAssocRelation( AcDbObjectIdArray& ids )
{
	assertWriteEnabled();
	TPickEntSet ss(SS_FREE);
	ads_name eName;
	for (int i = 0; i < ids.length(); i++)
	{
		if (acdbGetAdsName(eName, ids[i]) == Acad::eOk)
		{
			ss += ids[i];
		}
	}

	TEntitySet ent;
#ifdef TESTCASE
	//简单方式手动建立关联
	for (long j = 0; j < ss.Length(); j++)
	{
		ent = ss[j];
		if (ent.Is(_T("ATS_STRUBEAM"))) // 梁
		{
			if (!m_arAssocBWallIds.contains(ids[j])) 
			{
				m_arAssocBWallIds.append(ids[j]);
			}
		}
		else if (ent.Is(_T("ATS_COLUMN"))) // 柱子
		{
			if (!m_arColumnIds.contains(ids[j]))
			{
				m_arColumnIds.append(ids[j]);
			}
		}
		else if (ent.Is(_T("ATS_STRU_FLOORSLAB"))) // 板
		{
			if (!m_arSlabIds.contains(ids[j]))
			{
				m_arSlabIds.append(ids[j]);
			}
		}
	}
	return;
#endif

	TGGePoly2D poly;					//梁闭合平面
	GetPoly2D(poly);

	double dWidth = 0;					//梁平面宽
	GetTotalWidth(dWidth);
	
	TGGeCurveSegment cvCL = GetCenterLine();
	cvCL.SetLineFlag(LS_INFINITE);

	double dElevS = cvCL.StartPoint().z;
	double dElevE = cvCL.EndPoint().z;
	bool bModFlg = false;				//记录梁的中心线是否调整
	double dGap(0);
	AcDbObjectId idObj = AcDbObjectId::kNull;

	for (long j = 0; j < ss.Length(); j++)
	{
		ent = ss[j];
		OPENOBJ_BEGIN(ent, AcDb::kForRead, AcDbEntity, pEnt);
		if (pEnt)
		{
			CString sss = pEnt->isA()->name();
		}
		OPENOBJ_END();
		if (ent.Is(_T("ATS_STRUBEAM"))) // 梁
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbStruBeam, pEnt);
			if (!pEnt)
			{
				continue;
			}
			
			TGGePoly2D polyDest;
			pEnt->GetPoly2D(polyDest);

			double dWidthDest(0);
			pEnt->GetTotalWidth(dWidthDest);

			bool bRet = TBaseWallIntegrateTool::GetMinGap(poly, polyDest, dGap);
			//间隙小于梁宽一半时，当作关联处理
			if(bRet && (dGap < dWidth*0.5 || dGap < dWidthDest*0.5))
			{
				if (cvCL.Is(CURVE_LINE))
				{
					//建立关联时对梁的中心线进行校验，相交
					TGGeCurveSegment cvCLDest = pEnt->GetCenterLine();
					cvCLDest.SetLineFlag(LS_INFINITE);

					TADSGePoint3d ptInter1,ptInter2;
					int nNum = cvCL.Intersection(cvCLDest,ptInter1,ptInter2);
					if (nNum == 0)			//没有交点，直接建立关联
					{
						
					}
					else
					{
						//两个交点时取离cvCL中点近的
						if (nNum == 2)
						{
							TADSGePoint3d ptMid = cvCL.MidPoint();
							ptInter1 = TGGeLine(ptInter1, ptInter2).NearPoint(ptMid);
						}

						int nHitFlag = cvCL.HitTest2d(ptInter1);
						bool bModBreak = false;
						if (nHitFlag == 6)			//起始侧延长线
						{
							bModFlg = true;
							bModBreak = true;
							cvCL.SetStartPoint(ptInter1);
						}
						else if (nHitFlag == 7)		//终止侧延长线
						{
							bModFlg = true;
							bModBreak = true;
							cvCL.SetEndPoint(ptInter1);
						}

						//add by xlc on 120417 梁柱自动打断
						if (g_bAutoBreak)
						{
							if (bModBreak)
							{
								Acad::ErrorStatus es = upgradeOpen();
								if ((es == Acad::eOk || es == Acad::eWasOpenForWrite))
								{
									AcGePoint3d pt = cvCL.StartPoint();
									pt.z = dElevS;
									SetAt(KEY_START, pt);

									pt = cvCL.EndPoint();
									pt.z = dElevE;
									SetAt(KEY_END, pt);
									if (es == Acad::eOk)
									{
										downgradeOpen();
									}
								}
							}

							bool bBreak = false;
							if(nHitFlag == 5)			//交点在线内时对自己进行打断
							{
								if(BreakAt(ptInter1,NULL))
								{
									bModFlg = false;
									bBreak = true;
								}
							}

							bool bModifyOld = g_bModifyAgain;
							pEnt->BreakAt(ptInter1, NULL);
							g_bModifyAgain = bModifyOld;
							if(bBreak)
							{
								break;
							}

						}
						
					}
				}

				idObj = pEnt->objectId();
			}
			else
			{
				continue;
			}
			OPENOBJ_END();	

			if (!m_arAssocBWallIds.contains(idObj)) 
			{
				m_arAssocBWallIds.append(idObj);
			}
		}
		else if (ent.Is(_T("ATS_COLUMN"))) // 柱子
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbColumn, pEnt);
			if (!pEnt)
			{
				continue;
			}

			TGGePoly2D polyDest;
			pEnt->GetOutline(polyDest);
			polyDest.SetElevation(0);
			
			bool bRet = TBaseWallIntegrateTool::GetMinGap(poly,polyDest,dGap);
			//间隙小于梁宽一半时，当作关联处理
			if (bRet && dGap < dWidth*0.5)
			{
				if (g_bAutoBreak)
				{
					AcGePoint3d pt = pEnt->GetLocation();

					BreakAt(TADSGePoint3d(pt), &polyDest);
				}
				idObj = pEnt->objectId();
			}
			else
			{
				continue;
			}
			OPENOBJ_END();

			if (!m_arColumnIds.contains(idObj))
			{
				m_arColumnIds.append(idObj);
			}
		}
		else if (ent.Is(_T("ATS_STRU_FLOORSLAB"))) // 板
		{
			OPENOBJ_BEGIN(ent, AcDb::kForRead, TDbStruFloorSlab, pEnt);
			if (!pEnt)
			{
				continue;
			}

			TGGePoly2D polyDest;
			pEnt->GetOutline(polyDest);
			polyDest.SetElevation(0);

			// 判断间隙
			bool bRet = TBaseWallIntegrateTool::GetMinGap(poly,polyDest,dGap);
			if (bRet && dGap < _DIST_SNAP)
			{
				idObj = pEnt->objectId();
			}
			else
			{
				continue;
			}
			OPENOBJ_END();

			if (!m_arSlabIds.contains(idObj))
			{
				m_arSlabIds.append(idObj);
			}
		}
	}

	// 修改梁的端点
	if (bModFlg)
	{
		Acad::ErrorStatus es = upgradeOpen();
		if ((es == Acad::eOk || es == Acad::eWasOpenForWrite))
		{
			AcGePoint3d pt = cvCL.StartPoint();
			pt.z = dElevS;
			SetAt(KEY_START, pt);

			pt = cvCL.EndPoint();
			pt.z = dElevE;
			SetAt(KEY_END, pt);

			if (es == Acad::eOk)
			{
				downgradeOpen();
			}
		}
	}
}

void TDbStruBeam::RemoveAssocRelation( AcDbObjectId& id )
{
	m_arAssocBWallIds.remove(id);
	m_arColumnIds.remove(id);
	m_arSlabIds.remove(id);
}

void TDbStruBeam::GetThisBaseWallLine( TBaseWallLine& baseWall ) const
{
	assertReadEnabled();
	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	ptS.z = 0.0;
	ptE.z = 0.0;
	double dBulge = 0.0, dWidth = 0.0;
	GetAt(KEY_BULGE, dBulge);
	
	GetTotalWidth(dWidth);
	
	TGGeVisibilityPoly2D left;		// 左线
	TGGeVisibilityPoly2D right;		// 右线
	
	if (fabs(dBulge) < g_angleZero) // 直线
	{
		// 偏移向量
		AcGeVector3d vt = ptE - ptS;
		vt.normalize();
		vt.rotateBy(PI/2, AcGeVector3d::kZAxis);
		
		// 墙线1
		ptS += vt * dWidth * 0.5;
		ptE += vt * dWidth * 0.5;
		left.AppendNode(ptS);
		left.AppendNode(ptE);
		
		// 墙线2
		ptS -= vt * dWidth;
		ptE -= vt * dWidth;
		right.AppendNode(ptS);
		right.AppendNode(ptE);	
	}
	else // 弧线
	{
		TADSGePoint3d ptStart = ptS, ptEnd = ptE;
		// 创建新弧取圆心
		TGGeArc arc(ptStart, ptEnd, dBulge);
		AcGePoint3d ptCenter = arc.GetCenterPt();
		// 创建偏移向量
		AcGeVector3d vt1 = ptStart - ptCenter, vt2 = ptEnd - ptCenter;
		vt1.normalize();
		vt2.normalize();
		vt1 *= dWidth * 0.5;
		vt2 *= dWidth * 0.5;
		//  创建弧梁
		ptS = ptStart + vt1;
		ptE = ptEnd + vt2;
		right.AppendNode(ptS,dBulge);
		right.AppendNode(ptE);
		
		ptS = ptStart - vt1;
		ptE = ptEnd - vt2;
		left.AppendNode(ptS,dBulge);
		left.AppendNode(ptE);
	}
	
	int nWeight = 0;
	GetAt(KEY_WEIGHT, nWeight);
	baseWall.SetLeftLine(left);
	baseWall.SetRightLine(right);
	baseWall.SetWeight(nWeight);
}

void TDbStruBeam::GetAssocBaseWallLine( TDPtrList<TBaseWallLine>& arBaseWallLinesS, TDPtrList<TBaseWallLine>& arBaseWallLinesM, TDPtrList<TBaseWallLine>& arBaseWallLinesE ) const
{
	TBaseWallLine bwlThis;
	GetThisBaseWallLine(bwlThis);
	
	// 获得起点终点标高
	double dEleS = 0.0, dEleE = 0.0;
	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	dEleS = ptS.z;
	dEleE = ptE.z;

	TDbStruBeam *pBaseWall = NULL;
	TBaseWallLine bwlThat;
	double dH = GetSection2dHeight(); // 截面高度
	int nIntegrateType = DocGetBeamRelCtl();//融合方式
	for (int i = 0; i < m_arAssocBWallIds.length(); i++)
	{
		acdbOpenObject(pBaseWall, m_arAssocBWallIds[i], AcDb::kForRead);
		if (pBaseWall != NULL)
		{
			pBaseWall->GetThisBaseWallLine(bwlThat);
			double dH2 = pBaseWall->GetSection2dHeight();
			pBaseWall->GetAt(KEY_START, ptS);
			pBaseWall->GetAt(KEY_END, ptE);
			pBaseWall->close();
			
			// 获得起点终点标高
			double dEleS1 = 0.0, dEleE1 = 0.0;
			dEleS1 = ptS.z;
			dEleE1 = ptE.z; 

			// 判断墙线融合方式
			TBaseWallLine *pBWLine = new TBaseWallLine;
			pBWLine->SetLeftLine(bwlThat.GetLeftLine());
			pBWLine->SetRightLine(bwlThat.GetRightLine());

			// 根据梁与梁的融合方式设置优先级
			if (nIntegrateType) // 全部融合
			{
				pBWLine->SetWeight(bwlThis.GetWeight()); // 优先级设置为相同值
			} 
			else if (fabs(dEleS - dEleS1) < _DIST_SNAP && fabs(dEleE - dEleE1) < _DIST_SNAP) // 等标高
			{
				if (fabs(dH2 - dH) < _DIST_SNAP)
				{
					pBWLine->SetWeight(bwlThis.GetWeight());
				}
				else if (dH > dH2)
				{
					pBWLine->SetWeight(bwlThis.GetWeight() - 1);
				}
				else
				{
					pBWLine->SetWeight(bwlThis.GetWeight() + 1);
				}
			}
			else
			{
				delete pBWLine;
				continue;
			}
			
			
			int nType = TBaseWallIntegrateTool::IsIntegrateAtTail(bwlThis, bwlThat);
			if (nType == 1) // 起始端融合
			{
				arBaseWallLinesS.Append(pBWLine);
			}
			else if (nType == 2) // 终止端融合
			{
				arBaseWallLinesE.Append(pBWLine);
			}
			else if (nType == 3) // 两端融合
			{
				arBaseWallLinesS.Append(pBWLine);
				TBaseWallLine *pbWLineNew = new TBaseWallLine;
				pbWLineNew->SetLeftLine(bwlThat.GetLeftLine());
				pbWLineNew->SetRightLine(bwlThat.GetRightLine());
				pbWLineNew->SetWeight(bwlThat.GetWeight());
				arBaseWallLinesE.Append(pbWLineNew);
			}
			else // 墙体内融合（非墙体起点终点）
			{
				arBaseWallLinesM.Append(pBWLine);
			}
		}
	}
}

bool TDbStruBeam::GetSection2d( TGGePoly2D& polyShape ) const
{
	polyShape.Reset();
	int nType = 0;
	GetAt(KEY_SECTYP, nType);
	
	switch(nType)
	{
	case ST_RECT: // 矩形
		{
			ConstructRectShape(polyShape);
			break;
		}
	case ST_IBEAM: // 工字型
		{
			ConstructIShape(polyShape);
			break;
		}
	default:
		{
			return false;
		}
	}

	return true;
}

double TDbStruBeam::GetSection2dWidth() const
{
	TADSGePoint3d ptMin, ptMax;
	TGGePoly2D poly;
	GetSection2d(poly);
	if (poly.Length() > 0)
	{
		poly.GetExtend(ptMin, ptMax);
	}
	return fabs(ptMax.x - ptMin.x);
}

double TDbStruBeam::GetSection2dHeight() const 
{
	TADSGePoint3d ptMin, ptMax;
	TGGePoly2D poly;
	GetSection2d(poly);
	if (poly.Length() > 0)
	{
		poly.GetExtend(ptMin, ptMax);
	}
	
	double dHeight = fabs(ptMax.y - ptMin.y);	
	return dHeight;	
}

void TDbStruBeam::UpdatePts(double dDist)
{
	double dOldVal = 0.0;
	GetAt(KEY_EDIS, dOldVal);
	if (fabs(dDist - dOldVal) < _DIST_SNAP)
	{
		return;
	}

	double dDist1 = dDist - dOldVal;

	// 调整型心线位置即起点终点位置
	double dBugle = 0.0;
	GetAt(KEY_BULGE, dBugle);
	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	if (fabs(dBugle) < g_angleZero) // 直线
	{
		AcGeVector3d vt = ptS - ptE;
		vt.normalize();
		vt.rotateBy(-PI/2, AcGeVector3d::kZAxis);
		ptS += vt * dDist1;
		ptE += vt * dDist1;
	}
	else  // 弧线
	{
		TGGeArc arc(ptS, ptE, dBugle);
		AcGePoint3d ptCenter;
		ptCenter = arc.GetCenterPt();
		AcGeVector3d vt = ptCenter - ptS;
		vt.normalize();
		ptS += vt * dDist1;
		vt = ptCenter - ptE;
		vt.normalize();
		ptE += vt * dDist1;
	}
	SetAt(KEY_START, ptS);
	SetAt(KEY_END, ptE);
}

bool TDbStruBeam::ConstructRectShape( TGGePoly2D& polyShape ) const
{
	double dWidth = 0.0, dHeight = 0.0, dAng = 0.0;
	GetAt(KEY_B, dWidth);
	GetAt(KEY_H, dHeight);
	GetAt(KEY_AXANG, dAng);
	AcGePoint3d ptOrigin = AcGePoint3d::kOrigin;
	AcGeVector3d vtX = AcGeVector3d::kXAxis;
	vtX = vtX.rotateBy(dAng, AcGeVector3d::kZAxis);
	AcGeVector3d vtY = vtX;
	vtY = vtY.rotateBy(PI / 2, AcGeVector3d::kZAxis);
	AcGePoint3d ptLT = ptOrigin - vtX * dWidth * 0.5 + vtY * dHeight * 0.5;
	AcGePoint3d ptRT = ptLT + vtX * dWidth;
	AcGePoint3d ptLB = ptLT - vtY * dHeight;
	AcGePoint3d ptRB = ptRT - vtY * dHeight;
	polyShape.AppendNode(ptLT);
	polyShape.AppendNode(ptRT);
	polyShape.AppendNode(ptRB);
	polyShape.AppendNode(ptLB);
	polyShape.SetFlag(1);
	return true;
}

bool TDbStruBeam::ConstructIShape( TGGePoly2D& polyShape ) const
{
	double dB = 0.0, dH = 0.0, dU = 0.0, dT = 0.0, dD = 0.0, dF = 0.0, dAngle = 0.0;
	GetAt(KEY_B,dB);
	GetAt(KEY_H,dH);
	GetAt(KEY_U,dU);
	GetAt(KEY_T,dT);
	GetAt(KEY_D,dD);
	GetAt(KEY_F,dF);
	GetAt(KEY_AXANG, dAngle);
	AcGePoint3d ptOrigin = AcGePoint3d::kOrigin;
	AcGeVector3d vtX = AcGeVector3d::kXAxis;
	vtX = vtX.rotateBy(dAngle, AcGeVector3d::kZAxis);
	AcGeVector3d vtY = vtX;
	vtY = vtY.rotateBy(PI / 2, AcGeVector3d::kZAxis);
	AcGePoint3d pt1 = ptOrigin - vtX * dU * 0.5 + vtY * dH * 0.5;
	AcGePoint3d pt2 = pt1 + vtX * dU;
	AcGePoint3d pt3 = pt2 - vtY * dT;
	AcGePoint3d pt4 = pt3 - vtX * (dU - dB) * 0.5;
	AcGePoint3d pt5 = pt4 - vtY * (dH - dF - dT);
	AcGePoint3d pt6 = pt5 + vtX * (dD - dB) * 0.5;
	AcGePoint3d pt7 = pt6 - vtY * dF;
	AcGePoint3d pt8 = pt7 - vtX * dD;
	AcGePoint3d pt9 = pt8 + vtY * dF;
	AcGePoint3d pt10 = pt9 + vtX * (dD - dB) * 0.5;
	AcGePoint3d pt11 = pt10 + vtY * (dH - dT - dF);
	AcGePoint3d pt12 = pt11 - vtX * (dU - dB) * 0.5;
	
	polyShape.AppendNode(pt1);
	polyShape.AppendNode(pt2); 
	polyShape.AppendNode(pt3);
	polyShape.AppendNode(pt4);
	polyShape.AppendNode(pt5);
	polyShape.AppendNode(pt6);
	polyShape.AppendNode(pt7);
	polyShape.AppendNode(pt8);
	polyShape.AppendNode(pt9);
	polyShape.AppendNode(pt10);
	polyShape.AppendNode(pt11);
	polyShape.AppendNode(pt12);
	polyShape.SetFlag(1);
	return true;
}

void TDbStruBeam::GetPolyBase(TGGePoly2D &polyBase) const
{
	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	double dBulge = 0.0;
	GetAt(KEY_BULGE,dBulge);
	polyBase.AppendNode(ptS, dBulge);
	polyBase.AppendNode(ptE);
}

bool TDbStruBeam::IsLinkColumn(bool bStart) const
{
	// 查看端点是否发生融合
	TBaseWallLine bwLine;
	GetThisBaseWallLine(bwLine);
	TGGeVisibilityPoly2D left = bwLine.GetLeftLine();
	TGGeVisibilityPoly2D right = bwLine.GetRightLine();
	TADSGePoint3d pt1, pt2; // 端点
	if (bStart) // 起点
	{
		pt1 = *left[0];
		pt2 = *right[0];
	}
	else // 终点
	{
		pt1 = *left[left.Length() - 1];
		pt2 = *right[right.Length() - 1];
	}
	
	AcDbLine line(pt1, pt2);
	AcGePoint3dArray ptArr;
	TDbColumn *pStruColumn = NULL;
	for (int i = 0; i < m_arColumnIds.length(); i++)
	{
		acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
		if (pStruColumn != NULL)
		{
			TGGePoly2D poly2d;
			pStruColumn->GetOutline(poly2d);
			pStruColumn->Close();
			poly2d.SetElevation(0.0);
			pt1.z = 0.0;
			pt2.z = 0.0;
			if (((pt1 & poly2d) == PR_EDGE || (pt1 & poly2d) == PR_INSIDE)
				||((pt2 & poly2d) == PR_EDGE || (pt2 & poly2d) == PR_INSIDE))
			{
				return true;
			}

			AcDbCurve *pCurve = poly2d.AsAcDbCurve();
			if (pCurve != NULL && pCurve->intersectWith(&line, AcDb::kOnBothOperands, ptArr) == Acad::eOk
				&& ptArr.length() > 0)
			{
				return true;
			}
		}
	}
	return false;
}

Acad::ErrorStatus TDbStruBeam::DrawSideLine2d(bool bStart, TGGiExplodeDrawBase &dc) const
{
	// 查看端点与柱子是否发生融合
	TBaseWallLine bwLine;
	GetThisBaseWallLine(bwLine);
	TGGeVisibilityPoly2D left = bwLine.GetLeftLine();
	TGGeVisibilityPoly2D right = bwLine.GetRightLine();
	TADSGePoint3d pt1, pt2; // 端点
	if (bStart) // 起点
	{
		pt1 = *left[0];
		pt2 = *right[0];
	}
	else // 终点
	{
		pt1 = *left[left.Length() - 1];
		pt2 = *right[right.Length() - 1];
	}
	
	AcDbLine line(pt1, pt2);
	TDbColumn *pStruColumn = NULL;
	for (int i = 0; i < m_arColumnIds.length(); i++)
	{
		acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
		if (pStruColumn != NULL)
		{
			TGGePoly2D poly2d;
			pStruColumn->GetOutline(poly2d);
			pStruColumn->Close();

			bool bLink1 = (pt1 & poly2d) == PR_EDGE || (pt1 & poly2d) == PR_INSIDE;
			bool bLink2 = (pt2 & poly2d) == PR_EDGE || (pt2 & poly2d) == PR_INSIDE;
			if ((bLink1 && !bLink2) || (!bLink1 && bLink2)) // 端点只要一点与柱子相连时，墙体部分封口
			{
				TADSGePoint3d pt;   
				if (bLink1 && !bLink2)
				{
					pt = pt2;
				} 
				else
				{
					pt = pt1;
				}
				
				AcDbLine  line(pt1,pt2);
				AcDbCurve *pCurve = poly2d.AsAcDbCurve();
				AcGePoint3dArray arrPt;
				line.intersectWith(pCurve, AcDb::kOnBothOperands, arrPt);
				if (arrPt.length() == 1)
				{
					pt1 = arrPt[0]; // 将AcGePoint3d转化为TADSGePoint3d
					dc << TGGeLine(pt, pt1);
				}
				else if (arrPt.length() > 1)
				{
					std::map<double, TADSGePoint3d> data;
					for (int i = 0; i < arrPt.length(); i++)
					{
						data.insert(std::make_pair(pt.Distance(arrPt[i]), arrPt[i]));
					}
					
					//获得最近的交点
					pt1 = (*data.begin()).second;
					dc << TGGeLine(pt1, pt);
				}
				
				break;
			}
			else if (!bLink1 && !bLink2) // 两点都与poly2d不相连
			{
				AcGePoint3dArray ptArr;
				AcDbCurve *pCurve = poly2d.AsAcDbCurve();
				if (pCurve != NULL)
				{
					pCurve->intersectWith(&line, AcDb::kOnBothOperands, ptArr);
					if (ptArr.length() == 1)
					{
						dc << TGGeLine(pt1, pt2);
						break;
					}
					else if (ptArr.length() == 2)
					{
						double dDist1 = 0.0, dDist2 = 0.0;
						dDist1 = pt1.Distance(ptArr[0]);
						dDist2 = pt1.Distance(ptArr[1]);
						if(dDist2 > dDist1)
						{
							dc << TGGeLine(pt1, asDblArray(ptArr[0]));
						}
						else
						{
							dc << TGGeLine(pt1, asDblArray(ptArr[1]));
						}

						dDist1 = pt2.Distance(ptArr[0]);
						dDist2 = pt2.Distance(ptArr[1]);
						if(dDist2 > dDist1)
						{
							dc << TGGeLine(pt2, asDblArray(ptArr[0]));
						}
						else
						{
							dc << TGGeLine(pt2, asDblArray(ptArr[1]));
						}
						break;
					}
				}
			}
		}
	}
	
	return Acad::eOk;
}

Acad::ErrorStatus TDbStruBeam::DrawSideLine2d(bool bStart, const AcDbObjectId &idWall, const TBaseWallLine &wallLine, TGGiExplodeDrawBase &dc) const
{
	TDbStruBeam *pBeam = NULL;
	acdbOpenObject(pBeam, idWall, AcDb::kForRead);
	if (pBeam != NULL)
	{
		TBaseWallLine bwlThat;
		pBeam->GetThisBaseWallLine(bwlThat);
		int nThatWeight = 0;
		pBeam->GetAt(KEY_WEIGHT, nThatWeight);
		pBeam->close();

		// 判断墙线融合方式
		TADSGePoint3d ptThat1,ptThat2;
		TBaseWallLine bwlThis;
		GetThisBaseWallLine(bwlThis);
		int nType = TBaseWallIntegrateTool::IsIntegrateAtTail(bwlThat, bwlThis);
		if (nType == 1) // 起始端相交
		{
			TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
			TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
			ptThat1 = *leftThat[0];
			ptThat2 = *rightThat[0];
		}
		else if (nType == 2) // 终止端相交
		{
			TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
			TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
			ptThat1 = *leftThat[leftThat.Length() - 1];
			ptThat2 = *rightThat[leftThat.Length() - 1];
    	}
		else
		{
			return Acad::eOk;
		}

		if (!!ptThat1 && !!ptThat2)
		{
			TADSGePoint3d ptThis1,ptThis2;
			TGGeVisibilityPoly2D leftThis = bwlThis.GetLeftLine();
			TGGeVisibilityPoly2D rightThis = bwlThis.GetRightLine();
			if (bStart) 
			{
				ptThis1 = *leftThis[0];
				ptThis2 = *rightThis[0];
			}
			else
			{
				ptThis1 = *leftThis[leftThis.Length() - 1];
				ptThis2 = *rightThis[rightThis.Length() - 1];
			}

			AcGeVector3d vtThat = ptThat1 - ptThat2;
			AcGeVector3d vtThis = ptThis1 - ptThis2;
			int nThisWeight = 0;
			GetAt(KEY_WEIGHT, nThisWeight);
			if (vtThis.isParallelTo(vtThat)) // 端点连线平行
			{
				if (nThisWeight < nThatWeight) // 比较优先级
				{
					dc << TGGeLine(ptThis1, ptThis2);
				} 
				else
				{
					bool bSuperposition = (ptThat1.Distance(ptThis1) < _DIST_SNAP && ptThat2.Distance(ptThis2) < _DIST_SNAP) 
										  || (ptThat1.Distance(ptThis2) < _DIST_SNAP && ptThat2.Distance(ptThis1) < _DIST_SNAP); // 融合端点两两重合
					if (!bSuperposition)
					{
						// 将that的融合端点投影到this融合端点连线的直线上
						std::vector<TADSGePoint3d> vecPt;
						vecPt.push_back(ptThis1);
						vecPt.push_back(ptThis2);
						TADSGePoint3d pt;
						TGGeLine line(ptThis1, ptThis2);
						ptThat1.Project(&line, pt);
						vecPt.push_back(pt);
						ptThat2.Project(&line, pt);
						vecPt.push_back(pt);

						// 求两点间的距离
						std::map<double, std::vector<TADSGePoint3d> > mapData;
						std::vector<TADSGePoint3d> vecTemp;
						std::vector<TADSGePoint3d>::iterator it1, it2;
						for (it1 = vecPt.begin(); it1 != vecPt.end(); it1++)
						{
							it2 = it1;
							++it2;
							for (; it2 != vecPt.end(); it2++)
							{
								vecTemp.clear();
								vecTemp.push_back(*it1);
								vecTemp.push_back(*it2);
								mapData.insert(std::make_pair((*it1).Distance(*it2), vecTemp));
							}
						}

						// 获取距离最远的点
						std::map<double, std::vector<TADSGePoint3d> >::iterator it;
						it = mapData.end();
						--it;
						vecTemp.clear();
						vecTemp.push_back((*it).second[0]);
						vecTemp.push_back((*it).second[1]);

						// 从vecPt中删除最远的两点
						for (it1 = vecTemp.begin(); it1 != vecTemp.end(); it1++)
						{
							for (it2 = vecPt.begin(); it2 != vecPt.end(); it2++)
							{
								if ((*it1).Distance(*it2) < _DIST_SNAP)
								{
									vecPt.erase(it2);
									break;;
								}
							}
						}
						
						// this的融合端点是否与最远点重合
						if (ptThis1.Distance(vecTemp[0]) < _DIST_SNAP || ptThis1.Distance(vecTemp[1]) < _DIST_SNAP)
						{
							double dDist1 = ptThis1.Distance(vecPt[0]);
							double dDist2 = ptThis1.Distance(vecPt[1]);
							if (dDist1 < dDist2)
							{
								dc << TGGeLine(ptThis1, vecPt[0]);
							} 
							else
							{
								dc << TGGeLine(ptThis1, vecPt[1]);
							}
						}

						if (ptThis2.Distance(vecTemp[0]) < _DIST_SNAP || ptThis2.Distance(vecTemp[1]) < _DIST_SNAP)
						{
							double dDist1 = ptThis2.Distance(vecPt[0]);
							double dDist2 = ptThis2.Distance(vecPt[1]);
							if (dDist1 < dDist2)
							{
								dc << TGGeLine(ptThis2, vecPt[0]);
							} 
							else
							{
								dc << TGGeLine(ptThis2, vecPt[1]);
							}
						}
					}
				}
			}
			else if (nThatWeight != nThisWeight) // 优先级不同 
			{
				TGGeVisibilityPoly2D left = wallLine.GetLeftLine();
				TGGeVisibilityPoly2D right = wallLine.GetRightLine();
				if (bStart)
				{
					dc << TGGeLine(*left[0], *right[0]);
				} 
				else
				{
					dc << TGGeLine(*left[left.Length() - 1], *right[right.Length() - 1]);
				}
			}
		}
	}

	return Acad::eOk;
}

void TDbStruBeam::GetPoly2D(TGGePoly2D &poly2d) const
{
	TBaseWallLine wallLine;
	GetThisBaseWallLine(wallLine);
	TGGeVisibilityPoly2D left, right;
	left = wallLine.GetLeftLine();
	right = wallLine.GetRightLine();
	
	AcDbPolyline* pLwPoly = new AcDbPolyline();
	double dBuge = 0.0;
	int nIndex = 0;
	for (int i = 0; i < left.Length(); i++) 
	{
		dBuge = tan(*(left.m_ardbulges[i]) / 4.0);
		pLwPoly->addVertexAt(nIndex, (*left[i]).AsAcGePoint2d(), dBuge);
		++nIndex;
	}
	
	for (i = left.Length() - 1; i >= 0; i--) 
	{
		if (i > 0)
		{
			dBuge = tan(*(right.m_ardbulges[i-1]) / 4.0) * (-1);
		} 
		else
		{
			dBuge = 0.0;
		}
		pLwPoly->addVertexAt(nIndex, (*right[i]).AsAcGePoint2d(), dBuge);
		++nIndex;
	}
	
	pLwPoly->setClosed(Adesk::kTrue);
	poly2d.SetAcDbCurve(pLwPoly);
	delete pLwPoly;
}

bool TDbStruBeam::GetBasePoint(AcGePoint3d &ptBase) const
{
	ptBase = AcGePoint3d::kOrigin;
	int nType = 0;
	GetAt(KEY_SECTYP, nType);
	switch(nType)
	{
	case ST_RECT: // 矩形
		{
			double dHeight = 0.0, dAng = 0.0;
			GetAt(KEY_H, dHeight);
			GetAt(KEY_AXANG, dAng);
			AcGeVector3d vtY = AcGeVector3d::kXAxis;
			vtY = vtY.rotateBy(PI / 2 + dAng, AcGeVector3d::kZAxis);
			ptBase = AcGePoint3d::kOrigin + vtY * dHeight * 0.5;
			break;
		}
	case ST_IBEAM: // 工字型
		{
			double dH = 0.0,  dAngle = 0.0;
			GetAt(KEY_H,dH);
			GetAt(KEY_AXANG, dAngle);
			AcGePoint3d ptOrigin = AcGePoint3d::kOrigin;
			AcGeVector3d vtY = AcGeVector3d::kXAxis;
			vtY = vtY.rotateBy(PI / 2 + dAngle, AcGeVector3d::kZAxis);
			ptBase= ptOrigin + vtY * dH * 0.5;
			break;
		}
	default:
		{
			return false;
		}	
	}

	return true;
}

void TDbStruBeam::GetBaseLine(TGGeCurveSegment &seg) const
{
	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	
	double dBulge = 0.0;
	GetAt(KEY_BULGE,dBulge);

	TGGeCurveSegment segTemp(ptS, ptE, dBulge);
	seg = segTemp;
}

void TDbStruBeam::CopyData(TDbStruBeam *pBeam)
{
	if (pBeam == NULL)
	{
		return;
	}

	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	double dBulge = 0.0;
	GetAt(KEY_BULGE, dBulge);
	/*int nType = 0;
	GetAt(KEY_SECTYP, nType);
	double dAng = 0.0;
	GetAt(KEY_AXANG, dAng);
	double dWidth = 0.0, dHeight = 0.0;
	GetAt(KEY_SUMB, dWidth);
	GetAt(KEY_SUMH, dHeight);

	switch(nType)
	{
	case ST_RECT: // 矩形
		{
			double dB = 0.0, dH = 0.0;
			GetAt(KEY_B, dB);
			GetAt(KEY_H, dH);
			GetSpecialtyData()->Empty();
			*GetSpecialtyData() = *pBeam->GetSpecialtyData();
			SetAt(KEY_B, dB);
			SetAt(KEY_H, dH);
			break;
		}
	case ST_IBEAM: // 工字型
		{
			double dB = 0.0, dH = 0.0, dU = 0.0, dT = 0.0, dD = 0.0, dF = 0.0;
			GetAt(KEY_B,dB);
			GetAt(KEY_H,dH);
			GetAt(KEY_U,dU);
			GetAt(KEY_T,dT);
			GetAt(KEY_D,dD);
			GetAt(KEY_F,dF);
			GetSpecialtyData()->Empty();
			*GetSpecialtyData() = *pBeam->GetSpecialtyData();
			SetAt(KEY_B,dB);
			SetAt(KEY_H,dH);
			SetAt(KEY_U,dU);
			SetAt(KEY_T,dT);
			SetAt(KEY_D,dD);
			SetAt(KEY_F,dF);
			break;
		}	
	}*/
	GetSpecialtyData()->Empty();
	*GetSpecialtyData() = *pBeam->GetSpecialtyData();
	
	SetAt(KEY_START, ptS);
	SetAt(KEY_END, ptE);
	SetAt(KEY_BULGE, dBulge);
	/*SetAt(KEY_SECTYP, nType);
	SetAt(KEY_AXANG, dAng);
	SetAt(KEY_SUMB, dWidth);
	SetAt(KEY_SUMH, dHeight);*/
}

void TDbStruBeam::GetPoly2dBehindIntegrate(TGGePoly2D &poly2d) const
{	
	assertReadEnabled();
	TBaseWallLine bwlThis;
	GetThisBaseWallLine(bwlThis);

	// 梁与柱融合
	TDbColumn *pStruColumn = NULL;
	for (int i = 0; i < m_arColumnIds.length(); i++)
	{
		acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
		if (pStruColumn != NULL)
		{
			TGGePoly2D poly2d;
			pStruColumn->GetOutline(poly2d);
			pStruColumn->Close();
			poly2d.SetElevation(0.0);
			TBaseWallIntegrateTool::Integrate(bwlThis, poly2d);
		}
	}

	TDPtrList<TBaseWallLine> arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE;
	GetAssocBaseWallLine(arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE);
	
	// 起点融合
	TBaseWallIntegrateTool::IntegrateAtTail(true, bwlThis, arBaseWallLinesS);
	
	// 终点融合
	TBaseWallIntegrateTool::IntegrateAtTail(false, bwlThis, arBaseWallLinesE);
	
	// 端点融合后新生成的梁线
	TGGeVisibilityPoly2D left, right;
	left = bwlThis.GetLeftLine();
	right = bwlThis.GetRightLine();
	
	// 删除端点出不可见的梁线
	DeleteInVisiblePt(true, left);
	DeleteInVisiblePt(false,left);
	DeleteInVisiblePt(true, right);
	DeleteInVisiblePt(false, right);
	
	// 有left,right生成闭合poly2d
	AcDbPolyline* pLwPoly = new AcDbPolyline();
	double dBuge = 0.0;
	int nIndex = 0;
	for (i = 0; i < left.Length(); i++) 
	{
		dBuge = tan(*(left.m_ardbulges[i]) / 4.0);
		pLwPoly->addVertexAt(nIndex, (*left[i]).AsAcGePoint2d(), dBuge);
		++nIndex;
	}
	
	for (i = right.Length() - 1; i >= 0; i--) 
	{
		if (i > 0)
		{
			dBuge = tan(*(right.m_ardbulges[i-1]) / 4.0) * (-1);
		} 
		else
		{
			dBuge = 0.0;
		}
		pLwPoly->addVertexAt(nIndex, (*right[i]).AsAcGePoint2d(), dBuge);
		++nIndex;
	}
	
	pLwPoly->setClosed(Adesk::kTrue);
	poly2d.SetAcDbCurve(pLwPoly);
	delete pLwPoly;
}

void TDbStruBeam::DeleteInVisiblePt(bool bStart, TGGeVisibilityPoly2D &poly) const
{
	if (bStart) // 删除起点处不可见的点
	{
		for (int i = 0; i < poly.Length(); i++)
		{
			if (poly.GetVisibleAt(i) == AcDb::kInvisible)
			{
				poly.RemoveNode(i);
				continue;
			}
			break;
		}
	} 
	else // 删除终点处不可见的点
	{
		for (int i = poly.Length() - 1; i >= 0 ; i--)
		{
			if (poly.GetVisibleAt(i) == AcDb::kInvisible && i > 0 && poly.GetVisibleAt(i - 1) == AcDb::kInvisible)
			{
				poly.RemoveNode(i);
				continue;
			}
			break;
		}
	}
}

Acad::ErrorStatus TDbStruBeam::DrawWeightLine2d(TGGiExplodeDrawBase &dc) const
{
	// 获取融合后的poly2d
	TGGeVisibilityPoly2D poly;
	GetIntegratedPoly2d(poly);
	poly.Compress();
	
	// 	dc.SetColor(1);
	// 	TGGeCurveSegment seg;
	// 	for (int j = 0; j < poly.Length(); j++)
	// 	{
	// 		if (poly.GetVisibleAt(j) == AcDb::kInvisible)
	// 		{
	// 			continue;
	// 		}
	// 
	// 		poly.Nth(j, seg);
	// 		dc << seg;
	// 	}
	// 	return Acad::eOk;
	
	int nMatTyp = MAT_CONCRETE;
	GetAt(KEY_MATTYP, nMatTyp);

	double dLineWidth = 0;					//加粗线宽
	switch (nMatTyp)
	{
	case MAT_CONCRETE:						//混凝土梁
		dLineWidth = DocGetConBeamLWeight();
		break;
	case MAT_STEEL:							//钢梁
		dLineWidth = DocGetStlBeamLWeight();
		break;
	}

	dLineWidth *= GetPScale();

	TGGePoly2D polyDest;
	if (poly.PathArea() > 0) // 顺时针
	{
		poly.Offset(dLineWidth, polyDest);
	}
	else
	{
		poly.Offset(dLineWidth * (-1), polyDest);
	}
	
	if (poly.Length() != polyDest.Length())
	{
		return Acad::eInvalidInput;
	}
	
	TGGePoly2D poly2dNew;
	for (int i = 0; i < poly.Length() - 1; i++)
	{
		if (poly.GetVisibleAt(i) == AcDb::kInvisible)
		{
			continue;
		}
		
		poly2dNew.Reset();
		poly2dNew.AppendNode(*poly[i], *(poly.m_ardbulges[i]));
		poly2dNew.AppendNode(*poly[i+1]);
		poly2dNew.AppendNode(*polyDest[i+1], *(polyDest.m_ardbulges[i]) * (-1));
		poly2dNew.AppendNode(*polyDest[i]);
		poly2dNew.SetClosed();
		dc << TGGeSolid(poly2dNew);
	}
	
	if (poly.GetVisibleAt(poly.Length() - 1) == AcDb::kVisible)
	{
		poly2dNew.Reset();
		poly2dNew.AppendNode(*poly[poly.Length() - 1], *(poly.m_ardbulges[poly.Length() - 1]));
		poly2dNew.AppendNode(*poly[0]);
		poly2dNew.AppendNode(*polyDest[0], *(polyDest.m_ardbulges[polyDest.Length() - 1]) * (-1));
		poly2dNew.AppendNode(*polyDest[polyDest.Length() - 1]);
		poly2dNew.SetClosed();
		dc << TGGeSolid(poly2dNew);
	}
	
	return Acad::eOk;
}

void TDbStruBeam::GetIntegratedPoly2d(TGGeVisibilityPoly2D &poly) const
{
	// 双线绘制样式
	TBaseWallLine bwlThis;
	GetThisBaseWallLine(bwlThis);
	
	// 梁与柱融合
	TDbColumn *pStruColumn = NULL;
	for (int i = 0; i < m_arColumnIds.length(); i++)
	{
		acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
		if (pStruColumn != NULL)
		{
			TGGePoly2D poly2d;
			pStruColumn->GetOutline(poly2d);
			pStruColumn->Close();
			poly2d.SetElevation(0.0);
			TBaseWallIntegrateTool::Integrate(bwlThis, poly2d);
		}
	}
	
	// 梁与梁融合
	TDPtrList<TBaseWallLine> arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE;
	GetAssocBaseWallLine(arBaseWallLinesS, arBaseWallLinesM, arBaseWallLinesE);
	// 起点融合
	TBaseWallIntegrateTool::IntegrateAtTail(true, bwlThis, arBaseWallLinesS);
	// 终点融合
	TBaseWallIntegrateTool::IntegrateAtTail(false, bwlThis, arBaseWallLinesE);
	// 梁内融合
	for (i = 0; i < arBaseWallLinesM.Length(); i++)
	{
		TBaseWallIntegrateTool::Integrate(bwlThis,*arBaseWallLinesM[i]);
	}
	
	// 生成poly2d
	// 添加左线
	TGGeVisibilityPoly2D left, right;
	left = bwlThis.GetLeftLine();
	right = bwlThis.GetRightLine();
	for (i = 0; i < left.Length(); i++)
	{
		poly.AppendNode(*left[i], *(left.m_ardbulges[i]), left.GetVisibleAt(i));
	}

	// 添加终点封口线
	int nLen = arBaseWallLinesE.Length();
	bool bHasColumn = IsLinkColumn(false);
	if (arBaseWallLinesE.Length() == 0 && !bHasColumn) // 终点封口
	{
		if (!(left.GetVisibleAt(left.Length() - 2) == AcDb::kInvisible && right.GetVisibleAt(right.Length() - 2) == AcDb::kInvisible))
		{
			poly.AppendNode(*left[left.Length() - 1]);	
			poly.AppendNode(*right[right.Length() - 1]);
		}		
	}
	else if (nLen == 1 && !bHasColumn) // 处理终点处有一个融合墙体时，墙体端点两点连线平行的情况
	{
		AcDbObjectId id;
		GetWallId(false, id);
		TGGeVisibilityPoly2D polyNew;
		GetSideLine2d(false, id, bwlThis, polyNew);
		polyNew.Compress();
		for (int i = 0; i < polyNew.Length(); i++)
		{
			poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
		}

		// 未封口时，设置为不可见
		if (polyNew.Length() == 0)
		{
			poly.InsertNodeAt(*left[left.Length() - 1], AcDb::kInvisible);	// 改变点的可见性
		}
	}
	else if (nLen == 0 && bHasColumn) // 终点关联柱子
	{
		TGGeVisibilityPoly2D polyNew;
		GetIntegratedPoly2dForColumn(false, polyNew);
		polyNew.Compress();
		for (int i = 0; i < polyNew.Length(); i++)
		{
			poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
		}
	}
	else
	{
		poly.InsertNodeAt(*left[left.Length() - 1], AcDb::kInvisible);	// 改变点的可见性
	}
	
	// 添加右线
	right.Reverse();
	for (i = 0; i < right.Length(); i++)
	{
		poly.AppendNode(*right[i], *(right.m_ardbulges[i]), right.GetVisibleAt(i));
	}
	
	//  添加起点封口线
	nLen = arBaseWallLinesS.Length();
	bHasColumn = IsLinkColumn(true);
	if (nLen == 0 && !bHasColumn) // 起点封口
	{
		if (!(left.GetVisibleAt(0) == AcDb::kInvisible && right.GetVisibleAt(0) == AcDb::kInvisible))
		{
			poly.AppendNode(*right[right.Length() - 1]);	// right 已逆转方向
			poly.AppendNode(*left[0]);	
		}
	}
	else if (nLen == 1 && !bHasColumn) // 处理起点处有一个融合墙体时，墙体端点两点连线平行的情况
	{
		AcDbObjectId id;
		GetWallId(true, id);	
		TGGeVisibilityPoly2D polyNew;
		GetSideLine2d(true, id, bwlThis, polyNew);
		polyNew.Compress();
		polyNew.Reverse();
		for (int i = 0; i < polyNew.Length(); i++)
		{
			poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
		}

		// 未封口时，设置为不可见
		if (polyNew.Length() == 0)
		{
			poly.InsertNodeAt(*right[right.Length() - 1], AcDb::kInvisible);	// 改变点的可见性
		}
	}
	else if (nLen == 0 && bHasColumn) // 起点关联柱子
	{
		TGGeVisibilityPoly2D polyNew;
		GetIntegratedPoly2dForColumn(true, polyNew);
		polyNew.Compress();
		polyNew.Reverse();
		for (int i = 0; i < polyNew.Length(); i++)
		{
			poly.AppendNode(*polyNew[i], *(polyNew.m_ardbulges[i]), polyNew.GetVisibleAt(i));
		}
	}
	else
	{
		poly.InsertNodeAt(*right[right.Length() - 1], AcDb::kInvisible);	// 改变点的可见性
	}
	
	poly.SetClosed();
}

void TDbStruBeam::GetSideLine2d(bool bStart, const AcDbObjectId &idBeam, const TBaseWallLine &wallLine, TGGeVisibilityPoly2D &poly) const
{
	poly.Reset();
	TDbStruBeam *pBeam = NULL;
	acdbOpenObject(pBeam, idBeam, AcDb::kForRead);
	if (pBeam != NULL)
	{
		TBaseWallLine bwlThat;
		pBeam->GetThisBaseWallLine(bwlThat);
		int nThatWeight = 0;
		pBeam->GetAt(KEY_WEIGHT, nThatWeight);
		pBeam->close();

		// 判断墙线融合方式
		TADSGePoint3d ptThat1,ptThat2;
		TBaseWallLine bwlThis;
		GetThisBaseWallLine(bwlThis);
		int nType = TBaseWallIntegrateTool::IsIntegrateAtTail(bwlThat, bwlThis);
		if (nType == 1) // 起始端相交
		{
			TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
			TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
			ptThat1 = *leftThat[0];
			ptThat2 = *rightThat[0];
		}
		else if (nType == 2) // 终止端相交
		{
			TGGeVisibilityPoly2D leftThat = bwlThat.GetLeftLine();
			TGGeVisibilityPoly2D rightThat = bwlThat.GetRightLine();
			ptThat1 = *leftThat[leftThat.Length() - 1];
			ptThat2 = *rightThat[leftThat.Length() - 1];
    	}
		else
		{
			return;
		}

		if (!!ptThat1 && !!ptThat2)
		{
			TADSGePoint3d ptThis1,ptThis2;
			TGGeVisibilityPoly2D leftThis = bwlThis.GetLeftLine();
			TGGeVisibilityPoly2D rightThis = bwlThis.GetRightLine();
			if (bStart) 
			{
				ptThis1 = *leftThis[0];
				ptThis2 = *rightThis[0];
			}
			else
			{
				ptThis1 = *leftThis[leftThis.Length() - 1];
				ptThis2 = *rightThis[rightThis.Length() - 1];
			}

			AcGeVector3d vtThat = ptThat1 - ptThat2;
			AcGeVector3d vtThis = ptThis1 - ptThis2;
			int nThisWeight = 0;
			GetAt(KEY_WEIGHT, nThisWeight);
			if (vtThis.isParallelTo(vtThat)) // 端点连线平行
			{
				if (nThisWeight < nThatWeight) // 比较优先级
				{
					poly.AppendNode(ptThis1);
					poly.AppendNode(ptThis2);
				} 
				else
				{
					bool bSuperposition = (ptThat1.Distance(ptThis1) < _DIST_SNAP && ptThat2.Distance(ptThis2) < _DIST_SNAP) 
										  || (ptThat1.Distance(ptThis2) < _DIST_SNAP && ptThat2.Distance(ptThis1) < _DIST_SNAP); // 融合端点两两重合
					if (!bSuperposition)
					{
						// 将that的融合端点投影到this融合端点连线的直线上
						std::vector<TADSGePoint3d> vecPt;
						vecPt.push_back(ptThis1);
						vecPt.push_back(ptThis2);
						TADSGePoint3d pt;
						TGGeLine line(ptThis1, ptThis2);
						ptThat1.Project(&line, pt);
						vecPt.push_back(pt);
						ptThat2.Project(&line, pt);
						vecPt.push_back(pt);

						// 求两点间的距离
						std::map<double, std::vector<TADSGePoint3d> > mapData;
						std::vector<TADSGePoint3d> vecTemp;
						std::vector<TADSGePoint3d>::iterator it1, it2;
						for (it1 = vecPt.begin(); it1 != vecPt.end(); it1++)
						{
							it2 = it1;
							++it2;
							for (; it2 != vecPt.end(); it2++)
							{
								vecTemp.clear();
								vecTemp.push_back(*it1);
								vecTemp.push_back(*it2);
								mapData.insert(std::make_pair((*it1).Distance(*it2), vecTemp));
							}
						}

						// 获取距离最远的点
						std::map<double, std::vector<TADSGePoint3d> >::iterator it;
						it = mapData.end();
						--it;
						vecTemp.clear();
						vecTemp.push_back((*it).second[0]);
						vecTemp.push_back((*it).second[1]);

						// 从vecPt中删除最远的两点
						for (it1 = vecTemp.begin(); it1 != vecTemp.end(); it1++)
						{
							for (it2 = vecPt.begin(); it2 != vecPt.end(); it2++)
							{
								if ((*it1).Distance(*it2) < _DIST_SNAP)
								{
									vecPt.erase(it2);
									break;;
								}
							}
						}
						
						// this的融合端点是否与最远点重合
						if (ptThis1.Distance(vecTemp[0]) < _DIST_SNAP || ptThis1.Distance(vecTemp[1]) < _DIST_SNAP)
						{
							double dDist1 = ptThis1.Distance(vecPt[0]);
							double dDist2 = ptThis1.Distance(vecPt[1]);
							if (dDist1 < dDist2)
							{
								poly.AppendNode(ptThis1);
								poly.AppendNode(vecPt[0], 0.0, AcDb::kInvisible);
							} 
							else
							{
								poly.AppendNode(ptThis1);
								poly.AppendNode(vecPt[1], 0.0, AcDb::kInvisible);
							}
						}

						if (ptThis2.Distance(vecTemp[0]) < _DIST_SNAP || ptThis2.Distance(vecTemp[1]) < _DIST_SNAP)
						{
							double dDist1 = ptThis2.Distance(vecPt[0]);
							double dDist2 = ptThis2.Distance(vecPt[1]);
							if (dDist1 < dDist2)
							{
								poly.AppendNode(vecPt[0]);
								poly.AppendNode(ptThis2);
							} 
							else
							{
								poly.AppendNode(vecPt[1]);
								poly.AppendNode(ptThis2);
							}
						}

						if (poly.Length() == 0)
						{
							poly.AppendNode(ptThis1, 0.0, AcDb::kInvisible);
							poly.AppendNode(ptThis2, 0.0, AcDb::kInvisible);
						}
					}
				}
			}
			else if (nThatWeight != nThisWeight) // 优先级不同 
			{
				TGGeVisibilityPoly2D left = wallLine.GetLeftLine();
				TGGeVisibilityPoly2D right = wallLine.GetRightLine();
				if (bStart)
				{
					poly.AppendNode(*left[0]);
					poly.AppendNode(*right[0]);
				} 
				else
				{
					poly.AppendNode(*left[left.Length() - 1]);
					poly.AppendNode(*right[right.Length() - 1]);
				}
			}
		}
	}
}

void TDbStruBeam::GetIntegratedPoly2dForColumn(bool bStart, TGGeVisibilityPoly2D &poly) const
{
	poly.Reset();
	// 查看端点与柱子是否发生融合
	TBaseWallLine bwLine;
	GetThisBaseWallLine(bwLine);
	TGGeVisibilityPoly2D left = bwLine.GetLeftLine();
	TGGeVisibilityPoly2D right = bwLine.GetRightLine();
	TADSGePoint3d pt1, pt2; // 端点
	if (bStart) // 起点
	{
		pt1 = *left[0];
		pt2 = *right[0];
	}
	else // 终点
	{
		pt1 = *left[left.Length() - 1];
		pt2 = *right[right.Length() - 1];
	}

	pt1.z = 0.0;
	pt2.z = 0.0;

	AcDbLine line(pt1, pt2);
	TDbColumn *pStruColumn = NULL;
	for (int i = 0; i < m_arColumnIds.length(); i++)
	{
		acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
		if (pStruColumn != NULL)
		{
			TGGePoly2D poly2d;
			pStruColumn->GetOutline(poly2d);
			pStruColumn->Close();
			poly2d.SetElevation(0.0);
			bool bLink1 = (pt1 & poly2d) == PR_EDGE || (pt1 & poly2d) == PR_INSIDE;
			bool bLink2 = (pt2 & poly2d) == PR_EDGE || (pt2 & poly2d) == PR_INSIDE;
			// 端点只要一点与柱子相连时，墙体部分封口
			if ((bLink1 && !bLink2) || (!bLink1 && bLink2))
			{
				TADSGePoint3d pt;   
				if (bLink1 && !bLink2)
				{
					pt = pt2;
				} 
				else
				{
					pt = pt1;
				}

				AcDbLine  line(pt1,pt2);
				AcDbCurve *pCurve = poly2d.AsAcDbCurve();
				AcGePoint3dArray arrPt;
				line.intersectWith(pCurve, AcDb::kOnBothOperands, arrPt);
				if (arrPt.length() == 1)
				{
					if (bLink1 && !bLink2)
					{
						poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
						poly.AppendNode(arrPt[0]);
						poly.AppendNode(pt2);
					} 
					else
					{
						poly.AppendNode(pt1);
						poly.AppendNode(arrPt[0], 0.0, AcDb::kInvisible);
						poly.AppendNode(pt2);
					}
				}
				else if (arrPt.length() > 1)
				{
					std::map<double, TADSGePoint3d> data;
					for (int i = 0; i < arrPt.length(); i++)
					{
						data.insert(std::make_pair(pt.Distance(arrPt[i]), arrPt[i]));
					}

					if (bLink1 && !bLink2)
					{
						poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
						poly.AppendNode((*data.begin()).second);
						poly.AppendNode(pt2);
					} 
					else
					{
						poly.AppendNode(pt1);
						poly.AppendNode((*data.begin()).second, 0.0, AcDb::kInvisible);
						poly.AppendNode(pt2);
					}
				}

				break;
			}
			else if (!bLink1 && !bLink2) // 两点都与poly2d不相连
			{
				AcGePoint3dArray ptArr;
				AcDbCurve *pCurve = poly2d.AsAcDbCurve();
				if (pCurve != NULL)
				{
					pCurve->intersectWith(&line, AcDb::kOnBothOperands, ptArr);
					if (ptArr.length() == 1)
					{
						poly.AppendNode(pt1);
						poly.AppendNode(pt2);
						break;
					}
					else if (ptArr.length() == 2)
					{
						double dDist1 = 0.0, dDist2 = 0.0;
						dDist1 = pt1.Distance(ptArr[0]);
						dDist2 = pt1.Distance(ptArr[1]);
						if(dDist2 > dDist1)
						{
							poly.AppendNode(pt1);
							poly.AppendNode(asDblArray(ptArr[0]), 0.0, AcDb::kInvisible);
							poly.AppendNode(pt2);
						}
						else
						{
							poly.AppendNode(pt1);
							poly.AppendNode(asDblArray(ptArr[1]), 0.0, AcDb::kInvisible);
							poly.AppendNode(pt2);
						}
						
						dDist1 = pt2.Distance(ptArr[0]);
						dDist2 = pt2.Distance(ptArr[1]);
						if(dDist2 > dDist1)
						{
							poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
							poly.AppendNode(asDblArray(ptArr[0]));
							poly.AppendNode(pt2);
						}
						else
						{
							poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
							poly.AppendNode(asDblArray(ptArr[1]));
							poly.AppendNode(pt2);
						}
						break;
					}
				}
			}

			if (poly.Length() == 0)
			{
				poly.AppendNode(pt1, 0.0, AcDb::kInvisible);
				poly.AppendNode(pt2);
			}
		}
	}
}

void TDbStruBeam::GetCoverSlab(AcDbObjectIdArray& idArr) const
{
	//modify by cet	111206 多边形时部分遮挡有问题
	//TBaseWallLine baseWallLine;
	//GetThisBaseWallLine(baseWallLine);
	//TGGeVisibilityPoly2D left = baseWallLine.GetLeftLine();
	//TGGeVisibilityPoly2D right = baseWallLine.GetRightLine();
	//left.SetElevation(0.0);
	//right.SetElevation(0.0);
	//AcDbPolyline *pLeft = static_cast<AcDbPolyline*>(left.AsAcDbCurve());
	//if (pLeft == NULL)
	//{
	//	return;
	//}
	//
	//AcDbPolyline *pRight = static_cast<AcDbPolyline*>(right.AsAcDbCurve());
	//if (pRight == NULL)
	//{
	//	return;
	//}
	//
	//AcGePoint3dArray ptArrLeft, ptArrRight;
	//AcGePoint3d pt;
	//GetAt(KEY_START, pt);
	//double dBeamEle = pt.z;
	//for (int i = 0; i < m_arSlabIds.length(); i++)
	//{
	//	TDbStruFloorSlab *pSlab = NULL;
	//	acdbOpenObject(pSlab, m_arSlabIds[i], AcDb::kForRead);
	//	if (pSlab != NULL)
	//	{
	//		double dSlabElev = pSlab->GetTopElev();
	//		if (dSlabElev > dBeamEle || fabs(dSlabElev - dBeamEle) < _DIST_SNAP)
	//		{
	//			TGGePoly2D poly;
	//			pSlab->GetOutline(poly);
	//			poly.SetElevation(0.0);
	//			AcDbPolyline *pLine = static_cast<AcDbPolyline*>(poly.AsAcDbCurve());
	//			if (pLine != NULL)
	//			{
	//				ptArrLeft.setLogicalLength(0);
	//				ptArrRight.setLogicalLength(0);
	//				pLine->intersectWith(pLeft, AcDb::kOnBothOperands, ptArrLeft);
	//				pLine->intersectWith(pRight,AcDb::kOnBothOperands, ptArrRight);
	//				
	//				if (ptArrLeft.length() > 0 || ptArrRight.length() > 0)
	//				{
	//					idArr.append(m_arSlabIds[i]);
	//				}
	//				delete pLine;
	//			}
	//		}
	//		pSlab->close();
	//	}
	//}
	//
	//delete pLeft;
	//delete pRight;
	TGGePoly2D poly;
	GetPoly2D(poly);
	poly.SetElevation(0.0);
	AcDbPolyline *pWallLine = static_cast<AcDbPolyline*>(poly.AsAcDbCurve());
	if (pWallLine == NULL)
	{
		return;
	}

	AcGePoint3dArray ptArr;
	AcGePoint3d pt;
	GetAt(KEY_START, pt);
	double dBeamEle = pt.z;
	for (int i = 0; i < m_arSlabIds.length(); i++)
	{
		TDbStruFloorSlab *pSlab = NULL;
		acdbOpenObject(pSlab, m_arSlabIds[i], AcDb::kForRead);
		if (pSlab != NULL)
		{
			double dSlabElev = pSlab->GetTopElev();
			if (dSlabElev > dBeamEle || fabs(dSlabElev - dBeamEle) < _DIST_SNAP)
			{
				TGGePoly2D poly;
				pSlab->GetOutline(poly);
				poly.SetElevation(0.0);
				AcDbPolyline *pLine = static_cast<AcDbPolyline*>(poly.AsAcDbCurve());
				if (pLine != NULL)
				{
					ptArr.setLogicalLength(0);
					pLine->intersectWith(pWallLine, AcDb::kOnBothOperands, ptArr);

					if (ptArr.length() > 0)
					{
						idArr.append(m_arSlabIds[i]);
					}
					delete pLine;
				}
			}
			pSlab->close();
		}
	}
	delete pWallLine;
}

Acad::ErrorStatus TDbStruBeam::DrawBeamLine2dForCoverSlab(TGGiExplodeDrawBase &dc, const TGGeVisibilityPoly2D &poly) const
{
	AcDbObjectIdArray idArr;
	GetCoverSlab(idArr);
	TGGeCurveSegment seg;
	AcDb::Visibility eVal;
	TDbStruFloorSlab *pSlab = NULL;
	TGGePoly2D polySlab;
	std::vector<TGGeCurveSegment> vecSeg1, vecSeg2; // 保存生成的实线虚线
	for (int i = 0; i < poly.TotalSegments(); i++)
	{
		poly.Nth(i, seg, &eVal);
		if (eVal == AcDb::kVisible)
		{
			for (int j = 0; j < idArr.length(); j++)
			{
				acdbOpenObject(pSlab, idArr[j], AcDb::kForRead);
				if (pSlab != NULL)
				{
					polySlab.Reset();
					pSlab->GetOutline(polySlab);
					pSlab->close();
					polySlab.SetElevation(0.0);
					GetSegmentForSlab2d(polySlab, seg, vecSeg1, vecSeg2);
				}
			}
		}
	}
	
	// 过滤，剪切实线虚线 
	FiltrateSegment(vecSeg1, vecSeg2);
	
	std::vector<TGGeCurveSegment>::iterator it;
	for (it = vecSeg1.begin(); it < vecSeg1.end(); it++)
	{
		dc << *it;
	}
	
	//Adesk::UInt16 nColor = dc.GetColor();
	//dc.SetColor(1);
	
	AcDbObjectId idOldLine = dc.GetLineTypeId();
	dc.SetLineType(InitLineType(_T("DASHED"),database()));

	for (it = vecSeg2.begin(); it < vecSeg2.end(); it++)
	{
		dc << *it;
	}
	//dc.SetColor(nColor);
	dc.SetLineType(idOldLine);

	return Acad::eOk;
}

void TDbStruBeam::GetClipedPoly2d(std::vector<TGGePoly2D> &vecPoly) const
{
	TGGePoly2D poly2d;
	TDbColumn *pStruColumn = NULL;
	for (int i = 0; i < m_arColumnIds.length(); i++) 
	{
		acdbOpenObject(pStruColumn, m_arColumnIds[i], AcDb::kForRead);
		if (pStruColumn != NULL)
		{
			poly2d.Reset();
			pStruColumn->GetOutline(poly2d);
			vecPoly.push_back(poly2d);
			pStruColumn->Close();
		}
	}

	// 获得起点终点标高
	double dEleS = 0.0, dEleE = 0.0;
	AcGePoint3d ptS, ptE;
	GetAt(KEY_START, ptS);
	GetAt(KEY_END, ptE);
	dEleS = ptS.z;
	dEleE = ptE.z;	
	
	double dH = GetSection2dHeight(); // 截面高度
	int nIntegrateType = DocGetBeamRelCtl();//融合方式
	TDbStruBeam *pBeam = NULL;
	
	for(i = 0; i < m_arAssocBWallIds.length(); i++)
	{
		acdbOpenObject(pBeam, m_arAssocBWallIds[i], AcDb::kForRead);
		if (pBeam != NULL)
		{
			// 获得起点终点标高
			pBeam->GetAt(KEY_START, ptS);
			pBeam->GetAt(KEY_END, ptE);
			double dEleS1 = 0.0, dEleE1 = 0.0;
			dEleS1 = ptS.z;
			dEleE1 = ptE.z; 
			double dH2 = pBeam->GetSection2dHeight();
			pBeam->close();

			if (!nIntegrateType &&fabs(dEleS - dEleS1) < _DIST_SNAP && fabs(dEleE - dEleE1) < _DIST_SNAP) // 等标高
			{
				if (dH < dH2)
				{
					poly2d.Reset();
					pBeam->GetPoly2dBehindIntegrate(poly2d);
					vecPoly.push_back(poly2d);
				}
			}
		}
	}
}

void TDbStruBeam::AssociateMove( const AcDbIntArray& indices, const AcGeVector3d& offset )
{
	AcGePoint3d ptS;
	GetAt(KEY_START, ptS);
	AcGePoint3d ptE;
	GetAt(KEY_END, ptE);
	double dBulge = 0.0;
	GetAt(KEY_BULGE, dBulge);

	// 限制在平面移动
	AcGeVector3d vtOffset = offset;
	vtOffset.z = 0.0;

	int nIndex = indices[0];
	if (nIndex == 0) // 起点
	{
		// 将拖动方向限制在剪力墙方向
		if (fabs(dBulge) < g_angleZero) // 直线 沿线方向拉伸缩短
		{
			TGGeLine line(asDblArray(ptS), asDblArray(ptE));
			TADSGePoint3d ptTemp;
			ptTemp = ptS + vtOffset;
			ptTemp.Project(&line, ptTemp);
			vtOffset = ptTemp - ptS;
			ptS += vtOffset; 
			SetAt(KEY_START, ptS);
		}
		else // 弧线 沿弧拉伸缩短
		{
			TADSGePoint3d ptStart = ptS, ptEnd = ptE, ptMid;
			TGGeArc arc(ptStart, ptEnd, dBulge);
			ptMid = arc.MidPoint();
			TADSGePoint3d ptCenter;
			arc.Center(ptCenter);
			TGGeCircle cir(ptCenter, arc.GetRadius());
			ptStart += vtOffset; 
			ptStart.Project(&cir,ptStart);
			arc.Set(ptStart, ptMid, ptEnd);
			SetAt(KEY_START, ptStart.AsAcGePoint3d());
			SetAt(KEY_BULGE, arc.Bulge());
		}
	} 
	else if (nIndex == 1) // 终点 
	{
		// 将拖动方向限制在剪力墙方向
		if (fabs(dBulge) < g_angleZero) // 直线 沿线方向拉伸缩短
		{
			TGGeLine line(asDblArray(ptS), asDblArray(ptE));
			TADSGePoint3d ptTemp;
			ptTemp = ptE + vtOffset;
			ptTemp.Project(&line, ptTemp);
			vtOffset = ptTemp - ptE;
			ptE += vtOffset;
			SetAt(KEY_END, ptE);
		}
		else // 弧线 沿弧拉伸缩短
		{
			TADSGePoint3d ptStart = ptS, ptEnd = ptE, ptMid;
			TGGeArc arc(ptStart, ptEnd, dBulge);
			ptMid = arc.MidPoint();
			TADSGePoint3d ptCenter;
			arc.Center(ptCenter);
			TGGeCircle cir(ptCenter, arc.GetRadius());
			ptEnd += vtOffset; 
			ptEnd.Project(&cir,ptEnd);
			arc.Set(ptStart, ptMid, ptEnd);
			SetAt(KEY_END, ptEnd.AsAcGePoint3d());
			SetAt(KEY_BULGE, arc.Bulge());
		}
	}
	else if (nIndex == 2) // 中点
	{
		if (fabs(dBulge) < g_angleZero) // 直线 关联平行移动
		{
			// 限制移动方向
			TADSGePoint3d pt = ptS + vtOffset, pt2;
			TGGeLine line(asDblArray(ptS), asDblArray(ptE));
			pt.Project(&line, pt2);
			vtOffset = pt - pt2; 
			vtOffset.z = 0;

			ptS += vtOffset;
			SetAt(KEY_START, ptS);
			ptE += vtOffset;
			SetAt(KEY_END, ptE);

			// 拖拽结束时发送消息
			if (objectId())
			{
				TAssocMsg msg;
				msg.SetMethod(TAssocMsg::kMovegrippoint);
				msg.SetTarget(line.MidPoint());
				msg.SetOffset(vtOffset);
				msg.SetAssocId(objectId());

				AddMsg(msg);
			}
		}
		else // 弧线 改变半径
		{
			TADSGePoint3d ptStart = ptS, ptEnd = ptE, ptMid;
			TGGeArc arc(ptStart, ptEnd, dBulge);
			ptMid = arc.MidPoint();
			TADSGePoint3d ptCenter;
			arc.Center(ptCenter);
			TGGeLine line(ptCenter, ptMid);
			ptMid += vtOffset;
			ptMid.Project(&line, ptMid);
			if (ptMid.Distance(ptCenter) > _DIST_SNAP)
			{
				AcGeVector3d vt1 = ptS - ptCenter.AsAcGePoint3d(), vt2 = ptE - ptCenter.AsAcGePoint3d();
				double dAngle = vt1.angleTo(vt2, AcGeVector3d::kZAxis);
				vt1 = ptMid - ptCenter;
				ptStart = ptCenter + vt1.rotateBy(-dAngle * 0.5, AcGeVector3d::kZAxis);
				ptEnd = ptCenter + vt1.rotateBy(dAngle, AcGeVector3d::kZAxis);
				arc.Set(ptStart, ptMid, ptEnd);
				SetAt(KEY_START, ptStart.AsAcGePoint3d());
				SetAt(KEY_END, ptEnd.AsAcGePoint3d());
				SetAt(KEY_BULGE, arc.Bulge());
			}
		}
	}
}

void TDbStruBeam::SingleMove( const AcDbIntArray& indices, const AcGeVector3d& offset )
{
	if (m_arHoleIds.length() > 0) // 有洞时不移动
	{
		return;
	}

	AcGePoint3d ptS;
	GetAt(KEY_START, ptS);
	AcGePoint3d ptE;
	GetAt(KEY_END, ptE);
	double dBulge = 0.0;
	GetAt(KEY_BULGE, dBulge);

	// 限制在平面移动
	AcGeVector3d vtOffset = offset;
	vtOffset.z = 0.0;

	int nIndex = indices[0];
	if (nIndex == 0) // 起点 改变端点位置
	{
		ptS += vtOffset;
		SetAt(KEY_START, ptS);
	} 
	else if (nIndex == 1) // 终点 改变端点位置
	{
		ptE += vtOffset;
		SetAt(KEY_END, ptE);
	}
	else if (nIndex == 2) // 中点
	{
		if (fabs(dBulge) < g_angleZero) // 直线 独立平行移动
		{
			ptS += vtOffset;
			SetAt(KEY_START, ptS);
			ptE += vtOffset;
			SetAt(KEY_END, ptE);
		}
		else // 弧线 改变位置
		{
			TADSGePoint3d ptStart = ptS, ptEnd = ptE, ptMid;
			TGGeArc arc(ptStart, ptEnd, dBulge);
			ptMid = arc.MidPoint();
			ptMid += vtOffset;

			TGGeArc arcNew(ptStart, ptMid, ptEnd); // 移动后的新弧
			arcNew.GetStartPoint(ptStart);
			arcNew.GetEndPoint(ptEnd);
			dBulge = arcNew.Bulge();
			ptS = ptStart;
			ptE = ptEnd;
			SetAt(KEY_START, ptS);
			SetAt(KEY_END, ptE);
			SetAt(KEY_BULGE, dBulge);
		}
	}
}

void TDbStruBeam::GetTotalWidth(double &dWidth)const
{
	int nSecTyp = 0;
	GetAt(KEY_SECTYP, nSecTyp);

	dWidth = 0;
	switch (nSecTyp)
	{
	case ST_RECT:
		GetAt(KEY_B, dWidth);
		break;
	case ST_IBEAM:
		{
			double dU(0),dD(0);	//工形截面上下翼缘宽度
			GetAt(KEY_U, dU);
			GetAt(KEY_D, dD);

			dWidth = dU > dD ? dU : dD;
		}
		break;
	default:
		break;
	}
}

// 获得总高度
void TDbStruBeam::GetTotalHeight(double &dHeight)const
{
	int nSecTyp = 0;
	GetAt(KEY_SECTYP, nSecTyp);

	dHeight = 0;
	switch (nSecTyp)
	{
	case ST_RECT:
	case ST_IBEAM:
		GetAt(KEY_H, dHeight);
		break;
	default:
		break;
	}
}

// 梁标注
void TDbStruBeam::DrawBH(TGGiExplodeDrawBase &dc) const
{
	TDbText text;
	if (m_idLayerDim.isValid())
	{
		text.setLayer(m_idLayerDim);
	}

	AcDbObjectId idBHStyl = DocGetBeamBHStyle();
	if(idBHStyl.isNull())
	{
		idBHStyl = InitTextStyle(TS_STANDARD);
	}
	text.SetStyleId(idBHStyl);					// 设置文字样式

	text.SetHeight(DocGetBeamBHHigh());			// 设置尺寸文字高度			

	text.setColorIndex(DocGetBeamBHColor());	// 设置尺寸文字颜色

	text.SetAlignment(XExplodeDraw::kCenter);	// 设置文字的对齐方式

	double dWidth = GetSection2dWidth();		// 得到梁截面的宽度
	double dHeight = GetSection2dHeight();		// 得到梁截面的高度

	//add by xlc on 140421  截面尺寸考虑轴转角的影响
	double dAxis(0.0);
	GetAt(KEY_AXANG,dAxis);
	double dVal = fabs(cos(dAxis));
	if(dVal < g_fZero)
	{
		double dTmp = dWidth;
		dWidth = dHeight;
		dHeight = dTmp;
	}
	else
	{
		dWidth = dWidth/dVal;
		dHeight = dHeight/dVal;
	}

	CString strHeight, strWidth;
	strHeight = Dist2Str(dHeight);
	strWidth = Dist2Str(dWidth);

	CString strText;
	strText.Format(_T("%s×%s"), strWidth, strHeight);
	text.SetText(strText);						// 设置显示内容

	TADSGePoint3d ptMid;
	AcGePoint3d  ptStart, ptEnd;
	GetAt(KEY_START, ptStart);					// 得到梁的起始位置
	GetAt(KEY_END, ptEnd);						// 得到梁的终止位置

	double dBulge = 0.0;
	GetAt(KEY_BULGE, dBulge);

	double dDis = (DocGetBeamBHDist() * GetPScale());// 得到文字到梁的距离考虑图纸比例
	double dBeamWidth;
	GetTotalWidth(dBeamWidth);					// 得到梁的宽度

	double dTextDis = dBeamWidth/2+dDis;		// 考虑到文字显示位置(梁形心为文字的对齐点)所以距离为梁的一半宽度加上距离


	ads_real angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd));	// 与x轴的夹角
	if (angle - PI < g_angleZero)				// 0-180度之间
	{
		if(angle - PI/2 > g_angleZero)			// 90-180度时文字的显示角度
		{
			angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));

			if(fabs(dBulge) > g_angleZero)		// 弧梁
			{
				dTextDis = -dTextDis;
			}
		}
	}
	else										// 180-360度之间
	{
		if(angle - 3*PI/2 < g_angleZero)		// 180-270度时文字的显示角度
		{
			angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));

			if(fabs(dBulge) > g_angleZero)		// 弧梁
			{
				dTextDis = -dTextDis;
			}
		}
	}
	text.SetRotation(angle);					// 设置文字旋转角度
	
	TADSGePoint3d ptTextAlign;
	if(fabs(dBulge) > g_angleZero)
	{
		TGGeCurveSegment cvsegCenter = GetCenterLine();		 // 得到梁的中心线
		TADSGePoint3d ptCenter = cvsegCenter.GetArc().GetCenterPt();// 得到弧墙的圆心
		TADSGePoint3d ptMid = cvsegCenter.MidPoint();				 // 得到中心线的中心点
		double dBeamAngle = ads_angle(ptMid, ptCenter);		 // 得到中心线的中点和圆心与x轴的角度
		ptTextAlign = TADSGePoint3d(ptMid, dBeamAngle, dTextDis);	 // 得到文字的显示位置
	}
	else
	{
		Midpoint(ptStart, ptEnd, ptTextAlign);	// 得到梁的中点
		ptTextAlign = TADSGePoint3d(ptTextAlign, angle+PI/2, dTextDis);//与梁垂直方向
	}

	text.SetLocation(ptTextAlign);				// 设置文字的插入位置				

	TPushProperty vProp(&text, dc);
	if (dc.IsFullExplode())
	{
		text.ExplodeOrDraw2d(dc);
	}
	else
	{
		dc.DrawEntity(text);
	}					
}

// 构件编号
void TDbStruBeam::DrawClab(TGGiExplodeDrawBase &dc) const
{
	TDbText text;
	text.setPropertiesFrom(this);

	AcDbObjectId idCLStyl = DocGetBeamCLStyle();
	if(idCLStyl.isNull())
	{
		idCLStyl = InitTextStyle(TS_STANDARD);
	}
	text.SetStyleId(idCLStyl);					// 设置文字样式

	text.SetHeight(DocGetBeamCLHigh());			// 设置文字高度			

	text.setColorIndex(DocGetBeamCLColor());	// 设置文字颜色

	text.SetAlignment(XExplodeDraw::kTopCenter);// 设置文字对齐方式
	
	CString strText;
	GetAt(KEY_CLAB, strText);					// 得到梁的构件编号
	text.SetText(strText);						// 设置文字显示内容

	AcGePoint3d  ptStart, ptEnd;
	GetAt(KEY_START, ptStart);
	GetAt(KEY_END, ptEnd);

	double dBeamWidth;
	GetTotalWidth(dBeamWidth);					// 得到梁宽
	double dDis = dBeamWidth/2;

	double dBulge = 0.0;	
	GetAt(KEY_BULGE, dBulge);					// 得到梁的凸度,根据凸度判断是否是弧梁

	// 计算文字的旋转角度
	ads_real angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd));// 与x轴的夹角
	if (angle - PI < g_angleZero)
	{
		if(angle - PI/2 > g_angleZero)			// 90-180度时文字的显示角度
		{
			angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));

			if(fabs(dBulge) > g_angleZero)		// 弧梁	
			{
				dDis = -dDis;
			}
		}
	}
	else
	{
		if(angle - 3*PI/2 < g_angleZero)		// 180-270度时文字的显示角度
		{
			angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));

			if(fabs(dBulge) > _DIST_SNAP)		// 弧梁	
			{
				dDis = -dDis;
			}
		}
	}

	TADSGePoint3d ptTextAlign;					// 墙体构件文字位置点

	if(fabs(dBulge) > _DIST_SNAP)				// 弧梁	
	{
		TGGeCurveSegment cvsegCenter = GetCenterLine();				// 得到梁的中心线
		TADSGePoint3d ptCenter = cvsegCenter.GetArc().GetCenterPt();// 得到弧梁的圆心
		TADSGePoint3d ptMid = cvsegCenter.MidPoint();				// 得到弧梁中心线的中心点
		double dBeamAngle = ads_angle(ptMid, ptCenter);				// 得到中心线的中心点和圆心得连线的角度
		ptTextAlign = TADSGePoint3d(ptMid, dBeamAngle, -dDis);		// 得到文字的插入位置
	}
	else
	{
		Midpoint(ptStart, ptEnd, ptTextAlign);						// 得到梁的中点
		ptTextAlign = TADSGePoint3d(ptTextAlign, angle+PI/2, -dDis);//与梁垂直方向
	}

	text.SetRotation(angle);
	text.SetLocation(ptTextAlign);

	//text.setLayer(DocGetBeamCLLayer());				// 设置文字图层
	if (m_idLayerNum.isValid())
	{
		text.setLayer(m_idLayerNum);
	}
	
	TPushProperty vProp(&text, dc);
	if (dc.IsFullExplode())
	{
		text.ExplodeOrDraw2d(dc);
	}
	else
	{
		dc.DrawEntity(text);
	}
}

// 单元编号
void TDbStruBeam::DrawCellNo(TGGiExplodeDrawBase &dc) const
{
	CString strCellNo;
	GetAt(KEY_CELLNO, strCellNo);

	if (strCellNo.IsEmpty())
	{
		return;
	}

	AcDbText text;
	text.setTextString(strCellNo);						// 设置文字显示内容
	if (m_idLayerNum.isValid())
	{
		text.setLayer(m_idLayerNum);
	}
	// 设置文字样式
	AcDbObjectId idNoStyl = DocGetBeamNoStyle();
	if(!idNoStyl.isNull())
	{
		text.setTextStyle(idNoStyl);					// 设置文字样式
	}
	else
	{
		text.setTextStyle(InitTextStyle(TS_STANDARD));
	}

	text.setHeight(DocGetBeamNoHigh() * GetPScale());	// 设置文字高

	text.setColorIndex(DocGetBeamNoColor());			// 设置文字颜色

	// 设置文字法向
	if(_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor())==0)
	{
		AcGiViewport &vp = ((TGGiWorldViewportDraw&)dc).m_pVd->viewport();

		AcGePoint3d ptCamera, ptTarget;
		vp.getCameraTarget(ptTarget);					// 得到目标位置点
		vp.getCameraLocation(ptCamera);					// 得到照相机位置点

		AcGeVector3d vtViewDrt = ptCamera-ptTarget;
		AcGeVector3d vtViewDir1= vp.viewDir();

		AcGeVector3d vtCamera;
		vp.getCameraUpVector(vtCamera);

		vtViewDrt.normalize();							// 单位化向量

		text.setNormal(vtViewDrt);						// 设置文字法向
	}

	TGGeCurveSegment cvCenter = GetCenterLine();		// 得到梁的中心线
	TADSGePoint3d ptNoDist = cvCenter.MidPoint();	// 得到梁中心线的中心点
	
	double dBeamWidth;
	GetTotalWidth(dBeamWidth);							// 得到梁的宽
	dBeamWidth /= 2;

	ptNoDist.y += dBeamWidth;
	ptNoDist.y += DocGetBeamNoDist() * GetPScale();		// 设置文字到梁的距离

	text.setPosition(ptNoDist);							// 设置文字显示位置
	text.setHorizontalMode(AcDb::kTextCenter);			// 设置文字的对齐方式

	dc.DrawEntity(text);								// 画文字对象
}

// 刚域
void TDbStruBeam::DrawRG(TGGiExplodeDrawBase &dc) const
{
	double dRGI, dRGJ;
	bool bI = GetAt(KEY_RIGIDI, dRGI);
	bool bJ = GetAt(KEY_RIGIDJ, dRGJ);

	if(!bI && !bJ)
	{
		return;
	}

	CString strRGI, strRGJ;
	AcDbText text;
	if (m_idLayerText.isValid())
	{
		text.setLayer(m_idLayerText);
	}
	// 设置文字样式
	AcDbObjectId idRGStyl = DocGetBeamRGStyle();
	if(!idRGStyl.isNull())
	{
		text.setTextStyle(idRGStyl);
	}
	else
	{
		text.setTextStyle(InitTextStyle(TS_STANDARD));
	}

	text.setHeight(DocGetBeamRGHigh() * GetPScale());// 设置文字高度		

	text.setColorIndex(DocGetBeamRGColor());		 // 设置文字颜色

	// 设置文字法向
	if(_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor())==0)
	{
		AcGiViewport &vp = ((TGGiWorldViewportDraw&)dc).m_pVd->viewport();

		AcGePoint3d ptCamera, ptTarget;
		vp.getCameraTarget(ptTarget);
		vp.getCameraLocation(ptCamera);

		AcGeVector3d vtViewDrt = ptCamera-ptTarget;
		AcGeVector3d vtViewDir1= vp.viewDir();

		AcGeVector3d vtCamera;
		vp.getCameraUpVector(vtCamera);

		vtViewDrt.normalize();

		text.setNormal(vtViewDrt);
	}

	TADSGePoint3d ptNoDist;
	AcGePoint3d  ptStart, ptEnd;


	if(bI)
	{
		GetAt(KEY_START, ptStart);
		ptStart.x -= DocGetBeamRGDist() * GetPScale();	// 设置文字到梁的距离

		text.setPosition(ptStart);						// 设置文字位置
		text.setHorizontalMode(AcDb::kTextLeft);		// 设置文字的对齐方式
		strRGI = TrimDoubleZero(dRGI);
		text.setTextString(strRGI);						// 设置文字显示内容
		dc.DrawEntity(text);							// 画该对象
	}

	if(bJ)
	{
		GetAt(KEY_END, ptEnd);
		strRGJ = TrimDoubleZero(dRGJ);
		text.setTextString(strRGJ);						// 设置文字显示内容

		ptEnd.x += DocGetBeamRGDist() * GetPScale();	// 设置文字到梁的距离

		text.setPosition(ptEnd);						// 设置文字显示位置
		text.setHorizontalMode(AcDb::kTextRight);		// 设置文字对齐方式

		dc.DrawEntity(text);							// 画该对象
	}
}

//铰接属性
//返回值 0：普通梁，1:一端铰梁,2:两端铰梁
int TDbStruBeam::GetHinge()const
{
	assertReadEnabled();
	int nHingeNum(0);			
	int	nHinge(0);
	if(GetAt(KEY_HINGE, nHinge))
	{
		nHingeNum += ((nHinge & HINGE_START) != 0);
		nHingeNum += ((nHinge & HINGE_END) != 0);
	}
	return nHingeNum;
}

//梁两端的铰接属性
BOOL TDbStruBeam::GetHinge(BOOL bStart)
{
	assertReadEnabled();
	
	BOOL bTrue = FALSE;

	int	nHinge(0);
	if(GetAt(KEY_HINGE, nHinge))
	{
		if(bStart)
		{
			bTrue = ((nHinge & HINGE_START) != 0);
		}
		else
		{
			bTrue = ((nHinge & HINGE_END) != 0);
		}
	}
	return bTrue;
}

void TDbStruBeam::SetHinge(BOOL bStart, BOOL bTrue)
{
	assertReadEnabled();
	int nHingeNum(0);			
	int	nHinge(0);

	GetAt(KEY_HINGE, nHinge);
	if(bStart)
	{
		if(bTrue)
		{
			nHinge |= HINGE_START;
		}
		else
		{
			nHinge &= ~HINGE_START;
		}
	}
	else
	{
		if(bTrue)
		{
			nHinge |= HINGE_END;
		}
		else
		{
			nHinge &= ~HINGE_END;
		}
	}
	SetAt(KEY_HINGE, nHinge);
}

// add by wjx on 111220
// 功能:得到中心线的中心点和圆心得连线的角度和距离
// [in]:dDis: 到梁边的距离
// return: 中心线的中点和圆心连线的角度
double TDbStruBeam::GetCenetrAngle(double &dDis) const
{
	double dBulge = 0.0;	
	GetAt(KEY_BULGE, dBulge);					// 得到梁的凸度,根据凸度判断是否是弧梁

	AcGePoint3d  ptStart, ptEnd;
	GetAt(KEY_START, ptStart);
	GetAt(KEY_END, ptEnd);

// 	double dBeamWidth;
// 	GetTotalWidth(dBeamWidth);					// 得到梁宽
// 	dDis += dBeamWidth/2;

	// 计算文字的旋转角度
	ads_real angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd));// 与x轴的夹角
	if (angle - PI < g_angleZero)
	{
		if(angle - PI/2 > g_angleZero)			// 90-180度时文字的显示角度
		{
			angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));

			if(fabs(dBulge) > g_angleZero)		// 弧梁	
			{
				dDis = -dDis;
			}
		}
	}
	else
	{
		if(angle - 3*PI/2 < g_angleZero)		// 180-270度时文字的显示角度
		{
			angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));

			if(fabs(dBulge) > _DIST_SNAP)		// 弧梁	
			{
				dDis = -dDis;
			}
		}
	}

	double dBeamAngle = 0;
	if(fabs(dBulge) > _DIST_SNAP)				// 弧梁	
	{
		TGGeCurveSegment cvsegCenter = GetCenterLine();				// 得到梁的中心线
		TADSGePoint3d ptCenter = cvsegCenter.GetArc().GetCenterPt();// 得到弧梁的圆心
		TADSGePoint3d ptMid = cvsegCenter.MidPoint();				// 得到弧梁中心线的中心点
		dBeamAngle = ads_angle(ptMid, ptCenter);				// 得到中心线的中心点和圆心得连线的角度
	}
 	else
 	{
		dBeamAngle = angle+PI/2;
 	}

	return dBeamAngle;
}
// add by wjx on 111220
// 确定左右端点,以x方向和y方向确定
// [in]: ptStart:梁的起始点
// [in]: ptEnd:梁的终止点
// return: 是否交换梁的起始点和终止点
BOOL TDbStruBeam::GetLRPoint(XPoint &ptStart, XPoint &ptEnd)const
{
	bool bSEFlag = true;			// 取起始点的标志
	if (fabs(ptStart.x - ptEnd.x) < _DIST_SNAP)	// 竖向
	{
		if(ptStart.y - ptEnd.y > _DIST_SNAP)
		{
			XPoint ptTemp = ptStart;
			ptStart = ptEnd;
			ptEnd = ptTemp;
			bSEFlag = false;
		}
	}
	else if(ptStart.x - ptEnd.x > _DIST_SNAP)				// 横向
	{
		XPoint ptTemp = ptStart;
		ptStart = ptEnd;
		ptEnd = ptTemp;
		bSEFlag = false;
	}
	return bSEFlag;
}

// add by wjx on 111219
// 功能: 显示梁的荷载信息
void TDbStruBeam::DrawBeamLoad(TGGiExplodeDrawBase &dc) const
{
	//if(NULL == g_pStruSubProject)
	//{
	//	return;
	//}

	//add by xlc on 120112荷载显示控制
	BOOL bShowGraphic = false;		//显示图形
	BOOL bShowLive = false;			//显示活荷
	BOOL bShowUnLive = false;		//显示恒荷

	if(g_nLoadDrawMode == BYOBJLOAD)
	{
		bShowGraphic = true;
		bShowLive = bShowUnLive = DocGetShowLoadPara();
	}
	else
	{
		bShowGraphic = GetViewStyle(BYGRAPHIC);
		bShowLive = GetViewStyle(BYVARYING);
		bShowUnLive = GetViewStyle(BYUNVARYING);
	}

	//都不显示时直接返回
	if (!(bShowGraphic||bShowLive||bShowUnLive))
	{
		return;
	}

// 	AcDbHandle hBeam;
// 	getAcDbHandle(hBeam);
// 	int nHandle = hBeam.low();
	// 
	// 	// 在自然层中找到该句柄对应的荷载信息
	// 	int nSize = g_pStruSubProject->m_vecFloorData.size();// 自然层数
	// 	int nLoadSize = 0;						// 自然层中荷载数量
	// 	TStruEntLoads entLoad;
	// 	bool bFind = false;						// 是否找到梁的荷载信息
	// 	for(int i = 0; i < nSize; i++)
	// 	{
	// 		nLoadSize = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads.size();
	// 		for (int j = 0; j < nLoadSize; j++)
	// 		{
	// 			entLoad = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j];
	// 
	// 			if (entLoad.GetEntHandle().low() == nHandle)
	// 			{
	// 				bFind = true;				// 找到自然层中梁的荷载

	// 得到荷载数据
	// 				int nLoadInfoCount = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j].m_vecLoads.size();
	std::vector<TStruLoad> vecLoad;
	bool bl = GetLoadsArray(vecLoad);
	
	// 				int nLoadInfoCount = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j].m_vecLoads.size();
	int nLoadInfoCount = vecLoad.size();
	if(nLoadInfoCount < 1)
	{
		return;
	}

	TStruLoad loadData;

	// 画荷载图形
	TGGeCurveSegment segCenter = GetCenterLine();
	segCenter.SetElevation(0.0);
	XPoint ptStart = segCenter.StartPoint();
	XPoint ptEnd = segCenter.EndPoint();
	BOOL bSwtchSEFlag = GetLRPoint(ptStart, ptEnd);
	
	//int nColorOld = dc.GetColor();
	//dc.SetColor(1);
	TPushProperty vProp(this, dc);
	if (m_idLayerLoad.isValid())
	{
		dc.SetLayer(m_idLayerLoad);
	}

	// 计算移动方向
	double dLoadDis = 0.0;	  // 荷载到梁的距离
	double dAugle = 0.0;
	TADSGePoint3d ptMid = segCenter.MidPoint();				// 得到梁中心线的中心点
	XPoint ptInsert;
	ads_matrix mat;
	double dLoadLen = segCenter.GetLength();
	double dTextDis = 300.0;					// 文字到线的距离
	// 画图形和荷载信息
	for(int k = 0; k < nLoadInfoCount; k++)
	{
		// 					loadData = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j].m_vecLoads[k];
		loadData = vecLoad[k];

		// modify by wjx on 120313 修改原因:根据荷载的实际数据显示荷载图
		if(bShowGraphic)
		{
			TGGeCurveSegment segSub, segTemp;
			XPoint ptSToCenter, ptEtoCenter;	// 映射到中心线上的点
			switch (loadData.GetLoadType())
			{
			case TStruLoad::LT_ALL_H:
				dLoadDis = 100.0;				// 荷载到梁的距离
				dAugle = GetCenetrAngle(dLoadDis);
				ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
				ptMid.GetMoveMatrix(ptInsert, mat);
				
				segTemp = segCenter;
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);
				break;
			case TStruLoad::LT_LEFT:
				dLoadDis = 150.0;				// 荷载到梁的距离
				dAugle = GetCenetrAngle(dLoadDis);
				ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
				ptMid.GetMoveMatrix(ptInsert, mat);

// 				segCenter.GetSubSegment(ptStart, dLoadLen/4, segTemp);
// 				segCenter.GetSubSegment((bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint(), 
// 					dLoadLen/4, segSub);
				segCenter.GetSubSegment(ptStart, loadData.GetPara1() * 1000, segTemp);
				segCenter.GetSubSegment((bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint(), 
					loadData.GetPara1() * 1000, segSub);

				segSub.TransformBy(mat);
				dc.DrawCurve(segSub);

				segTemp = segSub;

				ptSToCenter = segTemp.GetStartPoint();
				segCenter.ProjectToMe(ptSToCenter, ptSToCenter);
				segSub = TGGeCurveSegment(ptSToCenter, segTemp.GetStartPoint(), 0);
				dc.DrawCurve(segSub);

				ptEtoCenter = segTemp.GetEndPoint();
				segCenter.ProjectToMe(ptEtoCenter, ptEtoCenter);
				segSub = TGGeCurveSegment(ptEtoCenter, segTemp.GetEndPoint(), 0);
				dc.DrawCurve(segSub);
				break;
			case TStruLoad::LT_RIGHT:
				dLoadDis = 150.0;				// 荷载到梁的距离
				dAugle = GetCenetrAngle(dLoadDis);
				ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
				ptMid.GetMoveMatrix(ptInsert, mat);

// 				segCenter.GetSubSegment(ptEnd, dLoadLen/4, segTemp);
// 				segCenter.GetSubSegment((!bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint(), 
// 					dLoadLen/4, segSub);
				segCenter.GetSubSegment(ptEnd, loadData.GetPara1() * 1000, segTemp);
				segCenter.GetSubSegment((!bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint(), 
					loadData.GetPara1() * 1000, segSub);
				segSub.TransformBy(mat);
				dc.DrawCurve(segSub);

				segTemp = segSub;

				ptSToCenter = segTemp.GetStartPoint();
				segCenter.ProjectToMe(ptSToCenter, ptSToCenter);
				segSub = TGGeCurveSegment(ptSToCenter, segTemp.GetStartPoint(), 0);
				dc.DrawCurve(segSub);

				ptEtoCenter = segTemp.GetEndPoint();
				segCenter.ProjectToMe(ptEtoCenter, ptEtoCenter);
				segSub = TGGeCurveSegment(ptEtoCenter, segTemp.GetEndPoint(), 0);
				dc.DrawCurve(segSub);
				break;
			case TStruLoad::LT_FOCUS:
				dAugle = ads_angle(ptStart, ptEnd);
				ptStart.GetRotationMatrix(dAugle, mat);

				dLoadDis = 200.0;

// 				ptEtoCenter = XPoint(ptMid.x, ptMid.y,0);
// 				ptSToCenter = XPoint(ptMid.x, ptMid.y+dLoadDis,0);
				ptEtoCenter = XPoint(ptStart.x + loadData.GetPara1()*1000, ptStart.y,0);
				ptSToCenter = XPoint(ptEtoCenter.x, ptEtoCenter.y+dLoadDis,0);
				segTemp = TGGeCurveSegment(ptSToCenter, ptEtoCenter, 0);
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);

				segTemp = TGGeCurveSegment(ptEtoCenter, XPoint(ptEtoCenter.x-100, ptEtoCenter.y+100, 0.0), 0);
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);

				segTemp = TGGeCurveSegment(ptEtoCenter, XPoint(ptEtoCenter.x+100, ptEtoCenter.y+100, 0.0), 0);
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);
				break;
			case TStruLoad::LT_TRAPE:
				dLoadDis = 200.0;				// 荷载到梁的距离
				dAugle = GetCenetrAngle(dLoadDis);
				ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
				ptMid.GetMoveMatrix(ptInsert, mat);

				segCenter.GetSubSegment(ptMid, dLoadLen - loadData.GetPara1()*1000*2, segSub);
				segSub.TransformBy(mat);
				dc.DrawCurve(segSub);

				segTemp = segSub;

				ptSToCenter = (!bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint();
				segSub = TGGeCurveSegment(ptStart, ptSToCenter, 0);
				dc.DrawCurve(segSub);

				ptEtoCenter = (bSwtchSEFlag)? segTemp.EndPoint(): segTemp.StartPoint();
				segSub = TGGeCurveSegment(ptEnd, ptEtoCenter, 0);
				dc.DrawCurve(segSub);
				break;
			case TStruLoad::LT_TRIGON:
				dLoadDis = 200.0;				// 荷载到梁的距离
				dAugle = GetCenetrAngle(dLoadDis);
// 				ptInsert = TADSGePoint3d(ptMid, dAugle, dLoadDis);
				segCenter.GetSubSegment(ptStart, 2*(loadData.GetPara1()+loadData.GetPara2())*1000, segSub);
				ptInsert = (bSwtchSEFlag)? segSub.EndPoint(): segSub.StartPoint();
				ptInsert = TADSGePoint3d(ptInsert, dAugle, dLoadDis);

// 				segCenter.GetSubSegment(ptMid, dLoadLen/3, segSub);
				segCenter.GetSubSegment(ptStart, 2*loadData.GetPara1()*1000, segSub);

				ptSToCenter = (bSwtchSEFlag)? segSub.EndPoint(): segSub.StartPoint();
				segSub = TGGeCurveSegment(ptInsert, ptSToCenter, 0);
				dc.DrawCurve(segSub);

				segCenter.GetSubSegment(ptStart, 2*(loadData.GetPara1()+loadData.GetPara2()*2)*1000, segSub);
				ptEtoCenter = (bSwtchSEFlag)? segSub.EndPoint(): segSub.StartPoint();
				segSub = TGGeCurveSegment(ptInsert, ptEtoCenter, 0);
				dc.DrawCurve(segSub);
				break;
			case TStruLoad::LT_FOLD:
				dLoadDis = 250.0;				// 荷载到梁的距离
				dAugle = GetCenetrAngle(dLoadDis);

// 				segCenter.GetSubSegment(ptMid, dLoadLen/3, segSub);
				segCenter.GetSubSegment(ptStart, loadData.GetPara2()*2*1000, segSub);
// 				segTemp = segSub;

				ptInsert = (bSwtchSEFlag)? segSub.EndPoint(): segSub.StartPoint();
				ptSToCenter = TADSGePoint3d(ptInsert, dAugle, dLoadDis-200);
				segSub = TGGeCurveSegment(ptInsert, ptSToCenter, 0);
				dc.DrawCurve(segSub);

				segCenter.GetSubSegment(ptStart, (loadData.GetPara2()+loadData.GetPara3())*2*1000, segSub);
				ptInsert = (bSwtchSEFlag)? segSub.EndPoint(): segSub.StartPoint();
				ptEtoCenter = TADSGePoint3d(ptInsert, dAugle, dLoadDis);
				segSub = TGGeCurveSegment(ptInsert, ptEtoCenter, 0);
				dc.DrawCurve(segSub);

				segSub = TGGeCurveSegment(ptSToCenter, ptEtoCenter, 0);
				dc.DrawCurve(segSub);
				break;
			case TStruLoad::LT_MOMENT:
				dAugle = ads_angle(ptStart, ptEnd);
// 				ptMid.GetRotationMatrix(dAugle, mat);
				ptStart.GetRotationMatrix(dAugle, mat);

				dLoadDis = 200;
// 				ptEtoCenter = XPoint(ptMid.x, ptMid.y-dLoadDis/2,0);
// 				ptSToCenter = XPoint(ptMid.x, ptMid.y+dLoadDis/2,0);
				ptEtoCenter = XPoint(ptStart.x+loadData.GetPara1()*1000, ptStart.y-dLoadDis/2,0);
				ptSToCenter = XPoint(ptStart.x+loadData.GetPara1()*1000, ptStart.y+dLoadDis/2,0);
				segTemp = TGGeCurveSegment(ptSToCenter, ptEtoCenter, -PI*5/4);
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);

				segTemp = TGGeCurveSegment(ptEtoCenter, XPoint(ptEtoCenter.x+100, ptEtoCenter.y+100, 0.0), 0);
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);

				segTemp = TGGeCurveSegment(ptEtoCenter, XPoint(ptEtoCenter.x+100, ptEtoCenter.y-100, 0.0), 0);
				segTemp.TransformBy(mat);
				dc.DrawCurve(segTemp);

				break;
			}
		}

		// 显示文字
		if ((loadData.GetLoadKind() == TStruLoad::LK_VARYING && bShowLive)			//活荷
			||(loadData.GetLoadKind() == TStruLoad::LK_UNVARYING && bShowUnLive)	//恒荷
			)
		{
			dAugle = ads_angle(ptStart, ptEnd);
			DrawBeamLoadText2d(loadData, dAugle, dTextDis, dc);
		}
	}

	//dc.SetColor(nColorOld);
	// 				break;
	// 			}
	// 		}
	// 
	// 		if(bFind)
	// 		{
	// 			break;
	// 		}
	// 	}
}

// add by wjx on 111220
// 功能: 设置显示梁荷载的文字
// [in]: loadData: 荷载信息
// [in]: dAugle: 梁线与x轴的夹角
// [in]: dDis: 荷载信息显示位置到线的距离
void TDbStruBeam::DrawBeamLoadText2d(TStruLoad loadData, double dAugle, 
									 double &dDis, TGGiExplodeDrawBase &dc) const
{
	int nKind = loadData.GetLoadKind();       // 荷载种类

	//del by xlc on 120112显示控制移到外边了
	//if(!GetViewStyle(nKind))
	//{
	//	return;
	//}

	// 设置文字
	AcDbText text;
	text.setTextStyle(InitTextStyle(TS_STANDARD));
	text.setHeight(DocGetLoadTextHeight());// 设置文字高度		

	// 得到梁的中心线
	TGGeCurveSegment segCenter = GetCenterLine();
	segCenter.SetElevation(0.0);
	XPoint ptMid = segCenter.MidPoint();

	// 生成要显示的荷载文字
	int nType = loadData.GetLoadType();		  // 荷载类型
	CString strLoadInfo;
	if(nType == TStruLoad::LT_FOLD)
	{
		strLoadInfo.Format(_T("7*%s*%s*%s*%s"), TrimDoubleZero(loadData.GetValue()),
			TrimDoubleZero(loadData.GetPara1()),TrimDoubleZero(loadData.GetPara2()),
			TrimDoubleZero(loadData.GetPara3()));
	}
	else if(nType == TStruLoad::LT_TRIGON)
	{
		strLoadInfo.Format(_T("6*%s*%s*%s"), TrimDoubleZero(loadData.GetValue()),
			TrimDoubleZero(loadData.GetPara1()),TrimDoubleZero(loadData.GetPara2()));
	}
	else if(nType == TStruLoad::LT_ALL_H)
	{
		strLoadInfo.Format(_T("1*%s"), TrimDoubleZero(loadData.GetValue()));
	}
	else
	{
		strLoadInfo.Format(_T("%d*%s*%s"), nType, TrimDoubleZero(loadData.GetValue()),
												  TrimDoubleZero(loadData.GetPara1()));
	}

	text.setTextString(strLoadInfo);
	//if(nKind == TStruLoad::LK_UNVARYING)
	//{
	//	text.setColorIndex(7);
	//}
	//else if(nKind == TStruLoad::LK_VARYING)
	//{
	//	text.setColorIndex(2);
	//}
	if (nKind == TStruLoad::LK_UNVARYING)
	{
		if (m_idLayerLoadC.isValid())
		{
			text.setLayer(m_idLayerLoadC);
		}
	}
	else
	{
		if (m_idLayerLoadL.isValid())
		{
			text.setLayer(m_idLayerLoadL);
		}
	}

	double dBugle = GetCenetrAngle(dDis);	// 与梁线垂直方向与x轴夹角

	text.setRotation(dAugle);

	TADSGePoint3d ptInsert = TADSGePoint3d(ptMid, dBugle, dDis);	// 得到梁中心线的中心点
	text.setPosition(ptInsert);
	dc.DrawEntity(text);

	dDis += DocGetLoadTextHeight();
}

// 在线的中点位置画箭头
// [in]: seg:梁线
// [in]: nEdgeFlag: 0:起始点 1:中点 2:终止点
void TDbStruBeam::DrawArrow3D(TGGeCurveSegment seg, TGGiExplodeDrawBase &dc, int nEdgeFalg)const
{
	XPoint ptS;

	if(nEdgeFalg == 1)
	{
		ptS= seg.MidPoint();
	}
	else if(nEdgeFalg == 0)
	{
		ptS = seg.StartPoint();
	}
	else
	{
		ptS = seg.EndPoint();
	}

	XPoint ptPro, ptTemp;

	TGGeCurveSegment segCenter = GetCenterLine();
	segCenter.ProjectToMe(ptS, ptPro);

	TGGeCurveSegment segTemp(ptS, ptPro, 0);
	dc.DrawCurve(segTemp);

	ptTemp = ptPro;
	TGGeCurveSegment  segSub;

	seg.GetSubSegment(ptS, 200, segSub);

	segCenter.ProjectToMe(segSub.StartPoint(), ptPro);
	segTemp = TGGeCurveSegment(XPoint(ptPro.x, ptPro.y, ptPro.z+100), ptTemp, 0);
	dc.DrawCurve(segTemp);

	segCenter.ProjectToMe(segSub.EndPoint(), ptPro);
	segTemp = TGGeCurveSegment(XPoint(ptPro.x, ptPro.y, ptPro.z+100), ptTemp, 0);
	dc.DrawCurve(segTemp);
}

// add by wjx 0n 111221
// 绘制3d荷载信息
void TDbStruBeam::DrawBeamLoad3D(TGGiExplodeDrawBase &dc)const
{
	//if(NULL == g_pStruSubProject)
	//{
	//	return;
	//}

	//add by xlc on 120112荷载显示控制
	BOOL bShowGraphic = false;		//显示图形
	BOOL bShowLive = false;			//显示活荷
	BOOL bShowUnLive = false;		//显示恒荷

	if(g_nLoadDrawMode == BYOBJLOAD)
	{
		bShowGraphic = true;
		bShowLive = bShowUnLive = DocGetShowLoadPara();
	}
	else
	{
		bShowGraphic = GetViewStyle(BYGRAPHIC);
		bShowLive = GetViewStyle(BYVARYING);
		bShowUnLive = GetViewStyle(BYUNVARYING);
	}

	//都不显示时直接返回
	if (!(bShowGraphic||bShowLive||bShowUnLive))
	{
		return;
	}

	// modify by wjx on 120119 修改荷载的读取方式
	// 	AcDbHandle hBeam;
	// 	getAcDbHandle(hBeam);
	// 	int nHandle = hBeam.low();
	// 
	// 	// 在自然层中找到该句柄对应的荷载信息
	// 	int nSize = g_pStruSubProject->m_vecFloorData.size();// 自然层数
	// 	int nLoadSize = 0;						// 自然层中荷载数量
	// 	TStruEntLoads entLoad;
	// 	bool bFind = false;						// 是否找到梁的荷载信息
	// 	for(int i = 0; i < nSize; i++)
	// 	{
	// 		nLoadSize = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads.size();
	// 		for (int j = 0; j < nLoadSize; j++)
	// 		{
	// 			entLoad = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j];	
	// 			if (entLoad.GetEntHandle().low() == nHandle)
	// 			{
	// 				bFind = true;				// 找到自然层中梁的荷载
	// 				
	// 				int nColorOld = dc.GetColor();
	// 				dc.SetColor(1);
	// 
	// 				TGGeCurveSegment segCenter = GetCenterLine();// 梁的中心线
	// 				TGGeCurveSegment segSub, segCenterBak;
	// 				XPoint ptMid = segCenter.MidPoint();
	// 				XPoint ptStart = segCenter.GetStartPoint();
	// 				XPoint ptEnd = segCenter.GetEndPoint();
	// 				BOOL bSwitchSE = GetLRPoint(ptStart, ptEnd);// 确定起始点和终止点那个点在左侧或右侧
	// 				XPoint ptS, ptE, ptM;						// 荷载图像上的起始,结束,中点
	// 				ads_matrix mat;
	// 				double dLoadLen = segCenter.GetLength();
	// 				double dZ = 500;
	// 				double dAugle = ads_angle(ptStart, ptEnd);
	// 				AcDbArc arcLine;
	// 				AcGeVector3d vecNormal = AcGeVector3d(0, 0, 1);
	// 				// 得到荷载数据
	// 				int nLoadInfoCount = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j].m_vecLoads.size();
	// 				TStruLoad loadData;
	// 				
	// 				for(int k = 0; k < nLoadInfoCount; k++)
	// 				{
	// 					loadData = g_pStruSubProject->m_vecFloorData[i].m_arEntLoads[j].m_vecLoads[k];
	// 					if(bShowGraphic)
	// 					{
	// 
	// 						switch (loadData.GetLoadType())
	// 						{
	// 						case TStruLoad::LT_ALL_H:
	// 							ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+300);
	// 							ptMid.GetMoveMatrix(ptM, mat);
	// 							segCenterBak = segCenter;
	// 							segCenterBak.TransformBy(mat);
	// 							dc.DrawCurve(segCenterBak);
	// 
	// 							DrawArrow3D(segCenterBak, dc);
	// 							segCenterBak.GetSubSegment(ptM, dLoadLen/2, segSub);
	// 							DrawArrow3D(segSub, dc, 0);
	// 							DrawArrow3D(segSub, dc, 2);
	// 							DrawArrow3D(segCenterBak, dc, 0);
	// 							DrawArrow3D(segCenterBak, dc, 2);
	// 							break;
	// 						case TStruLoad::LT_LEFT:
	// 							ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
	// 							ptMid.GetMoveMatrix(ptM, mat);
	// 							segCenter.GetSubSegment(ptStart, dLoadLen/4, segCenterBak);
	// 							segCenter.GetSubSegment((bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint(), 
	// 								dLoadLen/4, segSub);
	// 							segSub.TransformBy(mat);
	// 							dc.DrawCurve(segSub);
	// 
	// 							segCenterBak = segSub;
	// 
	// 							ptM = segCenterBak.MidPoint();
	// 
	// 							DrawArrow3D(segCenterBak, dc);
	// 							segCenterBak.GetSubSegment(ptM, segCenterBak.GetLength()/2, segSub);
	// 							DrawArrow3D(segSub, dc, 0);
	// 							DrawArrow3D(segSub, dc, 2);
	// 							DrawArrow3D(segCenterBak, dc, 0);
	// 							DrawArrow3D(segCenterBak, dc, 2);
	// 							break;
	// 						case TStruLoad::LT_RIGHT:
	// 							ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
	// 							ptMid.GetMoveMatrix(ptM, mat);
	// 							segCenter.GetSubSegment(ptEnd, dLoadLen/4, segCenterBak);
	// 							segCenter.GetSubSegment((bSwitchSE)? segCenterBak.StartPoint(): segCenterBak.EndPoint(), 
	// 								dLoadLen/4, segSub);
	// 							segSub.TransformBy(mat);
	// 							dc.DrawCurve(segSub);
	// 
	// 							segCenterBak = segSub;
	// 
	// 							ptM = segCenterBak.MidPoint();
	// 
	// 							DrawArrow3D(segCenterBak, dc);
	// 							segCenterBak.GetSubSegment(ptM, segCenterBak.GetLength()/2, segSub);
	// 							DrawArrow3D(segSub, dc, 0);
	// 							DrawArrow3D(segSub, dc, 2);
	// 							DrawArrow3D(segCenterBak, dc, 0);
	// 							DrawArrow3D(segCenterBak, dc, 2);
	// 							break;
	// 						case TStruLoad::LT_FOCUS:
	// 							ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+400);
	// 							ptMid.GetMoveMatrix(ptM, mat);
	// 							segCenterBak = segCenter;
	// 							segCenterBak.TransformBy(mat);
	// 
	// 							DrawArrow3D(segCenterBak, dc);
	// 							break;
	// 						case TStruLoad::LT_TRAPE:
	// 							ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
	// 							ptMid.GetMoveMatrix(ptM, mat);
	// 							segCenter.GetSubSegment(ptMid, dLoadLen/3, segCenterBak);
	// 							segCenterBak.TransformBy(mat);
	// 							dc.DrawCurve(segCenterBak);
	// 
	// 							DrawArrow3D(segCenterBak, dc, 0);
	// 							DrawArrow3D(segCenterBak, dc, 1);
	// 							DrawArrow3D(segCenterBak, dc, 2);
	// 
	// 							ptS = (!bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
	// 							segSub = TGGeCurveSegment(ptStart, ptS, 0);
	// 							dc.DrawCurve(segSub);
	// 							DrawArrow3D(segSub, dc);
	// 
	// 							ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
	// 							segSub = TGGeCurveSegment(ptEnd, ptE, 0);
	// 							dc.DrawCurve(segSub);
	// 							DrawArrow3D(segSub, dc);
	// 							break;
	// 						case TStruLoad::LT_TRIGON:
	// 							ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+400);
	// 							ptMid.GetMoveMatrix(ptM, mat);
	// 
	// 							segCenterBak = segCenter;
	// 							segCenterBak.TransformBy(mat);
	// 							DrawArrow3D(segCenterBak, dc);
	// 
	// 							segCenter.GetSubSegment(ptMid, dLoadLen/3, segSub);
	// 							segCenterBak = segSub;
	// 
	// 							ptS = segCenterBak.StartPoint();
	// 							segSub = TGGeCurveSegment(ptM, ptS, 0);
	// 							dc.DrawCurve(segSub);
	// 
	// 							DrawArrow3D(segSub, dc);
	// 
	// 							ptE = segCenterBak.EndPoint();
	// 							segSub = TGGeCurveSegment(ptM, ptE, 0);
	// 							dc.DrawCurve(segSub);
	// 
	// 							DrawArrow3D(segSub, dc);
	// 							break;
	// 						case TStruLoad::LT_FOLD:
	// 							segCenter.GetSubSegment(ptMid, dLoadLen/4, segSub);
	// 							segCenterBak = segSub;
	// 
	// 							ptS = (!bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
	// 							ptS = XPoint(ptS.x, ptS.y, ptS.z+100);
	// 
	// 							ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
	// 							ptE = XPoint(ptE.x, ptE.y, ptE.z+400);
	// 
	// 							segSub = TGGeCurveSegment(ptS, ptE, 0);
	// 							dc.DrawCurve(segSub);
	// 
	// 							DrawArrow3D(segSub, dc, 0);
	// 							DrawArrow3D(segSub, dc, 1);
	// 							DrawArrow3D(segSub, dc, 2);
	// 							break;
	// 						case TStruLoad::LT_MOMENT:
	// 							arcLine.setCenter(ptMid);
	// 							arcLine.setStartAngle(0);
	// 							arcLine.setEndAngle(PI*3/2);
	// 							arcLine.setRadius(200);
	// 							arcLine.setNormal(AcGeVector3d::kZAxis);
	// 							arcLine.setColorIndex(1);
	// 							dc.DrawEntity(arcLine);
	// 
	// 							arcLine.getEndPoint(ptE);
	// 							segSub = TGGeCurveSegment(ptE, ptMid, 0);
	// 							dc.DrawCurve(segSub);
	// 							segSub = TGGeCurveSegment(ptE, XPoint(ptMid.x, ptMid.y, ptMid.z-200), 0);
	// 							dc.DrawCurve(segSub);
	// 
	// 							break;
	// 						}
	// 					}
	// 					
	// 					if ((loadData.GetLoadKind() == TStruLoad::LK_VARYING && bShowLive)			//活荷
	// 						||(loadData.GetLoadKind() == TStruLoad::LK_UNVARYING && bShowUnLive)	//恒荷
	// 						)
	// 					{
	// 						DrawLoadText3D(loadData, dAugle, dZ, dc);
	// 					}
	// 				}
	// 				
	// 				dc.SetColor(nColorOld);
	// 				break;
	// 			}
	// 		}
	// 
	// 		if(bFind)
	// 		{
	// 			break;
	// 		}
	// 	}

	std::vector<TStruLoad> vecLoad;
	GetLoadsArray(vecLoad);
	int nSize = vecLoad.size();
	if(nSize < 1)
	{
		return;
	}

	//int nColorOld = dc.GetColor();
	//dc.SetColor(1);
	TPushProperty vProp(this, dc);
	if (m_idLayerLoad.isValid())
	{
		dc.SetLayer(m_idLayerLoad);
	}

	TGGeCurveSegment segCenter = GetCenterLine();// 梁的中心线
	TGGeCurveSegment segSub, segCenterBak;
	XPoint ptMid = segCenter.MidPoint();
	XPoint ptStart = segCenter.GetStartPoint();
	XPoint ptEnd = segCenter.GetEndPoint();
	BOOL bSwitchSE = GetLRPoint(ptStart, ptEnd);// 确定起始点和终止点那个点在左侧或右侧
	XPoint ptS, ptE, ptM;						// 荷载图像上的起始,结束,中点
	ads_matrix mat;
	double dLoadLen = segCenter.GetLength();
	double dZ = 500;
	double dAugle = ads_angle(ptStart, ptEnd);
	AcDbArc arcLine;
	AcGeVector3d vecNormal = AcGeVector3d(0, 0, 1);

	TStruLoad loadData;
	for(int i = 0; i < nSize; i++)
	{
		loadData = vecLoad[i];

		if(bShowGraphic)
		{
			// modify by wjx on 120314 修改原因:要根据荷载参数绘制荷载
			switch (loadData.GetLoadType())
			{
			case TStruLoad::LT_ALL_H:
				ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+300);
				ptMid.GetMoveMatrix(ptM, mat);
				segCenterBak = segCenter;
				segCenterBak.TransformBy(mat);
				dc.DrawCurve(segCenterBak);

				DrawArrow3D(segCenterBak, dc);
				segCenterBak.GetSubSegment(ptM, dLoadLen/2, segSub);
				DrawArrow3D(segSub, dc, 0);
				DrawArrow3D(segSub, dc, 2);
				DrawArrow3D(segCenterBak, dc, 0);
				DrawArrow3D(segCenterBak, dc, 2);
				break;
			case TStruLoad::LT_LEFT:
				ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
				ptMid.GetMoveMatrix(ptM, mat);
// 				segCenter.GetSubSegment(ptStart, dLoadLen/4, segCenterBak);
// 				segCenter.GetSubSegment((bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint(), 
// 					dLoadLen/4, segSub);
				segCenter.GetSubSegment(ptStart, loadData.GetPara1() * 1000, segCenterBak);
				segCenter.GetSubSegment((bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint(), 
					loadData.GetPara1() * 1000, segSub);
				segSub.TransformBy(mat);
				dc.DrawCurve(segSub);

				segCenterBak = segSub;

				ptM = segCenterBak.MidPoint();

				DrawArrow3D(segCenterBak, dc);
				segCenterBak.GetSubSegment(ptM, segCenterBak.GetLength()/2, segSub);
				DrawArrow3D(segSub, dc, 0);
				DrawArrow3D(segSub, dc, 2);
				DrawArrow3D(segCenterBak, dc, 0);
				DrawArrow3D(segCenterBak, dc, 2);
				break;
			case TStruLoad::LT_RIGHT:
				ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
				ptMid.GetMoveMatrix(ptM, mat);
// 				segCenter.GetSubSegment(ptEnd, dLoadLen/4, segCenterBak);
// 				segCenter.GetSubSegment((bSwitchSE)? segCenterBak.StartPoint(): segCenterBak.EndPoint(), 
// 					dLoadLen/4, segSub);
				segCenter.GetSubSegment(ptEnd, loadData.GetPara1() * 1000, segCenterBak);
				segCenter.GetSubSegment((bSwitchSE)? segCenterBak.StartPoint(): segCenterBak.EndPoint(), 
					loadData.GetPara1() * 1000, segSub);
				segSub.TransformBy(mat);
				dc.DrawCurve(segSub);

				segCenterBak = segSub;

				ptM = segCenterBak.MidPoint();

				DrawArrow3D(segCenterBak, dc);
				segCenterBak.GetSubSegment(ptM, segCenterBak.GetLength()/2, segSub);
				DrawArrow3D(segSub, dc, 0);
				DrawArrow3D(segSub, dc, 2);
				DrawArrow3D(segCenterBak, dc, 0);
				DrawArrow3D(segCenterBak, dc, 2);
				break;
			case TStruLoad::LT_FOCUS:
				ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+400);
				ptMid.GetMoveMatrix(ptM, mat);
// 				segCenterBak = segCenter;
				segCenter.GetSubSegment(ptStart, loadData.GetPara1() * 1000 * 2, segCenterBak);
				segCenterBak.TransformBy(mat);

				DrawArrow3D(segCenterBak, dc, 2);
				break;
			case TStruLoad::LT_TRAPE:
				ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+500);
				ptMid.GetMoveMatrix(ptM, mat);
// 				segCenter.GetSubSegment(ptMid, dLoadLen/3, segCenterBak);
				segCenter.GetSubSegment(ptMid, dLoadLen - 2 * loadData.GetPara1()*1000, segCenterBak);
				segCenterBak.TransformBy(mat);
				dc.DrawCurve(segCenterBak);

				DrawArrow3D(segCenterBak, dc, 0);
				DrawArrow3D(segCenterBak, dc, 1);
				DrawArrow3D(segCenterBak, dc, 2);

				ptS = (!bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
				segSub = TGGeCurveSegment(ptStart, ptS, 0);
				dc.DrawCurve(segSub);
				DrawArrow3D(segSub, dc);

				ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
				segSub = TGGeCurveSegment(ptEnd, ptE, 0);
				dc.DrawCurve(segSub);
				DrawArrow3D(segSub, dc);
				break;
			case TStruLoad::LT_TRIGON:
				segCenter.GetSubSegment(ptStart, (loadData.GetPara1() + loadData.GetPara2())*2*1000, segSub);
// 				ptM = XPoint(ptMid.x, ptMid.y, ptMid.z+400);
// 				ptMid.GetMoveMatrix(ptM, mat);
				ptS = (bSwitchSE)? segSub.GetEndPoint(): segSub.GetStartPoint();
				ptM = XPoint(ptS.x, ptS.y, ptS.z+400);
				ptS.GetMoveMatrix(ptM, mat);

// 				segCenterBak = segCenter;
				segCenter.GetSubSegment(ptS, loadData.GetPara2()*2*1000, segCenterBak);
				segCenterBak.TransformBy(mat);
				DrawArrow3D(segCenterBak, dc);

// 				segCenter.GetSubSegment(ptMid, dLoadLen/3, segSub);
				segCenter.GetSubSegment(ptStart, loadData.GetPara1()*2*1000, segCenterBak);
// 				segCenterBak = segSub;

				ptS = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
				segSub = TGGeCurveSegment(ptM, ptS, 0);
				dc.DrawCurve(segSub);

				DrawArrow3D(segSub, dc);

				segCenter.GetSubSegment(ptStart, (loadData.GetPara1() + loadData.GetPara2()*2)*2*1000, segCenterBak);
				ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
				segSub = TGGeCurveSegment(ptM, ptE, 0);
				dc.DrawCurve(segSub);

				DrawArrow3D(segSub, dc);
				break;
			case TStruLoad::LT_FOLD:
// 				segCenter.GetSubSegment(ptMid, dLoadLen/4, segSub);
				segCenter.GetSubSegment(ptStart, loadData.GetPara2()*2*1000, segCenterBak);

				ptS = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
				ptS = XPoint(ptS.x, ptS.y, ptS.z+100);

				segCenter.GetSubSegment(ptStart, (loadData.GetPara2()+loadData.GetPara3())*2*1000, segCenterBak);
				ptE = (bSwitchSE)? segCenterBak.EndPoint(): segCenterBak.StartPoint();
				ptE = XPoint(ptE.x, ptE.y, ptE.z+400);

				segSub = TGGeCurveSegment(ptS, ptE, 0);
				dc.DrawCurve(segSub);

				DrawArrow3D(segSub, dc, 0);
				DrawArrow3D(segSub, dc, 1);
				DrawArrow3D(segSub, dc, 2);
				break;
			case TStruLoad::LT_MOMENT:
				segCenter.GetSubSegment(ptStart, loadData.GetPara1()*2*1000, segCenterBak);
// 				arcLine.setCenter(ptMid);
				ptM = (bSwitchSE)? segCenterBak.GetEndPoint(): segCenterBak.GetStartPoint();
				arcLine.setCenter(ptM);
				arcLine.setStartAngle(0);
				arcLine.setEndAngle(PI*3/2);
				arcLine.setRadius(200);
				arcLine.setNormal(AcGeVector3d::kZAxis);
				arcLine.setColorIndex(1);
				dc.DrawEntity(arcLine);

				arcLine.getEndPoint(ptE);
				segSub = TGGeCurveSegment(ptE, ptM, 0);
				dc.DrawCurve(segSub);
				segSub = TGGeCurveSegment(ptE, XPoint(ptM.x, ptM.y, ptM.z-200), 0);
				dc.DrawCurve(segSub);

				break;
			}
		}

		if ((loadData.GetLoadKind() == TStruLoad::LK_VARYING && bShowLive)			//活荷
			||(loadData.GetLoadKind() == TStruLoad::LK_UNVARYING && bShowUnLive)	//恒荷
			)
		{
			DrawLoadText3D(loadData, dAugle, dZ, dc);
		}
	}
	//dc.SetColor(nColorOld);
}

void TDbStruBeam::DrawLoadText3D(TStruLoad loadData, double dAugle, double &dZ, TGGiExplodeDrawBase &dc)const
{
	int nKind = loadData.GetLoadKind();       // 荷载种类

	//del by xlc on 120112显示控制移到外边了
 	//if(!GetViewStyle(nKind))
 	//{
 	//	return;
 	//}

	// 设置文字
	AcDbText text;
	text.setHeight(DocGetLoadTextHeight());// 设置文字高度		

	// 得到梁的中心线
	TGGeCurveSegment segCenter = GetCenterLine();
	XPoint ptMid = segCenter.MidPoint();

	// 生成要显示的荷载文字
	int nType = loadData.GetLoadType();		  // 荷载类型
	CString strLoadInfo;
	if(nType == TStruLoad::LT_FOLD)
	{
		strLoadInfo.Format(_T("7*%s*%s*%s*%s"), TrimDoubleZero(loadData.GetValue()),
			TrimDoubleZero(loadData.GetPara1()),TrimDoubleZero(loadData.GetPara2()), 
			TrimDoubleZero(loadData.GetPara3()));
	}
	else if(nType == TStruLoad::LT_TRIGON)
	{
		strLoadInfo.Format(_T("6*%s*%s*%s"), TrimDoubleZero(loadData.GetValue()),
			TrimDoubleZero(loadData.GetPara1()), TrimDoubleZero(loadData.GetPara2()));
	}
	else if(nType == TStruLoad::LT_ALL_H)
	{
		strLoadInfo.Format(_T("1*%s"), TrimDoubleZero(loadData.GetValue()));
	}
	else
	{
		strLoadInfo.Format(_T("%d*%s*%s"), nType, TrimDoubleZero(loadData.GetValue()),
			TrimDoubleZero(loadData.GetPara1()));
	}

	text.setTextString(strLoadInfo);
	//if(nKind == TStruLoad::LK_UNVARYING)
	//{
	//	text.setColorIndex(7);
	//}
	//else if(nKind == TStruLoad::LK_VARYING)
	//{
	//	text.setColorIndex(2);
	//}
	if (nKind == TStruLoad::LK_UNVARYING)
	{
		if (m_idLayerLoadC.isValid())
		{
			text.setLayer(m_idLayerLoadC);
		}
	}
	else
	{
		if (m_idLayerLoadL.isValid())
		{
			text.setLayer(m_idLayerLoadL);
		}
	}

	text.setRotation(dAugle);

	// 设置文字法向
	if(_tcscmp(dc.Desc(), TGGiWorldViewportDraw::Descriptor())==0)
	{
		AcGiViewport &vp = ((TGGiWorldViewportDraw&)dc).m_pVd->viewport();

		AcGePoint3d ptCamera, ptTarget;
		vp.getCameraTarget(ptTarget);
		vp.getCameraLocation(ptCamera);

		AcGeVector3d vtViewDrt = ptCamera-ptTarget;
		AcGeVector3d vtViewDir1= vp.viewDir();

		AcGeVector3d vtCamera;
		vp.getCameraUpVector(vtCamera);

		vtViewDrt.normalize();

		text.setNormal(vtViewDrt);
	}

	text.setPosition(XPoint(ptMid.x, ptMid.y, ptMid.z+dZ));
	dc.DrawEntity(text);

	dZ += DocGetLoadTextHeight();
}

// add by wjx on 111230
// 绘制特殊梁
void TDbStruBeam::DrawStruBeam(TGGiExplodeDrawBase &dc)const
{
	int nColor = dc.GetColor();
	
	double dLineWidth = 100;
	int nType = kBeam;
	XPoint ptCenter;
	TGGeCurveSegment segBase;
	GetBaseLine(segBase);			// 得到基线

	GetAt(KEY_USETYP, nType);
	if(nType == kBeam)				// 普通梁
	{
		dc.SetColor(BEAMCOLOR);	
	}
	else if(nType == kAMBeam)		// 不调幅梁
	{
		dc.SetColor(AMBEAMCOLOR);	
	}
	else if(nType == kCPBeam)		// 连梁
	{
		dc.SetColor(CPBEAMCOLOR);	
	}
	else if(nType == kTransBeam)	// 转换梁
	{
		dc.SetColor(TRANBEAMCOLOR);	
	}
	else if(nType == kSlideBeam)	// 滑动支梁
	{
		// 绘制梁中圆点
		ptCenter = segBase.MidPoint();
		AcDbPolyline polyLine;
		double dDis = 10;
		polyLine.setColorIndex(BEAMCOLOR);
		polyLine.addVertexAt(0, XPoint(ptCenter.x, ptCenter.y+dDis, 0), PI, dLineWidth, dLineWidth);
		polyLine.addVertexAt(1, XPoint(ptCenter.x, ptCenter.y-dDis, 0), 0.3, dLineWidth, dLineWidth);
		polyLine.setClosed(Adesk::kTrue);
		dc.DrawEntity(polyLine);
		dc.SetColor(BEAMCOLOR);	
	}
	dc.DrawCurve(segBase);

	dc.SetColor(1);
	int nHinge = GetHinge();
	double dRadius = 100;
	TGGeCurveSegment seg;
	if(nHinge == 1)								// 一端铰梁	
	{
		int	nHinge(0);
		if(GetAt(KEY_HINGE, nHinge))
		{
			if((nHinge & HINGE_START) != 0)		// 起始端
			{
				getStartPoint(ptCenter);
			}
			else
			{
				getEndPoint(ptCenter);			// 终端
			}
		}

		seg.SetCircle(ptCenter, dRadius);
		dc.DrawCurve(seg);
	}
	else if(nHinge == 2)						// 两端铰梁
	{
		getStartPoint(ptCenter);
		seg.SetCircle(ptCenter, dRadius);
		dc.DrawCurve(seg);

		TGGeCurveSegment cvseg;
		getEndPoint(ptCenter);
		cvseg.SetCircle(ptCenter, dRadius);
		dc.DrawCurve(cvseg);
	}

	dc.SetColor(nColor);
}

//add by xlc on 120118
//设置荷载数组
bool TDbStruBeam::SetLoadsArray(const std::vector<TStruLoad>& vectLoads)
{
	assertWriteEnabled();
	ClearLoadsArray();
	return SetAt(KEY_BEAM, vectLoads);
}
//获得荷载数组
bool TDbStruBeam::GetLoadsArray(std::vector<TStruLoad>& vectLoads)const
{
	assertReadEnabled();
	return GetAt(KEY_BEAM, vectLoads);
}
//清除荷载数组
void TDbStruBeam::ClearLoadsArray()
{
	assertWriteEnabled();
	RemoveLoadsKey(KEY_BEAM);
}

// add by wjx on 120223 弯矩包络图
bool TDbStruBeam::SetMGraArray(const std::vector<TCombForceData>& vectMin, const std::vector<TCombForceData>& vectMax)
{
	assertWriteEnabled();
	ClearMGraArray();
	return SetAt(KEY_MGRA, vectMin, vectMax);
}

//获得弯矩包络图数组
bool TDbStruBeam::GetMGraArray(std::vector<TCombForceData>& vectMin, std::vector<TCombForceData>& vectMax)const
{
	assertReadEnabled();
	return GetAt(KEY_MGRA, vectMin, vectMax);
}

//清除弯矩包络图数组
void TDbStruBeam::ClearMGraArray()
{
	assertWriteEnabled();
	RemoveMGraKey(KEY_MGRA);
}

// add by wjx on 120224 弯矩包络图
void TDbStruBeam::DrawMGraph(TGGiExplodeDrawBase &dc)const
{
	std::vector<TCombForceData> vecMin, vecMax;

	TPushProperty vProp(this, dc);
	if(m_idLayerForce.isValid())
	{
		dc.SetLayer(m_idLayerForce);
	}

	if(GetMGraArray(vecMin, vecMax))
	{
		//int nColorOld = dc.GetColor();
		//int nColor = 7;
		//dc.SetColor(nColor);

		// 得到梁的中心线
		TGGeCurveSegment segCenter = GetCenterLine();

		AcGePoint3d ptNode, ptStart, ptEnd;
		GetAt(KEY_START, ptStart);					// 得到梁的起始位置
		GetAt(KEY_END, ptEnd);						// 得到梁的终止位置

		if(ptStart.x - ptEnd.x > _DIST_SNAP)
		{
			ptNode = ptEnd;
			ptEnd = ptStart;
			ptStart = ptNode;
		}
		else if(fabs(ptStart.x - ptEnd.x) < _DIST_SNAP)
		{
			if(ptEnd.y - ptStart.y < _DIST_SNAP)
			{
				ptNode = ptEnd;
				ptEnd = ptStart;
				ptStart = ptNode;
			}
		}

		int nCount = vecMin.size();
		if (nCount < 2 || vecMax.size() < 2)
		{
			return;
		}

		double dLen = segCenter.GetLength();// 梁的长度
		double dSepDis = dLen / (nCount-1);	// 最小点之间的间距
		double dDis= 0;						// 最小点与梁起始位置的距离
		TADSGePointDir2d ptTemp;
		ads_real angle = 0;					// 旋转方向

		int nBeamType = segCenter.GetCurveType();
		TADSGePoint3d ptCenter = segCenter.GetArc().GetCenterPt();// 得到弧梁的圆心
		double dRia = 0;
		if(nBeamType == CURVE_ARC)
		{
			dRia = segCenter.GetArc().GetRadius();
		}
		else
		{
			// 计算旋转方向
			angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd));	// 与x轴的夹角
			if (angle - PI < g_angleZero)				// 0-180度之间
			{
				if(angle - PI/2 > g_angleZero)			// 90-180度时
				{
					angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
				}
			}
			else										// 180-360度之间
			{
				if(angle - 3*PI/2 < g_angleZero)		// 180-270度
				{
					angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
				}
			}
		}

		bool bVisible = false;
		TGGeVisibilityPoly2D polyMin;
		for(int i = 0; i < nCount; i++)
		{
			// 求对应的最小点位置
			dDis = i * dSepDis;
			segCenter.Polar(dDis, ptTemp);
			if(nBeamType == CURVE_ARC)
			{
				TGGeCurveSegment segTemp(ptCenter, ptTemp, 0, LS_INFINITE);
				segTemp.Polar((vecMin[i].m_dForce*g_dMGrapScal)+dRia, ptTemp);
				ptNode = ptTemp;
			}
			else
			{
				ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMin[i].m_dForce*g_dMGrapScal);//与梁垂直方向
			}
		
			//确定边的可见性
			if (vecMin[i].m_dForce < -_DIST_SNAP)
			{
				bVisible = true;
			}
			else
			{
				bVisible = false;
			}

			if (i!=0)
			{
				TGGeCurveSegment cvSeg(*polyMin[polyMin.Length()-1], ptNode, 0);
				
				TADSGePoint3d ptInter1,ptInter2;
				int nNum = cvSeg.Intersection(segCenter, ptInter1, ptInter2);
				if (nNum == 1)
				{
					polyMin.AppendNode(ptInter1, 0, bVisible ? AcDb::kVisible : AcDb::kInvisible);
				}
			}

			polyMin.AppendNode(ptNode, 0, bVisible ? AcDb::kVisible : AcDb::kInvisible);

			if(i == 0)
			{
				ptStart = ptNode;
			}
			else if(i == (nCount-1))
			{
				ptEnd = ptNode;
			}
		}
		
		DrawBaseWall2d(dc, polyMin, false);

		TGGePoly2D polyMax;
		polyMax.AppendNode(ptStart);
		nCount = vecMax.size();
		dSepDis = dLen / (nCount-1);
		for(int i = 0; i < nCount; i++)
		{
			// 求对应的最小点位置
			dDis = i * dSepDis;
			segCenter.Polar(dDis, ptTemp);

			if(nBeamType == CURVE_ARC)					//得到梁是直梁还是弧梁
			{
				TGGeCurveSegment segTemp(ptCenter, ptTemp, 0, LS_INFINITE);
				segTemp.Polar(dRia + (vecMax[i].m_dForce*g_dMGrapScal), ptTemp);
				ptNode = ptTemp;
			}
			else
			{
				ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMax[i].m_dForce*g_dMGrapScal);//与梁垂直方向
			}
			polyMax.AppendNode(ptNode);
		}
		polyMax.AppendNode(ptEnd);
		dc.DrawXPoly(polyMax);
		//dc.SetColor(nColorOld);		
	}

	DrawMGraphText(dc);
}

void TDbStruBeam::DrawMGraphText(TGGiExplodeDrawBase &dc)const
{
	std::vector<TCombForceData> vecMin, vecMax;

	TPushProperty vProp(this, dc);
	if (m_idLayerText.isValid())
	{
		dc.SetLayer(m_idLayerText);
	}

	if(GetMGraArray(vecMin, vecMax))
	{
		std::sort(vecMin.begin(), vecMin.end(), AscCompare);
		std::sort(vecMax.begin(), vecMax.end(), AscCompare);

		double dPaperScale = GetPScale();
		AcDbText text;
		text.setTextStyle(InitTextStyle(TS_STANDARD));
		text.setHeight(g_dMGrapTextH*dPaperScale);// 设置文字高度		

		// 得到梁的中心线
		TGGeCurveSegment segCenter = GetCenterLine();
		int nBeamType = segCenter.GetCurveType();
	
		AcGePoint3d ptNode, ptStart, ptEnd;
		GetAt(KEY_START, ptStart);					// 得到梁的起始位置
		GetAt(KEY_END, ptEnd);						// 得到梁的终止位置

		BOOL bSwitch = false;
		if(ptStart.x - ptEnd.x > _DIST_SNAP)
		{
			ptNode = ptEnd;
			ptEnd = ptStart;
			ptStart = ptNode;
			bSwitch = true;
		}
		else if(fabs(ptStart.x - ptEnd.x) < _DIST_SNAP)
		{
			if(ptStart.y - ptEnd.y > _DIST_SNAP)
			{
				ptNode = ptEnd;
				ptEnd = ptStart;
				ptStart = ptNode;
				bSwitch = true;
			}
		}

		// 计算旋转方向
		ads_real angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd));	// 与x轴的夹角
		if (angle - PI < g_angleZero)				// 0-180度之间
		{
			if(angle - PI/2 > g_angleZero)			// 90-180度时
			{
				angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
			}
		}
		else										// 180-360度之间
		{
			if(angle - 3*PI/2 < g_angleZero)		// 180-270度
			{
				angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
			}
		}

		int nCount = vecMin.size();
		double dPos = segCenter.GetLength() / 10;
		TADSGePointDir2d ptTemp;
		CString strText;
		text.setHeight(g_dMGrapTextH*dPaperScale);
//		int nColor = 7;
//		text.setColorIndex(nColor);

		if(nCount > 0)
		{
			text.setRotation(angle);
			strText.Format(_T("%.3f"),vecMin[nCount-1].m_dForce);
			text.setTextString(strText);
			segCenter.Polar((bSwitch)? 9*dPos: dPos, ptTemp);
			ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMin[nCount-1].m_dForce*g_dMGrapScal);//与梁垂直方向
 			text.setPosition(ptNode);
 			dc.DrawEntity(text);

			if(nCount > 1)
			{
				strText.Format(_T("%.3f"),vecMin[nCount-2].m_dForce);
				text.setTextString(strText);
				segCenter.Polar((bSwitch)? dPos: 9*dPos, ptTemp);
				ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMin[nCount-1].m_dForce*g_dMGrapScal);
				text.setPosition(ptNode);
				dc.DrawEntity(text);
			}
		}

		nCount = vecMax.size();
		if(nCount > 0)
		{
			strText.Format(_T("%.3f"),vecMax[0].m_dForce);
			text.setTextString(strText);
			ptNode = TADSGePoint3d(segCenter.MidPoint(), angle+PI/2, (-1) * (vecMax[0].m_dForce*g_dMGrapScal+g_dMGrapTextH*dPaperScale));
			text.setPosition(ptNode);
			dc.DrawEntity(text);
		}
	}
}

void InitStruBeam(bool bTrue)
{
	if (bTrue)
	{
		TDbStruBeam::rxInit();
		acrxBuildClassHierarchy();
		TDbStruBeam::InitMatchProtocol(TRUE);
	} 
	else
	{
		TDbStruBeam::InitMatchProtocol(FALSE);
		deleteAcRxClass(TDbStruBeam::desc());
	}
}

// add by wjx on 120330 剪力包络图
bool TDbStruBeam::SetSGraArray(const std::vector<TCombForceData>& vectMin)
{
	assertWriteEnabled();
	ClearSGraArray();
	return SetAt(KEY_SGRA, vectMin);
}

//获得剪力包络图数组
bool TDbStruBeam::GetSGraArray(std::vector<TCombForceData>& vectMin)const
{
	assertReadEnabled();
	return GetAt(KEY_SGRA, vectMin);
}

//清除剪力包络图数组
void TDbStruBeam::ClearSGraArray()
{
	assertWriteEnabled();
	RemoveNGraKey(KEY_SGRA);
}

// 绘制剪力包络图
void TDbStruBeam::DrawSGraph(TGGiExplodeDrawBase &dc)const
{
	std::vector<TCombForceData> vecMin, vecMax;

	TPushProperty vProp(this, dc);
	if(m_idLayerForce.isValid())
	{
		dc.SetLayer(m_idLayerForce);
	}

	if(GetSGraArray(vecMin))
	{
		//int nColorOld = dc.GetColor();
		//int nColor = 7;
		//dc.SetColor(nColor);
		// 得到梁的中心线
		TGGeCurveSegment segCenter = GetCenterLine();
		XPoint ptMid = segCenter.MidPoint();

		AcGePoint3d ptNode, ptStart, ptEnd;
		GetAt(KEY_START, ptStart);					// 得到梁的起始位置
		GetAt(KEY_END, ptEnd);						// 得到梁的终止位置
		BOOL blSwitch = FALSE;

		if(ptStart.x - ptEnd.x > _DIST_SNAP)
		{
			ptNode = ptEnd;
			ptEnd = ptStart;
			ptStart = ptNode;
			blSwitch = TRUE;
		}
		else if(fabs(ptStart.x - ptEnd.x) < _DIST_SNAP)
		{
			if(ptEnd.y - ptStart.y < _DIST_SNAP)
			{
				ptNode = ptEnd;
				ptEnd = ptStart;
				ptStart = ptNode;
				blSwitch = TRUE;
			}
		}

		TGGePoly2D poly;

		int nCount = vecMin.size();
		if (nCount < 2)
		{
			return;
		}
		nCount -= 1;
		double dLen = segCenter.GetLength();  // 梁的一半长度
		double dSepDis = dLen/nCount;	  // 最小点之间的间距
		double dDis= 0;						  // 最小点与梁起始位置的距离
		TADSGePointDir2d ptTemp;
		ads_real angle = 0;					  // 旋转方向

		int nBeamType = segCenter.GetCurveType();
		TADSGePoint3d ptCenter = segCenter.GetArc().GetCenterPt();// 得到弧梁的圆心
		double dRia = 0;
		if(nBeamType == CURVE_ARC)
		{
			dRia = segCenter.GetArc().GetRadius();
		}
		else
		{
			// 计算旋转方向
			angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd));	// 与x轴的夹角
			if (angle - PI < g_angleZero)				// 0-180度之间
			{
				if(angle - PI/2 > g_angleZero)			// 90-180度时
				{
					angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
				}
			}
			else										// 180-360度之间
			{
				if(angle - 3*PI/2 < g_angleZero)		// 180-270度
				{
					angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
				}
			}
		}

		int i = 0;
		poly.AppendNode(ptStart);
		for(; i < (int)vecMin.size(); i++)
		{
			// 求对应的点位置
			dDis = (blSwitch) ? ((nCount - i) * dSepDis): (i * dSepDis);
			segCenter.Polar(dDis, ptTemp);
			if(nBeamType == CURVE_ARC)
			{
				TGGeCurveSegment segTemp(ptCenter, ptTemp, 0, LS_INFINITE);
				segTemp.Polar((vecMin[i].m_dForce*g_dSGrapScal)+dRia, ptTemp);
				ptNode = ptTemp;
			}
			else
			{
				ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMin[i].m_dForce*g_dSGrapScal);//与梁垂直方向
			}
			poly.AppendNode(ptNode);
		}

		poly.AppendNode(ptEnd);
		dc.DrawXPoly(poly);
		//dc.SetColor(nColorOld);
	}

	DrawSGraphText(dc);
}

// 从大到小
BOOL ComparaDouble(double d1, double d2)
{
	if(d1 < d2)
	{
		return TRUE;
	}

	return FALSE;
}

void TDbStruBeam::DrawSGraphText(TGGiExplodeDrawBase &dc)const
{
	std::vector<TCombForceData> vecMin, vecMax;

	TPushProperty vProp(this, dc);
	if(m_idLayerText.isValid())
	{
		dc.SetLayer(m_idLayerText);
	}

	if(GetSGraArray(vecMin))
	{
		std::sort(vecMin.begin(), vecMin.end(), AscCompare);
		std::sort(vecMax.begin(), vecMax.end(), AscCompare);

		double dPaperScale = GetPScale();
		AcDbText text;
		text.setTextStyle(InitTextStyle(TS_STANDARD));
		text.setHeight(g_dSGrapTextH*dPaperScale);// 设置文字高度		

		// 得到梁的中心线
		TGGeCurveSegment segCenter = GetCenterLine();
		int nBeamType = segCenter.GetCurveType();

		AcGePoint3d ptNode, ptStart, ptEnd;
		GetAt(KEY_START, ptStart);					// 得到梁的起始位置
		GetAt(KEY_END, ptEnd);						// 得到梁的终止位置

		BOOL bSwitch = false;
		if(ptStart.x - ptEnd.x > _DIST_SNAP)
		{
			ptNode = ptEnd;
			ptEnd = ptStart;
			ptStart = ptNode;
			bSwitch = true;
		}
		else if(fabs(ptStart.x - ptEnd.x) < _DIST_SNAP)
		{
			if(ptEnd.y - ptStart.y < _DIST_SNAP)
			{
				ptNode = ptEnd;
				ptEnd = ptStart;
				ptStart = ptNode;
				bSwitch = true;
			}
		}

		// 计算旋转方向
		ads_real angle = ads_angle(TADSGePoint3d(ptStart), TADSGePoint3d(ptEnd));	// 与x轴的夹角
		if (angle - PI < g_angleZero)				// 0-180度之间
		{
			if(angle - PI/2 > g_angleZero)			// 90-180度时
			{
				angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
			}
		}
		else										// 180-360度之间
		{
			if(angle - 3*PI/2 < g_angleZero)		// 180-270度
			{
				angle = ads_angle(TADSGePoint3d(ptEnd), TADSGePoint3d(ptStart));
			}
		}

		double dPos = segCenter.GetLength() / 10;
		TADSGePointDir2d ptTemp;
		text.setRotation(angle);
		//int nColor = 7;
		//text.setColorIndex(nColor);
		int nSize = vecMax.size();
		CString strText;

		if(nSize > 0)
		{
			strText.Format(_T("%.3f"), vecMax[0].m_dForce);
			text.setTextString(strText);
			segCenter.Polar((bSwitch)? 9*dPos: dPos, ptTemp);
			ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMax[0].m_dForce*g_dSGrapScal);//与梁垂直方向
			text.setPosition(ptNode);
			dc.DrawEntity(text);
		}
		 
		int nCount = vecMin.size();
		if(nCount > 0)
		{
			strText.Format(_T("%.3f"),vecMin[nCount-1].m_dForce);
			text.setTextString(strText);
			segCenter.Polar((bSwitch)? dPos: 9*dPos, ptTemp);
			ptNode = TADSGePoint3d(ptTemp, angle+PI/2, (-1) * vecMin[nCount-1].m_dForce*g_dSGrapScal);
			text.setPosition(ptNode);
			dc.DrawEntity(text);
		}
	}
}

//梁可以合并的属性条件判断
BOOL TDbStruBeam::CanMerge(AcDbObjectId idWall)
{
	int nMatTyp, nMatTypOther;
	GetAt(KEY_MATTYP, nMatTyp);

	double dAxAng,dAxAngOther;
	GetAt(KEY_AXANG, dAxAng);

	int nSecTypThis,nSecTypOther;
	GetAt(KEY_SECTYP,nSecTypThis);

	double dB,dH,dU,dT,dD,dF;
	switch (nSecTypThis)
	{
	case ST_RECT:
		GetAt(KEY_B,dB);
		GetAt(KEY_H,dH);
		break;
	case ST_IBEAM:
		GetAt(KEY_B,dB);
		GetAt(KEY_H,dH);
		GetAt(KEY_U,dU);
		GetAt(KEY_T,dT);
		GetAt(KEY_D,dD);
		GetAt(KEY_F,dF);
		break;
	default:
		break;
	}

	double dBOther,dHOther,dUOther,dTOther,dDOther,dFOther;
	OPENOBJ_BEGIN(idWall, AcDb::kForRead, TDbStruBeam, pEnt);
	if (pEnt)
	{
		pEnt->GetAt(KEY_MATTYP, nMatTypOther);
		if (nMatTyp - nMatTypOther != 0)
		{
			//材料不同
			return FALSE;
		}

		pEnt->GetAt(KEY_AXANG, dAxAngOther);
		if (fabs(dAxAng - dAxAngOther) > g_angleZero)
		{
			return FALSE;
		}

		pEnt->GetAt(KEY_SECTYP,nSecTypOther);

		if(nSecTypThis != nSecTypOther)
		{
			//截面类型不同
			return FALSE;
		}
		
		switch (nSecTypOther)
		{
		case ST_RECT:
			GetAt(KEY_B,dBOther);
			GetAt(KEY_H,dHOther);
			if(fabs(dB - dBOther) > _DIST_SNAP || fabs(dHOther - dH) > _DIST_SNAP )
			{
				return FALSE;
			}
			break;
		case ST_IBEAM:
			GetAt(KEY_B,dBOther);
			GetAt(KEY_H,dHOther);
			GetAt(KEY_U,dUOther);
			GetAt(KEY_T,dTOther);
			GetAt(KEY_D,dDOther);
			GetAt(KEY_F,dFOther);
			if(fabs(dB - dBOther) > _DIST_SNAP || fabs(dHOther - dH) > _DIST_SNAP 
				||fabs(dU - dUOther) > _DIST_SNAP || fabs(dTOther - dT) > _DIST_SNAP
				||fabs(dD - dDOther) > _DIST_SNAP || fabs(dFOther - dF) > _DIST_SNAP)
			{
				return FALSE;
			}
			break;
		default:
			break;
		}

	}
	else
	{
		return FALSE;
	}
	OPENOBJ_END();

	return TRUE;
}

//梁正截面配筋面积数据
bool TDbStruBeam::SetRSArray(const std::vector<TReinSectData>& vecRSData)
{
	assertWriteEnabled();
	ClearRSArray();
	return SetAt(KEY_RSA, vecRSData);
}
bool TDbStruBeam::GetRSArray(std::vector<TReinSectData>& vecRSData)const
{
	assertReadEnabled();	
	return GetAt(KEY_RSA, vecRSData);
}
void TDbStruBeam::ClearRSArray()
{
	assertWriteEnabled();
	RemoveRSDataKey(KEY_RSA);
}

//梁正截面计算配筋面积数据
bool TDbStruBeam::SetCRSArray(const std::vector<TReinSectData>& vecRSData)
{
	assertWriteEnabled();
	ClearRSArray();
	return SetAt(KEY_CRSA, vecRSData);
}
bool TDbStruBeam::GetCRSArray(std::vector<TReinSectData>& vecRSData)const
{
	assertReadEnabled();	
	return GetAt(KEY_CRSA, vecRSData);
}
void TDbStruBeam::ClearCRSArray()
{
	assertWriteEnabled();
	RemoveRSDataKey(KEY_CRSA);
}

//梁斜截面配筋面积数据
bool TDbStruBeam::SetRSSArray(const std::vector<TReinSectData>& vecRSData)
{
	assertWriteEnabled();
	ClearRSSArray();
	return SetAt(KEY_RSSA, vecRSData);
}
bool TDbStruBeam::GetRSSArray(std::vector<TReinSectData>& vecRSData)const
{
	assertReadEnabled();	
	return GetAt(KEY_RSSA, vecRSData);
}
void TDbStruBeam::ClearRSSArray()
{
	assertWriteEnabled();
	RemoveRSDataKey(KEY_RSSA);
}

//梁尺寸图层
AcDbObjectId TDbStruBeam::GetLayerDim() const
{
	return m_idLayerDim;
}
void TDbStruBeam::SetLayerDim(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerDim = idLayer;
}

//梁编号图层
AcDbObjectId TDbStruBeam::GetLayerNum() const
{
	return m_idLayerNum;
}
void TDbStruBeam::SetLayerNum(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerNum = idLayer;
}

//梁标注图层
AcDbObjectId TDbStruBeam::GetLayerMark() const
{
	return m_idLayerMark;
}
void TDbStruBeam::SetLayerMark(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerMark = idLayer;
}

//梁其他文字图层
AcDbObjectId TDbStruBeam::GetLayerText() const
{
	return m_idLayerText;
}
void TDbStruBeam::SetLayerText(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerText = idLayer;
}

//梁钢筋图层
AcDbObjectId TDbStruBeam::GetLayerRBar() const
{
	return m_idLayerRBar;
}
void TDbStruBeam::SetLayerRBar(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerRBar = idLayer;
}

//梁附加吊筋图层
AcDbObjectId TDbStruBeam::GetLayerRBarU() const
{
	return m_idLayerRBarU;
}
void TDbStruBeam::SetLayerRBarU(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerRBarU = idLayer;
}

//梁附加箍筋图层
AcDbObjectId TDbStruBeam::GetLayerRBarO() const
{
	return m_idLayerRBarO;
}
void TDbStruBeam::SetLayerRBarO(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerRBarO = idLayer;
}

//梁实配面积图层
AcDbObjectId TDbStruBeam::GetLayerRealArea() const
{
	return m_idLayerRealArea;
}
void TDbStruBeam::SetLayerRealArea(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerRealArea = idLayer;
}

//梁计算挠度图层
AcDbObjectId TDbStruBeam::GetLayerCalDefl() const
{
	return m_idLayerCalDefl;
}
void TDbStruBeam::SetLayerCalDefl(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerCalDefl = idLayer;
}

//梁计算裂缝图层
AcDbObjectId TDbStruBeam::GetLayerCalCrk() const
{
	return m_idLayerCalCrk;
}
void TDbStruBeam::SetLayerCalCrk(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerCalCrk = idLayer;
}
//梁内力结果图层
AcDbObjectId TDbStruBeam::GetLayerForce() const
{
	return m_idLayerForce;
}
void TDbStruBeam::SetLayerForce(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerForce = idLayer;
}

//梁计算配筋图层
AcDbObjectId TDbStruBeam::GetLayerCalcArea() const
{
	return m_idLayerCalcArea;
}
void TDbStruBeam::SetLayerCalcArea(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerCalcArea = idLayer;
}

//梁荷载
AcDbObjectId TDbStruBeam::GetLayerLoad() const
{
	return m_idLayerLoad;
}
void TDbStruBeam::SetLayerLoad(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerLoad = idLayer;
}

//梁活荷值
AcDbObjectId TDbStruBeam::GetLayerLoadL() const
{
	return m_idLayerLoadL;
}
void TDbStruBeam::SetLayerLoadL(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerLoadL = idLayer;
}

//梁恒荷值
AcDbObjectId TDbStruBeam::GetLayerLoadC() const
{
	return m_idLayerLoadC;
}
void TDbStruBeam::SetLayerLoadC(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idLayerLoadC = idLayer;
}
//文字样式
AcDbObjectId TDbStruBeam::GetTextStyle() const
{
	return m_idTextStyle;
}
void TDbStruBeam::SetTextStyle(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idTextStyle = idLayer;
}

//文字样式
AcDbObjectId TDbStruBeam::GetTextStyleRB() const
{
	return m_idTextStyleRB;
}
void TDbStruBeam::SetTextStyleRB(AcDbObjectId idLayer)
{
	assertWriteEnabled();
	m_idTextStyleRB = idLayer;
}

//得到显示配筋面积的梁线
TGGeCurveSegment TDbStruBeam::GetBeamLine()const
{
	TGGeCurveSegment segCenter = GetCenterLine();

	AcDbObjectIdArray idColus;
	GetAssocRelation(ASSOC_COLU, idColus);			//得到关联柱子
	TADSGePoint3d pt1, pt2;
	for (int i = 0; i < idColus.length(); i++)
	{
		OPENOBJ_BEGIN(idColus[i], AcDb::kForRead, TDbColumn, pColumn);
		if (pColumn == NULL)
		{
			continue;
		}

		TGGePoly2D poly;
		pColumn->GetOutline(poly);

		for (int j = 0; j < poly.TotalSegments(); j++)
		{
			TGGeCurveSegment segTemp;
			poly.Nth(j, segTemp);
			if (segTemp.Intersection(segCenter, pt1, pt2) == 1)		//梁线跟柱子的多段线只有一个交点
			{
				//判断交点应该设置为梁线的哪一个点
				if (segCenter.StartPoint().Distance2d(pt1) < segCenter.EndPoint().Distance2d(pt1))
				{
					double dDist = segCenter.PathDistance(pt1);
					double dBugle = (segCenter.GetLength() - dDist)*segCenter.GetBulge()/segCenter.GetLength();
					segCenter.SetStartPoint(pt1);
					segCenter.SetBulge(dBugle);
				}
				else
				{
					double dDist = segCenter.PathDistance(pt1, 0);
					double dBugle = (segCenter.GetLength() - dDist)*segCenter.GetBulge()/segCenter.GetLength();
					segCenter.SetEndPoint(pt1);
					segCenter.SetBulge(dBugle);
				}
			}
		}
		OPENOBJ_END();
	}

	return segCenter;
}
CString TDbStruBeam::FormatText(double dValue, int nPrec) const
{
	TCString sFormat;
	sFormat << _T("%.") << nPrec << _T("f");

	CString strValue;
	strValue = TCString(sFormat, dValue);
	
	return strValue;
}
//绘制配筋面积数据
void TDbStruBeam::DrawReinText(TGGiExplodeDrawBase &dc, double dLeft, double dRight, double dMidUp, double dMidDown, int nPrec) const
{
	TGGeCurveSegment cvSeg = GetBeamLine();

	bool bIsTurn = false;		//判断线段是否是逆时针
	double dAngle = ads_angle(cvSeg.StartPoint(), cvSeg.EndPoint());
	if (dAngle > PI/2 && dAngle <= 3*PI/2)
	{
		bIsTurn = true;
	}

	TDbText text;

	AcDbObjectId id = GetTextStyleId(_T("STANDARD"));
	text.setPropertiesFrom(this);
	double dTextHeight = 3.5;		//文字字高
	text.SetHeight(dTextHeight);
	text.SetStyleId(id);
	text.SetText(FormatText(dLeft, nPrec));

	TADSGePoint3d ptTemp = bIsTurn ? cvSeg.EndPoint() : cvSeg.StartPoint();

	text.SetLocation(ptTemp);
	dAngle = bIsTurn ? cvSeg.Direction(ptTemp) - PI : cvSeg.Direction(ptTemp);
	text.SetRotation(dAngle);		//设置文字角度，跟梁线有关系
	text.SetAlignment(XExplodeDraw::kBottomLeft);	//文字左侧底部对齐

	dc.DrawEntity(text);

	text.SetLocation(cvSeg.MidPoint());				//中间文字位置点
	text.SetText(FormatText(dMidUp, nPrec));
	text.SetAlignment(XExplodeDraw::kBottomCenter);
	dAngle = bIsTurn ? cvSeg.Direction(cvSeg.MidPoint()) - PI : cvSeg.Direction(cvSeg.MidPoint());
	text.SetRotation(dAngle);						//设置文字角度
	dc.DrawEntity(text);

	text.SetText(FormatText(dMidDown, nPrec));
	text.SetAlignment(XExplodeDraw::kTopCenter);	
	dc.DrawEntity(text);

	text.SetText(FormatText(dRight, nPrec));		//设置右侧文字
	ptTemp = bIsTurn ?  cvSeg.StartPoint() : cvSeg.EndPoint();
	text.SetLocation(ptTemp);
	dAngle = bIsTurn ? cvSeg.Direction(ptTemp) - PI : cvSeg.Direction(ptTemp);
	text.SetRotation(dAngle);
	text.SetAlignment(XExplodeDraw::kBottomRight);	//设置对齐方式为底部右侧对齐
	dc.DrawEntity(text);
}

//绘制配筋图
void TDbStruBeam::DrawReinGragh(TGGiExplodeDrawBase &dc) const
{
	double dLeft = 0, dRight = 0, dMidUp = 0, dMidDown = 0;
	int nPrec = 0;
	bool bShow = false;
	TPushProperty vPorp(this, dc);
	switch (g_nReinAreaMode)
	{
	case eCalArea:				//计算配筋面积
		{
			std::vector<TReinSectData> vecData;
			if( GetRSArray(vecData))
			{
				int nSize = vecData.size();
				if(nSize > 1)
				{
					TReinSectData reinData = vecData[0];
					dLeft = reinData.m_dArea;

					reinData = vecData[nSize - 1];
					dRight = reinData.m_dArea;

					reinData = vecData[(int)(nSize / 2)];
					dMidDown = reinData.m_dArea;
					dMidUp = reinData.m_dAreaS;

					dc.SetLayer(m_idLayerCalcArea);
					bShow = true;
				}
			}
		}
		break;
	case eRealArea:				//实配面积
		{
			std::vector<TReinSectData> vecData;
			if( GetCRSArray(vecData))
			{
				int nSize = vecData.size();
				if(nSize > 1)
				{
					TReinSectData reinData = vecData[0];
					dLeft = reinData.m_dArea;

					reinData = vecData[nSize - 1];
					dRight = reinData.m_dArea;

					reinData = vecData[(int)(nSize / 2)];
					dMidDown = reinData.m_dArea;
					dMidUp = reinData.m_dAreaS;

					dc.SetLayer(m_idLayerRealArea);
					bShow = true;
				}
			}
		}
		break;
	case eReinRate:				//配筋率
		{
			std::vector<TReinSectData> vecData;
			if( GetCRSArray(vecData))
			{
				int nSize = vecData.size();
				if(nSize > 1)
				{
					double dArea = CalSectionArea();
					if (dArea > _DIST_SNAP)
					{
						TReinSectData reinData = vecData[0];
						dLeft = reinData.m_dArea / dArea * 100;

						reinData = vecData[nSize - 1];
						dRight = reinData.m_dArea / dArea * 100;

						reinData = vecData[(int)(nSize / 2)];
						dMidDown = reinData.m_dArea/ dArea * 100;
						dMidUp = reinData.m_dAreaS / dArea * 100;

						dc.SetLayer(m_idLayerRealArea);
						bShow = true;
						nPrec = 2;			//两位精度
					}
				}
			}
		}
		break;
	default:
		break;
	}

	if (bShow)
	{
		DrawReinText(dc, dLeft, dRight, dMidUp, dMidDown, nPrec);
	}
}

//计算截面有效面积
double TDbStruBeam::CalSectionArea()const
{
	int nSectType(0);
	GetAt(KEY_SECTYP, nSectType);

	double dB(0),dH(0),dU(0),dT(0),dD(0),dF(0),dHw(0), dArea(0);
	switch (nSectType)
	{
	case ST_RECT: // 矩形
		{
			GetAt(KEY_B, dB);
			GetAt(KEY_H, dH);
			break;
		}
	case ST_IBEAM: // 工字型
		{
			GetAt(KEY_B, dB);
			GetAt(KEY_H, dH);			
			break;
		}
	}

	dArea = dB * dH;

	return dArea;
}

void TDbStruBeam::RemoveCrackArray(LPCTSTR pszKey)
{
	CString sKey;
	sKey.Format(_T("%sLeft"), pszKey);
	GetSpecialtyData()->RemoveAt(sKey);

	sKey.Format(_T("%sMid"), pszKey);
	GetSpecialtyData()->RemoveAt(sKey);

	sKey.Format(_T("%sRight"), pszKey);
	GetSpecialtyData()->RemoveAt(sKey);
}
bool TDbStruBeam::SetCrackArray(const TCrackData& crackData)
{
	bool bRet = SetAt(KEY_CRACKDATA, crackData);
	return bRet;
}
bool TDbStruBeam::GetCrackArray(TCrackData& crackData) const
{
	bool bRet = GetAt(KEY_CRACKDATA, crackData);
	return bRet;
}
void TDbStruBeam::ClearCrackArray()
{
	RemoveCrackArray(KEY_CRACKDATA);
}

void TDbStruBeam::DrawCrackGraph(TGGiExplodeDrawBase& dc) const
{
	// 裂缝数据
	TCrackData crackData;
	if (!GetCrackArray(crackData))
	{
		return;
	}

	// 获取梁的中线
	TGGeCurveSegment segCenterLine = GetCenterLine();

	// 梁的起点、终点和中点
	TADSGePoint3d ptStart = segCenterLine.GetStartPoint();
	TADSGePoint3d ptEnd   = segCenterLine.GetEndPoint();
	ptStart[Z] = 0;
	ptEnd[Z] = 0;
	TADSGePoint3d ptMid;
	Midpoint(ptStart, ptEnd, ptMid);

	// 梁的方向向量
	TADSGePoint3d vtBeamDir = ptEnd - ptStart;

	// 使梁的方向向量角度<=90度，>270度
	double dAngle = vtBeamDir.AsAcGeVector2d().angle();
	if (dAngle > PI / 2.0f + g_angleZero &&      // >   90度
		dAngle < PI / 2.0f * 3.0f + g_angleZero) // <= 270度
	{
		// 反转方向向量
		vtBeamDir = TADSGePoint3d(0, 0, 0) - vtBeamDir;
		TADSGePoint3d ptTemp = ptEnd;
		ptEnd   = ptStart;
		ptStart = ptTemp;
	}

	// 构造文本对象
	TDbText text;
	text.SetStyleId(GetTextStyleId(_T("STANDARD")));
	text.SetRotation(vtBeamDir.AsAcGeVector2d().angle());
	text.SetHeight(g_dCrackGraphTextH);

	CString sText;
	// 起点文本
	sText.Format(_T("%lf"), crackData.m_dLeft);
	sText.TrimRight('0');
	sText.TrimRight('.');
	text.SetText(sText);
	text.SetLocation(ptStart);
	text.SetAlignment(TGGiExplodeDrawBase::kBottomLeft);
	if (crackData.m_dLeft > g_dCrackLimit + g_fZero) // > g_dCrackLimit
	{
		text.setColorIndex(1);
	}
	else
	{
		text.setColorIndex(7);
	}
	dc.DrawEntity(text);

	// 中点文本
	sText.Format(_T("%lf"), crackData.m_dMid);
	sText.TrimRight('0');
	sText.TrimRight('.');
	text.SetText(sText);
	text.SetLocation(ptMid);
	text.SetAlignment(TGGiExplodeDrawBase::kTopCenter);
	if (crackData.m_dMid > g_dCrackLimit + g_fZero) // > g_dCrackLimit
	{
		text.setColorIndex(1);
	}
	else
	{
		text.setColorIndex(7);
	}
	dc.DrawEntity(text);

	// 终点文本
	sText.Format(_T("%lf"), crackData.m_dRight);
	sText.TrimRight('0');
	sText.TrimRight('.');
	text.SetText(sText);
	text.SetLocation(ptEnd);
	text.SetAlignment(TGGiExplodeDrawBase::kBottomRight);
	if (crackData.m_dRight > g_dCrackLimit + g_fZero) // > g_dCrackLimit
	{
		text.setColorIndex(1);
	}
	else
	{
		text.setColorIndex(7);
	}
	dc.DrawEntity(text);
}

// 挠度图
bool TDbStruBeam::SetDeflectArray(const std::vector<double>& deflectData)
{
	AcGeDoubleArray arData;
	for (UINT i=0; i<deflectData.size(); i++)
	{
		arData.append(deflectData[i]);
	}
	bool bRet = (bool)GetSpecialtyData()->SetAt(KEY_DEFLECTDATA, arData);
	return bRet;
}

bool TDbStruBeam::GetDeflectArray(std::vector<double>& deflectData) const
{
	AcGeDoubleArray arData;
	if (!GetSpecialtyDataReadOnly()->GetAt(KEY_DEFLECTDATA, arData))
	{
		return false;
	}
	for (int i=0; i<arData.length(); i++)
	{
		deflectData.push_back(arData[i]);
	}
	return true;
}

void TDbStruBeam::ClearDeflectArray()
{
	GetSpecialtyData()->RemoveAt(KEY_DEFLECTDATA);
}

void TDbStruBeam::DrawDeflectGraph(TGGiExplodeDrawBase& dc) const
{
	// 获取挠度数据
	std::vector<double> vecData;
	if (!GetDeflectArray(vecData) || vecData.size() < 1)
	{
		return;
	}

	// 获取数组的中间值
	double dValue;
	UINT uCount = vecData.size();
	if (uCount % 2 != 0) // 奇数个
	{
		dValue = vecData[(uCount + 1) / 2 - 1];
	}
	else
	{
		dValue = max(vecData[uCount / 2 - 1], vecData[uCount / 2]);
	}

	// 获取梁的中线
	TGGeCurveSegment segCenterLine = GetCenterLine();

	// 梁的起点、终点和中点
	TADSGePoint3d ptStart = segCenterLine.GetStartPoint();
	TADSGePoint3d ptEnd   = segCenterLine.GetEndPoint();
	ptStart[Z] = 0;
	ptEnd[Z] = 0;
	TADSGePoint3d ptMid;
	Midpoint(ptStart, ptEnd, ptMid);

	// 梁的方向向量
	TADSGePoint3d vtBeamDir = ptEnd - ptStart;

	// 使梁的方向向量角度<=90度，>270度
	double dAngle = vtBeamDir.AsAcGeVector2d().angle();
	if (dAngle > PI / 2.0f + g_angleZero &&      // >   90度
		dAngle < PI / 2.0f * 3.0f + g_angleZero) // <= 270度
	{
		// 反转方向向量
		vtBeamDir = TADSGePoint3d(0, 0, 0) - vtBeamDir;
		TADSGePoint3d ptTemp = ptEnd;
		ptEnd   = ptStart;
		ptStart = ptTemp;
	}

	// 文本的偏移方向向量
	TADSGePoint3d vtOffsetDir = vtBeamDir;
	vtOffsetDir.Rotate(-PI / 2.0f);

	// 偏移后的中点
	vtOffsetDir.Normalize();
	ptMid = ptMid + vtOffsetDir.AsAcGePoint3d() * dValue * g_dDeflectGraphScale;

	// 绘制线
	AcDbPolyline plLine;
	plLine.setNormal(AcGeVector3d(0, 0, 1));
	plLine.addVertexAt(0, ptStart.AsAcGePoint2d());
	plLine.addVertexAt(1, ptMid.AsAcGePoint2d());
	plLine.addVertexAt(2, ptEnd.AsAcGePoint2d());
	plLine.setColorIndex(6);
	dc.DrawEntity(plLine);

	// 文本
	CString sText;
	sText.Format(_T("%lf"), dValue);
	sText.TrimRight('0');
	sText.TrimRight('.');
	TDbText text;
	text.SetStyleId(GetTextStyleId(_T("STANDARD")));
	text.SetRotation(vtBeamDir.AsAcGeVector2d().angle());
	text.SetHeight(g_dDeflectGraphTextH);
	text.SetText(sText);
	text.SetLocation(ptMid);
	text.SetAlignment(TGGiExplodeDrawBase::kTopCenter);
	text.setColorIndex(7);
	dc.DrawEntity(text);
}

//恒荷弯矩值
BOOL TDbStruBeam::SetMArray(const AcGeDoubleArray& arM)
{
	assertWriteEnabled();
	return GetSpecialtyData()->SetAt(KEY_M, arM);
}
BOOL TDbStruBeam::GetMArray(AcGeDoubleArray& arM)const
{
	assertReadEnabled();
	return GetSpecialtyDataReadOnly()->GetAt(KEY_M, arM);
}
void TDbStruBeam::ClearMArray()
{
	assertWriteEnabled();
	GetSpecialtyData()->RemoveAt(KEY_M);
}

//活荷弯矩值
BOOL TDbStruBeam::SetMVArray(const AcGeDoubleArray& arM)
{
	assertWriteEnabled();
	return GetSpecialtyData()->SetAt(KEY_MV, arM);
}
BOOL TDbStruBeam::GetMVArray(AcGeDoubleArray& arM)const
{
	assertReadEnabled();
	return GetSpecialtyDataReadOnly()->GetAt(KEY_MV, arM);
}
void TDbStruBeam::ClearMVArray()
{
	assertWriteEnabled();
	GetSpecialtyData()->RemoveAt(KEY_MV);
}

//恒荷剪力值
BOOL TDbStruBeam::SetSArray(const AcGeDoubleArray& arM)
{
	assertWriteEnabled();
	return GetSpecialtyData()->SetAt(KEY_S, arM);
}
BOOL TDbStruBeam::GetSArray(AcGeDoubleArray& arM)const
{
	assertReadEnabled();
	return GetSpecialtyDataReadOnly()->GetAt(KEY_S, arM);
}
void TDbStruBeam::ClearSArray()
{
	assertWriteEnabled();
	GetSpecialtyData()->RemoveAt(KEY_S);
}

//活荷剪力值
BOOL TDbStruBeam::SetSVArray(const AcGeDoubleArray& arM)
{
	assertWriteEnabled();
	return GetSpecialtyData()->SetAt(KEY_SV, arM);
}
BOOL TDbStruBeam::GetSVArray(AcGeDoubleArray& arM)const
{
	assertReadEnabled();
	return GetSpecialtyDataReadOnly()->GetAt(KEY_SV, arM);
}
void TDbStruBeam::ClearSVArray()
{
	assertWriteEnabled();
	GetSpecialtyData()->RemoveAt(KEY_SV);
}

int TDbStruBeam::GetFirstVersion()const
{
	return 10;
}
bool TDbStruBeam::IsModelEntity() const
{
	return true;
}
#endif