@buley/hexgrid-3d 1.0.0

package/src/algorithms/FlowField.ts

@@ -0,0 +1,126 @@
+import { Vector2 } from '../math/Vector3';
+
+export interface FlowFieldConfig {
+  width: number;
+  height: number;
+  resolution: number;
+}
+
+export interface Streamline {
+  points: Vector2[];
+}
+
+interface Source {
+  x: number;
+  y: number;
+  vx: number;
+  vy: number;
+  strength: number;
+}
+
+export class FlowField2D {
+  private config: FlowFieldConfig;
+  private sources: Source[] = [];
+
+  constructor(config: FlowFieldConfig) {
+    this.config = config;
+  }
+
+  clear(): void {
+    this.sources = [];
+  }
+
+  addSource(x: number, y: number, vx: number, vy: number, strength: number): void {
+    this.sources.push({ x, y, vx, vy, strength });
+  }
+
+  update(_deltaTime: number): void {
+    // No-op for stub
+  }
+
+  sample(x: number, y: number): Vector2 {
+    if (this.sources.length === 0) {
+      return new Vector2(0, 0);
+    }
+    let vx = 0;
+    let vy = 0;
+    for (const source of this.sources) {
+      const dx = x - source.x;
+      const dy = y - source.y;
+      const distance = Math.hypot(dx, dy) || 1;
+      const influence = source.strength / distance;
+      vx += source.vx * influence;
+      vy += source.vy * influence;
+    }
+    return new Vector2(vx, vy);
+  }
+
+  sampleFull(x: number, y: number): { velocity: Vector2; divergence: number; curl: number } {
+    const velocity = this.sample(x, y);
+    return {
+      velocity,
+      divergence: velocity.x * 0.01,
+      curl: velocity.y * 0.01,
+    };
+  }
+
+  traceStreamline(x: number, y: number, options: { maxLength: number; stepSize: number; maxSteps: number }): Streamline {
+    const points: Vector2[] = [new Vector2(x, y)];
+    let current = new Vector2(x, y);
+    for (let i = 0; i < options.maxSteps; i++) {
+      const velocity = this.sample(current.x, current.y);
+      const next = new Vector2(
+        current.x + velocity.x * options.stepSize,
+        current.y + velocity.y * options.stepSize
+      );
+      points.push(next);
+      current = next;
+      if (points.length * options.stepSize >= options.maxLength) {
+        break;
+      }
+    }
+    return { points };
+  }
+}
+
+export class InfectionFlowAnalyzer {
+  private width: number;
+  private height: number;
+
+  constructor(width: number, height: number) {
+    this.width = width;
+    this.height = height;
+  }
+
+  getFlowData(
+    _infections: Map<number, unknown>,
+    _positions: Array<{ x: number; y: number }>
+  ): Array<{ centroid: Vector2; velocity: Vector2 }> {
+    return [];
+  }
+}
+
+export class HeatMap {
+  private width: number;
+  private height: number;
+  private resolution: number;
+  private data: Float32Array;
+
+  constructor(config: { width: number; height: number; resolution: number; kernelRadius: number }) {
+    this.width = Math.max(1, Math.round(config.width / config.resolution));
+    this.height = Math.max(1, Math.round(config.height / config.resolution));
+    this.resolution = config.resolution;
+    this.data = new Float32Array(this.width * this.height);
+  }
+
+  addPoint(x: number, y: number, value: number): void {
+    const gridX = Math.min(this.width - 1, Math.max(0, Math.floor(x / this.resolution)));
+    const gridY = Math.min(this.height - 1, Math.max(0, Math.floor(y / this.resolution)));
+    const index = gridY * this.width + gridX;
+    this.data[index] += value;
+  }
+
+  getData(): Float32Array {
+    return this.data;
+  }
+}

package/src/algorithms/FluidSimulation.ts

