@antv/l7-layers 2.25.7 → 2.25.10

package/es/utils/grid-index.js

@@ -0,0 +1,128 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+/**
+ * 网格索引，相比 @mapbox/grid-index，在简单计算碰撞检测结果时效率更高
+ * @see https://zhuanlan.zhihu.com/p/74373214
+ */
+class GridIndex {
+  constructor(width, height, cellSize) {
+    _defineProperty(this, "boxCells", []);
+    _defineProperty(this, "xCellCount", void 0);
+    _defineProperty(this, "yCellCount", void 0);
+    _defineProperty(this, "boxKeys", void 0);
+    _defineProperty(this, "bboxes", void 0);
+    _defineProperty(this, "width", void 0);
+    _defineProperty(this, "height", void 0);
+    _defineProperty(this, "xScale", void 0);
+    _defineProperty(this, "yScale", void 0);
+    _defineProperty(this, "boxUid", void 0);
+    const boxCells = this.boxCells;
+    this.xCellCount = Math.ceil(width / cellSize);
+    this.yCellCount = Math.ceil(height / cellSize);
+    for (let i = 0; i < this.xCellCount * this.yCellCount; i++) {
+      boxCells.push([]);
+    }
+    this.boxKeys = [];
+    this.bboxes = [];
+    this.width = width;
+    this.height = height;
+    this.xScale = this.xCellCount / width;
+    this.yScale = this.yCellCount / height;
+    this.boxUid = 0;
+  }
+  insert(key, x1, y1, x2, y2) {
+    this.forEachCell(x1, y1, x2, y2, this.insertBoxCell, this.boxUid++);
+    this.boxKeys.push(key);
+    this.bboxes.push(x1);
+    this.bboxes.push(y1);
+    this.bboxes.push(x2);
+    this.bboxes.push(y2);
+  }
+  query(x1, y1, x2, y2, predicate) {
+    return this.queryHitTest(x1, y1, x2, y2, false, predicate);
+  }
+  hitTest(x1, y1, x2, y2, predicate) {
+    return this.queryHitTest(x1, y1, x2, y2, true, predicate);
+  }
+  insertBoxCell(x1, y1, x2, y2, cellIndex, uid) {
+    this.boxCells[cellIndex].push(uid);
+  }
+  queryHitTest(x1, y1, x2, y2, hitTest, predicate) {
+    if (x2 < 0 || x1 > this.width || y2 < 0 || y1 > this.height) {
+      return hitTest ? false : [];
+    }
+    const result = [];
+    if (x1 <= 0 && y1 <= 0 && this.width <= x2 && this.height <= y2) {
+      // 这一步是高效的关键，后续精确碰撞检测结果在计算文本可见性时并不需要
+      if (hitTest) {
+        return true;
+      }
+      for (let boxUid = 0; boxUid < this.boxKeys.length; boxUid++) {
+        result.push({
+          key: this.boxKeys[boxUid],
+          x1: this.bboxes[boxUid * 4],
+          y1: this.bboxes[boxUid * 4 + 1],
+          x2: this.bboxes[boxUid * 4 + 2],
+          y2: this.bboxes[boxUid * 4 + 3]
+        });
+      }
+      return predicate ? result.filter(predicate) : result;
+    }
+    const queryArgs = {
+      hitTest,
+      seenUids: {
+        box: {},
+        circle: {}
+      }
+    };
+    this.forEachCell(x1, y1, x2, y2, this.queryCell, result, queryArgs, predicate);
+    return hitTest ? result.length > 0 : result;
+  }
+  queryCell(x1, y1, x2, y2, cellIndex, result, queryArgs, predicate) {
+    const seenUids = queryArgs.seenUids;
+    const boxCell = this.boxCells[cellIndex];
+    if (boxCell !== null) {
+      const bboxes = this.bboxes;
+      for (const boxUid of boxCell) {
+        if (!seenUids.box[boxUid]) {
+          seenUids.box[boxUid] = true;
+          const offset = boxUid * 4;
+          if (x1 <= bboxes[offset + 2] && y1 <= bboxes[offset + 3] && x2 >= bboxes[offset + 0] && y2 >= bboxes[offset + 1] && (!predicate || predicate(this.boxKeys[boxUid]))) {
+            if (queryArgs.hitTest) {
+              result.push(true);
+              return true;
+            }
+            result.push({
+              key: this.boxKeys[boxUid],
+              x1: bboxes[offset],
+              y1: bboxes[offset + 1],
+              x2: bboxes[offset + 2],
+              y2: bboxes[offset + 3]
+            });
+          }
+        }
+      }
+    }
+    return false;
+  }
+  forEachCell(x1, y1, x2, y2, fn, arg1, arg2, predicate) {
+    const cx1 = this.convertToXCellCoord(x1);
+    const cy1 = this.convertToYCellCoord(y1);
+    const cx2 = this.convertToXCellCoord(x2);
+    const cy2 = this.convertToYCellCoord(y2);
+    for (let x = cx1; x <= cx2; x++) {
+      for (let y = cy1; y <= cy2; y++) {
+        const cellIndex = this.xCellCount * y + x;
+        if (fn.call(this, x1, y1, x2, y2, cellIndex, arg1, arg2, predicate)) {
+          return;
+        }
+      }
+    }
+  }
+  convertToXCellCoord(x) {
+    return Math.max(0, Math.min(this.xCellCount - 1, Math.floor(x * this.xScale)));
+  }
+  convertToYCellCoord(y) {
+    return Math.max(0, Math.min(this.yCellCount - 1, Math.floor(y * this.yScale)));
+  }
+}
+export default GridIndex;

