bruce-models 0.8.0 → 0.8.2

package/dist/bruce-models.umd.js

@@ -2321,9 +2321,9 @@
                 var pointData = points[i];
                 var coords = pointData.trim().split(splitterAxis);
                 if (coords.length == 2 || coords.length == 3) {
-                    var longitude = +coords[0];
-                    var latitude = +coords[1];
-                    var altitude = coords.length >= 3 ? +coords[2] : 0;
+                    var longitude = Number(coords[0]);
+                    var latitude = Number(coords[1]);
+                    var altitude = Number(coords.length >= 3 ? coords[2] : 0);
                     if (longitude != null && latitude != null) {
                         result.push({
                             altitude: altitude,
@@ -3724,15 +3724,13 @@
         if (cell.Fetched) {
             return true;
         }
-        // TODO: If all cells of the size smaller are fetched then this is fetched.
-        // TODO: If this is a cell within a larger cell that is fetched then this is fetched.
         return false;
     }
     function getOrCreateCell(cells, cellSize, lon, maxLon, lat, maxLat) {
         var id = cellSize + "_" + lon + "_" + maxLon + "_" + lat + "_" + maxLat;
         var cell = getCell(cells, cellSize, lon, maxLon, lat, maxLat);
         if (!cell) {
-            cell = cells[id] = new Cell();
+            cell = new Cell();
             cell.Boundaries = {
                 minLatitude: lat,
                 maxLatitude: maxLat,
@@ -3741,7 +3739,7 @@
             };
             cell.IsFetched = function () { return isCellFetched(cell); };
         }
-        return cell;
+        return [id, cell];
     }
     (function (EntityGlobe) {
         var Grid = /** @class */ (function () {
@@ -3749,34 +3747,122 @@
                 this.cells = {};
             }
             Grid.prototype.GetCellsForView = function (viewRect) {
-                var cells = [];
-                var minLat = viewRect.south;
-                var minLon = viewRect.west;
-                var maxLat = viewRect.north;
-                var maxLon = viewRect.east;
+                var _this = this;
                 var MAX_CELLS = 150;
+                var minLat = viewRect.south, minLon = viewRect.west, maxLat = viewRect.north, maxLon = viewRect.east;
                 var cellDegreeSize = getCellSizeFromHeight(viewRect.alt);
-                var curMinLon = floorValueToCellSize(cellDegreeSize, minLon);
-                var curMinLat = floorValueToCellSize(cellDegreeSize, minLat);
-                var width = (maxLon - curMinLon) / cellDegreeSize;
-                var height = (maxLat - curMinLat) / cellDegreeSize;
+                var _a = [minLon, minLat].map(function (v) { return floorValueToCellSize(cellDegreeSize, v); }), curMinLon = _a[0], curMinLat = _a[1];
+                var _b = [maxLon - curMinLon, maxLat - curMinLat].map(function (v) { return v / cellDegreeSize; }), width = _b[0], height = _b[1];
+                var ids = [];
+                var cells = [];
+                var max = [curMinLon, curMinLat];
+                var intersections = this.intersections(viewRect);
+                var addCell = function (x, y) {
+                    var lon1 = x * cellDegreeSize + curMinLon;
+                    var lat1 = y * cellDegreeSize + curMinLat;
+                    var lon2 = lon1 + cellDegreeSize;
+                    var lat2 = lat1 + cellDegreeSize;
+                    var _a = getOrCreateCell(_this.cells, cellDegreeSize, lon1, lon2, lat1, lat2), id = _a[0], cell = _a[1];
+                    {
+                        var cell_bounds = { south: lat1, west: lon1, north: lat2, east: lon2 };
+                        var subcells = [];
+                        for (var _i = 0, intersections_1 = intersections; _i < intersections_1.length; _i++) {
+                            var id_1 = intersections_1[_i];
+                            var c = _this.cells[id_1].GetBounds();
+                            if (contains(c, cell_bounds)) {
+                                cell.Fetched = true;
+                                return;
+                            }
+                            if (intersects(c, cell_bounds)) {
+                                var cropped = crop(c, cell.GetBounds());
+                                subcells.push(cropped);
+                            }
+                        }
+                        var filled = 0;
+                        while (subcells.length > 0) {
+                            var c = subcells.pop();
+                            filled += area(c);
+                            for (var _b = 0, subcells_1 = subcells; _b < subcells_1.length; _b++) {
+                                var s = subcells_1[_b];
+                                filled -= intersection(s, c);
+                            }
+                        }
+                        if (filled + Number.EPSILON * 2 > area(cell.GetBounds())) {
+                            cell.Fetched = true;
+                            return;
+                        }
+                        var x2_1 = max[0], y2_1 = max[1];
+                        x2_1 = Math.max(x2_1, lon2);
+                        y2_1 = Math.max(y2_1, lat2);
+                        max = [x2_1, y2_1];
+                    }
+                    ids.push(id);
+                    cells.push(cell);
+                    cells[id] = cell;
+                };
                 for (var x = 0; x < width; x++) {
                     for (var y = 0; y < height; y++) {
-                        var lon = x * cellDegreeSize + curMinLon;
-                        var lat = y * cellDegreeSize + curMinLat;
-                        var cell = getOrCreateCell(this.cells, cellDegreeSize, lon, lon + cellDegreeSize, lat, lat + cellDegreeSize);
-                        cells.push(cell);
-                        if (cells.length > MAX_CELLS) {
+                        addCell(x, y);
+                        if (cells.length >= MAX_CELLS) {
                             break;
                         }
                     }
                 }
+                var x2 = max[0], y2 = max[1];
+                if (x2 != curMinLon && y2 != curMinLat) {
+                    this.patches.push([{ west: curMinLon, east: x2, south: curMinLat, north: y2 }, ids]);
+                }
                 return cells;
             };
+            Grid.prototype.intersections = function (withRect) {
+                return this.patches
+                    .filter(function (_a) {
+                    var rect = _a[0], _ = _a[1];
+                    return intersects(rect, withRect);
+                })
+                    .map(function (_a) {
+                    var _ = _a[0], ids = _a[1];
+                    return ids;
+                })
+                    .reduce(function (all, ids) {
+                    all.push.apply(all, ids);
+                    return all;
+                }, []);
+            };
             return Grid;
         }());
         EntityGlobe.Grid = Grid;
-    })(exports.EntityGlobe || (exports.EntityGlobe = {}));
+    })(exports.EntityGlobe || (exports.EntityGlobe = {}));
+    function intersects(l, r) {
+        var w = l.west, s = l.south, n = l.north, e = l.east;
+        var wr = r.west, sr = r.south, nr = r.north, er = r.east;
+        return !(e <= wr || w >= er || n <= sr || s >= nr);
+    }
+    function contains(l, r) {
+        var w = l.west, s = l.south, n = l.north, e = l.east;
+        var wr = r.west, sr = r.south, nr = r.north, er = r.east;
+        return !(er < e || wr > w || nr > n || sr < s);
+    }
+    function crop(rect, by) {
+        var w = rect.west, s = rect.south, n = rect.north, e = rect.east;
+        var wc = by.west, sc = by.south, nc = by.north, ec = by.east;
+        w = Math.max(w, ec);
+        e = Math.min(e, wc);
+        s = Math.max(s, nc);
+        n = Math.min(n, sc);
+        return { west: w, south: s, north: n, east: e };
+    }
+    function intersection(l, r) {
+        var w = l.west, s = l.south, n = l.north, e = l.east;
+        var wr = r.west, sr = r.south, nr = r.north, er = r.east;
+        var x = Math.min(e, er) - Math.max(w, wr);
+        var y = Math.min(n, nr) - Math.max(s, sr);
+        return (x > 0 && y > 0) ? x * y : 0;
+    }
+    function area(rect) {
+        var w = rect.west, s = rect.south, n = rect.north, e = rect.east;
+        return Math.abs((e - w) * (n - s));
+    }
 
     var MAX_AREA_IN_DEGREES = 90;
     var MAX_RETRY_ATTEMPTS = 1;