#include "StdAfx.h"
#include "terrainAnalysis.h"
#include "UITools.h"
#include <sstream>
#include "ktcadutility.h"
#include <set>
#include "dbobjptr.h"
#include "aecdbterrain.h"
#include "KTSetting.h"
#include "coretools.h"

#if ARX > 17
#include "dbsubd.h"

namespace
{
	static void AcDbSubDMeshfromAcDb3dSolid(void)
	{
		Acad::ErrorStatus err;
		ads_name name;
		ads_point pt;
		if (acedEntSel(L"Select a solid", name, pt) != RTNORM) return;

		AcDbObjectId id;
		acdbGetObjectId(id, name);
		AcDbObjectPointer<AcDb3dSolid> ptrSolid(id, AcDb::kForRead);

		AcDbFaceterSettings settings;
		AcGePoint3dArray pts;
		AcArray<Adesk::Int32> faces;
		AcGiFaceData* faceData;
		err = acdbGetObjectMesh(ptrSolid, &settings, pts, faces, faceData);
		if (faceData)
		{
			delete[] faceData->trueColors();
			delete[] faceData->materials();
			DELETE_PTR(faceData);
		}

		AcDbObjectPointer<AcDbSubDMesh> ptrMesh;
		ptrMesh.create();
		ptrMesh->setSubDMesh(pts, faces, 0);

		AcDbDatabase* pDb = acdbHostApplicationServices()->workingDatabase();
		AcDbBlockTableRecordPointer ptrMS(ACDB_MODEL_SPACE, pDb, AcDb::kForWrite);

		ptrMS->appendAcDbEntity(ptrMesh);
	}

	struct Face
	{
		Face(): num(0), vertices(0){}
		int num;
		std::vector<AcGePoint3d> vertices;
	};

	struct FacePoint
	{
		AcGePoint3d pt;
		Face face;
		void setFace(const Face &f)
		{
			face = f;
			AcGePlane pln(f.vertices[0], f.vertices[1], f.vertices[2]);
			AcGePoint3d ptClosed = pln.closestPointTo(pt);
			pt.z = ptClosed.z;
		}
	};

	struct com_pt_z{ bool operator () (AcGePoint3d &pt1, AcGePoint3d &pt2) { return pt1.z < pt2.z; } };

	double crossProduct(const AcGeVector2d v1, const AcGeVector2d &v2) { return v1.x*v2.y - v1.y*v2.x; }

	bool isInTriangle(const AcGePoint2d &pt0
		, const AcGePoint2d &pt1
		, const AcGePoint2d &pt2
		, const AcGePoint2d &pt )
	{
		AcGeVector2d v0(pt0 - pt), v1(pt1 - pt), v2(pt2 - pt);
		double d01 = crossProduct(v0, v1);
		double d12 = crossProduct(v1, v2);
		double d20 = crossProduct(v2, v0);
		return (d01 * d12 >= 0) && (d01 * d20 >= 0);
	}

	bool isInFace(const AcGePoint3d &pt, const Face &f)
	{
		if (f.num < 3) return false;

		AcGePoint2d pt0(f.vertices[0].x, f.vertices[0].y)
			, pt1(f.vertices[1].x, f.vertices[1].y)
			, pt2(f.vertices[2].x, f.vertices[2].y)
			, pt2d(pt.x, pt.y);

		return isInTriangle(pt0, pt1, pt2, pt2d);
	}

	bool isDouble(LPCTSTR psz, double &d)
	{
		std::wstringstream ss(psz);
		TCHAR c;
		if (!(ss >> d))
			return false;
		if (ss >> c)
			return false;
		return true;
	}

	void polyline2PointArray(const AcDbPolyline &poly, std::vector<AcGePoint3d> &ar, const double &dElev)
	{
		AcGePoint3d pt;
		double dParam(.0);
		std::set<double> params;
		AcGeLineSeg3d seg3d;
		AcGeCircArc3d arc3d;
		AcDbPolyline::SegType st(AcDbPolyline::kEmpty);
		for (int i(0); i < poly.numVerts(); ++i)
		{
			st = poly.segType(i);
			if (st == AcDbPolyline::kLine)
			{
				poly.getLineSegAt(i, seg3d);
				poly.getParamAtPoint(seg3d.startPoint(), dParam);
				params.insert(dParam);
				poly.getParamAtPoint(seg3d.endPoint(), dParam);
				params.insert(dParam);
			}
			else if (st == AcDbPolyline::kArc)
			{
				double dS(.0), dE(.0);
				poly.getArcSegAt(i, arc3d);
				poly.getParamAtPoint(arc3d.startPoint(), dS);
				poly.getParamAtPoint(arc3d.endPoint(), dE);

				double dStep(abs((dS - dE) * .01));
				for (int i(0); i < 100; ++i)
				{
					params.insert(dS + i * dStep);
				}
				params.insert(dE);
			}
		}

		std::set<double>::const_iterator it(params.begin());
		for (; it != params.end(); ++it)
		{
			if (poly.getPointAtParam(*it, pt) == Acad::eOk)
				ar.push_back(AcGePoint3d(pt.x, pt.y, dElev));
		}
	}

	void circle2PointArray(const AcDbCircle &circle, std::vector<AcGePoint3d> &ar, const double &dElev)
	{
		std::set<double> params;
		double dS(.0), dE(.0);
		circle.getStartParam(dS);
		circle.getEndParam(dE);
		double dStep(abs((dS - dE) * .01));
		for (int i(0); i < 100; ++i)
		{
			params.insert(dS + i * dStep);
		}

		params.insert(dE);

		AcGePoint3d pt;
		std::set<double>::const_iterator it(params.begin());
		for (; it != params.end(); ++it)
		{
			if (circle.getPointAtParam(*it, pt) == Acad::eOk)
				ar.push_back(AcGePoint3d(pt.x, pt.y, dElev));
		}
	}

	void setBlockAttri(AcDbBlockReference *pRef, LPCTSTR str)
	{
		if (!pRef) return;
		AcDbObjectIterator *pIt = pRef->attributeIterator();
		if (!pIt) return;

		AcDbAttribute *pAttr(NULL);
		for (pIt->start(); !pIt->done(); pIt->step())
		{
			AcDbObjectId id = pIt->objectId();
			pRef->openAttribute(pAttr, id, AcDb::kForWrite);
			if (pAttr)
			{
				pAttr->setTextString(str);
				pAttr->close();
				break;
			}
		}
		DELETE_PTR(pIt);
		return;
	}

	void getBlockAttri(AcDbBlockReference *pRef, std::set<CString> &tags, std::set<CString> &texts)
	{
		if (!pRef) return;
		AcDbObjectIterator *pIt = pRef->attributeIterator();
		if (!pIt) return;

		CString str(_T(""));
		AcDbAttribute *pAttr(NULL);
		for (pIt->start(); !pIt->done(); pIt->step())
		{
			AcDbObjectId id = pIt->objectId();
			pRef->openAttribute(pAttr, id, AcDb::kForRead);
			if (pAttr)
			{
				str = pAttr->tag();
				tags.insert(pAttr->tag());
				texts.insert(pAttr->textString());
				pAttr->close();
			}
		}
		DELETE_PTR(pIt);
		return;
	}

