Files
GC/model/contour-map/src/TerrainField.cs
T
Morris 5b628971a9
PR 审核 / 后端编译 (pull_request) Canceled after 0s
PR 审核 / 后端自检 (pull_request) Canceled after 0s
PR 审核 / 前端检查(Flutter) (pull_request) Canceled after 0s
PR 审核 / 安全扫描 (pull_request) Canceled after 0s
PR 审核 / 审核汇总 (pull_request) Canceled after 0s
feat(contour-map): 重写为可交互 3D 等高线模型,新增五大地貌专题
- 新增 LandformKind 与五套高度场生成器:穹状山峰、宽脊山脊、V 形山谷、双峰鞍部、台地陡崖
- 3D 视图重写:拖动旋转 / 滚轮缩放、按包围盒自动取景、法线光照、四周裙边侧壁、
  切割步骤改为把高度压到切面得到真实截面并用求交线精确出线
- 四步实验动画(等高切割 → 形成交线 → 垂直投影 → 疏密判坡),俯视 / 立体切换
- 界面重排:地貌标签移到画布上方(WrapPanel,窄屏自动换行并隐藏侧栏),
  右侧栏放实验流程 / 观察面板 / 判读要点;播放、重置、视图、上色、实时读数,空格与 1–5 快捷键、全屏
- 文案 90 个键中英双语;LoadTexts 改为「内置默认 + i18n 文件覆盖」,此前完全忽略语言包
- 修复三处渲染缺陷:Chain() 只向尾部延伸把等高线切成虚线;坡度归一化写死导致判坡整片红;
  切割只是叠加半透明板而山尖仍在
- 清单版本 1.1 → 1.2,描述与 help.json 同步;62×62 面片 + 画刷缓存,1440×900 单帧约 35ms
2026-11-19 20:45:03 +08:00