package/es/utils/identityScale.d.ts

@@ -0,0 +1,8 @@
+export default function identity(d: any): {
+    (x: any): any;
+    invert: any;
+    domain: (v?: any) => any;
+    range(v?: any): any;
+    unknown(v: any): any;
+    copy(): any;
+};

package/es/utils/identityScale.js

@@ -0,0 +1,26 @@
+export default function identity(d) {
+  let unknown;
+  let domain = [];
+  function scale(x) {
+    return x == null ? unknown : x;
+  }
+  scale.invert = scale;
+  scale.domain = scale.range = v => {
+    if (v) {
+      domain = v;
+      return v;
+    }
+    return domain;
+  };
+  scale.unknown = v => {
+    if (v) {
+      unknown = v;
+      return v;
+    }
+    return unknown;
+  };
+  scale.copy = () => {
+    return identity(d).unknown(unknown);
+  };
+  return scale;
+}

package/es/utils/load-image.d.ts

@@ -0,0 +1 @@
+export declare function loadImage(url: string): Promise<HTMLImageElement | ImageBitmap>;

package/es/utils/load-image.js

@@ -0,0 +1,22 @@
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+export function loadImage(_x) {
+  return _loadImage.apply(this, arguments);
+}
+function _loadImage() {
+  _loadImage = _asyncToGenerator(function* (url) {
+    // @ts-ignore
+    if (window.createImageBitmap) {
+      const response = yield fetch(url);
+      const imageBitmap = yield createImageBitmap(yield response.blob());
+      return imageBitmap;
+    } else {
+      const image = new window.Image();
+      return new Promise(res => {
+        image.onload = () => res(image);
+        image.src = url;
+        image.crossOrigin = 'Anonymous';
+      });
+    }
+  });
+  return _loadImage.apply(this, arguments);
+}

package/es/utils/multiPassRender.d.ts

@@ -0,0 +1,16 @@
+import type { ILayer, IPass, IPostProcessingPass } from '@antv/l7-core';
+/**
+ * 'blurH' -> ['blurH', {}]
+ */
+export declare function normalizePasses(passes: Array<string | [string, {
+    [key: string]: unknown;
+}]>): [string, {
+    [key: string]: unknown;
+}][];
+/**
+ * 默认添加 ClearPass、RenderPass
+ * 以及 PostProcessing 中的最后一个 CopyPass
+ */
+export declare function createMultiPassRenderer(layer: ILayer, passes: Array<string | [string, {
+    [key: string]: unknown;
+}]>, postProcessingPassFactory: (name: string) => IPostProcessingPass<unknown>, normalPassFactory: (name: string) => IPass<unknown>): import("@antv/l7-core").IMultiPassRenderer;

package/es/utils/multiPassRender.js

