#include "StdAfx.h"
#include "CollisionDetection.h"
#include "aecdbentitybase.h"
#include "aecdbcurvebase.h"
#include "aecdbwall.h"
#include "aecdbbeam.h"
#include "aecdbcolumn.h"
#include "aecdbslab.h"
#include "aecdbopening.h"
#include "aecdbewequipment.h"
#include "aecdbxequipment.h"
#include "AecUIContextMenu.h"
#include "coretools.h"
#include "entityfilter.h"
#include "typeconvert.h"

#undef min
#undef max

#define CD_FLAG _T("CD_FLAG")
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
namespace CDA
{
	AABB::AABB()
	{
		// 使用极端的正负值，确保任何有效的图形 extents 都能覆盖它
		m_maxPt.x = m_maxPt.y = m_maxPt.z = -1e20;
		m_minPt.x = m_minPt.y = m_minPt.z = 1e20;
	}

	AABB::AABB(const AcDbExtents &ext)
	{
		set(ext);
	}

	// 辅助方法：合并另一个 AABB
	void AABB::grow(const AABB &other)
	{
		m_minPt.x = std::min(m_minPt.x, other.m_minPt.x);
		m_minPt.y = std::min(m_minPt.y, other.m_minPt.y);
		m_minPt.z = std::min(m_minPt.z, other.m_minPt.z);

		m_maxPt.x = std::max(m_maxPt.x, other.m_maxPt.x);
		m_maxPt.y = std::max(m_maxPt.y, other.m_maxPt.y);
		m_maxPt.z = std::max(m_maxPt.z, other.m_maxPt.z);
	}

	void AABB::set(const AcDbExtents &ext)
	{
		m_maxPt = ext.maxPoint();
		m_minPt = ext.minPoint();
	}

	// 辅助方法：计算包围盒的中心点 (用于拆分节点)
	AcGePoint3d AABB::centroid() const
	{
		return AcGePoint3d((m_minPt.x + m_maxPt.x) * 0.5,
			(m_minPt.y + m_maxPt.y) * 0.5,
			(m_minPt.z + m_maxPt.z) * 0.5);
	}

	// 辅助方法：获取最长轴 (0=X, 1=Y, 2=Z)
	int AABB::getLongestAxis() const
	{
		double dx = m_maxPt.x - m_minPt.x;
		double dy = m_maxPt.y - m_minPt.y;
		double dz = m_maxPt.z - m_minPt.z;
		if (dx >= dy && dx >= dz) return 0;
		if (dy >= dx && dy >= dz) return 1;
		return 2;
	}

	bool AABB::intersects(const AABB &other) const
	{
		if (m_maxPt.x < other.m_minPt.x || m_minPt.x > other.m_maxPt.x) return false;
		if (m_maxPt.y < other.m_minPt.y || m_minPt.y > other.m_maxPt.y) return false;
		if (m_maxPt.z < other.m_minPt.z || m_minPt.z > other.m_maxPt.z) return false;
		return true;
	}

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 参数改用 const 引用传递
	bool EntityProxy::set(const AcDbObjectId &id)
	{
		AcDbEntityPointer ent(id, AcDb::kForRead);
		if (ent.openStatus() != Acad::eOk) return false;

		AcDbExtents ext;
		if (ent->getGeomExtents(ext) != Acad::eOk) return false;
		m_entityId = id;
		m_box.set(ext);
		m_centroid = m_box.centroid();
		return true;
	}

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 外部世界只需要调用这一个接口
	void BVHTree::Build(const AcDbObjectIdArray &ar)
	{
		if (ar.isEmpty()) return;

		EntityProxy proxy;
		for (int i(0); i < ar.length(); ++i)
		{
			if (proxy.set(ar[i]))
				m_allEntities.push_back(proxy);
		}

		// 预分配内存，这在 C++ 中极其重要！
		// 数学上，N 个叶子节点的满二叉树，总节点数最多是 2N - 1
		// 提前 reserve 可以彻底避免递归中 push_back 导致的动态扩容和内存搬运性能损耗
		m_bvhNodes.clear();
		m_bvhNodes.reserve(m_allEntities.size() * 2);

		// 压入根节点 (索引为 0)
		m_bvhNodes.push_back(BVHNode());

		// 启动递归建树
		BuildNode(0, 0, (int)m_allEntities.size());
	}

	void BVHTree::GetIntersections(const AABB &queryBox, std::vector<AcDbObjectId> &hitIds) const
	{
		// 如果树还没建好，直接返回
		if (m_bvhNodes.empty())
		{
			return;
		}

		// 手搓一个极其轻量的栈。64 层深度足以容纳上百万实体的树！
		const int MAX_STACK_SIZE = 64;
		int stack[MAX_STACK_SIZE];
		int stackPtr = 0;

		// 把根节点（索引为 0）压入栈
		stack[stackPtr++] = 0;

		while (stackPtr > 0)
		{
			// 弹出栈顶节点
			int nodeIdx = stack[--stackPtr];
			const BVHNode &node = m_bvhNodes[nodeIdx];

			// 1. 核心粗筛：如果连这个大管辖区的包围盒都不碰，直接跳过这整整半片厂房！
			if (!node.box.intersects(queryBox))
			{
				continue;
			}

			// 2. 如果碰到了，判断是不是叶子节点
			if (node.isLeaf())
			{
				// 已经是叶子节点了：遍历里面那几个具体的实体，进行精确 AABB 检测
				for (int i = 0; i < node.primitiveCount; ++i)
				{
					const EntityProxy &proxy = m_allEntities[node.leftFirst + i];
					if (proxy.m_box.intersects(queryBox))
					{
						hitIds.push_back(proxy.m_entityId);
					}
				}
			}
			else
			{
				// 绝对的防线：因为我们每次要压入 2 个元素，所以必须保证至少还有 2 个空位
				if (stackPtr <= MAX_STACK_SIZE - 2)
				{
					stack[stackPtr++] = node.leftFirst;       // 左子节点
					stack[stackPtr++] = node.leftFirst + 1;   // 右子节点
				}
				else
				{
					// 触发了这一步，说明图纸数据极度病态，击穿了 256 层深度。
					// 在工业软件中，通常会在这里输出一行 Debug 日志，
					// 丢弃这部分极深层级的遍历以保全主程序不崩溃。
					//acutPrintf(_T("\n警告: BVH 树深度超过 %d，放弃深层碰撞检测。"), MAX_STACK_SIZE);
					continue;
				}
			}
		}
	}

	void BVHTree::GetIntersections(AcDbObjectId &id, std::vector<AcDbObjectId> &hitIds) const
	{
		AcDbEntityPointer ent(id, AcDb::kForRead);
		if (ent.openStatus() != Acad::eOk) return;

		AcDbExtents ext;
		if (ent->getGeomExtents(ext) != Acad::eOk) return;

		AABB ab(ext);
		GetIntersections(ab, hitIds);
	}

	void BVHTree::GetAllIntersections(std::vector<std::pair<AcDbObjectId, AcDbObjectId>> &hitPairs) const
	{
		if (m_bvhNodes.empty())
		{
			return;
		}

		// 从根节点开始，让整棵树自己和自己比较
		CollideNodes(0, 0, hitPairs);
	}

