@antv/l7-layers 2.25.7 → 2.25.9

package/lib/utils/scale.js

@@ -0,0 +1,610 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.scaleDiverging = scaleDiverging;
+exports.scaleLinear = scaleLinear;
+exports.scaleLog = scaleLog;
+exports.scaleOrdinal = scaleOrdinal;
+exports.scalePow = scalePow;
+exports.scaleQuantile = scaleQuantile;
+exports.scaleQuantize = scaleQuantize;
+exports.scaleSequential = scaleSequential;
+exports.scaleThreshold = scaleThreshold;
+exports.scaleTime = scaleTime;
+/**
+ * 比例尺工具
+ * 用于替代 d3-scale 的功能
+ */
+
+// ==================== 工具函数 ====================
+
+function bisect(a, x, lo = 0, hi = a.length) {
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (a[mid] < x) lo = mid + 1;else hi = mid;
+  }
+  return lo;
+}
+function tickIncrement(start, stop, count) {
+  if (start === stop) return 0;
+  const d = stop - start;
+  const step = Math.pow(10, Math.floor(Math.log(d / count) / Math.LN10));
+  const err = count / d * step;
+  if (err <= 0.15) return step * 10;
+  if (err <= 0.35) return step * 5;
+  if (err <= 0.75) return step * 2;
+  return step;
+}
+function tickStep(start, stop, count) {
+  if (start === stop) return 1;
+  const d = stop - start;
+  const step0 = Math.abs(d) / Math.max(1, count);
+  let step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10));
+  const error = step0 / step1;
+  if (error >= 10) step1 *= 10;else if (error >= 5) step1 *= 5;else if (error >= 2) step1 *= 2;
+  return d < 0 ? -step1 : step1;
+}
+
+// 处理 domain 中的无效值
+function sanitizeDomain(d) {
+  const filtered = d.filter(v => v != null && !Number.isNaN(v) && typeof v === 'number');
+  if (filtered.length === 0) {
+    return [0, 1];
+  } else if (filtered.length === 1) {
+    return [filtered[0], filtered[0]];
+  }
+  return filtered;
+}
+
+// ==================== Linear Scale ====================
+
+function scaleLinear() {
+  let domain = [0, 1];
+  let range = [0, 1];
+  let _clamp = false;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+
+    // 处理相等的 domain - 返回 range 中值，避免所有值映射到最小值
+    if (d0 === d1) {
+      return (r0 + r1) / 2;
+    }
+    let t = (x - d0) / (d1 - d0);
+    if (_clamp) t = Math.max(0, Math.min(1, t));
+    return r0 + t * (r1 - r0);
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    domain = sanitizeDomain(d);
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return range.slice();
+    range = r.slice();
+    return scale;
+  };
+  scale.invert = function (y) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+    return d0 + (y - r0) / (r1 - r0) * (d1 - d0);
+  };
+  scale.ticks = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return [d0];
+    const step = tickStep(d0, d1, count);
+    const ticks = [];
+    let i = Math.floor(d0 / step);
+    const maxI = Math.ceil(d1 / step);
+    while (i <= maxI) {
+      ticks.push(i * step);
+      i++;
+    }
+    return ticks;
+  };
+  scale.nice = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return scale;
+    const step = tickIncrement(d0, d1, count);
+    if (step > 0) {
+      domain = [Math.floor(d0 / step) * step, Math.ceil(d1 / step) * step];
+    }
+    return scale;
+  };
+  scale.clamp = function (c) {
+    if (c === undefined) return _clamp;
+    _clamp = c;
+    return scale;
+  };
+  return scale;
+}
+
+// ==================== Power Scale ====================
+
+function scalePow() {
+  let domain = [0, 1];
+  let range = [0, 1];
+  let _clamp = false;
+  let _exponent = 1;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+
+    // 处理相等的 domain - 返回 range 中值，避免所有值映射到最小值
+    if (d0 === d1) {
+      return (r0 + r1) / 2;
+    }
+    let t = (x - d0) / (d1 - d0);
+    if (_clamp) t = Math.max(0, Math.min(1, t));
+    t = Math.pow(t, _exponent);
+    return r0 + t * (r1 - r0);
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    domain = sanitizeDomain(d);
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return range.slice();
+    range = r.slice();
+    return scale;
+  };
+  scale.invert = function (y) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+    let t = (y - r0) / (r1 - r0);
+    t = Math.pow(t, 1 / _exponent);
+    return d0 + t * (d1 - d0);
+  };
+  scale.ticks = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return [d0];
+    const step = tickStep(d0, d1, count);
+    const ticks = [];
+    let i = Math.floor(d0 / step);
+    const maxI = Math.ceil(d1 / step);
+    while (i <= maxI) {
+      ticks.push(i * step);
+      i++;
+    }
+    return ticks;
+  };
+  scale.nice = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return scale;
+    const step = tickIncrement(d0, d1, count);
+    if (step > 0) {
+      domain = [Math.floor(d0 / step) * step, Math.ceil(d1 / step) * step];
+    }
+    return scale;
+  };
+  scale.clamp = function (c) {
+    if (c === undefined) return _clamp;
+    _clamp = c;
+    return scale;
+  };
+  scale.exponent = function (k) {
+    if (k === undefined) return _exponent;
+    _exponent = k;
+    return scale;
+  };
+  return scale;
+}
+
+// ==================== Log Scale ====================
+
+function log(x, base) {
+  return Math.log(x) / Math.log(base);
+}
+function pow(x, base) {
+  return Math.pow(base, x);
+}
+function scaleLog() {
+  let domain = [1, 10];
+  let range = [0, 1];
+  let _clamp = false;
+  let _base = 10;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+
+    // 处理相等的 domain - 返回 range 中值，避免所有值映射到最小值
+    if (d0 === d1) {
+      return (r0 + r1) / 2;
+    }
+    const absD0 = Math.abs(d0) || 1;
+    const absD1 = Math.abs(d1) || 1;
+    const absX = Math.abs(x) || 1;
+    let t = (log(absX, _base) - log(absD0, _base)) / (log(absD1, _base) - log(absD0, _base));
+    if (_clamp) t = Math.max(0, Math.min(1, t));
+    return r0 + t * (r1 - r0);
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    const sanitized = sanitizeDomain(d);
+    // log scale 需要 正数domain
+    domain = sanitized.map(v => v <= 0 ? 1 : v);
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return range.slice();
+    range = r.slice();
+    return scale;
+  };
+  scale.invert = function (y) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+    const t = (y - r0) / (r1 - r0);
+    const absD0 = Math.abs(d0) || 1;
+    const absD1 = Math.abs(d1) || 1;
+    return pow(log(absD0, _base) + t * (log(absD1, _base) - log(absD0, _base)), _base);
+  };
+  scale.ticks = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return [d0];
+    const ticks = [];
+    const startPow = Math.floor(log(Math.abs(d0) || 1, _base));
+    const endPow = Math.ceil(log(Math.abs(d1) || 1, _base));
+    for (let i = startPow; i <= endPow; i++) {
+      ticks.push(pow(i, _base));
+    }
+    return ticks;
+  };
+  scale.nice = function () {
+    return scale;
+  };
+  scale.clamp = function (c) {
+    if (c === undefined) return _clamp;
+    _clamp = c;
+    return scale;
+  };
+  scale.base = function (b) {
+    if (b === undefined) return _base;
+    _base = b;
+    return scale;
+  };
+  return scale;
+}
+
+// ==================== Ordinal Scale ====================
+
+function scaleOrdinal(range) {
+  let domain = [];
+  let _range = range || [];
+  let _unknown;
+  const index = new Map();
+  function scale(x) {
+    let i = index.get(x);
+    if (i === undefined) {
+      if (_unknown !== undefined) return _unknown;
+      if (_range.length === 0) return undefined;
+      i = domain.push(x) - 1;
+      index.set(x, i);
+    }
+    return _range[i % _range.length];
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    domain = [];
+    index.clear();
+    d.forEach(x => {
+      if (!index.has(x)) {
+        index.set(x, domain.length);
+        domain.push(x);
+      }
+    });
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return _range.slice();
+    _range = r.slice();
+    return scale;
+  };
+  scale.unknown = function (value) {
+    _unknown = value;
+    return scale;
+  };
+  return scale;
+}
+
+// ==================== Quantize Scale ====================
+
+function scaleQuantize() {
+  let domain = [0, 1];
+  let _range = [0, 1];
+  let n = 1;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    // 处理相等的 domain - 返回 range 中值，避免所有值映射到最小值
+    if (d0 === d1) {
+      return _range[Math.floor(_range.length / 2)];
+    }
+    const t = (x - d0) / (d1 - d0);
+    const i = Math.max(0, Math.min(n - 1, Math.floor(t * n)));
+    return _range[i];
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    domain = sanitizeDomain(d);
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return _range.slice();
+    _range = r.slice();
+    n = Math.max(1, _range.length);
+    return scale;
+  };
+  scale.invertExtent = function (y) {
+    const i = _range.indexOf(y);
+    if (i < 0) return [NaN, NaN];
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const step = (d1 - d0) / n;
+    return [d0 + i * step, d0 + (i + 1) * step];
+  };
+  return scale;
+}
+
+// ==================== Quantile Scale ====================
+
+function scaleQuantile() {
+  let _domain = [];
+  let _range = [0, 1];
+  let thresholds = [];
+  function scale(x) {
+    if (isNaN(x)) return _range[0];
+    const i = bisect(thresholds, x);
+    return _range[i];
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return _domain.slice();
+    _domain = d.filter(x => x != null && !isNaN(x) && typeof x === 'number').sort((a, b) => a - b);
+    rescale();
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return _range.slice();
+    _range = r.slice();
+    rescale();
+    return scale;
+  };
+  scale.invertExtent = function (y) {
+    const i = _range.indexOf(y);
+    if (i < 0) return [NaN, NaN];
+    const n = _range.length;
+    return i > 0 ? [thresholds[i - 1], thresholds[i]] : [_domain[0], thresholds[0]];
+  };
+  scale.quantiles = function () {
+    return thresholds.slice();
+  };
+  function rescale() {
+    const n = _range.length;
+    const m = _domain.length;
+    if (m === 0 || n === 0) {
+      thresholds = [];
+      return;
+    }
+    thresholds = [];
+    for (let i = 1; i < n; i++) {
+      const q = i / n;
+      const index = (m - 1) * q;
+      const lower = Math.floor(index);
+      const upper = Math.ceil(index);
+      const weight = index - lower;
+      if (upper >= m) {
+        thresholds.push(_domain[m - 1]);
+      } else {
+        thresholds.push(_domain[lower] * (1 - weight) + _domain[upper] * weight);
+      }
+    }
+  }
+  return scale;
+}
+
+// ==================== Threshold Scale ====================
+
+function scaleThreshold() {
+  let _domain = [0.5];
+  let _range = [0, 1];
+  function scale(x) {
+    const i = bisect(_domain, x);
+    return _range[i];
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return _domain.slice();
+    _domain = d.filter(v => v != null && !isNaN(v) && typeof v === 'number');
+    if (_domain.length === 0) {
+      _domain = [0.5];
+    }
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return _range.slice();
+    _range = r.slice();
+    return scale;
+  };
+  scale.invertExtent = function (y) {
+    const i = _range.indexOf(y);
+    return [i > 0 ? _domain[i - 1] : undefined, i < _domain.length ? _domain[i] : undefined];
+  };
+  return scale;
+}
+
+// ==================== Sequential Scale ====================
+
+function scaleSequential() {
+  let domain = [0, 1];
+  let _interpolator = t => t;
+  let _clamp = false;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) {
+      return _interpolator(0.5);
+    }
+    let t = (x - d0) / (d1 - d0);
+    if (_clamp) t = Math.max(0, Math.min(1, t));
+    return _interpolator(t);
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    domain = sanitizeDomain(d);
+    return scale;
+  };
+  scale.interpolator = function (i) {
+    if (i === undefined) return _interpolator;
+    _interpolator = i;
+    return scale;
+  };
+  scale.clamp = function (c) {
+    if (c === undefined) return _clamp;
+    _clamp = c;
+    return scale;
+  };
+  return scale;
+}
+
+// ==================== Diverging Scale ====================
+
+function scaleDiverging() {
+  let domain = [0, 0.5, 1];
+  let _interpolator = t => t;
+  let _clamp = false;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[1];
+    const d2 = domain[2];
+    let t;
+    if (x < d1) {
+      if (d0 === d1) {
+        return _interpolator(0.5);
+      }
+      t = (x - d0) / (d1 - d0);
+      t = _clamp ? Math.max(0, t) : t;
+      return _interpolator(0.5 - t * 0.5);
+    } else {
+      if (d1 === d2) {
+        return _interpolator(0.5);
+      }
+      t = (x - d1) / (d2 - d1);
+      t = _clamp ? Math.min(1, t) : t;
+      return _interpolator(0.5 + t * 0.5);
+    }
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    // diverging scale 需要 3 个值
+    const sanitized = d.filter(v => v != null && !isNaN(v) && typeof v === 'number');
+    if (sanitized.length >= 3) {
+      domain = [sanitized[0], sanitized[1], sanitized[2]];
+    } else if (sanitized.length === 2) {
+      const mid = (sanitized[0] + sanitized[1]) / 2;
+      domain = [sanitized[0], mid, sanitized[1]];
+    } else if (sanitized.length === 1) {
+      domain = [sanitized[1], sanitized[0], sanitized[0] + 1];
+    } else {
+      domain = [0, 0.5, 1];
+    }
+    return scale;
+  };
+  scale.interpolator = function (i) {
+    if (i === undefined) return _interpolator;
+    _interpolator = i;
+    return scale;
+  };
+  scale.clamp = function (c) {
+    if (c === undefined) return _clamp;
+    _clamp = c;
+    return scale;
+  };
+  return scale;
+}
+
+// ==================== Time Scale ====================
+
+function scaleTime() {
+  let domain = [0, 1];
+  let range = [0, 1];
+  let _clamp = false;
+  function scale(x) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+
+    // 处理相等的 domain - 返回 range 中值，避免所有值映射到最小值
+    if (d0 === d1) {
+      return (r0 + r1) / 2;
+    }
+    let t = (x - d0) / (d1 - d0);
+    if (_clamp) t = Math.max(0, Math.min(1, t));
+    return r0 + t * (r1 - r0);
+  }
+  scale.domain = function (d) {
+    if (d === undefined) return domain.slice();
+    domain = sanitizeDomain(d);
+    return scale;
+  };
+  scale.range = function (r) {
+    if (r === undefined) return range.slice();
+    range = r.slice();
+    return scale;
+  };
+  scale.invert = function (y) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    const r0 = range[0];
+    const r1 = range[range.length - 1];
+    return d0 + (y - r0) / (r1 - r0) * (d1 - d0);
+  };
+  scale.ticks = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return [d0];
+    const step = tickStep(d0, d1, count);
+    const ticks = [];
+    let i = Math.floor(d0 / step);
+    const maxI = Math.ceil(d1 / step);
+    while (i <= maxI) {
+      ticks.push(i * step);
+      i++;
+    }
+    return ticks;
+  };
+  scale.nice = function (count = 10) {
+    const d0 = domain[0];
+    const d1 = domain[domain.length - 1];
+    if (d0 === d1) return scale;
+    const step = tickIncrement(d0, d1, count);
+    if (step > 0) {
+      domain = [Math.floor(d0 / step) * step, Math.ceil(d1 / step) * step];
+    }
+    return scale;
+  };
+  scale.clamp = function (c) {
+    if (c === undefined) return _clamp;
+    _clamp = c;
+    return scale;
+  };
+  return scale;
+}

