@flowmap.gl/data 8.0.0-alpha.25 → 8.0.0-alpha.27

package/src/FlowmapSelectors.ts

@@ -1,19 +1,7 @@
 /*
- * Copyright 2022 FlowmapBlue
- * Copyright 2018-2020 Teralytics, modified by FlowmapBlue
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
  */
 
 import {ascending, descending, extent, min, rollup} from 'd3-array';
@@ -83,7 +71,10 @@ export type Selector<L, F, T> = ParametricSelector<
   T
 >;
 
-export default class FlowmapSelectors<L, F> {
+export default class FlowmapSelectors<
+  L extends Record<string, any>,
+  F extends Record<string, any>,
+> {
   accessors: FlowmapAggregateAccessors<L, F>;
 
   constructor(accessors: FlowmapDataAccessors<L, F>) {
@@ -737,14 +728,20 @@ export default class FlowmapSelectors<L, F> {
       if (!locations) {
         return undefined;
       }
-      return new KDBush(
-        // @ts-ignore
-        locations,
-        (location: L | ClusterNode) =>
-          lngX(this.accessors.getLocationLon(location)),
-        (location: L | ClusterNode) =>
-          latY(this.accessors.getLocationLat(location)),
-      );
+      const nodes = Array.isArray(locations)
+        ? locations
+        : Array.from(locations);
+      const bush = new KDBush(nodes.length, 64, Float32Array);
+      for (let i = 0; i < nodes.length; i++) {
+        const node = nodes[i];
+        bush.add(
+          lngX(this.accessors.getLocationLon(node)),
+          latY(this.accessors.getLocationLat(node)),
+        );
+      }
+      bush.finish();
+      bush.points = nodes;
+      return bush;
     },
   );
 

package/src/FlowmapState.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import {LocationFilterMode, ViewportProps} from './types';
 
 export interface FilterState {
@@ -10,6 +16,7 @@ export interface SettingsState {
   animationEnabled: boolean;
   fadeEnabled: boolean;
   fadeOpacityEnabled: boolean;
+  locationsEnabled: boolean;
   locationTotalsEnabled: boolean;
   locationLabelsEnabled: boolean;
   adaptiveScalesEnabled: boolean;

package/src/cluster/ClusterIndex.ts

@@ -1,19 +1,7 @@
 /*
- * Copyright 2022 FlowmapBlue
- * Copyright 2018-2020 Teralytics, modified by FlowmapBlue
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
  */
 
 import {

package/src/cluster/cluster.ts

@@ -1,46 +1,34 @@
 /*
- * Copyright 2022 FlowmapBlue
- * Copyright 2018-2020 Teralytics, modified by FlowmapBlue
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
  */
 
-/**
- * The code in this file is a based on https://github.com/mapbox/supercluster
- */
-
-// ISC License
-//
-// Copyright (c) 2016, Mapbox
-//
-// Permission to use, copy, modify, and/or distribute this software for any purpose
-// with or without fee is hereby granted, provided that the above copyright notice
-// and this permission notice appear in all copies.
-//
-// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-// FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
-// OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
-// TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
-// THIS SOFTWARE.
-
 import {min, rollup} from 'd3-array';
 import KDBush from 'kdbush';
 import {LocationWeightGetter} from './ClusterIndex';
 import {Cluster, ClusterLevel, ClusterNode, LocationAccessors} from '../types';
 
+/**
+ * The code in this file is a based on https://github.com/mapbox/supercluster
+ *
+ *  ISC License
+ *
+ *  Copyright (c) 2016, Mapbox
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any purpose
+ *  with or without fee is hereby granted, provided that the above copyright notice
+ *  and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ *  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
+ *  OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+ *  TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ *  THIS SOFTWARE.
+ */
+
 export interface Options {
   minZoom: number; // min zoom to generate clusters on
   maxZoom: number; // max zoom level to cluster the points on
@@ -126,9 +114,19 @@ export function clusterLocations<L>(
     locationsCount++;
   }
 
+  const makeBush = (points: Point<L>[]) => {
+    const bush = new KDBush(points.length, nodeSize, Float32Array);
+    for (let i = 0; i < points.length; i++) {
+      bush.add(points[i].x, points[i].y);
+    }
+    bush.finish();
+    bush.points = points;
+    return bush;
+  };
+
   // cluster points on max zoom, then cluster the results on previous zoom, etc.;
   // results in a cluster hierarchy across zoom levels
-  trees[maxZoom + 1] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);
+  trees[maxZoom + 1] = makeBush(clusters);
   let prevZoom = maxZoom + 1;
 
   for (let z = maxZoom; z >= minZoom; z--) {
@@ -144,7 +142,7 @@ export function clusterLocations<L>(
     } else {
       prevZoom = z;
       clusters = _clusters;
-      trees[z] = new KDBush(clusters, getX, getY, nodeSize, Float32Array);
+      trees[z] = makeBush(clusters);
     }
   }
 
@@ -152,21 +150,34 @@ export function clusterLocations<L>(
     return [];
   }
 
-  const numbersOfClusters = trees.map((d) => d?.points.length);
+  const numbersOfClusters: number[] = trees.map((d) => d?.points.length);
   const minClusters = min(numbersOfClusters.filter((d) => d > 0));
-  const maxClusters = getMaxNumberOfClusters(locations, locationAccessors);
-
-  let maxAvailZoom = numbersOfClusters.indexOf(maxClusters);
-  if (maxClusters < locationsCount) {
-    maxAvailZoom++;
-    if (maxAvailZoom < maxZoom + 1) {
-      trees[maxAvailZoom] = trees[maxZoom + 1];
-      trees[maxZoom + 1] = undefined;
+
+  let maxAvailZoom =
+    findIndexOfMax(numbersOfClusters) ?? numbersOfClusters.length - 1;
+
+  const numUniqueLocations = countUniqueLocations(locations, locationAccessors);
+  if (numUniqueLocations < locationsCount) {
+    // Duplicate locations would be clustered together at any zoom level which can lead to having too many zooms.
+    // To avoid that, we need to find the max zoom level that has less or equal clusters than unique locations
+    // and drop all zoom levels beyond that (except the unclustered level).
+    const maxClustersZoom = findLastIndex(
+      numbersOfClusters,
+      (d) => d <= numUniqueLocations,
+    );
+    if (maxClustersZoom >= 0) {
+      // Now, move the unclustered points to the next zoom level to avoid having a gap
+      if (maxClustersZoom < maxAvailZoom) {
+        trees[maxClustersZoom + 1] = trees[maxAvailZoom];
+        trees.splice(maxClustersZoom + 2); // Remove all zoom levels beyond maxClustersZoom
+      }
+      maxAvailZoom = maxClustersZoom + 1;
     }
   }
+
   const minAvailZoom = Math.min(
     maxAvailZoom,
-    numbersOfClusters.lastIndexOf(minClusters),
+    minClusters ? numbersOfClusters.lastIndexOf(minClusters) : maxAvailZoom,
   );
 
   const clusterLevels = new Array<ClusterLevel>();
@@ -175,8 +186,8 @@ export function clusterLocations<L>(
     let childrenByParent: Map<number, (string | number)[]> | undefined;
     const tree = trees[zoom];
     if (!tree) continue;
-    if (zoom < maxAvailZoom) {
-      childrenByParent = rollup<Point<L>, (string | number)[], number>(
+    if (trees[prevZoom] && zoom < maxAvailZoom) {
+      childrenByParent = rollup(
         trees[prevZoom].points,
         (points: any[]) =>
           points.map((p: any) =>
@@ -200,16 +211,19 @@ export function clusterLocations<L>(
         const {id} = point;
         const children = childrenByParent && childrenByParent.get(id);
         if (!children) {
-          throw new Error(`Cluster ${id} doesn't have children`);
+          // Might happen if there are multiple locations with same coordinates
+          console.warn(`Omitting cluster with no children, point:`, point);
+          continue;
         }
-        nodes.push({
+        const cluster = {
           id: makeClusterId(id),
           name: makeClusterName(id, numPoints),
           zoom,
           lat: yLat(y),
           lon: xLng(x),
-          children,
-        } as Cluster);
+          children: children ?? [],
+        } as Cluster;
+        nodes.push(cluster);
       }
     }
     clusterLevels.push({
@@ -329,32 +343,52 @@ function getY<L>(p: Point<L>) {
   return p.y;
 }
 
-/**
- * Finds groups of locations which share the same positions.
- * They will always be clustered together at any zoom level
- * which can lead to having too many zooms.
- */
-function getMaxNumberOfClusters<L>(
+function countUniqueLocations<L>(
   locations: Iterable<L>,
   locationAccessors: LocationAccessors<L>,
 ) {
   const {getLocationLon, getLocationLat} = locationAccessors;
   const countByLatLon = new Map<string, number>();
-  let numLocations = 0;
+  let uniqueCnt = 0;
   for (const loc of locations) {
     const lon = getLocationLon(loc);
     const lat = getLocationLat(loc);
     const key = `${lon},${lat}`;
     const prev = countByLatLon.get(key);
+    if (!prev) {
+      uniqueCnt++;
+    }
     countByLatLon.set(key, prev ? prev + 1 : 1);
-    numLocations++;
   }
+  return uniqueCnt;
+}
+
+function findIndexOfMax(arr: (number | undefined)[]): number | undefined {
+  let max = -Infinity;
+  let maxIndex: number | undefined = undefined;
+
+  for (let i = 0; i < arr.length; i++) {
+    const value = arr[i];
+
+    if (typeof value === 'number') {
+      if (value > max) {
+        max = value;
+        maxIndex = i;
+      }
+    }
+  }
+
+  return maxIndex;
+}
 
-  let numSame = 0;
-  for (const [key, count] of countByLatLon) {
-    if (count > 1) {
-      numSame++;
+function findLastIndex<T>(
+  arr: T[],
+  predicate: (value: T, index: number, array: T[]) => boolean,
+): number {
+  for (let i = arr.length - 1; i >= 0; i--) {
+    if (predicate(arr[i], i, arr)) {
+      return i;
     }
   }
-  return numLocations - numSame;
+  return -1;
 }

package/src/colors.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import {
   interpolateCool,
   interpolateInferno,

package/src/getViewStateForLocations.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import {geoBounds} from 'd3-geo';
 import {fitBounds} from '@math.gl/web-mercator';
 import type {

package/src/index.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 export * from './types';
 export * from './colors';
 export * from './FlowmapState';

package/src/provider/FlowmapDataProvider.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import {AggregateFlow, Cluster, LocationAccessors, LocationTotals} from '..';
 import {FlowmapState} from '../FlowmapState';
 import {

package/src/provider/LocalFlowmapDataProvider.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import type FlowmapDataProvider from './FlowmapDataProvider';
 import type {
   Cluster,
@@ -17,8 +23,10 @@ import {
 } from '../getViewStateForLocations';
 import {ClusterIndex} from '../cluster/ClusterIndex';
 
-export default class LocalFlowmapDataProvider<L, F>
-  implements FlowmapDataProvider<L, F>
+export default class LocalFlowmapDataProvider<
+  L extends Record<string, any>,
+  F extends Record<string, any>,
+> implements FlowmapDataProvider<L, F>
 {
   private selectors: FlowmapSelectors<L, F>;
   private flowmapData: FlowmapData<L, F> | undefined;

package/src/selector-functions.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import {WebMercatorViewport} from '@math.gl/web-mercator';
 import {
   ClusterLevel,

package/src/time.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import {timeFormat, timeParse} from 'd3-time-format';
 import {
   timeDay,

package/src/types.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 export type FlowmapData<L, F> = {
   locations: Iterable<L> | undefined;
   flows: Iterable<F> | undefined;

package/src/util.ts

@@ -1,3 +1,9 @@
+/*
+ * Copyright (c) Flowmap.gl contributors
+ * Copyright (c) 2018-2020 Teralytics
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
 import {createSelectorCreator, defaultMemoize} from 'reselect';
 
 export const createDebugSelector = createSelectorCreator(defaultMemoize, {