maplibre-gl-lidar 0.6.0 → 0.6.2

package/README.md

@@ -50,51 +50,53 @@ npm install maplibre-gl-lidar
 ### Basic Usage (Vanilla JS/TypeScript)
 
 ```typescript
-import maplibregl from 'maplibre-gl';
-import { LidarControl } from 'maplibre-gl-lidar';
-import 'maplibre-gl-lidar/style.css';
-import 'maplibre-gl/dist/maplibre-gl.css';
+import maplibregl from "maplibre-gl";
+import { LidarControl } from "maplibre-gl-lidar";
+import "maplibre-gl-lidar/style.css";
+import "maplibre-gl/dist/maplibre-gl.css";
 
 const map = new maplibregl.Map({
-  container: 'map',
-  style: 'https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json',
+  container: "map",
+  style: "https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json",
   center: [-122.4, 37.8],
   zoom: 12,
   pitch: 60,
   maxPitch: 85, // Allow higher pitch for better 3D viewing
 });
 
-map.on('load', () => {
+map.on("load", () => {
   // Add the LiDAR control
   const lidarControl = new LidarControl({
-    title: 'LiDAR Viewer',
+    title: "LiDAR Viewer",
     collapsed: true,
     pointSize: 2,
-    colorScheme: 'elevation',
+    colorScheme: "elevation",
     pickable: true, // Enable point picking for hover tooltips
   });
 
-  map.addControl(lidarControl, 'top-right');
+  map.addControl(lidarControl, "top-right");
 
   // Listen for events
-  lidarControl.on('load', (event) => {
-    console.log('Point cloud loaded:', event.pointCloud);
+  lidarControl.on("load", (event) => {
+    console.log("Point cloud loaded:", event.pointCloud);
     lidarControl.flyToPointCloud();
   });
 
   // Load a point cloud programmatically
-  lidarControl.loadPointCloud('https://s3.amazonaws.com/hobu-lidar/autzen-classified.copc.laz');
+  lidarControl.loadPointCloud(
+    "https://s3.amazonaws.com/hobu-lidar/autzen-classified.copc.laz"
+  );
 });
 ```
 
 ### React Usage
 
 ```tsx
-import { useEffect, useRef, useState } from 'react';
-import maplibregl, { Map } from 'maplibre-gl';
-import { LidarControlReact, useLidarState } from 'maplibre-gl-lidar/react';
-import 'maplibre-gl-lidar/style.css';
-import 'maplibre-gl/dist/maplibre-gl.css';
+import { useEffect, useRef, useState } from "react";
+import maplibregl, { Map } from "maplibre-gl";
+import { LidarControlReact, useLidarState } from "maplibre-gl-lidar/react";
+import "maplibre-gl-lidar/style.css";
+import "maplibre-gl/dist/maplibre-gl.css";
 
 function App() {
   const mapContainer = useRef<HTMLDivElement>(null);
@@ -106,28 +108,28 @@ function App() {
 
     const mapInstance = new maplibregl.Map({
       container: mapContainer.current,
-      style: 'https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json',
+      style: "https://basemaps.cartocdn.com/gl/dark-matter-gl-style/style.json",
       center: [-122.4, 37.8],
       zoom: 12,
       pitch: 60,
       maxPitch: 85, // Allow higher pitch for better 3D viewing
     });
 
-    mapInstance.on('load', () => setMap(mapInstance));
+    mapInstance.on("load", () => setMap(mapInstance));
 
     return () => mapInstance.remove();
   }, []);
 
   return (
-    <div style={{ width: '100%', height: '100vh' }}>
-      <div ref={mapContainer} style={{ width: '100%', height: '100%' }} />
+    <div style={{ width: "100%", height: "100vh" }}>
+      <div ref={mapContainer} style={{ width: "100%", height: "100%" }} />
       {map && (
         <LidarControlReact
           map={map}
           title="LiDAR Viewer"
           pointSize={state.pointSize}
           colorScheme={state.colorScheme}
-          onLoad={(pc) => console.log('Loaded:', pc)}
+          onLoad={(pc) => console.log("Loaded:", pc)}
           defaultUrl="https://s3.amazonaws.com/hobu-lidar/autzen-classified.copc.laz"
         />
       )}
@@ -147,37 +149,37 @@ The main control class implementing MapLibre's `IControl` interface.
 ```typescript
 interface LidarControlOptions {
   // Panel settings
-  collapsed?: boolean;        // Start collapsed (default: true)
-  position?: string;          // 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right'
-  title?: string;             // Panel title (default: 'LiDAR Viewer')
-  panelWidth?: number;        // Panel width in pixels (default: 365)
-  panelMaxHeight?: number;    // Panel max height with scrollbar (default: 500)
-  className?: string;         // Custom CSS class
+  collapsed?: boolean; // Start collapsed (default: true)
+  position?: string; // 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right'
+  title?: string; // Panel title (default: 'LiDAR Viewer')
+  panelWidth?: number; // Panel width in pixels (default: 365)
+  panelMaxHeight?: number; // Panel max height with scrollbar (default: 500)
+  className?: string; // Custom CSS class
 
   // Point cloud styling
-  pointSize?: number;         // Point size in pixels (default: 2)
-  opacity?: number;           // Opacity 0-1 (default: 1.0)
-  colorScheme?: ColorScheme;  // Color scheme (default: 'elevation')
-  usePercentile?: boolean;    // Use 2-98% percentile for coloring (default: true)
-  pointBudget?: number;       // Max points to display (default: 1000000)
+  pointSize?: number; // Point size in pixels (default: 2)
+  opacity?: number; // Opacity 0-1 (default: 1.0)
+  colorScheme?: ColorScheme; // Color scheme (default: 'elevation')
+  usePercentile?: boolean; // Use 2-98% percentile for coloring (default: true)
+  pointBudget?: number; // Max points to display (default: 1000000)
 
   // Filters and adjustments
-  elevationRange?: [number, number] | null;  // Elevation filter
-  zOffsetEnabled?: boolean;   // Enable Z offset adjustment (default: false)
-  zOffset?: number;           // Z offset in meters (default: 0)
+  elevationRange?: [number, number] | null; // Elevation filter
+  zOffsetEnabled?: boolean; // Enable Z offset adjustment (default: false)
+  zOffset?: number; // Z offset in meters (default: 0)
 
   // Interaction
-  pickable?: boolean;         // Enable point picking/hover tooltips (default: false)
-  pickInfoFields?: string[];  // Fields to show in tooltip (default: all)
+  pickable?: boolean; // Enable point picking/hover tooltips (default: false)
+  pickInfoFields?: string[]; // Fields to show in tooltip (default: all)
 
   // Behavior
-  autoZoom?: boolean;         // Auto zoom to data after loading (default: true)
+  autoZoom?: boolean; // Auto zoom to data after loading (default: true)
 
   // COPC Streaming (dynamic loading)
-  copcLoadingMode?: 'full' | 'dynamic';  // Loading mode for COPC files (default: 'dynamic')
-  streamingPointBudget?: number;         // Max points for streaming (default: 5000000)
+  copcLoadingMode?: "full" | "dynamic"; // Loading mode for COPC files (default: 'dynamic')
+  streamingPointBudget?: number; // Max points for streaming (default: 5000000)
   streamingMaxConcurrentRequests?: number; // Concurrent node requests (default: 4)
-  streamingViewportDebounceMs?: number;  // Viewport change debounce (default: 150)
+  streamingViewportDebounceMs?: number; // Viewport change debounce (default: 150)
 }
 ```
 
@@ -261,8 +263,8 @@ By default, elevation and intensity coloring uses the 2nd-98th percentile range
 ```typescript
 // Percentile coloring is enabled by default
 const control = new LidarControl({
-  colorScheme: 'elevation',
-  usePercentile: true,  // default
+  colorScheme: "elevation",
+  usePercentile: true, // default
 });
 
 // Disable to use full value range (min-max)
