|
|
#pragma once
|
|
|
|
|
|
#include "stdafx.h"
|
|
|
#include "ItemEraser.h"
|
|
|
#include "SigmaDoc.h"
|
|
|
#include "ActionListItem.h"
|
|
|
#include "ActionBackupItem.h"
|
|
|
#include "Util.h"
|
|
|
#include <clipper2/clipper.h>
|
|
|
|
|
|
enum class EraserMode
|
|
|
{
|
|
|
Normal,
|
|
|
Segments,
|
|
|
Nodes,
|
|
|
Relink,
|
|
|
};
|
|
|
|
|
|
class ICurveEraseStrategy
|
|
|
{
|
|
|
public:
|
|
|
virtual ~ICurveEraseStrategy() = default;
|
|
|
|
|
|
virtual void SetContext(CXy* pXy, CPositionList* pPlDel, CPositionList* pPlAdd) = 0;
|
|
|
|
|
|
virtual void Erase(POSITION pos, const CCurveEx& cutter) = 0;
|
|
|
};
|
|
|
|
|
|
class RelinkEraseStrategy : public ICurveEraseStrategy
|
|
|
{
|
|
|
public:
|
|
|
void SetContext(CXy* pXy, CPositionList* pPlDel, CPositionList* pPlAdd) override
|
|
|
{
|
|
|
m_pXy = pXy;
|
|
|
m_plDel = pPlDel;
|
|
|
m_plAdd = pPlAdd;
|
|
|
}
|
|
|
|
|
|
// 由于这个操作实际上只需要两个点，我们这里要求传入的 cutter 只有两个点，而且这两个点要和被切割的线重合
|
|
|
void Erase(POSITION pos, const CCurveEx& cutter) override
|
|
|
{
|
|
|
|
|
|
COne* pOne = m_pXy->GetAt(pos);
|
|
|
CCurveEx* pCurve = pOne->GetValueSafe<CCurveEx>();
|
|
|
|
|
|
std::vector<int> idxs;
|
|
|
for (int32_t i = 0; i < pCurve->num; ++i)
|
|
|
{
|
|
|
if (IsPointInPolygon(pCurve->x[i], pCurve->y[i], cutter))
|
|
|
{
|
|
|
idxs.push_back(i);
|
|
|
if (idxs.size() == 2)
|
|
|
{
|
|
|
break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (idxs.size() >= 2)
|
|
|
{
|
|
|
SplitClosedPath(pCurve, pos, idxs[0], idxs[1]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
/**
|
|
|
* @brief 从一个闭合路径（环形）上切出两个顶点，将路径分成两段，
|
|
|
* 并且分别将这两段的两端连接起来，形成两个新的闭合路径。
|
|
|
*
|
|
|
* 举例：
|
|
|
* 原路径（闭合）：P0 → P1 → P2 → P3 → P4 → P5 → P6 → P0
|
|
|
* 切点：idx1 = 2 (P2), idx2 = 5 (P5)
|
|
|
*
|
|
|
* 结果：
|
|
|
* 段A：P2 → P3 → P4 → P5 → P2 （闭合）
|
|
|
* 段B：P5 → P6 → P0 → P1 → P2 → P5 （闭合）
|
|
|
*
|
|
|
* @param pCurve 原始闭合路径（顶点顺序表示环）
|
|
|
* @param pos pCurve 的 POSITION
|
|
|
* @param idx1 第一个切割点索引（必须在顶点上）
|
|
|
* @param idx2 第二个切割点索引（必须在顶点上）
|
|
|
* @return
|
|
|
*/
|
|
|
void SplitClosedPath(CCurveEx *pCurve, POSITION pos, int idx1, int idx2)
|
|
|
{
|
|
|
int n = pCurve->num;
|
|
|
if (idx1 == idx2 || n < 3)
|
|
|
{
|
|
|
throw std::runtime_error("Invalid cut positions");
|
|
|
}
|
|
|
|
|
|
if (idx1 > idx2)
|
|
|
{
|
|
|
std::swap(idx1, idx2);
|
|
|
}
|
|
|
|
|
|
// 段A: idx1 → idx2
|
|
|
std::vector<CPoint2D> partA;
|
|
|
for (int i = idx1; i <= idx2; ++i)
|
|
|
{
|
|
|
partA.push_back({ pCurve->x[i], pCurve->y[i] });
|
|
|
}
|
|
|
partA.push_back({ pCurve->x[idx1], pCurve->y[idx1] }); // 闭合
|
|
|
|
|
|
// 段B: idx2 → idx1（绕回）
|
|
|
std::vector<CPoint2D> partB;
|
|
|
for (int i = idx2; i < n; ++i)
|
|
|
{
|
|
|
partB.push_back({ pCurve->x[i], pCurve->y[i] });
|
|
|
}
|
|
|
for (int i = 0; i <= idx1; ++i)
|
|
|
{
|
|
|
partB.push_back({ pCurve->x[i], pCurve->y[i] });
|
|
|
}
|
|
|
partB.push_back({ pCurve->x[idx2], pCurve->y[idx2] }); // 闭合
|
|
|
|
|
|
m_plDel->AddTail(pos);
|
|
|
|
|
|
COne* pOne = m_pXy->GetAt(pos);
|
|
|
assert(pOne != nullptr);
|
|
|
|
|
|
AddCurve(pOne, MakeCurveEx(partA));
|
|
|
AddCurve(pOne, MakeCurveEx(partB));
|
|
|
}
|
|
|
|
|
|
std::unique_ptr<CCurveEx> MakeCurveEx(const std::vector<CPoint2D>& points)
|
|
|
{
|
|
|
auto pCurve = std::make_unique<CCurveEx>();
|
|
|
pCurve->Create(static_cast<int>(points.size()));
|
|
|
|
|
|
for (size_t i = 0; i < points.size(); i++)
|
|
|
{
|
|
|
pCurve->x[i] = points[i].x0;
|
|
|
pCurve->y[i] = points[i].y0;
|
|
|
}
|
|
|
|
|
|
pCurve->GetLocation();
|
|
|
|
|
|
return pCurve;
|
|
|
}
|
|
|
|
|
|
void AddCurve(COne* pOldOne, std::unique_ptr<CCurveEx> pCurve)
|
|
|
{
|
|
|
auto pNewOne = std::make_unique<COne>();
|
|
|
CLayer* pLayer = pOldOne->GetLayer();
|
|
|
pNewOne->SetLayer(pLayer);
|
|
|
pNewOne->SetValueSafe(pCurve.release());
|
|
|
pNewOne->CloneOtherParameter(*pOldOne);
|
|
|
POSITION newPos = m_pXy->AddTailOne(pNewOne.release());
|
|
|
m_plAdd->AddTail(newPos);
|
|
|
}
|
|
|
|
|
|
CXy* m_pXy = nullptr;
|
|
|
CPositionList* m_plDel = nullptr;
|
|
|
CPositionList* m_plAdd = nullptr;
|
|
|
};
|
|
|
|
|
|
class NormalEraseStrategy : public ICurveEraseStrategy
|
|
|
{
|
|
|
public:
|
|
|
void SetContext(CXy* pXy, CPositionList* pPlDel, CPositionList* pPlAdd) override
|
|
|
{
|
|
|
m_pXy = pXy;
|
|
|
m_plDel = pPlDel;
|
|
|
m_plAdd = pPlAdd;
|
|
|
}
|
|
|
|
|
|
void Erase(POSITION pos, const CCurveEx& cutter) override
|
|
|
{
|
|
|
const auto erasePolygon = CurveToPathD(cutter);
|
|
|
if (erasePolygon.size() < 3)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
CRect8 range(1e100, -1e100, -1e100, 1e100);
|
|
|
const_cast<CCurveEx&>(cutter).GetRange(range);
|
|
|
|
|
|
COne* pOne = m_pXy->GetAt(pos);
|
|
|
CCurveEx* pCurve = pOne->GetValueSafe<CCurveEx>();
|
|
|
if (!pCurve)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
CRect8 currRange(1e100, -1e100, -1e100, 1e100);
|
|
|
pCurve->GetRange(currRange);
|
|
|
|
|
|
if (!IsIntersecting(range, currRange))
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
auto sourcePath = CurveToPathD(*pCurve);
|
|
|
|
|
|
// 如果完全包含，则只需要将这条曲线直接删除
|
|
|
if (IsPathInsidePolygon(sourcePath, erasePolygon))
|
|
|
{
|
|
|
m_plDel->AddTail(pos);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
const Clipper2Lib::PathsD subject{ sourcePath };
|
|
|
const Clipper2Lib::PathsD clip{ erasePolygon };
|
|
|
|
|
|
Clipper2Lib::ClipperD clipper;
|
|
|
clipper.AddOpenSubject(subject);
|
|
|
clipper.AddClip(clip);
|
|
|
|
|
|
Clipper2Lib::PathsD closed_paths;
|
|
|
Clipper2Lib::PathsD open_paths;
|
|
|
clipper.Execute(Clipper2Lib::ClipType::Difference, Clipper2Lib::FillRule::NonZero, closed_paths, open_paths);
|
|
|
// FIXME: 我不知道能不能用这个判断是否进行了切割，先暂时这么处理
|
|
|
if (open_paths.empty())
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
m_plDel->AddTail(pos);
|
|
|
|
|
|
for (const auto& path : open_paths)
|
|
|
{
|
|
|
if (path.size() < 2) continue;
|
|
|
|
|
|
auto newCurve = std::make_unique<CCurveEx>();
|
|
|
newCurve->Create(static_cast<int>(path.size()));
|
|
|
|
|
|
for (size_t i = 0; i < path.size(); ++i)
|
|
|
{
|
|
|
newCurve->x[i] = path[i].x;
|
|
|
newCurve->y[i] = path[i].y;
|
|
|
}
|
|
|
|
|
|
newCurve->GetLocation();
|
|
|
|
|
|
POSITION newPos = m_pXy->AddElement(newCurve.release(), DOUBLEFOX_CURVE);
|
|
|
COne* pNewOne = m_pXy->GetAt(newPos);
|
|
|
|
|
|
pNewOne->SetLayer(pOne->GetLayer());
|
|
|
pNewOne->CloneOtherParameter(*pOne);
|
|
|
m_plAdd->AddTail(newPos);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
Clipper2Lib::PathD CurveToPathD(const CCurveEx& curve) const
|
|
|
{
|
|
|
Clipper2Lib::PathD path;
|
|
|
for (int32_t i = 0; i < curve.num; i++)
|
|
|
{
|
|
|
double x = curve.x[i];
|
|
|
double y = curve.y[i];
|
|
|
path.emplace_back(x, y);
|
|
|
}
|
|
|
return path;
|
|
|
}
|
|
|
|
|
|
bool IsPathInsidePolygon(const Clipper2Lib::PathD& path, const Clipper2Lib::PathD& polygon)
|
|
|
{
|
|
|
if (polygon.empty())
|
|
|
{
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
const auto& clip = polygon;
|
|
|
for (const auto& pt : path)
|
|
|
{
|
|
|
if (Clipper2Lib::PointInPolygon(pt, clip) != Clipper2Lib::PointInPolygonResult::IsInside)
|
|
|
{
|
|
|
return false; // 只要有一个点不在多边形内，就认为不完全包含
|
|
|
}
|
|
|
}
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
CXy* m_pXy = nullptr;
|
|
|
CPositionList* m_plDel = nullptr;
|
|
|
CPositionList* m_plAdd = nullptr;
|
|
|
};
|
|
|
|
|
|
class SegmentEraseStrategy : public ICurveEraseStrategy
|
|
|
{
|
|
|
public:
|
|
|
void SetContext(CXy* pXy, CPositionList* pPlDel, CPositionList* pPlAdd) override
|
|
|
{
|
|
|
m_pXy = pXy;
|
|
|
m_plDel = pPlDel;
|
|
|
m_plAdd = pPlAdd;
|
|
|
}
|
|
|
|
|
|
void Erase(POSITION pos, const CCurveEx& cutter) override
|
|
|
{
|
|
|
CRect8 range(1e100, -1e100, -1e100, 1e100);
|
|
|
const_cast<CCurveEx&>(cutter).GetRange(range);
|
|
|
|
|
|
COne* pOne = m_pXy->GetAt(pos);
|
|
|
CCurveEx* pCurve = pOne->GetValueSafe<CCurveEx>();
|
|
|
if (pCurve == nullptr)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
CRect8 currRange(1e100, -1e100, -1e100, 1e100);
|
|
|
pCurve->GetRange(currRange);
|
|
|
|
|
|
if (!IsIntersecting(range, currRange))
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
if (IsInRect(currRange, range))
|
|
|
{
|
|
|
m_plDel->AddTail(pos);
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
DoCut(pCurve, cutter, pos, pOne);
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
void DoCut(CCurveEx* pOriginCurve, const CCurveEx& cutter, POSITION pos, COne* pOne)
|
|
|
{
|
|
|
std::vector<int32_t> segmentsIntersection;
|
|
|
for (int32_t i = 0; i < pOriginCurve->num - 1; i++)
|
|
|
{
|
|
|
double p0_x = pOriginCurve->x[i], p0_y = pOriginCurve->y[i];
|
|
|
double p1_x = pOriginCurve->x[i + 1], p1_y = pOriginCurve->y[i + 1];
|
|
|
|
|
|
bool result = IsPointInPolygon(p0_x, p0_y, cutter) && IsPointInPolygon(p1_x, p1_y, cutter);
|
|
|
if (!result) result = IsIntersection(p0_x, p0_y, p1_x, p1_y, cutter);
|
|
|
|
|
|
segmentsIntersection.push_back(result ? 1 : 0);
|
|
|
}
|
|
|
|
|
|
if (NoneOf(segmentsIntersection, [](int32_t n) { return n == 1; }))
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
auto ranges = GetSplitIndexs(segmentsIntersection, 1);
|
|
|
|
|
|
for (const auto& vec : ranges)
|
|
|
{
|
|
|
auto newCurve = SliceCurve(*pOriginCurve, vec[0], *(vec.end() - 1) + 2);
|
|
|
POSITION newPos = m_pXy->AddElement(newCurve.release(), DOUBLEFOX_CURVE);
|
|
|
COne* pNewOne = m_pXy->GetAt(newPos);
|
|
|
pNewOne->SetLayer(pOne->GetLayer());
|
|
|
pNewOne->CloneOtherParameter(*pOne);
|
|
|
pNewOne->SetName(pOne->GetName());
|
|
|
m_plAdd->AddTail(newPos);
|
|
|
}
|
|
|
|
|
|
m_plDel->AddTail(pos);
|
|
|
}
|
|
|
|
|
|
std::unique_ptr<CCurveEx> SliceCurve(const CCurveEx& curve, int32_t startIndex, int32_t endIndex) const
|
|
|
{
|
|
|
auto newCurve = std::make_unique<CCurveEx>();
|
|
|
int32_t count = endIndex - startIndex;
|
|
|
newCurve->Create(count);
|
|
|
memcpy(newCurve->x, curve.x + startIndex, count * sizeof(double));
|
|
|
memcpy(newCurve->y, curve.y + startIndex, count * sizeof(double));
|
|
|
newCurve->GetLocation();
|
|
|
return newCurve;
|
|
|
}
|
|
|
|
|
|
bool IsIntersection(double x1, double y1, double x2, double y2, const CCurveEx& curve) const
|
|
|
{
|
|
|
for (int32_t i = 0; i < curve.num - 1; i++)
|
|
|
{
|
|
|
double x3 = curve.x[i], y3 = curve.y[i];
|
|
|
double x4 = curve.x[i + 1], y4 = curve.y[i + 1];
|
|
|
double ix = 0.0, iy = 0.0;
|
|
|
if (GetLineIntersection(x1, y1, x2, y2, x3, y3, x4, y4, ix, iy) > 0)
|
|
|
{
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
std::vector<std::vector<int32_t>> GetSplitIndexs(const std::vector<int32_t>& vec, int32_t sep)
|
|
|
{
|
|
|
std::vector<std::vector<int32_t>> result, curr;
|
|
|
std::vector<int32_t> temp;
|
|
|
for (size_t i = 0; i < vec.size(); i++)
|
|
|
{
|
|
|
if (vec[i] == sep)
|
|
|
{
|
|
|
if (!temp.empty()) { result.push_back(temp); temp.clear(); }
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
temp.push_back((int32_t)i);
|
|
|
}
|
|
|
}
|
|
|
if (!temp.empty())
|
|
|
{
|
|
|
result.push_back(temp);
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
CXy* m_pXy = nullptr;
|
|
|
CPositionList* m_plDel = nullptr;
|
|
|
CPositionList* m_plAdd = nullptr;
|
|
|
};
|
|
|
|
|
|
class NodeEraseStrategy : public ICurveEraseStrategy
|
|
|
{
|
|
|
public:
|
|
|
void SetContext(CXy* pXy, CPositionList* pPlDel, CPositionList* pPlAdd) override
|
|
|
{
|
|
|
m_pXy = pXy;
|
|
|
m_plDel = pPlDel;
|
|
|
m_plAdd = pPlAdd;
|
|
|
}
|
|
|
|
|
|
void Erase(POSITION pos, const CCurveEx& cutter) override
|
|
|
{
|
|
|
CRect8 range(1e100, -1e100, -1e100, 1e100);
|
|
|
const_cast<CCurveEx&>(cutter).GetRange(range);
|
|
|
|
|
|
COne* pOne = m_pXy->GetAt(pos);
|
|
|
CCurveEx* pCurve = pOne->GetValueSafe<CCurveEx>();
|
|
|
if (!pCurve)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
CRect8 currRange(1e100, -1e100, -1e100, 1e100);
|
|
|
pCurve->GetRange(currRange);
|
|
|
|
|
|
if (!IsIntersecting(range, currRange))
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
std::vector<int32_t> toRemove;
|
|
|
for (int32_t i = 0; i < pCurve->num; ++i)
|
|
|
{
|
|
|
if (IsPointInPolygon(pCurve->x[i], pCurve->y[i], cutter))
|
|
|
{
|
|
|
toRemove.push_back(i);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (toRemove.empty())
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
auto pNewCurve = std::make_unique<CCurveEx>(*pCurve);
|
|
|
for (auto it = toRemove.rbegin(); it != toRemove.rend(); ++it)
|
|
|
{
|
|
|
RemoveCurveIndex(*pNewCurve, *it);
|
|
|
}
|
|
|
|
|
|
m_plDel->AddTail(pos);
|
|
|
|
|
|
if (pNewCurve->num >= 2)
|
|
|
{
|
|
|
POSITION newPos = m_pXy->AddElement(pNewCurve.release(), DOUBLEFOX_CURVE);
|
|
|
COne* pNewOne = m_pXy->GetAt(newPos);
|
|
|
pNewOne->SetLayer(pOne->GetLayer());
|
|
|
pNewOne->CloneOtherParameter(*pOne);
|
|
|
m_plAdd->AddTail(newPos);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
private:
|
|
|
CXy* m_pXy = nullptr;
|
|
|
CPositionList* m_plDel = nullptr;
|
|
|
CPositionList* m_plAdd = nullptr;
|
|
|
};
|
|
|
|
|
|
class Eraser
|
|
|
{
|
|
|
public:
|
|
|
Eraser()
|
|
|
{
|
|
|
SetMode(EraserMode::Normal);
|
|
|
}
|
|
|
|
|
|
void SetXY(CXy* pXy)
|
|
|
{
|
|
|
m_pXy = pXy;
|
|
|
}
|
|
|
|
|
|
void Cut(const CCurveEx& curve)
|
|
|
{
|
|
|
m_plAdd.RemoveAll();
|
|
|
m_plDel.RemoveAll();
|
|
|
|
|
|
if (!m_pXy)
|
|
|
{
|
|
|
return;
|
|
|
}
|
|
|
|
|
|
CXyElementFilter filter;
|
|
|
filter.addType(DOUBLEFOX_CURVE);
|
|
|
|
|
|
CPositionList select;
|
|
|
m_pXy->GetElement(filter, select);
|
|
|
|
|
|
m_strategy->SetContext(m_pXy, &m_plDel, &m_plAdd);
|
|
|
|
|
|
for (POSITION pos : CListToStdVector(select))
|
|
|
{
|
|
|
m_strategy->Erase(pos, curve);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
void SetMode(EraserMode mode)
|
|
|
{
|
|
|
if (mode == EraserMode::Normal && dynamic_cast<NormalEraseStrategy*>(m_strategy.get()) == nullptr)
|
|
|
{
|
|
|
m_strategy = std::make_unique<NormalEraseStrategy>();
|
|
|
}
|
|
|
else if (mode == EraserMode::Nodes && dynamic_cast<NodeEraseStrategy*>(m_strategy.get()) == nullptr)
|
|
|
{
|
|
|
m_strategy = std::make_unique<NodeEraseStrategy>();
|
|
|
}
|
|
|
else if (mode == EraserMode::Segments && dynamic_cast<SegmentEraseStrategy*>(m_strategy.get()) == nullptr)
|
|
|
{
|
|
|
m_strategy = std::make_unique<SegmentEraseStrategy>();
|
|
|
}
|
|
|
else if (mode == EraserMode::Relink && dynamic_cast<RelinkEraseStrategy*>(m_strategy.get()) == nullptr)
|
|
|
{
|
|
|
m_strategy = std::make_unique<RelinkEraseStrategy>();
|
|
|
}
|
|
|
|
|
|
m_mode = mode;
|
|
|
}
|
|
|
|
|
|
EraserMode GetMode() const
|
|
|
{
|
|
|
return m_mode;
|
|
|
}
|
|
|
|
|
|
CPositionList m_plDel;
|
|
|
CPositionList m_plAdd;
|
|
|
|
|
|
private:
|
|
|
EraserMode m_mode;
|
|
|
CXy* m_pXy = nullptr;
|
|
|
std::unique_ptr<ICurveEraseStrategy> m_strategy;
|
|
|
};
|
|
|
|