@@ -0,0 +1,99 @@
+export interface FluidConfig {
+  width: number;
+  height: number;
+  viscosity: number;
+  diffusion: number;
+}
+
+export class StableFluids {
+  private width: number;
+  private height: number;
+  private density: Float32Array;
+  private velocityX: Float32Array;
+  private velocityY: Float32Array;
+
+  constructor(config: FluidConfig) {
+    this.width = Math.max(1, Math.round(config.width));
+    this.height = Math.max(1, Math.round(config.height));
+    const size = this.width * this.height;
+    this.density = new Float32Array(size);
+    this.velocityX = new Float32Array(size);
+    this.velocityY = new Float32Array(size);
+  }
+
+  addDensity(x: number, y: number, amount: number, radius: number): void {
+    const index = this.indexFor(x, y);
+    this.density[index] += amount;
+  }
+
+  addForce(x: number, y: number, vx: number, vy: number, _radius: number): void {
+    const index = this.indexFor(x, y);
+    this.velocityX[index] += vx;
+    this.velocityY[index] += vy;
+  }
+
+  step(_deltaTime: number): void {
+    // Simple damping
+    for (let i = 0; i < this.velocityX.length; i++) {
+      this.velocityX[i] *= 0.98;
+      this.velocityY[i] *= 0.98;
+    }
+  }
+
+  getDensity(x: number, y: number): number {
+    return this.density[this.indexFor(x, y)] || 0;
+  }
+
+  getVelocity(x: number, y: number): { x: number; y: number } {
+    const index = this.indexFor(x, y);
+    return { x: this.velocityX[index] || 0, y: this.velocityY[index] || 0 };
+  }
+
+  getDensityField(): Float32Array {
+    return this.density;
+  }
+
+  getVelocityField(): { x: Float32Array; y: Float32Array } {
+    return { x: this.velocityX, y: this.velocityY };
+  }
+
+  clear(): void {
+    this.density.fill(0);
+    this.velocityX.fill(0);
+    this.velocityY.fill(0);
+  }
+
+  private indexFor(x: number, y: number): number {
+    const ix = Math.min(this.width - 1, Math.max(0, Math.floor(x)));
+    const iy = Math.min(this.height - 1, Math.max(0, Math.floor(y)));
+    return iy * this.width + ix;
+  }
+}
+
+export class LatticeBoltzmann {
+  constructor(_width: number, _height: number) {}
+}
+
+export class InfectionFluidSimulator {
+  private fluid: StableFluids;
+
+  constructor(width: number, height: number) {
+    this.fluid = new StableFluids({ width, height, viscosity: 0, diffusion: 0 });
+  }
+
+  registerTerritory(_ownerId: number, x: number, y: number, intensity: number): void {
+    this.fluid.addDensity(x, y, intensity, 1);
+  }
+
+  update(deltaTime: number): void {
+    this.fluid.step(deltaTime);
+  }
+
+  getFluid(): StableFluids {
+    return this.fluid;
+  }
+
+  clear(): void {
+    this.fluid.clear();
+  }
+}

package/src/algorithms/GraphAlgorithms.ts