	// 内部递归建树函数，直接操作类成员变量
	void BVHTree::BuildNode(int nodeIdx, int entityOffset, int entityCount)
	{
		// 1. 计算这批实体的总包围盒
		AABB totalBox;
		for (int i = 0; i < entityCount; ++i)
		{
			totalBox.grow(m_allEntities[entityOffset + i].m_box);
		}

		// 注意：不要在这里使用引用 (BVHNode& node = m_bvhNodes[nodeIdx]) 然后贯穿整个函数。
		// 因为后面有 push_back 操作，理论上如果 capacity 不够会导致底层数组重新分配，
		// 引用就会瞬间变成悬空引用（野指针）。这是极其经典的 C++ 崩溃暗坑！
		m_bvhNodes[nodeIdx].box = totalBox;

		// 2. 终止条件：如果实体数量足够少，直接变成叶子节点
		if (entityCount <= 4)
		{
			m_bvhNodes[nodeIdx].leftFirst = entityOffset;
			m_bvhNodes[nodeIdx].primitiveCount = entityCount;
			return;
		}

		// 3. 找出当前 Box 的最长轴以及空间的中心点
		int longestAxis = totalBox.getLongestAxis();
		double splitPos = 0.0;

		if (longestAxis == 0)
		{
			splitPos = totalBox.centroid().x;
		}
		else if (longestAxis == 1)
		{
			splitPos = totalBox.centroid().y;
		}
		else
		{
			splitPos = totalBox.centroid().z;
		}

		// 4. 使用 std::partition 原地划分数组
		std::vector<EntityProxy>::iterator beginIt = m_allEntities.begin() + entityOffset;
		std::vector<EntityProxy>::iterator endIt = beginIt + entityCount;

		std::vector<EntityProxy>::iterator midIt = std::partition(
			beginIt,
			endIt,
			PartitionPredicate(longestAxis, splitPos)
		);

		int leftCount = (int)std::distance(beginIt, midIt);

		// 5. 极端边界处理：如果所有实体的质心都完全重合，强行平分
		if (leftCount == 0 || leftCount == entityCount)
		{
			leftCount = entityCount / 2;
		}

		// 6. 分配左右子节点的索引
		int leftChildIdx = (int)m_bvhNodes.size();
		m_bvhNodes.push_back(BVHNode()); // 压入左节点
		m_bvhNodes.push_back(BVHNode()); // 压入右节点

		// 安全地更新当前节点信息
		m_bvhNodes[nodeIdx].leftFirst = leftChildIdx;
		m_bvhNodes[nodeIdx].primitiveCount = 0;

		// 7. 递归构建左子树和右子树
		BuildNode(leftChildIdx, entityOffset, leftCount);
		BuildNode(leftChildIdx + 1, entityOffset + leftCount, entityCount - leftCount);
	}

	// 核心的双树递归遍历函数
	void BVHTree::CollideNodes(int nodeIdxA, int nodeIdxB, std::vector<std::pair<AcDbObjectId, AcDbObjectId>> &hitPairs) const
	{
		const BVHNode &nA = m_bvhNodes[nodeIdxA];
		const BVHNode &nB = m_bvhNodes[nodeIdxB];

		// 极速粗筛：如果这两个节点的包围盒根本不相交，直接砍掉整条递归分支！
		if (!nA.box.intersects(nB.box))
		{
			return;
		}

		// 情况 1：正在检查同一个节点 (nodeIdxA == nodeIdxB)
		if (nodeIdxA == nodeIdxB)
		{
			if (nA.isLeaf())
			{
				// 同一个叶子节点内部的实体两两比较
				// 剪刀 1：j 从 i + 1 开始，完美避开 A-B 和 B-A，且不比较自己
				for (int i = 0; i < nA.primitiveCount; ++i)
				{
					for (int j = i + 1; j < nA.primitiveCount; ++j)
					{
						const EntityProxy &p1 = m_allEntities[nA.leftFirst + i];
						const EntityProxy &p2 = m_allEntities[nA.leftFirst + j];

						if (p1.m_box.intersects(p2.m_box))
						{
							hitPairs.push_back(std::make_pair(p1.m_entityId, p2.m_entityId));
						}
					}
				}
			}
			else
			{
				// 同一个内部节点，拆分成三个子任务：
				// 1. 左子树内部自己和自己查
				CollideNodes(nA.leftFirst, nA.leftFirst, hitPairs);

				// 2. 右子树内部自己和自己查
				CollideNodes(nA.leftFirst + 1, nA.leftFirst + 1, hitPairs);

				// 3. 左子树 vs 右子树
				// 剪刀 2：只调一次！绝不调用 CollideNodes(右, 左)，彻底打破跨分支的对称性！
				CollideNodes(nA.leftFirst, nA.leftFirst + 1, hitPairs);
			}
		}
		// 情况 2：正在检查两个完全不同的节点 (nodeIdxA != nodeIdxB)
		else
		{
			if (nA.isLeaf() && nB.isLeaf())
			{
				// 两个都是叶子节点，进行二分图式的完全交叉比较
				for (int i = 0; i < nA.primitiveCount; ++i)
				{
					for (int j = 0; j < nB.primitiveCount; ++j)
					{
						const EntityProxy &p1 = m_allEntities[nA.leftFirst + i];
						const EntityProxy &p2 = m_allEntities[nB.leftFirst + j];

						if (p1.m_box.intersects(p2.m_box))
						{
							hitPairs.push_back(std::make_pair(p1.m_entityId, p2.m_entityId));
						}
					}
				}
			}
			else if (nA.isLeaf())
			{
				// A 是叶子，B 是内部节点，所以我们把 B 拆开，继续用 A 去和 B 的子节点比
				CollideNodes(nodeIdxA, nB.leftFirst, hitPairs);
				CollideNodes(nodeIdxA, nB.leftFirst + 1, hitPairs);
			}
			else if (nB.isLeaf())
			{
				// B 是叶子，A 是内部节点，拆分 A
				CollideNodes(nA.leftFirst, nodeIdxB, hitPairs);
				CollideNodes(nA.leftFirst + 1, nodeIdxB, hitPairs);
			}
			else
			{
				// A 和 B 都是内部节点，为了最快缩小包围盒范围，理论上应该拆分包围盒表面积更大的那个。
				// 这里为了代码简洁，我们统一固定拆分 A 节点。
				CollideNodes(nA.leftFirst, nodeIdxB, hitPairs);
				CollideNodes(nA.leftFirst + 1, nodeIdxB, hitPairs);
			}
		}
	}

}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
extern void DeepFaceToSolid(AcDbBlockReference *pRef, AcDbVoidPtrArray &arGetSolidPtrs);
namespace
{
	bool collisionDetection(AcDb3dSolid *pSolidA, AcDb3dSolid *pSolidB, AcGePoint3d *pPtIns = NULL)
	{
		if (!pSolidA || !pSolidB) return false;

		// 1. 过滤自身的比较
		if (pSolidA == pSolidB) return false;

		AcDb3dSolid *pInterferenceSolid = NULL;
		Adesk::Boolean bIntersects = Adesk::kFalse;

		// 4. 调用底层的干涉检查 API
		// 这里的关键是将第二个参数设为 Adesk::kFalse，禁止它生成相交实体！
		Acad::ErrorStatus es = pSolidA->checkInterference( pSolidB
			, Adesk::kFalse
			, bIntersects
			, pInterferenceSolid );

		// 5. 防御性编程：清理内存
		// 即使我们传了 kFalse，如果由于某些不可预知的内核原因返回了一个实体指针，
		// 因为它是内存常驻（非数据库常驻）实体，如果不 delete 会造成严重的内存泄漏。
		if (pInterferenceSolid != NULL)
		{
			delete pInterferenceSolid;
			pInterferenceSolid = NULL;
		}

		// 6. 返回真实的碰撞结果
		if (es == Acad::eOk && bIntersects == Adesk::kTrue)
		{
			return true;
		}

		return false;
	}

