ashatora/openlayers
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Make code prettier

Browse Source 
This updates ESLint and our shared eslint-config-openlayers to use Prettier.  Most formatting changes were automatically applied with this:

    npm run lint -- --fix

A few manual changes were required:

 * In `examples/offscreen-canvas.js`, the `//eslint-disable-line` comment needed to be moved to the appropriate line to disable the error about the `'worker-loader!./offscreen-canvas.worker.js'` import.
 * In `examples/webpack/exapmle-builder.js`, spaces could not be added after a couple `function`s for some reason.  While editing this, I reworked `ExampleBuilder` to be a class.
 * In `src/ol/format/WMSGetFeatureInfo.js`, the `// @ts-ignore` comment needed to be moved down one line so it applied to the `parsersNS` argument.
This commit is contained in:
Tim Schaub
2020-04-06 12:25:12 -06:00
parent 53b48baf62
commit 054af09032
790 changed files with 46833 additions and 33765 deletions
Download Patch File Download Diff File Expand all files Collapse all files
test/spec/ol/geom/flat/area.test.js
+11 -13
View File
@@ -1,29 +1,27 @@
import {linearRing, linearRings} from '../../../../../src/ol/geom/flat/area.js';
describe('ol.geom.flat.area', function() {
describe('ol.geom.flat.area.linearRing', function() {
it('calculates the area of a triangle', function() {
describe('ol.geom.flat.area', function () {
describe('ol.geom.flat.area.linearRing', function () {
it('calculates the area of a triangle', function () {
const area = linearRing([0, 0, 0.5, 1, 1, 0], 0, 6, 2);
expect(area).to.be(0.5);
});
it('calculates the area of a unit square', function() {
it('calculates the area of a unit square', function () {
const area = linearRing([0, 0, 0, 1, 1, 1, 1, 0], 0, 8, 2);
expect(area).to.be(1);
});
});
describe('ol.geom.flat.area.linearRings', function() {
it('calculates the area with holes', function() {
describe('ol.geom.flat.area.linearRings', function () {
it('calculates the area with holes', function () {
const area = linearRings(
[0, 0, 0, 3, 3, 3, 3, 0, 1, 1, 2, 1, 2, 2, 1, 2], 0, [8, 16], 2);
[0, 0, 0, 3, 3, 3, 3, 0, 1, 1, 2, 1, 2, 2, 1, 2],
0,
[8, 16],
2
);
expect(area).to.be(8);
});
});
});
test/spec/ol/geom/flat/center.test.js
+50 -21
View File
@@ -1,15 +1,20 @@
import {linearRingss as linearRingssCenter} from '../../../../../src/ol/geom/flat/center.js';
import MultiPolygon from '../../../../../src/ol/geom/MultiPolygon.js';
import {linearRingss as linearRingssCenter} from '../../../../../src/ol/geom/flat/center.js';
describe('ol.geom.flat.center', function() {
describe('ol.geom.flat.center.linearRingss', function() {
it('calculates the center of a square', function() {
const squareMultiPoly = new MultiPolygon([[
[[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]
]]);
describe('ol.geom.flat.center', function () {
describe('ol.geom.flat.center.linearRingss', function () {
it('calculates the center of a square', function () {
const squareMultiPoly = new MultiPolygon([
[
[
[0, 0],
[0, 1],
[1, 1],
[1, 0],
[0, 0],
],
],
]);
const got = linearRingssCenter(
squareMultiPoly.flatCoordinates,
0,
@@ -19,14 +24,26 @@ describe('ol.geom.flat.center', function() {
expect(got).to.eql([0.5, 0.5]);
});
it('calculates the centers of two squares', function() {
it('calculates the centers of two squares', function () {
const squareMultiPoly = new MultiPolygon([
[
[[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]
[
[0, 0],
[0, 1],
[1, 1],
[1, 0],
[0, 0],
],
],
[
[[3, 0], [3, 1], [4, 1], [4, 0], [3, 0]]
]
[
[3, 0],
[3, 1],
[4, 1],
[4, 0],
[3, 0],
],
],
]);
const got = linearRingssCenter(
squareMultiPoly.flatCoordinates,
@@ -37,11 +54,25 @@ describe('ol.geom.flat.center', function() {
expect(got).to.eql([0.5, 0.5, 3.5, 0.5]);
});
it('does not care about holes', function() {
const polywithHole = new MultiPolygon([[
[[0, 0], [0, 5], [5, 5], [5, 0], [0, 0]],
[[1, 1], [1, 4], [4, 4], [4, 1], [1, 1]]
]]);
it('does not care about holes', function () {
const polywithHole = new MultiPolygon([
[
[
[0, 0],
[0, 5],
[5, 5],
[5, 0],
[0, 0],
],
[
[1, 1],
[1, 4],
[4, 4],
[4, 1],
[1, 1],
],
],
]);
const got = linearRingssCenter(
polywithHole.flatCoordinates,
0,
@@ -50,7 +81,5 @@ describe('ol.geom.flat.center', function() {
);
expect(got).to.eql([2.5, 2.5]);
});
});
});
test/spec/ol/geom/flat/closest.test.js
+345 -98
View File
@@ -1,143 +1,390 @@
import {assignClosestPoint, maxSquaredDelta} from '../../../../../src/ol/geom/flat/closest.js';
describe('ol.geom.flat.closest', function() {
describe('with simple data', function() {
import {
assignClosestPoint,
maxSquaredDelta,
} from '../../../../../src/ol/geom/flat/closest.js';
describe('ol.geom.flat.closest', function () {
describe('with simple data', function () {
const flatCoordinates = [0, 0, 1, 0, 3, 0, 5, 0, 6, 0, 8, 0, 11, 0];
describe('ol.geom.flat.closest.maxSquaredDelta', function() {
it('returns the expected value in simple cases', function() {
expect(maxSquaredDelta(
flatCoordinates, 0, flatCoordinates.length, 2, 0)).to.be(9);
describe('ol.geom.flat.closest.maxSquaredDelta', function () {
it('returns the expected value in simple cases', function () {
expect(
maxSquaredDelta(flatCoordinates, 0, flatCoordinates.length, 2, 0)
).to.be(9);
});
});
describe('ol.geom.flat.closest.assignClosestPoint', function() {
it('returns the expected value', function() {
const maxDelta = Math.sqrt(maxSquaredDelta(
flatCoordinates, 0, flatCoordinates.length, 2, 0));
describe('ol.geom.flat.closest.assignClosestPoint', function () {
it('returns the expected value', function () {
const maxDelta = Math.sqrt(
maxSquaredDelta(flatCoordinates, 0, flatCoordinates.length, 2, 0)
);
expect(maxDelta).to.be(3);
const closestPoint = [NaN, NaN];
expect(assignClosestPoint(
flatCoordinates, 0, flatCoordinates.length, 2,
maxDelta, false, 0, 0, closestPoint, Infinity)).to.be(0);
expect(
assignClosestPoint(
flatCoordinates,
0,
flatCoordinates.length,
2,
maxDelta,
false,
0,
0,
closestPoint,
Infinity
)
).to.be(0);
expect(closestPoint).to.eql([0, 0]);
expect(assignClosestPoint(
flatCoordinates, 0, flatCoordinates.length, 2,
maxDelta, false, 4, 1, closestPoint, Infinity)).to.be(1);
expect(
assignClosestPoint(
flatCoordinates,
0,
flatCoordinates.length,
2,
maxDelta,
false,
4,
1,
closestPoint,
Infinity
)
).to.be(1);
expect(closestPoint).to.eql([4, 0]);
expect(assignClosestPoint(
flatCoordinates, 0, flatCoordinates.length, 2,
maxDelta, false, 5, 2, closestPoint, Infinity)).to.be(4);
expect(
assignClosestPoint(
flatCoordinates,
0,
flatCoordinates.length,
2,
maxDelta,
false,
5,
2,
closestPoint,
Infinity
)
).to.be(4);
expect(closestPoint).to.eql([5, 0]);
expect(assignClosestPoint(
flatCoordinates, 0, flatCoordinates.length, 2,
maxDelta, false, 10, 100, closestPoint, Infinity)).to.be(10000);
expect(
assignClosestPoint(
flatCoordinates,
0,
flatCoordinates.length,
2,
maxDelta,
false,
10,
100,
closestPoint,
Infinity
)
).to.be(10000);
expect(closestPoint).to.eql([10, 0]);
});
});
});
describe('with real data', function() {
describe('with real data', function () {
const flatCoordinates = [
224.55, 250.15, 226.91, 244.19, 233.31, 241.45, 234.98, 236.06,
244.21, 232.76, 262.59, 215.31, 267.76, 213.81, 273.57, 201.84,
273.12, 192.16, 277.62, 189.03, 280.36, 181.41, 286.51, 177.74,
292.41, 159.37, 296.91, 155.64, 314.95, 151.37, 319.75, 145.16,
330.33, 137.57, 341.48, 139.96, 369.98, 137.89, 387.39, 142.51,
391.28, 139.39, 409.52, 141.14, 414.82, 139.75, 427.72, 127.30,
439.60, 119.74, 474.93, 107.87, 486.51, 106.75, 489.20, 109.45,
493.79, 108.63, 504.74, 119.66, 512.96, 122.35, 518.63, 120.89,
524.09, 126.88, 529.57, 127.86, 534.21, 140.93, 539.27, 147.24,
567.69, 148.91, 575.25, 157.26, 580.62, 158.15, 601.53, 156.85,
617.74, 159.86, 622.00, 167.04, 629.55, 194.60, 638.90, 195.61,
641.26, 200.81, 651.77, 204.56, 671.55, 222.55, 683.68, 217.45,
695.25, 219.15, 700.64, 217.98, 703.12, 214.36, 712.26, 215.87,
721.49, 212.81, 727.81, 213.36, 729.98, 208.73, 735.32, 208.20,
739.94, 204.77, 769.98, 208.42, 779.60, 216.87, 784.20, 218.16,
800.24, 214.62, 810.53, 219.73, 817.19, 226.82, 820.77, 236.17,
827.23, 236.16, 829.89, 239.89, 851.00, 248.94, 859.88, 255.49,
865.21, 268.53, 857.95, 280.30, 865.48, 291.45, 866.81, 298.66,
864.68, 302.71, 867.79, 306.17, 859.87, 311.37, 860.08, 314.35,
858.29, 314.94, 858.10, 327.60, 854.54, 335.40, 860.92, 343.00,
856.43, 350.15, 851.42, 352.96, 849.84, 359.59, 854.56, 365.53,
849.74, 370.38, 844.09, 371.89, 844.75, 380.44, 841.52, 383.67,
839.57, 390.40, 845.59, 399.05, 848.40, 407.55, 843.71, 411.30,
844.09, 419.88, 839.51, 432.76, 841.33, 441.04, 847.62, 449.22,
847.16, 458.44, 851.38, 462.79, 853.97, 471.15, 866.36, 480.77
224.55,
250.15,
226.91,
244.19,
233.31,
241.45,
234.98,
236.06,
244.21,
232.76,
262.59,
215.31,
267.76,
213.81,
273.57,
201.84,
273.12,
192.16,
277.62,
189.03,
280.36,
181.41,
286.51,
177.74,
292.41,
159.37,
296.91,
155.64,
314.95,
151.37,
319.75,
145.16,
330.33,
137.57,
341.48,
139.96,
369.98,
137.89,
387.39,
142.51,
391.28,
139.39,
409.52,
141.14,
414.82,
139.75,
427.72,
127.3,
439.6,
119.74,
474.93,
107.87,
486.51,
106.75,
489.2,
109.45,
493.79,
108.63,
504.74,
119.66,
512.96,
122.35,
518.63,
120.89,
524.09,
126.88,
529.57,
127.86,
534.21,
140.93,
539.27,
147.24,
567.69,
148.91,
575.25,
157.26,
580.62,
158.15,
601.53,
156.85,
617.74,
159.86,
622.0,
167.04,
629.55,
194.6,
638.9,
195.61,
641.26,
200.81,
651.77,
204.56,
671.55,
222.55,
683.68,
217.45,
695.25,
219.15,
700.64,
217.98,
703.12,
214.36,
712.26,
215.87,
721.49,
212.81,
727.81,
213.36,
729.98,
208.73,
735.32,
208.2,
739.94,
204.77,
769.98,
208.42,
779.6,
216.87,
784.2,
218.16,
800.24,
214.62,
810.53,
219.73,
817.19,
226.82,
820.77,
236.17,
827.23,
236.16,
829.89,
239.89,
851.0,
248.94,
859.88,
255.49,
865.21,
268.53,
857.95,
280.3,
865.48,
291.45,
866.81,
298.66,
864.68,
302.71,
867.79,
306.17,
859.87,
311.37,
860.08,
314.35,
858.29,
314.94,
858.1,
327.6,
854.54,
335.4,
860.92,
343.0,
856.43,
350.15,
851.42,
352.96,
849.84,
359.59,
854.56,
365.53,
849.74,
370.38,
844.09,
371.89,
844.75,
380.44,
841.52,
383.67,
839.57,
390.4,
845.59,
399.05,
848.4,
407.55,
843.71,
411.3,
844.09,
419.88,
839.51,
432.76,
841.33,
441.04,
847.62,
449.22,
847.16,
458.44,
851.38,
462.79,
853.97,
471.15,
866.36,
480.77,
];
describe('ol.geom.closest.maxSquaredDelta', function() {
it('returns the expected value', function() {
expect(maxSquaredDelta(
flatCoordinates, 0, flatCoordinates.length, 2, 0)).
to.roughlyEqual(1389.1058, 1e-9);
describe('ol.geom.closest.maxSquaredDelta', function () {
it('returns the expected value', function () {
expect(
maxSquaredDelta(flatCoordinates, 0, flatCoordinates.length, 2, 0)
).to.roughlyEqual(1389.1058, 1e-9);
});
});
describe('ol.geom.flat.closest.assignClosestPoint', function() {
it('returns the expected value', function() {
const maxDelta = Math.sqrt(maxSquaredDelta(
flatCoordinates, 0, flatCoordinates.length, 2, 0));
describe('ol.geom.flat.closest.assignClosestPoint', function () {
it('returns the expected value', function () {
const maxDelta = Math.sqrt(
maxSquaredDelta(flatCoordinates, 0, flatCoordinates.length, 2, 0)
);
expect(maxDelta).to.roughlyEqual(Math.sqrt(1389.1058), 1e-9);
const closestPoint = [NaN, NaN];
expect(assignClosestPoint(
flatCoordinates, 0, flatCoordinates.length, 2,
maxDelta, false, 0, 0, closestPoint, Infinity)).
to.roughlyEqual(110902.405, 1e-9);
expect(
assignClosestPoint(
flatCoordinates,
0,
flatCoordinates.length,
2,
maxDelta,
false,
0,
0,
closestPoint,
Infinity
)
).to.roughlyEqual(110902.405, 1e-9);
expect(closestPoint).to.eql([292.41, 159.37]);
expect(assignClosestPoint(
flatCoordinates, 0, flatCoordinates.length, 2,
maxDelta, false, 500, 500, closestPoint, Infinity)).
to.roughlyEqual(106407.905, 1e-9);
expect(
assignClosestPoint(
flatCoordinates,
0,
flatCoordinates.length,
2,
maxDelta,
false,
500,
500,
closestPoint,
Infinity
)
).to.roughlyEqual(106407.905, 1e-9);
expect(closestPoint).to.eql([671.55, 222.55]);
expect(assignClosestPoint(
flatCoordinates, 0, flatCoordinates.length, 2,
maxDelta, false, 1000, 500, closestPoint, Infinity)).
to.roughlyEqual(18229.4425, 1e-9);
expect(
assignClosestPoint(
flatCoordinates,
0,
flatCoordinates.length,
2,
maxDelta,
false,
1000,
500,
closestPoint,
Infinity
)
).to.roughlyEqual(18229.4425, 1e-9);
expect(closestPoint).to.eql([866.36, 480.77]);
});
});
});
describe('with multi-dimensional data', function() {
describe('with multi-dimensional data', function () {
const flatCoordinates = [0, 0, 10, -10, 2, 2, 30, -20];
const stride = 4;
describe('ol.geom.flat.closest.assignClosestPoint', function() {
it('interpolates M coordinates', function() {
const maxDelta = Math.sqrt(maxSquaredDelta(
flatCoordinates, 0, flatCoordinates.length, stride, 0));
describe('ol.geom.flat.closest.assignClosestPoint', function () {
it('interpolates M coordinates', function () {
const maxDelta = Math.sqrt(
maxSquaredDelta(flatCoordinates, 0, flatCoordinates.length, stride, 0)
);
expect(maxDelta).to.roughlyEqual(Math.sqrt(8), 1e-9);
const closestPoint = [NaN, NaN];
expect(assignClosestPoint(
flatCoordinates, 0, flatCoordinates.length, stride,
maxDelta, false, 1, 1, closestPoint, Infinity)).
to.roughlyEqual(0, 1e-9);
expect(
assignClosestPoint(
flatCoordinates,
0,
flatCoordinates.length,
stride,
maxDelta,
false,
1,
1,
closestPoint,
Infinity
)
).to.roughlyEqual(0, 1e-9);
expect(closestPoint).to.have.length(stride);
expect(closestPoint[0]).to.be(1);
expect(closestPoint[1]).to.be(1);
expect(closestPoint[2]).to.be(20);
expect(closestPoint[3]).to.be(-15);
});
});
});
});
test/spec/ol/geom/flat/contains.test.js
+80 -24
View File
@@ -1,40 +1,96 @@
import {linearRingContainsXY} from '../../../../../src/ol/geom/flat/contains.js';
describe('ol.geom.flat.contains', function() {
describe('with simple data', function() {
describe('ol.geom.flat.contains', function () {
describe('with simple data', function () {
const flatCoordinatesSimple = [0, 0, 1, 0, 1, 1, 0, 1];
const flatCoordinatesNonSimple = [0, 0, 4, 0, 4, 3, 1, 3, 1, 2, 3, 2, 3, 1, 2, 1, 2, 4, 0, 4];
const flatCoordinatesNonSimple = [
0,
0,
4,
0,
4,
3,
1,
3,
1,
2,
3,
2,
3,
1,
2,
1,
2,
4,
0,
4,
];
describe('ol.geom.flat.contains.linearRingContainsXY', function() {
it('returns true for point inside a simple polygon', function() {
expect(linearRingContainsXY(
flatCoordinatesSimple, 0, flatCoordinatesSimple.length, 2, 0.5, 0.5)).to.be(true);
describe('ol.geom.flat.contains.linearRingContainsXY', function () {
it('returns true for point inside a simple polygon', function () {
expect(
linearRingContainsXY(
flatCoordinatesSimple,
0,
flatCoordinatesSimple.length,
2,
0.5,
0.5
)
).to.be(true);
});
it('returns false for point outside a simple polygon', function() {
expect(linearRingContainsXY(
flatCoordinatesSimple, 0, flatCoordinatesSimple.length, 2, 1.5, 1.5)).to.be(false);
it('returns false for point outside a simple polygon', function () {
expect(
linearRingContainsXY(
flatCoordinatesSimple,
0,
flatCoordinatesSimple.length,
2,
1.5,
1.5
)
).to.be(false);
});
it('returns true for point inside a non-simple polygon', function() {
expect(linearRingContainsXY(
flatCoordinatesNonSimple, 0, flatCoordinatesNonSimple.length, 2, 1, 1)).to.be(true);
it('returns true for point inside a non-simple polygon', function () {
expect(
linearRingContainsXY(
flatCoordinatesNonSimple,
0,
flatCoordinatesNonSimple.length,
2,
1,
1
)
).to.be(true);
});
it('returns true for point inside an overlap of a non-simple polygon', function() {
expect(linearRingContainsXY(
flatCoordinatesNonSimple, 0, flatCoordinatesNonSimple.length, 2, 1.5, 2.5)).to.be(true);
it('returns true for point inside an overlap of a non-simple polygon', function () {
expect(
linearRingContainsXY(
flatCoordinatesNonSimple,
0,
flatCoordinatesNonSimple.length,
2,
1.5,
2.5
)
).to.be(true);
});
it('returns false for a point inside a hole of a non-simple polygon', function() {
expect(linearRingContainsXY(
flatCoordinatesNonSimple, 0, flatCoordinatesNonSimple.length, 2, 2.5, 1.5)).to.be(false);
it('returns false for a point inside a hole of a non-simple polygon', function () {
expect(
linearRingContainsXY(
flatCoordinatesNonSimple,
0,
flatCoordinatesNonSimple.length,
2,
2.5,
1.5
)
).to.be(false);
});
});
});
});
test/spec/ol/geom/flat/deflate.test.js
+34 -18
View File
@@ -1,38 +1,54 @@
import {deflateCoordinates, deflateCoordinatesArray} from '../../../../../src/ol/geom/flat/deflate.js';
describe('ol.geom.flat.deflate', function() {
describe('ol.geom.flat.deflate.deflateCoordinates', function() {
import {
deflateCoordinates,
deflateCoordinatesArray,
} from '../../../../../src/ol/geom/flat/deflate.js';
describe('ol.geom.flat.deflate', function () {
describe('ol.geom.flat.deflate.deflateCoordinates', function () {
let flatCoordinates;
beforeEach(function() {
beforeEach(function () {
flatCoordinates = [];
});
it('flattens coordinates', function() {
it('flattens coordinates', function () {
const offset = deflateCoordinates(
flatCoordinates, 0, [[1, 2], [3, 4]], 2);
flatCoordinates,
0,
[
[1, 2],
[3, 4],
],
2
);
expect(offset).to.be(4);
expect(flatCoordinates).to.eql([1, 2, 3, 4]);
});
});
describe('ol.geom.flat.deflate.deflateCoordinatesArray', function() {
describe('ol.geom.flat.deflate.deflateCoordinatesArray', function () {
let flatCoordinates;
beforeEach(function() {
beforeEach(function () {
flatCoordinates = [];
});
it('flattens arrays of coordinates', function() {
const ends = deflateCoordinatesArray(flatCoordinates, 0,
[[[1, 2], [3, 4]], [[5, 6], [7, 8]]], 2);
it('flattens arrays of coordinates', function () {
const ends = deflateCoordinatesArray(
flatCoordinates,
0,
[
[
[1, 2],
[3, 4],
],
[
[5, 6],
[7, 8],
],
],
2
);
expect(ends).to.eql([4, 8]);
expect(flatCoordinates).to.eql([1, 2, 3, 4, 5, 6, 7, 8]);
});
});
});
test/spec/ol/geom/flat/flip.test.js
+15 -17
View File
@@ -1,33 +1,31 @@
import {flipXY} from '../../../../../src/ol/geom/flat/flip.js';
describe('ol.geom.flat.flip', function() {
describe('ol.geom.flat.flip.flipXY', function() {
it('can flip XY coordinates', function() {
describe('ol.geom.flat.flip', function () {
describe('ol.geom.flat.flip.flipXY', function () {
it('can flip XY coordinates', function () {
const flatCoordinates = flipXY([1, 2, 3, 4], 0, 4, 2);
expect(flatCoordinates).to.eql([2, 1, 4, 3]);
});
it('can flip XY coordinates while preserving other dimensions', function() {
it('can flip XY coordinates while preserving other dimensions', function () {
const flatCoordinates = flipXY([1, 2, 3, 4, 5, 6, 7, 8], 0, 8, 4);
expect(flatCoordinates).to.eql([2, 1, 3, 4, 6, 5, 7, 8]);
});
it('can flip XY coordinates in place', function() {
it('can flip XY coordinates in place', function () {
const flatCoordinates = [1, 2, 3, 4];
expect(flipXY(flatCoordinates, 0, 4, 2, flatCoordinates)).to.be(flatCoordinates);
expect(flipXY(flatCoordinates, 0, 4, 2, flatCoordinates)).to.be(
flatCoordinates
);
expect(flatCoordinates).to.eql([2, 1, 4, 3]);
});
it('can flip XY coordinates in place while preserving other dimensions',
function() {
const flatCoordinates = [1, 2, 3, 4, 5, 6, 7, 8, 9];
expect(flipXY(flatCoordinates, 0, 9, 3, flatCoordinates)).to.be(flatCoordinates);
expect(flatCoordinates).to.eql([2, 1, 3, 5, 4, 6, 8, 7, 9]);
});
it('can flip XY coordinates in place while preserving other dimensions', function () {
const flatCoordinates = [1, 2, 3, 4, 5, 6, 7, 8, 9];
expect(flipXY(flatCoordinates, 0, 9, 3, flatCoordinates)).to.be(
flatCoordinates
);
expect(flatCoordinates).to.eql([2, 1, 3, 5, 4, 6, 8, 7, 9]);
});
});
});
test/spec/ol/geom/flat/inflate.test.js
+28 -16
View File
@@ -1,25 +1,37 @@
import {inflateCoordinates, inflateCoordinatesArray} from '../../../../../src/ol/geom/flat/inflate.js';
import {
inflateCoordinates,
inflateCoordinatesArray,
} from '../../../../../src/ol/geom/flat/inflate.js';
describe('ol.geom.flat.inflate', function() {
describe('ol.geom.flat.inflate.inflateCoordinates', function() {
it('inflates coordinates', function() {
describe('ol.geom.flat.inflate', function () {
describe('ol.geom.flat.inflate.inflateCoordinates', function () {
it('inflates coordinates', function () {
const coordinates = inflateCoordinates([1, 2, 3, 4], 0, 4, 2);
expect(coordinates).to.eql([[1, 2], [3, 4]]);
expect(coordinates).to.eql([
[1, 2],
[3, 4],
]);
});
});
describe('ol.geom.flat.inflate.inflateCoordinatesArray', function() {
it('inflates arrays of coordinates', function() {
describe('ol.geom.flat.inflate.inflateCoordinatesArray', function () {
it('inflates arrays of coordinates', function () {
const coordinatess = inflateCoordinatesArray(
[1, 2, 3, 4, 5, 6, 7, 8], 0, [4, 8], 2);
expect(coordinatess).to.eql([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]);
[1, 2, 3, 4, 5, 6, 7, 8],
0,
[4, 8],
2
);
expect(coordinatess).to.eql([
[
[1, 2],
[3, 4],
],
[
[5, 6],
[7, 8],
],
]);
});
});
});
test/spec/ol/geom/flat/interpolate.test.js
+41 -54
View File
@@ -1,80 +1,67 @@
import {interpolatePoint} from '../../../../../src/ol/geom/flat/interpolate.js';
describe('ol.geom.flat.interpolate', function() {
describe('ol.geom.flat.interpolate.interpolatePoint', function() {
it('returns the expected value for single points', function() {
describe('ol.geom.flat.interpolate', function () {
describe('ol.geom.flat.interpolate.interpolatePoint', function () {
it('returns the expected value for single points', function () {
const flatCoordinates = [0, 1];
const point =
interpolatePoint(flatCoordinates, 0, 2, 2, 0.5);
const point = interpolatePoint(flatCoordinates, 0, 2, 2, 0.5);
expect(point).to.eql([0, 1]);
});
it('returns the expected value for simple line segments', function() {
it('returns the expected value for simple line segments', function () {
const flatCoordinates = [0, 1, 2, 3];
const point =
interpolatePoint(flatCoordinates, 0, 4, 2, 0.5);
const point = interpolatePoint(flatCoordinates, 0, 4, 2, 0.5);
expect(point).to.eql([1, 2]);
});
it('returns the expected value when the mid point is an existing ' +
it(
'returns the expected value when the mid point is an existing ' +
'coordinate',
function() {
const flatCoordinates = [0, 1, 2, 3, 4, 5];
const point = interpolatePoint(
flatCoordinates, 0, 6, 2, 0.5);
expect(point).to.eql([2, 3]);
});
function () {
const flatCoordinates = [0, 1, 2, 3, 4, 5];
const point = interpolatePoint(flatCoordinates, 0, 6, 2, 0.5);
expect(point).to.eql([2, 3]);
}
);
it('also when vertices are repeated', function() {
it('also when vertices are repeated', function () {
const flatCoordinates = [0, 1, 2, 3, 2, 3, 4, 5];
const point = interpolatePoint(
flatCoordinates, 0, 8, 2, 0.5);
const point = interpolatePoint(flatCoordinates, 0, 8, 2, 0.5);
expect(point).to.eql([2, 3]);
});
it('returns the expected value when the midpoint falls halfway between ' +
it(
'returns the expected value when the midpoint falls halfway between ' +
'two existing coordinates',
function() {
const flatCoordinates = [0, 1, 2, 3, 4, 5, 6, 7];
const point = interpolatePoint(
flatCoordinates, 0, 8, 2, 0.5);
expect(point).to.eql([3, 4]);
});
function () {
const flatCoordinates = [0, 1, 2, 3, 4, 5, 6, 7];
const point = interpolatePoint(flatCoordinates, 0, 8, 2, 0.5);
expect(point).to.eql([3, 4]);
}
);
it('also when vertices are repeated', function() {
it('also when vertices are repeated', function () {
const flatCoordinates = [0, 1, 2, 3, 2, 3, 4, 5, 6, 7];
const point = interpolatePoint(
flatCoordinates, 0, 10, 2, 0.5);
const point = interpolatePoint(flatCoordinates, 0, 10, 2, 0.5);
expect(point).to.eql([3, 4]);
});
it('returns the expected value when the coordinates are not evenly spaced',
function() {
const flatCoordinates = [0, 1, 2, 3, 6, 7];
const point = interpolatePoint(
flatCoordinates, 0, 6, 2, 0.5);
expect(point).to.eql([3, 4]);
});
it('returns the expected value when the coordinates are not evenly spaced', function () {
const flatCoordinates = [0, 1, 2, 3, 6, 7];
const point = interpolatePoint(flatCoordinates, 0, 6, 2, 0.5);
expect(point).to.eql([3, 4]);
});
it('also when vertices are repeated',
function() {
const flatCoordinates = [0, 1, 2, 3, 2, 3, 6, 7];
const point = interpolatePoint(
flatCoordinates, 0, 8, 2, 0.5);
expect(point).to.eql([3, 4]);
});
it('returns the expected value when using opt_dest',
function() {
const flatCoordinates = [0, 1, 2, 3, 6, 7];
const point = interpolatePoint(
flatCoordinates, 0, 6, 2, 0.5, [0, 0]);
expect(point).to.eql([3, 4]);
});
it('also when vertices are repeated', function () {
const flatCoordinates = [0, 1, 2, 3, 2, 3, 6, 7];
const point = interpolatePoint(flatCoordinates, 0, 8, 2, 0.5);
expect(point).to.eql([3, 4]);
});
it('returns the expected value when using opt_dest', function () {
const flatCoordinates = [0, 1, 2, 3, 6, 7];
const point = interpolatePoint(flatCoordinates, 0, 6, 2, 0.5, [0, 0]);
expect(point).to.eql([3, 4]);
});
});
});
test/spec/ol/geom/flat/intersectsextent.test.js
+139 -55
View File
@@ -1,118 +1,202 @@
import {intersectsLinearRing, intersectsLineString, intersectsLinearRingArray} from '../../../../../src/ol/geom/flat/intersectsextent.js';
import {
intersectsLineString,
intersectsLinearRing,
intersectsLinearRingArray,
} from '../../../../../src/ol/geom/flat/intersectsextent.js';
describe('ol.geom.flat.intersectsextent', function() {
describe('ol.geom.flat.intersectsextent.intersectsLineString', function() {
describe('ol.geom.flat.intersectsextent', function () {
describe('ol.geom.flat.intersectsextent.intersectsLineString', function () {
let flatCoordinates;
beforeEach(function() {
beforeEach(function () {
flatCoordinates = [0, 0, 1, 1, 2, 2];
});
describe('linestring envelope does not intersect the extent', function() {
it('returns false', function() {
describe('linestring envelope does not intersect the extent', function () {
it('returns false', function () {
const extent = [3, 3, 4, 4];
const r = intersectsLineString(
flatCoordinates, 0, flatCoordinates.length, 2, extent);
flatCoordinates,
0,
flatCoordinates.length,
2,
extent
);
expect(r).to.be(false);
});
});
describe('linestring envelope within the extent', function() {
it('returns true', function() {
describe('linestring envelope within the extent', function () {
it('returns true', function () {
const extent = [-1, -1, 3, 3];
const r = intersectsLineString(
flatCoordinates, 0, flatCoordinates.length, 2, extent);
flatCoordinates,
0,
flatCoordinates.length,
2,
extent
);
expect(r).to.be(true);
});
});
describe('linestring envelope bisected by an edge of the extent',
function() {
it('returns true', function() {
const extent = [-0.1, 0.1, 2.1, 0.1];
const r = intersectsLineString(
flatCoordinates, 0, flatCoordinates.length, 2, extent);
expect(r).to.be(true);
});
describe('linestring envelope bisected by an edge of the extent', function () {
it('returns true', function () {
const extent = [-0.1, 0.1, 2.1, 0.1];
const r = intersectsLineString(
flatCoordinates,
0,
flatCoordinates.length,
2,
extent
);
expect(r).to.be(true);
});
describe('a segment intersects the extent', function() {
it('returns true', function() {
});
describe('a segment intersects the extent', function () {
it('returns true', function () {
const extent = [-0.5, -0.5, 0.5, 0.5];
const r = intersectsLineString(
flatCoordinates, 0, flatCoordinates.length, 2, extent);
flatCoordinates,
0,
flatCoordinates.length,
2,
extent
);
expect(r).to.be(true);
});
});
describe('no segments intersect the extent', function() {
it('returns false', function() {
describe('no segments intersect the extent', function () {
it('returns false', function () {
const extent = [0.5, 1.5, 1, 1.75];
const r = intersectsLineString(
flatCoordinates, 0, flatCoordinates.length, 2, extent);
flatCoordinates,
0,
flatCoordinates.length,
2,
extent
);
expect(r).to.be(false);
});
it('returns false', function() {
it('returns false', function () {
const extent = [1, 0.25, 1.5, 0.5];
const r = intersectsLineString(
flatCoordinates, 0, flatCoordinates.length, 2, extent);
flatCoordinates,
0,
flatCoordinates.length,
2,
extent
);
expect(r).to.be(false);
});
});
});
describe('ol.geom.flat.intersectsextent.intersectsLinearRing', function() {
describe('ol.geom.flat.intersectsextent.intersectsLinearRing', function () {
let flatCoordinates;
beforeEach(function() {
beforeEach(function () {
flatCoordinates = [0, 0, 1, 1, 2, 0, 1, -1, 0, 0];
});
describe('boundary intersects the extent', function() {
it('returns true', function() {
describe('boundary intersects the extent', function () {
it('returns true', function () {
const extent = [1.5, 0.0, 2.5, 1.0];
const r = intersectsLinearRing(
flatCoordinates, 0, flatCoordinates.length, 2, extent);
flatCoordinates,
0,
flatCoordinates.length,
2,
extent
);
expect(r).to.be(true);
});
});
describe('boundary does not intersect the extent and ring does not ' +
describe(
'boundary does not intersect the extent and ring does not ' +
'contain a corner of the extent',
function() {
it('returns false', function() {
const extent = [2.0, 0.5, 3, 1.5];
const r = intersectsLinearRing(
flatCoordinates, 0, flatCoordinates.length, 2, extent);
expect(r).to.be(false);
});
});
describe('ring contains the extent', function() {
it('returns true', function() {
function () {
it('returns false', function () {
const extent = [2.0, 0.5, 3, 1.5];
const r = intersectsLinearRing(
flatCoordinates,
0,
flatCoordinates.length,
2,
extent
);
expect(r).to.be(false);
});
}
);
describe('ring contains the extent', function () {
it('returns true', function () {
const extent = [0.75, -0.25, 1.25, 0.25];
const r = intersectsLinearRing(
flatCoordinates, 0, flatCoordinates.length, 2, extent);
flatCoordinates,
0,
flatCoordinates.length,
2,
extent
);
expect(r).to.be(true);
});
});
});
describe('ol.geom.flat.intersectsextent.intersectsLinearRingArray', function() {
describe('ol.geom.flat.intersectsextent.intersectsLinearRingArray', function () {
let flatCoordinates;
let ends;
beforeEach(function() {
flatCoordinates = [0, 0, 0, 10, 10, 10, 10, 0, 0, 0, /*hole*/2, 2, 8, 2, 8, 4, 5, 5, 8, 6, 8, 8, 2, 8, 2, 2];
beforeEach(function () {
flatCoordinates = [
0,
0,
0,
10,
10,
10,
10,
0,
0,
0,
/*hole*/ 2,
2,
8,
2,
8,
4,
5,
5,
8,
6,
8,
8,
2,
8,
2,
2,
];
ends = [10, flatCoordinates.length];
});
describe('ring with hole where hole contains the extent', function() {
it('returns true', function() {
describe('ring with hole where hole contains the extent', function () {
it('returns true', function () {
const extent = [3, 3, 3.5, 3.5];
const r = intersectsLinearRingArray(
flatCoordinates, 0, ends, 2, extent);
flatCoordinates,
0,
ends,
2,
extent
);
expect(r).to.be(false);
});
});
describe('ring with hole intersects the extent', function() {
it('returns true', function() {
describe('ring with hole intersects the extent', function () {
it('returns true', function () {
const extent = [3, 3, 6, 6];
const r = intersectsLinearRingArray(
flatCoordinates, 0, ends, 2, extent);
flatCoordinates,
0,
ends,
2,
extent
);
expect(r).to.be(true);
});
});
});
});
test/spec/ol/geom/flat/length.test.js
+17 -22
View File
@@ -1,15 +1,15 @@
import {lineStringLength, linearRingLength} from '../../../../../src/ol/geom/flat/length.js';
import {
lineStringLength,
linearRingLength,
} from '../../../../../src/ol/geom/flat/length.js';
describe('ol.geom.flat.length', function() {
describe('ol.geom.flat.length.lineStringLength', function() {
describe('stride = 2', function() {
describe('ol.geom.flat.length', function () {
describe('ol.geom.flat.length.lineStringLength', function () {
describe('stride = 2', function () {
const flatCoords = [0, 0, 1, 0, 1, 1, 0, 1];
const stride = 2;
it('calculates the total length of a lineString', function() {
it('calculates the total length of a lineString', function () {
const offset = 0;
const end = 8;
const expected = 3;
@@ -17,7 +17,7 @@ describe('ol.geom.flat.length', function() {
expect(got).to.be(expected);
});
it('calculates a partwise length of a lineString (offset)', function() {
it('calculates a partwise length of a lineString (offset)', function () {
const offset = 2;
const end = 8;
const expected = 2;
@@ -25,21 +25,20 @@ describe('ol.geom.flat.length', function() {
expect(got).to.be(expected);
});
it('calculates a partwise length of a lineString (end)', function() {
it('calculates a partwise length of a lineString (end)', function () {
const offset = 0;
const end = 4;
const expected = 1;
const got = lineStringLength(flatCoords, offset, end, stride);
expect(got).to.be(expected);
});
});
describe('stride = 3', function() {
describe('stride = 3', function () {
const flatCoords = [0, 0, 42, 1, 0, 42, 1, 1, 42, 0, 1, 42];
const stride = 3;
it('calculates the total length of a lineString', function() {
it('calculates the total length of a lineString', function () {
const offset = 0;
const end = 12;
const expected = 3;
@@ -47,7 +46,7 @@ describe('ol.geom.flat.length', function() {
expect(got).to.be(expected);
});
it('calculates a partwise length of a lineString (offset)', function() {
it('calculates a partwise length of a lineString (offset)', function () {
const offset = 3;
const end = 12;
const expected = 2;
@@ -55,20 +54,18 @@ describe('ol.geom.flat.length', function() {
expect(got).to.be(expected);
});
it('calculates a partwise length of a lineString (end)', function() {
it('calculates a partwise length of a lineString (end)', function () {
const offset = 0;
const end = 6;
const expected = 1;
const got = lineStringLength(flatCoords, offset, end, stride);
expect(got).to.be(expected);
});
});
});
describe('ol.geom.flat.length.linearRingLength', function() {
it('calculates the total length of a simple linearRing', function() {
describe('ol.geom.flat.length.linearRingLength', function () {
it('calculates the total length of a simple linearRing', function () {
const flatCoords = [0, 0, 1, 0, 1, 1, 0, 1];
const stride = 2;
const offset = 0;
@@ -78,7 +75,7 @@ describe('ol.geom.flat.length', function() {
expect(got).to.be(expected);
});
it('calculates the total length of a figure-8 linearRing', function() {
it('calculates the total length of a figure-8 linearRing', function () {
const flatCoords = [0, 0, 1, 0, 1, 1, 0, 1, 0, -1, -1, -1, -1, 0];
const stride = 2;
const offset = 0;
@@ -87,7 +84,5 @@ describe('ol.geom.flat.length', function() {
const got = linearRingLength(flatCoords, offset, end, stride);
expect(got).to.be(expected);
});
});
});
test/spec/ol/geom/flat/orient.test.js
+281 -56
View File
@@ -1,101 +1,255 @@
import {linearRingIsClockwise, linearRingsAreOriented,
linearRingssAreOriented, orientLinearRings, orientLinearRingsArray} from '../../../../../src/ol/geom/flat/orient.js';
import {
linearRingIsClockwise,
linearRingsAreOriented,
linearRingssAreOriented,
orientLinearRings,
orientLinearRingsArray,
} from '../../../../../src/ol/geom/flat/orient.js';
describe('ol.geom.flat.orient', function() {
describe('ol.geom.flat.orient.linearRingIsClockwise', function() {
it('identifies clockwise rings', function() {
describe('ol.geom.flat.orient', function () {
describe('ol.geom.flat.orient.linearRingIsClockwise', function () {
it('identifies clockwise rings', function () {
const flatCoordinates = [0, 1, 1, 4, 4, 3, 3, 0];
const isClockwise = linearRingIsClockwise(
flatCoordinates, 0, flatCoordinates.length, 2);
flatCoordinates,
0,
flatCoordinates.length,
2
);
expect(isClockwise).to.be(true);
});
it('identifies anti-clockwise rings', function() {
it('identifies anti-clockwise rings', function () {
const flatCoordinates = [2, 2, 3, 2, 3, 3, 2, 3];
const isClockwise = linearRingIsClockwise(
flatCoordinates, 0, flatCoordinates.length, 2);
flatCoordinates,
0,
flatCoordinates.length,
2
);
expect(isClockwise).to.be(false);
});
});
describe('ol.geom.flat.orient.linearRingsAreOriented', function() {
describe('ol.geom.flat.orient.linearRingsAreOriented', function () {
const oriented = linearRingsAreOriented;
const rightCoords = [
-180, -90, 180, -90, 180, 90, -180, 90, -180, -90,
-100, -45, -100, 45, 100, 45, 100, -45, -100, -45
-180,
-90,
180,
-90,
180,
90,
-180,
90,
-180,
-90,
-100,
-45,
-100,
45,
100,
45,
100,
-45,
-100,
-45,
];
const leftCoords = [
-180, -90, -180, 90, 180, 90, 180, -90, -180, -90,
-100, -45, 100, -45, 100, 45, -100, 45, -100, -45
-180,
-90,
-180,
90,
180,
90,
180,
-90,
-180,
-90,
-100,
-45,
100,
-45,
100,
45,
-100,
45,
-100,
-45,
];
const ends = [10, 20];
it('checks for left-hand orientation by default', function() {
it('checks for left-hand orientation by default', function () {
expect(oriented(rightCoords, 0, ends, 2)).to.be(false);
expect(oriented(leftCoords, 0, ends, 2)).to.be(true);
});
it('can check for right-hand orientation', function() {
it('can check for right-hand orientation', function () {
expect(oriented(rightCoords, 0, ends, 2, true)).to.be(true);
expect(oriented(leftCoords, 0, ends, 2, true)).to.be(false);
});
});
describe('ol.geom.flat.orient.linearRingssAreOriented', function() {
describe('ol.geom.flat.orient.linearRingssAreOriented', function () {
const oriented = linearRingssAreOriented;
const rightCoords = [
-180, -90, 180, -90, 180, 90, -180, 90, -180, -90,
-100, -45, -100, 45, 100, 45, 100, -45, -100, -45,
-180, -90, 180, -90, 180, 90, -180, 90, -180, -90,
-100, -45, -100, 45, 100, 45, 100, -45, -100, -45
-180,
-90,
180,
-90,
180,
90,
-180,
90,
-180,
-90,
-100,
-45,
-100,
45,
100,
45,
100,
-45,
-100,
-45,
-180,
-90,
180,
-90,
180,
90,
-180,
90,
-180,
-90,
-100,
-45,
-100,
45,
100,
45,
100,
-45,
-100,
-45,
];
const leftCoords = [
-180, -90, -180, 90, 180, 90, 180, -90, -180, -90,
-100, -45, 100, -45, 100, 45, -100, 45, -100, -45,
-180, -90, -180, 90, 180, 90, 180, -90, -180, -90,
-100, -45, 100, -45, 100, 45, -100, 45, -100, -45
-180,
-90,
-180,
90,
180,
90,
180,
-90,
-180,
-90,
-100,
-45,
100,
-45,
100,
45,
-100,
45,
-100,
-45,
-180,
-90,
-180,
90,
180,
90,
180,
-90,
-180,
-90,
-100,
-45,
100,
-45,
100,
45,
-100,
45,
-100,
-45,
];
const ends = [[10, 20], [30, 40]];
const ends = [
[10, 20],
[30, 40],
];
it('checks for left-hand orientation by default', function() {
it('checks for left-hand orientation by default', function () {
expect(oriented(rightCoords, 0, ends, 2)).to.be(false);
expect(oriented(leftCoords, 0, ends, 2)).to.be(true);
});
it('can check for right-hand orientation', function() {
it('can check for right-hand orientation', function () {
expect(oriented(rightCoords, 0, ends, 2, true)).to.be(true);
expect(oriented(leftCoords, 0, ends, 2, true)).to.be(false);
});
});
describe('ol.geom.flat.orient.orientLinearRings', function() {
describe('ol.geom.flat.orient.orientLinearRings', function () {
const orient = orientLinearRings;
const rightCoords = [
-180, -90, 180, -90, 180, 90, -180, 90, -180, -90,
-100, -45, -100, 45, 100, 45, 100, -45, -100, -45
-180,
-90,
180,
-90,
180,
90,
-180,
90,
-180,
-90,
-100,
-45,
-100,
45,
100,
45,
100,
-45,
-100,
-45,
];
const leftCoords = [
-180, -90, -180, 90, 180, 90, 180, -90, -180, -90,
-100, -45, 100, -45, 100, 45, -100, 45, -100, -45
-180,
-90,
-180,
90,
180,
90,
180,
-90,
-180,
-90,
-100,
-45,
100,
-45,
100,
45,
-100,
45,
-100,
-45,
];
const ends = [10, 20];
it('orients using the left-hand rule by default', function() {
it('orients using the left-hand rule by default', function () {
const rightClone = rightCoords.slice();
orient(rightClone, 0, ends, 2);
expect(rightClone).to.eql(leftCoords);
@@ -105,7 +259,7 @@ describe('ol.geom.flat.orient', function() {
expect(leftClone).to.eql(leftCoords);
});
it('can orient using the right-hand rule', function() {
it('can orient using the right-hand rule', function () {
const rightClone = rightCoords.slice();
orient(rightClone, 0, ends, 2, true);
expect(rightClone).to.eql(rightCoords);
@@ -114,29 +268,103 @@ describe('ol.geom.flat.orient', function() {
orient(leftClone, 0, ends, 2, true);
expect(leftClone).to.eql(rightCoords);
});
});
describe('ol.geom.flat.orient.orientLinearRingsArray', function() {
describe('ol.geom.flat.orient.orientLinearRingsArray', function () {
const orient = orientLinearRingsArray;
const rightCoords = [
-180, -90, 180, -90, 180, 90, -180, 90, -180, -90,
-100, -45, -100, 45, 100, 45, 100, -45, -100, -45,
-180, -90, 180, -90, 180, 90, -180, 90, -180, -90,
-100, -45, -100, 45, 100, 45, 100, -45, -100, -45
-180,
-90,
180,
-90,
180,
90,
-180,
90,
-180,
-90,
-100,
-45,
-100,
45,
100,
45,
100,
-45,
-100,
-45,
-180,
-90,
180,
-90,
180,
90,
-180,
90,
-180,
-90,
-100,
-45,
-100,
45,
100,
45,
100,
-45,
-100,
-45,
];
const leftCoords = [
-180, -90, -180, 90, 180, 90, 180, -90, -180, -90,
-100, -45, 100, -45, 100, 45, -100, 45, -100, -45,
-180, -90, -180, 90, 180, 90, 180, -90, -180, -90,
-100, -45, 100, -45, 100, 45, -100, 45, -100, -45
-180,
-90,
-180,
90,
180,
90,
180,
-90,
-180,
-90,
-100,
-45,
100,
-45,
100,
45,
-100,
45,
-100,
-45,
-180,
-90,
-180,
90,
180,
90,
180,
-90,
-180,
-90,
-100,
-45,
100,
-45,
100,
45,
-100,
45,
-100,
-45,
];
const ends = [[10, 20], [30, 40]];
const ends = [
[10, 20],
[30, 40],
];
it('orients using the left-hand rule by default', function() {
it('orients using the left-hand rule by default', function () {
const rightClone = rightCoords.slice();
orient(rightClone, 0, ends, 2);
expect(rightClone).to.eql(leftCoords);
@@ -146,7 +374,7 @@ describe('ol.geom.flat.orient', function() {
expect(leftClone).to.eql(leftCoords);
});
it('can orient using the right-hand rule', function() {
it('can orient using the right-hand rule', function () {
const rightClone = rightCoords.slice();
orient(rightClone, 0, ends, 2, true);
expect(rightClone).to.eql(rightCoords);
@@ -155,8 +383,5 @@ describe('ol.geom.flat.orient', function() {
orient(leftClone, 0, ends, 2, true);
expect(leftClone).to.eql(rightCoords);
});
});
});
test/spec/ol/geom/flat/reverse.test.js
+56 -35
View File
@@ -1,114 +1,135 @@
import {coordinates as reverseCoordinates} from '../../../../../src/ol/geom/flat/reverse.js';
describe('ol.geom.flat.reverse', function() {
describe('ol.geom.flat.reverse.coordinates', function() {
describe('with a stride of 2', function() {
it('can reverse empty flat coordinates', function() {
describe('ol.geom.flat.reverse', function () {
describe('ol.geom.flat.reverse.coordinates', function () {
describe('with a stride of 2', function () {
it('can reverse empty flat coordinates', function () {
const flatCoordinates = [];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 2);
expect(flatCoordinates).to.be.empty();
});
it('can reverse one flat coordinates', function() {
it('can reverse one flat coordinates', function () {
const flatCoordinates = [1, 2];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 2);
expect(flatCoordinates).to.eql([1, 2]);
});
it('can reverse two flat coordinates', function() {
it('can reverse two flat coordinates', function () {
const flatCoordinates = [1, 2, 3, 4];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 2);
expect(flatCoordinates).to.eql([3, 4, 1, 2]);
});
it('can reverse three flat coordinates', function() {
it('can reverse three flat coordinates', function () {
const flatCoordinates = [1, 2, 3, 4, 5, 6];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 2);
expect(flatCoordinates).to.eql([5, 6, 3, 4, 1, 2]);
});
it('can reverse four flat coordinates', function() {
it('can reverse four flat coordinates', function () {
const flatCoordinates = [1, 2, 3, 4, 5, 6, 7, 8];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 2);
expect(flatCoordinates).to.eql([7, 8, 5, 6, 3, 4, 1, 2]);
});
});
describe('with a stride of 3', function() {
it('can reverse empty flat coordinates', function() {
describe('with a stride of 3', function () {
it('can reverse empty flat coordinates', function () {
const flatCoordinates = [];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 3);
expect(flatCoordinates).to.be.empty();
});
it('can reverse one flat coordinates', function() {
it('can reverse one flat coordinates', function () {
const flatCoordinates = [1, 2, 3];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 3);
expect(flatCoordinates).to.eql([1, 2, 3]);
});
it('can reverse two flat coordinates', function() {
it('can reverse two flat coordinates', function () {
const flatCoordinates = [1, 2, 3, 4, 5, 6];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 3);
expect(flatCoordinates).to.eql([4, 5, 6, 1, 2, 3]);
});
it('can reverse three flat coordinates', function() {
it('can reverse three flat coordinates', function () {
const flatCoordinates = [1, 2, 3, 4, 5, 6, 7, 8, 9];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 3);
expect(flatCoordinates).to.eql([7, 8, 9, 4, 5, 6, 1, 2, 3]);
});
it('can reverse four flat coordinates', function() {
it('can reverse four flat coordinates', function () {
const flatCoordinates = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 3);
expect(flatCoordinates).to.eql([10, 11, 12, 7, 8, 9, 4, 5, 6, 1, 2, 3]);
});
});
describe('with a stride of 4', function() {
it('can reverse empty flat coordinates', function() {
describe('with a stride of 4', function () {
it('can reverse empty flat coordinates', function () {
const flatCoordinates = [];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 4);
expect(flatCoordinates).to.be.empty();
});
it('can reverse one flat coordinates', function() {
it('can reverse one flat coordinates', function () {
const flatCoordinates = [1, 2, 3, 4];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 4);
expect(flatCoordinates).to.eql([1, 2, 3, 4]);
});
it('can reverse two flat coordinates', function() {
it('can reverse two flat coordinates', function () {
const flatCoordinates = [1, 2, 3, 4, 5, 6, 7, 8];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 4);
expect(flatCoordinates).to.eql([5, 6, 7, 8, 1, 2, 3, 4]);
});
it('can reverse three flat coordinates', function() {
it('can reverse three flat coordinates', function () {
const flatCoordinates = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 4);
expect(flatCoordinates).to.eql([9, 10, 11, 12, 5, 6, 7, 8, 1, 2, 3, 4]);
});
it('can reverse four flat coordinates', function() {
const flatCoordinates =
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16];
it('can reverse four flat coordinates', function () {
const flatCoordinates = [
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
];
reverseCoordinates(flatCoordinates, 0, flatCoordinates.length, 4);
expect(flatCoordinates).to.eql(
[13, 14, 15, 16, 9, 10, 11, 12, 5, 6, 7, 8, 1, 2, 3, 4]);
expect(flatCoordinates).to.eql([
13,
14,
15,
16,
9,
10,
11,
12,
5,
6,
7,
8,
1,
2,
3,
4,
]);
});
});
});
});
test/spec/ol/geom/flat/segments.test.js
+9 -11
View File
@@ -1,20 +1,18 @@
import {forEach as forEachSegment} from '../../../../../src/ol/geom/flat/segments.js';
describe('ol.geom.flat.segments', function() {
describe('ol.geom.flat.segments.forEach', function() {
describe('ol.geom.flat.segments', function () {
describe('ol.geom.flat.segments.forEach', function () {
let flatCoordinates, offset, end, stride;
beforeEach(function() {
beforeEach(function () {
flatCoordinates = [0, 0, 1, 1, 2, 2, 3, 3];
offset = 0;
end = 8;
stride = 2;
});
describe('callback returns undefined', function() {
it('executes the callback for each segment', function() {
describe('callback returns undefined', function () {
it('executes the callback for each segment', function () {
const args = [];
const spy = sinon.spy(function(point1, point2) {
const spy = sinon.spy(function (point1, point2) {
args.push([point1[0], point1[1], point2[0], point2[1]]);
});
const ret = forEachSegment(flatCoordinates, offset, end, stride, spy);
@@ -34,10 +32,10 @@ describe('ol.geom.flat.segments', function() {
expect(ret).to.be(false);
});
});
describe('callback returns true', function() {
it('executes the callback for the first segment', function() {
describe('callback returns true', function () {
it('executes the callback for the first segment', function () {
const args = [];
const spy = sinon.spy(function(point1, point2) {
const spy = sinon.spy(function (point1, point2) {
args.push([point1[0], point1[1], point2[0], point2[1]]);
return true;
});
test/spec/ol/geom/flat/simplify.test.js
+769 -209
View File
File diff suppressed because it is too large Load Diff
test/spec/ol/geom/flat/straightchunk.test.js
+31 -20
View File
@@ -1,58 +1,69 @@
import {matchingChunk} from '../../../../../src/ol/geom/flat/straightchunk.js';
describe('ol.geom.flat.straightchunk', function() {
describe('ol.geom.flat.straightchunk.matchingChunk', function() {
describe('single segment with stride == 3', function() {
describe('ol.geom.flat.straightchunk', function () {
describe('ol.geom.flat.straightchunk.matchingChunk', function () {
describe('single segment with stride == 3', function () {
const flatCoords = [0, 0, 42, 1, 1, 42];
const stride = 3;
it('returns whole line with angle delta', function() {
it('returns whole line with angle delta', function () {
const got = matchingChunk(Math.PI / 4, flatCoords, 0, 6, stride);
expect(got).to.eql([0, 6]);
});
it('returns whole line with zero angle delta', function() {
it('returns whole line with zero angle delta', function () {
const got = matchingChunk(0, flatCoords, 0, 6, stride);
expect(got).to.eql([0, 6]);
});
});
describe('short line string', function() {
describe('short line string', function () {
const flatCoords = [0, 0, 1, 0, 1, 1, 0, 1];
const stride = 2;
it('returns whole line if straight enough', function() {
it('returns whole line if straight enough', function () {
const got = matchingChunk(Math.PI, flatCoords, 0, 8, stride);
expect(got).to.eql([0, 8]);
});
it('returns first matching chunk if all chunk lengths are the same', function() {
it('returns first matching chunk if all chunk lengths are the same', function () {
const got = matchingChunk(Math.PI / 4, flatCoords, 0, 8, stride);
expect(got).to.eql([0, 4]);
});
});
describe('longer line string', function() {
const flatCoords = [0, 0, 1, 0, 1, 1, 0, 1, 0, -1, -1, -1, -1, 0, -1, 2, -2, 4];
describe('longer line string', function () {
const flatCoords = [
0,
0,
1,
0,
1,
1,
0,
1,
0,
-1,
-1,
-1,
-1,
0,
-1,
2,
-2,
4,
];
const stride = 2;
it('returns stright chunk from within the linestring', function() {
it('returns stright chunk from within the linestring', function () {
const got = matchingChunk(0, flatCoords, 0, 18, stride);
expect(got).to.eql([10, 16]);
});
it('returns long chunk at the end if angle and length within threshold', function() {
it('returns long chunk at the end if angle and length within threshold', function () {
const got = matchingChunk(Math.PI / 4, flatCoords, 0, 18, stride);
expect(got).to.eql([10, 18]);
});
});
});
});
test/spec/ol/geom/flat/textpath.test.js
+165 -35
View File
@@ -1,8 +1,7 @@
import {drawTextOnPath} from '../../../../../src/ol/geom/flat/textpath.js';
import {lineStringLength} from '../../../../../src/ol/geom/flat/length.js';
describe('ol.geom.flat.drawTextOnPath', function() {
describe('ol.geom.flat.drawTextOnPath', function () {
const horizontal = [0, 0, 100, 0];
const vertical = [0, 0, 0, 100];
const diagonal = [0, 0, 100, 100];
@@ -14,103 +13,234 @@ describe('ol.geom.flat.drawTextOnPath', function() {
return 10 * text.length;
}
it('center-aligns text on a horizontal line', function() {
it('center-aligns text on a horizontal line', function () {
const startM = 50 - 15;
const instructions = drawTextOnPath(
horizontal, 0, horizontal.length, 2, 'foo', startM, Infinity, 1, measureAndCacheTextWidth, '', {});
horizontal,
0,
horizontal.length,
2,
'foo',
startM,
Infinity,
1,
measureAndCacheTextWidth,
'',
{}
);
expect(instructions).to.eql([[40, 0, 5, 0, 'foo']]);
});
it('left-aligns text on a horizontal line', function() {
it('left-aligns text on a horizontal line', function () {
const instructions = drawTextOnPath(
horizontal, 0, horizontal.length, 2, 'foo', 0, Infinity, 1, measureAndCacheTextWidth, '', {});
horizontal,
0,
horizontal.length,
2,
'foo',
0,
Infinity,
1,
measureAndCacheTextWidth,
'',
{}
);
expect(instructions).to.eql([[5, 0, 5, 0, 'foo']]);
});
it('right-aligns text on a horizontal line', function() {
it('right-aligns text on a horizontal line', function () {
const startM = 100 - 30;
const instructions = drawTextOnPath(
horizontal, 0, horizontal.length, 2, 'foo', startM, Infinity, 1, measureAndCacheTextWidth, '', {});
horizontal,
0,
horizontal.length,
2,
'foo',
startM,
Infinity,
1,
measureAndCacheTextWidth,
'',
{}
);
expect(instructions).to.eql([[75, 0, 5, 0, 'foo']]);
});
it('draws text on a vertical line', function() {
it('draws text on a vertical line', function () {
const startM = 50 - 15;
const instructions = drawTextOnPath(
vertical, 0, vertical.length, 2, 'foo', startM, Infinity, 1, measureAndCacheTextWidth, '', {});
const a = 90 * Math.PI / 180;
vertical,
0,
vertical.length,
2,
'foo',
startM,
Infinity,
1,
measureAndCacheTextWidth,
'',
{}
);
const a = (90 * Math.PI) / 180;
expect(instructions).to.eql([[0, 40, 5, a, 'foo']]);
});
it('draws text on a diagonal line', function() {
it('draws text on a diagonal line', function () {
const startM = Math.sqrt(2) * 50 - 15;
const instructions = drawTextOnPath(
diagonal, 0, diagonal.length, 2, 'foo', startM, Infinity, 1, measureAndCacheTextWidth, '', {});
expect(instructions[0][3]).to.be(45 * Math.PI / 180);
diagonal,
0,
diagonal.length,
2,
'foo',
startM,
Infinity,
1,
measureAndCacheTextWidth,
'',
{}
);
expect(instructions[0][3]).to.be((45 * Math.PI) / 180);
expect(instructions.length).to.be(1);
});
it('draws reverse text on a diagonal line', function() {
it('draws reverse text on a diagonal line', function () {
const startM = Math.sqrt(2) * 50 - 15;
const instructions = drawTextOnPath(
reverse, 0, reverse.length, 2, 'foo', startM, Infinity, 1, measureAndCacheTextWidth, '', {});
expect(instructions[0][3]).to.be(-45 * Math.PI / 180);
reverse,
0,
reverse.length,
2,
'foo',
startM,
Infinity,
1,
measureAndCacheTextWidth,
'',
{}
);
expect(instructions[0][3]).to.be((-45 * Math.PI) / 180);
expect(instructions.length).to.be(1);
});
it('renders long text with extrapolation', function() {
it('renders long text with extrapolation', function () {
const startM = 50 - 75;
const instructions = drawTextOnPath(
horizontal, 0, horizontal.length, 2, 'foo-foo-foo-foo', startM, Infinity, 1, measureAndCacheTextWidth, '', {});
horizontal,
0,
horizontal.length,
2,
'foo-foo-foo-foo',
startM,
Infinity,
1,
measureAndCacheTextWidth,
'',
{}
);
expect(instructions[0]).to.eql([-20, 0, 5, 0, 'foo-foo-foo-foo']);
expect(instructions.length).to.be(1);
});
it('renders angled text', function() {
it('renders angled text', function () {
const length = lineStringLength(angled, 0, angled.length, 2);
const startM = length / 2 - 15;
const instructions = drawTextOnPath(
angled, 0, angled.length, 2, 'foo', startM, Infinity, 1, measureAndCacheTextWidth, '', {});
expect(instructions[0][3]).to.eql(45 * Math.PI / 180);
angled,
0,
angled.length,
2,
'foo',
startM,
Infinity,
1,
measureAndCacheTextWidth,
'',
{}
);
expect(instructions[0][3]).to.eql((45 * Math.PI) / 180);
expect(instructions[0][4]).to.be('f');
expect(instructions[1][3]).to.eql(45 * Math.PI / 180);
expect(instructions[1][3]).to.eql((45 * Math.PI) / 180);
expect(instructions[1][4]).to.be('o');
expect(instructions[2][3]).to.eql(-45 * Math.PI / 180);
expect(instructions[2][3]).to.eql((-45 * Math.PI) / 180);
expect(instructions[2][4]).to.be('o');
});
it('respects maxAngle', function() {
it('respects maxAngle', function () {
const length = lineStringLength(angled, 0, angled.length, 2);
const startM = length / 2 - 15;
const instructions = drawTextOnPath(
angled, 0, angled.length, 2, 'foo', startM, Math.PI / 4, 1, measureAndCacheTextWidth, '', {});
angled,
0,
angled.length,
2,
'foo',
startM,
Math.PI / 4,
1,
measureAndCacheTextWidth,
'',
{}
);
expect(instructions).to.be(null);
});
it('uses the smallest angle for maxAngleDelta', function() {
it('uses the smallest angle for maxAngleDelta', function () {
const length = lineStringLength(reverseangled, 0, reverseangled.length, 2);
const startM = length / 2 - 15;
const instructions = drawTextOnPath(
reverseangled, 0, reverseangled.length, 2, 'foo', startM, Math.PI, 1, measureAndCacheTextWidth, '', {});
reverseangled,
0,
reverseangled.length,
2,
'foo',
startM,
Math.PI,
1,
measureAndCacheTextWidth,
'',
{}
);
expect(instructions).to.not.be(undefined);
});
it('respects the offset option', function() {
it('respects the offset option', function () {
const length = lineStringLength(angled, 2, angled.length, 2);
const startM = length / 2 - 15;
const instructions = drawTextOnPath(
angled, 2, angled.length, 2, 'foo', startM, Infinity, 1, measureAndCacheTextWidth, '', {});
expect(instructions[0][3]).to.be(-45 * Math.PI / 180);
angled,
2,
angled.length,
2,
'foo',
startM,
Infinity,
1,
measureAndCacheTextWidth,
'',
{}
);
expect(instructions[0][3]).to.be((-45 * Math.PI) / 180);
expect(instructions.length).to.be(1);
});
it('respects the end option', function() {
it('respects the end option', function () {
const length = lineStringLength(angled, 0, 4, 2);
const startM = length / 2 - 15;
const instructions = drawTextOnPath(
angled, 0, 4, 2, 'foo', startM, Infinity, 1, measureAndCacheTextWidth, '', {});
expect(instructions[0][3]).to.be(45 * Math.PI / 180);
angled,
0,
4,
2,
'foo',
startM,
Infinity,
1,
measureAndCacheTextWidth,
'',
{}
);
expect(instructions[0][3]).to.be((45 * Math.PI) / 180);
expect(instructions.length).to.be(1);
});
});
test/spec/ol/geom/flat/topologyflatgeom.test.js
+29 -13
View File
@@ -1,31 +1,47 @@
import {lineStringIsClosed} from '../../../../../src/ol/geom/flat/topology.js';
describe('ol.geom.flat.topology', function() {
describe('ol.geom.flat.topology.lineStringIsClosed', function() {
it('identifies closed lines aka boundaries', function() {
describe('ol.geom.flat.topology', function () {
describe('ol.geom.flat.topology.lineStringIsClosed', function () {
it('identifies closed lines aka boundaries', function () {
const flatCoordinates = [0, 0, 3, 0, 0, 3, 0, 0];
const isClosed = lineStringIsClosed(flatCoordinates, 0, flatCoordinates.length, 2);
const isClosed = lineStringIsClosed(
flatCoordinates,
0,
flatCoordinates.length,
2
);
expect(isClosed).to.be(true);
});
it('identifies regular linestrings', function() {
it('identifies regular linestrings', function () {
const flatCoordinates = [0, 0, 3, 0, 0, 3, 5, 2];
const isClosed = lineStringIsClosed(flatCoordinates, 0, flatCoordinates.length, 2);
const isClosed = lineStringIsClosed(
flatCoordinates,
0,
flatCoordinates.length,
2
);
expect(isClosed).to.be(false);
});
it('identifies degenerate boundaries', function() {
it('identifies degenerate boundaries', function () {
let flatCoordinates = [0, 0, 3, 0, 0, 0];
let isClosed = lineStringIsClosed(flatCoordinates, 0, flatCoordinates.length, 2);
let isClosed = lineStringIsClosed(
flatCoordinates,
0,
flatCoordinates.length,
2
);
expect(isClosed).to.be(false);
flatCoordinates = [0, 0, 1, 1, 3, 3, 5, 5, 0, 0];
isClosed = lineStringIsClosed(flatCoordinates, 0, flatCoordinates.length, 2);
isClosed = lineStringIsClosed(
flatCoordinates,
0,
flatCoordinates.length,
2
);
expect(isClosed).to.be(false);
});
});
});
test/spec/ol/geom/flat/transform.test.js
+129 -46
View File
@@ -1,37 +1,48 @@
import MultiPolygon from '../../../../../src/ol/geom/MultiPolygon.js';
import {transformGeom2D} from '../../../../../src/ol/geom/SimpleGeometry.js';
import {rotate, translate} from '../../../../../src/ol/geom/flat/transform.js';
import {transformGeom2D} from '../../../../../src/ol/geom/SimpleGeometry.js';
describe('ol.geom.flat.transform', function() {
describe('ol.geom.flat.transform.transform2D', function() {
it('transforms a Simple Geometry to 2D', function() {
describe('ol.geom.flat.transform', function () {
describe('ol.geom.flat.transform.transform2D', function () {
it('transforms a Simple Geometry to 2D', function () {
const multiPolygonGeometry = new MultiPolygon([
[[[-80.736061, 28.788576000000006, 0],
[-80.763557, 28.821799999999996, 0],
[-80.817406, 28.895123999999996, 0],
[-80.891304, 29.013130000000004, 0],
[-80.916512, 29.071560000000005, 0],
[-80.899323, 29.061249000000004, 0],
[-80.862663, 28.991361999999995, 0],
[-80.736061, 28.788576000000006, 0]]], [[
[-82.102127, 26.585724, 0],
[-82.067139, 26.497208, 0],
[-82.097641, 26.493585999999993, 0],
[-82.135895, 26.642279000000002, 0],
[-82.183495, 26.683082999999996, 0],
[-82.128838, 26.693342, 0],
[-82.102127, 26.585724, 0]]]
[
[
[-80.736061, 28.788576000000006, 0],
[-80.763557, 28.821799999999996, 0],
[-80.817406, 28.895123999999996, 0],
[-80.891304, 29.013130000000004, 0],
[-80.916512, 29.071560000000005, 0],
[-80.899323, 29.061249000000004, 0],
[-80.862663, 28.991361999999995, 0],
[-80.736061, 28.788576000000006, 0],
],
],
[
[
[-82.102127, 26.585724, 0],
[-82.067139, 26.497208, 0],
[-82.097641, 26.493585999999993, 0],
[-82.135895, 26.642279000000002, 0],
[-82.183495, 26.683082999999996, 0],
[-82.128838, 26.693342, 0],
[-82.102127, 26.585724, 0],
],
],
]).transform('EPSG:4326', 'EPSG:3857');
const transform = [
0.0004088332670837288, 0,
0, -0.0004088332670837288,
4480.991370439071, 1529.5752568707105
0.0004088332670837288,
0,
0,
-0.0004088332670837288,
4480.991370439071,
1529.5752568707105,
];
const pixelCoordinates = transformGeom2D(multiPolygonGeometry, transform, []);
const pixelCoordinates = transformGeom2D(
multiPolygonGeometry,
transform,
[]
);
expect(pixelCoordinates[0]).to.roughlyEqual(806.6035275946265, 1e-9);
expect(pixelCoordinates[1]).to.roughlyEqual(160.48916296287916, 1e-9);
expect(pixelCoordinates[2]).to.roughlyEqual(805.3521540835154, 1e-9);
@@ -63,37 +74,111 @@ describe('ol.geom.flat.transform', function() {
expect(pixelCoordinates[28]).to.roughlyEqual(744.4323460835158, 1e-9);
expect(pixelCoordinates[29]).to.roughlyEqual(273.7179168205373, 1e-9);
});
});
describe('ol.geom.flat.transform.translate', function() {
it('translates the coordinates array', function() {
describe('ol.geom.flat.transform.translate', function () {
it('translates the coordinates array', function () {
const multiPolygon = new MultiPolygon([
[[[0, 0, 2], [0, 1, 2], [1, 1, 2], [1, 0, 2], [0, 0, 2]]],
[[[2, 2, 3], [2, 3, 3], [3, 3, 3], [3, 2, 3], [2, 2, 3]]]]);
[
[
[0, 0, 2],
[0, 1, 2],
[1, 1, 2],
[1, 0, 2],
[0, 0, 2],
],
],
[
[
[2, 2, 3],
[2, 3, 3],
[3, 3, 3],
[3, 2, 3],
[2, 2, 3],
],
],
]);
const flatCoordinates = multiPolygon.getFlatCoordinates();
const deltaX = 1;
const deltaY = 2;
translate(flatCoordinates, 0,
flatCoordinates.length, multiPolygon.getStride(),
deltaX, deltaY, flatCoordinates);
translate(
flatCoordinates,
0,
flatCoordinates.length,
multiPolygon.getStride(),
deltaX,
deltaY,
flatCoordinates
);
expect(flatCoordinates).to.eql([
1, 2, 2, 1, 3, 2, 2, 3, 2, 2, 2, 2, 1, 2, 2,
3, 4, 3, 3, 5, 3, 4, 5, 3, 4, 4, 3, 3, 4, 3]);
1,
2,
2,
1,
3,
2,
2,
3,
2,
2,
2,
2,
1,
2,
2,
3,
4,
3,
3,
5,
3,
4,
5,
3,
4,
4,
3,
3,
4,
3,
]);
});
});
describe('ol.geom.flat.transform.rotate', function() {
it('rotates the coordinates array', function() {
describe('ol.geom.flat.transform.rotate', function () {
it('rotates the coordinates array', function () {
const multiPolygon = new MultiPolygon([
[[[0, 0, 2], [0, 1, 2], [1, 1, 2], [1, 0, 2], [0, 0, 2]]],
[[[2, 2, 3], [2, 3, 3], [3, 3, 3], [3, 2, 3], [2, 2, 3]]]]);
[
[
[0, 0, 2],
[0, 1, 2],
[1, 1, 2],
[1, 0, 2],
[0, 0, 2],
],
],
[
[
[2, 2, 3],
[2, 3, 3],
[3, 3, 3],
[3, 2, 3],
[2, 2, 3],
],
],
]);
const flatCoordinates = multiPolygon.getFlatCoordinates();
const angle = Math.PI / 2;
const anchor = [0, 1];
rotate(flatCoordinates, 0,
flatCoordinates.length, multiPolygon.getStride(),
angle, anchor, flatCoordinates);
rotate(
flatCoordinates,
0,
flatCoordinates.length,
multiPolygon.getStride(),
angle,
anchor,
flatCoordinates
);
expect(flatCoordinates[0]).to.roughlyEqual(1, 1e-9);
expect(flatCoordinates[1]).to.roughlyEqual(1, 1e-9);
expect(flatCoordinates[2]).to.roughlyEqual(2, 1e-9);
@@ -125,7 +210,5 @@ describe('ol.geom.flat.transform', function() {
expect(flatCoordinates[28]).to.roughlyEqual(3, 1e-9);
expect(flatCoordinates[29]).to.roughlyEqual(3, 1e-9);
});
});
});