#include "StdAfx.h"
#include "globalFunc.h"
#include "DrawSectionSymbol.h"
#include "dbelipse.h"
#include <set>
#include "dbpipe.h"
#include "AecDbDimension.h"
#include "AecDbText.h"

extern AcDbObjectId InitLayer(const TCHAR *szLayer, BOOL bApplyChange = TRUE);
extern AcDbObjectId InitDimStyle(TDimStyle ds);

CDrawSectionSymbol::CDrawSectionSymbol()
{
	m_pmapData = NULL;
}

void CDrawSectionSymbol::SetDataContainer(CDataContainer *pData)
{
	if (pData != NULL)
	{
		m_pmapData = pData;
	}
}

bool CDrawSectionSymbol::DrawPipe(const AcDbObjectId& idPipe, AcDbEntity*& pOutEnt)
{
	bool bRet = false;
	CDbPipe *pPipe = NULL;
	acdbOpenObject(pPipe, idPipe, AcDb::kForRead);
	if (pPipe != NULL)
	{
		AcGePoint3d ptS, ptE;
		pPipe->getStartPoint(ptS);
		pPipe->getEndPoint(ptE);

		ptS.z = 0;
		ptE.z = 0;
	    AcDbLine line1(ptS, ptE);

		AcGePoint3d ptCutS, ptCutE;
		if (m_pmapData->GetData(_T("CutS"), ptCutS) &&
			m_pmapData->GetData(_T("CutE"), ptCutE))
		{
			ptCutS.z = 0.0;
			ptCutE.z = 0.0;
			AcDbLine line2(ptCutS, ptCutE);  // 剖切线

			AcGePoint3d ptInt;
			if (IsIntersect(line1, line2, ptInt)) // 判断管线与剖切线是否相交
			{
				//求交点处标高	
				double dEle = 0.0;
				double dI = pPipe->GetPipeGradient();
				TPipeSys::FlowDirection dir = pPipe->GetFlowDir();
				XPoint ptWell;
				if(dir == TPipeSys::kFromStart)
				{
					dEle = pPipe->StartPoint().z ;
					ptWell = pPipe->StartPoint();
				}
				else
				{
					dEle = pPipe->EndPoint().z ;
					ptWell = pPipe->EndPoint();
				}
				ptWell.z = 0;
				double nDistWell = ptInt.distanceTo(ptWell);
		        dEle = dEle - nDistWell * dI;

				// 设置交点标高 
				ptInt.z = dEle;	
			
				// 坐标变换
				AcGeVector3d vtView; //剖切方向
				if (m_pmapData->GetData(_T("vtView"), vtView))
				{
					AcGePlane    plane(ptCutS, vtView); //以剖切0点，剖切方向，确定投影面
					AcGePoint3d  ptOrigin;
					AcGeVector3d vtNormal(0,0,1);
					AcGeVector3d vtToX(1,0,0);
					AcGeVector3d vtToY(0,1,0);
					
					//顺着剖切的方向是Y轴，根据右手定则，与z轴差乘是X轴
					AcGeMatrix3d mat;
					AcGeVector3d vtFromX = vtView.crossProduct(vtNormal);
					mat.setToAlignCoordSys(ptOrigin, vtFromX, vtView, vtNormal, ptOrigin, vtToX, vtToY, vtNormal);
					
					//把投影到PLANE的结果，坐标转换到正常坐标，因为有高度，所以再旋转90度
					AcGeMatrix3d matWcs;
					matWcs.setToRotation(-PI/2, AcGeVector3d::kXAxis);

					ptInt.transformBy(mat);
					ptInt.transformBy(matWcs);
					ptInt.z = 0; 

					// 获取横纵比例系数
					double dScaleX = 0.0, dScaleY = 0.0;
					if (m_pmapData->GetData(_T("ScaleX"), dScaleX) &&
						m_pmapData->GetData(_T("ScaleY"), dScaleY))
					{	
						double dX = 1, dY = 1;
						dX = GlobalFunc::DocGetPScale() / dScaleX;
						dY = GlobalFunc::DocGetPScale() / dScaleY;


						if (GlobalFunc::DocGetMeterUnitDraw())
						{
							int nType = -1;
							m_pmapData->GetData(_T("Type"), nType);
							if (nType == 0)
							{
								double dRoadEle = 0.0;
								AcGePoint3d ptCus;
								if (m_pmapData->GetData(_T("RoadEld"), dRoadEle)&& m_pmapData->GetData(_T("CutS"), ptCus))
								{
									ptCus.z = dRoadEle;
									ptCus.transformBy(mat);
									ptCus.transformBy(matWcs);
									ptCus.z = 0; 
									
									ptInt.x = ptCus.x + (ptInt.x - ptCus.x) * 1000;
									ptInt.y = ptCus.y + (ptInt.y - ptCus.y) * 1000;
								}
							}
							else if (nType == 1)
							{
								AcGePoint3d ptMid;
								if (m_pmapData->GetData(_T("RoadMidPt"), ptMid))
								{
									ptMid.transformBy(mat);
									ptMid.transformBy(matWcs);
									ptMid.z = 0; 
									
									ptInt.x = ptMid.x + (ptInt.x - ptMid.x) * 1000;
									ptInt.y = ptMid.y + (ptInt.y - ptMid.y) * 1000;
								}			
							}
	
						}
						
						ptInt.x *= dX;
						ptInt.y *= dY;

						ptInt = GlobalFunc::Ucs2Wcs(ptInt);
						m_mapPipe.insert(std::make_pair(idPipe, ptInt));

						// 绘制管线切面图
						AcDbEllipse *pEllipse = NULL;
						double dRadius = GlobalFunc::GetPipeOutDByDn(pPipe->GetMaterial(), pPipe->GetDnDiameter()) / 2.0;
			            CString strLayerName = pPipe->GetLayer();

						if (dScaleX < dScaleY)
						{
							AcGeVector3d vt = GlobalFunc::Ucs2Wcs(AcGeVector3d::kXAxis, true); 
							vt *= dRadius * GlobalFunc::DocGetPScale() / dScaleY;
							pEllipse =new AcDbEllipse(ptInt,
													  AcGeVector3d::kZAxis,
													  vt,
													  dScaleX / dScaleY);
						}
						else
						{
							AcGeVector3d vt = GlobalFunc::Ucs2Wcs(AcGeVector3d::kYAxis, true);
							vt *= dRadius * GlobalFunc::DocGetPScale() / dScaleX;
							pEllipse =new AcDbEllipse(ptInt,
								                      AcGeVector3d::kZAxis,
								                      vt,
								                      dScaleY / dScaleX);
						}	
						pEllipse->setLayer(strLayerName);
						pOutEnt = pEllipse;
						bRet = true;
					}
				}
			}
		}	

	    pPipe->close();
	}	
	return bRet;
}

bool CDrawSectionSymbol::DrawText(const AcGePoint3d &ptLoc,LPCTSTR pszText, BOOL bDir, AcDbEntity*& pOutText)
{
	bool bRet = false;
	double dH = 7.0;
	double dWidth = GlobalFunc::DocGetPScale();
	if (GlobalFunc::DocGetMeterUnitDraw())
	{
		dH = 10;
		dWidth = 10.0 * GlobalFunc::DocGetPScale();
	}

	if (pszText != NULL)
	{
		double dAngle = GlobalFunc::Ucs2Wcs(0.0);
		if (bDir)
		{	
			AcDbText *pText = new AcDbText;
			AcDbObjectId idTextStyle=GlobalFunc::InitTwtTextStyle(_T("STANDARD"));
 			pText->setTextStyle(idTextStyle);
			pText->setHorizontalMode(AcDb::kTextCenter);
			pText->setVerticalMode(AcDb::kTextBase);
			pText->setTextString(pszText);
			pText->setHeight(dH * GlobalFunc::DocGetPScale());
			pText->setRotation(GlobalFunc::Ucs2Wcs(0.0));
			pText->setAlignmentPoint(ptLoc);
			pText->setPosition(ptLoc);
			pText->setColorIndex(7);

	    	pOutText = pText;
		} 
		else
		{
			AcDbMText *pText = new AcDbMText;
			AcDbObjectId idTextStyle=GlobalFunc::InitTwtTextStyle(_T("STANDARD"));
			pText->setTextStyle(idTextStyle);
			pText->setTextHeight(dH * GlobalFunc::DocGetPScale());
			pText->setWidth(dWidth);
			pText->setRotation(0.0);
			pText->setContents(pszText);
			pText->setLocation(ptLoc);
			pText->setColorIndex(7);

			pOutText = pText;
		}

		bRet = true;
	}
	return bRet;
}

