/* eslint-env jest*/ import OlFeature from 'ol/Feature'; import OlFormatGeoJSON from 'ol/format/GeoJSON'; import OlGeometry from 'ol/geom/Geometry'; import OlGeomLineString from 'ol/geom/LineString'; import OlGeomMultiLineString from 'ol/geom/MultiLineString'; import OlGeomMultiPoint from 'ol/geom/MultiPoint'; import OlGeomMultiPolygon from 'ol/geom/MultiPolygon'; import OlGeomPoint from 'ol/geom/Point'; import OlGeomPolygon from 'ol/geom/Polygon'; import { Extent as OlExtent } from 'ol/extent'; import GeometryUtil from './GeometryUtil'; import { boxCoords, boxCoords2, boxCoords3, boxCoords4, differenceBoxCoords, expectedMultiPolygon, holeCoords2, holeCoords2CutLine, holeCoords2ExpPoly1, holeCoords2ExpPoly2, holeCoords2ExpPoly3, intersectionCoords, lineStringCoords, lineStringCoords2, lineStringLFormedCoords, mergedBoxCoords, mergedLineStringCoordinates, mergedPointCoordinates, mergedPointCoordinates2, pointCoords, pointCoords2, pointCoords3, pointCoords4, splitBoxCoords1, splitBoxCoords2, splitBoxLFormedCoords1, splitBoxLFormedCoords2, splitUFormerdCoords1, splitUFormerdCoords2, splitUFormerdCoords3, uFormedPolygonCoords, unionedBoxCoordinates } from './TestCoords'; describe('GeometryUtil', () => { let polygonFeature: OlFeature; let polygonGeometry: OlGeomPolygon; let format: OlFormatGeoJSON; beforeEach(() => { format = new OlFormatGeoJSON(); polygonFeature = new OlFeature({ geometry: new OlGeomPolygon(boxCoords) }); }); describe('Basics', () => { it('is defined', () => { expect(GeometryUtil).toBeDefined(); }); }); describe('Static methods', () => { describe('#splitByLine', () => { describe('with ol.Feature as params', () => { /** * + * | * +-------------+ * | | | * | | | * | | | * | | | * | | | * | | | * +-------------+ * | * + */ it('splits the given convex polygon geometry with a straight line', () => { const line = new OlFeature({ geometry: new OlGeomLineString(lineStringCoords) }); const got: OlFeature[] = GeometryUtil.splitByLine(polygonFeature, line, 'EPSG:4326') as OlFeature[]; const exp = [ new OlFeature({ geometry: new OlGeomPolygon(splitBoxCoords1) }), new OlFeature({ geometry: new OlGeomPolygon(splitBoxCoords2) }) ]; expect(format.writeFeatures(got)).toEqual(format.writeFeatures(exp)); }); /** * + * | * +-------------+ * | | | * | | | * | | | * | +---------+ * | | * | | * +-------------+ */ it('splits the given convex polygon geometry with a more complex line', () => { const line = new OlFeature({ geometry: new OlGeomLineString(lineStringLFormedCoords) }); const got = GeometryUtil.splitByLine(polygonFeature, line, 'EPSG:4326') as OlFeature[]; const exp = [ new OlFeature({ geometry: new OlGeomPolygon(splitBoxLFormedCoords1) }), new OlFeature({ geometry: new OlGeomPolygon(splitBoxLFormedCoords2) }) ]; expect(format.writeFeatures(got)).toEqual(format.writeFeatures(exp)); }); /** * +----+ +----+ * | | | | * | | | | * +--------------------------------+ * | | | | * | +---------+ | * | | * | | * | | * | | * +-------------------+ * */ it('splits the given concave polygon geometry with a straight line', () => { polygonFeature = new OlFeature({ geometry: new OlGeomPolygon(uFormedPolygonCoords) }); const line = new OlFeature({ geometry: new OlGeomLineString(lineStringCoords2) }); const got = GeometryUtil.splitByLine(polygonFeature, line, 'EPSG:4326') as OlFeature[]; const exp = [ new OlFeature({ geometry: new OlGeomPolygon(splitUFormerdCoords1) }), new OlFeature({ geometry: new OlGeomPolygon(splitUFormerdCoords2) }), new OlFeature({ geometry: new OlGeomPolygon(splitUFormerdCoords3) }) ]; expect(format.writeFeatures(got)).toEqual(format.writeFeatures(exp)); }); /** * +-------------------+ * | | * + | +---------+ | * |\ | | | | * | \ | | | | * +----------------------------------+ * | \ | | | | * | \ | +---------+ | * | \| | * | + | * | | * +------------------------ + * */ it('splits a complex polygon geometry (including hole) with a straight line',() => { polygonFeature = new OlFeature({ geometry: new OlGeomPolygon(holeCoords2) }); const line = new OlFeature({ geometry: new OlGeomLineString(holeCoords2CutLine) }); const got = GeometryUtil.splitByLine(polygonFeature, line, 'EPSG:4326') as OlFeature[]; const exp: OlFeature[] = [ new OlFeature({ geometry: new OlGeomPolygon(holeCoords2ExpPoly1) }), new OlFeature({ geometry: new OlGeomPolygon(holeCoords2ExpPoly2) }), new OlFeature({ geometry: new OlGeomPolygon(holeCoords2ExpPoly3) }) ]; expect(got.length).toBe(3); got.forEach((polygon, i) => { polygon?.getGeometry()?.getCoordinates()[0].sort().forEach(coord=>{ coord.forEach(()=>{ expect(exp[i]!.getGeometry()!.getCoordinates()[0].sort()).toContainEqual(coord); }); }); }); }); }); describe('with ol.geom.Geometry as params', () => { /** * + * | * +-------------+ * | | | * | | | * | | | * | | | * | | | * | | | * +-------------+ * | * + */ it('splits the given convex polygon geometry with a straight line', () => { polygonGeometry = new OlGeomPolygon(boxCoords); const line = new OlGeomLineString(lineStringCoords); const got = GeometryUtil.splitByLine(polygonGeometry, new OlFeature(line), 'EPSG:4326') as OlGeomPolygon[]; const exp = [ new OlGeomPolygon(splitBoxCoords1), new OlGeomPolygon(splitBoxCoords2) ]; got.forEach((polygon, i) => { expect(polygon.getCoordinates()).toEqual(exp[i].getCoordinates()); }); }); /** * + * | * +-------------+ * | | | * | | | * | | | * | +---------+ * | | * | | * +-------------+ */ it('splits the given convex polygon geometry with a more complex line', () => { polygonGeometry = new OlGeomPolygon(boxCoords); const line = new OlGeomLineString(lineStringLFormedCoords); const got = GeometryUtil.splitByLine(polygonGeometry, new OlFeature(line), 'EPSG:4326') as OlGeomPolygon[]; const exp = [ new OlGeomPolygon(splitBoxLFormedCoords1), new OlGeomPolygon(splitBoxLFormedCoords2) ]; got.forEach((polygon, i) => { expect(polygon.getCoordinates()).toEqual(exp[i].getCoordinates()); }); }); /** * +----+ +----+ * | | | | * | | | | * +--------------------------------+ * | | | | * | +---------+ | * | | * | | * | | * | | * +-------------------+ * */ it('splits the given concave polygon geometry with a straight line', () => { polygonGeometry = new OlGeomPolygon(uFormedPolygonCoords); const line = new OlGeomLineString(lineStringCoords2); const got = GeometryUtil.splitByLine(polygonGeometry, new OlFeature(line), 'EPSG:4326') as OlGeomPolygon[]; const exp = [ new OlGeomPolygon(splitUFormerdCoords1), new OlGeomPolygon(splitUFormerdCoords2), new OlGeomPolygon(splitUFormerdCoords3) ]; got.forEach((polygon, i) => { expect(polygon.getCoordinates()).toEqual(exp[i].getCoordinates()); }); }); }); }); // describe('#addBuffer', () => { // describe('with ol.Feature as params', () => { // it('adds a buffer to an ol.geom.Point', () => { // const testPoint = new OlFeature({ // geometry: new OlGeomPoint(pointCoords) // }); // const bufferedPoint = GeometryUtil.addBuffer(testPoint, 200, 'EPSG:4326') as OlFeature; // expect(bufferedPoint instanceof OlFeature).toBe(true); // expect(bufferedPoint.getGeometry()!.getCoordinates()).toEqual(bufferedPointCoords); // }); // it('adds a buffer to an ol.geom.Polygon', () => { // const testPolygon = new OlFeature({ // geometry: new OlGeomPolygon(boxCoords) // }); // const bufferedPolygon = GeometryUtil.addBuffer(testPolygon, 200, 'EPSG:4326'); // expect(bufferedPolygon instanceof OlFeature).toBe(true); // expect(bufferedPolygon.getGeometry().getCoordinates()).toEqual(bufferedBoxCoords); // }); // it('adds a buffer to an ol.geom.Linestring', () => { // const testLineString = new OlFeature({ // geometry: new OlGeomLineString(lineStringCoords) // }); // const bufferedLineString = GeometryUtil.addBuffer(testLineString, 200, 'EPSG:4326'); // expect(bufferedLineString instanceof OlFeature).toBe(true); // expect(bufferedLineString.getGeometry().getCoordinates()).toEqual(bufferedLineStringCoords); // }); // it('adds a buffer to an ol.geom.Polygon containing a hole', () => { // const testPolygon = new OlFeature({ // geometry: new OlGeomPolygon(holeCoords) // }); // const bufferedPolygon = GeometryUtil.addBuffer(testPolygon, 200, 'EPSG:4326'); // expect(bufferedPolygon instanceof OlFeature).toBe(true); // expect(bufferedPolygon.getGeometry().getCoordinates()).toEqual(bufferedHoleCoords); // }); // }); // describe('with ol.geom.Geometry as params', () => { // it('adds a buffer to an ol.geom.Point', () => { // const testPoint = new OlGeomPoint(pointCoords); // const bufferedPoint = GeometryUtil.addBuffer(testPoint, 200, 'EPSG:4326'); // expect(bufferedPoint instanceof OlGeomPolygon).toBe(true); // expect(bufferedPoint.getCoordinates()).toEqual(bufferedPointCoords); // }); // it('adds a buffer to an ol.geom.Polygon', () => { // const testPolygon = new OlGeomPolygon(boxCoords); // const bufferedPolygon = GeometryUtil.addBuffer(testPolygon, 200, 'EPSG:4326'); // expect(bufferedPolygon instanceof OlGeomPolygon).toBe(true); // expect(bufferedPolygon.getCoordinates()).toEqual(bufferedBoxCoords); // }); // it('adds a buffer to an ol.geom.Linestring', () => { // const testLineString = new OlGeomLineString(lineStringCoords); // const bufferedLineString = GeometryUtil.addBuffer(testLineString, 200, 'EPSG:4326'); // expect(bufferedLineString instanceof OlGeomPolygon).toBe(true); // expect(bufferedLineString.getCoordinates()).toEqual(bufferedLineStringCoords); // }); // }); // }); describe('#separateGeometries', () => { it('can split a single ol.geom.MultiPoint into an array of ol.geom.Points', () => { const testPoint1 = new OlGeomPoint(pointCoords); const testPoint2 = new OlGeomPoint(pointCoords2); const mergedPoint = GeometryUtil.mergeGeometries([testPoint1, testPoint2]); const separatedPoints = GeometryUtil.separateGeometries(mergedPoint); expect(Array.isArray(separatedPoints)).toBe(true); expect(separatedPoints[0]).toBeInstanceOf(OlGeomPoint); const firstPoint = separatedPoints[0] as OlGeomPoint; const secondPoint = separatedPoints[1] as OlGeomPoint; expect(firstPoint.getCoordinates()).toEqual(pointCoords); expect(secondPoint.getCoordinates()).toEqual(pointCoords2); }); it('can split a single ol.geom.MultiPolygoin into an array of ol.geom.Polygon', () => { const testPolygon1 = new OlGeomPolygon(boxCoords); const testPolygon2 = new OlGeomPolygon(boxCoords3); const mergedPolygon = GeometryUtil.mergeGeometries([testPolygon1, testPolygon2]); const separatedPolygons = GeometryUtil.separateGeometries(mergedPolygon); expect(Array.isArray(separatedPolygons)).toBe(true); expect(separatedPolygons[0]).toBeInstanceOf(OlGeomPolygon); const firstPolygon = separatedPolygons[0] as OlGeomPolygon; const secondPolygon = separatedPolygons[1] as OlGeomPolygon; expect(firstPolygon.getCoordinates()).toEqual(boxCoords); expect(secondPolygon.getCoordinates()).toEqual(boxCoords3); }); it('can split a single ol.geom.MultiLineString into an array of ol.geom.LineString', () => { const testLineString1 = new OlGeomLineString(lineStringCoords); const testLineString2 = new OlGeomLineString(lineStringCoords2); const mergedLineString = GeometryUtil.mergeGeometries([testLineString1, testLineString2]); const separatedLineStrings = GeometryUtil.separateGeometries(mergedLineString); expect(Array.isArray(separatedLineStrings)).toBe(true); expect(separatedLineStrings[0]).toBeInstanceOf(OlGeomLineString); const firstLineString = separatedLineStrings[0] as OlGeomLineString; const secondLineString = separatedLineStrings[1] as OlGeomLineString; expect(firstLineString.getCoordinates()).toEqual(lineStringCoords); expect(secondLineString.getCoordinates()).toEqual(lineStringCoords2); }); it('can split multiple mixed MultiGeometries into an array of ol.geom.Geomtries', () => { const testPoint1 = new OlGeomPoint(pointCoords); const testPoint2 = new OlGeomPoint(pointCoords2); const mergedPoint = GeometryUtil.mergeGeometries([testPoint1, testPoint2]); const testPolygon1 = new OlGeomPolygon(boxCoords); const testPolygon2 = new OlGeomPolygon(boxCoords3); const mergedPolygon = GeometryUtil.mergeGeometries([testPolygon1, testPolygon2]); const testLineString1 = new OlGeomLineString(lineStringCoords); const testLineString2 = new OlGeomLineString(lineStringCoords2); const mergedLineString = GeometryUtil.mergeGeometries([testLineString1, testLineString2]); const mixedMultiGeometries = [mergedPoint, mergedPolygon, mergedLineString]; const separatedGeometries = GeometryUtil.separateGeometries(mixedMultiGeometries); expect(Array.isArray(separatedGeometries)).toBe(true); expect(separatedGeometries.length).toEqual(6); expect(separatedGeometries[0]).toBeInstanceOf(OlGeomPoint); expect(separatedGeometries[1]).toBeInstanceOf(OlGeomPoint); expect(separatedGeometries[2]).toBeInstanceOf(OlGeomPolygon); expect(separatedGeometries[3]).toBeInstanceOf(OlGeomPolygon); expect(separatedGeometries[4]).toBeInstanceOf(OlGeomLineString); expect(separatedGeometries[5]).toBeInstanceOf(OlGeomLineString); expect((separatedGeometries[0] as OlGeomPoint).getCoordinates()).toEqual(pointCoords); expect((separatedGeometries[1] as OlGeomPoint).getCoordinates()).toEqual(pointCoords2); expect((separatedGeometries[2] as OlGeomPolygon).getCoordinates()).toEqual(boxCoords); expect((separatedGeometries[3] as OlGeomPolygon).getCoordinates()).toEqual(boxCoords3); expect((separatedGeometries[4] as OlGeomLineString).getCoordinates()).toEqual(lineStringCoords); expect((separatedGeometries[5] as OlGeomLineString).getCoordinates()).toEqual(lineStringCoords2); }); it('can split multiple mixed MultiGeometries and SingelGeometries into an array of ol.geom.Geomtries', () => { const testPoint1 = new OlGeomPoint(pointCoords); const testPoint2 = new OlGeomPoint(pointCoords2); const mergedPoint = GeometryUtil.mergeGeometries([testPoint1, testPoint2]); const testPolygon1 = new OlGeomPolygon(boxCoords); const testPolygon2 = new OlGeomPolygon(boxCoords3); const mixedMultiGeoemtries = [mergedPoint, testPolygon1, testPolygon2]; const separatedGeometries = GeometryUtil.separateGeometries(mixedMultiGeoemtries); expect(Array.isArray(separatedGeometries)).toBe(true); expect(separatedGeometries.length).toEqual(4); expect(separatedGeometries[0]).toBeInstanceOf(OlGeomPoint); expect(separatedGeometries[1]).toBeInstanceOf(OlGeomPoint); expect(separatedGeometries[2]).toBeInstanceOf(OlGeomPolygon); expect(separatedGeometries[3]).toBeInstanceOf(OlGeomPolygon); expect((separatedGeometries[0] as OlGeomPoint).getCoordinates()).toEqual(pointCoords); expect((separatedGeometries[1] as OlGeomPoint).getCoordinates()).toEqual(pointCoords2); expect((separatedGeometries[2] as OlGeomPolygon).getCoordinates()).toEqual(boxCoords); expect((separatedGeometries[3] as OlGeomPolygon).getCoordinates()).toEqual(boxCoords3); }); }); describe('#mergeGeometries', () => { it('merges multiple instances of ol.geom.Point into ol.geom.MultiPoint', () => { const testPoint1 = new OlGeomPoint(pointCoords); const testPoint2 = new OlGeomPoint(pointCoords2); const mergedPoint = GeometryUtil.mergeGeometries([testPoint1, testPoint2]); expect(mergedPoint instanceof OlGeomMultiPoint).toBe(true); expect(mergedPoint.getCoordinates()).toEqual(mergedPointCoordinates); }); it('merges multiple instances of ol.geom.Polygon into ol.geom.MultiPolygon', () => { const testPolygon1 = new OlGeomPolygon(boxCoords); const testPolygon2 = new OlGeomPolygon(boxCoords3); const mergedPolygon = GeometryUtil.mergeGeometries([testPolygon1, testPolygon2]); expect(mergedPolygon instanceof OlGeomMultiPolygon).toBe(true); expect(mergedPolygon.getCoordinates()).toEqual(mergedBoxCoords); }); it('merges multiple instances of ol.geom.LineString into ol.geom.MultiLineString', () => { const testLineString1 = new OlGeomLineString(lineStringCoords); const testLineString2 = new OlGeomLineString(lineStringCoords2); const mergedLineString = GeometryUtil.mergeGeometries([testLineString1, testLineString2]); expect(mergedLineString instanceof OlGeomMultiLineString).toBe(true); expect(mergedLineString.getCoordinates()).toEqual(mergedLineStringCoordinates); }); it('merges multiple instances of ol.geom.MultiPoint into ol.geom.MultiPoint', () => { const testMultiPoint1 = new OlGeomMultiPoint([pointCoords, pointCoords2]); const testMultiPoint2 = new OlGeomMultiPoint([pointCoords3, pointCoords4]); const mergedMultiPoint = GeometryUtil.mergeGeometries([testMultiPoint1, testMultiPoint2]); expect(mergedMultiPoint instanceof OlGeomMultiPoint).toBe(true); expect(mergedMultiPoint.getCoordinates()).toEqual(mergedPointCoordinates2); }); it('merges multiple instances of ol.geom.MultiPolygon into ol.geom.MultiPolygon', () => { const testMultiPolygon1 = new OlGeomMultiPolygon([boxCoords, boxCoords2]); const testMultiPolygon2 = new OlGeomMultiPolygon([boxCoords3, boxCoords4]); const mergedMultiPolygon = GeometryUtil.mergeGeometries([testMultiPolygon1, testMultiPolygon2]); expect(mergedMultiPolygon instanceof OlGeomMultiPolygon).toBe(true); expect(mergedMultiPolygon.getCoordinates()).toEqual(expectedMultiPolygon); }); it('merges multiple instances of ol.geom.MultiLineString into ol.geom.MultiLineString', () => { const testMultiLineString1 = new OlGeomMultiLineString([lineStringCoords]); const testMultiLineString2 = new OlGeomMultiLineString([lineStringCoords2]); const mergedMultiLineString = GeometryUtil.mergeGeometries([testMultiLineString1, testMultiLineString2]); expect(mergedMultiLineString instanceof OlGeomMultiLineString).toBe(true); expect(mergedMultiLineString.getCoordinates()).toEqual(mergedLineStringCoordinates); }); }); describe('#union', () => { describe('with ol.Feature as params', () => { it('unions multiple instances of ol.geom.Polygon into one ol.geom.MultiPolygon', () => { const poly1 = new OlFeature({ geometry: new OlGeomPolygon(boxCoords) }); const poly2 = new OlFeature({ geometry: new OlGeomPolygon(boxCoords2) }); const unionedFeature: OlFeature = GeometryUtil.union([poly1, poly2], 'EPSG:4326') as OlFeature; expect(unionedFeature).toBeDefined(); expect(unionedFeature.getGeometry()).toBeDefined(); expect(unionedFeature?.getGeometry()?.getCoordinates()).toEqual(unionedBoxCoordinates); }); it('unions multiple instances of ol.geom.MultiPolygon into one ol.geom.MultiPolygon', () => { const multiPoly1 = new OlFeature({ geometry: new OlGeomMultiPolygon([boxCoords]) }); const multiPoly2 = new OlFeature({ geometry: new OlGeomMultiPolygon([boxCoords2]) }); const unionedFeature = GeometryUtil.union([multiPoly1, multiPoly2], 'EPSG:4326'); expect(unionedFeature instanceof OlFeature).toBe(true); expect((unionedFeature as OlFeature)!.getGeometry()! .getCoordinates()).toEqual(unionedBoxCoordinates); }); }); describe('with ol.geom.Geometry as params', () => { it('unions multiple instances of ol.geom.Polygon into one ol.geom.MultiPolygon', () => { const poly1 = new OlGeomPolygon(boxCoords); const poly2 = new OlGeomPolygon(boxCoords2); const unionedGeometry = GeometryUtil.union([poly1, poly2], 'EPSG:4326'); expect(unionedGeometry).toBeInstanceOf(OlGeomPolygon); expect((unionedGeometry as OlGeomPolygon).getCoordinates()).toEqual(unionedBoxCoordinates); }); }); }); describe('#difference', () => { describe('with ol.Feature as params', () => { it('returns the difference of two instances of ol.geom.Polygon', () => { const poly1 = new OlFeature({ geometry: new OlGeomPolygon(boxCoords) }); const poly2 = new OlFeature({ geometry: new OlGeomPolygon(boxCoords2) }); const differenceFeature = GeometryUtil.difference(poly1, poly2, 'EPSG:4326'); expect(differenceFeature instanceof OlFeature).toBe(true); expect((differenceFeature as OlFeature)!.getGeometry()!.getCoordinates()) .toEqual(differenceBoxCoords); }); it('returns poly1 if no difference is found', () => { const poly1 = new OlFeature({ geometry: new OlGeomPolygon(boxCoords) }); const poly2 = new OlFeature({ geometry: new OlGeomPolygon(boxCoords4) }); const differenceFeature = GeometryUtil.difference(poly1, poly2, 'EPSG:4326'); expect(differenceFeature instanceof OlFeature).toBe(true); expect((differenceFeature as OlFeature)!.getGeometry()!.getCoordinates()) .toEqual(poly1?.getGeometry()?.getCoordinates()); }); }); describe('with ol.geom.Geometry as params', () => { it('returns the difference of two instances of ol.geom.Polygon', () => { const poly1 = new OlGeomPolygon(boxCoords); const poly2 = new OlGeomPolygon(boxCoords2); const differenceGeometry = GeometryUtil.difference(poly1, poly2, 'EPSG:4326'); expect(differenceGeometry instanceof OlGeometry).toBe(true); expect((differenceGeometry as OlGeomMultiPolygon).getCoordinates()).toEqual(differenceBoxCoords); }); it('returns poly1 if no difference is found', () => { const poly1 = new OlGeomPolygon(boxCoords); const poly2 = new OlGeomPolygon(boxCoords4); const differenceGeometry = GeometryUtil.difference(poly1, poly2, 'EPSG:4326'); expect(differenceGeometry instanceof OlGeometry).toBe(true); expect((differenceGeometry as OlGeomPolygon).getCoordinates()).toEqual(poly1.getCoordinates()); }); }); }); describe('#intersection', () => { describe('with ol.Feature as params', () => { it('returns the intersection of two instances of ol.geom.Polygon', () => { const poly1 = new OlFeature({ geometry: new OlGeomPolygon(boxCoords) }); const poly2 = new OlFeature({ geometry: new OlGeomPolygon(boxCoords3) }); const intersectionFeature = GeometryUtil.intersection(poly1, poly2, 'EPSG:4326'); expect(intersectionFeature instanceof OlFeature).toBe(true); expect((intersectionFeature as OlFeature)!.getGeometry()!.getCoordinates()) .toEqual(intersectionCoords); }); it('returns null if no intersection is found', () => { const poly1 = new OlFeature({ geometry: new OlGeomPolygon(boxCoords) }); const poly2 = new OlFeature({ geometry: new OlGeomPolygon(boxCoords4) }); const intersectionFeature = GeometryUtil.intersection(poly1, poly2, 'EPSG:4326'); expect(intersectionFeature).toBeUndefined(); }); }); describe('with ol.geom.Geometry as params', () => { it('returns the intersection of two instances of ol.geom.Polygon', () => { const poly1 = new OlGeomPolygon(boxCoords); const poly2 = new OlGeomPolygon(boxCoords3); const intersectionGeometry = GeometryUtil.intersection(poly1, poly2, 'EPSG:4326'); expect(intersectionGeometry).toBeInstanceOf(OlGeomPolygon); expect((intersectionGeometry as OlGeomPolygon).getCoordinates()).toEqual(intersectionCoords); }); it('returns null if no intersection is found', () => { const poly1 = new OlGeomPolygon(boxCoords); const poly2 = new OlGeomPolygon(boxCoords4); const intersectionGeometry = GeometryUtil.intersection(poly1, poly2, 'EPSG:4326'); expect(intersectionGeometry).toBeUndefined(); }); }); }); describe('#getPolygonFromExtent', () => { it('is defined', () => { expect(GeometryUtil.getPolygonFromExtent).toBeDefined(); }); it('returns a polygon for a valid extent', () => { const extent: OlExtent = [0, 0, 10, 10]; const polygon = GeometryUtil.getPolygonFromExtent(extent); expect(polygon).toBeInstanceOf(OlGeomPolygon); expect(polygon?.getCoordinates()).toEqual([[[0, 0], [0, 10], [10, 10], [10, 0], [0, 0]]]); }); it('returns undefined for an extent with less than 4 values', () => { const extent: OlExtent = [0, 0, 10]; const polygon = GeometryUtil.getPolygonFromExtent(extent); expect(polygon).toBeUndefined(); }); it('returns undefined for a nil extent', () => { const extent = null; const polygon = GeometryUtil.getPolygonFromExtent(extent); expect(polygon).toBeUndefined(); }); }); }); });