bruce-models 2.1.1 → 2.1.3

package/dist/bruce-models.es5.js

@@ -7092,6 +7092,7 @@ var EntityGlobe;
             this.IsFetched = null;
             this.FetchPageIndex = 0;
             this.Boundaries = null;
+            this.Fetching = false;
         }
         GetBounds() {
             // Entity data works in -180 to 180 range.
@@ -7118,93 +7119,51 @@ var EntityGlobe;
     class Grid {
         constructor() {
             this.cells = {};
-            this.patches = [];
         }
-        GetCellsForView(viewRect) {
+        GetCellsForView(cameraPos, viewRect) {
+            const cells = [];
+            const minLat = viewRect.south;
+            const minLon = viewRect.west;
+            const maxLat = viewRect.north;
+            const maxLon = viewRect.east;
             const MAX_CELLS = 150;
-            const { south: minLat, west: minLon, north: maxLat, east: maxLon } = viewRect;
             const cellDegreeSize = getCellSizeFromHeight(viewRect.alt);
-            const [curMinLon, curMinLat] = [minLon, minLat].map((v) => floorValueToCellSize(cellDegreeSize, v));
-            const [width, height] = [maxLon - curMinLon, maxLat - curMinLat].map((v) => v / cellDegreeSize);
-            const ids = [];
-            const cells = [];
-            let max = [curMinLon, curMinLat];
-            const intersections = this.intersections(viewRect);
-            const addCell = (x, y) => {
-                const lon1 = x * cellDegreeSize + curMinLon;
-                const lat1 = y * cellDegreeSize + curMinLat;
-                const lon2 = lon1 + cellDegreeSize;
-                const lat2 = lat1 + cellDegreeSize;
-                const [id, cell] = getOrCreateCell(this.cells, cellDegreeSize, lon1, lon2, lat1, lat2);
-                /*
-                {
-                    const cell_bounds = { south: lat1, west: lon1, north: lat2, east: lon2 };
-                    const subcells = [];
-                    for (const id of intersections) {
-                        const c = this.cells[id].GetBounds();
-                        if (contains(c, cell_bounds)) {
-                            cell.Fetched = true;
-                            return;
-                        }
-                        if (intersects(c, cell_bounds)) {
-                            const cropped = crop(c, cell.GetBounds());
-                            subcells.push(cropped);
-                        }
-                    }
-                    let filled = 0;
-                    while (subcells.length > 0) {
-                        const c = subcells.pop();
-                        filled += area(c);
-                        for (const s of subcells) {
-                            filled -= intersection(s, c);
-                        }
-                    }
-                    if (filled + Number.EPSILON * 2 > area(cell.GetBounds())) {
-                        cell.Fetched = true;
-                        return;
-                    }
-
-                    let [x2, y2] = max;
-                    x2 = Math.max(x2, lon2);
-                    y2 = Math.max(y2, lat2);
-                    max = [x2, y2];
-                }
-                */
-                ids.push(id);
-                cells.push(cell);
-                cells[id] = cell;
-            };
+            const curMinLon = floorValueToCellSize(cellDegreeSize, minLon);
+            const curMinLat = floorValueToCellSize(cellDegreeSize, minLat);
+            let centerX = cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.longitude;
+            let centerY = cameraPos === null || cameraPos === void 0 ? void 0 : cameraPos.latitude;
+            if (isNaN(centerX) || isNaN(centerY)) {
+                centerX = (minLon + maxLon) / 2;
+                centerY = (minLat + maxLat) / 2;
+            }
+            const width = Math.ceil((maxLon - curMinLon) / cellDegreeSize);
+            const height = Math.ceil((maxLat - curMinLat) / cellDegreeSize);
+            const cellDistances = [];
             for (let x = 0; x < width; x++) {
                 for (let y = 0; y < height; y++) {
-                    addCell(x, y);
-                    if (cells.length >= MAX_CELLS) {
-                        break;
-                    }
+                    const lon = x * cellDegreeSize + curMinLon;
+                    const lat = y * cellDegreeSize + curMinLat;
+                    const cellCenterX = lon + cellDegreeSize / 2;
+                    const cellCenterY = lat + cellDegreeSize / 2;
+                    const dist = Math.sqrt(Math.pow(cellCenterX - centerX, 2) + Math.pow(cellCenterY - centerY, 2));
+                    cellDistances.push({ x, y, dist });
+                }
+            }
+            cellDistances.sort((a, b) => a.dist - b.dist);
+            for (const { x, y } of cellDistances) {
+                const lon = x * cellDegreeSize + curMinLon;
+                const lat = y * cellDegreeSize + curMinLat;
+                const [id, cell] = getOrCreateCell(this.cells, cellDegreeSize, lon, lon + cellDegreeSize, lat, lat + cellDegreeSize);
+                cells.push(cell);
+                if (cells.length >= MAX_CELLS) {
+                    break;
                 }
             }
-            const [x2, y2] = max;
-            if (x2 != curMinLon && y2 != curMinLat) {
-                this.patches.push([{ west: curMinLon, east: x2, south: curMinLat, north: y2 }, ids]);
-            }
             return cells;
         }
-        intersections(withRect) {
-            return this.patches
-                .filter(([rect, _]) => intersects(rect, withRect))
-                .map(([_, ids]) => ids)
-                .reduce((all, ids) => {
-                all.push(...ids);
-                return all;
-            }, []);
-        }
     }
     EntityGlobe.Grid = Grid;
 })(EntityGlobe || (EntityGlobe = {}));