	AcDb3dSolid *getOpeningSolid(AcDbEntity *pEnt)
	{
		AecDbXOpening *pOpen = AecDbXOpening::cast(pEnt);
		if (!pOpen) return NULL;

		OpeningData data;
		pOpen->GetOpeningData(data);
		pOpen->GetAt(KEY_BOMEL, data.ptPos.z);

		// 得到完整的长宽高，和插入位置，构建出一个solid
		
		AcDbObjectId idWall;
		idWall.setFromOldId(data.idWall);
		AcDbObjectPointer<AecDbXWall> wall(idWall, AcDb::kForRead);
		if (wall.openStatus() != Acad::eOk) return NULL;

		AcDbCurve *pCrv(wall->GetBaseCurve());
		if (!pCrv) return NULL;

		AcDb3dSolid *pSolid(NULL);

		do
		{
			AcGePoint3d ptOnCrv;
			if (pCrv->getClosestPointTo(data.ptPos, ptOnCrv) != Acad::eOk)
				break;

			// 墙体在插入点处的切线方向
			AcGeVector3d vtDir;
			if (pCrv->getFirstDeriv(ptOnCrv, vtDir) != Acad::eOk)
				break;
			vtDir.normalize();

			AcGeVector3d vtUp(vtDir);
			vtUp.rotateBy(PI * .5, AcGeVector3d::kZAxis);
			vtUp.normalize();

			/*
				vtDir ->->->

				pt0---------pt1
				 |   ptPos   |
				pt3---------pt2

			*/

			AcGePoint3d pt0, pt1, pt2, pt3;
			pt0 = data.ptPos - vtDir * data.dWidth * .5;
			pt0 += vtUp * data.dThick * .5;
			pt1 = pt0 + vtDir * data.dWidth;
			pt2 = pt1 - vtUp * data.dThick;
			pt3 = pt2 - vtDir * data.dWidth;

			AcDbVoidPtrArray ar;
			ar.append(new AcDbLine(pt0,pt1));
			ar.append(new AcDbLine(pt1,pt2));
			ar.append(new AcDbLine(pt2,pt3));
			ar.append(new AcDbLine(pt3,pt0));
			AcDbRegion *pReg = CoreTools::createRegion(ar); 
			deleteArrayVoidPtrs<AcDbLine>(ar);
			if (pReg)
			{
				AcDbSweepOptions op;
				pSolid = new AcDb3dSolid();
				if (pSolid->createExtrudedSolid(pReg, AcGeVector3d::kZAxis * data.dHeight, op) != Acad::eOk)
				{
					DELETE_PTR(pSolid);
				}
				DELETE_PTR(pReg);
			}
			
		} while (false);

		DELETE_PTR(pCrv);

		return pSolid;
	}

	void get3dSolidCacheFromEntity(AcDbEntity *pEnt, AcDbVoidPtrArray &ar_all, AcDbVoidPtrArray &ar_must_del)
	{
		if (!pEnt) return;

		const AcDbVoidPtrArray *pAr(NULL);
		AcDbVoidPtrArray _ar;

		AecDbEntityBase *pEntBase = AecDbEntityBase::cast(pEnt);
		if (pEntBase)
		{
			pAr = &pEntBase->Get3DBuffer();

			// AecDbXOpening 实体比较特殊，是由AcDbBlockRefrence组成的，block里面由shell构成需要特殊处理
			AecDbXOpening *pOpen = AecDbXOpening::cast(pEnt);
			if (pOpen)
			{
				AcDb3dSolid *pSolid = getOpeningSolid(pEnt);
				if (pSolid)
				{
					_ar.append(pSolid);
					ar_must_del.append(pSolid);
				}
			}
			else
				_ar = *pAr;
		}

		AecDbCurveBase *pCrvBase = AecDbCurveBase::cast(pEnt);
		if (pCrvBase)
		{
			pAr = &pCrvBase->Get3DBuffer();
			_ar = *pAr;
		}

		for (int i(0); i < _ar.length(); ++i)
		{
			AcDb3dSolid *pSolid = AcDb3dSolid::cast((AcDbEntity*)_ar[i]);
			if (pSolid)
			ar_all.append(pSolid);
		}

		return;
	}

	bool isAecMInterfaces(AcDbObjectId &id)
	{
		return UIMenuItem::isAecMInterfaces(id);
	}

	bool isOpening(AcDbObjectId &id)
	{
		return CDA::isSameOf<AecDbXOpening>(id);
	}

	bool isWall(AcDbObjectId &id)
	{
		return CDA::isSameOf<AecDbXWall>(id);
	}

	bool isEqu(AcDbObjectId &id)
	{
		if (CDA::isSameOf<AecDbEwEquipment>(id) || CDA::isSameOf<AecDbXEquipment>(id))
			return true;
		return false;
	}

	bool isPipeValve(AcDbObjectId &id)
	{
		if (id.objectClass() != AecDbEwEquipment::desc())
			return false;

		AcDbObjectPointer<AecDbEwEquipment> ent(id, AcDb::kForRead);
		if (ent.openStatus() != Acad::eOk)
			return false;

		int subRuntime(0), valveType(0);
		ent->GetAt(KEY_SUBRUNTIME, subRuntime);

		if (subRuntime != eValve)
			return false;
		if (!ent->GetAt(PIPE_VALVE, valveType))
			return false;

		return true;

	}

	bool isEquButNoValve(AcDbObjectId &id)
	{
		return isEqu(id) && !isPipeValve(id);
	}

	bool isEnvelope(AcDbObjectId &id)
	{
		CEntityProperty::EEntityType et(CEntityProperty::getTypeOfEntity(id));
		return et == CEntityProperty::eArchitecture
			|| et == CEntityProperty::eStructure
			|| et == CEntityProperty::eGuardBar
			|| et == CEntityProperty::eHanger
			|| et == CEntityProperty::eStair;
	}

	bool isHanger(AcDbObjectId &id)
	{
		CEntityProperty::EEntityType et(CEntityProperty::getTypeOfEntity(id));
		return et == CEntityProperty::eHanger;
	}

	bool isHole(AcDbObjectId &id)
	{
		return CEntityProperty::isHole(id);
	}

	bool isJSJ(AcDbObjectId &id)
	{
		return CEntityProperty::isJSJ(id);
	}

	bool isPipe(AcDbObjectId &id)
	{
		CEntityProperty::EEntityType et(CEntityProperty::getTypeOfEntity(id));
		return et == CEntityProperty::eCabtry
			|| et == CEntityProperty::eCabtryFitting
			|| et == CEntityProperty::eCable
			|| et == CEntityProperty::eHVACFitting
			|| et == CEntityProperty::eHVAC
			|| et == CEntityProperty::ePipeFitting
			|| et == CEntityProperty::ePipe ;
	}

	// 门窗和墙体需要碰撞检测吗？
	bool needCD_WallAndOpening(AcDbObjectId &id1, AcDbObjectId &id2)
	{
		AcDbObjectPointer<AecDbXOpening> opening(id1, AcDb::kForRead);

		AcDbObjectId idWall;
		if (opening.open(id1, AcDb::kForRead) != Acad::eOk)
		{
			opening.open(id2, AcDb::kForRead);
			idWall = id1;
		}
		else
		{
			idWall = id2;
		}

		if (opening.openStatus() != Acad::eOk) return true;

		OpeningData data;
		::memset(&data, 0, sizeof(OpeningData));
		if (!opening->GetOpeningData(data)) return true;

		AcDbObjectId idOpenWall;
		idOpenWall.setFromOldId(data.idWall);

		// 是墙上的门窗,不需要比较,不碰撞
		if (idWall == idOpenWall)
			return false;

		return true;
	}