@@ -298,7 +300,12 @@ const control = new LidarControl({ pickable: true });
 control.setPickable(true);
 
 // Optionally filter which fields to display
-control.setPickInfoFields(['Classification', 'Intensity', 'GpsTime', 'ReturnNumber']);
+control.setPickInfoFields([
+  "Classification",
+  "Intensity",
+  "GpsTime",
+  "ReturnNumber",
+]);
 ```
 
 ### Z Offset
@@ -331,6 +338,7 @@ When using the "Classification" color scheme, an interactive legend appears show
 - A checkbox to toggle visibility
 
 **Features:**
+
 - **Show All / Hide All buttons** - Quickly toggle all classifications at once
 - **Individual toggles** - Show or hide specific classification types
 - **Auto-detection** - Classifications are automatically detected from loaded data
@@ -341,24 +349,24 @@ When using the "Classification" color scheme, an interactive legend appears show
 // The legend automatically appears with checkboxes for each class
 
 // Programmatically control visibility
-control.setColorScheme('classification');
+control.setColorScheme("classification");
 
 // Hide specific classifications (e.g., hide noise points)
-control.setClassificationVisibility(7, false);  // Hide "Low Point (Noise)"
+control.setClassificationVisibility(7, false); // Hide "Low Point (Noise)"
 control.setClassificationVisibility(18, false); // Hide "High Noise"
 
 // Show only ground and buildings
 control.hideAllClassifications();
-control.setClassificationVisibility(2, true);  // Ground
-control.setClassificationVisibility(6, true);  // Building
+control.setClassificationVisibility(2, true); // Ground
+control.setClassificationVisibility(6, true); // Building
 
 // Get available classifications in the data
 const available = control.getAvailableClassifications();
-console.log('Classifications:', available); // [2, 3, 4, 5, 6, ...]
+console.log("Classifications:", available); // [2, 3, 4, 5, 6, ...]
 
 // Get currently hidden classifications
 const hidden = control.getHiddenClassifications();
-console.log('Hidden:', hidden); // [7, 18]
+console.log("Hidden:", hidden); // [7, 18]
 ```
 
 **ASPRS Classification Codes:**
