#include "stdafx.h"
#include <set>
#include <sstream>
#include <algorithm>
#include "UITools.h"
#include "MakeDim.h"
#include "AecDbEarthWorm.h"
#include "coreTools.h"
#include "FHBZSZDlg.h"
#include "aecdbObjXDataMap.h"
#include "JDZBDlg.h"

void SortPoints(AcGePoint3dArray& points, AcDbCurve* pLine);
//////////////////////////////////////////////////////////////////////////

namespace
{
#define XMAP_KEY _T("FIREDIM")

	using namespace MK_DIM;

	void split(LPCTSTR pszSrc, TCHAR sp, std::vector<CString> &vec)
	{
		if (!pszSrc) return;

		vec.clear();

		CString src(pszSrc);

		CString oneString(_T(""));
		TCHAR ch;
		for (int i = 0; i < src.GetLength(); ++i)
		{
			ch = src[i];
			if (ch == sp)
			{
				if (oneString.IsEmpty())
					continue;
				else
				{
					vec.push_back(oneString);
					oneString.Empty();
				}
			}
			else
				oneString += ch;
		}
		if (!oneString.IsEmpty())
			vec.push_back(oneString);
	}

	template <class T>
	bool loadMkDimDll(T &proc, LPCSTR func, HINSTANCE &hmod)
	{
		if (!func) return false;

#ifndef ZWCAD
		hmod = ::LoadLibrary(FilePath::GetArxDir() + _T("\\wfK.arx"));
#else
		hmod = ::LoadLibrary(FilePath::GetArxDir() + _T("\\wfK.zrx"));
#endif
		if (!hmod) return false;

		proc = (T)::GetProcAddress(hmod, func);
		if (!proc) return false;

		return true;
	}

	bool hasSameStake(std::vector<NodeDim> &dims, LPCTSTR stake, NodeDim **pDim)
	{
		for (size_t i = 0; i < dims.size(); ++i)
		{
			if (dims[i].stake.CompareNoCase(stake) == 0)
			{
				*pDim = &dims[i];
				return true;
			}
		}
		return false;
	}

	bool beNeedDim(const EFnctType &type, bool includeFire)
	{
		if (!includeFire)
		{
			if (type == kFirwWall)
				return false;
		}

		if ((type >= kDrainWell && type <= kHTOutLetHouse)
			|| type == kProModel
			|| type == kBDOutLetHouse )
			//|| type == kSubEspJoint )
			return true;
		return false;
	}

	bool IsFamilyNode(const EFnctType &type)
	{
		return type == kProModel;
	}

	CString getFamilyNodeName(const EWFnctNode &node)
	{
		return node.szNodeSpec;
	}

	void analyFamilyNode(const EWFnctNode &node, NodeDim &dim)
	{
		//电力舱:通风口;逃生口|综合舱:通风口;人员出入口	
		std::vector<CString> vec(0), vTypes(0);
		split(node.szNodeDefSpec, _T('|'), vec);
		//split(_T("电力舱:通风口;逃生口;集水井|综合舱:通风口;逃生口;集水井"), _T('|'), vec);
		if (vec.empty()) return;
		int idx(-1);
		CString str(_T(""));
		CString room(_T("")), types(_T(""));
		std::vector<NodeDim::ENodeType> etypes(0);
		NodeDim::ENodeType ty(NodeDim::eNone);
		for (size_t i = 0; i < vec.size(); ++i)
		{
			etypes.clear();
			str = vec[i];
			str.TrimRight();
			idx = str.Find(_T(':'));
			if (idx == -1) continue;
			room = str.Left(idx);
			types = str.Right(str.GetLength() - idx - 1);
			split(types, _T(';'), vTypes);
			if (vTypes.empty()) continue;
			for (size_t t = 0; t < vTypes.size(); ++t)
			{
				if ((ty = getNodeType(vTypes[t])) != NodeDim::eNone)
					etypes.push_back(ty);
			}

			if (dim.room_types.find(room) == dim.room_types.end())
				dim.room_types.insert(std::make_pair(room, std::set<NodeDim::ENodeType>()));
			dim.room_types[room].insert(etypes.begin(), etypes.end());
			
			for (size_t t = 0; t < etypes.size(); t++)
			{
				NodeDim::ENodeType &type = etypes[t];
				if (dim.type_rooms.find(type) == dim.type_rooms.end())
					dim.type_rooms.insert(std::make_pair(type, std::set<CString>()));
				dim.type_rooms[type].insert(room);
			}
		}
		return;
	}