	// 两个有管嘴的实体需要碰撞吗？
	bool needCD_2Interface(AcDbObjectId &id1, AcDbObjectId &id2)
	{
		AcDbEntityPointer ent1(id1, AcDb::kForRead);
		AcDbEntityPointer ent2(id2, AcDb::kForRead);
		if (ent1.openStatus() != Acad::eOk || ent2.openStatus() != Acad::eOk) return true;

		AecMInterfaces *pInf1 = dynamic_cast<AecMInterfaces *>(ent1.object());
		AecMInterfaces *pInf2 = dynamic_cast<AecMInterfaces *>(ent2.object());

		if (!pInf1 || !pInf2) return true;
		
		AcArray<AecInterface> arInfs1, arInfs2;
		pInf1->GetInterface(arInfs1);
		pInf2->GetInterface(arInfs2);

		AecInterface inf1, inf2;
		for (int i(0); i < arInfs1.length(); ++i)
		{
			inf1 = arInfs1[i];
			for (int j(0); j < arInfs2.length(); ++j)
			{
				inf2 = arInfs2[j];
				// 不能严格判断距离,小于10就算连上
				if (inf1.ptPos.distanceTo(inf2.ptPos) < 10)
					return false;
			}
		}
		return true;
	}

	// 如果两个个实体不需要检测，返回false，需要则返回true
	bool needCD(AcDbObjectId &id1, AcDbObjectId &id2)
	{
		// 如果有一个实体是洞口，不需要碰撞检测
		if (isHole(id1) || isHole(id2)) return false;

		// 管线和支架不需要碰撞
		if ((isPipe(id1) && isHanger(id2))
			|| (isPipe(id2) && isHanger(id1))) return false;

		// 设备和支架不需要碰撞
		if ((isEqu(id1) && isHanger(id2))
			|| (isEqu(id2) && isHanger(id1))) return false;

		// 构筑物之间，不需要碰撞检测
		if (isEnvelope(id1) && isEnvelope(id2) ) return false;

		// 墙和窗体，判断两个实体的的连接关系，如果存在连接关系，不需要碰撞检测
		if ((isWall(id1) && isOpening(id2))
			|| (isWall(id2) && isOpening(id1)))
			return needCD_WallAndOpening(id1, id2);

		// 由于板和设备都有接口,所以,放到接口的判断之前判断
		// 板实体上经常会有非阀门的设备，如果是这样不应该碰撞检测
		if ((CDA::isSameOf<AecDbXSlab>(id1) && isEquButNoValve(id2))
			|| (CDA::isSameOf<AecDbXSlab>(id2) && isEquButNoValve(id1)))
			return false;

		// 有接口的两个实体，判断是否有接口相连，如果有，不需要碰撞检测
		if (isAecMInterfaces(id1) && isAecMInterfaces(id2))
			return needCD_2Interface(id1, id2);


		// 板实体上的集水井不需要碰撞
		if ( (isJSJ(id1) && CDA::isSameOf<AecDbXSlab>(id2))
			|| (isJSJ(id2) && CDA::isSameOf<AecDbXSlab>(id1)))
			return false;

		return true;
	}

	bool collisionDetection(AcDbObjectId &id1, AcDbObjectId &id2)
	{
		if (!needCD(id1, id2)) return false;

		using namespace CDA;
		// 1. 在整个检测期间，将两个实体保持打开状态，防止其内部数据变为野指针！
		AcDbEntityPointer pEnt1(id1, AcDb::kForRead);
		if (pEnt1.openStatus() != Acad::eOk) return false;

		AcDbEntityPointer pEnt2(id2, AcDb::kForRead);
		if (pEnt2.openStatus() != Acad::eOk) return false;

		// 2. 获取缓存数组
		AcDbVoidPtrArray ar1, ar2, ar_must_del;
		get3dSolidCacheFromEntity(pEnt1.object(), ar1, ar_must_del);
		get3dSolidCacheFromEntity(pEnt2.object(), ar2, ar_must_del);

		if (ar1.isEmpty() || ar2.isEmpty()) return false;

		// 比较两个实体的原则，是只要它们的任意一个子组件发生碰撞，我们就认为它们发生了碰撞。
		// 只比较子组件中是AcDb3dSolid的部分，其他类型的子组件（如曲面、线框等）不参与碰撞检测。


		// 遍历 A 里面的每一个小组件
		AcDbExtents ext1, ext2;
		AABB ab1, ab2;
		AcDb3dSolid *pSolid1(NULL), *pSolid2(NULL);
		for (int i = 0; i < ar1.length(); ++i)
		{
			// 只比较3dSolid
			pSolid1 = AcDb3dSolid::cast((AcDbEntity *)ar1[i]);
			if (!pSolid1) continue;

			// 获取 A 子组件的 AABB
			if (pSolid1->getGeomExtents(ext1) != Acad::eOk) continue;
			ab1.set(ext1);

			// 遍历 B 里面的每一个小组件
			for (int j = 0; j < ar2.length(); ++j)
			{
				pSolid2 = AcDb3dSolid::cast((AcDbEntity *)ar2[j]);
				if (!pSolid2) continue;

				// 获取 B 子组件的 AABB
				if (pSolid2->getGeomExtents(ext2) != Acad::eOk) continue;
				ab2.set(ext2);

				// 微观粗筛：用 C++98 风格判断两个子 Extents 是否重叠
				if (!ab1.intersects(ab2))
					continue; // 子包围盒不碰，直接跳过底层几何计算！

				if (collisionDetection(pSolid1, pSolid2))
				{
					deleteArrayVoidPtrs<AcDbEntity>(ar_must_del);
					return true;
				}
			}
		}

		deleteArrayVoidPtrs<AcDbEntity>(ar_must_del);

		return false;
	}
}

namespace
{
	void clearOldCDFlag()
	{
		ads_name ss, ent;
		struct resbuf *pRb = acutBuildList(RTDXF0, _T("3DSOLID"), 0);
		int nRes;
		nRes = acedSSGet(_T("A"), NULL, NULL, pRb, ss);
		acutRelRb(pRb);
		if (nRes != RTNORM) return;

		Adesk::Int32 lLen = 0L;
		acedSSLength(ss, &lLen);
		if (lLen == 0) return;

		AecDbObjXDataMap xData;

		AcDbObjectId id;
		for (long i = 0; i < lLen; i++)
		{
			acedSSName(ss, i, ent);
			acdbGetObjectId(id, ent);
			if (!id.isValid()) continue;
			if (xData.Read(id, CD_FLAG))
			{
				AcDbEntityPointer ent(id, AcDb::kForWrite);
				if (ent.openStatus() == Acad::eOk)
					ent->erase();
			}
		}
		acedSSFree(ss);
	}
}

CCollisionDetectionDlg *g_pDlg = NULL;