	// 判断 idDest 所代表的标高是否再 dMax 与 dMin 之间
	bool modifyElevObj(AcDbObjectId idDest, const double &dMax, const double &dMin)
	{
		OPENOBJ_BEGIN(idDest, AcDb::kForWrite, AcDbEntity, pDest)
		{
			if (!pDest) return false;

			AcDbBlockReference *pRef2 = AcDbBlockReference::cast(pDest);
			AcDbPoint *pPnt2 = AcDbPoint::cast(pDest);
			AcDbText *pTxt2 = AcDbText::cast(pDest);
			AcDbMText *pMTxt2 = AcDbMText::cast(pDest);

			AcGePoint3d pt(AcGePoint3d::kOrigin);
			int prec(2);

			// 图块
			if (pRef2)
			{
				// 比较属性
				std::set<CString> attr2, text2;
				getBlockAttri(pRef2, attr2, text2);
				pt = pRef2->position();
				if (isDouble(*text2.begin(), pt.z))
				{
					if (pt.z > dMax)
					{
						pt.z = dMax;
						pRef2->setPosition(pt);
						setBlockAttri(pRef2, TypeConvert::d2s(pt.z, &prec));
					}
					else if (pt.z < dMin)
					{
						pt.z = dMin;
						pRef2->setPosition(pt);
						setBlockAttri(pRef2, TypeConvert::d2s(pt.z, &prec));
					}
					return true;
				}
				return true;
			}
			else if (pPnt2)	// 点
			{
				pt = pPnt2->position();
				if (pt.z > dMax)
				{
					pt.z = dMax;
					pPnt2->setPosition(pt);
				}
				else if ( pt.z < dMin)
				{
					pt.z = dMin;
					pPnt2->setPosition(pt);
				}
				return true;
			}
			else if (pTxt2)	// 单行文字
			{
				pt = pTxt2->position();
				if (isDouble(pTxt2->textString(), pt.z))
				{
					if (pt.z > dMax)
					{
						pt.z = dMax;
						pTxt2->setPosition(pt);
						pTxt2->setTextString(TypeConvert::d2s(pt.z, &prec));
					}
					else if (pt.z < dMin)
					{
						pt.z = dMin;
						pTxt2->setPosition(pt);
						pTxt2->setTextString(TypeConvert::d2s(pt.z, &prec));
					}
					return true;
				}
				return false;
			}
			else if (pMTxt2)	// 多行文字
			{
				pt = pMTxt2->location();
				if (isDouble(pMTxt2->contents(), pt.z))
				{
					if (pt.z > dMax)
					{
						pt.z = dMax;
						pMTxt2->setLocation(pt);
						pMTxt2->setContents(TypeConvert::d2s(pt.z, &prec));
					}
					else if (pt.z < dMin)
					{
						pt.z = dMin;
						pMTxt2->setLocation(pt);
						pMTxt2->setContents(TypeConvert::d2s(pt.z, &prec));
					}
					return true;
				}
				return false;
			}
			return false;
		}
		OPENOBJ_END()
	}

	// 分析高程对象
	// idOrig是示例对象,判断idDest是否和idOrig一样
	// 如果返回false，说明不是高程点
	bool analyElevObj(AcDbObjectId idOrig, AcDbObjectId idDest, AcGePoint3d &pt)
	{
		//if (idOrig == idDest) return false;
		AcDbObjectId idLay1, idLay2, idLt1, idLt2;
		AcDb::LineWeight lw1, lw2;
		AcCmColor cm1, cm2;
		AcCmTransparency ct1, ct2;
		// 目前只支持3种，块参照 文字对象 点对象
		OPENOBJ_BEGIN(idOrig, AcDb::kForRead, AcDbEntity, pOrig)
		{
			if (!pOrig) return false;
			idLay1 = pOrig->layerId();
			idLt1 = pOrig->linetypeId();
			lw1 = pOrig->lineWeight();
			cm1 = pOrig->color();
			ct1 = pOrig->transparency();
			if (!pOrig) return false;
			AcDbBlockReference *pRef1 = AcDbBlockReference::cast(pOrig);
			AcDbPoint *pPnt1 = AcDbPoint::cast(pOrig);
			AcDbText *pTxt1 = AcDbText::cast(pOrig);
			AcDbMText *pMTxt1 = AcDbMText::cast(pOrig);
			OPENOBJ_BEGIN(idDest, AcDb::kForRead, AcDbEntity, pDest)
			{
				if (!pDest) return false;
				idLay2 = pDest->layerId();
				idLt2 = pDest->linetypeId();
				lw2 = pDest->lineWeight();
				cm2 = pDest->color();
				ct2 = pDest->transparency();
				if (idLay1 != idLay2) return false;
				if (idLt1 != idLt2) return false;
				if (lw1 != lw2) return false;
				if (cm1 != cm2) return false;
				if (ct1 != ct2) return false;

				// 下面分别对图块,点,文字对象进行比较
				AcDbBlockReference *pRef2 = AcDbBlockReference::cast(pDest);
				AcDbPoint *pPnt2 = AcDbPoint::cast(pDest);
				AcDbText *pTxt2 = AcDbText::cast(pDest);
				AcDbMText *pMTxt2 = AcDbMText::cast(pDest);

				// 图块
				if (pRef1 && pRef2)
				{
					if (pRef1->scaleFactors() != pRef2->scaleFactors()) return false;
					if (pRef1->rotation() != pRef2->rotation()) return false;
					if (pRef1->blockTableRecord() != pRef2->blockTableRecord()) return false;
					// 比较属性
					std::set<CString> attr1, attr2, text1, text2;
					getBlockAttri(pRef1, attr1, text1);
					getBlockAttri(pRef2, attr2, text2);
					if (attr1 != attr2) return false;
					// 能走到这里，说明都有属性，或都没有属性

					AcGePoint3d _pt;
					// 如果 ref1 有属性,并且有数字属性值（就判断第一个）
					if (!attr1.empty()) // 说明都有属性
					{	
						// 如果ref1 的属性值是数字,那么，ref2 属性值必须是数字（就判断第一个）
						if (isDouble(*text1.begin(), _pt.z))
						{
							pt = pRef2->position();
							if (!text2.empty() && isDouble(*text2.begin(), pt.z))
							{
								return true;
							}
							else
								return false;
						}
						else // 如果ref1属性值不是数字，那么直接返回ref2的插入点算逑
						{
							pt = pRef2->position();
							return true;
						}
						return false;
					}
					// 都没有属性，直接取插入点
					else
					{
						pt = pRef2->position();
						return true;
					}
				}
				else if (pPnt1 && pPnt2)	// 点
				{
					pt = pPnt2->position();
					return true;
				}
				else if (pTxt1 && pTxt2)	// 单行文字
				{
					if (pTxt1->textStyle() != pTxt2->textStyle()) return false;
					if (pTxt1->horizontalMode() != pTxt2->horizontalMode()) return false;
					if (pTxt1->verticalMode() != pTxt2->verticalMode()) return false;
					if (pTxt1->rotation() != pTxt2->rotation()) return false;
					if (pTxt1->thickness() != pTxt2->thickness()) return false;
					if (pTxt1->widthFactor() != pTxt2->widthFactor()) return false;
					if (pTxt1->height() != pTxt2->height()) return false;
					if (pTxt1->oblique() != pTxt2->oblique()) return false;
					if (pTxt1->isMirroredInX() != pTxt2->isMirroredInX()) return false;
					if (pTxt1->isMirroredInY() != pTxt2->isMirroredInY()) return false;
					pt = pTxt2->position();
					return isDouble(pTxt2->textString(), pt.z);
				}
				else if (pMTxt1 && pMTxt2)	// 多行文字
				{
					if (pMTxt1->actualHeight() != pMTxt2->actualHeight()) return false;
					if (pMTxt1->actualWidth() != pMTxt2->actualWidth()) return false;
					if (pMTxt1->ascent() != pMTxt2->ascent()) return false;
					if (pMTxt1->attachment() != pMTxt2->attachment()) return false;
					if (pMTxt1->descent() != pMTxt2->descent()) return false;
					if (pMTxt1->direction() != pMTxt2->direction()) return false;
					if (pMTxt1->flowDirection() != pMTxt2->flowDirection()) return false;

					AcCmColor cm11, cm22;
					if (pMTxt1->getBackgroundFillColor(cm11) == Acad::eOk
						&& pMTxt2->getBackgroundFillColor(cm22) == Acad::eOk)
					{
						if (cm11 != cm22) return false;
					}

					AcCmTransparency ct11, ct22;
					if (pMTxt1->getBackgroundTransparency(ct11) == Acad::eOk
						&& pMTxt2->getBackgroundTransparency(ct22) == Acad::eOk)
					{
						if (ct11 != ct22) return false;
					}

					double d1, d2;
					if (pMTxt1->getBackgroundScaleFactor(d1) == Acad::eOk
						&& pMTxt2->getBackgroundScaleFactor(d2) == Acad::eOk)
					{
						if (!EQUAL(d1, d2)) return false;
					}

// 					AcGePoint3dArray ar1, ar2;
// 					pMTxt1->getBoundingPoints(ar1);
// 					pMTxt2->getBoundingPoints(ar2);
// 					if (ar1 != ar2) return false;
					
					if (pMTxt1->lineSpacingFactor() != pMTxt2->lineSpacingFactor()) return false;
					if (pMTxt1->lineSpacingStyle() != pMTxt2->lineSpacingStyle()) return false;
					if (pMTxt1->width() != pMTxt2->width()) return false;
					if (pMTxt1->rotation() != pMTxt2->rotation()) return false;
					if (pMTxt1->textStyle() != pMTxt2->textStyle()) return false;
					if (pMTxt1->textHeight() != pMTxt2->textHeight()) return false;

					pt = pMTxt2->location();
					return isDouble(pMTxt2->contents(), pt.z);
				}
				return false;
			}
			OPENOBJ_END()
		}
		OPENOBJ_END()
		return false;
	}