	void sortCenterPnt(AecDbEarthWorm *pEw, AcGePoint3dArray &arCenterPnts)
	{
		if (!pEw) return;
		AcGePoint2d pt2dS(pEw->StartPoint()), pt2dE(pEw->EndPoint());
		AcDbLine line(AcGePoint3d(pt2dS.x, pt2dS.y, 0.), AcGePoint3d(pt2dE.x, pt2dE.y, 0.));
		SortPoints(arCenterPnts, &line);
	}

	// 通过 数组dims 内的索引 idx，得到其前面的对应舱室的防火墙个数，并拼成字符串
	void getDimTextForFireWall(const int &idx, const std::vector<NodeDim> &dims, const NodeDim::ENodeType &type, std::vector<CString> &left, std::vector<CString> &right)
	{
		CString sLeft(_T("")), sRight(_T(""));
		int num(0);
		const NodeDim &curDim = dims[idx];
		NodeDim::RoomTypes::const_iterator it = curDim.room_types.begin();
		for (; it != curDim.room_types.end(); ++it)
		{	// 向前搜索，寻找有type的此类舱室
			sLeft.Empty();
			sRight.Empty();
			num = 0;
			const CString &sRoom = it->first;
			for (int i = 0; i < idx; ++i)
			{
				const NodeDim &dim = dims[i];
				if (dim.room_types.find(sRoom) == dim.room_types.end()) continue;
				if (dim.type_rooms.find(type) == dim.type_rooms.end()) continue;
				++num;
			}
			sLeft.Format(_T("%s防火分区%d"), sRoom, num + 1);
			sRight.Format(_T("%s防火分区%d"), sRoom, num + 2);
			left.push_back(sLeft);
			right.push_back(sRight);
		}
	}

	void drawArrow(const AcGeVector3d &v
		, const double &aW
		, const AcGePoint3d &ptS
		, AcDbObjectIdArray &ids)
	{
		AcDbObjectId id;
		AcGePoint3d ptE;
		double aL = aW * 100 / 33;
		AcGeVector3d vt(v);
		vt.normalize();
		vt *= aL;
		ptE = ptS + vt;
		AcDbLine *p = new AcDbLine(ptS, ptE);
		CoreTools::AddToModelSpace(p, NULL, true, &id);
		ids.append(id);
		vt *= -1;
		double angle = atan(aW / (2 * aL));
		vt.rotateBy(angle, AcGeVector3d::kZAxis);
		p = new AcDbLine(ptE, ptE + vt);
		CoreTools::AddToModelSpace(p, NULL, true, &id);
		ids.append(id);
		vt.rotateBy(2 * angle * -1, AcGeVector3d::kZAxis);
		p = new AcDbLine(ptE, ptE + vt);
		CoreTools::AddToModelSpace(p, NULL, true, &id);
		ids.append(id);
	}

	double drawFireDimText(const AcGeVector3d &vtEw
		, const AcGePoint3d &ptAlgn
		, const double &h
		, AcDbObjectId styleID
		, std::vector<CString> &vLeft
		, std::vector<CString> &vRight
		, const bool bDraw
		, AcDbObjectIdArray &ids)
	{
		CString left(_T("")), right(_T("")), room(_T(""));

		for (size_t i = 0; i < vLeft.size(); ++i)
		{
			left += vLeft[i];
			left += _T("、");
			right += vRight[i];
			right += _T("、");
		}
		left.TrimRight(_T("、"));
		right.TrimRight(_T("、"));

		AcGePoint3d ptLeft(ptAlgn), ptRight(ptAlgn);
		AcGeVector3d vt1(vtEw), vt2(vtEw);
		vt1.rotateBy(.5 * PI, AcGeVector3d::kZAxis);
		vt1.normalize();
		vt2.normalize();
		vt1 *= h;
		vt2 *= h;
		ptLeft += vt1;
		ptLeft -= vt2;
		ptRight += vt1;
		ptRight += vt2;

		double angle = AcGeVector3d::kXAxis.angleTo(vtEw, AcGeVector3d::kZAxis);
		// 此时文字为水平方向，取出长度
		AcDbExtents ext, extAll;
		AcDbText *pLeft = new AcDbText;
		pLeft->setTextString(left);
		pLeft->setTextStyle(styleID);
		pLeft->setHeight(h);
		pLeft->setHorizontalMode(AcDb::kTextRight);
		pLeft->setAlignmentPoint(ptLeft);

		AcDbText *pRight = (AcDbText*)pLeft->clone();
		pRight->setTextString(right);
		pRight->setHorizontalMode(AcDb::kTextLeft);
		pRight->setPosition(ptRight);

		pRight->getGeomExtents(ext);
		extAll.addExt(ext);

		pLeft->setRotation(angle);
		pRight->setRotation(angle);

		if (bDraw)
		{
			AcDbObjectId id;
			CoreTools::AddToModelSpace(pLeft, NULL, true, &id);
			ids.append(id);
			CoreTools::AddToModelSpace(pRight, NULL, true, &id);
			ids.append(id);
		}
		else
		{
			DELETE_PTR(pLeft);
			DELETE_PTR(pRight);
		}
		double len = extAll.maxPoint().x - extAll.minPoint().x;

		return len;
	}