void pzjc(const bool &bSelect)
{
	clearOldCDFlag();
	using namespace CDA;
	ads_name ss, ent;
	struct resbuf* pRb = acutBuildList(RTDXF0, _T("AEC_*,INSERT"), 0);

	int nRes;
	if (!bSelect)
		nRes = acedSSGet(_T("A"), NULL, NULL, pRb, ss);
	else
		nRes = acedSSGet(NULL, NULL, NULL, pRb, ss);

	acutRelRb(pRb);
	if (nRes != RTNORM) return;

	Adesk::Int32 lLen = 0L;
	acedSSLength(ss, &lLen);
	if (lLen == 0) return;

	AcDbObjectIdArray arids;
	AcDbObjectId id;
	for (long i = 0; i < lLen; i++)
	{
		acedSSName(ss, i, ent);
		acdbGetObjectId(id, ent);
		if (!id.isValid()) continue;

		arids.append(id);
	}
	acedSSFree(ss);
	if (arids.isEmpty()) return;

	BVHTree bvh;
	bvh.Build(arids);

	// 1. 获取所有粗筛相交的实体对 (绝无重复！)
	std::vector< std::pair<AcDbObjectId, AcDbObjectId> > hitPairs, hitReals;
	bvh.GetAllIntersections(hitPairs);

	// 2. 逐对进行底层内核精细检查
	acedSetStatusBarProgressMeter(_T("正在处理实体，请稍候..."), 0, (int)hitPairs.size());
	for (size_t i = 0; i < hitPairs.size(); ++i)
	{
		if (acedUsrBrk() == 1)
        {
			if (AfxMessageBox(_T("用户按下了 ESC 键， 确定取消检查操作吗？"), MB_YESNO) == IDYES)
				break;
		}

		if (collisionDetection(hitPairs[i].first, hitPairs[i].second))
		{
			hitReals.push_back(hitPairs[i]);
		}
		acedSetStatusBarProgressMeterPos((int)i + 1);
	}

	acedRestoreStatusBar();

	acutPrintf(_T("\nnumber of cd:%d"), hitReals.size());

	if (hitReals.empty())
	{
		CString sMsg;
		sMsg.Format(_T("检查了%d个实体，未找到碰撞点。"), lLen);
		AfxMessageBox(sMsg);
		return;
	}

	{
		if (g_pDlg)
		{
			if (::IsWindow(g_pDlg->m_hWnd))
				g_pDlg->DestroyWindow();
			DELETE_PTR(g_pDlg);
		}
		else
		{
			g_pDlg = new CCollisionDetectionDlg(hitReals, acedGetAcadFrame());
			g_pDlg->Create(CCollisionDetectionDlg::IDD, acedGetAcadFrame());
			g_pDlg->CenterWindow();
			g_pDlg->ShowWindow(SW_SHOW);
		}
	}

}

void pzjca()
{
	pzjc(false);
}

void pzjcs()
{
	pzjc(true);
}

#pragma region CCollisionDetectionDlg

namespace
{
	static int CALLBACK CompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
	{
		typedef CCollisionDetectionDlg::DataContext DataContext;
		typedef CCollisionDetectionDlg::SortContext SortContext;

		XLISTCTRLDATA *pXData1 = reinterpret_cast<XLISTCTRLDATA*>(lParam1);
		XLISTCTRLDATA *pXData2 = reinterpret_cast<XLISTCTRLDATA*>(lParam2);
		if (!pXData1 || !pXData2) return 0;

		DataContext *pData1 = reinterpret_cast<DataContext*>(pXData1->dwItemData);
		DataContext *pData2 = reinterpret_cast<DataContext*>(pXData2->dwItemData);
		SortContext *pContext = reinterpret_cast<SortContext *>(lParamSort);

		if (!pData1 || !pData2 || !pContext) return 0;

		int nResult = 0;
		// 根据点击的列号，执行不同的比较逻辑
		switch (pContext->m_nColumn )
		{
		case 0:
			if (pData1->m_nIdx < pData2->m_nIdx)
				nResult = -1;
			else if (pData1->m_nIdx > pData2->m_nIdx)
				nResult = 1;
			else
				nResult = 0;
			break;
		case 1: 
			nResult = pData1->m_sName1.CompareNoCase(pData2->m_sName1);
			break;
		case 2: 
			nResult = pData1->m_sSys1.CompareNoCase(pData2->m_sSys1);
			break;
		case 3: 
			nResult = pData1->m_sName2.CompareNoCase(pData2->m_sName2);
			break;
		case 4: 
			nResult = pData1->m_sSys2.CompareNoCase(pData2->m_sSys2);
			break;
		default:
			break;
		}

		// 根据升降序状态返回最终结果
		return pContext->m_bAscending ? nResult : -nResult;
	}

	void GetCurrentDynamicView(AcDbViewTableRecord &viewRec)
	{
		struct resbuf rb;
		struct resbuf rbWcs, rbUcs;

		// 0 代表 WCS，1 代表 UCS
		rbWcs.restype = RTSHORT;
		rbWcs.resval.rint = 0;
		rbUcs.restype = RTSHORT;
		rbUcs.resval.rint = 1;

		// 1. 获取 VIEWMODE (包含透视、剪裁等布尔状态)
		if (acedGetVar(_T("VIEWMODE"), &rb) == RTNORM)
		{
			viewRec.setPerspectiveEnabled((rb.resval.rint & 1) != 0);
			viewRec.setFrontClipEnabled((rb.resval.rint & 2) != 0);
			viewRec.setBackClipEnabled((rb.resval.rint & 4) != 0);
			viewRec.setFrontClipAtEye((rb.resval.rint & 16) == 0);
		}

		ads_point ptTrans;

		// 2. 获取 VIEWDIR (视线方向，UCS矢量 -> WCS矢量)
		if (acedGetVar(_T("VIEWDIR"), &rb) == RTNORM)
		{
			// acedTrans 的第 4 个参数为 1，表示正在转换一个方向矢量(Vector)而不是坐标点
			acedTrans(rb.resval.rpoint, &rbUcs, &rbWcs, 1, ptTrans);
			viewRec.setViewDirection(AcGeVector3d(ptTrans[0], ptTrans[1], ptTrans[2]));
		}

		// 3. 获取 TARGET (目标中心点，UCS点 -> WCS点)
		if (acedGetVar(_T("TARGET"), &rb) == RTNORM)
		{
			// acedTrans 的第 4 个参数为 0，表示正在转换一个坐标点(Point)
			acedTrans(rb.resval.rpoint, &rbUcs, &rbWcs, 0, ptTrans);
			viewRec.setTarget(AcGePoint3d(ptTrans[0], ptTrans[1], ptTrans[2]));
		}

		// 4. 获取 VIEWTWIST (相机扭曲角度)
		if (acedGetVar(_T("VIEWTWIST"), &rb) == RTNORM)
		{
			viewRec.setViewTwist(rb.resval.rreal);
		}

		// 5. 获取 LENSLENGTH (镜头焦距)
		if (acedGetVar(_T("LENSLENGTH"), &rb) == RTNORM)
		{
			viewRec.setLensLength(rb.resval.rreal);
		}
	}