	// 交互：用户选取离散点
	bool getElevPoints(Geometry::GePoint3dArray &arPts, AcDbObjectIdArray &ids)
	{
		ads_name adsNames, adsName;
		AcDbObjectId id(AcDbObjectId::kNull), idOrig(AcDbObjectId::kNull);
		Adesk::Int32 count(0);

		struct resbuf* pRb = acutBuildList(RTDXF0, _T("INSERT,POINT,TEXT,MTEXT"), 0);
		int nRes = CKTCadUtility::SelectEntity(_T("\n请选择一个“图块”、“点”、“文字”对象，做为参考对象："), adsName, pRb);
		acutRelRb(pRb);

		if (nRes != RTNORM) return false;

		acdbGetObjectId(id, adsName);

		CString sFilter(_T("INSERT"));
		OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt)
		{
			if (!pEnt) return false;
			AcDbBlockReference *pRef = AcDbBlockReference::cast(pEnt);
			AcDbPoint *pPnt = AcDbPoint::cast(pEnt);
			AcDbText *pTxt = AcDbText::cast(pEnt);
			AcDbMText *pMTxt = AcDbMText::cast(pEnt);
			if (pRef)
				sFilter = _T("INSERT");
			else if (pPnt)
				sFilter = _T("POINT");
			else if (pTxt)
				sFilter = _T("TEXT");
			else if (pMTxt)
				sFilter = _T("MTEXT");
			else
				return false;
		}
		OPENOBJ_END()
		

		// 在这里判断是用户选择，还是选一个样例，然后选中dwg中的所有与样例相同的实体
		TCHAR szKey[131] = {_T('S'),};
		acedInitGet(RSG_OTHER, _T("S A"));
		nRes = acedGetKword(_T("\n请选择[手动选择高程数据(S)/选择图中全部高程数据(A)]<手动选择高程数据(S)>:"), szKey);

		if (nRes == RTCAN)
			return false;

		if (nRes == RTNONE) _tcscpy(szKey, _T("S"));

		if (_tcscmp(szKey, _T("S")) == 0)
		{
			struct resbuf* pRb = acutBuildList(RTDXF0, sFilter, 0);
			nRes = CKTCadUtility::SelectEntities(_T("\n请选择“图块”、“点”、“文字”对象："), adsNames, pRb);
			acutRelRb(pRb);
			if (nRes != RTNORM) return false;
			acedSSLength(adsNames, &count);
			if (!count) return false;
		}
		else
		{
			pRb = acutBuildList(RTDXF0, sFilter, 0);
			acedSSGet(_T("X"), NULL, NULL, pRb, adsNames);
			acutRelRb(pRb);
			acedSSLength(adsNames, &count);
			if (!count) return false;
		}


		AcGePoint3d pt(AcGePoint3d::kOrigin);
		for (size_t i = 0; i < count; i++)
		{
			acedSSName(adsNames, i, adsName);
			if (Acad::eOk != acdbGetObjectId(idOrig, adsName)) continue;
			if (analyElevObj(id, idOrig, pt))
			{
				arPts.push_back(pt);
				ids.append(idOrig);
			}
		}

		acedSSFree(adsNames);

