@antv/l7-layers 2.23.2 → 2.23.3-beta.1

package/es/utils/scale.js

@@ -0,0 +1,588 @@
+/**
+ * 比例尺工具
+ * 用于替代 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 ====================
+
+export 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
+    if (d0 === d1) {
+      return r0;
+    }
+    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 ====================
+
+export 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];
+    if (d0 === d1) {
+      return r0;
+    }
+    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);
+}
+export 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];
+    if (d0 === d1) {
+      return r0;
+    }
+    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 ====================
+
+export 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 ====================
+
+export 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];
+    if (d0 === d1) {
+      return _range[0];
+    }
+    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 ====================
+
+export 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 ====================
+
+export 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 ====================
+
+export 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 ====================
+
+export 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 ====================
+
+export 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];
+    if (d0 === d1) {
+      return r0;
+    }
+    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/{citybuliding → citybuilding}/models/build.js

@@ -62,8 +62,10 @@ class CityBuildModel extends _BaseModel.default {
     return commonBufferInfo;
   }
   calCityGeo() {
-    // @ts-ignore
-    const [minLng, minLat, maxLng, maxLat] = this.layer.getSource().extent;
+    // 当启用 enableRelativeCoordinates 时，使用 originalExtent（原始绝对坐标范围）
+    const originalExtent = this.layer.getOriginalExtent();
+    const extent = originalExtent[0] !== 0 || originalExtent[2] !== 0 ? originalExtent : this.layer.getSource().extent;
+    const [minLng, minLat, maxLng, maxLat] = extent;
     const w = maxLng - minLng;
     const h = maxLat - minLat;
     this.cityCenter = [(maxLng + minLng) / 2, (maxLat + minLat) / 2];

package/lib/core/BaseLayer.js

@@ -967,12 +967,12 @@ class BaseLayer extends _eventemitter.EventEmitter {
     return this.styleAttributeService.getLayerAttributeScale(name);
   }
   getLegend(name) {
-    var _attribute$scale, _scales$, _attribute$scale2;
+    var _attribute$scale, _scales$, _scales$2;
     const attribute = this.styleAttributeService.getLayerStyleAttribute(name);
     const scales = (attribute === null || attribute === void 0 || (_attribute$scale = attribute.scale) === null || _attribute$scale === void 0 ? void 0 : _attribute$scale.scalers) || [];
     return {
       type: (_scales$ = scales[0]) === null || _scales$ === void 0 || (_scales$ = _scales$.option) === null || _scales$ === void 0 ? void 0 : _scales$.type,
-      field: attribute === null || attribute === void 0 || (_attribute$scale2 = attribute.scale) === null || _attribute$scale2 === void 0 ? void 0 : _attribute$scale2.field,
+      field: (_scales$2 = scales[0]) === null || _scales$2 === void 0 ? void 0 : _scales$2.field,
       items: this.getLegendItems(name)
     };
   }
@@ -1216,7 +1216,7 @@ class BaseLayer extends _eventemitter.EventEmitter {
    * 继承空方法
    * @param time
    */
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+
   setEarthTime(time) {
     console.warn('empty fn');
   }

package/lib/core/LayerPickService.js

@@ -46,7 +46,9 @@ class BaseLayerPickService {
     const container = this.layer.getContainer();
     const pickingService = container.pickingService;
     const mapService = container.mapService;
-    const extent = this.layer.getSource().extent;
+    // 当启用 enableRelativeCoordinates 时，使用 originalExtent 判断绝对坐标是否在范围内
+    const originalExtent = this.layer.getOriginalExtent();
+    const extent = originalExtent[0] !== 0 || originalExtent[2] !== 0 ? originalExtent : this.layer.getSource().extent;
     const isPick = (0, _l7Utils.lngLatInExtent)(target.lngLat, extent);
     const layerTarget = {
       x: target.x,

package/lib/core/shape/Path.d.ts

@@ -18,8 +18,9 @@ export declare enum ShapeType2D {
  * 生成规则多边形顶点个数
  * @param pointCount  顶点个数 3 => 三角形
  * @param start 顶点起始角度 调整图形的方向
+ * @param angleOffset 额外的角度偏移，用于调整六边形方向
  */
-export declare function polygonPath(pointCount: number, start?: number): IPath;
+export declare function polygonPath(pointCount: number, start?: number, angleOffset?: number): IPath;
 export declare function circle(): IPath;
 export declare function square(): IPath;
 export declare function triangle(): IPath;

package/lib/core/shape/Path.js

@@ -31,16 +31,17 @@ let ShapeType2D = exports.ShapeType2D = /*#__PURE__*/function (ShapeType2D) {
  * 生成规则多边形顶点个数
  * @param pointCount  顶点个数 3 => 三角形
  * @param start 顶点起始角度 调整图形的方向
+ * @param angleOffset 额外的角度偏移，用于调整六边形方向
  */
-function polygonPath(pointCount, start = 0) {
+function polygonPath(pointCount, start = 0, angleOffset = Math.PI / 4) {
   const step = Math.PI * 2 / pointCount;
   const line = [];
   for (let i = 0; i < pointCount; i++) {
     line.push(step * i + start * Math.PI / 12);
   }
   const path = line.map(t => {
-    const x = Math.sin(t + Math.PI / 4);
-    const y = Math.cos(t + Math.PI / 4);
+    const x = Math.sin(t + angleOffset);
+    const y = Math.cos(t + angleOffset);
     return [x, y, 0];
   });
   // path.push(path[0]);
@@ -56,7 +57,12 @@ function triangle() {
   return polygonPath(3);
 }
 function hexagon() {
-  return polygonPath(6, 1);
+  // 生成 pointy-top 六边形（尖角朝上）
+  // 使用 angleOffset = 0 并翻转 y 方向，以匹配 d3-hexbin 的方向
+  // d3-hexbin 在屏幕坐标系中 y 向下为正，使用 y = -cos(angle)
+  // 我们需要翻转 y 坐标以确保蜂窝网格闭合
+  const path = polygonPath(6, 0, 0);
+  return path.map(p => [p[0], -p[1], p[2]]);
 }
 function pentagon() {
   return polygonPath(5);