Cesium-Prequel/Specs/Scene/TileBoundingRegionSpec.js

import { Cartesian2 } from "../../Source/Cesium.js";
import { Cartesian3 } from "../../Source/Cesium.js";
import { Cartographic } from "../../Source/Cesium.js";
import { Color } from "../../Source/Cesium.js";
import { Ellipsoid } from "../../Source/Cesium.js";
import { GeographicTilingScheme } from "../../Source/Cesium.js";
import { Intersect } from "../../Source/Cesium.js";
import { Math as CesiumMath } from "../../Source/Cesium.js";
import { Plane } from "../../Source/Cesium.js";
import { Rectangle } from "../../Source/Cesium.js";
import { SceneMode } from "../../Source/Cesium.js";
import { TileBoundingRegion } from "../../Source/Cesium.js";
import createFrameState from "../createFrameState.js";

describe("Scene/TileBoundingRegion", function () {
  var boundingVolumeRegion = [0.0, 0.0, 1.0, 1.0, 0, 1];
  var regionBox = boundingVolumeRegion.slice(0, 4);
  var rectangle = new Rectangle(
    regionBox[0],
    regionBox[1],
    regionBox[2],
    regionBox[3]
  );
  var tileBoundingRegion = new TileBoundingRegion({
    maximumHeight: boundingVolumeRegion[5],
    minimumHeight: boundingVolumeRegion[4],
    rectangle: rectangle,
  });

  var frameState;
  var camera;

  beforeEach(function () {
    frameState = createFrameState();
    camera = frameState.camera;
  });

  it("throws when options.rectangle is undefined", function () {
    expect(function () {
      return new TileBoundingRegion();
    }).toThrowDeveloperError();
  });

  it("can be instantiated with rectangle and heights", function () {
    var minimumHeight = boundingVolumeRegion[4];
    var maximumHeight = boundingVolumeRegion[5];
    var tbr = new TileBoundingRegion({
      maximumHeight: maximumHeight,
      minimumHeight: minimumHeight,
      rectangle: rectangle,
    });
    expect(tbr).toBeDefined();
    expect(tbr.boundingVolume).toBeDefined();
    expect(tbr.boundingSphere).toBeDefined();
    expect(tbr.rectangle).toEqual(rectangle);
    expect(tbr.minimumHeight).toEqual(minimumHeight);
    expect(tbr.maximumHeight).toEqual(maximumHeight);
  });

  it("can be instantiated with only a rectangle", function () {
    var tbr = new TileBoundingRegion({ rectangle: rectangle });
    expect(tbr).toBeDefined();
    expect(tbr.boundingVolume).toBeDefined();
    expect(tbr.boundingSphere).toBeDefined();
    expect(tbr.rectangle).toEqual(rectangle);
    expect(tbr.minimumHeight).toBeDefined();
    expect(tbr.maximumHeight).toBeDefined();
  });

  it("distanceToCamera throws when frameState is undefined", function () {
    expect(function () {
      return tileBoundingRegion.distanceToCamera();
    }).toThrowDeveloperError();
  });

  it("distance to camera is 0 when camera is inside bounding region", function () {
    camera.position = Cartesian3.fromRadians(
      regionBox[0] + CesiumMath.EPSILON6,
      regionBox[1],
      0
    );
    expect(tileBoundingRegion.distanceToCamera(frameState)).toEqual(0.0);
  });

  it("distance to camera is correct when camera is outside bounding region", function () {
    camera.position = Cartesian3.fromRadians(regionBox[0], regionBox[1], 2.0);
    expect(tileBoundingRegion.distanceToCamera(frameState)).toEqualEpsilon(
      1.0,
      CesiumMath.EPSILON6
    );
  });

  it("distanceToCamera", function () {
    var offset = 0.0001;
    var west = -0.001;
    var south = -0.001;
    var east = 0.001;
    var north = 0.001;

    var tile = new TileBoundingRegion({
      rectangle: new Rectangle(west, south, east, north),
      minimumHeight: 0.0,
      maximumHeight: 10.0,
    });

    // Inside rectangle, above height
    camera.position = Cartesian3.fromRadians(0.0, 0.0, 20.0);
    expect(tile.distanceToCamera(frameState)).toEqualEpsilon(
      10.0,
      CesiumMath.EPSILON3
    );

    // Inside rectangle, below height
    camera.position = Cartesian3.fromRadians(0.0, 0.0, 5.0);
    expect(tile.distanceToCamera(frameState)).toEqual(0.0);

    // From southwest
    camera.position = Cartesian3.fromRadians(
      west - offset,
      south - offset,
      0.0
    );
    var southwestPosition = Cartesian3.fromRadians(west, south);
    var expectedDistance = Cartesian3.distance(
      camera.position,
      southwestPosition
    );
    expect(tile.distanceToCamera(frameState)).toEqualEpsilon(
      expectedDistance,
      CesiumMath.EPSILON1
    );

    // From northeast
    camera.position = Cartesian3.fromRadians(
      east + offset,
      north + offset,
      0.0
    );
    var northeastPosition = Cartesian3.fromRadians(east, north);
    expectedDistance = Cartesian3.distance(camera.position, northeastPosition);
    expect(tile.distanceToCamera(frameState)).toEqualEpsilon(
      expectedDistance,
      CesiumMath.EPSILON1
    );
  });

  it("distanceToCamera close to south plane at the northern hemisphere", function () {
    var ellipsoid = Ellipsoid.WGS84;
    var tilingScheme = new GeographicTilingScheme({ ellipsoid: ellipsoid });

    // Tile on the northern hemisphere
    var rectangle = tilingScheme.tileXYToRectangle(5, 0, 2);
    var cameraPositionCartographic = new Cartographic(
      (rectangle.west + rectangle.east) * 0.5,
      rectangle.south,
      0.0
    );

    cameraPositionCartographic.south -= CesiumMath.EPSILON8;

    var tile = new TileBoundingRegion({
      rectangle: rectangle,
      minimumHeight: 0.0,
      maximumHeight: 10.0,
    });

    camera.position = ellipsoid.cartographicToCartesian(
      cameraPositionCartographic,
      new Cartesian3()
    );
    expect(tile.distanceToCamera(frameState)).toBeLessThan(
      CesiumMath.EPSILON8 * ellipsoid.maximumRadius
    );
  });

  it("distanceToCamera close to north plane at the southern hemisphere", function () {
    var ellipsoid = Ellipsoid.WGS84;
    var tilingScheme = new GeographicTilingScheme({ ellipsoid: ellipsoid });

    // Tile on the southern hemisphere
    var rectangle = tilingScheme.tileXYToRectangle(4, 3, 2);
    var cameraPositionCartographic = new Cartographic(
      (rectangle.west + rectangle.east) * 0.5,
      rectangle.north,
      0.0
    );

    cameraPositionCartographic.north += CesiumMath.EPSILON8;

    var tile = new TileBoundingRegion({
      rectangle: rectangle,
      minimumHeight: 0.0,
      maximumHeight: 10.0,
    });

    camera.position = ellipsoid.cartographicToCartesian(
      cameraPositionCartographic,
      new Cartesian3()
    );
    expect(tile.distanceToCamera(frameState)).toBeLessThan(
      CesiumMath.EPSILON8 * ellipsoid.maximumRadius
    );
  });

  it("distanceToCamera in 2D", function () {
    frameState.mode = SceneMode.SCENE2D;

    var offset = 0.0001;
    var west = -0.001;
    var south = -0.001;
    var east = 0.001;
    var north = 0.001;

    var tile = new TileBoundingRegion({
      rectangle: new Rectangle(west, south, east, north),
      minimumHeight: 0.0,
      maximumHeight: 10.0,
    });

    // Inside rectangle
    camera.position = Cartesian3.fromRadians(0.0, 0.0, 0.0);
    expect(tile.distanceToCamera(frameState)).toEqual(Ellipsoid.WGS84.radii.x);

    // From southwest
    var southwest3D = new Cartographic(west, south, 0.0);
    var southwest2D = frameState.mapProjection.project(southwest3D);
    var position3D = new Cartographic(west - offset, south - offset, 0.0);
    var position2D = frameState.mapProjection.project(position3D);
    var distance2D = Cartesian2.distance(southwest2D, position2D);
    var height = Ellipsoid.WGS84.radii.x;
    var expectedDistance = Math.sqrt(distance2D * distance2D + height * height);

    camera.position = Cartesian3.fromRadians(
      position3D.longitude,
      position3D.latitude
    );
    expect(tile.distanceToCamera(frameState)).toEqualEpsilon(
      expectedDistance,
      10.0
    );
  });

  it("createDebugVolume throws when color is undefined", function () {
    expect(function () {
      return tileBoundingRegion.createDebugVolume();
    }).toThrowDeveloperError();
  });

  it("can create a debug volume", function () {
    var debugVolume = tileBoundingRegion.createDebugVolume(Color.BLUE);
    expect(debugVolume).toBeDefined();
  });

  it("intersectPlane throws when plane is undefined", function () {
    expect(function () {
      return tileBoundingRegion.intersectPlane();
    }).toThrowDeveloperError();
  });

  it("intersects plane", function () {
    var normal = new Cartesian3();
    Cartesian3.normalize(Cartesian3.fromRadians(0.0, 0.0, 1.0), normal);
    var distanceFromCenter = Cartesian3.distance(
      new Cartesian3(0.0, 0.0, 0.0),
      Cartesian3.fromRadians(0.0, 0.0, 0.0)
    );
    var plane = new Plane(normal, -distanceFromCenter);
    expect(tileBoundingRegion.intersectPlane(plane)).toEqual(
      Intersect.INTERSECTING
    );
  });
});