bool CDrawSectionSymbol::DrawArrow(AcDbEntity*& pArrow)
{
	bool bRet = false;

	int nType = -1;
	m_pmapData->GetData(_T("Type"), nType);
    if (nType == 1) // 选择了中心线
	{
		// 获取剖切点，剖切方向
		AcGePoint3d ptS, ptE;
		AcGeVector3d vtView;
		if (!(m_pmapData->GetData(_T("CutS"), ptS)&&
			m_pmapData->GetData(_T("CutE"), ptE)&&
			m_pmapData->GetData(_T("vtView"), vtView)))
		{
			return false;
		}
		
		AcGePlane    plane(ptS, vtView); //以剖切0点，剖切方向，确定投影面
		AcGePoint3d  ptOrigin;
		AcGeVector3d vtNormal(0,0,1);
		AcGeVector3d vtToX(1,0,0);
		AcGeVector3d vtToY(0,1,0);
		
		//顺着剖切的方向是Y轴，根据右手定则，与z轴差乘是X轴
		AcGeMatrix3d mat;
		AcGeVector3d vtFromX = vtView.crossProduct(vtNormal);
		mat.setToAlignCoordSys(ptOrigin, vtFromX, vtView, vtNormal, ptOrigin, vtToX, vtToY, vtNormal);
		
		//把投影到PLANE的结果，坐标转换到正常坐标，因为有高度，所以再旋转90度
		AcGeMatrix3d matWcs;
		matWcs.setToRotation(-PI/2, vtToX);
		
		double dUnitMeter = 1000;
		
		// 比例系数
		double dX = 1, dY = 1;
		GetScaleXY(dX, dY);
		dX = GlobalFunc::DocGetPScale() / dX;
    	dY = GlobalFunc::DocGetPScale() / dY;

		AcGePoint3d ptMid;
		double dRoadMidEle = 0.0;
		if (!m_pmapData->GetData(_T("RoadMidPt"), ptMid)) // 道路中心线点
		{
			return false;
		}
		ptMid.transformBy(mat);
		ptMid.transformBy(matWcs);
		ptMid.z = 0.0;	

		ptMid.x *= dX;
		ptMid.y *= dY;

		double dVal = 0.0;
		GetMaxVal(dVal);  // 道牙最大值

		AcGePoint3d ptDraw; // 箭头起点
		ptDraw = ptMid + vtToY * (2 * dUnitMeter + dVal) * dY;

		AcGePoint2d pt1, pt2, pt3, pt4;
		pt1 = ptDraw.convert2d(AcGePlane::kXYPlane);
		pt2 = (ptDraw + vtToY * 0.3 * dUnitMeter * dY).convert2d(AcGePlane::kXYPlane);
		pt3 = (ptDraw + vtToY * 0.3 * dUnitMeter * dY).convert2d(AcGePlane::kXYPlane);
		pt4 = (ptDraw + vtToY * 0.45 * dUnitMeter * dY).convert2d(AcGePlane::kXYPlane);
		pt1 = GlobalFunc::Ucs2Wcs(pt1);
		pt2 = GlobalFunc::Ucs2Wcs(pt2);
		pt3 = GlobalFunc::Ucs2Wcs(pt3);
		pt4 = GlobalFunc::Ucs2Wcs(pt4);
		AcDbPolyline *pPoly = new AcDbPolyline();
		pPoly->addVertexAt(0, pt1, 0, 0.8 * dUnitMeter * dX, 0.8 * dUnitMeter * dX);
		pPoly->addVertexAt(1, pt2, 0, 0.8 * dUnitMeter * dX, 0.8 * dUnitMeter * dX);
		pPoly->addVertexAt(2, pt3, 0, 1.6 * dUnitMeter * dX, 0);
		pPoly->addVertexAt(3, pt4);
		pPoly->setColorIndex(1);
		
		pArrow = pPoly;
		bRet = true;
	}

	return bRet;
}

bool CDrawSectionSymbol::DrawDivision(AcDbVoidPtrArray& arPtr)
{
	bool bRet = false;

	int nType = -1;
	m_pmapData->GetData(_T("Type"), nType);
	if (nType == 1) // 选择了中心线
	{
		// 获取剖切点，剖切方向
		AcGePoint3d ptS, ptE;
		AcGeVector3d vtView;
		if (!(m_pmapData->GetData(_T("CutS"), ptS)&&
			m_pmapData->GetData(_T("CutE"), ptE)&&
			m_pmapData->GetData(_T("vtView"), vtView)))
		{
			return false;
		}
		
		AcGePlane    plane(ptS, vtView); //以剖切0点，剖切方向，确定投影面
		AcGePoint3d  ptOrigin;
		AcGeVector3d vtNormal(0,0,1);
		AcGeVector3d vtToX(1,0,0);
		AcGeVector3d vtToY(0,1,0);
		
		//顺着剖切的方向是Y轴，根据右手定则，与z轴差乘是X轴
		AcGeMatrix3d mat;
		AcGeVector3d vtFromX = vtView.crossProduct(vtNormal);
		mat.setToAlignCoordSys(ptOrigin, vtFromX, vtView, vtNormal, ptOrigin, vtToX, vtToY, vtNormal);
		
		//把投影到PLANE的结果，坐标转换到正常坐标，因为有高度，所以再旋转90度
		AcGeMatrix3d matWcs;
		matWcs.setToRotation(-PI/2, vtToX);
		
		double dUnitMeter = 1000;
		
		// 比例系数
		double dX = 1, dY = 1;
		GetScaleXY(dX, dY);
		dX = GlobalFunc::DocGetPScale() / dX;
	    dY = GlobalFunc::DocGetPScale() / dY;

		AcGePoint3d ptMid;
		double dRoadMidEle = 0.0;
		if (!m_pmapData->GetData(_T("RoadMidPt"), ptMid)) // 道路中心线点
		{
			return false;
		}
		ptMid.transformBy(mat);
		ptMid.transformBy(matWcs);
		ptMid.z = 0.0;

		ptMid.x *= dX;
		ptMid.y *= dY;

		AcGePoint3d ptDraw; // 箭头起点
		ptDraw = ptMid;

		double dVal = 0.0;
		GetMaxVal(dVal);  // 道牙最大值
		
		AcDbLine *pLine = new AcDbLine(GlobalFunc::Ucs2Wcs(ptDraw + vtToY * (0.5 * dUnitMeter + dVal) * dY) , GlobalFunc::Ucs2Wcs(ptDraw - vtToY * 0.5 * dUnitMeter * dY));
		pLine->setColorIndex(2);
		arPtr.append(pLine);
		
		pLine = new AcDbLine(GlobalFunc::Ucs2Wcs(ptDraw+vtToY * (dUnitMeter + dVal) * dY), GlobalFunc::Ucs2Wcs(ptDraw + vtToY * (1.5 * dUnitMeter + dVal) * dY));
		pLine->setColorIndex(2);
		arPtr.append(pLine);
		
		double dWayWidth = 0.0;   // 道路宽度
		std::set<double> setWay;  
		GetWayInfo(dWayWidth,setWay); // 获得道路宽度，道路各个部分距道路一端的距离
		
		AcGePoint3d ptBase = ptDraw + vtToY * (dUnitMeter + dVal) * dY - vtToX * dWayWidth / 2;
		std::set<double>::iterator it;
		for (it = setWay.begin(); it != setWay.end(); it++)
		{
			ptS = ptBase + vtToX * (*it) * dUnitMeter;
			ptE = ptS + vtToY * 0.5 * dUnitMeter * dY;
			
			ptS = GlobalFunc::Ucs2Wcs(ptS);
			ptE = GlobalFunc::Ucs2Wcs(ptE);
			pLine = new AcDbLine(ptS, ptE);
			pLine->setColorIndex(7);
			arPtr.append(pLine);
		}

		bRet = true;
	}
	
	return bRet;
}