@@ -378,12 +386,14 @@ console.log('Hidden:', hidden); // [7, 18]
 For large COPC (Cloud Optimized Point Cloud) files, dynamic streaming loads only the points visible in the current viewport, dramatically reducing initial load time and memory usage.
 
 **Key features:**
+
 - **Viewport-based loading** - Only loads octree nodes visible in the current map view
 - **Level-of-detail (LOD)** - Automatically selects appropriate detail level based on zoom
 - **Center-first priority** - Points near the viewport center load first
 - **Point budget** - Limits total points in memory (default: 5 million)
 
 **How it works:**
+
 1. When loading a COPC file (from URL or local file), dynamic mode is used by default
 2. As you pan/zoom the map, new nodes are streamed based on viewport
 3. Deeper octree levels (more detail) load as you zoom in
@@ -392,20 +402,21 @@ For large COPC (Cloud Optimized Point Cloud) files, dynamic streaming loads only
 ```typescript
 // Dynamic loading is the default for COPC files
 const control = new LidarControl();
-control.loadPointCloud('https://example.com/large-pointcloud.copc.laz');
+control.loadPointCloud("https://example.com/large-pointcloud.copc.laz");
 
 // Explicitly set loading mode
 const control = new LidarControl({
-  copcLoadingMode: 'dynamic',  // or 'full' for complete load
-  streamingPointBudget: 10_000_000,  // 10 million points max
+  copcLoadingMode: "dynamic", // or 'full' for complete load
+  streamingPointBudget: 10_000_000, // 10 million points max
 });
 
 // Override per-load
-control.loadPointCloud(file, { loadingMode: 'full' });  // Force full load
-control.loadPointCloud(url, { loadingMode: 'dynamic' }); // Force streaming
+control.loadPointCloud(file, { loadingMode: "full" }); // Force full load
+control.loadPointCloud(url, { loadingMode: "dynamic" }); // Force streaming
 ```
 
 **Loading modes:**
