|
|
#pragma once
|
|
|
|
|
|
#include "SpatialIndex.h"
|
|
|
#include "DrawOperator/Xy.h"
|
|
|
#include "GeometryUtils.h"
|
|
|
|
|
|
namespace Geometry
|
|
|
{
|
|
|
|
|
|
/**
|
|
|
* \brief 吸附配置参数
|
|
|
* 用于控制吸附的灵敏度和判定范围
|
|
|
*/
|
|
|
struct SnapConfig
|
|
|
{
|
|
|
double searchRadius = 0.0; // [粗筛] 空间索引搜索半径 (通常比 snapDistance 大一点，用于获取候选集)
|
|
|
double angleTolerance = 0.0; // [角度] 平行判定容差，单位：度 (Degrees)。例如 5.0 表示 ±5 度以内视为平行
|
|
|
double snapDistance = 0.0; // [阈值] 最小吸附距离阈值 (真实坐标单位)。小于此距离才会触发吸附
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* \brief 吸附类型枚举
|
|
|
*/
|
|
|
enum class SnapType
|
|
|
{
|
|
|
NONE, // 未吸附
|
|
|
POINT, // 吸附到某个特定点 (端点、中点等)
|
|
|
PARALLEL_LINE, // 吸附到某条平行线段 (实现共线)
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* \brief 吸附结果描述结构
|
|
|
* 包含吸附后的位置信息、偏移量以及被吸附的目标信息
|
|
|
*/
|
|
|
struct SnapResult
|
|
|
{
|
|
|
SnapType snapType = SnapType::NONE; // 吸附类型
|
|
|
double distanceSq = 0.0; // 原始距离的平方（用于多候选时的优先级比对）
|
|
|
POSITION sourceElement = nullptr; // 被吸附的目标图元 (Source Object)
|
|
|
Point offset = { 0.0, 0.0 }; // [核心数据] 修正偏移向量。InputPoint + Offset = SnappedPoint
|
|
|
Segment snappedSegment; // 吸附后的新线段 (预览用，已应用 offset)
|
|
|
Point snappedReferencePoint; // 视觉参考点 (例如：吸附到了哪个端点，或者吸附到了目标线的哪个投影点)
|
|
|
Segment targetSegment; // [平行吸附专用] 记录目标线段的几何信息，用于后续的投影计算
|
|
|
};
|
|
|
|
|
|
/**
|
|
|
* \brief 线段吸附引擎
|
|
|
* 核心职责：
|
|
|
* 给定一条输入线段 (Input Segment)，在空间索引中寻找最近的、符合条件的几何特征 (点或平行线)。
|
|
|
* 计算出将输入线段“移动”到目标特征所需的最小偏移量。
|
|
|
*/
|
|
|
class SnappingEngine
|
|
|
{
|
|
|
public:
|
|
|
/**
|
|
|
* \brief 构造函数
|
|
|
* \param pXy 图元容器指针
|
|
|
* \param index 空间索引 (QuadTree/R-Tree)
|
|
|
* \param config 吸附参数配置
|
|
|
* \param ignoreSet 忽略列表 (通常包含当前正在被拖动的图元自身，防止吸附自己)
|
|
|
*/
|
|
|
SnappingEngine(CXy* pXy, const CSpatialIndex& index, const SnapConfig& config, std::set<void*> ignoreSet = {})
|
|
|
: m_pXy(pXy), m_index(index), m_config(config), m_ingoreSet(ignoreSet)
|
|
|
{
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* \brief 计算最佳吸附结果
|
|
|
* * 流程：
|
|
|
* 1. AABB 查询：获取线段周围的候选图元。
|
|
|
* 2. 竞标机制：遍历所有候选图元，分别计算“点吸附”和“平行线吸附”。
|
|
|
* 3. 优胜劣汰：保留距离最近的点吸附结果和线吸附结果。
|
|
|
* 4. 最终决策：比较最佳点吸附和最佳线吸附，返回距离更近的那个。
|
|
|
* \param inputSegment 当前鼠标拖动产生的临时线段
|
|
|
* \return SnapResult 最佳吸附结果，如果没有合适目标则返回 SnapType::NONE
|
|
|
*/
|
|
|
SnapResult getSnapResult(const Segment& inputSegment)
|
|
|
{
|
|
|
// Step 1: 获取搜索区域 (线段 AABB 向外扩充吸附距离)
|
|
|
CRect8 area = getLineSegmentAABB(inputSegment, m_config.snapDistance);
|
|
|
|
|
|
// Step 2: 空间索引查询
|
|
|
std::vector<POSITION> positions = m_index.FindElementsInRect(area);
|
|
|
|
|
|
SnapResult bestPointSnap;
|
|
|
SnapResult bestLineSnap;
|
|
|
|
|
|
// Step 3: 遍历候选集进行详细几何计算
|
|
|
for (POSITION pos : positions)
|
|
|
{
|
|
|
SnapResult pResult = calcPointSnap(inputSegment, pos);
|
|
|
if (isBetter(pResult, bestPointSnap))
|
|
|
{
|
|
|
bestPointSnap = pResult;
|
|
|
}
|
|
|
|
|
|
SnapResult lResultl = calcParallelSnap(inputSegment, pos);
|
|
|
if (isBetter(lResultl, bestLineSnap))
|
|
|
{
|
|
|
bestLineSnap = lResultl;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Step 4: 决出最终赢家 (Point vs Line)
|
|
|
SnapResult finalResult = decideWinner(bestPointSnap, bestLineSnap);
|
|
|
|
|
|
// Step 5: 阈值截断 (如果最近的距离依然超过了 snapDistance，则放弃
|
|
|
if (finalResult.distanceSq <= m_config.snapDistance)
|
|
|
{
|
|
|
return finalResult;
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
return noneResult();
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
CRect8 getLineSegmentAABB(const Segment& segment, double width) const
|
|
|
{
|
|
|
double halfWidth = width / 2.0;
|
|
|
double rawMinX = min(segment.start.x, segment.end.x);
|
|
|
double rawMaxX = max(segment.start.x, segment.end.x);
|
|
|
double rawMinY = min(segment.start.y, segment.end.y);
|
|
|
double rawMaxY = max(segment.start.y, segment.end.y);
|
|
|
|
|
|
return CRect8(rawMinX - halfWidth, rawMaxY + halfWidth, rawMaxX + halfWidth, rawMinY - halfWidth);
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* \brief 计算点吸附 (Point Snap)
|
|
|
* * 逻辑：
|
|
|
* 1. 提取目标图元的所有关键点 (端点、节点)。
|
|
|
* 2. 计算这些点到 inputSegment 所在直线的投影位置。
|
|
|
* 3. 约束检查：投影点必须落在 inputSegment 线段内部 (t ∈ [0, 1])。
|
|
|
* 原理：我们只希望线段的“侧面”去吸附别人的点，而不是无限延长线去吸附。
|
|
|
* 4. 记录最小距离。
|
|
|
*/
|
|
|
SnapResult calcPointSnap(const Segment& inputSegment, POSITION target) const
|
|
|
{
|
|
|
COne* pOne = m_pXy->GetAt(target);
|
|
|
if (!pOne)
|
|
|
{
|
|
|
return noneResult();
|
|
|
}
|
|
|
|
|
|
if (inIngoreSet(pOne->value))
|
|
|
{
|
|
|
return noneResult();
|
|
|
}
|
|
|
|
|
|
// 1. 收集目标几何体所有的关键点
|
|
|
std::vector<Point> candidatePoints;
|
|
|
int pOneType = pOne->GetType();
|
|
|
|
|
|
if (pOneType == DOUBLEFOX_POINT)
|
|
|
{
|
|
|
CPointNameEx* pPoint = pOne->GetValueSafe<CPointNameEx>();
|
|
|
candidatePoints.push_back({ pPoint->x0, pPoint->y0 });
|
|
|
}
|
|
|
else if (pOneType == DOUBLEFOX_CURVE)
|
|
|
{
|
|
|
CCurveEx* pCurve = pOne->GetValueSafe<CCurveEx>();
|
|
|
for (int i = 0; i < pCurve->num; i++)
|
|
|
{
|
|
|
candidatePoints.push_back({ pCurve->x[i], pCurve->y[i] });
|
|
|
}
|
|
|
}
|
|
|
|
|
|
SnapResult bestLocal = noneResult();
|
|
|
bestLocal.distanceSq = std::numeric_limits<double>::max();
|
|
|
double snapDistSqLimit = m_config.snapDistance * m_config.snapDistance;
|
|
|
|
|
|
// 2. 遍历所有候选点
|
|
|
for (const auto& targetPt : candidatePoints)
|
|
|
{
|
|
|
// 计算 目标点 在 输入线段 上的投影因子 t
|
|
|
// 公式: P_proj = Start + t * Dir
|
|
|
double t = GeometryUtils::getProjectionFactor(targetPt, inputSegment);
|
|
|
|
|
|
// [核心约束]: 只有当 t 在 [0, 1] 之间时，点才位于线段的“正侧方” (法线区域)
|
|
|
// 如果不加这个限制，线段的延长线也会吸附到远处的点，体验会很差
|
|
|
if (t >= 0.0 && t <= 1.0)
|
|
|
{
|
|
|
// 计算线段上的投影点坐标
|
|
|
Point dir = inputSegment.direction();
|
|
|
Point projPoint = inputSegment.start + (dir * t);
|
|
|
|
|
|
// 计算偏移向量：从 投影点 指向 目标点 (这就是线段需要移动的向量)
|
|
|
Point offset = targetPt - projPoint;
|
|
|
double currentDistSq = offset.lengthSq();
|
|
|
|
|
|
// 3. 距离判定与更新
|
|
|
if (currentDistSq <= snapDistSqLimit && currentDistSq < bestLocal.distanceSq)
|
|
|
{
|
|
|
bestLocal.snapType = SnapType::POINT;
|
|
|
bestLocal.sourceElement = target;
|
|
|
bestLocal.distanceSq = currentDistSq;
|
|
|
|
|
|
// 填充结果
|
|
|
bestLocal.offset = offset;
|
|
|
bestLocal.snappedReferencePoint = targetPt; // 吸附到了这个点
|
|
|
|
|
|
// 生成吸附后的新线段 (原线段平移 offset)
|
|
|
bestLocal.snappedSegment.start = inputSegment.start + offset;
|
|
|
bestLocal.snappedSegment.end = inputSegment.end + offset;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return bestLocal;
|
|
|
}
|
|
|
|
|
|
/**
|
|
|
* \brief 计算平行线吸附 (Parallel Line Snap)
|
|
|
* * 逻辑：
|
|
|
* 1. 遍历目标曲线的所有线段。
|
|
|
* 2. 平行检查：计算两向量夹角余弦值，判断是否在 angleTolerance 范围内。
|
|
|
* 3. 重叠检查：防止两条平行线虽然在同一直线上，但相距十万八千里（投影无交集）。
|
|
|
* 4. 距离计算：计算 inputSegment 起点到 targetSegment 所在直线的垂直距离。
|
|
|
*/
|
|
|
SnapResult calcParallelSnap(const Segment& inputSegment, POSITION target) const
|
|
|
{
|
|
|
COne* pOne = m_pXy->GetAt(target);
|
|
|
// 只处理曲线/线段类型
|
|
|
if (!pOne || pOne->GetType() != DOUBLEFOX_CURVE)
|
|
|
{
|
|
|
return noneResult();
|
|
|
}
|
|
|
|
|
|
if (inIngoreSet(pOne->value))
|
|
|
{
|
|
|
return noneResult();
|
|
|
}
|
|
|
|
|
|
CCurveEx* pCurve = pOne->GetValueSafe<CCurveEx>();
|
|
|
|
|
|
SnapResult bestLocal = noneResult();
|
|
|
bestLocal.distanceSq = std::numeric_limits<double>::max();
|
|
|
double snapDistSqLimit = m_config.snapDistance * m_config.snapDistance;
|
|
|
|
|
|
// 遍历目标折线的所有线段
|
|
|
for (int i = 0; i < pCurve->num - 1; i++)
|
|
|
{
|
|
|
Segment targetSeg;
|
|
|
targetSeg.start = { pCurve->x[i], pCurve->y[i] };
|
|
|
targetSeg.end = { pCurve->x[i + 1], pCurve->y[i + 1] };
|
|
|
|
|
|
// 1. 判定是否接近平行 (角度容差)
|
|
|
if (GeometryUtils::isNearlyParallel(inputSegment, targetSeg, m_config.angleTolerance))
|
|
|
{
|
|
|
// 2. 判定是否在投影方向上重叠 (防止吸附到无限远处的延长线)
|
|
|
if (GeometryUtils::areSegmentsOverlapping(inputSegment, targetSeg))
|
|
|
{
|
|
|
// 3. 计算垂直距离和偏移向量
|
|
|
// 方法：将 inputSegment 的起点投影到 targetSeg 所在的直线上
|
|
|
|
|
|
double t = GeometryUtils::getProjectionFactor(inputSegment.start, targetSeg);
|
|
|
|
|
|
Point targetDir = targetSeg.direction();
|
|
|
Point projStart = targetSeg.start + (targetDir * t);
|
|
|
|
|
|
// 偏移向量 = 投影点 - 输入线段起点
|
|
|
Point offset = projStart - inputSegment.start;
|
|
|
double currentDistSq = offset.lengthSq();
|
|
|
|
|
|
if (currentDistSq <= snapDistSqLimit && currentDistSq < bestLocal.distanceSq)
|
|
|
{
|
|
|
bestLocal.snapType = SnapType::PARALLEL_LINE;
|
|
|
bestLocal.sourceElement = target;
|
|
|
bestLocal.distanceSq = currentDistSq;
|
|
|
|
|
|
// 填充结果
|
|
|
bestLocal.offset = offset;
|
|
|
bestLocal.snappedReferencePoint = projStart; // 视觉参考点
|
|
|
|
|
|
// 生成吸附后的新线段
|
|
|
bestLocal.snappedSegment.start = inputSegment.start + offset;
|
|
|
bestLocal.snappedSegment.end = inputSegment.end + offset;
|
|
|
|
|
|
bestLocal.targetSegment = targetSeg;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return bestLocal;
|
|
|
}
|
|
|
|
|
|
bool isBetter(const SnapResult& current, const SnapResult& target)
|
|
|
{
|
|
|
if (target.snapType == SnapType::NONE)
|
|
|
{
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
if (current.snapType != SnapType::NONE && current.snapType == target.snapType)
|
|
|
{
|
|
|
return current.distanceSq < target.distanceSq;
|
|
|
}
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
SnapResult decideWinner(const SnapResult& current, const SnapResult& target) const
|
|
|
{
|
|
|
if (current.snapType != SnapType::NONE && target.snapType != SnapType::NONE)
|
|
|
{
|
|
|
return current.distanceSq < target.distanceSq ? current : target;
|
|
|
}
|
|
|
|
|
|
return current.snapType == SnapType::NONE ? target : current;
|
|
|
}
|
|
|
|
|
|
SnapResult noneResult() const
|
|
|
{
|
|
|
SnapResult result;
|
|
|
result.sourceElement = nullptr;
|
|
|
result.snapType = SnapType::NONE;
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
double calcDistanceSq(double dx, double dy) const
|
|
|
{
|
|
|
return dx * dx + dy * dy;
|
|
|
}
|
|
|
|
|
|
bool inIngoreSet(void* pValue) const
|
|
|
{
|
|
|
return m_ingoreSet.find(pValue) != m_ingoreSet.end();
|
|
|
}
|
|
|
|
|
|
const CSpatialIndex& m_index;
|
|
|
SnapConfig m_config;
|
|
|
CXy* m_pXy = nullptr;
|
|
|
std::set<void*> m_ingoreSet; // 忽略列表，里面存储 COne Value 指针
|
|
|
};
|
|
|
|
|
|
}
|