	// 主函数：将视图缩放至指定实体
	void ZoomToEntity(AcDbObjectId entId)
	{
		Acad::ErrorStatus es;
		AcDbEntity *pEnt = NULL;

		es = acdbOpenAcDbEntity(pEnt, entId, AcDb::kForRead);
		if (es != Acad::eOk)
		{
			acutPrintf(_T("\n无法打开实体."));
			return;
		}

		AcDbExtents extents;
		es = pEnt->getGeomExtents(extents);
		pEnt->close();

		if (es != Acad::eOk)
		{
			acutPrintf(_T("\n无法获取实体几何边界."));
			return;
		}

		AcGePoint3d ptMax(extents.maxPoint()), ptMin(extents.minPoint());
		// 构造 WCS 包围盒的 8 个顶点
		AcGePoint3d ptWcs[8];
		ptWcs[0] = ptMin;
		ptWcs[1] = AcGePoint3d(ptMin.x, ptMin.y, ptMax.z);
		ptWcs[2] = AcGePoint3d(ptMin.x, ptMax.y, ptMin.z);
		ptWcs[3] = AcGePoint3d(ptMin.x, ptMax.y, ptMax.z);
		ptWcs[4] = AcGePoint3d(ptMax.x, ptMin.y, ptMin.z);
		ptWcs[5] = AcGePoint3d(ptMax.x, ptMin.y, ptMax.z);
		ptWcs[6] = AcGePoint3d(ptMax.x, ptMax.y, ptMin.z);
		ptWcs[7] = ptMax;

		// WCS(0) 到 DCS(2) 转换，寻找真正的屏幕极值
		resbuf rbWcs, rbDcs;
		rbWcs.restype = RTSHORT;
		rbWcs.resval.rint = 0;
		rbDcs.restype = RTSHORT;
		rbDcs.resval.rint = 2;

		double minX = 1e20, minY = 1e20;
		double maxX = -1e20, maxY = -1e20;

		for (int i = 0; i < 8; ++i)
		{
			ads_point ptInWcs, ptInDcs;
			ptInWcs[0] = ptWcs[i].x;
			ptInWcs[1] = ptWcs[i].y;
			ptInWcs[2] = ptWcs[i].z;

			// 这里的 acedTrans 依旧会自动引用当前屏幕正在呈现的 DCS 矩阵
			acedTrans(ptInWcs, &rbWcs, &rbDcs, 0, ptInDcs);

			if (ptInDcs[0] < minX) minX = ptInDcs[0];
			if (ptInDcs[0] > maxX) maxX = ptInDcs[0];
			if (ptInDcs[1] < minY) minY = ptInDcs[1];
			if (ptInDcs[1] > maxY) maxY = ptInDcs[1];
		}

		double dWidth = fabs(maxX - minX) * 2.;
		double dHeight = fabs(maxY - minY) * 2.;
		AcGePoint2d centerPt(minX + (maxX - minX) * .5, minY + (maxY - minY) * .5);

		struct resbuf screenRb;
		acedGetVar(_T("SCREENSIZE"), &screenRb);
		if (screenRb.resval.rpoint[1] > 0.0)
		{
			double screenRatio = screenRb.resval.rpoint[0] / screenRb.resval.rpoint[1];
			if (dWidth > dHeight * screenRatio)
			{
				dHeight = dWidth / screenRatio;
				dWidth = dHeight * screenRatio;
			}
		}

		// 核心修复：通过封装的系统变量函数，获取完整的动态三维环境
		AcDbViewTableRecord viewRec;
		GetCurrentDynamicView(viewRec);

		// 将计算出的 DCS 中心点与高度覆盖进去
		viewRec.setCenterPoint(centerPt);
		viewRec.setHeight(dHeight);
		viewRec.setWidth(dWidth);

		// 更新视图，彻底解决视角被拉回俯视图的问题
		acedSetCurrentView(&viewRec, NULL);
	}
}

extern UINT WM_XLISTCTRL_CHECKBOX_CLICKED;
extern UINT WM_XLISTCTRL_HEADER_MOUSE_CLICKED;

IMPLEMENT_DYNAMIC(CCollisionDetectionDlg, CDialog)

BEGIN_MESSAGE_MAP(CCollisionDetectionDlg, CDialog)
	ON_WM_SIZE()
	ON_WM_GETMINMAXINFO()
	ON_WM_CLOSE()
	ON_BN_CLICKED(IDOK, &CCollisionDetectionDlg::OnOK)
	ON_BN_CLICKED(IDC_BTN_REFRESH, &CCollisionDetectionDlg::OnRefreshBtnClicked)
	ON_REGISTERED_MESSAGE(WM_XLISTCTRL_CHECKBOX_CLICKED, &CCollisionDetectionDlg::OnCheckBoxClicked)
	ON_REGISTERED_MESSAGE(WM_XLISTCTRL_HEADER_MOUSE_CLICKED, &CCollisionDetectionDlg::OnHeaderMouseClicked)
	ON_NOTIFY(NM_DBLCLK, IDC_LIST, &CCollisionDetectionDlg::OnNMDblclkList)
END_MESSAGE_MAP()


CCollisionDetectionDlg::CCollisionDetectionDlg(IDPairs &pairs, CWnd *pParent)
	: m_szMinDlgSize(800, 600)
	, m_idPairs(pairs)
	, m_nSortCol(-1)
	, m_bAscending(true)
{
	m_CdFlags.resize(pairs.size());
	for (size_t i(0); i < m_CdFlags.size(); ++i)
		m_CdFlags[i] = AcDbObjectId::kNull;
}

CCollisionDetectionDlg::~CCollisionDetectionDlg()
{
	clearDatas();
}

void CCollisionDetectionDlg::DoDataExchange(CDataExchange *pDX)
{
	CDialog::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_LIST, m_wndList);
}

BOOL CCollisionDetectionDlg::OnInitDialog()
{
	CDialog::OnInitDialog();
	initColumns();
	layoutControls(0, 0);
	refreshList();
	return 0;
}

void CCollisionDetectionDlg::refreshList()
{
	m_wndList.DeleteAllItems();

	const AecDbObjXDataMap *pXData1(NULL), *pXData2(NULL);
	CString sName1, sName2, sSys1, sSys2;
	AcDbObjectId id1, id2;
	IDPairs::const_iterator it(m_idPairs.begin());
	for (int i(0); it != m_idPairs.end(); ++it, ++i)
	{
		id1 = it->first;
		id2 = it->second;
		sName1 = CEntityProperty::getNameOfEntity(id1);
		sName2 = CEntityProperty::getNameOfEntity(id2);

		sSys1 = _T("无");
		pXData1 = CEntityProperty::getXDataConst(id1);
		if (pXData1)
			pXData1->GetAt(PIPE_SYS, sSys1);

		sSys2 = _T("无");
		pXData2 = CEntityProperty::getXDataConst(id2);
		if (pXData2)
			pXData2->GetAt(PIPE_SYS, sSys2);

		m_wndList.InsertItem(i, TypeConvert::i2s(i + 1));
		m_wndList.SetItemText(i, 1, sName1);
		m_wndList.SetItemText(i, 2, sSys1);
		m_wndList.SetItemText(i, 3, sName2);
		m_wndList.SetItemText(i, 4, sSys2);
		m_wndList.SetCheckbox(i, 0, FALSE);
		m_wndList.SetItemData(i, (DWORD_PTR)(new DataContext(i, sName1, sSys1, sName2, sSys2)));
	}
}

