1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.commons.geometry.euclidean.twod;
18
19 import org.apache.commons.geometry.core.GeometryTestUtils;
20 import org.apache.commons.geometry.core.RegionLocation;
21 import org.apache.commons.geometry.core.partitioning.Split;
22 import org.apache.commons.geometry.core.precision.DoublePrecisionContext;
23 import org.apache.commons.geometry.core.precision.EpsilonDoublePrecisionContext;
24 import org.apache.commons.geometry.euclidean.EuclideanTestUtils;
25 import org.apache.commons.geometry.euclidean.oned.Interval;
26 import org.junit.Assert;
27 import org.junit.Test;
28
29 public class LineSpanningSubsetTest {
30
31 private static final double TEST_EPS = 1e-10;
32
33 private static final DoublePrecisionContext TEST_PRECISION =
34 new EpsilonDoublePrecisionContext(TEST_EPS);
35
36 @Test
37 public void testProperties() {
38
39 final Line line = Lines.fromPoints(Vector2D.ZERO, Vector2D.Unit.PLUS_X, TEST_PRECISION);
40
41
42 final LineSpanningSubset result = new LineSpanningSubset(line);
43
44
45 Assert.assertSame(line, result.getHyperplane());
46 Assert.assertSame(line, result.getLine());
47
48 Assert.assertTrue(result.isFull());
49 Assert.assertFalse(result.isEmpty());
50 Assert.assertTrue(result.isInfinite());
51 Assert.assertFalse(result.isFinite());
52
53 GeometryTestUtils.assertPositiveInfinity(result.getSize());
54 Assert.assertNull(result.getCentroid());
55 Assert.assertNull(result.getBounds());
56
57 Assert.assertNull(result.getStartPoint());
58 GeometryTestUtils.assertNegativeInfinity(result.getSubspaceStart());
59 Assert.assertNull(result.getEndPoint());
60 GeometryTestUtils.assertPositiveInfinity(result.getSubspaceEnd());
61 }
62
63 @Test
64 public void testTransform() {
65
66 final AffineTransformMatrix2D t = AffineTransformMatrix2D.createRotation(-0.5 * Math.PI)
67 .translate(Vector2D.Unit.PLUS_X)
68 .scale(1, -1);
69
70 final LineConvexSubset span =
71 Lines.fromPointAndDirection(Vector2D.of(1, 0), Vector2D.Unit.PLUS_X, TEST_PRECISION).span();
72
73
74 final LineConvexSubset result = span.transform(t);
75
76
77 EuclideanTestUtils.assertCoordinatesEqual(Vector2D.Unit.PLUS_Y, result.getLine().getDirection(), TEST_EPS);
78 }
79
80 @Test
81 public void testReverse() {
82
83 final LineConvexSubset span =
84 Lines.fromPointAndDirection(Vector2D.of(1, 2), Vector2D.Unit.PLUS_X, TEST_PRECISION).span();
85
86
87 final LineConvexSubset rev = span.reverse();
88
89
90 EuclideanTestUtils.assertCoordinatesEqual(Vector2D.of(0, 2), rev.getLine().getOrigin(), TEST_EPS);
91 EuclideanTestUtils.assertCoordinatesEqual(Vector2D.Unit.MINUS_X, rev.getLine().getDirection(), TEST_EPS);
92 }
93
94 @Test
95 public void testClosest() {
96
97 final Vector2D p1 = Vector2D.of(0, -1);
98 final Vector2D p2 = Vector2D.of(0, 1);
99 final LineConvexSubset span =
100 Lines.fromPointAndDirection(p1, p1.directionTo(p2), TEST_PRECISION).span();
101
102
103 EuclideanTestUtils.assertCoordinatesEqual(p1, span.closest(p1), TEST_EPS);
104 EuclideanTestUtils.assertCoordinatesEqual(Vector2D.of(0, -2), span.closest(Vector2D.of(0, -2)), TEST_EPS);
105 EuclideanTestUtils.assertCoordinatesEqual(Vector2D.of(0, -2), span.closest(Vector2D.of(2, -2)), TEST_EPS);
106 EuclideanTestUtils.assertCoordinatesEqual(Vector2D.of(0, -1), span.closest(Vector2D.of(-1, -1)), TEST_EPS);
107
108 EuclideanTestUtils.assertCoordinatesEqual(p2, span.closest(p2), TEST_EPS);
109 EuclideanTestUtils.assertCoordinatesEqual(Vector2D.of(0, 2), span.closest(Vector2D.of(0, 2)), TEST_EPS);
110 EuclideanTestUtils.assertCoordinatesEqual(Vector2D.of(0, 2), span.closest(Vector2D.of(-2, 2)), TEST_EPS);
111 EuclideanTestUtils.assertCoordinatesEqual(Vector2D.of(0, 1), span.closest(Vector2D.of(-1, 1)), TEST_EPS);
112
113 EuclideanTestUtils.assertCoordinatesEqual(Vector2D.ZERO, span.closest(Vector2D.ZERO), TEST_EPS);
114 EuclideanTestUtils.assertCoordinatesEqual(Vector2D.of(0, 0.5), span.closest(Vector2D.of(1, 0.5)), TEST_EPS);
115 EuclideanTestUtils.assertCoordinatesEqual(Vector2D.of(0, -0.5), span.closest(Vector2D.of(-2, -0.5)), TEST_EPS);
116 }
117
118 @Test
119 public void testClassify() {
120
121 final LineConvexSubset span =
122 Lines.fromPointAndDirection(Vector2D.of(1, 1), Vector2D.Unit.PLUS_X, TEST_PRECISION).span();
123
124
125 for (double x = -10; x <= 10; x += 1) {
126 EuclideanTestUtils.assertRegionLocation(span, RegionLocation.INSIDE, Vector2D.of(x, 1 + 1e-11));
127
128 EuclideanTestUtils.assertRegionLocation(span, RegionLocation.OUTSIDE,
129 Vector2D.of(x, 0), Vector2D.of(x, 2));
130 }
131 }
132
133 @Test
134 public void testSplit() {
135
136 final Vector2D pt = Vector2D.of(1, 1);
137
138 final LineConvexSubset span = Lines.fromPointAndDirection(pt, Vector2D.Unit.PLUS_X, TEST_PRECISION).span();
139
140
141 Split<LineConvexSubset> split;
142
143
144 split = span.split(Lines.fromPointAndAngle(Vector2D.of(2, 2), 0, TEST_PRECISION));
145 Assert.assertNull(split.getMinus());
146 Assert.assertSame(span, split.getPlus());
147
148 split = span.split(Lines.fromPointAndAngle(Vector2D.of(2, 2), Math.PI, TEST_PRECISION));
149 Assert.assertSame(span, split.getMinus());
150 Assert.assertNull(split.getPlus());
151
152
153 split = span.split(Lines.fromPointAndDirection(pt, Vector2D.Unit.PLUS_X, TEST_PRECISION));
154 Assert.assertNull(split.getMinus());
155 Assert.assertNull(split.getPlus());
156
157
158 checkSplit(span.split(Lines.fromPointAndAngle(pt, 1, TEST_PRECISION)),
159 null, pt,
160 pt, null);
161 checkSplit(span.split(Lines.fromPointAndAngle(pt, -1, TEST_PRECISION)),
162 pt, null,
163 null, pt);
164 }
165
166 @Test
167 public void testGetInterval() {
168
169 final LineConvexSubset span =
170 Lines.fromPointAndDirection(Vector2D.of(2, -1), Vector2D.Unit.PLUS_X, TEST_PRECISION).span();
171
172
173 final Interval interval = span.getInterval();
174
175
176 GeometryTestUtils.assertNegativeInfinity(interval.getMin());
177 GeometryTestUtils.assertPositiveInfinity(interval.getMax());
178 }
179
180 @Test
181 public void testToString() {
182
183 final LineConvexSubset span =
184 Lines.fromPointAndDirection(Vector2D.ZERO, Vector2D.Unit.PLUS_X, TEST_PRECISION).span();
185
186
187 final String str = span.toString();
188
189
190 GeometryTestUtils.assertContains("LineSpanningSubset[origin= (0", str);
191 GeometryTestUtils.assertContains(", direction= (1", str);
192 }
193
194 private static void checkSplit(final Split<LineConvexSubset> split, final Vector2D minusStart, final Vector2D minusEnd,
195 final Vector2D plusStart, final Vector2D plusEnd) {
196
197 final LineConvexSubset minus = split.getMinus();
198 if (minusStart == null && minusEnd == null) {
199 Assert.assertNull(minus);
200 } else {
201 checkPoint(minusStart, minus.getStartPoint());
202 checkPoint(minusEnd, minus.getEndPoint());
203 }
204
205
206 final LineConvexSubset plus = split.getPlus();
207 if (plusStart == null && plusEnd == null) {
208 Assert.assertNull(plus);
209 } else {
210 checkPoint(plusStart, plus.getStartPoint());
211 checkPoint(plusEnd, plus.getEndPoint());
212 }
213 }
214
215 private static void checkPoint(final Vector2D expected, final Vector2D pt) {
216 if (expected == null) {
217 Assert.assertNull(pt);
218 } else {
219 EuclideanTestUtils.assertCoordinatesEqual(expected, pt, TEST_EPS);
220 }
221 }
222 }