	void drawFireDim(NodeDim &fd
		, const int &idx
		, const bool &bRight
		, const double &w
		, const double &h
		, const double &aW
		, const double &txtH
		, AcDbObjectId &idStyle
		, std::vector<CString> &vLeft
		, std::vector<CString> &vRight
		)
	{
		AcDbObjectId id;
		AcDbObjectIdArray ids(0);
		AcGePoint3d ptHs(AcGePoint3d::kOrigin), ptHe(AcGePoint3d::kOrigin)
			, ptVs(AcGePoint3d::kOrigin), ptVe(AcGePoint3d::kOrigin)
			, ptCross(AcGePoint3d::kOrigin);

		AcGeVector3d vt(AcGeVector3d::kIdentity);
		// 画竖线
		NodeDim &dim = fd;
		vt = dim.vt;
		vt.rotateBy(.5 * PI * (bRight ? -1 : 1), AcGeVector3d::kZAxis);
		vt.normalize();
		vt *= h;
		ptVs = dim.pntIns;
		ptVe = ptVs + vt;
		AcDbLine *p = new AcDbLine(ptVs, ptVe);
		// 将竖线最后一个点（远离管廊）存入管廊的扩展数据内
// 		if (bRight)
// 		{
			AecDbObjXDataMap xmap;
			xmap.Read(fd.idEw, XMAP_KEY);
			xmap.SetAt(fd.stake, ptVe);
			xmap.Write(fd.idEw, XMAP_KEY);
// 		}
		CoreTools::AddToModelSpace(p, NULL, true, &id);
		ids.append(id);
		// 画横线
		vt.normalize();
		vt *= h * .75;// +vLeft.size() * txtH;
		ptCross = ptHs = ptHe = dim.pntIns;
		ptCross += vt;
		ptHs += vt;
		ptHe += vt;
		vt.normalize();
		vt.rotateBy(.5 * PI, AcGeVector3d::kZAxis);
		vt *= w * .5;
		ptHs += vt;
		ptHe -= vt;
		p = new AcDbLine(ptHs, ptHe);
		CoreTools::AddToModelSpace(p, NULL, true, &id);
		ids.append(id);
		// 画两个箭头
		drawArrow(vt, aW, ptHs, ids);
		drawArrow(-1 * vt, aW, ptHe, ids);
		// 绘制文字
		drawFireDimText(dim.vt, ptCross, txtH, idStyle, vLeft, vRight, true, ids);
		CoreTools::generateGroup(NULL, ids);
	}

	template <class T1, class T2>
	void _insert_(std::map<T1, std::set<T2>> &mm, const T1 &key, const T2 &value)
	{
		if (mm.find(key) == mm.end())
			mm.insert(std::make_pair(key, std::set<T2>()));
		mm[key].insert(value);
	}

	void mergeNode(const NodeDim &nd, NodeDim *pDim)
	{
		for (NodeDim::TypeRooms::const_iterator it = nd.type_rooms.begin(); it != nd.type_rooms.end(); ++it)
		{
			// 是否有相同的类型
			NodeDim::TypeRooms::iterator preIt = pDim->type_rooms.find(it->first);
			if (preIt == pDim->type_rooms.end())
			{	// 不存在，直接插入
				pDim->type_rooms.insert(*it);
			}
			else
			{	// 存在，合并
				preIt->second.insert(it->second.begin(), it->second.end());
			}
		}

		for (NodeDim::RoomTypes::const_iterator it = nd.room_types.begin(); it != nd.room_types.end(); ++it)
		{
			// 是否有相同的舱室
			NodeDim::RoomTypes::iterator preIt = pDim->room_types.find(it->first);
			if (preIt == pDim->room_types.end())
			{	// 不存在，直接插入
				pDim->room_types.insert(*it);
			}
			else
			{	// 存在，合并
				preIt->second.insert(it->second.begin(), it->second.end());
			}
		}
	}

	AcGePoint3d getInsertPt(const AcGePoint3d &ptOrg, const EWFnctNode &node, const AcGeVector3d &v)
	{
		AcGePoint3d pt(ptOrg);
		AcGeVector3d vt(v);
		vt.normalize();
		double delta(GLTools::getNodeOffset(node));
		pt += vt * delta;
		return pt;
	}