void CCollisionDetectionDlg::initColumns()
{
	double dDpiScale = CoreTools::GetDPIScale();

	m_wndList.SetFont(GetFont());

	m_wndList.SetExtendedStyle(
		m_wndList.GetExtendedStyle()
		| LVS_EX_FULLROWSELECT
		| LVS_EX_GRIDLINES);

	// 第一列，选择列
	LV_COLUMN lvcolumn;
	::memset(&lvcolumn, 0, sizeof(lvcolumn));
	lvcolumn.mask = LVCF_FMT | LVCF_WIDTH | LVCF_TEXT | LVCF_SUBITEM;
	lvcolumn.fmt = LVCFMT_CENTER;

	int width(int(30 * dDpiScale));

	lvcolumn.pszText = const_cast<LPTSTR>(_T("序号"));
	lvcolumn.iSubItem = 0;
	lvcolumn.cx = width;
	m_wndList.InsertColumn(0, &lvcolumn);

	lvcolumn.pszText = const_cast<LPTSTR>(_T("实体类型1"));
	lvcolumn.iSubItem = 1;
	lvcolumn.cx = width;
	m_wndList.InsertColumn(1, &lvcolumn);

	lvcolumn.pszText = const_cast<LPTSTR>(_T("系统类型1"));
	lvcolumn.iSubItem = 2;
	lvcolumn.cx = width;
	m_wndList.InsertColumn(2, &lvcolumn);

	lvcolumn.pszText = const_cast<LPTSTR>(_T("实体类型2"));
	lvcolumn.iSubItem = 3;
	lvcolumn.cx = width;
	m_wndList.InsertColumn(3, &lvcolumn);

	lvcolumn.pszText = const_cast<LPTSTR>(_T("系统类型2"));
	lvcolumn.iSubItem = 4;
	lvcolumn.cx = width;
	m_wndList.InsertColumn(4, &lvcolumn);

	// 设置第一列为选择项
	if (m_wndList.m_HeaderCtrl.GetItemCount() > 0)
	{
		HDITEM hditem;
		hditem.mask = HDI_FORMAT | HDI_IMAGE;
		m_wndList.m_HeaderCtrl.GetItem(0, &hditem);
		hditem.fmt |= HDF_IMAGE;
		hditem.iImage = XHEADERCTRL_UNCHECKED_IMAGE;
		m_wndList.m_HeaderCtrl.SetItem(0, &hditem);
	}
}

void CCollisionDetectionDlg::layoutControls(const int &cx, const int &cy)
{
	if (!m_wndList.GetSafeHwnd()) return;

	double dDpiScale = CoreTools::GetDPIScale();

	CRect rcBtn(CPoint(0, 0), CSize(30, 90));
	CWnd *pOKBtn = GetDlgItem(IDOK);
	CWnd *pRefreshBtn = GetDlgItem(IDC_BTN_REFRESH);
	if (pOKBtn)
		pOKBtn->GetWindowRect(rcBtn);
	CSize szBtn = rcBtn.Size();

	CRect rcDlg;
	GetClientRect(rcDlg);

	int nSpace(int(5 * dDpiScale));

	// "确定"按钮 下边与dlg距离 nSpace
	rcBtn.bottom = rcDlg.bottom - nSpace;
	rcBtn.top = rcBtn.bottom - szBtn.cy;
	rcBtn.left = LONG((rcDlg.Width() - szBtn.cx) * .5);
	rcBtn.right = rcBtn.left + szBtn.cx;

	// m_wndList 上边、左边、右边与dlg距离 nSpace
	CRect rcList;
	rcList.left = rcDlg.left + nSpace;
	rcList.top = rcDlg.top + nSpace;
	rcList.right = rcDlg.right - nSpace;
	rcList.bottom = rcBtn.top - nSpace;

	if (pOKBtn)
		pOKBtn->MoveWindow(rcBtn);

	// pRefreshBtn bottom与pOKBtn相同, right与wndlist的right相同
	rcBtn.right = rcList.right;
	rcBtn.left = rcBtn.right - szBtn.cx;
	if (pRefreshBtn)
		pRefreshBtn->MoveWindow(rcBtn);

	m_wndList.MoveWindow(rcList);

	int col1 = int(80 * dDpiScale);
	m_wndList.GetClientRect(rcList);
	CSize sz = rcList.Size();
	sz.cx -= col1; // 第一列为序号
	sz.cx = LONG(sz.cx * .25);

	m_wndList.SetColumnWidth(0, col1);
	m_wndList.SetColumnWidth(1, (int)sz.cx);
	m_wndList.SetColumnWidth(2, (int)sz.cx);
	m_wndList.SetColumnWidth(3, (int)sz.cx);
	m_wndList.SetColumnWidth(4, LVSCW_AUTOSIZE_USEHEADER);

}

void CCollisionDetectionDlg::eraseFlag(AcDbObjectId &id)
{
	AcDbEntityPointer ent(id, AcDb::kForWrite);
	if (ent.openStatus() == Acad::eOk)
		ent->erase();
}

AcDbObjectId CCollisionDetectionDlg::createFlag(const AcDbObjectId & id1, const AcDbObjectId & id2)
{
	AcDbObjectId id(AcDbObjectId::kNull);

	if (!id1.isValid() || !id2.isValid()) return id;


	AcDbEntityPointer ent1(id1, AcDb::kForRead);
	AcDbEntityPointer ent2(id2, AcDb::kForRead);
	if (ent1.openStatus() != Acad::eOk || ent2.openStatus() != Acad::eOk) return id;

	AcDbVoidPtrArray ar1, ar2, ar_must_del;
	get3dSolidCacheFromEntity(ent1, ar1, ar_must_del);
	get3dSolidCacheFromEntity(ent2, ar2, ar_must_del);

	AcDb3dSolid *pInterferenceSolid = NULL;
	Adesk::Boolean bIntersects = Adesk::kFalse;
	double volume(.0);
	AcGePoint3d centroid(AcGePoint3d::kOrigin);
	double momInertia[3], prodInertia[3], prinMoments[3], radiiGyration[3];
	AcGeVector3d prinAxes[3];
	AcDbExtents extents;
	
	AecDbObjXDataMap xData;
	xData.SetAt(CD_FLAG, 1);

	bool bExit = false;
	for (int i1(0); i1 < ar1.length(); ++i1)
	{
		if (bExit) break;
		AcDb3dSolid *pSolid1 = AcDb3dSolid::cast((AcDbEntity *)(ar1)[i1]);
		if (!pSolid1) continue;

		for (int i2(0); i2 < ar2.length(); ++i2)
		{
			if (bExit) break;
			AcDb3dSolid *pSolid2 = AcDb3dSolid::cast((AcDbEntity *)(ar2)[i2]);
			if (!pSolid2) continue;

			bIntersects = Adesk::kFalse;

			Acad::ErrorStatus es = pSolid1->checkInterference(pSolid2
				, Adesk::kTrue
				, bIntersects
				, pInterferenceSolid);

			// 得到碰撞的中心点
			if (es == Acad::eOk && bIntersects == Adesk::kTrue && pInterferenceSolid)
			{
				centroid = (AcGePoint3d::kOrigin);
				es = pInterferenceSolid->getMassProp(volume
					, centroid
					, momInertia
					, prodInertia
					, prinMoments
					, prinAxes
					, radiiGyration
					, extents);

				DELETE_PTR(pInterferenceSolid);

				if (es == Acad::eOk)
				{
					AcDb3dSolid *pSolid = new AcDb3dSolid;
					if (pSolid->createSphere(extents.maxPoint().distanceTo(extents.minPoint()) * .5 * 1.5) == Acad::eOk)
					{
						AcGeMatrix3d mat;
						mat.setToTranslation(centroid.asVector());
						pSolid->transformBy(mat);
						pSolid->setColorIndex(1);

						// 做一下标记
						xData.Write(pSolid, _T("CD_FLAG"));

						CoreTools::AddToModelSpace(pSolid, NULL, true, &id);
						bExit = true;
					}
					else
						DELETE_PTR(pSolid);
				}
			}
		}
	}

	deleteArrayVoidPtrs<AcDbEntity>(ar_must_del);

	return id;
}