bool CDrawSectionSymbol::DrawRoadway(AcDbPolyline*& pOutLine, AcDbVoidPtrArray& arSplitLine, AcDbVoidPtrArray& arSubPtr, BOOL bCreateSub)
{
	// 获取剖切点，剖切方向
	AcGePoint3d ptS, ptE;
	AcGeVector3d vtView;
	if (!(m_pmapData->GetData(_T("CutS"), ptS)&&
		m_pmapData->GetData(_T("CutE"), ptE)&&
		m_pmapData->GetData(_T("vtView"), vtView)))
	{
		return false;
	}

	AcGePlane    plane(ptS, vtView); //以剖切0点，剖切方向，确定投影面
	AcGePoint3d  ptOrigin;
	AcGeVector3d vtNormal(0,0,1);
	AcGeVector3d vtToX(1,0,0);
	AcGeVector3d vtToY(0,1,0);
	
	//顺着剖切的方向是Y轴，根据右手定则，与z轴差乘是X轴
	AcGeMatrix3d mat;
	AcGeVector3d vtFromX = vtView.crossProduct(vtNormal);
	mat.setToAlignCoordSys(ptOrigin, vtFromX, vtView, vtNormal, ptOrigin, vtToX, vtToY, vtNormal);
	
	//把投影到PLANE的结果，坐标转换到正常坐标，因为有高度，所以再旋转90度
	AcGeMatrix3d matWcs;
	matWcs.setToRotation(-PI/2, vtToX);

	double dUnitMeter = 1000;
		
	// 比例系数
	double dX = 1, dY = 1;
	GetScaleXY(dX, dY);
	dX = GlobalFunc::DocGetPScale() / dX;
	dY = GlobalFunc::DocGetPScale() / dY;
	
	bool bRet = false;
	int nType = -1;
	m_pmapData->GetData(_T("Type"), nType);
	if (nType == 0) // 未选择中心线
	{
		double dRoadEle = 0.0;
		if (m_pmapData->GetData(_T("RoadEld"), dRoadEle)) // 获取道路标高
		{
			ptS.transformBy(mat);
			ptS.transformBy(matWcs);
			ptE.transformBy(mat);
			ptE.transformBy(matWcs);
			ptS.z = 0.0;
			ptE.z = 0.0;
			ptS.y = dRoadEle * dUnitMeter;
			ptE.y = dRoadEle * dUnitMeter;	

			// 绘制道路线
			AcGePoint3d pt1 = ptS, pt2 = ptE;
			if (GlobalFunc::DocGetMeterUnitDraw())
			{
				pt1.y = dRoadEle;
				pt1.x *= dX;
				pt1.y *= dY;
				double dLen = ptS.distanceTo(ptE);
				pt2 = pt1 + vtToX * ptS.distanceTo(ptE) * 1000 * dX; 
			}
			else
			{
				pt1.x *= dX;
				pt1.y *= dY;
				pt2.x *= dX;
				pt2.y *= dY;
			}

			pt1 = GlobalFunc::Ucs2Wcs(pt1);
			pt2 = GlobalFunc::Ucs2Wcs(pt2);

			AcDbPolyline *pPoly = new AcDbPolyline();
			pPoly->addVertexAt(0, pt1.convert2d(AcGePlane::kXYPlane));
			pPoly->addVertexAt(1, pt2.convert2d(AcGePlane::kXYPlane));
			pPoly->setColorIndex(7);

			pOutLine = pPoly;
			bRet = true;

			// 绘制边界线
			if (!bCreateSub)
			{
				DrawWayBorder(pt1, pt2, arSubPtr);
			}
		}
	} 
	else if (nType == 1) // 选择了中心线
	{
		int nBlockType = -1;
		if (m_pmapData->GetData(_T("BlockType"), nBlockType)) // 板块类型
		{
			AcGePoint3d ptMid;
			double dRoadMidEle = 0.0;
			if (!m_pmapData->GetData(_T("RoadMidPt"), ptMid)) // 道路中心线点
			{
				return false;
			}
			ptMid.transformBy(mat);
			ptMid.transformBy(matWcs);
			ptMid.z = 0.0;

			ptMid.x *= dX;
			ptMid.y *= dY;
			
			AcGeVector3d vtY = AcGeVector3d::kYAxis;
			AcGeVector3d vtX = AcGeVector3d::kXAxis;
			AcGePoint3d ptRoadLeft, ptRoadRight; // 道路端点
			AcGePoint3dArray arPt;
			if (nBlockType == 0) // 简单类型
			{
				arPt.setLogicalLength(3);
				double dGrad = 0.0; // 车行道坡度
				double dWidth = 0.0;    // 车行道宽度
				if (m_pmapData->GetData(_T("CarRoadWidth"), dWidth) &&
					m_pmapData->GetData(_T("CarRoadGradient"), dGrad))
				{
					dWidth *= dUnitMeter * dX;
					dGrad /= 100;
					
					AcGePoint3d pt1, pt2;
					pt1 = ptMid - vtX * dWidth + vtY * (dWidth * dGrad); 
					pt2 = ptMid + vtX * dWidth + vtY * (dWidth * dGrad); 
					arPt[0] = GlobalFunc::Ucs2Wcs(pt1);
					arPt[1] = GlobalFunc::Ucs2Wcs(ptMid);
					arPt[2] = GlobalFunc::Ucs2Wcs(pt2);
					ptRoadLeft = arPt[0];
					ptRoadRight = arPt[2];
				}
			} 
			else if (nBlockType == 1) // 单块板路
			{
				arPt.setLogicalLength(7);
				double dCarGrad = 0.0;   // 车行道坡度
				double dCarWidth = 0.0;  // 车行道宽度
				double dMenGrad = 0.0;	 // 人行道坡度
				double dMenWidth = 0.0;  // 人行道宽度
				double dMenHeight = 0.0; // 人道牙高度

				if (m_pmapData->GetData(_T("CarRoadWidth"), dCarWidth)&&
					m_pmapData->GetData(_T("CarRoadGradient"), dCarGrad)&&
					m_pmapData->GetData(_T("MenRoadWidth"), dMenWidth)&&
					m_pmapData->GetData(_T("MenRoadGrad"), dMenGrad)&&
					m_pmapData->GetData(_T("MenHeight"), dMenHeight))
				{
					dCarGrad /= 100;
					dCarWidth *= dUnitMeter * dX;
					dMenGrad /= 100;
					dMenWidth *= dUnitMeter * dX;
					dMenHeight *= dUnitMeter * dY;

					AcGePoint3d pt1, pt2, pt3, pt4, pt5, pt6;
					pt1 = ptMid - vtX * dCarWidth + vtY * (dCarWidth * dCarGrad);
					pt2 = ptMid + vtX * dCarWidth + vtY * (dCarWidth * dCarGrad);
					pt3 = pt1 + vtY * dMenHeight;
					pt4 = pt2 + vtY * dMenHeight;
					pt5 = pt3 - vtX * dMenWidth + vtY * (dMenWidth * dMenGrad);
					pt6 = pt4 + vtX * dMenWidth + vtY * (dMenWidth * dMenGrad);
					
					arPt[0] = GlobalFunc::Ucs2Wcs(pt5);
					arPt[1] = GlobalFunc::Ucs2Wcs(pt3);
					arPt[2] = GlobalFunc::Ucs2Wcs(pt1);
					arPt[3] = GlobalFunc::Ucs2Wcs(ptMid);
					arPt[4] = GlobalFunc::Ucs2Wcs(pt2);
					arPt[5] = GlobalFunc::Ucs2Wcs(pt4);
					arPt[6] = GlobalFunc::Ucs2Wcs(pt6);
					ptRoadLeft = arPt[0];
					ptRoadRight = arPt[6];
				}	
			}
			else if (nBlockType == 2) // 两块板路
			{
				arPt.setLogicalLength(11);
				double dGreenGrad = 0.0;    // 绿化带坡度
				double dGreenWidth = 0.0;   // 绿化带宽度
				double dCarGrad = 0.0;		// 车行道坡度
				double dCarWidth = 0.0;		// 车行道宽度
				double dMenGrad = 0.0;		// 人行道坡度
				double dMenWidth = 0.0;		// 人行道宽度
				double dMenHeight = 0.0;	// 人道牙高度
				double dSplitHeight = 0.0;	// 分道牙高度

				if (m_pmapData->GetData(_T("GreenGrad"), dGreenGrad)&&
					m_pmapData->GetData(_T("GreenWidth"), dGreenWidth)&&
					m_pmapData->GetData(_T("CarRoadWidth"), dCarWidth)&&
					m_pmapData->GetData(_T("CarRoadGradient"), dCarGrad)&&
					m_pmapData->GetData(_T("MenRoadWidth"), dMenWidth)&&
					m_pmapData->GetData(_T("MenRoadGrad"), dMenGrad)&&
					m_pmapData->GetData(_T("MenHeight"), dMenHeight)&&
					m_pmapData->GetData(_T("SplitHeight"), dSplitHeight))
				{
					dGreenGrad /= 100;
					dGreenWidth *= dUnitMeter * dX;
					dCarGrad /= 100;
					dCarWidth *= dUnitMeter * dX;
					dMenGrad /= 100;
					dMenWidth *= dUnitMeter * dX;
					dMenHeight *= dUnitMeter * dY;
					dSplitHeight *= dUnitMeter * dY;

					AcGePoint3d pt1, pt2, pt3, pt4, pt5, pt6, pt7, pt8, pt9, pt10;
					pt1 = ptMid - vtX * dGreenWidth + vtY * (dGreenWidth * dMenGrad);
					pt2 = ptMid + vtX * dGreenWidth + vtY * (dGreenWidth * dMenGrad);
					pt3 = pt1 - vtY * dSplitHeight;
					pt4 = pt2 - vtY * dSplitHeight;
					pt5 = pt3 - vtX * dCarWidth + vtY * (dCarWidth * dCarGrad);
					pt6 = pt4 + vtX * dCarWidth + vtY * (dCarWidth * dCarGrad);
					pt7 = pt5 + vtY * dMenHeight;
					pt8 = pt6 + vtY * dMenHeight;
					pt9 = pt7 - vtX * dMenWidth + vtY * (dMenWidth * dMenGrad);
					pt10 = pt8 + vtX * dMenWidth + vtY * (dMenWidth * dMenGrad);

					arPt[0] = GlobalFunc::Ucs2Wcs(pt9);
					arPt[1] = GlobalFunc::Ucs2Wcs(pt7);
					arPt[2] = GlobalFunc::Ucs2Wcs(pt5);
					arPt[3] = GlobalFunc::Ucs2Wcs(pt3);
					arPt[4] = GlobalFunc::Ucs2Wcs(pt1);
					arPt[5] = GlobalFunc::Ucs2Wcs(ptMid);
					arPt[6] = GlobalFunc::Ucs2Wcs(pt2);
					arPt[7] = GlobalFunc::Ucs2Wcs(pt4);
					arPt[8] = GlobalFunc::Ucs2Wcs(pt6);
					arPt[9] = GlobalFunc::Ucs2Wcs(pt8);
					arPt[10] = GlobalFunc::Ucs2Wcs(pt10);
					ptRoadLeft = arPt[0];
					ptRoadRight = arPt[10];
				}

			}
			else if (nBlockType == 3) // 三块板路
			{
				arPt.setLogicalLength(15);
				double dGreenGrad = 0.0;    // 绿化带坡度
				double dGreenWidth = 0.0;   // 绿化带宽度
				double dCarGrad = 0.0;		// 车行道坡度
				double dCarWidth = 0.0;		// 车行道宽度
				double dMenGrad = 0.0;		// 人行道坡度
				double dMenWidth = 0.0;		// 人行道宽度
				double dMenHeight = 0.0;	// 人道牙高度
				double dSplitHeight = 0.0;	// 分道牙高度
				double dNoCarWidth = 0.0;	// 非机动车道宽度
				double dNoCarGrad = 0.0;    // 非机动车道坡度
				
				if (m_pmapData->GetData(_T("GreenGrad"), dGreenGrad)&&
					m_pmapData->GetData(_T("GreenWidth"), dGreenWidth)&&
					m_pmapData->GetData(_T("CarRoadWidth"), dCarWidth)&&
					m_pmapData->GetData(_T("CarRoadGradient"), dCarGrad)&&
					m_pmapData->GetData(_T("MenRoadWidth"), dMenWidth)&&
					m_pmapData->GetData(_T("MenRoadGrad"), dMenGrad)&&
					m_pmapData->GetData(_T("MenHeight"), dMenHeight)&&
					m_pmapData->GetData(_T("SplitHeight"), dSplitHeight) &&
					m_pmapData->GetData(_T("NoCarWidth"), dNoCarWidth) &&
					m_pmapData->GetData(_T("NoCarGrad"), dNoCarGrad))
				{
					dGreenGrad /= 100;
					dGreenWidth *= dUnitMeter * dX;
					dCarGrad /= 100;
					dCarWidth *= dUnitMeter * dX;
					dMenGrad /= 100;
					dMenWidth *= dUnitMeter * dX;
					dMenHeight *= dUnitMeter * dY;
					dSplitHeight *= dUnitMeter * dY;
					dNoCarGrad /= 100;
					dNoCarWidth *= dUnitMeter * dX;

					AcGePoint3d pt1, pt2, pt3, pt4, pt5, pt6, pt7, pt8, pt9, pt10, pt11, pt12, pt13, pt14;
					pt1 = ptMid - vtX * dCarWidth + vtY * (dCarWidth * dCarGrad);
					pt2 = ptMid + vtX * dCarWidth + vtY * (dCarWidth * dCarGrad);
					pt3 = pt1 + vtY * dSplitHeight;
					pt4 = pt2 + vtY * dSplitHeight;
					pt5 = pt3 - vtX * dGreenWidth + vtY * (dGreenWidth * dGreenGrad);
					pt6 = pt4 + vtX * dGreenWidth + vtY * (dGreenWidth * dGreenGrad);
					pt7 = pt5 - vtY * dSplitHeight;
					pt8 = pt6 - vtY * dSplitHeight;
					pt9 = pt7 - vtX * dNoCarWidth + vtY * (dNoCarWidth * dNoCarGrad);
					pt10 = pt8 + vtX * dNoCarWidth + vtY * (dNoCarWidth * dNoCarGrad);
					pt11 = pt9 + vtY * dMenHeight;
					pt12 = pt10 + vtY * dMenHeight;
					pt13 = pt11 - vtX * dMenWidth + vtY * (dMenWidth * dMenGrad);
					pt14 = pt12 + vtX * dMenWidth + vtY * (dMenWidth * dMenGrad);

					arPt[0] = GlobalFunc::Ucs2Wcs(pt13);
					arPt[1] = GlobalFunc::Ucs2Wcs(pt11);
					arPt[2] = GlobalFunc::Ucs2Wcs(pt9);
					arPt[3] = GlobalFunc::Ucs2Wcs(pt7);
					arPt[4] = GlobalFunc::Ucs2Wcs(pt5);
					arPt[5] = GlobalFunc::Ucs2Wcs(pt3);
					arPt[6] = GlobalFunc::Ucs2Wcs(pt1);
					arPt[7] = GlobalFunc::Ucs2Wcs(ptMid);
					arPt[8] = GlobalFunc::Ucs2Wcs(pt2);
					arPt[9] = GlobalFunc::Ucs2Wcs(pt4);
					arPt[10] = GlobalFunc::Ucs2Wcs(pt6);
					arPt[11] = GlobalFunc::Ucs2Wcs(pt8);
					arPt[12] = GlobalFunc::Ucs2Wcs(pt10);
					arPt[13] = GlobalFunc::Ucs2Wcs(pt12);
					arPt[14] = GlobalFunc::Ucs2Wcs(pt14);
					ptRoadLeft = arPt[0];
					ptRoadRight = arPt[14];
				}	
			}
			else if (nBlockType == 4) // 四块板路
			{
				arPt.setLogicalLength(19);
				double dGreenGrad = 0.0;    // 绿化带坡度
				double dGreenWidth = 0.0;   // 绿化带宽度
				double dGreenGrad2 = 0.0;    // 绿化带坡度
				double dGreenWidth2 = 0.0;   // 绿化带宽度
				double dCarGrad = 0.0;		// 车行道坡度
				double dCarWidth = 0.0;		// 车行道宽度
				double dMenGrad = 0.0;		// 人行道坡度
				double dMenWidth = 0.0;		// 人行道宽度
				double dMenHeight = 0.0;	// 人道牙高度
				double dSplitHeight = 0.0;	// 分道牙高度
				double dNoCarWidth = 0.0;	// 非机动车道宽度
				double dNoCarGrad = 0.0;    // 非机动车道坡度

				if (m_pmapData->GetData(_T("GreenGrad"), dGreenGrad)&&
					m_pmapData->GetData(_T("GreenWidth"), dGreenWidth)&&
					m_pmapData->GetData(_T("GreenGrad2"), dGreenGrad2)&&
					m_pmapData->GetData(_T("GreenWidth2"), dGreenWidth2)&&
					m_pmapData->GetData(_T("CarRoadWidth"), dCarWidth)&&
					m_pmapData->GetData(_T("CarRoadGradient"), dCarGrad)&&
					m_pmapData->GetData(_T("MenRoadWidth"), dMenWidth)&&
					m_pmapData->GetData(_T("MenRoadGrad"), dMenGrad)&&
					m_pmapData->GetData(_T("MenHeight"), dMenHeight)&&
					m_pmapData->GetData(_T("SplitHeight"), dSplitHeight) &&
					m_pmapData->GetData(_T("NoCarWidth"), dNoCarWidth) &&
					m_pmapData->GetData(_T("NoCarGrad"), dNoCarGrad))
				{
					dGreenGrad /= 100;
					dGreenWidth *= dUnitMeter * dX;
					dCarGrad /= 100;
					dCarWidth *= dUnitMeter * dX;
					dMenGrad /= 100;
					dMenWidth *= dUnitMeter * dX;
					dMenHeight *= dUnitMeter * dY;
					dSplitHeight *= dUnitMeter * dY;
					dNoCarGrad /= 100;
					dNoCarWidth *= dUnitMeter * dX;
					dGreenGrad2 /= 100;
					dGreenWidth2 *= dUnitMeter * dX;

					AcGePoint3d pt1, pt2, pt3, pt4, pt5, pt6, pt7, pt8, pt9, 
								pt10, pt11, pt12, pt13, pt14, pt15, pt16, pt17, pt18;

					pt1 = ptMid - vtX * dGreenWidth + vtY * (dGreenWidth * dGreenGrad);
					pt2 = ptMid + vtX * dGreenWidth + vtY * (dGreenWidth * dGreenGrad);
					pt3 = pt1 - vtY * dSplitHeight;
					pt4 = pt2 - vtY * dSplitHeight;
					pt5 = pt3 - vtX * dCarWidth + vtY * (dCarWidth * dCarGrad);
					pt6 = pt4 + vtX * dCarWidth + vtY * (dCarWidth * dCarGrad);
					pt7 = pt5 + vtY * dSplitHeight;
					pt8 = pt6 + vtY * dSplitHeight;
					pt9 = pt7 - vtX * dGreenWidth2 + vtY * (dGreenWidth2 * dGreenGrad2);
					pt10 = pt8 + vtX * dGreenWidth2 + vtY * (dGreenWidth2 * dGreenGrad2);
					pt11 = pt9 - vtY * dSplitHeight;
					pt12 = pt10 - vtY * dSplitHeight;
					pt13 = pt11 - vtX * dNoCarWidth + vtY * (dNoCarWidth * dNoCarGrad);
					pt14 = pt12 + vtX * dNoCarWidth + vtY * (dNoCarWidth * dNoCarGrad);
					pt15 = pt13 + vtY * dMenHeight;
					pt16 = pt14 + vtY * dMenHeight;
					pt17 = pt15 - vtX * dMenWidth + vtY * (dMenWidth * dMenGrad);
					pt18 = pt16 + vtX * dMenWidth + vtY * (dMenWidth * dMenGrad);

					arPt[0] = GlobalFunc::Ucs2Wcs(pt17);
					arPt[1] = GlobalFunc::Ucs2Wcs(pt15);
					arPt[2] = GlobalFunc::Ucs2Wcs(pt13);
					arPt[3] = GlobalFunc::Ucs2Wcs(pt11);
					arPt[4] = GlobalFunc::Ucs2Wcs(pt9);
					arPt[5] = GlobalFunc::Ucs2Wcs(pt7);
					arPt[6] = GlobalFunc::Ucs2Wcs(pt5);
					arPt[7] = GlobalFunc::Ucs2Wcs(pt3);
					arPt[8] = GlobalFunc::Ucs2Wcs(pt1);
					arPt[9] = GlobalFunc::Ucs2Wcs(ptMid);
					arPt[10] = GlobalFunc::Ucs2Wcs(pt2);
					arPt[11] = GlobalFunc::Ucs2Wcs(pt4);
					arPt[12] = GlobalFunc::Ucs2Wcs(pt6);
					arPt[13] = GlobalFunc::Ucs2Wcs(pt8);
					arPt[14] = GlobalFunc::Ucs2Wcs(pt10);
					arPt[15] = GlobalFunc::Ucs2Wcs(pt12);
					arPt[16] = GlobalFunc::Ucs2Wcs(pt14);
					arPt[17] = GlobalFunc::Ucs2Wcs(pt16);
					arPt[18] = GlobalFunc::Ucs2Wcs(pt18);
					ptRoadLeft = arPt[0];
					ptRoadRight = arPt[18];
				}	
			}	

			if (arPt.length() != 0)
			{
				AcDbPolyline *pPoly = new AcDbPolyline();
				for (int i = 0; i < arPt.length(); i++)
				{
					pPoly->addVertexAt(i, arPt[i].convert2d(AcGePlane::kXYPlane));
				}

				pPoly->setColorIndex(7);
				pOutLine = pPoly;
				bRet = true;

				// 绘制边界线
				if (!bCreateSub)
				{
					DrawWayBorder(ptRoadLeft, ptRoadRight, arSubPtr);
				}
			}
		}
	}

	if (bCreateSub)
	{
		// 绘制箭头
		AcDbEntity *pEnt = NULL;
		DrawArrow(pEnt); 
		arSubPtr.append((void *)pEnt);

		//分割线
		DrawDivision(arSplitLine);

		//绘制文字
		AcGePoint3d ptL, ptR, ptUp;
		if (nType == 1) // 选择了中心线
		{
			AcGePoint3d ptMid;
			double dRoadMidEle = 0.0;
			if (!m_pmapData->GetData(_T("RoadMidPt"), ptMid)) // 道路中心线点
			{
				return false;
			}
			ptMid.transformBy(mat);
			ptMid.transformBy(matWcs);
			ptMid.z = 0.0;
			
			ptMid.x *= dX;
			ptMid.y *= dY;

			double dVal = 0.0;
			GetMaxVal(dVal);  // 道牙最大值

			std::set<double> data;
			double dLen = 0.0;
			GetWayInfo(dLen, data);
			if (GlobalFunc::DocGetMeterUnitDraw())
			{
				dLen += dUnitMeter * dX;
				ptUp = ptMid + vtToY * (2.6 * dUnitMeter + dVal) * dY - vtToX * 15 * GlobalFunc::DocGetPScale();
				ptL = ptMid - vtToX * (dLen / 2 + 7 * GlobalFunc::DocGetPScale()) + vtToY * (2.5 * dUnitMeter + dVal) * dY;
			    ptR = ptMid + vtToX * dLen / 2 + vtToY * (2.5 * dUnitMeter + dVal) * dY;
			} 
			else
			{
				dLen += dUnitMeter * dX;
				ptUp = ptMid + vtToY * (2.6 * dUnitMeter + dVal) * dY - vtToX * 10 * GlobalFunc::DocGetPScale();
				ptL = ptMid - vtToX * (dLen / 2 + 5 * GlobalFunc::DocGetPScale()) + vtToY * (2.5 * dUnitMeter + dVal) * dY;
			    ptR = ptMid + vtToX * dLen / 2 + vtToY * (2.5 * dUnitMeter + dVal) * dY;
			}

			DrawText(GlobalFunc::Ucs2Wcs(ptUp), _T("剖切方向"), TRUE, pEnt);
			if (pEnt != NULL)
			{
				arSplitLine.append(pEnt);
			}
			
			DrawText(GlobalFunc::Ucs2Wcs(ptL), _T("道路左侧"), FALSE, pEnt);
			if (pEnt != NULL)
			{
				arSplitLine.append(pEnt);
			}
			
			DrawText(GlobalFunc::Ucs2Wcs(ptR), _T("道路右侧"), FALSE, pEnt);
			if (pEnt != NULL)
			{
				arSplitLine.append(pEnt);
			}
		}
	}

	return bRet;
}