	void collectNodeInfoForDim(AcDbObjectId idEw
		, std::vector<NodeDim> &nodeDims
		, bool includeFire
		, NodeDim *pNodeStart = NULL
		, NodeDim *pNodeEnd = NULL)
	{
		AcDbObjectIdArray arrIDs;
		GetConnectedWorms(idEw, arrIDs);
		if (arrIDs.isEmpty()) return;

		AcArray<ELongParam> arLongParam(0);
		OPENOBJ_BEGIN(idEw, AcDb::kForRead, AecDbEarthWorm, pEw)
		{
			if (!pEw) return;
			pEw->CalEarthWork(arLongParam);
		}
		OPENOBJ_END()

			if (arLongParam.isEmpty()) return;

		std::map<CString, double> guids;
		for (int i = 0; i < arLongParam.length(); ++i)
			guids.insert(std::make_pair(arLongParam[i].szIDlock, arLongParam[i].dDistStakeLen));
			

		AcGePoint3dArray arCenPoints;
		AcGeIntArray arEntTypes;
		CUIntArray arColors;
		AcArray<EWFnctNode> arNodes;
		AcGePoint3dArray arNodePnts;
		AcGePoint3d pt(AcGePoint3d::kOrigin);
		CString nameNode(_T("")), nameRoom(_T(""));
		NodeDim::ENodeType nodeType;
		NodeDim nd;
		double dAllLengthForEW(.0);
		AcGePoint3d ptEwStart3d(AcGePoint3d::kOrigin);
		AcGePoint2d ptEwStart2d(AcGePoint2d::kOrigin);

		NodeDim nodS, nodE;

		EWSEGMENT seg;
		
		
		for (int i = 0; i < arrIDs.length(); ++i)
		{
			AcDbObjectId &id = arrIDs[i];

			if (!i)
				nodS.idEw = id;
			if (i == arrIDs.length() - 1)
				nodE.idEw = id;

			arCenPoints.removeAll();
			arEntTypes.removeAll();
			arColors.RemoveAll();

			OPENOBJ_BEGIN(id, AcDb::kForRead, AecDbEarthWorm, pEw)
			pEw->GetCenControlPoints(arCenPoints, arEntTypes, arColors, true);

			sortCenterPnt(pEw, arCenPoints);

			ptEwStart2d = pEw->StartPoint();
			ptEwStart3d.x = ptEwStart2d.x;
			ptEwStart3d.y = ptEwStart2d.y;
			ptEwStart3d.z = pEw->StartElevation();

			nd.vt = pEw->GetThisDir();

			AcGePoint2d pt2d1(AcGePoint2d::kOrigin), pt2d2(AcGePoint2d::kOrigin);
			// 遍历每个中心点，然后调用GetFncNodeAt函数，得到节点信息
			for (int iPnt = 0; iPnt < arCenPoints.length(); ++iPnt)
			{
				nd.type_rooms.clear();
				nd.room_types.clear();
				arNodes.removeAll();
				AcGePoint3d &ptC = arCenPoints[iPnt];

				pEw->GetFncNodeAt(ptC, .5, arNodes, arNodePnts);

				nd.idEw = pEw->objectId();

				pt2d1.set(ptC.x, ptC.y);
				//nd.distFromHead = dAllLengthForEW + pt2d1.distanceTo(ptEwStart2d);
				nd.distFromHead = .0;
				std::map<CString, double>::iterator it(guids.end());
				for (int iNd = 0; iNd < arNodes.length(); ++iNd)
				{
					EWFnctNode &node = arNodes[iNd];
					it = guids.find(node.szLockId);
					if (it != guids.end())
						nd.distFromHead = it->second;

					if (!beNeedDim(node.eFnType, includeFire)) continue;

					nd.pntIns = getInsertPt(ptC, node, nd.vt);

					if (!i && !iPnt/* && node.eFnType == kStackNode*/)
					{
						nodS.pntIns = ptC;
						nodS.stake = node.szStake;
						nodS.vt = pEw->GetThisDir();
					}
					if (i == arrIDs.length() - 1 && iPnt == arCenPoints.length() - 1/* && node.eFnType == kStackNode*/)
					{
						nodE.pntIns = ptC;
						nodE.stake = node.szStake;
						nodE.vt = pEw->GetThisDir();
					}

					nd.stake = node.szStake;

					
					nameRoom = pEw->GetRoomTypeByIdx(node.nRoomIndex);
					if (IsFamilyNode(node.eFnType))
					{
						nameNode = getFamilyNodeName(node);
						nd.name = nameNode;
						analyFamilyNode(node, nd);
					}
					else
					{
						nodeType = getNodeType(node.eFnType);
						nameNode = getNodeName(nodeType);
						nd.name = nameNode;
						// 填充type_rooms结构
						_insert_<NodeDim::ENodeType, CString>(nd.type_rooms, nodeType, nameRoom);

						// 填充room_types结构
						_insert_<CString, NodeDim::ENodeType>(nd.room_types, nameRoom, nodeType);
					}

				}

				// 在这里，对参通风口节点做特殊处理
				// 由于 插入通风口时，可以同时插入防火土墙和另一个通风口，
				// 所以在这里，对相同桩号进行融合
				// 由于，桩号是排好序的，所以只需要和前一个桩号对比即可
				NodeDim *preDim(NULL);
				if (hasSameStake(nodeDims, nd.stake, &preDim))
					mergeNode(nd, preDim);
				else
					nodeDims.push_back(nd);
			}
			pEw->GetSegment(0, seg);
			dAllLengthForEW += seg.dDistLen;
			OPENOBJ_END()
		}
		if (pNodeStart)
		{
			*pNodeStart = nodS;
			pNodeStart->distFromHead = .0;
		}
		if (pNodeEnd)
		{
			*pNodeEnd = nodE;
			pNodeEnd->distFromHead = dAllLengthForEW;
		}
	}

#define INS_TYPE(type)\
	for (std::set<CString>::iterator it = room_##type.begin(); it != room_##type.end(); ++it)\
	{\
		_insert_<CString, NodeDim::ENodeType>(nodS.room_types, *it, NodeDim::##type);\
		_insert_<NodeDim::ENodeType, CString>(nodS.type_rooms, NodeDim::##type, *it);\
		_insert_<CString, NodeDim::ENodeType>(nodE.room_types, *it, NodeDim::##type);\
		_insert_<NodeDim::ENodeType, CString>(nodE.type_rooms, NodeDim::##type, *it);\
	}

#define GET_TYPES(type)\
	itTR = nd.type_rooms.find(NodeDim::##type);\
	if (itTR != nd.type_rooms.end())\
		room_##type.insert(itTR->second.begin(), itTR->second.end())

	void collectNodeInfoForStatistic(AcDbObjectId idEw, std::vector<NodeDim> &nodeDims, bool includeFire)
	{
		NodeDim nodS, nodE;
		collectNodeInfoForDim(idEw, nodeDims, includeFire, &nodS, &nodE);

		if (nodeDims.empty()) return;

		// 如果舱室存在 防火墙 或 通风口 ，则在此舱室头尾加上相应的节点
		std::set<CString> room_eFireWall;
		std::set<CString> room_eVenDoghouse;
		std::set<CString> room_eEscapeHatch;
		std::set<CString> room_eDrainWell;
		std::set<CString> room_eDoghouse;
		std::set<CString> room_eOutlet;
		for (size_t i = 0; i < nodeDims.size(); ++i)
		{
			NodeDim &nd = nodeDims[i];
			NodeDim::TypeRooms::iterator itTR;

			GET_TYPES(eFireWall);
			GET_TYPES(eVenDoghouse);
			GET_TYPES(eDrainWell);
			GET_TYPES(eDoghouse);
			GET_TYPES(eEscapeHatch);
			GET_TYPES(eOutlet);
		}

		std::sort(nodeDims.begin(), nodeDims.end(), NodeDim::_com_by_dist());

		if (EQUAL(nodeDims.begin()->distFromHead, nodS.distFromHead))	// 存在首节点
			nodS = *nodeDims.begin();
		if (EQUAL(nodeDims.rbegin()->distFromHead, nodE.distFromHead))	// 存在尾节点
			nodE = *nodeDims.rbegin();

		INS_TYPE(eFireWall);
		INS_TYPE(eVenDoghouse);
		INS_TYPE(eDrainWell);
		INS_TYPE(eDoghouse);
		INS_TYPE(eEscapeHatch);
		INS_TYPE(eOutlet);

		if (!EQUAL(nodeDims.begin()->distFromHead, nodS.distFromHead))	// 不存在首节点
			nodeDims.insert(nodeDims.begin(), nodS);
		else
			*(nodeDims.begin()) = nodS;

		if (!EQUAL(nodeDims.rbegin()->distFromHead, nodE.distFromHead))	// 不存在尾节点
			nodeDims.push_back(nodE);
		else
			*(nodeDims.rbegin()) = nodE;
	}

	double getEwSectionWidth(AcDbObjectId id)
	{
		double w(.0);
		OPENOBJ_BEGIN(id, AcDb::kForRead, AecDbEarthWorm, pEw)
		if (!pEw) return w;
		AcGePoint2d pt = pEw->GetSize();
		w = pt.x;
		OPENOBJ_END()
		return w;
	}

	CString mergeString(const NodeDim::RoomTypes &nds, LPCTSTR nodeName, LPCTSTR stake, const int *pIdx)
	{
		CString strFireWall = getNodeName(getNodeType(kFirwWall));
		std::wstringstream ss;
		std::wstring wstr;
		ss << stake << _T(" ") << nodeName << _T(" ");
		for (NodeDim::RoomTypes::const_iterator it = nds.begin(); it != nds.end(); ++it)
		{
			ss << (LPCTSTR)it->first << _T("：");
			for (std::set<NodeDim::ENodeType>::const_iterator itType = it->second.begin(); itType != it->second.end(); ++itType)
			{
				if (*itType == NodeDim::eFireWall) continue;
				ss << (LPCTSTR)*itType << _T("、");
			}
			wstr = ss.str().substr(0, ss.str().size() - 1);
			ss.str(_T(""));
			ss << wstr << _T("，");
		}
		wstr.clear();
		wstr = ss.str().substr(0, ss.str().size() - 1);
		if (pIdx)
		{
			std::wstringstream _ss;
			_ss << *pIdx;
			return CString(wstr.c_str()) + _ss.str().c_str();
		}
		return wstr.c_str();
	}

	CString mergeString(const NodeDim::TypeRooms &nds, LPCTSTR nodeName, LPCTSTR stake, const int *pIdx)
	{
		std::wstringstream ss;
		std::wstring wstr;
		ss << stake << _T(" ") << nodeName << _T(" ");
		for (NodeDim::TypeRooms::const_iterator it = nds.begin(); it != nds.end(); ++it)
		{
			if (it->first == NodeDim::eFireWall) continue;
			for (std::set<CString>::const_iterator itRoom = it->second.begin(); itRoom != it->second.end(); ++itRoom)
			{
				ss << (LPCTSTR)*itRoom << _T("、");
			}
			wstr = ss.str().substr(0, ss.str().size() - 1);
			ss.str(_T(""));
			ss << wstr;
			ss << (LPCTSTR)getNodeName(it->first) << _T("，");
		}
		wstr.clear();
		wstr = ss.str().substr(0, ss.str().size() - 1);
		if (pIdx)
		{
			std::wstringstream _ss;
			_ss << *pIdx;
			return CString(wstr.c_str()) + _ss.str().c_str();
		}
		return wstr.c_str();
	}

	void drawNodeDimText(NodeDim &dim
		, const double h
		, const double len
		, AcDbObjectId style
		, bool bRight
		, AcDbObjectIdArray &ids
		, const int &idx
		, const bool &byCenterLine)	// 相同舱室、功能的节点序号
	{
		CString str(_T(""));
		if (!byCenterLine)
		{ 
			CString strL = StakeTools::generateStakeString(dim.distFromHead, _T("L"));
			str = mergeString(dim.type_rooms, dim.name, strL, &idx);
		}
		else
			str = mergeString(dim.type_rooms, dim.name, dim.stake, &idx);
		// 管廊宽
		double w = getEwSectionWidth(dim.idEw);
		
		AcGePoint3d ptIns = dim.pntIns;
		AcGeVector3d vt = dim.vt;

		// 转90
		vt.rotateBy(.5 * PI * (bRight ? -1 : 1), AcGeVector3d::kZAxis);
		vt.normalize();
		vt *= .5 * w + len + h;

		AcDbLine *pLine = new AcDbLine(ptIns, ptIns + vt);

		vt.normalize();
		vt *= .5 * w + len + 2*h;
		ptIns += vt;

		AcDbText *pTxt = new AcDbText();
		pTxt->setTextString(str);
		pTxt->setVerticalMode(AcDb::kTextVertMid);
		if (bRight)
			pTxt->setHorizontalMode(AcDb::kTextRight);
		else
			pTxt->setHorizontalMode(AcDb::kTextLeft);
		pTxt->setTextStyle(style);
		double angle = AcGeVector3d::kXAxis.angleTo(vt * (bRight ? -1 : 1), AcGeVector3d::kZAxis);
		pTxt->setRotation(angle);
		pTxt->setHeight(h);

		AcDbObjectId id;

		// 如果当前桩号上有防火墙标注
		AecDbObjXDataMap xmap;
		if (xmap.Read(dim.idEw, XMAP_KEY))
		{
			AcGePoint3d pt;
			if (xmap.GetAt(dim.stake, pt))
			{
				DELETE_PTR(pLine);
				vt.normalize();
				vt *= h;
				pt += vt;
				ptIns = pt;
			}
			else
			{ 
				CoreTools::AddToModelSpace(pLine, NULL, true, &id);
				ids.append(id);
			}

		}
		else
		{ 
			CoreTools::AddToModelSpace(pLine, NULL, true, &id);
			ids.append(id);
		}


		pTxt->setAlignmentPoint(ptIns);
		CoreTools::AddToModelSpace(pTxt, NULL, true, &id);
		ids.append(id);
	}
}

#define func_process(sfunc, ...)\
	AcDbEntity *pEnt(NULL);\
	func_##sfunc proc(NULL);\
	HINSTANCE hmod(NULL);\
	if (loadMkDimDll<func_##sfunc>(proc, #sfunc, hmod))\
	{\
		pEnt = proc(##__VA_ARGS__);\
		::FreeLibrary(hmod);\
	}\
	return pEnt

namespace MK_DIM
{

	NodeDim::ENodeType getNodeType(const EFnctType &type)
	{
		switch (type)
		{
		case kDrainWell:
			return NodeDim::eDrainWell;
		case kPipeDoghouse:
		case kCableDoghouse:
		case kHeatDoghouse:
			return NodeDim::eDoghouse;
		case kVenDoghouse:
			return NodeDim::eVenDoghouse;
		case kFirwWall:
			return NodeDim::eFireWall;
		case kEscapeHatch:
			return NodeDim::eEscapeHatch;
		case kSubEspJoint:
			return NodeDim::eEspJoint;
		case kFireOutlet:
		case kEWOutLethouse:
		case kHTOutLetHouse:
		case kBDOutLetHouse:
			return NodeDim::eOutlet;
		default:
			return NodeDim::eNone;
		}
		return NodeDim::eNone;
	}

	MK_DIM::NodeDim::ENodeType getNodeType(LPCTSTR psz)
	{
		CString str(psz);

		if (str == _T("集水井"))
			return NodeDim::eDrainWell;
		else if (str == _T("投料口"))
			return NodeDim::eDoghouse;
		else if (str == _T("通风口"))
			return NodeDim::eVenDoghouse;
		else if (str == _T("防火墙"))
			return NodeDim::eFireWall;
		else if (str == _T("逃生口"))
			return NodeDim::eEscapeHatch;
		else if (str == _T("管线分支口"))
			return NodeDim::eOutlet;
		else if (str == _T("变形缝"))
			return NodeDim::eEspJoint;
		else
			return NodeDim::eNone;

		return NodeDim::eNone;
	}

	CString getNodeName(const NodeDim::ENodeType &type)
	{
		switch (type)
		{
		case NodeDim::eDrainWell:
			return _T("集水井");
		case NodeDim::eDoghouse:
			return _T("投料口");
		case NodeDim::eVenDoghouse:
			return _T("通风口");
		case NodeDim::eFireWall:
			return _T("防火墙");
		case NodeDim::eEscapeHatch:
			return _T("逃生口");
		case NodeDim::eOutlet:
			return _T("管线分支口");
		case NodeDim::eEspJoint:
			return _T("变形缝");
		default:
			return _T("");
		}
		return _T("");
	}

	void collectNodeInfo_Dim(AcDbObjectId idEw, std::vector<NodeDim> &nodeDims, bool includeFire)
	{
		::collectNodeInfoForDim(idEw, nodeDims, includeFire);
	}

	void collectNodeInfo_Statistic(AcDbObjectId idEw, std::vector<NodeDim> &nodeDims, bool includeFire)
	{
		::collectNodeInfoForStatistic(idEw, nodeDims, includeFire);
	}
}

namespace MK_DIM
{

	void insertFireWallDim()
	{
		// 选择管廊
		ads_point adsPnt;
		ads_name adsName;
		int nRes = acedEntSel(_T("\n请选择要标注的管廊。"), adsName, adsPnt);
		if (nRes != RTNORM) return;
		AcDbObjectId idEw(AcDbObjectId::kNull);
		acdbGetObjectId(idEw, adsName);
		if (!GLTools::isThisClass<AecDbEarthWorm>(idEw))
		{
			acutPrintf(_T("\n请选择一段管廊。"));
			return;
		}

		// 绘制参数-------------------------------
		// 标注 宽，高，箭头宽，字高，文字比例
		double w(50), h(50), aW(2), txtH(1);
		AcDbObjectId idStyle;

		// 弹对话框
		CAcModuleResourceOverride myResources;
		CFHBZSZDlg dlg;
		if (dlg.DoModal() != IDOK) return;

		w = dlg.m_dW;
		h = dlg.m_dH;
		aW = dlg.m_dAW;
		txtH = dlg.m_dTxtH;
		idStyle = GLTools::getTextStyle(dlg.m_style);
		if (!idStyle.isValid())
			idStyle = GLTools::getTextStyle(_T("standard"));

		// 收集参数-------------------------------
		std::vector<NodeDim> nodeDims(0);
		collectNodeInfo_Dim(idEw, nodeDims, true);

		// 绘制
		AcGePoint3d ptCross(AcGePoint3d::kOrigin), ptOldCross(AcGePoint3d::kOrigin);
		double maxW(.0), oldMaxW(.0);
		bool bRight(dlg.m_iSide == 0);	// 是标在管廊方向右侧还是左侧


		// 整理一下，把有防火墙的挑出来，之后再统一处理
		std::vector<NodeDim> dims(0);
		CString strName(_T(""));
		for (size_t i = 0; i < nodeDims.size(); ++i)
		{
			NodeDim &dim = nodeDims[i];
			NodeDim::TypeRooms::iterator it = dim.type_rooms.find(NodeDim::eFireWall);
			if (it != dim.type_rooms.end())
				dims.push_back(dim);
		}

		std::vector<CString> Left(0), Right(0);
		for (size_t i = 0; i < dims.size(); ++i)
		{
			Left.clear();
			Right.clear();
			getDimTextForFireWall(i, dims, NodeDim::eFireWall, Left, Right);
			NodeDim &dim = dims[i];
			// 不是第一个
			if (i)
			{
				AcDbObjectIdArray ids(0);	// 临时，无用
				NodeDim &pre_dim = dims[i - 1];
				maxW = drawFireDimText(dim.vt, AcGePoint3d::kOrigin, txtH, idStyle, Left, Right, false, ids);
				oldMaxW = drawFireDimText(pre_dim.vt, AcGePoint3d::kOrigin, txtH, idStyle, Left, Right, false, ids);
// 				if (dim.pntIns.distanceTo(pre_dim.pntIns) < __max(w, maxW + oldMaxW))
// 					bRight = !bRight;
			}
			drawFireDim(dim, i, bRight, w, h, aW, txtH, idStyle, Left, Right);
		}
		return;
	}

	void insertNodeDim()
	{
		// 选择管廊
		ads_point adsPnt;
		ads_name adsName;
		int nRes = acedEntSel(_T("\n请选择要标注的管廊。"), adsName, adsPnt);
		if (nRes != RTNORM) return;
		AcDbObjectId idEw(AcDbObjectId::kNull);
		acdbGetObjectId(idEw, adsName);
		if (!GLTools::isThisClass<AecDbEarthWorm>(idEw))
		{
			acutPrintf(_T("\n请选择一段管廊。"));
			return;
		}

		CAcModuleResourceOverride myResources;
		CJDZBDlg dlg;
		if (dlg.DoModal() != IDOK) return;
		double txtH(dlg.m_textH);
		double len(dlg.m_leaderL);
		CString textStyle(dlg.m_style);
		AcDbObjectId idStyle = GLTools::getTextStyle(textStyle);
		if (!idStyle.isValid())
			idStyle = GLTools::getTextStyle(_T("standard"));

		// 收集参数-------------------------------
		std::vector<NodeDim> nodeDims(0);
		collectNodeInfo_Dim(idEw, nodeDims, false);

		CString strFrieWall = getNodeName(getNodeType(kFirwWall));
		CString strNodeName(_T("")), strOut(_T("")), _tmp(_T(""));
		std::wstringstream ss;
		std::wstring wstr;
		AcDbObjectIdArray ids(0);
		std::multiset<CString> mmapStrs;
		typedef std::multiset<CString>::iterator mmapIt;
		std::pair<mmapIt, mmapIt> pr;
		size_t dif(0);
		for (size_t i = 0; i < nodeDims.size(); ++i)
		{
			_tmp = mergeString(nodeDims[i].type_rooms, nodeDims[i].name, _T("0"), NULL);
			mmapStrs.insert(_tmp);
			pr = std::equal_range(mmapStrs.begin(), mmapStrs.end(), _tmp);
			dif = std::distance(pr.first, pr.second);
			drawNodeDimText(nodeDims[i], txtH, len, idStyle, dlg.m_iSide == 0, ids, dif, dlg.m_bByCenterLine ? true : false);
			CoreTools::generateGroup(NULL, ids);
			ids.removeAll();
		}

	}

}