		return !arPts.empty();
	}

	CString	getUserSelectType(AcDbObjectId &id)
	{
		ads_name adsName;
		Adesk::Int32 count(0);

		struct resbuf *pRb = acutBuildList(RTDXF0, _T("INSERT,POINT,TEXT,MTEXT"), 0);
		int nRes = CKTCadUtility::SelectEntity(_T("\n请选择一个“图块”、“点”、“文字”对象，做为参考对象："), adsName, pRb);
		acutRelRb(pRb);

		if (nRes != RTNORM) return _T("");

		acdbGetObjectId(id, adsName);

		CString sFilter(_T("INSERT"));
		OPENOBJ_BEGIN(id, AcDb::kForRead, AcDbEntity, pEnt)
		{
			if (!pEnt) return _T("");
			AcDbBlockReference *pRef = AcDbBlockReference::cast(pEnt);
			AcDbPoint *pPnt = AcDbPoint::cast(pEnt);
			AcDbText *pTxt = AcDbText::cast(pEnt);
			AcDbMText *pMTxt = AcDbMText::cast(pEnt);
			if (pRef)
				sFilter = _T("INSERT");
			else if (pPnt)
				sFilter = _T("POINT");
			else if (pTxt)
				sFilter = _T("TEXT");
			else if (pMTxt)
				sFilter = _T("MTEXT");
			else
				return _T("");
		}
		OPENOBJ_END()
		return sFilter;
	}

	bool getPointsInArea(LPCTSTR pszFilter
		, AcDbObjectId idOrig
		, Geometry::GePoint3dArray &arPts
		, AcDbObjectIdArray &ids
		, Geometry::GePoint3dArray &area)
	{
		if (!pszFilter) return false;

		ads_name ss, ent;
		struct resbuf *pRb = acutBuildList(RTDXF0, pszFilter, 0);

		// 转成UCS
		Geometry::GePoint3dArray _area(area);
		for (int i(0); i < _area.size(); ++i)
			CoreTools::WCS2UCS(_area[i], _area[i]);
		struct resbuf *pRbFence = CoreTools::MakeFence(_area);

		int nRes = acedSSGet(_T("CP"), pRbFence, NULL, pRb, ss);
		acutRelRb(pRb);
		acutRelRb(pRbFence);
		if (nRes != RTNORM)
		{
			acutPrintf(_T("\n区域内没有需要选择的标高对象!"));
			return false;
		}

		AcDbObjectId id;
		Adesk::Int32 count(0);
		acedSSLength(ss, &count);
		AcGePoint3d pt(AcGePoint3d::kOrigin);
		for (size_t i = 0; i < count; i++)
		{
			acedSSName(ss, i, ent);
			if (Acad::eOk != acdbGetObjectId(id, ent)) continue;
			if (analyElevObj(idOrig, id, pt))
			{
				arPts.push_back(pt);
				ids.append(id);
			}
		}

		acedSSFree(ss);

		return true;
	}

	void getPolyPoints(AcDbPolyline *pPoly
		, const AcGePoint3d &ptS
		, const AcGePoint3d &ptE
		, const double &step
		, std::vector<AcGePoint3d> &pts)
	{
		if (!pPoly) return;

		AcGePoint3d pt(AcGePoint3d::kOrigin), _ptS(ptS), _ptE(ptE);
		double distS(0.), distE(.0), len(.0);

		pPoly->getEndPoint(pt);
		pPoly->getDistAtPoint(pt, len);

		if (Acad::eOk != pPoly->getDistAtPoint(ptS, distS))
		{
			distS = 0.;
			pPoly->getStartPoint(_ptS);
		}

		if (Acad::eOk != pPoly->getDistAtPoint(ptE, distE))
		{
			distE = len;
			pPoly->getEndPoint(_ptE);
		}

		while (distE > distS)
		{
			pPoly->getPointAtDist(distS, pt);
			pts.push_back(pt);
			distS += step;
		}
		pts.push_back(_ptE);
	}

	// 从ptS开始以1米为间隔，逼近到ptE
	AcDbSubDMesh* polyline2SubDMesh(AcDbObjectId idPoly, const double &dH, const AcGePoint3d &ptS, const AcGePoint3d &ptE)
	{
		AcGePoint3dArray arBottoms(0), arTops(0);
		OPENOBJ_BEGIN(idPoly, AcDb::kForRead, AcDbPolyline, pPoly)
		{
			if (!pPoly) return NULL;

			AcGePoint3d pt(AcGePoint3d::kOrigin), _ptS(ptS), _ptE(ptE);
			double distS(0.), distE(.0), len(.0);

			pPoly->getEndPoint(pt);
			pPoly->getDistAtPoint(pt, len);

			if (Acad::eOk != pPoly->getDistAtPoint(ptS, distS))
			{
				distS = 0.;
				pPoly->getStartPoint(_ptS);
			}
			
			if (Acad::eOk != pPoly->getDistAtPoint(ptE, distE))
			{
				distE = len;
				pPoly->getEndPoint(_ptE);
			}

			while (distE > distS)
			{
				pPoly->getPointAtDist(distS, pt);
				arBottoms.append(pt);
				arTops.append(AcGePoint3d(pt.x, pt.y, pt.z + dH));
				distS += 1;
			}
			arBottoms.append(_ptE);
			arTops.append(AcGePoint3d(_ptE.x, _ptE.y, _ptE.z + dH));
		}
		OPENOBJ_END()

		arBottoms.append(arTops);

		int count_of_vertex = arBottoms.length();
		int count_of_vertex_half = (int)( count_of_vertex* .5);
		int count_of_face = count_of_vertex_half - 1;
		AcArray<Adesk::Int32> faces;
		for (int i = 0; i < count_of_face; ++i)
		{
			faces.append(4);
			faces.append(i);
			faces.append(faces.last() + 1);
			faces.append(faces.last() + count_of_vertex_half);
			faces.append(faces.last() - 1);
		}

		AcDbSubDMesh *pMesh = new AcDbSubDMesh;
		pMesh->setSubDMesh(arBottoms, faces, 0);
		return pMesh;
	}

	void getSubDMeshFaces(AcDbSubDMesh *pFaceMesh, std::vector<Face> &fs)
	{
		AcGePoint3dArray arV;
		AcArray<Adesk::Int32> arF;
		Adesk::Int32 countF;
		pFaceMesh->getFaceArray(arF);
		pFaceMesh->getVertices(arV);
		pFaceMesh->numOfFaces(countF);

		int count_of_v(arV.length());
		int count_of_f(arF.length());

		/*
		arF结构如下 第1个数字n为构成一个面的顶点数量，其后n个数字为顶点在arV中的索引
		*/

		Face f;
		for (int i = 0; i < count_of_f;)
		{
			f.num = abs(arF[i]);
			f.vertices.clear();
			// 加1，跳到顶点索引开始
			++i;
			// 将索引取出
			for (int j = 0; j < f.num; ++j)
			{
				if (i + j < count_of_f)
				{
					Adesk::Int32 &vIdx(arF[i + j]);
					if (vIdx < count_of_v)
						f.vertices.push_back(arV[vIdx]);
				}
			}
			fs.push_back(f);
			// 跳到下一个面
			i += f.num;
		}
	}

	double calcAverageZ(const Geometry::GePoint3dArray &pts)
	{
		double dElev(.0);
		for (size_t i(0); i < pts.size(); ++i)
			dElev += pts[i].z;
		dElev /= pts.size();
		return dElev;
	}

	void setZ(Geometry::GePoint3dArray &pts, const double &z)
	{
		for (size_t i(0); i < pts.size(); ++i)
			pts[i].z = z;
	}

	AecDbTerrain* makeTerrain( const Geometry::GePoint3dArray &arPts
		, const Geometry::GePoint3dArray &arOuter )
	{
		if (arPts.empty()) return NULL;
		AecDbTerrain *pTer = new AecDbTerrain();
		pTer->setPoints(arPts);
		if (!arOuter.empty())
			pTer->setOuter(arOuter);
		return pTer;
	}

	void getAllOfPoints(LPCTSTR pszFilter
		, AcDbObjectId idOrig
		, Geometry::GePoint3dArray &arPoints
		, AcDbObjectIdArray &arIds)
	{
		Adesk::Int32 count(0);
		ads_name adsNames, adsName;
		AcDbObjectId id(AcDbObjectId::kNull);
		struct resbuf *pRb = acutBuildList(RTDXF0, pszFilter, 0);
		acedSSGet(_T("X"), NULL, NULL, pRb, adsNames);
		acutRelRb(pRb);
		acedSSLength(adsNames, &count);
		if (!count) return;

		AcGePoint3d pt(AcGePoint3d::kOrigin);
		for (size_t i = 0; i < count; i++)
		{
			acedSSName(adsNames, i, adsName);
			if (Acad::eOk != acdbGetObjectId(id, adsName)) continue;
			if (analyElevObj(idOrig, id, pt))
			{
				arIds.append(id);
				arPoints.push_back(pt);
			}
		}

		acedSSFree(adsNames);
	}

	int getPointsInAreaByUser(LPCTSTR pszFilter
		, AcDbObjectId idOrig
		, std::vector<Geometry::GePoint3dArray> &arArraysOfPoint
		, std::vector<Geometry::GePoint3dArray> &arOuters
		, std::vector<AcDbObjectIdArray> &arArraysOfId )
	{
		Adesk::Int32 count(0);
		ads_name adsNames, adsName;
		struct resbuf *pRb = acutBuildList(RTDXF0, _T("LWPOLYLINE,CIRCLE"), 0);
		int nRes = CKTCadUtility::SelectEntities(_T("\n请选择由“多段线”或“圆”构成的闭合区域："), adsNames, pRb);
		acutRelRb(pRb);
		if (nRes != RTNORM) return nRes;
		acedSSLength(adsNames, &count);
		if (!count) return RTNONE;
		AcDbObjectIdArray ids;
		Geometry::GePoint3dArray arOuter, arPts;
		for (int i(0); i < count; ++i)
		{
			arOuter.clear();
			arPts.clear();
			ids.removeAll();
			acedSSName(adsNames, i, adsName);
			OPENOBJ_BEGIN(adsName, AcDb::kForRead, AcDbEntity, pEnt)
			{
				if (!pEnt) continue;

				AcDbPolyline *pPL = AcDbPolyline::cast(pEnt);
				AcDbCircle *pC = AcDbCircle::cast(pEnt);
				if (pPL)
				{
					polyline2PointArray(*pPL, arOuter, .0);
				}
				else if (pC)
				{
					circle2PointArray(*pC, arOuter, .0);
				}

				getPointsInArea(pszFilter, idOrig, arPts, ids, arOuter);
				if (!ids.isEmpty())
				{
					arArraysOfId.push_back(ids);
					arArraysOfPoint.push_back(arPts);
					arOuters.push_back(arOuter);
				}
			}
			OPENOBJ_END()
		}

		acedSSFree(adsNames);
		if (arArraysOfId.empty())
		{
			acutPrintf(_T("\n选中的区域没有符合特征的实体！"));
			return RTNONE;
		}

		return RTNORM;
	}

	// 0 取消 1 区域 2 全部
	int IsSelectAllPoint()
	{
		// 在这里判断是用户选择，还是选一个样例，然后选中dwg中的所有与样例相同的实体
		TCHAR szKey[131] = { _T('S'), };
		acedInitGet(RSG_OTHER, _T("S A"));
		int nRes = acedGetKword(_T("\n请选择[手动选择高程区域(S)/选择图中全部高程数据(A)]<手动选择高程区域(S)>:"), szKey);

		if (nRes == RTCAN)
			return 0;

		if (nRes == RTNONE)
			return 1;
		return _tcscmp(szKey, _T("S")) == 0 ? 1 : 2;
	}
}