@@ -0,0 +1,37 @@
+/**
+ * 'blurH' -> ['blurH', {}]
+ */
+export function normalizePasses(passes) {
+  return passes.map(pass => {
+    if (typeof pass === 'string') {
+      pass = [pass, {}];
+    }
+    return pass;
+  });
+}
+
+/**
+ * 默认添加 ClearPass、RenderPass
+ * 以及 PostProcessing 中的最后一个 CopyPass
+ */
+export function createMultiPassRenderer(layer, passes, postProcessingPassFactory, normalPassFactory) {
+  const multiPassRenderer = layer.multiPassRenderer;
+
+  // picking pass if enabled
+  // if (enablePicking) {
+  //   multiPassRenderer.add(normalPassFactory('pixelPicking'));
+  // }
+
+  // render all layers in this pass
+  multiPassRenderer.add(normalPassFactory('render'));
+
+  // post processing
+  normalizePasses(passes).forEach(pass => {
+    const [passName, initializationOptions] = pass;
+    multiPassRenderer.add(postProcessingPassFactory(passName), initializationOptions);
+  });
+
+  // 末尾为固定的 CopyPass
+  multiPassRenderer.add(postProcessingPassFactory('copy'));
+  return multiPassRenderer;
+}

package/es/utils/polylineNormal.d.ts

@@ -0,0 +1,9 @@
+import { vec2 } from 'gl-matrix';
+export declare function computeMiter(tangent: vec2, miter: vec2, lineA: vec2, lineB: vec2, halfThick: number): number;
+export declare function computeNormal(out: vec2, dir: vec2): vec2;
+export declare function direction(out: vec2, a: [number, number], b: [number, number]): vec2;
+export default function (points: number[][], closed: boolean, indexOffset: number, isDash?: boolean): {
+    normals: number[];
+    attrIndex: number[];
+    attrPos: number[];
+};

package/es/utils/polylineNormal.js

