@maplat/transform 0.4.1 → 0.5.1

package/src/map-transform.ts

@@ -0,0 +1,473 @@
+import type { Feature, Polygon } from "geojson";
+import { booleanPointInPolygon, point, polygon } from "@turf/turf";
+import { Transform } from "./transform.ts";
+import { zoom2Radius, mercViewpoint2Mercs, mercs2MercViewpoint } from "./viewpoint.ts";
+import { xy2SysCoord, sysCoord2Xy } from "./coord-utils.ts";
+import type { MapData, Viewpoint } from "./types.ts";
+
+/** Internal representation of a loaded sub-map TIN entry */
+interface SubTinEntry {
+  tin: Transform;
+  priority: number;
+  importance: number;
+  xyBounds: Feature<Polygon>;
+  mercBounds: Feature<Polygon>;
+}
+
+/** Tile size constant (same as MaplatCore) */
+const TILE_SIZE = 256;
+
+/**
+ * MapTransform — 処理2・3・4を担う座標変換クラス
+ *
+ * - 処理2: submaps 属性を持つ地図で、複数 TIN のうちどれを適用するか判定・選択し座標変換
+ * - 処理3: ビューポート ↔ メルカトル5点 変換
+ * - 処理4: ビューポート ↔ TIN 適用後メルカトル5点 変換
+ *
+ * OpenLayers への依存ゼロ。ブラウザ・Node.js 両対応。
+ */
+export class MapTransform {
+  private mainTin: Transform | null = null;
+  private subTins: SubTinEntry[] = [];
+  private _maxxy = 0;
+
+  // ─── 初期化 ────────────────────────────────────────────────────────────────
+
+  /**
+   * 地図データ（コンパイル済み TIN + sub_maps）をロードする
+   *
+   * @param mapData - メイン TIN と sub_maps の情報
+   */
+  setMapData(mapData: MapData): void {
+    // メイン TIN を構築
+    const mainTin = new Transform();
+    mainTin.setCompiled(mapData.compiled);
+    this.mainTin = mainTin;
+
+    // _maxxy を計算
+    // 優先順位: MapData.maxZoom > compiled.wh からの自動計算
+    if (mapData.maxZoom !== undefined) {
+      this._maxxy = Math.pow(2, mapData.maxZoom) * TILE_SIZE;
+    } else if (mapData.compiled.wh) {
+      const maxDim = Math.max(mapData.compiled.wh[0], mapData.compiled.wh[1]);
+      const maxZoom = Math.ceil(Math.log2(maxDim / TILE_SIZE));
+      this._maxxy = Math.pow(2, maxZoom) * TILE_SIZE;
+    }
+
+    // sub_maps を構築
+    this.subTins = [];
+    if (mapData.sub_maps) {
+      for (const subMapData of mapData.sub_maps) {
+        const tin = new Transform();
+        tin.setCompiled(subMapData.compiled);
+
+        // bounds: SubMapData.bounds を優先し、なければ compiled.bounds を使用
+        const rawBounds: number[][] | undefined =
+          subMapData.bounds ?? subMapData.compiled.bounds;
+        if (!rawBounds) {
+          throw new Error(
+            "SubMapData must have bounds or compiled.bounds to create xyBounds polygon"
+          );
+        }
+
+        const xyBoundsCoords = [...rawBounds, rawBounds[0]];
+        const mercBoundsCoords = xyBoundsCoords.map(xy => {
+          const merc = tin.transform(xy, false);
+          if (!merc) throw new Error("Failed to transform sub-map bounds to mercator");
+          return merc;
+        });
+
+        this.subTins.push({
+          tin,
+          priority: subMapData.priority,
+          importance: subMapData.importance,
+          xyBounds: polygon([xyBoundsCoords]) as Feature<Polygon>,
+          mercBounds: polygon([mercBoundsCoords]) as Feature<Polygon>
+        });
+      }
+    }
+  }
+
+  // ─── 処理2: submap TIN 選択付き変換 ───────────────────────────────────────
+
+  /**
+   * ピクセル座標 → メルカトル座標（最適レイヤー選択）
+   *
+   * @param xy - ピクセル座標 [x, y]
+   * @returns メルカトル座標、または範囲外の場合は false
+   */
+  xy2Merc(xy: number[]): number[] | false {
+    const result = this.xy2MercWithLayer(xy);
+    if (!result) return false;
+    return result[1];
+  }
+
+  /**
+   * メルカトル座標 → ピクセル座標（最適レイヤー選択）
+   *
+   * @param merc - メルカトル座標 [x, y]
+   * @returns ピクセル座標、または範囲外の場合は false
+   */
+  merc2Xy(merc: number[]): number[] | false {
+    const results = this.merc2XyWithLayer(merc);
+    const first = results[0] || results[1];
+    if (!first) return false;
+    return first[1];
+  }
+
+  /**
+   * ピクセル座標 → メルカトル座標（レイヤーID付き）
+   * histmap_tin.ts xy2MercAsync_returnLayer() の同期版
+   *
+   * @param xy - ピクセル座標 [x, y]
+   * @returns [レイヤーインデックス, メルカトル座標] または false
+   */
+  xy2MercWithLayer(xy: number[]): [number, number[]] | false {
+    this._assertMapData();
+
+    // priority 降順にソート（index 0 はメイン TIN）
+    const tinSorted = this._getTinsSortedByPriority();
+
+    for (let i = 0; i < tinSorted.length; i++) {
+      const { index, isMain } = tinSorted[i];
+
+      // メイン TIN（index 0）は常にマッチ、sub TIN はポリゴン内チェック
+      if (isMain || booleanPointInPolygon(point(xy), this.subTins[index - 1].xyBounds)) {
+        const merc = this._transformByIndex(xy, index, false);
+        if (merc === false) continue;
+        return [index, merc];
+      }
+    }
+    return false;
+  }
+
+  /**
+   * メルカトル座標 → ピクセル座標（複数レイヤー結果）
+   * histmap_tin.ts merc2XyAsync_returnLayer() の同期版
+   *
+   * 現在は MaplatCore の仕様に合わせ、最大2レイヤーまで返す。
+   * 3レイヤー以上返したい場合は、下記の .slice(0, 2) および .filter(i < 2) の
+   * 上限値を増やすか、引数で上限を指定できるようにすること。
+   *
+   * @param merc - メルカトル座標 [x, y]
+   * @returns 最大2要素の配列。各要素は [レイヤーインデックス, ピクセル座標] または undefined
+   */
+  merc2XyWithLayer(merc: number[]): ([number, number[]] | undefined)[] {
+    this._assertMapData();
+
+    // 全 TIN で逆変換を実行し、各結果が xyBounds 内かを確認
+    const allTins = this._getAllTinsWithIndex();
+    const rawResults: ([Transform, number, number[]] | [Transform, number])[] =
+      allTins.map(({ index, tin, isMain }) => {
+        const xy = this._transformByIndex(merc, index, true);
+        if (xy === false) return [tin, index] as [Transform, number];
+        // メイン TIN（index 0）は常に有効、sub TIN はポリゴン内チェック
+        if (isMain || booleanPointInPolygon(point(xy), this.subTins[index - 1].xyBounds)) {
+          return [tin, index, xy] as [Transform, number, number[]];
+        }
+        return [tin, index] as [Transform, number];
+      });
+
+    // priority 降順でソート
+    const sorted = rawResults.sort((a, b) => {
+      const priA = a[0].priority ?? 0;
+      const priB = b[0].priority ?? 0;
+      return priA < priB ? 1 : -1;
+    });
+
+    // importance と優先度で最大2レイヤーを選択
+    const result = sorted.reduce(
+      (
+        ret: (undefined | [number, number[], Transform])[],
+        current,
+        priIndex,
+        arry
+      ) => {
+        const tin = current[0];
+        const index = current[1];
+        const xy = current[2] as number[] | undefined;
+        if (!xy) return ret;
+
+        // より高優先レイヤーの xyBounds 内にあるか確認
+        for (let i = 0; i < priIndex; i++) {
+          const targetIndex = arry[i][1];
+          const isTargetMain = targetIndex === 0;
+          // 高優先 TIN が変換失敗している場合はスキップ
+          if (!arry[i][2]) continue;
+          if (
+            isTargetMain ||
+            booleanPointInPolygon(point(xy), this.subTins[targetIndex - 1].xyBounds)
+          ) {
+            if (ret.length) {
+              const hide = !ret[0];
+              const storedTin = hide ? ret[1]![2] : ret[0]![2];
+              const tinImportance = tin.importance ?? 0;
+              const storedImportance = storedTin.importance ?? 0;
+              if (!hide) {
+                // visible な stored TIN が既に存在 → current を 2番目要素として追加
+                const visible = ret.filter(
+                  (r): r is [number, number[], Transform] => r !== undefined
+                );
+                const newRet = [...visible, [index, xy, tin] as [number, number[], Transform]];
+                return newRet
+                  .sort((a, b) =>
+                    (a[2].importance ?? 0) < (b[2].importance ?? 0) ? 1 : -1
+                  )
+                  .slice(0, 2) as (undefined | [number, number[], Transform])[]; // 上限を増やす場合はここも変更
+              } else if (tinImportance < storedImportance) {
+                return ret;
+              } else {
+                return [undefined, [index, xy, tin]] as (undefined | [number, number[], Transform])[];
+              }
+            } else {
+              // ret が空なのに xyBounds 内 → 高優先 TIN が変換失敗しているだけ → visible として追加
+              return [[index, xy, tin]] as (undefined | [number, number[], Transform])[];
+            }
+          }
+        }
+
+        if (!ret.length || !ret[0]) {
+          return [[index, xy, tin]] as (undefined | [number, number[], Transform])[];
+        } else {
+          ret.push([index, xy, tin]);
+          return ret
+            .sort((a, b) => {
+              const impA = a![2].importance ?? 0;
+              const impB = b![2].importance ?? 0;
+              return impA < impB ? 1 : -1;
+            })
+            .filter((_row, i) => i < 2); // 上限を増やす場合はここも変更（例: i < 3）
+        }
+      },
+      []
+    );
+
+    return result.map(row => {
+      if (!row) return undefined;
+      return [row[0], row[1]] as [number, number[]];
+    });
+  }
+
+  /**
+   * メルカトル5点 → システム座標（複数レイヤー）
+   * histmap_tin.ts mercs2SysCoordsAsync_multiLayer() の同期版
+   *
+   * @param mercs - 5点のメルカトル座標配列（中心＋上下左右）
+   * @returns 各レイヤーのシステム座標配列（または undefined）
+   */
+  mercs2SysCoords(mercs: number[][]): (number[][] | undefined)[] {
+    this._assertMapData();
+    const centerResults = this.merc2XyWithLayer(mercs[0]);
+
+    let hide = false;
+    return centerResults.map((result, i) => {
+      if (!result) {
+        hide = true;
+        return undefined;
+      }
+      const index = result[0];
+      const centerXy = result[1];
+
+      if (i !== 0 && !hide) return [this.xy2SysCoordInternal(centerXy)];
+
+      const xys = mercs.map((merc, j) => {
+        if (j === 0) return centerXy;
+        return this._transformByIndex(merc, index, true) as number[];
+      });
+      return xys.map(xy => this.xy2SysCoordInternal(xy));
+    });
+  }
+
+  // ─── 処理3: ビューポート変換 ───────────────────────────────────────────────
+
+  /**
+   * ビューポート → TIN 適用後メルカトル5点
+   * histmap_tin.ts viewpoint2MercsAsync() の同期版
+   *
+   * @param viewpoint - ビューポート（center, zoom, rotation）
+   * @param size - 画面サイズ [width, height]
+   * @returns TIN 変換後のメルカトル5点
+   */
+  viewpoint2Mercs(viewpoint: Viewpoint, size: [number, number]): number[][] {
+    this._assertMapData();
+    this._assertMaxxy();
+
+    // ビューポート → メルカトル5点（処理3の純粋関数）
+    const mercs = mercViewpoint2Mercs(viewpoint.center, viewpoint.zoom, viewpoint.rotation, size);
+
+    // メルカトル → ピクセル座標（sysCoord2Xy）
+    const xys = mercs.map(merc => sysCoord2Xy(merc, this._maxxy));
+
+    // ピクセル中心 → TIN 変換 → メルカトル中心
+    const centerResult = this.xy2MercWithLayer(xys[0]);
+    if (!centerResult) throw new Error("viewpoint2Mercs: center point is out of bounds");
+
+    const centerIndex = centerResult[0];
+    const centerMerc = centerResult[1];
+
+    // 残り4点を同じレイヤーで変換
+    const resultMercs: number[][] = xys.map((xy, i) => {
+      if (i === 0) return centerMerc;
+      const merc = this._transformByIndex(xy, centerIndex, false);
+      if (merc === false) throw new Error(`viewpoint2Mercs: point ${i} is out of bounds`);
+      return merc;
+    });
+
+    return resultMercs;
+  }
+
+  /**
+   * TIN 適用後メルカトル5点 → ビューポート
+   * histmap_tin.ts mercs2ViewpointAsync() の同期版
+   *
+   * @param mercs - TIN 変換後のメルカトル5点
+   * @param size - 画面サイズ [width, height]
+   * @returns ビューポート（center, zoom, rotation）
+   */
+  mercs2Viewpoint(mercs: number[][], size: [number, number]): Viewpoint {
+    this._assertMapData();
+    this._assertMaxxy();
+
+    // メルカトル中心 → TIN 逆変換 → ピクセル中心
+    const centerResults = this.merc2XyWithLayer(mercs[0]);
+    const result = centerResults[0] || centerResults[1];
+    if (!result) throw new Error("mercs2Viewpoint: center point is out of bounds");
+
+    const centerIndex = result[0];
+    const centerXy = result[1];
+
+    // 残り4点を同じレイヤーで TIN 逆変換
+    const xys: number[][] = mercs.map((merc, i) => {
+      if (i === 0) return centerXy;
+      const xy = this._transformByIndex(merc, centerIndex, true);
+      if (xy === false) throw new Error(`mercs2Viewpoint: point ${i} is out of bounds`);
+      return xy;
+    });
+
+    // ピクセル → システム座標（xy2SysCoord）
+    const sysCoords = xys.map(xy => xy2SysCoord(xy, this._maxxy));
+
+    // システム座標5点 → ビューポート（mercs2MercViewpoint）
+    return mercs2MercViewpoint(sysCoords, size);
+  }
+
+  // ─── ユーティリティ（静的メソッド）────────────────────────────────────────
+
+  /** zoom2Radius の静的ラッパー */
+  static zoom2Radius(size: [number, number], zoom: number): number {
+    return zoom2Radius(size, zoom);
+  }
+
+  /** mercViewpoint2Mercs の静的ラッパー */
+  static mercViewpoint2Mercs(
+    center: number[],
+    zoom: number,
+    rotation: number,
+    size: [number, number]
+  ): number[][] {
+    return mercViewpoint2Mercs(center, zoom, rotation, size);
+  }
+
+  /** mercs2MercViewpoint の静的ラッパー */
+  static mercs2MercViewpoint(mercs: number[][], size: [number, number]): Viewpoint {
+    return mercs2MercViewpoint(mercs, size);
+  }
+
+  /** xy2SysCoord の静的ラッパー */
+  static xy2SysCoord(xy: number[], maxxy: number): number[] {
+    return xy2SysCoord(xy, maxxy);
+  }
+
+  /** sysCoord2Xy の静的ラッパー */
+  static sysCoord2Xy(sysCoord: number[], maxxy: number): number[] {
+    return sysCoord2Xy(sysCoord, maxxy);
+  }
+
+  // ─── 内部ヘルパー ──────────────────────────────────────────────────────────
+
+  private _assertMapData(): void {
+    if (!this.mainTin) {
+      throw new Error("setMapData() must be called before transformation");
+    }
+  }
+
+  private _assertMaxxy(): void {
+    if (this._maxxy === 0) {
+      throw new Error(
+        "MapData.maxZoom or compiled.wh must be set for viewpoint conversion (xy2SysCoord / sysCoord2Xy)"
+      );
+    }
+  }
+
+  /**
+   * レイヤーインデックスに対応する Transform インスタンスを返す（三角網描画などの用途）
+   *
+   * @param idx - 0 = メイン TIN、1以上 = sub_maps[idx-1]
+   * @returns 対応する Transform、または範囲外の場合は null
+   */
+  getLayerTransform(idx: number): Transform | null {
+    if (idx === 0) return this.mainTin;
+    const sub = this.subTins[idx - 1];
+    return sub ? sub.tin : null;
+  }
+
+  /** レイヤー数を返す（メイン + sub 数） */
+  get layerCount(): number {
+    return 1 + this.subTins.length;
+  }
+
+  /**
+   * viewpoint 変換に使用する最大ピクセル幅（2^maxZoom × 256）
+   * stateToViewpoint / viewpointToState で zoom ↔ scale 変換に使用する
+   * zoom = log2(scale × maxxy / 256) の関係
+   */
+  get maxxy(): number {
+    return this._maxxy;
+  }
+
+  /** priority 降順でソートした [index, tin, isMain] の配列を返す */
+  private _getTinsSortedByPriority(): { index: number; tin: Transform; isMain: boolean }[] {
+    const all = this._getAllTinsWithIndex();
+    return all.sort((a, b) => {
+      const priA = a.tin.priority ?? 0;
+      const priB = b.tin.priority ?? 0;
+      return priA < priB ? 1 : -1;
+    });
+  }
+
+  /** メイン TIN + 全 sub TIN を index 付きで返す */
+  private _getAllTinsWithIndex(): { index: number; tin: Transform; isMain: boolean }[] {
+    const result: { index: number; tin: Transform; isMain: boolean }[] = [
+      { index: 0, tin: this.mainTin!, isMain: true }
+    ];
+    this.subTins.forEach((entry, i) => {
+      // priority/importance を Transform インスタンスに反映（ソート・比較に使用）
+      entry.tin.priority = entry.priority;
+      entry.tin.importance = entry.importance;
+      result.push({ index: i + 1, tin: entry.tin, isMain: false });
+    });
+    return result;
+  }
+
+  /**
+   * 指定レイヤーインデックスで TIN 変換を実行する
+   * index 0 → mainTin, index 1..n → subTins[index-1]
+   */
+  private _transformByIndex(
+    coord: number[],
+    index: number,
+    backward: boolean
+  ): number[] | false {
+    if (index === 0) {
+      return this.mainTin!.transform(coord, backward);
+    }
+    const subEntry = this.subTins[index - 1];
+    if (!subEntry) return false;
+    return subEntry.tin.transform(coord, backward, true);
+  }
+
+  /** 内部用 xy2SysCoord（_maxxy を使用） */
+  private xy2SysCoordInternal(xy: number[]): number[] {
+    return xy2SysCoord(xy, this._maxxy);
+  }
+}