- 新增 LandformKind 与五套高度场生成器:穹状山峰、宽脊山脊、V 形山谷、双峰鞍部、台地陡崖 - 3D 视图重写:拖动旋转 / 滚轮缩放、按包围盒自动取景、法线光照、四周裙边侧壁、 切割步骤改为把高度压到切面得到真实截面并用求交线精确出线 - 四步实验动画(等高切割 → 形成交线 → 垂直投影 → 疏密判坡),俯视 / 立体切换 - 界面重排:地貌标签移到画布上方(WrapPanel,窄屏自动换行并隐藏侧栏), 右侧栏放实验流程 / 观察面板 / 判读要点;播放、重置、视图、上色、实时读数,空格与 1–5 快捷键、全屏 - 文案 90 个键中英双语;LoadTexts 改为「内置默认 + i18n 文件覆盖」,此前完全忽略语言包 - 修复三处渲染缺陷:Chain() 只向尾部延伸把等高线切成虚线;坡度归一化写死导致判坡整片红; 切割只是叠加半透明板而山尖仍在 - 清单版本 1.1 → 1.2,描述与 help.json 同步;62×62 面片 + 画刷缓存,1440×900 单帧约 35ms
708 lines
28 KiB
C#
708 lines
28 KiB
C#
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;
|
||
}
|