inline bool CDrawSectionSymbol::IsIntersect(const AcDbLine &line1, const AcDbLine &line2, AcGePoint3d &ptInt)
{
	AcGePoint3dArray arPt;
	line1.intersectWith(&line2, AcDb::kOnBothOperands, arPt);
	if (arPt.length() == 1)
	{
		ptInt = arPt[0];
		return true;
	}
	return false;
}

bool CDrawSectionSymbol::DrawRoadDist(AcDbVoidPtrArray &arPtr)
{
	bool bRet = false;
	int nType = -1;
	m_pmapData->GetData(_T("Type"), nType);

	std::set<double> setData; 
	std::map<AcDbObjectId,AcGePoint3d>::iterator it;
	double dMinY = 0.0, dMinX = 0.0;
	for (it = m_mapPipe.begin(); it != m_mapPipe.end(); it++)
	{
		AcGePoint3d ptPipe = (*it).second;
		ptPipe = GlobalFunc::Wcs2Ucs(ptPipe);
		if (it == m_mapPipe.begin())
		{
			dMinX = ptPipe.x;
			dMinY = ptPipe.y;
		} 
		else
		{
			if (dMinY > ptPipe.y)
			{
				dMinY = ptPipe.y;
			}
			
			if (dMinX > ptPipe.x)
			{
				dMinX = ptPipe.x;
			}
		}

		setData.insert(ptPipe.x);
	}

	double dUnitMeter = 1000;

	// 比例系数
	double dX = 1, dY = 1;
	GetScaleXY(dX, dY);
	dX = GlobalFunc::DocGetPScale() / dX;
    dY = GlobalFunc::DocGetPScale() / dY;

	double dDist = dUnitMeter; 
	AcGeVector3d vtX = AcGeVector3d::kXAxis;
	if (nType == 0) // 未选择中心线
	{
		if (m_mapPipe.size() > 1)
		{
			AcGePoint3d ptBase(dMinX, dMinY - dDist * dY, 0.0);
			std::set<double>::iterator iter;
			AcGePoint3dArray arPt;
			for (iter = setData.begin(); iter != setData.end(); iter++)
			{
				AcGePoint3d pt = ptBase + vtX * (*iter - dMinX);
				pt = GlobalFunc::Ucs2Wcs(pt);
				arPt.append(pt);
			}

			DrawLabel(arPt, arPtr); // 标注管线间距

			// 绘制名称，比例
			AcGeVector3d vtY = AcGeVector3d::kYAxis;
			DrawNameInfo(GlobalFunc::Wcs2Ucs(arPt[0]) - vtY * dUnitMeter * dY, arPtr, true);
			
		}

		bRet = true;
	} 
	else if (nType == 1) // 选择了中心线
	{
		// 获取剖切点,剖切方向,道路中心点
		AcGePoint3d ptS, ptE, ptMid;
	    AcGeVector3d vtView;
		double dRoadMidEle = 0.0;
		if (m_pmapData->GetData(_T("CutS"), ptS)&&
			m_pmapData->GetData(_T("CutE"), ptE)&&
			m_pmapData->GetData(_T("vtView"), vtView)&&
			m_pmapData->GetData(_T("RoadMidPt"), ptMid)&&
			m_pmapData->GetData(_T("RoadEle"), dRoadMidEle))
		{

			AcGePlane    plane(ptS, vtView); //以剖切0点，剖切方向，确定投影面
			AcGePoint3d  ptOrigin;
			AcGeVector3d vtNormal(0,0,1);
			AcGeVector3d vtToX(1,0,0);
			AcGeVector3d vtToY(0,1,0);
			
			//顺着剖切的方向是Y轴，根据右手定则，与z轴差乘是X轴
			AcGeMatrix3d mat;
			AcGeVector3d vtFromX = vtView.crossProduct(vtNormal);
			mat.setToAlignCoordSys(ptOrigin, vtFromX, vtView, vtNormal, ptOrigin, vtToX, vtToY, vtNormal);
			
			//把投影到PLANE的结果，坐标转换到正常坐标，因为有高度，所以再旋转90度
			AcGeMatrix3d matWcs;
			matWcs.setToRotation(-PI/2, vtToX);

			ptMid.transformBy(mat);
			ptMid.transformBy(matWcs);
			ptMid.z = 0.0;  // 道路中心点

			ptMid.x *= dX;
			ptMid.y *= dY;

			AcGePoint3d ptTemp(ptMid.x, dMinY - dDist * dY, 0.0);
			double dWayWidth = 0.0;   // 道路宽度
			std::set<double> setWay;  
			GetWayInfo(dWayWidth,setWay, true); // 获得道路宽度，道路各个部分距道路一端的距离
			AcGePoint3d ptBase = ptTemp - vtToX * dWayWidth / 2;  
		
			// 管线道路标注
			std::set<double> setData;
			std::set<double>::iterator it2;
			for(it2 = setWay.begin(); it2 != setWay.end(); it2++)
			{
				setData.insert((*it2) * dUnitMeter);
			}

			for (it = m_mapPipe.begin(); it != m_mapPipe.end(); it++)
			{
				AcGePoint3d pt = (*it).second;
				pt = GlobalFunc::Wcs2Ucs(pt);
				setData.insert(pt.x - ptBase.x);
			}

			AcGePoint3dArray arPt;
			for (it2 = setData.begin(); it2 != setData.end(); it2++)
			{
				AcGePoint3d pt = ptBase + vtX * (*it2);
				pt = GlobalFunc::Ucs2Wcs(pt);
				arPt.append(pt);	
			}
			DrawLabel(arPt, arPtr); 

			// 道路标注
			setWay.clear();
			GetWayInfo(dWayWidth,setWay);
			arPt.setLogicalLength(0);
			for (it2 = setWay.begin(); it2 != setWay.end(); it2++)
			{
				AcGePoint3d pt = ptBase + vtX * (*it2) * dUnitMeter - AcGeVector3d::kYAxis * 0.5 * dUnitMeter * dY;
				pt = GlobalFunc::Ucs2Wcs(pt);
				arPt.append(pt);
			}
			DrawLabel(arPt, arPtr);	

			//道路总长标注
			if (setWay.size() >= 2)
			{
				arPt.setLogicalLength(0);
				it2 = setWay.begin();
		    	AcGePoint3d pt1 = ptBase + vtX * (*it2) * dUnitMeter  - AcGeVector3d::kYAxis * dUnitMeter * dY;
				arPt.append(GlobalFunc::Ucs2Wcs(pt1));
				it2 = setWay.end();
				--it2;
		    	AcGePoint3d pt2 = ptBase + vtX * (*it2) * dUnitMeter  - AcGeVector3d::kYAxis * dUnitMeter * dY;
				arPt.append(GlobalFunc::Ucs2Wcs(pt2));

				DrawLabel(arPt, arPtr);	
			}

			// 绘制管线信息
			AcGePoint3d ptS, ptE;
			ptS = ptBase - vtToY * 2.5 * dUnitMeter * dY;
			ptE = ptS + vtToX * dWayWidth;
			ptS = GlobalFunc::Ucs2Wcs(ptS);
			ptE = GlobalFunc::Ucs2Wcs(ptE);
			AecDbDimension* pDim = new AecDbDimension;
			pDim->setLayer(InitLayer(_T("TWT_DIM")));
			pDim->SetPScale(0.08 * GlobalFunc::DocGetPScale());
			pDim->SetLocation(arPt[0]);
			pDim->SetDist2DimLine(-2.0 * dUnitMeter * dY, FALSE);
			pDim->SetStyleId(InitDimStyle(DS_LINEAR));
			pDim->SetRotation(GlobalFunc::Ucs2Wcs(0.0));
			pDim->SetLayoutRotation(GlobalFunc::Ucs2Wcs(0.0));
			pDim->AddSegment(ptS);
			pDim->AddSegment(ptE);
			pDim->SetTextContent(0, _T("  "));
			arPtr.append((void*)pDim);

			ptS = GlobalFunc::Wcs2Ucs(ptS);
			std::map<AcDbObjectId, AcGePoint3d> mapData;
			for (it = m_mapPipe.begin(); it != m_mapPipe.end(); it++)
			{
				AcGePoint3d ptPipe = GlobalFunc::Wcs2Ucs((*it).second);
				AcGePoint3d pt = ptS + vtX * (ptPipe.x - ptS.x) - vtToY * 0.4 * dUnitMeter * dY;
				pt = GlobalFunc::Ucs2Wcs(pt);
				mapData.insert(std::make_pair((*it).first, pt));
			}
			DrawPipeInfo(mapData, arPtr);

			// 绘制名称，比例
			AcGeVector3d vtY = AcGeVector3d::kYAxis;
			DrawNameInfo(ptS - vtY * dUnitMeter * dY + vtX * dWayWidth / 2, arPtr);

			// 绘制道路中心线
			ptS = ptMid + vtToY * 2.0 * dUnitMeter * dY;
			ptE = ptMid - vtToY * (ptMid.y - ptBase.y + 0.7 * dUnitMeter * dY) ;
			ptS = GlobalFunc::Ucs2Wcs(ptS);
			ptE = GlobalFunc::Ucs2Wcs(ptE);
			AcDbLine *pLine = new AcDbLine(ptS, ptE);
			pLine->setLayer(InitLayer(_T("TWT_室外")));
			pLine->setLinetype(_T("DASH"));
			pLine->setColorIndex(7);
			arPtr.append((void *)pLine);		
		}	
	}

	return bRet;
}

