|
|
#pragma once
|
|
|
|
|
|
#include "clipper2/clipper.h"
|
|
|
|
|
|
using namespace Clipper2Lib;
|
|
|
|
|
|
class PointInPolygonTester
|
|
|
{
|
|
|
private:
|
|
|
// 将 double 坐标转换为 int64_t（Clipper2 使用整数坐标）
|
|
|
Point64 toPoint64(double x, double y, double scale = 100.0) {
|
|
|
return Point64(
|
|
|
static_cast<int64_t>(x * scale),
|
|
|
static_cast<int64_t>(y * scale)
|
|
|
);
|
|
|
}
|
|
|
|
|
|
public:
|
|
|
BOOL isPointInCurvePath(double x, double y, Clipper2Lib::Path64& curvePath, int scale = 100);
|
|
|
// 方法1：判断单个点
|
|
|
void getPolygonPath(CCurve& curve, Clipper2Lib::Path64& curvePath, int scale = 100);
|
|
|
|
|
|
bool isPointInPolygon(double x, double y, const std::vector<std::pair<double, double>>& polygon);
|
|
|
|
|
|
// 方法2：判断点是否在多边形内或边界上
|
|
|
PointInPolygonResult detailedPointTest(double x, double y,
|
|
|
const std::vector<std::pair<double, double>>& polygon);
|
|
|
|
|
|
// 方法3：批量判断点
|
|
|
std::vector<bool> batchTestPoints(const std::vector<std::pair<double, double>>& points,
|
|
|
const std::vector<std::pair<double, double>>& polygon);
|
|
|
|
|
|
// 方法4：带孔的多边形判断
|
|
|
bool isPointInPolygonWithHoles(double x, double y,
|
|
|
const std::vector<std::pair<double, double>>& outerPolygon,
|
|
|
const std::vector<std::vector<std::pair<double, double>>>& holes);
|
|
|
|
|
|
// 方法5：使用 PolyTree 进行复杂判断
|
|
|
bool isPointInComplexPolygon(double x, double y, const Paths64& polygons);
|
|
|
//enum class PointInPolygonResult {
|
|
|
// Inside,
|
|
|
// Outside,
|
|
|
// OnBoundary
|
|
|
//};
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*一些网上ai生成的算法测试,不太好用*/
|
|
|
|
|
|
typedef struct _tPoint2D {
|
|
|
double x0, y0;
|
|
|
|
|
|
_tPoint2D() : x0(0), y0(0) {}
|
|
|
_tPoint2D(double x_, double y_) : x0(x_), y0(y_) {}
|
|
|
|
|
|
_tPoint2D operator+(const _tPoint2D& other) const {
|
|
|
return _tPoint2D(x0 + other.x0, y0 + other.y0);
|
|
|
}
|
|
|
|
|
|
_tPoint2D operator-(const _tPoint2D& other) const {
|
|
|
return _tPoint2D(x0 - other.x0, y0 - other.y0);
|
|
|
}
|
|
|
|
|
|
_tPoint2D operator*(double scalar) const {
|
|
|
return _tPoint2D(x0 * scalar, y0 * scalar);
|
|
|
}
|
|
|
|
|
|
double length() const {
|
|
|
return std::sqrt(x0 * x0 + y0 * y0);
|
|
|
}
|
|
|
|
|
|
_tPoint2D normalize() const {
|
|
|
double len = length();
|
|
|
if (len == 0) return _tPoint2D(0, 0);
|
|
|
return _tPoint2D(x0 / len, y0 / len);
|
|
|
}
|
|
|
|
|
|
// 为了方便输出
|
|
|
void print() const {
|
|
|
std::cout << "(" << x0 << ", " << y0 << ")";
|
|
|
}
|
|
|
} tPoint2D;
|
|
|
|
|
|
class ParallelPolylineGenerator //这个不好用
|
|
|
{
|
|
|
public:
|
|
|
// 连接类型枚举
|
|
|
enum class JoinType {
|
|
|
MITER, // 斜接连接
|
|
|
ROUND, // 圆角连接
|
|
|
BEVEL // 斜角连接（平头）
|
|
|
};
|
|
|
|
|
|
// 端点类型枚举
|
|
|
enum class EndType {
|
|
|
BUTT, // 平头端点
|
|
|
SQUARE, // 方形端点
|
|
|
ROUND // 圆角端点
|
|
|
};
|
|
|
|
|
|
private:
|
|
|
// 计算点到直线的垂直向量
|
|
|
tPoint2D perpendicularVector(const tPoint2D& p1, const tPoint2D& p2, double distance) {
|
|
|
tPoint2D dir = p2 - p1;
|
|
|
double len = dir.length();
|
|
|
if (len == 0) return tPoint2D(0, 0);
|
|
|
|
|
|
// 垂直向量（旋转90度）
|
|
|
tPoint2D perp = tPoint2D(-dir.y0, dir.x0);
|
|
|
perp = perp.normalize();
|
|
|
return perp * distance;
|
|
|
}
|
|
|
|
|
|
// 计算两条直线的交点
|
|
|
bool lineIntersection(const tPoint2D& p1, const tPoint2D& p2,
|
|
|
const tPoint2D& p3, const tPoint2D& p4,
|
|
|
tPoint2D& result) {
|
|
|
double denom = (p4.y0 - p3.y0) * (p2.x0 - p1.x0) - (p4.x0 - p3.x0) * (p2.y0 - p1.y0);
|
|
|
if (std::abs(denom) < 1e-10) return false;
|
|
|
|
|
|
double ua = ((p4.x0 - p3.x0) * (p1.y0 - p3.y0) - (p4.y0 - p3.y0) * (p1.x0 - p3.x0)) / denom;
|
|
|
|
|
|
result.x0 = p1.x0 + ua * (p2.x0 - p1.x0);
|
|
|
result.y0 = p1.y0 + ua * (p2.y0 - p1.y0);
|
|
|
return true;
|
|
|
}
|
|
|
|
|
|
// 计算向量夹角（0-180度）
|
|
|
double angleBetweenVectors(const tPoint2D& v1, const tPoint2D& v2) {
|
|
|
double dot = v1.x0 * v2.x0 + v1.y0 * v2.y0;
|
|
|
double len1 = v1.length();
|
|
|
double len2 = v2.length();
|
|
|
|
|
|
if (len1 == 0 || len2 == 0) return 0;
|
|
|
|
|
|
double cosAngle = dot / (len1 * len2);
|
|
|
cosAngle = max(-1.0, min(1.0, cosAngle));
|
|
|
return std::acos(cosAngle) * 180.0 / PI;
|
|
|
}
|
|
|
|
|
|
// 计算折线在顶点处的夹角
|
|
|
double calculateAngle(const tPoint2D& prev, const tPoint2D& curr, const tPoint2D& next) {
|
|
|
tPoint2D v1 = prev - curr;
|
|
|
tPoint2D v2 = next - curr;
|
|
|
return angleBetweenVectors(v1, v2);
|
|
|
}
|
|
|
|
|
|
// 生成圆弧点
|
|
|
std::vector<tPoint2D> generateArcPoints(const tPoint2D& center,
|
|
|
double radius,
|
|
|
double startAngle,
|
|
|
double endAngle,
|
|
|
int segments = 8) {
|
|
|
std::vector<tPoint2D> points;
|
|
|
|
|
|
// 确保角度递增
|
|
|
if (endAngle < startAngle) {
|
|
|
endAngle += 2 * PI;
|
|
|
}
|
|
|
|
|
|
double angleStep = (endAngle - startAngle) / segments;
|
|
|
|
|
|
for (int i = 1; i < segments; i++) {
|
|
|
double angle = startAngle + angleStep * i;
|
|
|
double x = center.x0 + std::cos(angle) * radius;
|
|
|
double y = center.y0 + std::sin(angle) * radius;
|
|
|
points.push_back(tPoint2D(x, y));
|
|
|
}
|
|
|
|
|
|
return points;
|
|
|
}
|
|
|
|
|
|
// 检查线段是否相交
|
|
|
bool segmentsIntersect(const tPoint2D& p1, const tPoint2D& p2,
|
|
|
const tPoint2D& p3, const tPoint2D& p4) {
|
|
|
auto orientation = [](const tPoint2D& p, const tPoint2D& q, const tPoint2D& r) -> double {
|
|
|
return (q.y0 - p.y0) * (r.x0 - q.x0) - (q.x0 - p.x0) * (r.y0 - q.y0);
|
|
|
};
|
|
|
|
|
|
auto onSegment = [](const tPoint2D& p, const tPoint2D& q, const tPoint2D& r) -> bool {
|
|
|
return q.x0 <= max(p.x0, r.x0) && q.x0 >= min(p.x0, r.x0) &&
|
|
|
q.y0 <= max(p.y0, r.y0) && q.y0 >= min(p.y0, r.y0);
|
|
|
};
|
|
|
|
|
|
double o1 = orientation(p1, p2, p3);
|
|
|
double o2 = orientation(p1, p2, p4);
|
|
|
double o3 = orientation(p3, p4, p1);
|
|
|
double o4 = orientation(p3, p4, p2);
|
|
|
|
|
|
// 一般情况
|
|
|
if (o1 * o2 < 0 && o3 * o4 < 0) return true;
|
|
|
|
|
|
// 特殊情况：共线
|
|
|
if (o1 == 0 && onSegment(p1, p3, p2)) return true;
|
|
|
if (o2 == 0 && onSegment(p1, p4, p2)) return true;
|
|
|
if (o3 == 0 && onSegment(p3, p1, p4)) return true;
|
|
|
if (o4 == 0 && onSegment(p3, p2, p4)) return true;
|
|
|
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 检查路径是否自相交
|
|
|
bool checkSelfIntersection(const std::vector<tPoint2D>& path) {
|
|
|
if (path.size() < 4) return false;
|
|
|
|
|
|
for (size_t i = 0; i < path.size() - 3; i++) {
|
|
|
for (size_t j = i + 2; j < path.size() - 1; j++) {
|
|
|
if (segmentsIntersect(path[i], path[i + 1], path[j], path[j + 1])) {
|
|
|
return true;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return false;
|
|
|
}
|
|
|
|
|
|
// 修复自相交
|
|
|
std::vector<tPoint2D> fixSelfIntersection(const std::vector<tPoint2D>& original,
|
|
|
const std::vector<tPoint2D>& parallel,
|
|
|
double distance,
|
|
|
JoinType joinType,
|
|
|
double miterLimit) {
|
|
|
std::vector<tPoint2D> fixedPath;
|
|
|
|
|
|
if (parallel.size() < 2) return parallel;
|
|
|
|
|
|
// 保留第一个点
|
|
|
fixedPath.push_back(parallel[0]);
|
|
|
|
|
|
// 重新计算连接点，对于锐角使用斜角连接
|
|
|
for (size_t i = 1; i < original.size() - 1; i++) {
|
|
|
tPoint2D prev = original[i - 1];
|
|
|
tPoint2D curr = original[i];
|
|
|
tPoint2D next = original[i + 1];
|
|
|
|
|
|
double angle = calculateAngle(prev, curr, next);
|
|
|
|
|
|
// 计算偏移点
|
|
|
tPoint2D offsetPrev = curr + perpendicularVector(curr, prev, -distance);
|
|
|
tPoint2D offsetNext = curr + perpendicularVector(curr, next, distance);
|
|
|
|
|
|
if (angle < 90.0) {
|
|
|
// 锐角：强制使用斜角连接
|
|
|
fixedPath.push_back(offsetPrev);
|
|
|
fixedPath.push_back(offsetNext);
|
|
|
}
|
|
|
else {
|
|
|
// 钝角或直角：根据连接类型处理
|
|
|
tPoint2D miterPoint;
|
|
|
if (lineIntersection(offsetPrev, offsetPrev + (prev - curr),
|
|
|
offsetNext, offsetNext + (next - curr),
|
|
|
miterPoint)) {
|
|
|
// 检查斜接长度
|
|
|
double miterLength = (miterPoint - curr).length();
|
|
|
double miterRatio = miterLength / std::abs(distance);
|
|
|
|
|
|
if (joinType == JoinType::MITER && miterRatio <= miterLimit) {
|
|
|
fixedPath.push_back(miterPoint);
|
|
|
}
|
|
|
else {
|
|
|
fixedPath.push_back(offsetPrev);
|
|
|
fixedPath.push_back(offsetNext);
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
fixedPath.push_back(offsetPrev);
|
|
|
fixedPath.push_back(offsetNext);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 添加最后一个点
|
|
|
fixedPath.push_back(parallel.back());
|
|
|
|
|
|
return fixedPath;
|
|
|
}
|
|
|
|
|
|
public:
|
|
|
// 生成平行折线的主函数
|
|
|
std::vector<tPoint2D> createParallelPolyline(const std::vector<tPoint2D>& original,
|
|
|
double distance,
|
|
|
JoinType joinType = JoinType::MITER,
|
|
|
EndType endType = EndType::BUTT,
|
|
|
double miterLimit = 2.0,
|
|
|
int roundSegments = 8) {
|
|
|
if (original.size() < 2) return {};
|
|
|
|
|
|
std::vector<tPoint2D> parallel;
|
|
|
size_t n = original.size();
|
|
|
|
|
|
// 1. 生成所有偏移点
|
|
|
std::vector<tPoint2D> offsetPoints(n);
|
|
|
|
|
|
// 第一个点
|
|
|
if (n > 1) {
|
|
|
tPoint2D dir = original[1] - original[0];
|
|
|
dir = dir.normalize();
|
|
|
tPoint2D perp = tPoint2D(-dir.y0, dir.x0);
|
|
|
offsetPoints[0] = original[0] + perp * distance;
|
|
|
}
|
|
|
|
|
|
// 中间点
|
|
|
for (size_t i = 1; i < n - 1; i++) {
|
|
|
tPoint2D prevDir = (original[i - 1] - original[i]).normalize();
|
|
|
tPoint2D nextDir = (original[i + 1] - original[i]).normalize();
|
|
|
|
|
|
tPoint2D perpPrev = tPoint2D(-prevDir.y0, prevDir.x0);
|
|
|
tPoint2D perpNext = tPoint2D(-nextDir.y0, nextDir.x0);
|
|
|
|
|
|
// 平均垂直向量
|
|
|
tPoint2D perpAvg = (perpPrev + perpNext).normalize();
|
|
|
offsetPoints[i] = original[i] + perpAvg * distance;
|
|
|
}
|
|
|
|
|
|
// 最后一个点
|
|
|
if (n > 1) {
|
|
|
tPoint2D dir = original[n - 1] - original[n - 2];
|
|
|
dir = dir.normalize();
|
|
|
tPoint2D perp = tPoint2D(-dir.y0, dir.x0);
|
|
|
offsetPoints[n - 1] = original[n - 1] + perp * distance;
|
|
|
}
|
|
|
|
|
|
// 2. 处理端点
|
|
|
if (endType == EndType::BUTT) {
|
|
|
parallel.push_back(offsetPoints[0]);
|
|
|
}
|
|
|
else if (endType == EndType::SQUARE) {
|
|
|
// 方形端点：延长半个距离
|
|
|
if (n > 1) {
|
|
|
tPoint2D dir = original[0] - original[1];
|
|
|
dir = dir.normalize() * std::abs(distance) * 0.5;
|
|
|
parallel.push_back(offsetPoints[0] + dir);
|
|
|
}
|
|
|
}
|
|
|
else if (endType == EndType::ROUND) {
|
|
|
// 圆角端点：添加圆弧
|
|
|
parallel.push_back(offsetPoints[0]);
|
|
|
if (n > 1) {
|
|
|
tPoint2D dir = (original[1] - original[0]).normalize();
|
|
|
double startAngle = std::atan2(dir.y0, dir.x0) + PI/2;
|
|
|
double endAngle = startAngle + PI/2;
|
|
|
auto arcPoints = generateArcPoints(original[0], std::abs(distance),
|
|
|
startAngle, endAngle, roundSegments);
|
|
|
parallel.insert(parallel.end(), arcPoints.begin(), arcPoints.end());
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 3. 处理连接点
|
|
|
for (size_t i = 1; i < n - 1; i++) {
|
|
|
double angle = calculateAngle(original[i - 1], original[i], original[i + 1]);
|
|
|
|
|
|
// 计算两个偏移方向
|
|
|
tPoint2D perpPrev = perpendicularVector(original[i], original[i - 1], distance);
|
|
|
tPoint2D perpNext = perpendicularVector(original[i], original[i + 1], distance);
|
|
|
|
|
|
tPoint2D offsetPrev = original[i] + perpPrev;
|
|
|
tPoint2D offsetNext = original[i] + perpNext;
|
|
|
|
|
|
if (joinType == JoinType::BEVEL || angle < 45.0) {
|
|
|
// 斜角连接或锐角：直接连接
|
|
|
parallel.push_back(offsetPrev);
|
|
|
parallel.push_back(offsetNext);
|
|
|
}
|
|
|
else if (joinType == JoinType::MITER) {
|
|
|
// 计算斜接点
|
|
|
tPoint2D miterPoint;
|
|
|
if (lineIntersection(offsetPrev, offsetPrev + (original[i - 1] - original[i]),
|
|
|
offsetNext, offsetNext + (original[i + 1] - original[i]),
|
|
|
miterPoint)) {
|
|
|
// 检查斜接限制
|
|
|
double miterLength = (miterPoint - original[i]).length();
|
|
|
double miterRatio = miterLength / std::abs(distance);
|
|
|
|
|
|
if (miterRatio <= miterLimit) {
|
|
|
parallel.push_back(miterPoint);
|
|
|
}
|
|
|
else {
|
|
|
// 超过限制，使用斜角连接
|
|
|
parallel.push_back(offsetPrev);
|
|
|
parallel.push_back(offsetNext);
|
|
|
}
|
|
|
}
|
|
|
else {
|
|
|
parallel.push_back(offsetPrev);
|
|
|
parallel.push_back(offsetNext);
|
|
|
}
|
|
|
}
|
|
|
else if (joinType == JoinType::ROUND) {
|
|
|
// 圆角连接
|
|
|
parallel.push_back(offsetPrev);
|
|
|
|
|
|
if (angle < 180.0 && std::abs(distance) > 0) {
|
|
|
// 计算圆弧
|
|
|
tPoint2D center = original[i];
|
|
|
double radius = std::abs(distance);
|
|
|
|
|
|
tPoint2D dir1 = (original[i - 1] - original[i]).normalize();
|
|
|
tPoint2D dir2 = (original[i + 1] - original[i]).normalize();
|
|
|
|
|
|
double startAngle = std::atan2(dir1.y0, dir1.x0) + PI/2;
|
|
|
double endAngle = std::atan2(dir2.y0, dir2.x0) + PI/2;
|
|
|
|
|
|
// 根据角度调整分段数
|
|
|
int segments = max(3, static_cast<int>(angle / 30.0));
|
|
|
segments = min(segments, roundSegments);
|
|
|
|
|
|
auto arcPoints = generateArcPoints(center, radius,
|
|
|
startAngle, endAngle, segments);
|
|
|
parallel.insert(parallel.end(), arcPoints.begin(), arcPoints.end());
|
|
|
}
|
|
|
|
|
|
parallel.push_back(offsetNext);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 4. 处理最后一个点之前的连接
|
|
|
if (n > 1) {
|
|
|
parallel.push_back(offsetPoints[n - 2]);
|
|
|
}
|
|
|
|
|
|
// 5. 处理终点
|
|
|
if (endType == EndType::BUTT) {
|
|
|
parallel.push_back(offsetPoints[n - 1]);
|
|
|
}
|
|
|
else if (endType == EndType::SQUARE) {
|
|
|
parallel.push_back(offsetPoints[n - 1]);
|
|
|
if (n > 1) {
|
|
|
tPoint2D dir = original[n - 1] - original[n - 2];
|
|
|
dir = dir.normalize() * std::abs(distance) * 0.5;
|
|
|
parallel.push_back(offsetPoints[n - 1] + dir);
|
|
|
}
|
|
|
}
|
|
|
else if (endType == EndType::ROUND) {
|
|
|
parallel.push_back(offsetPoints[n - 1]);
|
|
|
}
|
|
|
|
|
|
// 6. 检查并修复自相交
|
|
|
if (checkSelfIntersection(parallel)) {
|
|
|
std::cout << "Warning: Self-intersection detected, applying fix..." << std::endl;
|
|
|
parallel = fixSelfIntersection(original, parallel, distance, joinType, miterLimit);
|
|
|
}
|
|
|
|
|
|
return parallel;
|
|
|
}
|
|
|
|
|
|
// 打印点集
|
|
|
//void printPoints(const std::vector<tPoint2D>& points, const std::string& name) {
|
|
|
// std::cout << "\n" << name << " (" << points.size() << " points):" << std::endl;
|
|
|
// for (size_t i = 0; i < points.size(); i++) {
|
|
|
// std::cout << " " << i << ": (" << points[i].x0 << ", " << points[i].y0 << ")" << std::endl;
|
|
|
// }
|
|
|
//}
|
|
|
|
|
|
// 生成平行折线（简化接口）
|
|
|
std::vector<tPoint2D> createParallel(const std::vector<tPoint2D>& original,
|
|
|
double distance,
|
|
|
bool miterJoin = true,
|
|
|
bool roundEnds = false) {
|
|
|
JoinType joinType = miterJoin ? JoinType::MITER : JoinType::BEVEL;
|
|
|
EndType endType = roundEnds ? EndType::ROUND : EndType::BUTT;
|
|
|
|
|
|
return createParallelPolyline(original, distance, joinType, endType, 2.0, 8);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
extern AFX_EXT_API void makeCurveParallelSimple(CCurve& inCurve, double offset, CCurveEx& outCurve);
|
|
|
extern AFX_EXT_API void makeCurveParallel(CCurve& inCurve, double offset, CCurveEx& outCurve);
|
|
|
extern AFX_EXT_API void offsetCurveWithClipper3(CCurve& inCurve, double offset, CCurveEx& outCurve);//不好用
|
|
|
extern AFX_EXT_API void offsetCurveWithClipper2(CCurve& inCurve, double offset, CCurveEx& outCurve); //不好用
|