bruce-models 0.8.0 → 0.8.1

package/dist/bruce-models.es5.js

@@ -3819,15 +3819,13 @@ function isCellFetched(cell) {
     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,
@@ -3836,7 +3834,7 @@ function getOrCreateCell(cells, cellSize, lon, maxLon, lat, maxLat) {
         };
         cell.IsFetched = function () { return isCellFetched(cell); };
     }
-    return cell;
+    return [id, cell];
 }
 /**
  * This is a helper for making entity requests based on a grid area.
@@ -3850,34 +3848,122 @@ var EntityGlobe;
             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;
-})(EntityGlobe || (EntityGlobe = {}));
+})(EntityGlobe || (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;