bool CDrawSectionSymbol::DrawLabel(const AcGePoint3dArray &arPt, AcDbVoidPtrArray &arPtr)
{
	if (arPt.length() < 2)
	{
		return false;
	}
		
	double dUnitMeter = 1000;

	// 比例系数
	double dX = 1 , dY = 1;
	GetScaleXY(dX, dY);
	dX = dX / GlobalFunc::DocGetPScale();
	dY = GlobalFunc::DocGetPScale() / dY;

	AecDbDimension* pDim = new AecDbDimension;
	pDim->setLayer(InitLayer(_T("TWT_DIM")));
	pDim->SetPScale(0.8 * GlobalFunc::DocGetPScale());
	pDim->SetLocation(arPt[0]);
	pDim->SetDist2DimLine(-0.5 * dUnitMeter * dY, FALSE);
	pDim->SetStyleId(InitDimStyle(DS_LINEAR));
	pDim->SetRotation(GlobalFunc::Ucs2Wcs(0.0));
	pDim->SetLayoutRotation(GlobalFunc::Ucs2Wcs(0.0));
	
	CString strLabel;
	pDim->AddSegment(arPt[0]);
	for (int i = 1; i < arPt.length(); i++)
	{
		pDim->AddSegment(arPt[i]);
		double dDist = arPt[i-1].distanceTo(arPt[i]) / dUnitMeter * dX;
		strLabel.Format(_T("%.2f"), dDist);
		int nIndex = strLabel.GetLength() - 1;
		if (!strLabel.IsEmpty() && strLabel.GetAt(nIndex) == _T('0'))
		{
			strLabel.SetAt(nIndex,_T(' '));
		}
		pDim->SetTextContent(i-1,strLabel);
	}
	
	arPtr.append((void*)pDim);

	return true;
}