package/lib/utils/simpleLine.d.ts

@@ -0,0 +1,23 @@
+import { vec2 } from 'gl-matrix';
+export declare function direction(out: vec2, a: vec2, b: vec2): vec2;
+export default class ExtrudePolyline {
+    complex: {
+        positions: number[];
+        indices: number[];
+        startIndex: number;
+        indexes: number[];
+    };
+    private started;
+    private totalDistance;
+    private currentIndex;
+    constructor();
+    simpleExtrude(points: number[][]): {
+        positions: number[];
+        indices: number[];
+        startIndex: number;
+        indexes: number[];
+    };
+    private simpleSegment;
+    private extrusions;
+    private lineSegmentDistance;
+}

package/lib/utils/simpleLine.js

@@ -0,0 +1,85 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+exports.direction = direction;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _l7Utils = require("@antv/l7-utils");
+var _glMatrix = require("gl-matrix");
+const lineA = _glMatrix.vec2.create();
+function direction(out, a, b) {
+  _glMatrix.vec2.sub(out, a, b);
+  _glMatrix.vec2.normalize(out, out);
+  return out;
+}
+class ExtrudePolyline {
+  constructor() {
+    (0, _defineProperty2.default)(this, "complex", void 0);
+    (0, _defineProperty2.default)(this, "started", false);
+    (0, _defineProperty2.default)(this, "totalDistance", 0);
+    (0, _defineProperty2.default)(this, "currentIndex", 0);
+    this.complex = {
+      positions: [],
+      indices: [],
+      startIndex: 0,
+      indexes: []
+    };
+  }
+  simpleExtrude(points) {
+    const complex = this.complex;
+    if (points.length <= 1) {
+      return complex;
+    }
+    this.started = false;
+    this.totalDistance = 0;
+    const total = points.length;
+    let count = complex.startIndex;
+    for (let i = 1; i < total; i++) {
+      const last = points[i - 1];
+      const cur = points[i];
+      const amt = this.simpleSegment(complex, count, last, cur);
+      count += amt;
+    }
+    for (let i = 0; i < complex.positions.length / 6; i++) {
+      complex.positions[i * 6 + 5] = this.totalDistance;
+    }
+    return complex;
+  }
+  simpleSegment(complex, index, last, cur) {
+    let count = 0;
+    const indices = complex.indices;
+    const positions = complex.positions;
+    const flatCur = (0, _l7Utils.aProjectFlat)([cur[0], cur[1]]);
+    const flatLast = (0, _l7Utils.aProjectFlat)([last[0], last[1]]);
+    direction(lineA, flatCur, flatLast);
+    const segmentDistance = this.lineSegmentDistance(flatCur, flatLast);
+    this.totalDistance += segmentDistance;
+    if (!this.started) {
+      this.started = true;
+      this.extrusions(positions, last, this.totalDistance - segmentDistance);
+    }
+    this.extrusions(positions, cur, this.totalDistance);
+    indices.push(index + 0, index + 1, index + 2);
+    indices.push(index + 2, index + 1, index + 3);
+    count += 2;
+    return count;
+  }
+  extrusions(positions, point,
+  // 顶点
+  distanceRadio) {
+    positions.push(point[0], point[1], point[2] | 0, distanceRadio, 0, point[2] | 0);
+    this.complex.indexes.push(this.currentIndex);
+    positions.push(point[0], point[1], point[2] | 0, distanceRadio, 0, point[2] | 0);
+    this.complex.indexes.push(this.currentIndex);
+    this.currentIndex++;
+  }
+  lineSegmentDistance(b1, a1) {
+    const dx = a1[0] - b1[0];
+    const dy = a1[1] - b1[1];
+    return Math.sqrt(dx * dx + dy * dy);
+  }
+}
+exports.default = ExtrudePolyline;