2022.1.6

15832144755

2022-01-06 7b4c8991dca9cf2a809a95e239d144697d3afb56

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
import { Cartesian3 } from "../../Source/Cesium.js";
import { LinearSpline } from "../../Source/Cesium.js";
 
describe("Core/LinearSpline", function () {
  var points;
  var times;
 
  beforeEach(function () {
    points = [
      new Cartesian3(-1.0, -1.0, 0.0),
      new Cartesian3(-0.5, -0.125, 0.0),
      new Cartesian3(0.5, 0.125, 0.0),
      new Cartesian3(1.0, 1.0, 0.0),
    ];
    times = [0.0, 1.0, 2.0, 3.0];
  });
 
  it("constructor throws without points or times", function () {
    expect(function () {
      return new LinearSpline();
    }).toThrowDeveloperError();
  });
 
  it("constructor throws when control points length is less than 2", function () {
    expect(function () {
      return new LinearSpline({
        points: [Cartesian3.ZERO],
      });
    }).toThrowDeveloperError();
  });
 
  it("constructor throws when times.length is not equal to points.length", function () {
    expect(function () {
      return new LinearSpline({
        points: points,
        times: [0.0, 1.0],
      });
    }).toThrowDeveloperError();
  });
 
  it("evaluate throws without time", function () {
    var ls = new LinearSpline({
      points: points,
      times: times,
    });
 
    expect(function () {
      ls.evaluate();
    }).toThrowDeveloperError();
  });
 
  it("evaluate throws when time is out of range", function () {
    var ls = new LinearSpline({
      points: points,
      times: times,
    });
 
    expect(function () {
      ls.evaluate(times[0] - 1.0);
    }).toThrowDeveloperError();
  });
 
  it("evaluate without result parameter", function () {
    var ls = new LinearSpline({
      points: points,
      times: times,
    });
 
    expect(ls.evaluate(times[0])).toEqual(points[0]);
 
    var time = (times[1] + times[0]) * 0.5;
    var t = (time - times[0]) / (times[1] - times[0]);
    expect(ls.evaluate(time)).toEqual(
      Cartesian3.lerp(points[0], points[1], t, new Cartesian3())
    );
  });
 
  it("evaluate with result parameter", function () {
    var ls = new LinearSpline({
      points: points,
      times: times,
    });
    var result = new Cartesian3();
 
    var point = ls.evaluate(times[0], result);
    expect(point).toBe(result);
    expect(result).toEqual(points[0]);
  });
});