|
|
#pragma once
|
|
|
#include "StdAfx.h"
|
|
|
#include <vector>
|
|
|
#include <cmath>
|
|
|
#include <algorithm>
|
|
|
#include <list>
|
|
|
|
|
|
// 简单的点结构
|
|
|
struct Pnt {
|
|
|
double x, y;
|
|
|
};
|
|
|
|
|
|
namespace NoGeosUtils
|
|
|
{
|
|
|
double Dist(const Pnt& a, const Pnt& b) {
|
|
|
return std::sqrt(std::pow(a.x - b.x, 2) + std::pow(a.y - b.y, 2));
|
|
|
}
|
|
|
|
|
|
double PerpendicularDistance(const Pnt& pt, const Pnt& lineStart, const Pnt& lineEnd) {
|
|
|
double dx = lineEnd.x - lineStart.x;
|
|
|
double dy = lineEnd.y - lineStart.y;
|
|
|
double mag = std::sqrt(dx * dx + dy * dy);
|
|
|
if (mag < 1e-10) return Dist(pt, lineStart);
|
|
|
double u = ((pt.x - lineStart.x) * dx + (pt.y - lineStart.y) * dy) / (mag * mag);
|
|
|
Pnt intersection;
|
|
|
if (u < 0.0f) intersection = lineStart;
|
|
|
else if (u > 1.0f) intersection = lineEnd;
|
|
|
else {
|
|
|
intersection.x = lineStart.x + u * dx;
|
|
|
intersection.y = lineStart.y + u * dy;
|
|
|
}
|
|
|
return Dist(pt, intersection);
|
|
|
}
|
|
|
|
|
|
// 道格拉斯-普克 (Douglas-Peucker) 抽稀算法
|
|
|
void DouglasPeucker(const std::vector<Pnt>& pointList, double epsilon, std::vector<Pnt>& out) {
|
|
|
if (pointList.size() < 2) return;
|
|
|
|
|
|
double dmax = 0.0;
|
|
|
size_t index = 0;
|
|
|
size_t end = pointList.size() - 1;
|
|
|
|
|
|
for (size_t i = 1; i < end; i++) {
|
|
|
double d = PerpendicularDistance(pointList[i], pointList[0], pointList[end]);
|
|
|
if (d > dmax) {
|
|
|
index = i;
|
|
|
dmax = d;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
if (dmax > epsilon) {
|
|
|
std::vector<Pnt> recResults1;
|
|
|
std::vector<Pnt> recResults2;
|
|
|
std::vector<Pnt> firstLine(pointList.begin(), pointList.begin() + index + 1);
|
|
|
std::vector<Pnt> lastLine(pointList.begin() + index, pointList.end());
|
|
|
|
|
|
DouglasPeucker(firstLine, epsilon, recResults1);
|
|
|
DouglasPeucker(lastLine, epsilon, recResults2);
|
|
|
|
|
|
out.assign(recResults1.begin(), recResults1.end() - 1);
|
|
|
out.insert(out.end(), recResults2.begin(), recResults2.end());
|
|
|
}
|
|
|
else {
|
|
|
out.clear();
|
|
|
out.push_back(pointList[0]);
|
|
|
out.push_back(pointList[end]);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Chaikin 平滑算法 (保留直角)
|
|
|
// 迭代一次会把一个角切成两个，但会智能跳过 90 度左右的角
|
|
|
std::vector<Pnt> ChaikinSmooth(const std::vector<Pnt>& points, int iterations) {
|
|
|
if (points.size() < 3) return points;
|
|
|
std::vector<Pnt> current = points;
|
|
|
|
|
|
const double RIGHT_ANGLE_TOLERANCE = 0.15;
|
|
|
|
|
|
for (int iter = 0; iter < iterations; iter++) {
|
|
|
size_t n = current.size();
|
|
|
if (n < 3) break;
|
|
|
|
|
|
std::vector<Pnt> next;
|
|
|
// 标记哪些点需要保留 (是直角)
|
|
|
std::vector<bool> keepCorner(n, false);
|
|
|
|
|
|
for (size_t i = 0; i < n - 1; i++) {
|
|
|
// 获取前后点 (处理闭合回路)
|
|
|
Pnt prev = (i == 0) ? current[n - 2] : current[i - 1];
|
|
|
Pnt curr = current[i];
|
|
|
Pnt succ = current[i + 1];
|
|
|
|
|
|
// 计算向量
|
|
|
double x1 = prev.x - curr.x;
|
|
|
double y1 = prev.y - curr.y;
|
|
|
double x2 = succ.x - curr.x;
|
|
|
double y2 = succ.y - curr.y;
|
|
|
|
|
|
double len1 = std::sqrt(x1 * x1 + y1 * y1);
|
|
|
double len2 = std::sqrt(x2 * x2 + y2 * y2);
|
|
|
|
|
|
if (len1 > 1e-9 && len2 > 1e-9) {
|
|
|
// 计算余弦值: (v1 . v2) / |v1||v2|
|
|
|
double dot = x1 * x2 + y1 * y2;
|
|
|
double cosTheta = dot / (len1 * len2);
|
|
|
|
|
|
// 判断是否接近 90 度 (点积接近 0)
|
|
|
if (std::abs(cosTheta) < RIGHT_ANGLE_TOLERANCE) {
|
|
|
keepCorner[i] = true;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
// 对于闭合多边形，首尾是同一个点，状态必须同步
|
|
|
if (n > 0) keepCorner[n - 1] = keepCorner[0];
|
|
|
|
|
|
// 生成新点
|
|
|
for (size_t i = 0; i < n - 1; i++)
|
|
|
{
|
|
|
Pnt p0 = current[i];
|
|
|
Pnt p1 = current[i + 1];
|
|
|
|
|
|
Pnt q, r;
|
|
|
|
|
|
// --- 确定 Q 点 (靠近 p0) ---
|
|
|
if (keepCorner[i])
|
|
|
{
|
|
|
q = p0; // 如果 p0 是直角，Q 点就是 p0 本身 (不切割)
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
q.x = 0.75 * p0.x + 0.25 * p1.x;
|
|
|
q.y = 0.75 * p0.y + 0.25 * p1.y;
|
|
|
}
|
|
|
|
|
|
// --- 确定 R 点 (靠近 p1) ---
|
|
|
// 注意：p1 的保留状态由 keepCorner[i+1] 决定
|
|
|
if (keepCorner[i + 1])
|
|
|
{
|
|
|
r = p1; // 如果 p1 是直角，R 点就是 p1 本身
|
|
|
}
|
|
|
else
|
|
|
{
|
|
|
r.x = 0.25 * p0.x + 0.75 * p1.x;
|
|
|
r.y = 0.25 * p0.y + 0.75 * p1.y;
|
|
|
}
|
|
|
|
|
|
// 添加 Q (避免重复)
|
|
|
if (next.empty() || std::abs(next.back().x - q.x) > 1e-9 || std::abs(next.back().y - q.y) > 1e-9) {
|
|
|
next.push_back(q);
|
|
|
}
|
|
|
|
|
|
// 添加 R (避免重复)
|
|
|
if (std::abs(next.back().x - r.x) > 1e-9 || std::abs(next.back().y - r.y) > 1e-9) {
|
|
|
next.push_back(r);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// 确保闭合 (如果生成结果首尾不接，强制闭合)
|
|
|
if (!next.empty()) {
|
|
|
Pnt first = next.front();
|
|
|
Pnt last = next.back();
|
|
|
if (std::abs(first.x - last.x) > 1e-9 || std::abs(first.y - last.y) > 1e-9) {
|
|
|
next.push_back(first);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
current = next;
|
|
|
}
|
|
|
return current;
|
|
|
}
|
|
|
|
|
|
// 简单的 Moore-Neighbor 边界追踪 (获取网格边界)
|
|
|
// gridFunc: 返回 true 表示该位置是有效网格
|
|
|
std::vector<Pnt> TraceBoundary(int nx, int ny, double xmin, double ymin, double dx, double dy,
|
|
|
std::function<bool(int, int)> gridFunc)
|
|
|
{
|
|
|
std::vector<Pnt> boundary;
|
|
|
|
|
|
// --- 寻找起始点 ---
|
|
|
int sx = -1, sy = -1;
|
|
|
for (int j = 0; j < ny; ++j)
|
|
|
{
|
|
|
for (int i = 0; i < nx; ++i)
|
|
|
{
|
|
|
if (gridFunc(i, j))
|
|
|
{
|
|
|
sx = i; sy = j;
|
|
|
goto FoundStart; // 找到左下角第一个点
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
return boundary; // 空
|
|
|
|
|
|
FoundStart:
|
|
|
|
|
|
int cx = sx; // 当前像素坐标
|
|
|
int cy = sy;
|
|
|
int dir = 0; // 0:上, 1:右, 2:下, 3:左 (相对于像素的移动方向)
|
|
|
struct Edge
|
|
|
{
|
|
|
double x1, y1, x2, y2;
|
|
|
bool operator==(const Edge& other) const
|
|
|
{
|
|
|
// 无向边比较
|
|
|
return (std::abs(x1 - other.x1) < 1e-9 && std::abs(y1 - other.y1) < 1e-9 && std::abs(x2 - other.x2) < 1e-9 && std::abs(y2 - other.y2) < 1e-9) ||
|
|
|
(std::abs(x1 - other.x2) < 1e-9 && std::abs(y1 - other.y2) < 1e-9 && std::abs(x2 - other.x1) < 1e-9 && std::abs(y2 - other.y1) < 1e-9);
|
|
|
}
|
|
|
};
|
|
|
|
|
|
std::vector<Pnt> rawPoints;
|
|
|
|
|
|
int vx = sx, vy = sy;
|
|
|
int facing = 1; // 0:上(y+), 1:右(x+), 2:下(y-), 3:左(x-)
|
|
|
|
|
|
// 起始状态记录
|
|
|
int start_vx = vx, start_vy = vy, start_facing = facing;
|
|
|
bool first_step = true;
|
|
|
|
|
|
auto is_valid = [&](int c, int r) {
|
|
|
if (c < 0 || c >= nx || r < 0 || r >= ny) return false;
|
|
|
return gridFunc(c, r);
|
|
|
};
|
|
|
|
|
|
// 这里的逻辑是追踪格子的**间隙**
|
|
|
// 左手定则：始终保持有效格子在左侧
|
|
|
int loop_safety = 0;
|
|
|
int max_loop = nx * ny * 4;
|
|
|
|
|
|
do {
|
|
|
// 记录当前点
|
|
|
Pnt p;
|
|
|
p.x = xmin + vx * dx - dx * 0.5; // 注意：GridGenerationBoundary里xmin是中心还是边缘？
|
|
|
p.y = ymin + vy * dy - dy * 0.5; // 根据Python代码 cx = xmin + c * dx，通常xmin是第一个网格中心
|
|
|
boundary.push_back(p);
|
|
|
|
|
|
int left_x = vx, left_y = vy; // 需根据 facing 调整
|
|
|
int right_x = vx, right_y = vy;
|
|
|
|
|
|
|
|
|
// 当前边左边的格子
|
|
|
int c1_x, c1_y; // 左侧格子
|
|
|
if (facing == 0) { c1_x = vx - 1; c1_y = vy; }
|
|
|
else if (facing == 1) { c1_x = vx; c1_y = vy; }
|
|
|
else if (facing == 2) { c1_x = vx; c1_y = vy - 1; }
|
|
|
else { c1_x = vx - 1; c1_y = vy - 1; }
|
|
|
|
|
|
|
|
|
bool q1 = is_valid(vx, vy);
|
|
|
bool q2 = is_valid(vx - 1, vy);
|
|
|
bool q3 = is_valid(vx - 1, vy - 1);
|
|
|
bool q4 = is_valid(vx, vy - 1);
|
|
|
|
|
|
int state = (q2 ? 8 : 0) | (q1 ? 4 : 0) | (q4 ? 2 : 0) | (q3 ? 1 : 0);
|
|
|
|
|
|
break;
|
|
|
|
|
|
} while (vx != start_vx || vy != start_vy || first_step);
|
|
|
|
|
|
return boundary;
|
|
|
}
|
|
|
}; |