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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
import { Cartesian3 } from "../../Source/Cesium.js";
import { Ray } from "../../Source/Cesium.js";
 
describe("Core/Ray", function () {
  it("default constructor create zero valued Ray", function () {
    var ray = new Ray();
    expect(ray.origin).toEqual(Cartesian3.ZERO);
    expect(ray.direction).toEqual(Cartesian3.ZERO);
  });
 
  it("constructor sets expected properties", function () {
    var origin = Cartesian3.UNIT_Y;
    var direction = Cartesian3.UNIT_X;
    var ray = new Ray(origin, direction);
    expect(ray.origin).toEqual(origin);
    expect(ray.direction).toEqual(direction);
  });
 
  it("constructor normalizes direction", function () {
    var origin = Cartesian3.UNIT_Y;
    var direction = Cartesian3.multiplyByScalar(
      Cartesian3.UNIT_X,
      18,
      new Cartesian3()
    );
    var ray = new Ray(origin, direction);
    expect(ray.origin).toEqual(origin);
    expect(ray.direction).toEqual(Cartesian3.UNIT_X);
  });
 
  it("clone without a result parameter", function () {
    var direction = Cartesian3.normalize(
      new Cartesian3(1, 2, 3),
      new Cartesian3()
    );
    var ray = new Ray(Cartesian3.UNIT_X, direction);
    var returnedResult = Ray.clone(ray);
    expect(ray).not.toBe(returnedResult);
    expect(ray.origin).not.toBe(returnedResult.origin);
    expect(ray.direction).not.toBe(returnedResult.direction);
    expect(ray).toEqual(returnedResult);
  });
 
  it("clone with a result parameter", function () {
    var direction = Cartesian3.normalize(
      new Cartesian3(1, 2, 3),
      new Cartesian3()
    );
    var ray = new Ray(Cartesian3.UNIT_X, direction);
    var result = new Ray();
    var returnedResult = Ray.clone(ray, result);
    expect(ray).not.toBe(result);
    expect(ray.origin).not.toBe(returnedResult.origin);
    expect(ray.direction).not.toBe(returnedResult.direction);
    expect(result).toBe(returnedResult);
    expect(ray).toEqual(result);
  });
 
  it("clone works with a result parameter that is an input parameter", function () {
    var direction = Cartesian3.normalize(
      new Cartesian3(1, 2, 3),
      new Cartesian3()
    );
    var ray = new Ray(Cartesian3.UNIT_X, direction);
    var returnedResult = Ray.clone(ray, ray);
    expect(ray).toBe(returnedResult);
  });
 
  it("clone returns undefined if ray is undefined", function () {
    expect(Ray.clone()).toBeUndefined();
  });
 
  it("getPoint along ray works without a result parameter", function () {
    var direction = Cartesian3.normalize(
      new Cartesian3(1, 2, 3),
      new Cartesian3()
    );
    var ray = new Ray(Cartesian3.UNIT_X, direction);
    for (var i = -10; i < 11; i++) {
      var expectedResult = Cartesian3.add(
        Cartesian3.multiplyByScalar(direction, i, new Cartesian3()),
        Cartesian3.UNIT_X,
        new Cartesian3()
      );
      var returnedResult = Ray.getPoint(ray, i);
      expect(returnedResult).toEqual(expectedResult);
    }
  });
 
  it("getPoint works with a result parameter", function () {
    var direction = Cartesian3.normalize(
      new Cartesian3(1, 2, 3),
      new Cartesian3()
    );
    var ray = new Ray(Cartesian3.UNIT_X, direction);
    var result = new Cartesian3();
    for (var i = -10; i < 11; i++) {
      var expectedResult = Cartesian3.add(
        Cartesian3.multiplyByScalar(direction, i, new Cartesian3()),
        Cartesian3.UNIT_X,
        new Cartesian3()
      );
      var returnedResult = Ray.getPoint(ray, i, result);
      expect(result).toBe(returnedResult);
      expect(returnedResult).toEqual(expectedResult);
    }
  });
 
  it("getPoint throws without a point", function () {
    var direction = Cartesian3.normalize(
      new Cartesian3(1, 2, 3),
      new Cartesian3()
    );
    var ray = new Ray(Cartesian3.UNIT_X, direction);
    expect(function () {
      Ray.getPoint(ray, undefined);
    }).toThrowDeveloperError();
  });
});