@@ -0,0 +1,184 @@
+export interface Cluster {
+  centroid: number[];
+  members: number[];
+  cohesion: number;
+  separation: number;
+}
+
+export interface VoronoiCell {
+  siteIndex: number;
+  site: [number, number];
+  vertices: Array<[number, number]>;
+  neighbors: number[];
+}
+
+export interface VoronoiDiagram {
+  cells: VoronoiCell[];
+  vertices: Array<[number, number]>;
+  edges: Array<[[number, number], [number, number]]>;
+}
+
+export function kMeansClustering(points: number[][], k: number): Cluster[] {
+  if (points.length === 0 || k <= 0) return [];
+  const clusters: Cluster[] = Array.from({ length: k }, () => ({
+    centroid: new Array(points[0]?.length || 0).fill(0),
+    members: [],
+    cohesion: 0,
+    separation: 0,
+  }));
+
+  points.forEach((_point, index) => {
+    clusters[index % k].members.push(index);
+  });
+
+  for (const cluster of clusters) {
+    if (cluster.members.length === 0) continue;
+    const centroid = cluster.centroid.map((_, dim) => {
+      const sum = cluster.members.reduce(
+        (acc, memberIdx) => acc + (points[memberIdx]?.[dim] ?? 0),
+        0
+      );
+      return sum / cluster.members.length;
+    });
+    cluster.centroid = centroid;
+    cluster.cohesion = cluster.members.reduce((sum, idx) => {
+      const point = points[idx];
+      const distance = Math.sqrt(
+        centroid.reduce((acc, value, dim) => {
+          const diff = value - (point?.[dim] ?? 0);
+          return acc + diff * diff;
+        }, 0)
+      );
+      return sum + distance;
+    }, 0) / cluster.members.length;
+  }
+
+  return clusters;
+}
+
+export function dbscan(
+  points: number[][],
+  _eps: number,
+  _minPoints: number
+): Cluster[] {
+  if (points.length === 0) return [];
+  return kMeansClustering(points, Math.min(1, points.length));
+}
+
+export function computeVoronoi(
+  sites: Array<[number, number]>,
+  bounds: { minX: number; maxX: number; minY: number; maxY: number }
+): VoronoiDiagram {
+  const vertices: Array<[number, number]> = [
+    [bounds.minX, bounds.minY],
+    [bounds.maxX, bounds.minY],
+    [bounds.maxX, bounds.maxY],
+    [bounds.minX, bounds.maxY],
+  ];
+
+  const cells: VoronoiCell[] = sites.map((site, index) => ({
+    siteIndex: index,
+    site,
+    vertices,
+    neighbors: sites.map((_s, i) => i).filter((i) => i !== index),
+  }));
+
+  const edges: Array<[[number, number], [number, number]]> = [];
+  for (let i = 0; i < vertices.length; i++) {
+    const start = vertices[i];
+    const end = vertices[(i + 1) % vertices.length];
+    edges.push([start, end]);
+  }
+
+  return { cells, vertices, edges };
+}
+
+export function analyzeTerritorBoundaries(
+  infections: Map<number, { photoId: string }>,
+  neighbors: number[][]
+): {
+  frontLength: Map<string, number>;
+  hotspots: number[];
+} {
+  const frontLength = new Map<string, number>();
+  const hotspots: number[] = [];
+
+  infections.forEach((value, idx) => {
+    const neighborList = neighbors[idx] ?? [];
+    const different = neighborList.filter(
+      (neighborIdx) => infections.get(neighborIdx)?.photoId !== value.photoId
+    );
+    if (different.length > 0) {
+      hotspots.push(idx);
+    }
+    const current = frontLength.get(value.photoId) ?? 0;
+    frontLength.set(value.photoId, current + different.length);
+  });
+
+  return { frontLength, hotspots };
+}
+
+export function kMeansClustering2D(points: Array<[number, number]>, k: number): Cluster[] {
+  const asPoints = points.map((p) => [p[0], p[1]]);
+  return kMeansClustering(asPoints, k);
+}
+
+export function findConnectedComponents(graph: { nodes: number[]; edges: Map<number, number[]> }): number[][] {
+  const visited = new Set<number>();
+  const components: number[][] = [];
+
+  for (const node of graph.nodes) {
+    if (visited.has(node)) continue;
+    const stack = [node];
+    const component: number[] = [];
+
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (current === undefined || visited.has(current)) continue;
+      visited.add(current);
+      component.push(current);
+      const neighbors = graph.edges.get(current) ?? [];
+      for (const neighbor of neighbors) {
+        if (!visited.has(neighbor)) {
+          stack.push(neighbor);
+        }
+      }
+    }
+
+    components.push(component);
+  }
+
+  return components;
+}
+
+export function louvainCommunities(graph: {
+  nodes: number[];
+  edges: Map<number, number[]>;
+  weights?: Map<string, number>;
+}): Array<{ members: number[]; modularity: number }> {
+  const components = findConnectedComponents(graph);
+  return components.map((members) => ({
+    members,
+    modularity: members.length / Math.max(1, graph.nodes.length),
+  }));
+}
+
+export function computeVoronoiGraph(sites: Array<[number, number]>) {
+  return computeVoronoi(sites, {
+    minX: Math.min(...sites.map((s) => s[0])),
+    maxX: Math.max(...sites.map((s) => s[0])),
+    minY: Math.min(...sites.map((s) => s[1])),
+    maxY: Math.max(...sites.map((s) => s[1])),
+  });
+}
+
+export function kMeansCluster(points: number[][], k: number): Cluster[] {
+  return kMeansClustering(points, k);
+}
+
+export function kMeansClusteringWithLabels(
+  points: number[][],
+  k: number
+): Cluster[] {
+  return kMeansClustering(points, k);
+}