@@ -0,0 +1,182 @@
+import { aProjectFlat } from '@antv/l7-utils';
+import { vec2 } from 'gl-matrix';
+export function computeMiter(tangent, miter, lineA, lineB, halfThick) {
+  vec2.add(tangent, lineA, lineB);
+  vec2.normalize(tangent, tangent);
+  miter = vec2.fromValues(-tangent[1], tangent[0]);
+  const tmp = vec2.fromValues(-lineA[1], lineA[0]);
+  return halfThick / vec2.dot(miter, tmp);
+}
+export function computeNormal(out, dir) {
+  return vec2.set(out, -dir[1], dir[0]);
+}
+export function direction(out, a, b) {
+  // const a1 = aProjectFlat([a[0], a[1]]) as [number, number];
+  // const b1 = aProjectFlat([b[0], b[1]]) as [number, number];
+  vec2.sub(out, a, b);
+  vec2.normalize(out, out);
+  return out;
+}
+function extrusions(positions, out, miters, point, normal, scale) {
+  addNext(out, miters, normal, -scale);
+  addNext(out, miters, normal, scale);
+  positions.push(point[0], point[1], 0);
+  positions.push(point[0], point[1], 0);
+}
+function addNext(out, miters, normal, length) {
+  out.push(normal[0], normal[1], 0);
+  miters.push(length);
+}
+function lineSegmentDistance(b1, a1) {
+  const dx = a1[0] - b1[0];
+  const dy = a1[1] - b1[1];
+  return Math.sqrt(dx * dx + dy * dy);
+}
+function isPointEqual(a, b) {
+  return a[0] === b[0] && a[1] === b[1];
+}
+export default function (points, closed, indexOffset, isDash = true) {
+  const lineA = vec2.fromValues(0, 0);
+  const lineB = vec2.fromValues(0, 0);
+  const tangent = vec2.fromValues(0, 0);
+  const miter = vec2.create();
+  let started = false;
+  let lineNormal = null;
+  const tmp = vec2.create();
+  let count = indexOffset || 0;
+  const miterLimit = 4;
+  const out = [];
+  const attrPos = [];
+  const attrIndex = [];
+  const miters = [];
+  const attrDistance = [0, 0];
+  if (closed) {
+    points = points.slice();
+    points.push(points[0]);
+  }
+  const total = points.length;
+  for (let i = 1; i < total; i++) {
+    const index = count;
+    const last = vec2.fromValues(points[i - 1][0], points[i - 1][1]);
+    const cur = vec2.fromValues(points[i][0], points[i][1]);
+    let next = i < points.length - 1 ? vec2.fromValues(points[i + 1][0], points[i + 1][1]) : null;
+    // 如果当前点和前一点相同，跳过
+    if (isPointEqual(last, cur)) {
+      continue;
+    }
+    if (next) {
+      let nextIndex = i + 1;
+      // 找到不相同的下一点
+      while (next && isPointEqual(cur, next)) {
+        next = nextIndex < points.length - 1 ? vec2.fromValues(points[++nextIndex][0], points[nextIndex][1]) : null;
+      }
+    }
+    let d = 0;
+    const flatCur = aProjectFlat([cur[0], cur[1]]);
+    const flatLast = aProjectFlat([last[0], last[1]]);
+    if (isDash) {
+      const lineDistance = lineSegmentDistance(flatCur, flatLast);
+      d = lineDistance + attrDistance[attrDistance.length - 1];
+    }
+    direction(lineA, flatCur, flatLast);
+    if (!lineNormal) {
+      lineNormal = vec2.create();
+      computeNormal(lineNormal, lineA);
+    }
+    if (!started) {
+      started = true;
+      extrusions(attrPos, out, miters, last, lineNormal, 1);
+    }
+    attrIndex.push(index + 0, index + 2, index + 1);
+
+    // no miter, simple segment
+    if (!next) {
+      // reset normal
+      computeNormal(lineNormal, lineA);
+      extrusions(attrPos, out, miters, cur, lineNormal, 1);
+      attrDistance.push(d, d);
+      attrIndex.push(index + 1, index + 2, index + 3);
+      count += 2;
+    } else {
+      const flatNext = aProjectFlat([next[0], next[1]]);
+      // get unit dir of next line
+      direction(lineB, flatNext, flatCur);
+
+      // stores tangent & miter
+      let miterLen = computeMiter(tangent, vec2.fromValues(miter[0], miter[1]), lineA, lineB, 1);
+
+      // get orientation
+      const flip = vec2.dot(tangent, lineNormal) < 0 ? -1 : 1;
+      const bevel = Math.abs(miterLen) > miterLimit;
+
+      // 处理前后两条线段重合的情况，这种情况不需要使用任何接头（miter/bevel）。
+      // 理论上这种情况下 miterLen = Infinity，本应通过 isFinite(miterLen) 判断，
+      // 但是 AMap 投影变换后丢失精度，只能通过一个阈值（1000）判断。
+
+      if (Math.abs(miterLen) > 1000) {
+        extrusions(attrPos, out, miters, cur, lineNormal, 1);
+        attrIndex.push(index + 1, index + 2, index + 3);
+        attrIndex.push(index + 2, index + 4, index + 3);
+        computeNormal(tmp, lineB);
+        vec2.copy(lineNormal, tmp); // store normal for next round
+
+        extrusions(attrPos, out, miters, cur, lineNormal, 1);
+        attrDistance.push(d, d, d, d);
+
+        // the miter is now the normal for our next join
+        count += 4;
+        continue;
+      }
+      if (bevel) {
+        miterLen = miterLimit;
+
+        // next two points in our first segment
+        extrusions(attrPos, out, miters, cur, lineNormal, 1);
+        attrIndex.push(index + 1, index + 2, index + 3);
+
+        // now add the bevel triangle
+        attrIndex.push(...(flip === 1 ? [index + 2, index + 4, index + 5] : [index + 4, index + 5, index + 3]));
+        computeNormal(tmp, lineB);
+        vec2.copy(lineNormal, tmp); // store normal for next round
+
+        extrusions(attrPos, out, miters, cur, lineNormal, 1);
+        attrDistance.push(d, d, d, d);
+
+        // the miter is now the normal for our next join
+        count += 4;
+      } else {
+        // next two points in our first segment
+        extrusions(attrPos, out, miters, cur, lineNormal, 1);
+        attrIndex.push(index + 1, index + 2, index + 3);
+
+        // now add the miter triangles
+        addNext(out, miters, lineNormal, miterLen * -flip);
+        attrPos.push(cur[0], cur[1], 0);
+        attrIndex.push(index + 2, index + 4, index + 3);
+        attrIndex.push(index + 4, index + 5, index + 6);
+        computeNormal(tmp, lineB);
+        vec2.copy(lineNormal, tmp); // store normal for next round
+
+        extrusions(attrPos, out, miters, cur, lineNormal, 1);
+        attrDistance.push(d, d, d, d, d);
+
+        // the miter is now the normal for our next join
+        count += 5;
+      }
+    }
+  }
+  const pickData = [];
+  for (let i = 0; i < miters.length; i++) {
+    const totalDistance = attrDistance[attrDistance.length - 1];
+    pickData.push(attrPos[i * 3], attrPos[i * 3 + 1], attrPos[i * 3 + 2], attrDistance[i],
+    // dash
+    miters[i], totalDistance // dash
+    );
+  }
+  return {
+    normals: out,
+    attrIndex,
+    attrPos: pickData // [x,y,z, distance, miter ,t0tal ]
+  };
+}
+// [x,y,z, distance, miter ]