void TERRAIN::generateTerrainMesh()
{
	AcDbObjectId idOrig(AcDbObjectId::kNull);

	CString sFilter(getUserSelectType(idOrig));
	if (sFilter.IsEmpty()) return;

	int nSelType(IsSelectAllPoint());
	if (nSelType == 0) return;

	AcDbObjectId layerId = KTSetting::InitLayer(_T("LAY_FACTORY_LAND"), false);

	if (nSelType == 1)
	{
		std::vector<Geometry::GePoint3dArray> arArraysOfPoint;
		std::vector<Geometry::GePoint3dArray> arOuters;
		std::vector<AcDbObjectIdArray> arArraysOfId;
		int nRes = getPointsInAreaByUser(sFilter, idOrig, arArraysOfPoint, arOuters, arArraysOfId);
		if (nRes != RTNORM) return;

		if (!arArraysOfId.empty()
			&& !arArraysOfPoint.empty()
			&& !arOuters.empty()
			&& arArraysOfId.size() == arArraysOfPoint.size()
			&& arArraysOfId.size() == arOuters.size())
		{
			for (size_t i = 0; i < arArraysOfId.size(); ++i)
			{
				//AcDbObjectIdArray &ids(arArraysOfId[i]);
				Geometry::GePoint3dArray &arPts(arArraysOfPoint[i]);
				Geometry::GePoint3dArray &arOuter(arOuters[i]);
				setZ(arOuter, calcAverageZ(arPts));
				AecDbTerrain *pTer(makeTerrain(arPts, arOuter));
				if (pTer)
				{
					if (layerId.isValid()) pTer->setLayer(layerId);
					CoreTools::AddToModelSpace(pTer);
				}
			}
			return;
		}
	}
	else
	{
		Geometry::GePoint3dArray arPts(0);

		AcDbObjectIdArray ids;
		getAllOfPoints(sFilter, idOrig, arPts, ids);

		AecDbTerrain *pTer(makeTerrain(arPts, Geometry::GePoint3dArray()));
		if (pTer)
		{
			if (layerId.isValid()) pTer->setLayer(layerId);
			CoreTools::AddToModelSpace(pTer);
			return;
		}
	}

	return;

}

void TERRAIN::setSmoothLevelForTerrainMesh()
{
	ads_name entTerrain;
	struct resbuf *pRb = acutBuildList(RTDXF0, _T("AEC_DBTERRAIN"), 0);
	int nRes = CKTCadUtility::SelectEntity(_T("\n选择一个上华地形实体:"), entTerrain, pRb);
	if (RTNORM != nRes) return;
	acutRelRb(pRb);

	OPENOBJ_BEGIN(entTerrain, AcDb::kForWrite, AecDbTerrain, pTer)
	{
		if (!pTer) return;
		int iSm(pTer->getSmoothLevel());
		CString str(_T(""));
		str.Format(_T("\n请输入平滑度（1-4）<%d>："), iSm);
		acedGetInt(str, &iSm);
		pTer->setSmoothLevel(iSm);
	}
	OPENOBJ_END()
}