void CCollisionDetectionDlg::clearDatas()
{
	AcAxDocLock lock;
	for (size_t i(0); i < m_CdFlags.size(); ++i)
		eraseFlag(m_CdFlags[i]);

	for (int i(0); i < m_wndList.GetItemCount(); ++i)
	{
		DataContext *pData = (DataContext *)m_wndList.GetItemData(i);
		DELETE_PTR(pData);
	}
}

void CCollisionDetectionDlg::OnSize(UINT nType, int cx, int cy)
{
	CDialog::OnSize(nType, cx, cy);
	layoutControls(cx, cy);
}

void CCollisionDetectionDlg::OnGetMinMaxInfo(MINMAXINFO *lpMMI)
{
	CDialog::OnGetMinMaxInfo(lpMMI);
	// 只有当 m_minSize 有效（即 OnInitDialog 运行过）时才限制
	// 防止窗口创建初期 m_minSize 为 0 导致窗口无法显示
	if (m_szMinDlgSize.cx > 0 && m_szMinDlgSize.cy > 0)
	{
		// ptMinTrackSize 代表窗口允许的最小“追踪”尺寸 (拖拽时的尺寸)
		lpMMI->ptMinTrackSize.x = m_szMinDlgSize.cx; // 限制最小宽度
		lpMMI->ptMinTrackSize.y = m_szMinDlgSize.cy; // 限制最小高度
	}
}

LRESULT CCollisionDetectionDlg::OnCheckBoxClicked(WPARAM nItem, LPARAM nSubItem)
{
	if (nItem >= m_idPairs.size() || nItem < 0) return 0;
	if (nItem >= m_CdFlags.size() || nItem < 0) return 0;

	{
		AcAxDocLock lock;

		DataContext &ct = *(DataContext*)m_wndList.GetItemData((int)nItem);

		int idxFlag(ct.m_nIdx);

		// 得到两个碰撞的实体id
		AcDbObjectId id1(m_idPairs[idxFlag].first), id2(m_idPairs[idxFlag].second);

		// 碰撞标记id
		AcDbObjectId &idFlag = m_CdFlags[idxFlag];

		bool bCheck = m_wndList.GetItemCheckedState((int)nItem, (int)nSubItem) != 0 ? true : false;

		if (bCheck) // 需要显示碰撞标记
		{
			if (idFlag.isValid())
			{
				AcDbEntityPointer ent(idFlag, AcDb::kForRead);
				if (ent.openStatus() == Acad::eOk && ent->visibility() != AcDb::kVisible)
				{
					ent->upgradeOpen();
					ent->setVisibility(AcDb::kVisible);
					ent->downgradeOpen();
				}
			}
			else
			{	// 创建碰撞标记
				idFlag = createFlag(id1, id2);
			}
		}
		else	// 需要隐藏碰撞标记
		{
			// 不需要考虑idFlag无效的情况，因为如果无效说明之前没有创建过标记，自然也就不需要隐藏了
			AcDbEntityPointer ent(idFlag, AcDb::kForRead);
			if (ent.openStatus() == Acad::eOk && ent->visibility() == AcDb::kVisible)
			{
				ent->upgradeOpen();
				ent->setVisibility(AcDb::kInvisible);
				ent->downgradeOpen();
			}
		}
	}
	::SetFocus(adsw_acadDocWnd());
	CoreTools::refreshGraphics();
	return 0;
}

LRESULT CCollisionDetectionDlg::OnHeaderMouseClicked(WPARAM, LPARAM nSubItem)
{
	if (m_nSortCol == nSubItem)
	{
		m_bAscending = !m_bAscending;
	}
	else
	{
		m_nSortCol = (int)nSubItem;
		m_bAscending = true;
	}

	// 构建 排序信息
	SortContext sc;
	// 如果点了同一列，就切换排序顺序；如果点了不同列，默认升序
	sc.m_bAscending = m_bAscending;
	sc.m_nColumn = m_nSortCol;

	m_wndList.SortItems(CompareFunc, reinterpret_cast<DWORD_PTR>(&sc));

	CHeaderCtrl *pHeader = m_wndList.GetHeaderCtrl();
	if (!pHeader) return 0;

	for (int i = 0; i < pHeader->GetItemCount(); ++i)
	{
		HDITEM hditem;
		// 只需要获取和设置格式(Format)掩码
		hditem.mask = HDI_FORMAT;
		pHeader->GetItem(i, &hditem);

		// 核心位运算：先清除掉当前列可能存在的任何排序标志
		hditem.fmt &= ~(HDF_SORTUP | HDF_SORTDOWN);

		// 如果是当前正在排序的列，则追加对应的方向标志
		if (i == m_nSortCol)
		{
			if (m_bAscending)
			{
				hditem.fmt |= HDF_SORTUP;
			}
			else
			{
				hditem.fmt |= HDF_SORTDOWN;
			}
		}

		// 将修改后的格式写回表头
		pHeader->SetItem(i, &hditem);
	}

	return 0;
}

void CCollisionDetectionDlg::OnNMDblclkList(NMHDR *pNMHDR, LRESULT *pResult)
{
	LPNMITEMACTIVATE pNMItemActivate = reinterpret_cast<LPNMITEMACTIVATE>(pNMHDR);
    // 获取被双击的行号 (-1 表示没有选中项)
    int nIndex = pNMItemActivate->iItem;
    // 获取被双击的列号
    int nSubItem = pNMItemActivate->iSubItem;

	DataContext &ct = *(DataContext*)m_wndList.GetItemData(nIndex);

	int idxFlag(ct.m_nIdx);

	// 得到两个碰撞的实体id
	AcDbObjectId id1(m_idPairs[idxFlag].first), id2(m_idPairs[idxFlag].second);

	// 碰撞标记id
	AcDbObjectId &idFlag = m_CdFlags[idxFlag];

	AcAxDocLock lock;
	if (!idFlag.isValid())
	{
		idFlag = createFlag(id1, id2);
		AcDbEntityPointer ent(idFlag, AcDb::kForWrite);
		if (ent.openStatus() == Acad::eOk)
		{
			ent->setVisibility(AcDb::kInvisible);
			ent->close();
		}
	}

	ZoomToEntity(idFlag);
}

void CCollisionDetectionDlg::PostNcDestroy()
{
	CDialog::PostNcDestroy();

	DELETE_PTR(g_pDlg);

	// 清理图形
}

void CCollisionDetectionDlg::OnCancel()
{
	CDialog::OnCancel();
	DestroyWindow();
}

void CCollisionDetectionDlg::OnClose()
{
	CDialog::OnClose();
	DestroyWindow();
}

void CCollisionDetectionDlg::OnOK()
{
	CDialog::OnOK();
	DestroyWindow();
}

void CCollisionDetectionDlg::OnRefreshBtnClicked()
{
	if (m_idPairs.empty()) return;

	// 删除无效的flag球
	clearOldCDFlag();
	// 清空数据
	clearDatas();

	IDPairs prs;
	// 对列表内的结果重新碰撞验证
	for (size_t i(0); i < m_idPairs.size(); ++i)
	{
		if (collisionDetection(m_idPairs[i].first, m_idPairs[i].second))
		{
			prs.push_back(m_idPairs[i]);
		}
	}

	m_idPairs = prs;

	m_CdFlags.resize(m_idPairs.size());
	for (size_t i(0); i < m_CdFlags.size(); ++i)
		m_CdFlags[i] = AcDbObjectId::kNull;

	refreshList();
}

#pragma endregion