708 lines
28 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using System;
using System.Collections.Generic;
namespace GC.ContourMap;
/// <summary>五种基本地形类型(教科书分类)。</summary>
public enum TerrainKind
{
Mountain, // 山地:海拔高、起伏大
Basin, // 盆地:四周高、中间低
Hill, // 丘陵:海拔较低、坡度和缓
Plateau, // 高原:海拔高、地面平坦、边缘陡
Plain // 平原:海拔低、地面平坦
}
/// <summary>五大典型地貌部位(等高线判读的核心对象)。</summary>
public enum LandformKind
{
Peak, // 山峰:闭合等高线,数值向内升高
Ridge, // 山脊:等高线凸向低处,凸低为脊
Valley, // 山谷:等高线凸向高处,凸高为谷
Saddle, // 鞍部:两峰之间相对低洼,俯视收腰
Cliff // 陡崖:等高线密集甚至重合
}
/// <summary>
/// 地形高度场(等高线模型的数据核心)。
///
/// 用叠加的高斯山包合成一块教学用地形:
/// · 主峰(山峰)
/// · 次峰(与主峰之间形成鞍部)
/// · 两条山脊、一条山谷
/// · 一侧陡坡(等高线密集)、一侧缓坡(等高线稀疏)
/// · 一处陡崖
///
/// 高度单位米,网格分辨率可配置;网格值一次性算好,等高线由它切线得出。
/// </summary>
public sealed class TerrainField
{
/// <summary>网格边长(正方形,便于俯视与等高线处理)。</summary>
public int Size { get; }
/// <summary>海拔网格,[y, x],单位米。</summary>
public float[,] Heights { get; }
public float MinHeight { get; private set; }
public float MaxHeight { get; private set; }
/// <summary>等高距(米):教学图常用 100 m。</summary>
public float Interval { get; init; } = 100f;
/// <summary>这块地形属于哪种类型(决定界面标题与说明)。</summary>
public TerrainKind Kind { get; }
/// <summary>若这块地形是某个典型地貌部位,则记录其种类;否则为 null。</summary>
public LandformKind? Landform { get; }
public TerrainField(TerrainKind kind = TerrainKind.Mountain, int size = 192)
{
Size = size;
Kind = kind;
Heights = new float[size, size];
Build(kind);
}
/// <summary>创建一个专门表现某种典型地貌部位的高度场。</summary>
public TerrainField(LandformKind landform, int size = 192)
{
Size = size;
Kind = TerrainKind.Mountain;
Landform = landform;
Heights = new float[size, size];
BuildLandform(landform);
}
/// <summary>该类型对应的等高距:平原/丘陵用 20m,山地/高原/盆地用 100m。</summary>
public float EffectiveInterval => Kind switch
{
TerrainKind.Plain => 5f, // 平原起伏小,等高距要小才画得出线
TerrainKind.Hill => 10f, // 丘陵相对高差约 150 m
_ => 100f
};
/// <summary>归一化坐标 (u,v) ∈ [0,1],u 向东、v 向南。</summary>
public float HeightAt(double u, double v)
{
var x = (int)Math.Round(u * (Size - 1));
var y = (int)Math.Round(v * (Size - 1));
x = Math.Clamp(x, 0, Size - 1);
y = Math.Clamp(y, 0, Size - 1);
return Heights[y, x];
}
/// <summary>双线性插值取值,画平滑曲线时用。</summary>
public float SampleSmooth(double u, double v)
{
var fx = Math.Clamp(u, 0, 1) * (Size - 1);
var fy = Math.Clamp(v, 0, 1) * (Size - 1);
var x0 = (int)Math.Floor(fx); var y0 = (int)Math.Floor(fy);
var x1 = Math.Min(x0 + 1, Size - 1); var y1 = Math.Min(y0 + 1, Size - 1);
var tx = fx - x0; var ty = fy - y0;
var h00 = Heights[y0, x0]; var h10 = Heights[y0, x1];
var h01 = Heights[y1, x0]; var h11 = Heights[y1, x1];
var a = h00 * (1 - tx) + h10 * tx;
var b = h01 * (1 - tx) + h11 * tx;
return (float)(a * (1 - ty) + b * ty);
}
private void Build(TerrainKind kind)
{
switch (kind)
{
case TerrainKind.Mountain: BuildMountain(); break;
case TerrainKind.Basin: BuildBasin(); break;
case TerrainKind.Hill: BuildHill(); break;
case TerrainKind.Plateau: BuildPlateau(); break;
case TerrainKind.Plain: BuildPlain(); break;
}
BuildFeatures();
}
private void BuildMountain()
{
// 各山体参数:中心(u,v)、高度、东西半径、南北半径
var peaks = new (double U, double V, double H, double RU, double RV)[]
{
(0.34, 0.34, 1180, 0.26, 0.24), // 主峰
(0.66, 0.52, 860, 0.20, 0.20), // 次峰(与主峰间成鞍部)
(0.22, 0.70, 520, 0.18, 0.16), // 西侧小山
(0.78, 0.22, 430, 0.16, 0.15), // 东北小山
};
var min = float.MaxValue; var max = float.MinValue;
for (var y = 0; y < Size; y++)
{
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
double h = 120; // 基准面(平原 / 河谷)
foreach (var p in peaks)
{
var du = (u - p.U) / p.RU;
var dv = (v - p.V) / p.RV;
var d2 = du * du + dv * dv;
h += p.H * Math.Exp(-d2 * 1.15);
}
// 山谷:沿一条斜线切下去,形成 V 形谷地
var valley = Math.Abs((u - 0.5) * 0.8 + (v - 0.44) * 0.6);
h -= 210 * Math.Exp(-valley * valley / 0.0016);
// 陡崖:东侧一条近乎垂直的高差带(等高线会挤在一起)
if (u > 0.86 && v > 0.18 && v < 0.72)
h += 260 * SmoothStep(0.86, 0.895, u);
// 缓坡:西南角缓慢抬升
if (u < 0.3 && v > 0.6)
h += 90 * (1 - u / 0.3) * ((v - 0.6) / 0.4);
// 轻微起伏,避免地形过于几何化
h += 18 * Math.Sin(u * 9.1) * Math.Cos(v * 7.7);
var hf = (float)Math.Max(0, h);
Heights[y, x] = hf;
if (hf < min) min = hf;
if (hf > max) max = hf;
}
}
MinHeight = min;
MaxHeight = max;
}
/// <summary>盆地:四周高、中间低,等高线由外向内递减。</summary>
private void BuildBasin()
{
var min = float.MaxValue; var max = float.MinValue;
for (var y = 0; y < Size; y++)
{
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
var du = u - 0.5; var dv = v - 0.5;
var r = Math.Sqrt(du * du + dv * dv) * 2.0; // 0=中心 1=边缘
// 边缘抬升、中心下沉,形成碗状
double h = 160 + 900 * Math.Pow(Math.Clamp(r, 0, 1.15), 2.2);
// 一侧开个缺口(山口),让盆地向外开口
var gap = Math.Abs(Math.Atan2(dv, du) - 0.5);
if (gap < 0.35) h -= 320 * (1 - gap / 0.35) * (1 - Math.Clamp(r, 0, 1));
h += 14 * Math.Sin(u * 7.3) * Math.Cos(v * 6.1);
var hf = (float)Math.Max(0, h);
Heights[y, x] = hf;
if (hf < min) min = hf;
if (hf > max) max = hf;
}
}
MinHeight = min; MaxHeight = max;
}
/// <summary>丘陵:起伏和缓、海拔不高,等高线稀疏而弯曲。</summary>
private void BuildHill()
{
var bumps = new (double U, double V, double H, double R)[]
{
(0.30, 0.32, 120, 0.20), (0.66, 0.28, 95, 0.17),
(0.52, 0.62, 140, 0.22), (0.22, 0.72, 88, 0.16),
(0.78, 0.70, 110, 0.18),
};
var min = float.MaxValue; var max = float.MinValue;
for (var y = 0; y < Size; y++)
{
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
double h = 60;
foreach (var b in bumps)
{
var du = (u - b.U) / b.R; var dv = (v - b.V) / b.R;
h += b.H * Math.Exp(-(du * du + dv * dv) * 1.3);
}
h += 10 * Math.Sin(u * 11.0) * Math.Cos(v * 9.0);
var hf = (float)Math.Max(0, h);
Heights[y, x] = hf;
if (hf < min) min = hf;
if (hf > max) max = hf;
}
}
MinHeight = min; MaxHeight = max;
}
/// <summary>高原:顶部平坦、边缘陡峭(等高线在中部稀疏、边缘密集)。</summary>
private void BuildPlateau()
{
var min = float.MaxValue; var max = float.MinValue;
for (var y = 0; y < Size; y++)
{
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
// 到中心的距离,做平台 + 陡降
var du = (u - 0.5); var dv = (v - 0.5);
var r = Math.Sqrt(du * du + dv * dv) * 2.0;
double h;
if (r < 0.55) h = 1250; // 平坦顶面
else h = 1250 - 1000 * SmoothStep(0.55, 0.78, r); // 边缘陡降
// 顶面轻微起伏,避免完全平板
if (r < 0.55) h += 25 * Math.Sin(u * 6.0) * Math.Cos(v * 5.0);
h += 30 * (1 - Math.Clamp(r, 0, 1));
var hf = (float)Math.Max(0, h);
Heights[y, x] = hf;
if (hf < min) min = hf;
if (hf > max) max = hf;
}
}
MinHeight = min; MaxHeight = max;
}
/// <summary>平原:地面低平、起伏极小,等高线很少。</summary>
private void BuildPlain()
{
var min = float.MaxValue; var max = float.MinValue;
for (var y = 0; y < Size; y++)
{
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
// 整体微倾 + 极缓的起伏
double h = 40 + 22 * u + 8 * Math.Sin(u * 4.2) * Math.Cos(v * 3.6);
var hf = (float)Math.Max(0, h);
Heights[y, x] = hf;
if (hf < min) min = hf;
if (hf > max) max = hf;
}
}
MinHeight = min; MaxHeight = max;
}
// ───────────────────────── 五大典型地貌部位 ─────────────────────────
private void BuildLandform(LandformKind landform)
{
switch (landform)
{
case LandformKind.Peak: BuildPeak(); break;
case LandformKind.Ridge: BuildRidge(); break;
case LandformKind.Valley: BuildValley(); break;
case LandformKind.Saddle: BuildSaddle(); break;
case LandformKind.Cliff: BuildCliff(); break;
}
BuildFeatures();
}
/// <summary>山峰:单峰为主、层层闭合,四周逐级降低。配一处小侧峰便于读鞍部。</summary>
private void BuildPeak()
{
var min = double.MaxValue; var max = double.MinValue;
for (var y = 0; y < Size; y++)
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
var du = u - 0.5; var dv = (v - 0.5) / 0.94;
var r = Math.Sqrt(du * du + dv * dv);
// 主峰:宽阔的穹状山体(半径约占图幅 8 成),层层闭合的等高线才画得开
var core = Math.Exp(-Math.Pow(r / 0.36, 1.85));
var rim = 1 - SmoothStep(0.36, 0.50, r); // 山脚过渡到平地
var h = 65 + 1230 * core * rim;
// 东南侧肩部,让等高线不是完美同心圆
h += 120 * Math.Exp(-(Math.Pow(u - 0.72, 2) + Math.Pow(v - 0.66, 2)) / 0.016) * rim;
h += 22 * Math.Sin(u * 7.3 + 0.6) * Math.Cos(v * 6.1) * rim;
h = Math.Max(0, h);
Heights[y, x] = (float)h;
if (h < min) min = h; if (h > max) max = h;
}
MinHeight = (float)min; MaxHeight = (float)max;
Tags.Clear();
Tags.Add((0.5, 0.5, 0.09, TerrainFeature.Peak));
}
/// <summary>山脊:一条狭长高地,等高线沿脊线向低处凸出(凸低为脊)。</summary>
private void BuildRidge()
{
var min = double.MaxValue; var max = double.MinValue;
for (var y = 0; y < Size; y++)
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
// 脊线沿 u 方向(西高东低),东西向是长坡,南北向是宽缓的两翼
var crestV = 0.5 + 0.10 * Math.Sin(u * 3.1); // 脊线轻微弯曲
var across = v - crestV;
var crest = 1150 - 380 * u; // 脊线海拔由西向东降低
var lateral = Math.Exp(-Math.Pow(Math.Abs(across) / 0.27, 1.55));
var h = 85 + (crest - 85) * lateral;
// 两翼的次级起伏,避免像一堵直墙
h += 60 * Math.Exp(-Math.Pow(Math.Abs(across) - 0.30, 2) / 0.010) * (0.4 + 0.6 * (1 - u));
h += 24 * Math.Sin(u * 8.0) * Math.Cos(v * 5.6);
h = Math.Max(0, h);
Heights[y, x] = (float)h;
if (h < min) min = h; if (h > max) max = h;
}
MinHeight = (float)min; MaxHeight = (float)max;
Tags.Clear();
Tags.Add((0.30, 0.50, 0.09, TerrainFeature.Ridge));
Tags.Add((0.70, 0.50, 0.09, TerrainFeature.Ridge));
}
/// <summary>山谷:两侧高地夹持的低槽,等高线形成 V 形指向上游(凸高为谷)。</summary>
private void BuildValley()
{
var min = double.MaxValue; var max = double.MinValue;
for (var y = 0; y < Size; y++)
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
// 谷轴沿 v 方向:两侧高、中间是 V 形谷底;北侧(v 小)为上游更高
var side = Math.Pow(Math.Abs(u - 0.5) / 0.5, 1.5); // 0=谷心 1=图边
var downhill = 1 - v; // 上游 1 → 下游 0
var h = 90 + 760 * downhill + 585 * side * (0.30 + 0.70 * downhill);
// 谷底再切深一点,形成明显的集水线
h -= 70 * Math.Exp(-Math.Pow(u - 0.5, 2) / 0.0022);
h += 18 * Math.Sin(u * 6.5) * Math.Cos(v * 7.2);
h = Math.Max(0, h);
Heights[y, x] = (float)h;
if (h < min) min = h; if (h > max) max = h;
}
MinHeight = (float)min; MaxHeight = (float)max;
Tags.Clear();
Tags.Add((0.50, 0.40, 0.075, TerrainFeature.Valley));
Tags.Add((0.50, 0.68, 0.075, TerrainFeature.Valley));
}
/// <summary>鞍部:两座山峰之间相对低洼、俯视轮廓收腰的过渡地带。</summary>
private void BuildSaddle()
{
var min = double.MaxValue; var max = double.MinValue;
for (var y = 0; y < Size; y++)
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
// 两峰在 v≈0.5 的连线上,u=0.27 与 u=0.73;中间 u=0.5 为垭口
var d1 = Math.Sqrt(Math.Pow((u - 0.27) / 0.30, 2) + Math.Pow((v - 0.52) / 0.28, 2));
var d2 = Math.Sqrt(Math.Pow((u - 0.73) / 0.30, 2) + Math.Pow((v - 0.48) / 0.28, 2));
var p1 = 1140 * Math.Exp(-Math.Pow(d1, 2.2));
var p2 = 1060 * Math.Exp(-Math.Pow(d2, 2.2));
// 南北两侧缓慢降低,把两峰连成一条东西向的山梁
var bench = 330 * Math.Exp(-Math.Pow((v - 0.5) / 0.34, 2));
var h = 65 + bench + Math.Max(p1, p2);
h += 20 * Math.Sin(u * 8.0) * Math.Cos(v * 7.0);
h = Math.Max(0, h);
Heights[y, x] = (float)h;
if (h < min) min = h; if (h > max) max = h;
}
MinHeight = (float)min; MaxHeight = (float)max;
Tags.Clear();
Tags.Add((0.28, 0.50, 0.05, TerrainFeature.Peak));
Tags.Add((0.72, 0.50, 0.05, TerrainFeature.Peak));
Tags.Add((0.50, 0.50, 0.045, TerrainFeature.Saddle));
}
/// <summary>陡崖:一侧近乎直立的高差带,等高线在崖壁处高度密集甚至重合。</summary>
private void BuildCliff()
{
var min = double.MaxValue; var max = double.MinValue;
for (var y = 0; y < Size; y++)
for (var x = 0; x < Size; x++)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
// 西侧低台地、东侧高台地,中间一条近乎直立的高差带形成陡崖
// 崖线略呈波状(真实崖壁不是一条直线),过渡带留出 2~3 个采样格
var edge = SmoothStep(0.50, 0.62, u + 0.045 * Math.Sin(v * 5.2) + 0.02 * Math.Sin(v * 11.0));
var h = 210 + 940 * edge;
// 高台地北高南低、顶面起伏,低台地保持缓坡
h += 170 * (1 - v) * edge;
h += 55 * Math.Sin(v * 5.4) * Math.Cos(u * 4.2) * (0.4 + 0.6 * edge);
h += 26 * Math.Sin(u * 9.0); // 顶面轻微起伏
h = Math.Max(0, h);
Heights[y, x] = (float)h;
if (h < min) min = h; if (h > max) max = h;
}
MinHeight = (float)min; MaxHeight = (float)max;
Tags.Clear();
Tags.Add((0.50, 0.50, 0.035, TerrainFeature.Cliff));
}
private static double SmoothStep(double a, double b, double x)
{
var t = Math.Clamp((x - a) / (b - a), 0, 1);
return t * t * (3 - 2 * t);
}
/// <summary>
/// 教学标注区:把「典型部位」的位置固化成圆形区域,
/// 保证判读结果与地形设计一致(纯几何推断对鞍部/陡崖易误判)。
/// </summary>
public List<(double U, double V, double Radius, TerrainFeature Feature)> Tags { get; } = new()
{
(0.34, 0.34, 0.045, TerrainFeature.Peak), // 主峰
(0.66, 0.52, 0.042, TerrainFeature.Peak), // 次峰
(0.50, 0.44, 0.055, TerrainFeature.Saddle), // 两峰之间的鞍部
(0.90, 0.45, 0.035, TerrainFeature.Cliff), // 东侧陡崖
(0.22, 0.70, 0.045, TerrainFeature.Ridge), // 西南山脊
(0.50, 0.22, 0.040, TerrainFeature.Valley), // 河谷
};
/// <summary>查询标注区;未命中返回 None。</summary>
public TerrainFeature TagAt(double u, double v)
{
foreach (var (tu, tv, r, f) in Tags)
{
var du = u - tu; var dv = v - tv;
if (du * du + dv * dv <= r * r) return f;
}
return TerrainFeature.None;
}
/// <summary>
/// 河流:从最高点出发,沿最陡下降方向流到图边。
/// 教科书上的河流画蓝色线,且**只在河谷(等高线凸向高处的一侧)里流**。
/// </summary>
public List<(double U, double V)> River { get; } = new();
/// <summary>山峰位置(用于画 ▲ 与高程数字):局部最高点。</summary>
public List<(double U, double V, float Height)> Peaks { get; } = new();
/// <summary>陡崖位置(用于画锯齿线):坡度极大处。</summary>
public List<(double U, double V)> Cliffs { get; } = new();
/// <summary>找出山峰、陡崖,并生成河流线。</summary>
private void BuildFeatures()
{
// --- 山峰:局部最高且足够高 ---
const int step = 4;
for (var y = step; y < Size - step; y += step)
{
for (var x = step; x < Size - step; x += step)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
var h = Heights[y, x];
if (h < MaxHeight * 0.55) continue;
var isMax = true;
for (var dy = -step; dy <= step && isMax; dy += step)
for (var dx = -step; dx <= step; dx += step)
{
if (dx == 0 && dy == 0) continue;
if (Heights[y + dy, x + dx] > h) { isMax = false; break; }
}
if (isMax) Peaks.Add((u, v, h));
}
}
Peaks.Sort((a, b) => b.Height.CompareTo(a.Height));
// --- 陡崖:坡度极大 ---
const int cstep = 3;
for (var y = cstep; y < Size - cstep; y += cstep)
{
for (var x = cstep; x < Size - cstep; x += cstep)
{
var u = (double)x / (Size - 1);
var v = (double)y / (Size - 1);
var h = 0.004;
var du = (Heights[y, x + 2] - Heights[y, x - 2]) / (2 * h * (Size - 1)) / 1000;
var dv = (Heights[y + 2, x] - Heights[y - 2, x]) / (2 * h * (Size - 1)) / 1000;
var slope = Math.Sqrt(du * du + dv * dv);
if (slope > 0.11) Cliffs.Add((u, v));
}
}
// --- 河流:从最高点沿最陡下降方向走 ---
if (Peaks.Count > 0)
{
var start = Peaks[0];
var cu = start.U; var cv = start.V;
River.Add((cu, cv));
const int maxSteps = 400;
for (var step2 = 0; step2 < maxSteps; step2++)
{
var h0 = SampleSmooth(cu, cv);
double bestU = 0, bestV = 0; var bestH = h0; var found = false;
for (var a = 0; a < 16; a++)
{
var ang = a * Math.PI * 2 / 16;
var nu = cu + Math.Cos(ang) * 0.012;
var nv = cv + Math.Sin(ang) * 0.012;
if (nu < 0 || nu > 1 || nv < 0 || nv > 1) continue;
var nh = SampleSmooth(nu, nv);
if (nh < bestH) { bestH = nh; bestU = nu; bestV = nv; found = true; }
}
if (!found) break;
cu = bestU; cv = bestV;
River.Add((cu, cv));
if (cu <= 0.001 || cu >= 0.999 || cv <= 0.001 || cv >= 0.999) break;
if (bestH < MinHeight + 20) break;
}
}
}
/// <summary>等高线高度列表:从 MaxHeight 往下按等高距取整。</summary>
public List<float> ContourLevels()
{
var levels = new List<float>();
var iv = EffectiveInterval;
var top = (float)(Math.Floor(MaxHeight / iv) * iv);
var bottom = (float)(Math.Ceiling(MinHeight / iv) * iv);
for (var h = bottom; h <= top + 0.01f; h += iv)
levels.Add(h);
levels.Sort();
return levels;
}
/// <summary>
/// 用 Marching Squares 提取某条等高线,返回若干条折线(归一化坐标)。
/// </summary>
public List<List<(double U, double V)>> ExtractContour(float level)
{
var result = new List<List<(double, double)>>();
var size = Size;
// 记录每条线段,再按端点连通性串成折线
var segments = new List<(double U1, double V1, double U2, double V2)>();
for (var y = 0; y < size - 1; y++)
{
for (var x = 0; x < size - 1; x++)
{
var h00 = Heights[y, x];
var h10 = Heights[y, x + 1];
var h11 = Heights[y + 1, x + 1];
var h01 = Heights[y + 1, x];
var idx = 0;
if (h00 >= level) idx |= 1;
if (h10 >= level) idx |= 2;
if (h11 >= level) idx |= 4;
if (h01 >= level) idx |= 8;
if (idx == 0 || idx == 15) continue;
double u0 = (double)x / (size - 1), u1 = (double)(x + 1) / (size - 1);
double v0 = (double)y / (size - 1), v1 = (double)(y + 1) / (size - 1);
// 四条边上的交点
(double, double) Top() => (Lerp(u0, u1, (level - h00) / (h10 - h00)), v0);
(double, double) Bottom() => (Lerp(u0, u1, (level - h01) / (h11 - h01)), v1);
(double, double) Left() => (u0, Lerp(v0, v1, (level - h00) / (h01 - h00)));
(double, double) Right() => (u1, Lerp(v0, v1, (level - h10) / (h11 - h10)));
void Add((double U, double V) a, (double U, double V) b)
=> segments.Add((a.Item1, a.Item2, b.Item1, b.Item2));
switch (idx)
{
case 1: case 14: Add(Left(), Top()); break;
case 2: case 13: Add(Top(), Right()); break;
case 3: case 12: Add(Left(), Right()); break;
case 4: case 11: Add(Right(), Bottom()); break;
case 6: case 9: Add(Top(), Bottom()); break;
case 7: case 8: Add(Left(), Bottom()); break;
case 5: Add(Left(), Top()); Add(Right(), Bottom()); break;
case 10: Add(Top(), Right()); Add(Left(), Bottom()); break;
}
}
}
return Chain(segments);
}
private static double Lerp(double a, double b, double t)
=> a + (b - a) * Math.Clamp(double.IsNaN(t) ? 0.5 : t, 0, 1);
/// <summary>
/// 把零散线段按端点串成完整折线。
/// 关键点:必须**两端都延伸**。只往尾部延伸时,起点落在曲线中段就会把一条等高线
/// 切成许多短链,渲染出来是断续的虚线(学生看到的就是“虚线等高线”)。
/// </summary>
private static List<List<(double U, double V)>> Chain(
List<(double U1, double V1, double U2, double V2)> segments)
{
// 量化到 1e-4 的网格做端点索引:共享边上的交点由同一次插值算出,
// 端点值完全一致;网格远小于采样间距(1/192≈0.0052),不会误并。
const double Q = 1e4;
static (long, long) Key(double u, double v)
=> ((long)Math.Round(u * Q), (long)Math.Round(v * Q));
var index = new Dictionary<(long, long), List<int>>();
void Register(double u, double v, int seg)
{
var k = Key(u, v);
if (!index.TryGetValue(k, out var list)) index[k] = list = new List<int>();
list.Add(seg);
}
for (var i = 0; i < segments.Count; i++)
{
Register(segments[i].U1, segments[i].V1, i);
Register(segments[i].U2, segments[i].V2, i);
}
var used = new bool[segments.Count];
var result = new List<List<(double, double)>>();
int NextAt(double u, double v)
{
if (!index.TryGetValue(Key(u, v), out var list)) return -1;
foreach (var j in list) if (!used[j]) return j;
return -1;
}
for (var i = 0; i < segments.Count; i++)
{
if (used[i]) continue;
used[i] = true;
var line = new List<(double U, double V)>
{
(segments[i].U1, segments[i].V1),
(segments[i].U2, segments[i].V2)
};
// 向尾部延伸
while (true)
{
var (tu, tv) = line[^1];
var j = NextAt(tu, tv);
if (j < 0) break;
used[j] = true;
var s = segments[j];
line.Add(Key(s.U1, s.V1) == Key(tu, tv) ? (s.U2, s.V2) : (s.U1, s.V1));
}
// 向头部延伸
while (true)
{
var (hu, hv) = line[0];
var j = NextAt(hu, hv);
if (j < 0) break;
used[j] = true;
var s = segments[j];
line.Insert(0, Key(s.U1, s.V1) == Key(hu, hv) ? (s.U2, s.V2) : (s.U1, s.V1));
}
if (line.Count >= 3) result.Add(line);
}
return result;
}
private static bool Near(double u1, double v1, double u2, double v2, double eps)
=> Math.Abs(u1 - u2) < eps && Math.Abs(v1 - v2) < eps;
}