void TERRAIN::delHoldForTerrainMesh()
{
	ads_name entTerrain;
	struct resbuf *pRb = acutBuildList(RTDXF0, _T("AEC_DBTERRAIN"), 0);
	int nRes = CKTCadUtility::SelectEntity(_T("\n选择一个上华地形实体:"), entTerrain, pRb);
	if (RTNORM != nRes) return;
	acutRelRb(pRb);

	TCHAR szKey[131] = { _T('S'), };
	acedInitGet(RSG_OTHER, _T("S A"));
	nRes = acedGetKword(_T("\n请选择[删除单独的洞口(S)/删除全部洞口(A)]<删除单独的洞口(S)>:"), szKey);

	if (nRes == RTCAN) return;

	if (nRes == RTNONE) _tcscpy(szKey, _T("S"));

	if (_tcscmp(szKey, _T("S")) == 0)
	{
		ads_point adsPt;
		if (acedGetPoint(NULL, _T("\n请在要删除的洞口内部选择一点："), adsPt) != RTNORM) return;
		AcGePoint3d ptInput(asPnt3d(adsPt));
		CoreTools::UCS2WCS(ptInput, ptInput);

		OPENOBJ_BEGIN(entTerrain, AcDb::kForWrite, AecDbTerrain, pTer)
		{
			if (!pTer) return;
			if (pTer->deleteHold(ptInput))
				acutPrintf(_T("\n删除地形上的洞口成功！"));
			else
				acutPrintf(_T("\n删除地形上的洞口失败！"));
		}
		OPENOBJ_END()
	}
	else
	{
		OPENOBJ_BEGIN(entTerrain, AcDb::kForWrite, AecDbTerrain, pTer)
		{
			if (!pTer) return;
			if (pTer->clearHolds())
				acutPrintf(_T("\n地形上的洞口全部删除完毕！"));
			else
				acutPrintf(_T("\n全部删除地形上的洞口失败！"));
		}
		OPENOBJ_END()
	}
}

void TERRAIN::addHoldToTerrainMesh()
{
	ads_name entTerrain, ssHolds, ent;
	struct resbuf *pRb = acutBuildList(RTDXF0, _T("AEC_DBTERRAIN"), 0);
	int nRes = CKTCadUtility::SelectEntity(_T("\n选择一个上华地形实体:"), entTerrain, pRb);
	if (RTNORM != nRes) return;
	acutRelRb(pRb);

	AcDbObjectIdArray ids;
	CString psz(_T("LWPOLYLINE,CIRCLE"));
	resbuf *pRb2 = acutBuildList(RTDXF0, psz, 0);
	if (CKTCadUtility::SelectEntities(_T("\n请选择洞口闭合曲线（多段线或圆）："), ssHolds, pRb2) != RTNORM) return;
	acutRelRb(pRb2);

	AcDbObjectId id;
	Adesk::Int32 lLen(0L);
	acedSSLength(ssHolds, &lLen);

	ids.removeAll();
	for (long i = 0; i < lLen; ++i)
	{
		if (acedSSName(ssHolds, i, ent) != RTNORM) continue;
		if (acdbGetObjectId(id, ent) != Acad::eOk) continue;
		ids.append(id);
	}
	acedSSFree(ssHolds);


	std::vector<AcGePoint3d> pts;
	OPENOBJ_BEGIN(entTerrain, AcDb::kForWrite, AecDbTerrain, pTer)
	{
		if (!pTer) return;
		double dElev(pTer->getElev());
		CString str(_T(""));
		str.Format(_T("\n请输入洞口标高（单位与高程数据一致），默认为地形平均标高< % .2f>："), dElev);
		acedGetReal(str, &dElev);
		for (int i(0); i < ids.length(); ++i)
		{
			OPENOBJ_BEGIN(ids[i], AcDb::kForRead, AcDbEntity, pHold)
			{
				if (!pHold) continue;
				pts.clear();

				AcDbPolyline *pPoly = AcDbPolyline::cast(pHold);
				AcDbCircle *pCir = AcDbCircle::cast(pHold);

				if (pPoly)
					polyline2PointArray(*pPoly, pts, dElev);
				else if (pCir)
					circle2PointArray(*pCir, pts, dElev);

				if (!pts.empty())
					pTer->addHold(pts);
			}
			OPENOBJ_END()
		}
	}
	OPENOBJ_END()
}

void TERRAIN::addHoldForSubDMesh(const AcGePoint3dArray &arPt
	, const Geometry::GePolyArray3d &arHold)
{

	Geometry::GePoint3dArray pts;
	for (int i(0); i < arPt.length(); ++i)
		pts.push_back(arPt[i]);

	AcGePoint3dArray vertexArray;
	AcArray<Adesk::Int32> faceArray;
	Geometry::delaunayTriangulationMeshWithHolds(pts, arHold, vertexArray, faceArray);

	AcDbSubDMesh *pSubDMesh = new AcDbSubDMesh;

	AcDbObjectId layerID(AcDbObjectId::kNull);
	g_LayerMgr::instance().getLayer(GLTools::gLayer_DS, layerID);
	if (layerID.isValid())
		pSubDMesh->setLayer(layerID);

	pSubDMesh->setSubDMesh(vertexArray, faceArray, 0);
	CoreTools::AddToModelSpace(pSubDMesh);
	return;
}

void TERRAIN::getHull()
{
	Geometry::GePoint3dArray arPt3Ds(0);
	AcDbObjectIdArray ids;
	if (!getElevPoints(arPt3Ds, ids)) return;

	Geometry::GePoint2dArray ar2d, arOuter;
	for (size_t i(0); i < arPt3Ds.size(); ++i)
	{
		ar2d.push_back(AcGePoint2d(arPt3Ds[i].x, arPt3Ds[i].y));
	}

	
	Geometry::calcConvexHull2D(ar2d, arOuter);

	AcDbPolyline *pPolyline = new AcDbPolyline();
	for (size_t i(0); i < arOuter.size(); ++i)
	{
		pPolyline->addVertexAt(i, arOuter[i]);
	}
	pPolyline->setClosed(1);

	CoreTools::AddToModelSpace(pPolyline);
}