bool CDrawSectionSymbol::DrawNameInfo(const AcGePoint3d &ptText, AcDbVoidPtrArray &arPtr, bool bGeneral)
{
	bool bRet = false;
	CString strNumber;
	double dScaleX = 0.0, dScaleY = 0.0;
	if (m_pmapData->GetData(_T("ScaleX"), dScaleX)&&
		m_pmapData->GetData(_T("ScaleY"), dScaleY)&&
		m_pmapData->GetData(_T("Number"), strNumber))
	{
		double dUnitMeter = 1000;
		double dH = 1.0;

		// 比例系数
		double dX = 1, dY = 1;
		GetScaleXY(dX, dY);
		dX = GlobalFunc::DocGetPScale() / dX;
        dY = GlobalFunc::DocGetPScale() / dY;	

		CString strText = strNumber + _T("-") + strNumber + _T(" 标准横断面图");

		AecXDbText *pText1 = new AecXDbText;
		AcDbObjectId idTextStyle=GlobalFunc::InitTwtTextStyle(g_Option::instance().g_csSheetStyle);
		pText1->SetStyleId(idTextStyle);
		pText1->SetHeight(5.0);
		pText1->setColorIndex(7);
		if (bGeneral)
		{
			pText1->SetAlignment(AcGiDraw::kTopLeft);
		}
		else
		{
			pText1->SetAlignment(AcGiDraw::kMiddleCenter);
		}
		pText1->SetRotation(GlobalFunc::Ucs2Wcs(0.0));
		pText1->SetText(strText);
		pText1->setLayer(InitLayer(_T("TWT_室外")));
		pText1->SetLocation(GlobalFunc::Ucs2Wcs(ptText));
		arPtr.append((void*)pText1);

		double dWidth = 0.0, dHeight = 0.0;
		pText1->GetExtents(&dWidth, &dHeight);

		AcGePoint3d ptS, ptE;
		if (bGeneral)
		{
			ptS = ptText - AcGeVector3d::kYAxis * dHeight;
			ptE = ptText + AcGeVector3d::kXAxis * dWidth - AcGeVector3d::kYAxis * dHeight;
			ptS = GlobalFunc::Ucs2Wcs(ptS);
			ptE = GlobalFunc::Ucs2Wcs(ptE);
			AcDbPolyline *pLine = new AcDbPolyline();
			pLine->addVertexAt(0, ptS.convert2d(AcGePlane::kXYPlane), 0, 20 * dY, 20 * dY);
			pLine->addVertexAt(0, ptE.convert2d(AcGePlane::kXYPlane), 0, 20 * dY, 20 * dY);
			pLine->setLayer(InitLayer(_T("TWT_室外")));
			pLine->setColorIndex(7);
		    arPtr.append((void*)pLine);
		} 
		else
		{
			ptS = ptText - AcGeVector3d::kXAxis * dWidth / 2 - AcGeVector3d::kYAxis * dHeight / 2;
			ptE = ptText + AcGeVector3d::kXAxis * dWidth / 2 - AcGeVector3d::kYAxis * dHeight / 2;
			ptS = GlobalFunc::Ucs2Wcs(ptS);
			ptE = GlobalFunc::Ucs2Wcs(ptE);
			AcDbPolyline *pLine = new AcDbPolyline();
			pLine->addVertexAt(0, ptS.convert2d(AcGePlane::kXYPlane), 0, 20 * dY, 20 * dY);
			pLine->addVertexAt(0, ptE.convert2d(AcGePlane::kXYPlane), 0, 20 * dY, 20 * dY);
			pLine->setLayer(InitLayer(_T("TWT_室外")));
			pLine->setColorIndex(7);
		    arPtr.append((void*)pLine);
		}


		if (fabs(dScaleX - dScaleY) < 1e-3)
		{
			strText.Empty();
			strText.Format(_T("比例 1: %.3f"), dScaleX);
			strText.TrimRight(_T("0"));
			strText.TrimRight(_T("."));
		} 
		else
		{
			CString strScale;
			strScale.Format(_T("横 1: %.3f"), dScaleX);
			strScale.TrimRight(_T("0"));
			strScale.TrimRight(_T("."));
			strText.Empty();
			strText += strScale;
			strScale.Format(_T("\\P纵 1: %.3f"), dScaleY);
			strScale.TrimRight(_T("0"));
			strScale.TrimRight(_T("."));
		    strText += strScale;
		}

		AcDbMText *pText2 = new AcDbMText;
		idTextStyle=GlobalFunc::InitTwtTextStyle(g_Option::instance().g_csSheetStyle);
		pText2->setTextStyle(idTextStyle);
		pText2->setTextHeight(3.0 * GlobalFunc::DocGetPScale());
		pText2->setColorIndex(7);
		pText2->setRotation(GlobalFunc::Ucs2Wcs(0.0));
		pText2->setContents(strText);
		pText2->setRotation(0.0);
		pText2->setLayer(InitLayer(_T("TWT_室外")));
		if (bGeneral)
		{		
			if (fabs(dScaleX - dScaleY) < 1e-3)
			{
				pText2->setLocation(GlobalFunc::Ucs2Wcs(ptText + AcGeVector3d::kXAxis * (dWidth + dHeight) - AcGeVector3d::kYAxis * dHeight / 4));
			}
			else
			{
				pText2->setLocation(GlobalFunc::Ucs2Wcs(ptText + AcGeVector3d::kXAxis * (dWidth + dHeight) + AcGeVector3d::kYAxis * dHeight / 4));
			}
		} 
		else
		{
			if (fabs(dScaleX - dScaleY) < 1e-3)
			{
				pText2->setLocation(GlobalFunc::Ucs2Wcs(ptText + AcGeVector3d::kXAxis * (dWidth / 2 + dHeight) + AcGeVector3d::kYAxis * dHeight / 4));
			} 
			else
			{
				pText2->setLocation(GlobalFunc::Ucs2Wcs(ptText + AcGeVector3d::kXAxis * (dWidth / 2 + dHeight) + AcGeVector3d::kYAxis * dHeight * 3 / 4));
			}		
		}
		arPtr.append((void*)pText2);
		
		bRet = true;
	}
	return bRet;
}

