import { Cartesian3 } from "../../Source/Cesium.js";
|
import { Cartesian4 } from "../../Source/Cesium.js";
|
import { Math as CesiumMath } from "../../Source/Cesium.js";
|
import { Matrix3 } from "../../Source/Cesium.js";
|
import { Matrix4 } from "../../Source/Cesium.js";
|
import { Plane } from "../../Source/Cesium.js";
|
|
describe("Core/Plane", function () {
|
it("constructs", function () {
|
var normal = Cartesian3.UNIT_X;
|
var distance = 1.0;
|
var plane = new Plane(normal, distance);
|
expect(plane.normal).toEqual(normal);
|
expect(plane.distance).toEqual(distance);
|
});
|
|
it("constructor throws without a normal", function () {
|
expect(function () {
|
return new Plane(undefined, 0.0);
|
}).toThrowDeveloperError();
|
});
|
|
it("constructor throws if normal is not normalized", function () {
|
expect(function () {
|
return new Plane(new Cartesian3(1.0, 2.0, 3.0), 0.0);
|
}).toThrowDeveloperError();
|
});
|
|
it("constructor throws without a distance", function () {
|
expect(function () {
|
return new Plane(Cartesian3.UNIT_X, undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("constructs from a point and a normal", function () {
|
var normal = new Cartesian3(1.0, 2.0, 3.0);
|
normal = Cartesian3.normalize(normal, normal);
|
var point = new Cartesian3(4.0, 5.0, 6.0);
|
var plane = Plane.fromPointNormal(point, normal);
|
expect(plane.normal).toEqual(normal);
|
expect(plane.distance).toEqual(-Cartesian3.dot(normal, point));
|
});
|
|
it("constructs from a point and a normal with result", function () {
|
var normal = new Cartesian3(1.0, 2.0, 3.0);
|
normal = Cartesian3.normalize(normal, normal);
|
var point = new Cartesian3(4.0, 5.0, 6.0);
|
|
var plane = new Plane(Cartesian3.UNIT_X, 0.0);
|
Plane.fromPointNormal(point, normal, plane);
|
|
expect(plane.normal).toEqual(normal);
|
expect(plane.distance).toEqual(-Cartesian3.dot(normal, point));
|
});
|
|
it("constructs from a Cartesian4 without result", function () {
|
var result = Plane.fromCartesian4(Cartesian4.UNIT_X);
|
|
expect(result.normal).toEqual(Cartesian3.UNIT_X);
|
expect(result.distance).toEqual(0.0);
|
});
|
|
it("constructs from a Cartesian4 with result", function () {
|
var result = new Plane(Cartesian3.UNIT_X, 0.0);
|
Plane.fromCartesian4(Cartesian4.UNIT_X, result);
|
|
expect(result.normal).toEqual(Cartesian3.UNIT_X);
|
expect(result.distance).toEqual(0.0);
|
});
|
|
it("fromPointNormal throws without a point", function () {
|
expect(function () {
|
return Plane.fromPointNormal(undefined, Cartesian3.UNIT_X);
|
}).toThrowDeveloperError();
|
});
|
|
it("fromPointNormal throws without a normal", function () {
|
expect(function () {
|
return Plane.fromPointNormal(Cartesian3.UNIT_X, undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("fromPointNormal throws if normal is not normalized", function () {
|
expect(function () {
|
return Plane.fromPointNormal(Cartesian3.ZERO, Cartesian3.ZERO);
|
}).toThrowDeveloperError();
|
});
|
|
it("fromCartesian4 throws without coefficients", function () {
|
expect(function () {
|
return Plane.fromCartesian4(undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("fromCartesian4 throws if normal is not normalized", function () {
|
expect(function () {
|
return Plane.fromCartesian4(new Cartesian4(1.0, 2.0, 3.0, 4.0));
|
}).toThrowDeveloperError();
|
});
|
|
it("gets the distance to a point", function () {
|
var normal = new Cartesian3(1.0, 2.0, 3.0);
|
normal = Cartesian3.normalize(normal, normal);
|
var plane = new Plane(normal, 12.34);
|
var point = new Cartesian3(4.0, 5.0, 6.0);
|
|
expect(Plane.getPointDistance(plane, point)).toEqual(
|
Cartesian3.dot(plane.normal, point) + plane.distance
|
);
|
});
|
|
it("getPointDistance throws without a plane", function () {
|
var point = Cartesian3.ZERO;
|
expect(function () {
|
return Plane.getPointDistance(undefined, point);
|
}).toThrowDeveloperError();
|
});
|
|
it("getPointDistance throws without a point", function () {
|
var plane = new Plane(Cartesian3.UNIT_X, 0.0);
|
expect(function () {
|
return Plane.getPointDistance(plane, undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("projects a point onto the plane", function () {
|
var plane = new Plane(Cartesian3.UNIT_X, 0.0);
|
var point = new Cartesian3(1.0, 1.0, 0.0);
|
var result = Plane.projectPointOntoPlane(plane, point);
|
expect(result).toEqual(new Cartesian3(0.0, 1.0, 0.0));
|
|
plane = new Plane(Cartesian3.UNIT_Y, 0.0);
|
result = Plane.projectPointOntoPlane(plane, point);
|
expect(result).toEqual(new Cartesian3(1.0, 0.0, 0.0));
|
});
|
|
it("projectPointOntoPlane uses result parameter", function () {
|
var plane = new Plane(Cartesian3.UNIT_X, 0.0);
|
var point = new Cartesian3(1.0, 1.0, 0.0);
|
var result = new Cartesian3();
|
var returnedResult = Plane.projectPointOntoPlane(plane, point, result);
|
expect(result).toBe(returnedResult);
|
expect(result).toEqual(new Cartesian3(0.0, 1.0, 0.0));
|
});
|
|
it("projectPointOntoPlane requires the plane and point parameters", function () {
|
expect(function () {
|
return Plane.projectPointOntoPlane(
|
new Plane(Cartesian3.UNIT_X, 0),
|
undefined
|
);
|
}).toThrowDeveloperError();
|
|
expect(function () {
|
return Plane.projectPointOntoPlane(undefined, new Cartesian3());
|
}).toThrowDeveloperError();
|
});
|
|
it("clone throws without a plane", function () {
|
expect(function () {
|
Plane.clone(undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("clones a plane instance", function () {
|
var normal = new Cartesian3(1.0, 2.0, 3.0);
|
normal = Cartesian3.normalize(normal, normal);
|
var distance = 4.0;
|
var plane = new Plane(normal, distance);
|
|
var result = Plane.clone(plane);
|
expect(result.normal).toEqual(normal);
|
expect(result.distance).toEqual(distance);
|
});
|
|
it("clones a plane instance into a result paramter", function () {
|
var normal = new Cartesian3(1.0, 2.0, 3.0);
|
normal = Cartesian3.normalize(normal, normal);
|
var distance = 4.0;
|
var plane = new Plane(normal, distance);
|
|
var result = new Plane(Cartesian3.UNIT_X, 1.0);
|
|
Plane.clone(plane, result);
|
expect(result.normal).toEqual(normal);
|
expect(result.distance).toEqual(distance);
|
});
|
|
it("equals returns true only if two planes are equal by normal and distance", function () {
|
var left = new Plane(Cartesian3.UNIT_X, 0.0);
|
var right = new Plane(Cartesian3.UNIT_Y, 1.0);
|
|
expect(Plane.equals(left, right)).toBe(false);
|
|
right.distance = 0.0;
|
|
expect(Plane.equals(left, right)).toBe(false);
|
|
right.normal = Cartesian3.UNIT_X;
|
|
expect(Plane.equals(left, right)).toBe(true);
|
|
right.distance = 1.0;
|
|
expect(Plane.equals(left, right)).toBe(false);
|
});
|
|
it("equals throws developer error is left is undefined", function () {
|
var plane = new Plane(Cartesian3.UNIT_X, 0.0);
|
expect(function () {
|
return Plane.equals(undefined, plane);
|
}).toThrowDeveloperError();
|
});
|
|
it("equals throws developer error is right is undefined", function () {
|
var plane = new Plane(Cartesian3.UNIT_X, 0.0);
|
expect(function () {
|
return Plane.equals(plane, undefined);
|
}).toThrowDeveloperError();
|
});
|
|
it("transforms a plane according to a transform", function () {
|
var normal = new Cartesian3(1.0, 2.0, 3.0);
|
normal = Cartesian3.normalize(normal, normal);
|
var plane = new Plane(normal, 12.34);
|
|
var transform = Matrix4.fromUniformScale(2.0);
|
transform = Matrix4.multiplyByMatrix3(
|
transform,
|
Matrix3.fromRotationY(Math.PI),
|
transform
|
);
|
|
var transformedPlane = Plane.transform(plane, transform);
|
expect(transformedPlane.distance).toEqual(plane.distance * 2.0);
|
expect(transformedPlane.normal.x).toEqualEpsilon(
|
-plane.normal.x,
|
CesiumMath.EPSILON10
|
);
|
expect(transformedPlane.normal.y).toEqual(plane.normal.y);
|
expect(transformedPlane.normal.z).toEqual(-plane.normal.z);
|
});
|
|
it("transforms a plane according to a non-uniform scale transform", function () {
|
var normal = new Cartesian3(1.0, 0.0, 1.0);
|
normal = Cartesian3.normalize(normal, normal);
|
var plane = new Plane(normal, 0.0);
|
var planeOrigin = new Cartesian3(0.0, 0.0, 0.0);
|
var planePosition = new Cartesian3(1.0, 0.0, -1.0);
|
var planeDiff = Cartesian3.subtract(
|
planePosition,
|
planeOrigin,
|
new Cartesian3()
|
);
|
expect(Cartesian3.dot(planeDiff, plane.normal)).toEqualEpsilon(
|
0.0,
|
CesiumMath.EPSILON16
|
);
|
|
var transform = Matrix4.fromScale(
|
new Cartesian3(4.0, 1.0, 10.0),
|
new Matrix4()
|
);
|
var transformPlane = Plane.transform(plane, transform);
|
var transformPlaneDiff = Matrix4.multiplyByPointAsVector(
|
transform,
|
planeDiff,
|
new Cartesian3()
|
);
|
expect(
|
Cartesian3.dot(transformPlaneDiff, transformPlane.normal)
|
).toEqualEpsilon(0.0, CesiumMath.EPSILON16);
|
});
|
|
it("transform throws without a plane", function () {
|
var transform = Matrix4.IDENTITY;
|
expect(function () {
|
return Plane.transform(undefined, transform);
|
}).toThrowDeveloperError();
|
});
|
|
it("transform throws without a transform", function () {
|
var plane = new Plane(Cartesian3.UNIT_X, 0.0);
|
expect(function () {
|
return Plane.transform(plane, undefined);
|
}).toThrowDeveloperError();
|
});
|
});
|