void TERRAIN::levelTerrainMesh()
{
	Geometry::GePoint3dArray arPt3Ds(0);

	AcDbObjectId idOrig(AcDbObjectId::kNull);
	CString sFilter(getUserSelectType(idOrig));
	if (sFilter.IsEmpty()) return;


	double dMax(.0), dMin(.0);
	if (acedGetReal(_T("\n请输入需要平整的地形的最大标高（单位：米）："), &dMax) != RTNORM) return;
	if (acedGetReal(_T("\n请输入需要平整的地形的最小标高（单位：米）："), &dMin) != RTNORM) return;

	if (dMin > dMax)
	{
		double d(dMin);
		dMin = dMax;
		dMax = d;
	}

	bool bGenerateTerrain = true;
	TCHAR szKey2[131] = { _T('Y'), };
	acedInitGet(RSG_OTHER, _T("Y N"));
	int nRes = acedGetKword(_T("\n平整成功后，是否立即生成地形？[是(Y)/否(N)]<是(Y)>:"), szKey2);
	if (nRes == RTNONE) _tcscpy(szKey2, _T("Y"));

	if (_tcscmp(szKey2, _T("Y")) != 0)
		bGenerateTerrain = false;

	AcDbObjectId layerId = KTSetting::InitLayer(_T("LAY_FACTORY_LAND"), false);

	int nSelType(IsSelectAllPoint());
	if (nSelType == 0) return;

	if (nSelType == 1)
	{
		
		std::vector<Geometry::GePoint3dArray> arArraysOfPoint;
		std::vector<Geometry::GePoint3dArray> arOuters;
		std::vector<AcDbObjectIdArray> arArraysOfId;
		nRes = getPointsInAreaByUser(sFilter, idOrig, arArraysOfPoint, arOuters, arArraysOfId);
		if (nRes != RTNORM) return;

		if (!arArraysOfId.empty()
			&& !arArraysOfPoint.empty()
			&& !arOuters.empty()
			&& arArraysOfId.size() == arArraysOfPoint.size()
			&& arArraysOfId.size() == arOuters.size())
		{
			for (size_t i = 0; i < arArraysOfId.size(); ++i)
			{
				AcDbObjectIdArray &ids(arArraysOfId[i]);
				Geometry::GePoint3dArray &arOuter(arOuters[i]);
				// 修改标高
				for (int j(0); j < ids.length(); ++j)
					modifyElevObj(ids[j], dMax, dMin);
				
				if (bGenerateTerrain)
				{
					arPt3Ds.clear();
					// 修改后重新分析标高
					AcGePoint3d pt(AcGePoint3d::kOrigin);
					for (int i(0); i < ids.length(); ++i)
					{
						if (analyElevObj(ids.first(), ids[i], pt))
							arPt3Ds.push_back(pt);
					}

					// 重新为外轮廓设置标高
					setZ(arOuter, calcAverageZ(arPt3Ds));

					// 生成
					AecDbTerrain *pTer(makeTerrain(arPt3Ds, arOuter));
					if (pTer)
					{
						if (layerId.isValid()) pTer->setLayer(layerId);
						CoreTools::AddToModelSpace(pTer);
					}
				}
			}
			return;
		}
	}
	else
	{

		Geometry::GePoint3dArray arPts(0);

		AcDbObjectIdArray ids;
		getAllOfPoints(sFilter, idOrig, arPts, ids);

		// 修改标高
		for (int i(0); i < ids.length(); ++i)
			modifyElevObj(ids[i], dMax, dMin);

		if (bGenerateTerrain)
		{
			arPt3Ds.clear();
			// 修改后重新分析标高
			AcGePoint3d pt(AcGePoint3d::kOrigin);
			for (int i(0); i < ids.length(); ++i)
			{
				if (analyElevObj(ids.first(), ids[i], pt))
					arPt3Ds.push_back(pt);
			}

			AecDbTerrain *pTer(makeTerrain(arPts, Geometry::GePoint3dArray()));
			if (pTer)
			{
				if (layerId.isValid()) pTer->setLayer(layerId);
				CoreTools::AddToModelSpace(pTer);
				return;
			}
		}
		return;
	}
}

void TERRAIN::extractElevtionData()
{
	ads_name adsName;
	ads_point adsPt;

	int nRes = acedEntSel(_T("\n请选择一个多面网格对象："), adsName, adsPt);
	if (nRes != RTNORM) return;

	AcDbObjectId idMesh(AcDbObjectId::kNull);
	acdbGetObjectId(idMesh, adsName);
	if (!GLTools::isThisClass<AcDbSubDMesh>(idMesh))
	{
		acutPrintf(_T("\n请选择一个多面网格对象!"));
		return;
	}

	nRes = acedEntSel(_T("\n请选择一个多段线对象："), adsName, adsPt);
	if (nRes != RTNORM) return;
	AcDbObjectId idPoly(AcDbObjectId::kNull);
	acdbGetObjectId(idPoly, adsName);
	if (!GLTools::isThisClass<AcDbPolyline>(idPoly))
	{
		acutPrintf(_T("\n请选择一个多段线对象!"));
		return;
	}

	nRes = acedEntSel(_T("\n请选择起始桩号："), adsName, adsPt);
	if (nRes != RTNORM) return;
	AcDbObjectId StartTxtID(AcDbObjectId::kNull);
	acdbGetObjectId(StartTxtID, adsName);
	if (!GLTools::isThisClass<AcDbText>(StartTxtID) || !StakeTools::isSHSStake(StartTxtID))
	{
		acutPrintf(_T("\n请选择一个上华桩号对象。"));
		return;
	}

	nRes = acedEntSel(_T("\n请选择结束桩号："), adsName, adsPt);
	if (nRes != RTNORM) return;
	AcDbObjectId EndTxtID(AcDbObjectId::kNull);
	acdbGetObjectId(EndTxtID, adsName);
	if (!GLTools::isThisClass<AcDbText>(EndTxtID) || !StakeTools::isSHSStake(EndTxtID))
	{
		acutPrintf(_T("\n请选择一个上华桩号对象。"));
		return;
	}
	// 取出网格和路线的拷贝
	AcDbSubDMesh *pCloneMesh(NULL);
	OPENOBJ_BEGIN(idMesh, AcDb::kForRead, AcDbSubDMesh, pFaceMesh)
	{
		if (!pFaceMesh) return;
		pCloneMesh = (AcDbSubDMesh*)pFaceMesh->clone();
	}
	OPENOBJ_END()

	AcDbPolyline *pClonePoly(NULL);
	OPENOBJ_BEGIN(idPoly, AcDb::kForRead, AcDbPolyline, pPoly)
	{
		if (!pPoly)
		{
			DELETE_PTR(pCloneMesh);
			return;
		}
		pClonePoly = (AcDbPolyline*)pPoly->clone();
	}
	OPENOBJ_END()

	bool bS2E;
	CString strTemp;
	double dTemp;
	AcGePoint3d ptStart(AcGePoint3d::kOrigin), ptEnd(AcGePoint3d::kOrigin);
	StakeTools::readSHSStake(StartTxtID, ptStart, bS2E, strTemp, dTemp, dTemp);
	StakeTools::readSHSStake(EndTxtID, ptEnd, bS2E, strTemp, dTemp, dTemp);
	CString strPrefix(_T(""));
	StakeTools::analyStakeString(strTemp, dTemp, &strPrefix);

	if (!bS2E)
	{
		AcGePoint3d ptT(ptStart);
		ptStart = ptEnd;
		ptEnd = ptT;
	}

	AcDbExtents ext;
	pCloneMesh->getGeomExtents(ext);

	if ( ptStart.x > ext.maxPoint().x || ptStart.y > ext.maxPoint().y
		|| ptStart.x < ext.minPoint().x || ptStart.y < ext.minPoint().y
		|| ptEnd.x > ext.maxPoint().x || ptEnd.y > ext.maxPoint().y
		|| ptEnd.x < ext.minPoint().x || ptEnd.y < ext.minPoint().y )
	{
		acutPrintf(_T("\n起起桩号与结束桩号之间的范围大于地形网格的范围。"));
		return;
	}

	if (!EQUAL_ZERO(pClonePoly->elevation()))
		pClonePoly->setElevation(.0);

	std::vector<AcGePoint3d> pts(0);
	getPolyPoints(pClonePoly, ptStart, ptEnd, 1., pts);

	std::vector<Face> fs(0);
	getSubDMeshFaces(pCloneMesh, fs);

	std::vector<FacePoint> fps;
	FacePoint fp;
	for (size_t i = 0; i < pts.size(); ++i)
	{
		fp.pt = pts[i];
		for (size_t f = 0; f < fs.size(); ++f)
		{
			Face &face(fs[f]);
			if (isInFace(fp.pt, face))
			{
				fp.setFace(face);
				fps.push_back(fp);
				break;
			}
		}
	}

	std::map<double, CString> mapResult;
	int prec(3);
	AcGePoint3d ptClosed(AcGePoint3d::kOrigin);
	double dist(.0);
	for (size_t i = 0; i < fps.size(); ++i)
	{
		AcGePoint3d &pt(fps[i].pt);
		if (Acad::eOk != pClonePoly->getClosestPointTo(pt, ptClosed)) continue;
		if (Acad::eOk != pClonePoly->getDistAtPoint(ptClosed, dist)) continue;
		mapResult.insert(std::make_pair(dist, TypeConvert::f2s(pt.z, &prec)));
	}

	if (mapResult.empty())
	{
		DELETE_PTR(pClonePoly);
		DELETE_PTR(pCloneMesh);
		return;
	}

	CString  szFilter = _T("纵断数据文件 (*.txt)|*.txt;*.txt||");
	CFileDialog fileDlg(FALSE, _T("txt"), _T("纵断数据文件"), OFN_HIDEREADONLY, szFilter, acedGetAcadFrame());
	if (fileDlg.DoModal() != IDOK)
	{
		DELETE_PTR(pClonePoly);
		DELETE_PTR(pCloneMesh);
		return;
	}

	CStdioFile file(fileDlg.GetPathName(), CFile::modeCreate|CFile::modeWrite);
	if (!file.m_hFile)
	{
		DELETE_PTR(pClonePoly);
		DELETE_PTR(pCloneMesh);
		return;
	}

	std::map<double, CString>::iterator it = mapResult.begin();
	CString str(_T(""));
	for (; it != mapResult.end(); ++it)
	{
		str.Format(_T("%s %s\n"), StakeTools::generateStakeString(it->first, strPrefix), it->second);
		file.WriteString(str);
	}
	file.Close();

	DELETE_PTR(pClonePoly);
	DELETE_PTR(pCloneMesh);
	return;
}