bool CDrawSectionSymbol::DrawWayBorder(const AcGePoint3d &ptL, const AcGePoint3d &ptR, AcDbVoidPtrArray& arPtr)
{
	double dUnitMeter = 1000;
	double dX = 1.0, dY = 1.0;
	GetScaleXY(dX, dY);
	dX = GlobalFunc::DocGetPScale() / dX;
	dY = GlobalFunc::DocGetPScale() / dY;

	AcGePoint3d pt1 = GlobalFunc::Wcs2Ucs(ptL);
	AcGePoint3d pt2 = GlobalFunc::Wcs2Ucs(ptR);
	AcGeVector3d vtX = AcGeVector3d::kXAxis;
	AcGeVector3d vtY = AcGeVector3d::kYAxis;
	AcGeVector3d vtL = vtX * dX, vtR = vtX * dX;
	vtL.rotateBy(-PI / 4, AcGeVector3d::kZAxis);
	vtR.rotateBy(PI / 4, AcGeVector3d::kZAxis);

	AcDbLine *pLineLeft = new AcDbLine(GlobalFunc::Ucs2Wcs(pt1), GlobalFunc::Ucs2Wcs(pt1 + vtY * 2.0 * dUnitMeter * dY));
	pLineLeft->setLayer(InitLayer(_T("TWT_室外")));
	pLineLeft->setColorIndex(7);
	AcDbLine *pLineRight = new AcDbLine(GlobalFunc::Ucs2Wcs(pt2), GlobalFunc::Ucs2Wcs(pt2 + vtY * 2.0 * dUnitMeter * dY));
	pLineRight->setLayer(InitLayer(_T("TWT_室外")));
	pLineRight->setColorIndex(7);
	arPtr.append((void *)pLineLeft);
	arPtr.append((void *)pLineRight);

	AcDbLine *pLine1 = new AcDbLine(GlobalFunc::Ucs2Wcs(pt1 + vtY * 2.0 * dUnitMeter * dY + vtL * 0.2 * dUnitMeter), GlobalFunc::Ucs2Wcs(pt1 + vtY * 2.0 * dUnitMeter * dY - vtL * 0.2 * dUnitMeter));
	pLine1->setLayer(InitLayer(_T("TWT_室外")));
	pLine1->setColorIndex(7);
	
	AcDbLine *pLine2 = new AcDbLine(GlobalFunc::Ucs2Wcs(pt2 + vtY * 2.0 * dUnitMeter * dY + vtR * 0.2 * dUnitMeter), GlobalFunc::Ucs2Wcs(pt2 + vtY * 2.0 * dUnitMeter * dY - vtR * 0.2 * dUnitMeter));
	pLine2->setLayer(InitLayer(_T("TWT_室外")));
	pLine2->setColorIndex(7);
	arPtr.append((void *)pLine1);
	arPtr.append((void *)pLine2);

	return false;
}

bool CDrawSectionSymbol::GetWayInfo(double &dWayWidth, std::set<double> &setWay, bool bMidPt)
{
	bool bRet = false;
	int nBlockType = -1;
	double dUnitMeter = 1000;

	// 比例系数
	double dX = 1, dY = 1;
	GetScaleXY(dX, dY);
	dX = GlobalFunc::DocGetPScale() / dX;
	dY = GlobalFunc::DocGetPScale() / dY;

	if (m_pmapData->GetData(_T("BlockType"), nBlockType)) // 板块类型
	{
		if (nBlockType == 0) // 简单类型
		{
			double dGrad = 0.0; // 车行道坡度
			double dWidth = 0.0;    // 车行道宽度
			if (m_pmapData->GetData(_T("CarRoadWidth"), dWidth))
			{
				dWayWidth = dWidth * dUnitMeter * dX;
				setWay.insert(0.0);
				if (bMidPt)
				{
					setWay.insert(dWidth * dX);
				}
				setWay.insert(dWidth*2 * dX);
			}
		} 
		else if (nBlockType == 1) // 单块板路
		{
			double dCarWidth = 0.0;  // 车行道宽度
			double dMenWidth = 0.0;  // 人行道宽度
			
			if (m_pmapData->GetData(_T("CarRoadWidth"), dCarWidth)&&
				m_pmapData->GetData(_T("MenRoadWidth"), dMenWidth))
			{
				dWayWidth = (dCarWidth + dMenWidth) * dUnitMeter * dX;
				setWay.insert(0.0);
				setWay.insert(dMenWidth * dX);
				if (bMidPt)
				{
					setWay.insert((dMenWidth + dCarWidth) * dX);
				}
				setWay.insert((dMenWidth + dCarWidth * 2) * dX);
				setWay.insert((dMenWidth * 2 + dCarWidth * 2) * dX);
			}	
		}
		else if (nBlockType == 2) // 两块板路
		{
			double dGreenWidth = 0.0;   // 绿化带宽度
			double dCarWidth = 0.0;		// 车行道宽度
			double dMenWidth = 0.0;		// 人行道宽度
			
			if (m_pmapData->GetData(_T("GreenWidth"), dGreenWidth)&&
				m_pmapData->GetData(_T("CarRoadWidth"), dCarWidth)&&
				m_pmapData->GetData(_T("MenRoadWidth"), dMenWidth))
			{
				dWayWidth = (dGreenWidth + dCarWidth + dMenWidth) * dUnitMeter * dX;
				setWay.insert(0.0);
				setWay.insert(dMenWidth * dX);
				setWay.insert((dMenWidth + dCarWidth) * dX);
				if (bMidPt)
				{
					setWay.insert((dMenWidth + dCarWidth + dGreenWidth) * dX);
				}
				setWay.insert((dMenWidth + dCarWidth + dGreenWidth * 2) * dX);
				setWay.insert((dMenWidth + dCarWidth * 2 + dGreenWidth * 2) * dX);
				setWay.insert((dMenWidth * 2 + dCarWidth * 2 + dGreenWidth * 2) * dX);
			}
			
		}
		else if (nBlockType == 3) // 三块板路
		{
			double dGreenWidth = 0.0;   // 绿化带宽度
			double dCarWidth = 0.0;		// 车行道宽度
			double dMenWidth = 0.0;		// 人行道宽度
			double dNoCarWidth = 0.0;	// 非机动车道宽度
			
			if (m_pmapData->GetData(_T("GreenWidth"), dGreenWidth)&&
				m_pmapData->GetData(_T("CarRoadWidth"), dCarWidth)&&
				m_pmapData->GetData(_T("MenRoadWidth"), dMenWidth)&&
				m_pmapData->GetData(_T("NoCarWidth"), dNoCarWidth))
			{
				dWayWidth = (dGreenWidth + dCarWidth + dMenWidth + dNoCarWidth) * dUnitMeter * dX;
				setWay.insert(0.0);
				setWay.insert(dMenWidth * dX);
				setWay.insert((dMenWidth + dNoCarWidth) * dX);
				setWay.insert((dMenWidth + dNoCarWidth + dGreenWidth) * dX);
				if (bMidPt)
				{
					setWay.insert((dMenWidth + dNoCarWidth + dGreenWidth + dCarWidth) * dX);
				}
				setWay.insert((dMenWidth + dNoCarWidth + dGreenWidth + dCarWidth * 2) * dX);
				setWay.insert((dMenWidth + dNoCarWidth + dGreenWidth * 2 + dCarWidth * 2) * dX);
				setWay.insert((dMenWidth + dNoCarWidth * 2 + dGreenWidth * 2 + dCarWidth * 2) * dX);
				setWay.insert((dMenWidth * 2 + dNoCarWidth * 2 + dGreenWidth * 2 + dCarWidth * 2) * dX);
			}	
		}
		else if (nBlockType == 4) // 四块板路
		{
			double dGreenWidth = 0.0;   // 绿化带宽度
			double dGreenWidth2 = 0.0;   // 绿化带宽度
			double dCarWidth = 0.0;		// 车行道宽度
			double dMenWidth = 0.0;		// 人行道宽度
			double dNoCarWidth = 0.0;	// 非机动车道宽度
			
			if (m_pmapData->GetData(_T("GreenWidth"), dGreenWidth)&&
				m_pmapData->GetData(_T("GreenWidth2"), dGreenWidth2)&&
				m_pmapData->GetData(_T("CarRoadWidth"), dCarWidth)&&
				m_pmapData->GetData(_T("MenRoadWidth"), dMenWidth)&&
				m_pmapData->GetData(_T("NoCarWidth"), dNoCarWidth))
			{
				dWayWidth = (dGreenWidth + dGreenWidth2 + dCarWidth + dMenWidth + dNoCarWidth) * dUnitMeter * dX;
				setWay.insert(0.0);
				setWay.insert(dMenWidth * dX);
				setWay.insert((dMenWidth + dNoCarWidth) * dX);
				setWay.insert((dMenWidth + dNoCarWidth + dGreenWidth2) * dX);
				setWay.insert((dMenWidth + dNoCarWidth + dGreenWidth2 + dCarWidth) * dX);
				if (bMidPt)
				{
					setWay.insert((dMenWidth + dNoCarWidth + dGreenWidth2 + dCarWidth + dGreenWidth) * dX);
				}
				setWay.insert((dMenWidth + dNoCarWidth + dGreenWidth2 + dCarWidth + dGreenWidth * 2) * dX);
				setWay.insert((dMenWidth + dNoCarWidth + dGreenWidth2 + dCarWidth * 2 + dGreenWidth * 2) * dX);
				setWay.insert((dMenWidth + dNoCarWidth + dGreenWidth2 * 2 + dCarWidth * 2 + dGreenWidth * 2) * dX);
				setWay.insert((dMenWidth + dNoCarWidth * 2 + dGreenWidth2 * 2 + dCarWidth * 2 + dGreenWidth * 2) * dX);
				setWay.insert((dMenWidth * 2 + dNoCarWidth * 2 + dGreenWidth2 * 2 + dCarWidth * 2 + dGreenWidth * 2) * dX);
			}	
		}

		dWayWidth *= 2;
	}	
	return bRet;
}