+
 - `'dynamic'` (default for COPC) - Stream nodes based on viewport, ideal for large files
 - `'full'` - Load entire point cloud upfront, better for small files
 
@@ -416,6 +427,7 @@ control.loadPointCloud(url, { loadingMode: 'dynamic' }); // Force streaming
 maplibre-gl-lidar supports [Entwine Point Tile (EPT)](https://entwine.io/en/latest/entwine-point-tile.html) datasets, a widely-used format for serving large point clouds over HTTP with viewport-based streaming.
 
 **Key features:**
+
 - **Directory-based format** - Metadata in ept.json, hierarchy in ept-hierarchy/, data in ept-data/
 - **Viewport-based streaming** - Points load dynamically based on current map view
 - **LAZ compression** - Efficient data transfer using LAZ compression
@@ -425,15 +437,19 @@ maplibre-gl-lidar supports [Entwine Point Tile (EPT)](https://entwine.io/en/late
 
 ```typescript
 // Load EPT dataset by URL (automatically detected via ept.json)
-lidarControl.loadPointCloud('https://na-c.entwine.io/dublin/ept.json');
+lidarControl.loadPointCloud("https://na-c.entwine.io/dublin/ept.json");
 
 // Or load programmatically
-lidarControl.loadPointCloudEptStreaming('https://na-c.entwine.io/dublin/ept.json', {
-  pointBudget: 5_000_000,  // Max points in memory
-});
+lidarControl.loadPointCloudEptStreaming(
+  "https://na-c.entwine.io/dublin/ept.json",
+  {
+    pointBudget: 5_000_000, // Max points in memory
+  }
+);
 ```
 
 **Sample EPT datasets:**
+
 - Dublin, Ireland: `https://na-c.entwine.io/dublin/ept.json`
 - New York City (4.7B points): `https://na-c.entwine.io/nyc/ept.json`
 - Red Rocks: `https://na-c.entwine.io/red-rocks/ept.json`
@@ -515,12 +531,11 @@ docker run -p 8080:80 maplibre-gl-lidar
 
 ### Available Tags
 
-| Tag | Description |
-|-----|-------------|
-| `latest` | Latest release |
-| `x.y.z` | Specific version (e.g., `1.0.0`) |
-| `x.y` | Minor version (e.g., `1.0`) |
-
+| Tag      | Description                      |
+| -------- | -------------------------------- |
+| `latest` | Latest release                   |
+| `x.y.z`  | Specific version (e.g., `1.0.0`) |
+| `x.y`    | Minor version (e.g., `1.0`)      |
 
 ## Dependencies
 
@@ -537,4 +552,8 @@ MIT
 
 ## Credits
 
-The sample dataset [autzen-classified.copc.laz](https://s3.amazonaws.com/hobu-lidar/autzen-classified.copc.laz) is from [Hobu, Inc.](https://hobu.co). Credits to [Howard Butler](https://github.com/hobu).
+- Microsoft Planetary Computer: [USGS 3DEP Lidar Point Cloud Dataset](https://planetarycomputer.microsoft.com/dataset/usgs-3dep-lidar)
+- AWS Open Data: [USGS 3DEP LiDAR Point Clouds](https://registry.opendata.aws/usgs-lidar)
+- [Hobu, Inc.](https://hobu.co)
+- [COPC.io](https://copc.io)
+- [Entwine](https://entwine.io)

package/dist/{LidarLayerAdapter-CHu9adLN.cjs → LidarLayerAdapter-Sw_plY5a.cjs}

@@ -34221,6 +34221,7 @@ class PointCloudLoader {
     };
   }
 }
+proj4.defs("EPSG:2180", "+proj=tmerc +lat_0=0 +lon_0=19 +k=0.9993 +x_0=500000 +y_0=-5300000 +ellps=GRS80 +towgs84=0,0,0,0,0,0,0 +units=m +no_defs +type=crs");
 function createBufferGetter(buffer) {
   const uint8 = new Uint8Array(buffer);
   return async (begin, end) => {
@@ -34332,6 +34333,32 @@ function getVerticalUnitConversionFactor$1(wkt2) {
   }
   return 1;
 }
+function clampLatLng$1(lng, lat, context = "") {
+  let clampedLng = lng;
+  let clampedLat = lat;
+  let wasClamped = false;
+  if (lat > 90) {
+    clampedLat = 90;
+    wasClamped = true;
+  } else if (lat < -90) {
+    clampedLat = -90;
+    wasClamped = true;
+  }
+  if (lng > 180) {
+    clampedLng = 180;
+    wasClamped = true;
+  } else if (lng < -180) {
+    clampedLng = -180;
+    wasClamped = true;
+  }
+  if (wasClamped) {
+    console.warn(
+      `COPC: Clamped transformed coordinates to valid WGS84 range${context ? ` (${context})` : ""}:`,
+      `[${lng.toFixed(6)}, ${lat.toFixed(6)}] -> [${clampedLng.toFixed(6)}, ${clampedLat.toFixed(6)}]`
+    );
+  }
+  return [clampedLng, clampedLat];
+}
 const DEFAULT_OPTIONS$2 = {
   pointBudget: 5e6,
   maxConcurrentRequests: 4,
@@ -34439,10 +34466,30 @@ class CopcStreamingLoader {
       } catch (e) {
         console.warn("Failed to setup coordinate transformation:", e);
       }
+    } else {
+      const minX = header2.min[0];
+      const minY = header2.min[1];
+      const maxX = header2.max[0];
+      const maxY = header2.max[1];
+      let detectedEPSG = null;
+      if (minX >= 1e5 && maxX <= 9e5 && minY >= 1e5 && maxY <= 8e5) {
+        detectedEPSG = "EPSG:2180";
+      }
+      if (detectedEPSG) {
+        try {
+          const projConverter = proj4(detectedEPSG, "EPSG:4326");
+          this._transformer = (coord) => projConverter.forward(coord);
+          this._needsTransform = true;
+        } catch (e) {
+          console.warn(`Failed to setup coordinate transformation from ${detectedEPSG}:`, e);
+        }
+      }
     }
     if (this._needsTransform && this._transformer) {
-      const [minLng, minLat] = this._transformer([header2.min[0], header2.min[1]]);
-      const [maxLng, maxLat] = this._transformer([header2.max[0], header2.max[1]]);
+      const [rawMinLng, rawMinLat] = this._transformer([header2.min[0], header2.min[1]]);
+      const [rawMaxLng, rawMaxLat] = this._transformer([header2.max[0], header2.max[1]]);
+      const [minLng, minLat] = clampLatLng$1(rawMinLng, rawMinLat, "header bounds min");
+      const [maxLng, maxLat] = clampLatLng$1(rawMaxLng, rawMaxLat, "header bounds max");
       this._bounds = {
         minX: Math.min(minLng, maxLng),
         minY: Math.min(minLat, maxLat),
@@ -34532,8 +34579,10 @@ class CopcStreamingLoader {
     };
     let boundsWgs84 = bounds2;
     if (this._needsTransform && this._transformer) {
-      const [sw_lng, sw_lat] = this._transformer([minX, minY]);
-      const [ne_lng, ne_lat] = this._transformer([minX + nodeSize, minY + nodeSize]);
+      const [rawSwLng, rawSwLat] = this._transformer([minX, minY]);
+      const [rawNeLng, rawNeLat] = this._transformer([minX + nodeSize, minY + nodeSize]);
+      const [sw_lng, sw_lat] = clampLatLng$1(rawSwLng, rawSwLat, "node bounds SW");
+      const [ne_lng, ne_lat] = clampLatLng$1(rawNeLng, rawNeLat, "node bounds NE");
       boundsWgs84 = {
         minX: Math.min(sw_lng, ne_lng),
         minY: Math.min(sw_lat, ne_lat),
@@ -34765,7 +34814,8 @@ class CopcStreamingLoader {
       const y = yGetter(i);
       const z = zGetter(i);
       if (this._needsTransform && this._transformer) {
-        const [lng, lat] = this._transformer([x, y]);
+        const [rawLng, rawLat] = this._transformer([x, y]);
+        const [lng, lat] = clampLatLng$1(rawLng, rawLat, "");
         this._positions[pointIndex * 3] = lng - this._coordinateOrigin[0];
         this._positions[pointIndex * 3 + 1] = lat - this._coordinateOrigin[1];
         this._positions[pointIndex * 3 + 2] = z * this._verticalUnitFactor;
@@ -34986,6 +35036,32 @@ function createAttributeArray(type, length) {
       return new Float32Array(length);
   }
 }
+function clampLatLng(lng, lat, context = "") {
+  let clampedLng = lng;
+  let clampedLat = lat;
+  let wasClamped = false;
+  if (lat > 90) {
+    clampedLat = 90;
+    wasClamped = true;
+  } else if (lat < -90) {
+    clampedLat = -90;
+    wasClamped = true;
+  }
+  if (lng > 180) {
+    clampedLng = 180;
+    wasClamped = true;
+  } else if (lng < -180) {
+    clampedLng = -180;
+    wasClamped = true;
+  }
+  if (wasClamped && context) {
+    console.warn(
+      `EPT: Clamped transformed coordinates to valid WGS84 range${context ? ` (${context})` : ""}:`,
+      `[${lng.toFixed(6)}, ${lat.toFixed(6)}] -> [${clampedLng.toFixed(6)}, ${clampedLat.toFixed(6)}]`
+    );
+  }
+  return [clampedLng, clampedLat];
+}
 function extractProjcsFromWkt(wkt2) {
   if (wkt2.startsWith("COMPD_CS[")) {
     const projcsStart = wkt2.indexOf("PROJCS[");
@@ -35125,17 +35201,19 @@ class EptStreamingLoader {
     }
     const [minX, minY, minZ, maxX, maxY, maxZ] = this._metadata.boundsConforming;
     if (this._needsTransform && this._transformer) {
-      const [minLng, minLat] = this._transformer([minX, minY]);
-      const [maxLng, maxLat] = this._transformer([maxX, maxY]);
-      if (isNaN(minLng) || isNaN(minLat) || isNaN(maxLng) || isNaN(maxLat) || !isFinite(minLng) || !isFinite(minLat) || !isFinite(maxLng) || !isFinite(maxLat)) {
+      const [rawMinLng, rawMinLat] = this._transformer([minX, minY]);
+      const [rawMaxLng, rawMaxLat] = this._transformer([maxX, maxY]);
+      if (isNaN(rawMinLng) || isNaN(rawMinLat) || isNaN(rawMaxLng) || isNaN(rawMaxLat) || !isFinite(rawMinLng) || !isFinite(rawMinLat) || !isFinite(rawMaxLng) || !isFinite(rawMaxLat)) {
         console.error("EPT coordinate transformation produced invalid bounds:", {
           input: { minX, minY, maxX, maxY },
-          output: { minLng, minLat, maxLng, maxLat }
+          output: { rawMinLng, rawMinLat, rawMaxLng, rawMaxLat }
         });
         this._bounds = { minX, minY, minZ, maxX, maxY, maxZ };
         this._needsTransform = false;
         this._transformer = null;
       } else {
+        const [minLng, minLat] = clampLatLng(rawMinLng, rawMinLat, "header bounds min");
+        const [maxLng, maxLat] = clampLatLng(rawMaxLng, rawMaxLat, "header bounds max");
         this._bounds = {
           minX: Math.min(minLng, maxLng),
           minY: Math.min(minLat, maxLat),
@@ -35286,8 +35364,10 @@ class EptStreamingLoader {
     };
     let boundsWgs84 = bounds2;
     if (this._needsTransform && this._transformer) {
-      const [sw_lng, sw_lat] = this._transformer([minX, minY]);
-      const [ne_lng, ne_lat] = this._transformer([minX + nodeSize, minY + nodeSize]);
+      const [rawSwLng, rawSwLat] = this._transformer([minX, minY]);
+      const [rawNeLng, rawNeLat] = this._transformer([minX + nodeSize, minY + nodeSize]);
+      const [sw_lng, sw_lat] = clampLatLng(rawSwLng, rawSwLat, "node bounds SW");
+      const [ne_lng, ne_lat] = clampLatLng(rawNeLng, rawNeLat, "node bounds NE");
       boundsWgs84 = {
         minX: Math.min(sw_lng, ne_lng),
         minY: Math.min(sw_lat, ne_lat),
@@ -35571,7 +35651,8 @@ class EptStreamingLoader {
       const y = positions[i * 3 + 1];
       const z = positions[i * 3 + 2];
       if (this._needsTransform && this._transformer) {
-        const [lng, lat] = this._transformer([x, y]);
+        const [rawLng, rawLat] = this._transformer([x, y]);
+        const [lng, lat] = clampLatLng(rawLng, rawLat, "");
         this._positions[pointIndex * 3] = lng - this._coordinateOrigin[0];
         this._positions[pointIndex * 3 + 1] = lat - this._coordinateOrigin[1];
         this._positions[pointIndex * 3 + 2] = z * this._verticalUnitFactor;
@@ -35651,7 +35732,8 @@ class EptStreamingLoader {
       const y = yGetter(dataView, byteOffset);
       const z = zGetter(dataView, byteOffset);
       if (this._needsTransform && this._transformer) {
-        const [lng, lat] = this._transformer([x, y]);
+        const [rawLng, rawLat] = this._transformer([x, y]);
+        const [lng, lat] = clampLatLng(rawLng, rawLat, "");
         this._positions[pointIndex * 3] = lng - this._coordinateOrigin[0];
         this._positions[pointIndex * 3 + 1] = lat - this._coordinateOrigin[1];
         this._positions[pointIndex * 3 + 2] = z * this._verticalUnitFactor;
@@ -38431,10 +38513,14 @@ class LidarControl {
       });
       viewportManager.start();
       if (this._options.autoZoom) {
+        const clampedMinY = Math.max(-90, Math.min(90, bounds2.minY));
+        const clampedMaxY = Math.max(-90, Math.min(90, bounds2.maxY));
+        const clampedMinX = Math.max(-180, Math.min(180, bounds2.minX));
+        const clampedMaxX = Math.max(-180, Math.min(180, bounds2.maxX));
         (_c = this._map) == null ? void 0 : _c.fitBounds(
           [
-            [bounds2.minX, bounds2.minY],
-            [bounds2.maxX, bounds2.maxY]
+            [clampedMinX, clampedMinY],
+            [clampedMaxX, clampedMaxY]
           ],
           {
             padding: 50,
@@ -38591,10 +38677,14 @@ class LidarControl {
       });
       viewportManager.start();
       if (this._options.autoZoom) {
+        const clampedMinY = Math.max(-90, Math.min(90, bounds2.minY));
+        const clampedMaxY = Math.max(-90, Math.min(90, bounds2.maxY));
+        const clampedMinX = Math.max(-180, Math.min(180, bounds2.minX));
+        const clampedMaxX = Math.max(-180, Math.min(180, bounds2.maxX));
         (_d = this._map) == null ? void 0 : _d.fitBounds(
           [
-            [bounds2.minX, bounds2.minY],
-            [bounds2.maxX, bounds2.maxY]
+            [clampedMinX, clampedMinY],
+            [clampedMaxX, clampedMaxY]
           ],
           {
             padding: 50,
@@ -38975,6 +39065,9 @@ class LidarControl {
     var _a;
     this._state.pickable = pickable;
     (_a = this._pointCloudManager) == null ? void 0 : _a.setPickable(pickable);
+    if (!pickable && this._tooltip) {
+      this._tooltip.style.display = "none";
+    }
     this._emit("stylechange");
     this._emit("statechange");
   }
@@ -39701,4 +39794,4 @@ exports.generateId = generateId;
 exports.getClassificationName = getClassificationName;
 exports.getFilename = getFilename;
 exports.throttle = throttle;
-//# sourceMappingURL=LidarLayerAdapter-CHu9adLN.cjs.map
+//# sourceMappingURL=LidarLayerAdapter-Sw_plY5a.cjs.map