#endif

namespace
{
	class DBRule: public AcDbEntity
	{
	public:
		DBRule() : entitys(0) { }
		~DBRule() { clear(); }

		void clear()
		{
			for (size_t i = 0; i < entitys.size(); ++i)
			{
				AcDbEntity *p(entitys[i]);
				DELETE_PTR(p);
			}
			entitys.clear();
		}

		virtual Adesk::Boolean subWorldDraw(AcGiWorldDraw* pWd)
		{
			for (size_t i = 0; i < entitys.size(); i++)
			{
				AcDbEntity *p(entitys[i]);
				if (p) p->worldDraw(pWd);
			}
			return Adesk::kTrue;
		}

		void setEntitys(const std::vector<AcDbEntity*> &ents)
		{
			clear();
			entitys.assign(ents.begin(), ents.end());
		}

	public:
		std::vector<AcDbEntity*> entitys;
	};

	void drawRule(const AcGePoint3d &ptS
		, const AcGePoint3d &ptE
		, const double &dElev
		, std::vector<AcDbEntity*> &lines)
	{
		// 刻度1分米
		double delta = .1;
		AcGeVector3d vtX(ucsXDir()), vtY(ucsYDir());
		vtX.normalize();
		vtY.normalize();

		// 沿ucsX方向画刻度， ucsY方向画数轴

		AcGeVector3d vt = ptE - ptS;
		int iNegative(1);
		if (vt.dotProduct(vtY) < 0)
			iNegative = -1;
		//delta *= iNegative;
		vtY *= iNegative;

		double length(vt.length());

		lines.push_back(new AcDbLine(ptS, ptS + (vtY * length)));

		int step(0), prec(3);
		double dist(.0), angle(.0);
		AcGePoint3d pt(AcGePoint3d::kOrigin);
		while (dist < length)
		{
			pt = ptS + (vtY * dist);
			if (!(step % 10))
			{
				lines.push_back(new AcDbLine(pt, pt + (vtX * .05)));
				AcDbText *pTxt = new AcDbText();
				pTxt->setHorizontalMode(AcDb::kTextRight);
				pTxt->setVerticalMode(AcDb::kTextVertMid);
				pTxt->setAlignmentPoint(pt);
				pTxt->setHeight(.04);
				pTxt->setTextString(TypeConvert::f2s(dElev + step * .1 * iNegative, &prec));
				angle = AcGeVector3d::kXAxis.angleTo(vtX, AcGeVector3d::kZAxis);
				pTxt->setRotation(angle);
				lines.push_back(pTxt);
			}
			else if (!(step % 5))
			{
				lines.push_back(new AcDbLine(pt, pt + (vtX * .03)));
			}
			else
				lines.push_back(new AcDbLine(pt, pt + (vtX * .01)));
			dist += delta;
			++step;
		}

		return;
	}

	class RuleJig :public AcEdJig
	{
	public:
		RuleJig(const AcGePoint3d &ptS, const double &dElev)
			: m_pRule(NULL)
			, m_ptS(ptS)
			, m_dElev(dElev) { m_pRule = new DBRule(); }
		~RuleJig() { DELETE_PTR(m_pRule); }
		AcEdJig::DragStatus doIt()
		{
			setDispPrompt(_T("请选择一点做为标尺终点，来确定标尺方向与长度："));
			AcEdJig::DragStatus st = drag();
			return st;
		}

		void getEntitys(std::vector<AcDbEntity*> &ents)
		{
			for (size_t i = 0; i < m_pRule->entitys.size(); ++i)
				ents.push_back((AcDbEntity*)m_pRule->entitys[i]->clone());
		}

	protected:
		virtual AcEdJig::DragStatus sampler()
		{
			AcEdJig::DragStatus st = acquirePoint(m_ptPos);
			return st;
		}
		virtual Adesk::Boolean update()
		{
			if (!m_pRule) return Adesk::kFalse;
			std::vector<AcDbEntity*> ents(0);
			drawRule(m_ptS, m_ptPos, m_dElev, ents);
			// 在setEntitys()回收内存
			m_pRule->setEntitys(ents);
			return Adesk::kTrue;
		}
		virtual AcDbEntity* entity() const { return m_pRule; }

	private:
		DBRule *m_pRule;
		AcGePoint3d m_ptPos; // 选中点
		AcGePoint3d m_ptS; // 开始点
		double m_dElev;	// 起始标高
	};
}

void TERRAIN::GenerateScaleplate()
{
	ads_point adsPt;
	int nRes = acedGetPoint(NULL, _T("\n请选择一点做为标尺起点："), adsPt);
	if (nRes != RTNORM) return;

	acdbUcs2Wcs(adsPt, adsPt, false);
	AcGePoint3d ptOrig(asPnt3d(adsPt));

	double dElev(.0);
	nRes = acedGetReal(_T("\n请输入起点标高<0>："), &dElev);
	if (nRes == RTCAN) return;

	RuleJig *pJig = new RuleJig(ptOrig, dElev);
	if (pJig->doIt() != AcEdJig::kNormal)
	{
		DELETE_PTR(pJig);
		return;
	}
	
	std::vector<AcDbEntity*> lines;
	pJig->getEntitys(lines);

	AcDbObjectIdArray ids(0);
	AcDbObjectId id(AcDbObjectId::kNull);
	for (size_t i = 0; i < lines.size(); ++i)
	{
		if (CoreTools::AddToModelSpace(lines[i], 0, true, &id) == Acad::eOk)
			ids.append(id);
	}

	CoreTools::generateGroup(NULL, ids);

	DELETE_PTR(pJig);
}