bool CDrawSectionSymbol::DrawPipeInfo(const std::map<AcDbObjectId, AcGePoint3d>& mapData, AcDbVoidPtrArray& arPtr)
{
	if (mapData.size() == 0)
	{
		return false;
	}

	std::map<AcDbObjectId,AcGePoint3d>::const_iterator it, it2;
	CDbPipe *pPipe = NULL;
	for (it = mapData.begin(); it != mapData.end(); it++)
	{
		it2 = m_mapPipe.find((*it).first);
		if (it2 == m_mapPipe.end())
		{
			continue;
		}

		XPoint ptIns = (*it2).second;
		acdbOpenObject(pPipe, (*it).first, AcDb::kForRead);
		if (pPipe != NULL)
		{
			// 获取管子名称，规格，标高
			TPipeSys::SysType sys;
			CString strPipeType; // 管道类型
			CString strPipeSpec; // 管道规格
			double  dHigh = 0.0; // 管道高程
			CString strEle;
			CString strHighType; // 标高类型
			sys = pPipe->GetSysType();
			CString strLabel = pPipe->GetLabel();
			double dPipeDia = pPipe->GetDnDiameter();
			CString strTmp;
			strTmp.Format(_T("%.0f"), dPipeDia);
			strPipeSpec = strLabel + strTmp;
			strPipeType = GlobalFunc::GetPipeNameBySys(sys);
//			cet 2013.1.24 modify 给水、中水、消防有低中高三种类型，名称不同
// 			if(strPipeType.Compare(_T("给水")) == 0 || strPipeType.Compare(_T("中水")) == 0
// 				|| strPipeType.Compare(_T("消防")) == 0)
 			if(strPipeType.Find(_T("给水")) != -1 || strPipeType.Find(_T("中水")) != -1
 				|| strPipeType.Find(_T("消防")) != -1)
			{ 
				strHighType = _T("CEN"); // 管子中心的标高
			}	 
			else if (strPipeType.Compare(_T("污水")) == 0 || strPipeType.Compare(_T("废水")) == 0
				|| strPipeType.Compare(_T("雨水")) == 0 || strPipeType.Compare(_T("其它管")) == 0)
			{
				strHighType = _T("BOT"); // 管内底标高
			}
			
			double dUnitMeter = 1000;
			if(GlobalFunc::DocGetMeterUnitDraw())
			{
				dUnitMeter = 1.0;
			}
			double dH = 2.0;
			
			double dI = pPipe->GetPipeGradient();
			double dn = pPipe->GetDnDiameter();
			int iMaterial = pPipe->GetMaterial();
			CString csMat = GlobalFunc::GetPipeMaterialByIdx(iMaterial);
			dn  = GlobalFunc::GetPipeDjByDn(csMat, (int)dn);  //内径
			
			TPipeSys::FlowDirection dir = pPipe->GetFlowDir();
			XPoint ptWell;
			if(dir == TPipeSys::kFromStart)
			{
				if (strHighType.Compare(_T("CEN")) == 0)
				{
					dHigh = pPipe->StartPoint().z / dUnitMeter;
				} 
				else
				{
					dHigh = pPipe->StartPoint().z / dUnitMeter - dn / 2;
				}
				ptWell = pPipe->StartPoint();
			}
			else
			{
				if (strHighType.Compare(_T("CEN")) == 0)
				{
					dHigh = pPipe->EndPoint().z / dUnitMeter;
				}
				else
				{
					dHigh = pPipe->EndPoint().z / dUnitMeter - dn / 2;
				}
				ptWell = pPipe->EndPoint();
			}
			ptWell.z = 0;
			double nDistWell = ads_distance(ptIns, ptWell) / dUnitMeter;
		    dHigh = dHigh - nDistWell * dI;
			strEle.Format(_T("%.3f"), dHigh);
			strEle.TrimRight(_T("0"));
			strEle.TrimRight(_T("."));
			pPipe->close();

			CString strText;
			strPipeType.TrimRight(_T("管"));
			strPipeType += _T("管");
			strText = strPipeType + _T(" ") + strPipeSpec + _T(" 标高 ") + strEle;
			AecXDbText *pText = new AecXDbText;
			AcDbObjectId idTextStyle=GlobalFunc::InitTwtTextStyle(g_Option::instance().g_csSheetStyle);
			pText->SetStyleId(idTextStyle);
			pText->SetHeight(dH);
			pText->SetAlignment(AcGiDraw::kBottomLeft);
			pText->SetRotation(GlobalFunc::Ucs2Wcs(PI / 2));
			pText->SetText(strText);
			pText->setLayer(InitLayer(_T("TWT_室外")));
		    pText->SetLocation((*it).second);
			pText->setColorIndex(7);
			arPtr.append((void*)pText);
		}	
	}

	return true;
}

inline bool CDrawSectionSymbol::GetScaleXY(double &dX, double &dY)
{
	if (m_pmapData->GetData(_T("ScaleX"), dX)&& m_pmapData->GetData(_T("ScaleY"), dY))
	{
		return true;
	}
	return false;
}

bool CDrawSectionSymbol::GetMaxVal(double &dMax)
{
	bool bRet = false;	
	int nType = -1;
	m_pmapData->GetData(_T("Type"), nType);
	if (nType == 0) // 未选择中心线
	{
		dMax = 0.0;
		bRet = true;
	} 
	else if (nType == 1) // 选择了中心线
	{
		int nBlockType = -1;
		if (m_pmapData->GetData(_T("BlockType"), nBlockType)) // 板块类型
		{
			if (nBlockType == 0) // 简单类型
			{
				dMax = 0.0;
				bRet = true;
			} 
			else if (nBlockType == 1) // 单块板路
			{
				double dMenHeight = 0.0;
				if (m_pmapData->GetData(_T("MenHeight"), dMenHeight))
				{
					dMax = fabs(dMenHeight);
					bRet = true;
				}
			}
			else if (nBlockType == 2 || nBlockType == 3 || nBlockType == 4) // 两块板路 三块板路 四块板路
			{
				double dMenHeight = 0.0;
				double dSplitHeight = 0.0;
				if (m_pmapData->GetData(_T("MenHeight"), dMenHeight)&&
					m_pmapData->GetData(_T("SplitHeight"), dSplitHeight))
				{
					if (fabs(dMenHeight) > fabs(dSplitHeight))
					{
						dMax = fabs(dMenHeight);
					}
					else
					{
						dMax = fabs(dSplitHeight);
					}
					bRet = true;
				}	
			}
		}

		dMax *= 1000;
	}

	return bRet;

}