package/es/utils/rampcolor_legend.d.ts

@@ -0,0 +1,6 @@
+import type { ILegend, ScaleTypeName } from '@antv/l7-core';
+export declare function rampColor2legend(rampColors: {
+    type: ScaleTypeName;
+    colors: string[];
+    positions: number[];
+}, name: string): ILegend;

package/es/utils/rampcolor_legend.js

@@ -0,0 +1,12 @@
+export function rampColor2legend(rampColors, name) {
+  return {
+    type: rampColors.type,
+    field: 'value',
+    items: rampColors.positions.map((value, index) => {
+      return {
+        [name]: index >= rampColors.colors.length ? null : rampColors.colors[index],
+        value
+      };
+    })
+  };
+}

package/es/utils/scale.d.ts

@@ -0,0 +1,87 @@
+/**
+ * 比例尺工具
+ * 用于替代 d3-scale 的功能
+ */
+export interface ScaleLinear {
+    (x: number): number;
+    domain(): number[];
+    domain(domain: number[]): ScaleLinear;
+    range(): number[];
+    range(range: number[]): ScaleLinear;
+    invert(y: number): number;
+    ticks(count?: number): number[];
+    nice(count?: number): ScaleLinear;
+    clamp(): boolean;
+    clamp(clamp: boolean): ScaleLinear;
+}
+export declare function scaleLinear(): ScaleLinear;
+export interface ScalePow extends ScaleLinear {
+    exponent(): number;
+    exponent(k: number): ScalePow;
+}
+export declare function scalePow(): ScalePow;
+export interface ScaleLog extends ScaleLinear {
+    base(): number;
+    base(b: number): ScaleLog;
+}
+export declare function scaleLog(): ScaleLog;
+export interface ScaleOrdinal<T = any> {
+    (x: any): T;
+    domain(): any[];
+    domain(domain: any[]): ScaleOrdinal<T>;
+    range(): T[];
+    range(range: T[]): ScaleOrdinal<T>;
+    unknown(value: T): ScaleOrdinal<T>;
+}
+export declare function scaleOrdinal<T = any>(range?: T[]): ScaleOrdinal<T>;
+export interface ScaleQuantize {
+    (x: number): any;
+    domain(): number[];
+    domain(domain: number[]): ScaleQuantize;
+    range(): any[];
+    range(range: any[]): ScaleQuantize;
+    invertExtent(y: any): [number, number];
+}
+export declare function scaleQuantize(): ScaleQuantize;
+export interface ScaleQuantile {
+    (x: number): any;
+    domain(): number[];
+    domain(domain: number[]): ScaleQuantile;
+    range(): any[];
+    range(range: any[]): ScaleQuantile;
+    invertExtent(y: any): [number, number];
+    quantiles(): number[];
+}
+export declare function scaleQuantile(): ScaleQuantile;
+export interface ScaleThreshold {
+    (x: number): any;
+    domain(): number[];
+    domain(domain: number[]): ScaleThreshold;
+    range(): any[];
+    range(range: any[]): ScaleThreshold;
+    invertExtent(y: any): [number | undefined, number | undefined];
+}
+export declare function scaleThreshold(): ScaleThreshold;
+export interface ScaleSequential {
+    (x: number): any;
+    domain(): number[];
+    domain(domain: number[]): ScaleSequential;
+    interpolator(): (t: number) => any;
+    interpolator(interpolator: (t: number) => any): ScaleSequential;
+    clamp(): boolean;
+    clamp(clamp: boolean): ScaleSequential;
+}
+export declare function scaleSequential(): ScaleSequential;
+export interface ScaleDiverging {
+    (x: number): any;
+    domain(): number[];
+    domain(domain: number[]): ScaleDiverging;
+    interpolator(): (t: number) => any;
+    interpolator(interpolator: (t: number) => any): ScaleDiverging;
+    clamp(): boolean;
+    clamp(clamp: boolean): ScaleDiverging;
+}
+export declare function scaleDiverging(): ScaleDiverging;
+export interface ScaleTime extends ScaleLinear {
+}
+export declare function scaleTime(): ScaleTime;