-function intersects(l, r) {
-    const { west: w, south: s, north: n, east: e } = l;
-    const { west: wr, south: sr, north: nr, east: er } = r;
-    return !(e <= wr || w >= er || n <= sr || s >= nr);
-}
 function floorValueToCellSize(size, value) {
     return Math.floor(value / size) * size;
 }
@@ -7444,6 +7403,7 @@ var EntityFilterGetter;
                 let retryDelay = 0;
                 let prevFirstId = "";
                 let prevLastId = "";
+                let prevTicks = 0;
                 while ((!this.viewCenter || !this.viewRect) && this.getterLoopId == loopId) {
                     yield delay(RETRY_DELAY_INCREMENT);
                 }
@@ -7454,7 +7414,7 @@ var EntityFilterGetter;
                 if (alt > MAX_HEIGHT || (alt < MIN_HEIGHT && MIN_HEIGHT > 0)) {
                     return;
                 }
-                const cells = this.cells.GetCellsForView(this.viewRect);
+                const cells = this.cells.GetCellsForView(this.viewCenter, this.viewRect);
                 (_a = this.onScanUpdate) === null || _a === void 0 ? void 0 : _a.Trigger(cells);
                 let curCellIndex = cells.length > 0 ? 0 : null;
                 let postedScanning = false;
@@ -7473,8 +7433,12 @@ var EntityFilterGetter;
                     }
                     const curCell = cells[curCellIndex];
                     if (curCell.IsFetched()) {
+                        curCell.Fetching = false;
                         curCellIndex += 1;
-                        if (!cells[curCellIndex]) {
+                        if (cells[curCellIndex]) {
+                            cells[curCellIndex].Fetching = true;
+                        }
+                        else {
                             curCellIndex = null;
                         }
                         (_b = this.onScanUpdate) === null || _b === void 0 ? void 0 : _b.Trigger(cells);
@@ -7514,6 +7478,7 @@ var EntityFilterGetter;
                         // Only mark as fetched when ALL pages are done.
                         if (entities.length <= 0) {
                             curCell.Fetched = true;
+                            curCell.Fetching = false;
                             (_d = this.onScanUpdate) === null || _d === void 0 ? void 0 : _d.Trigger(cells);
                             continue;
                         }
@@ -7522,11 +7487,15 @@ var EntityFilterGetter;
                             const first = (_f = (_e = entities[0]) === null || _e === void 0 ? void 0 : _e.Bruce) === null || _f === void 0 ? void 0 : _f.ID;
                             const last = (_h = (_g = entities[entities.length - 1]) === null || _g === void 0 ? void 0 : _g.Bruce) === null || _h === void 0 ? void 0 : _h.ID;
                             if (prevFirstId == first && prevLastId == last) {
-                                break;
+                                prevTicks += 1;
+                                if (prevTicks > 3) {
+                                    break;
+                                }
                             }
                             else {
                                 prevFirstId = first;
                                 prevLastId = last;
+                                prevTicks = 0;
                             }
                         }
                         curCell.FetchPageIndex++;
@@ -7535,7 +7504,7 @@ var EntityFilterGetter;
                         retryDelay = 0;
                     }
                     catch (e) {
-                        console.log(e);
+                        console.error(e);
                         // Request failed so let's add a delay and try again soon.
                         retryDelay += RETRY_DELAY_INCREMENT;
                         retryAttempts -= 1;