@Test
public void testIsEarTip2() {
List<VectorXZ> outlineNoDup = outlineB.subList(0, outlineB.size() - 1);
assertTrue(EarClippingTriangulationUtil.isEarTip(0, outlineNoDup));
assertFalse(EarClippingTriangulationUtil.isEarTip(1, outlineNoDup));
assertFalse(EarClippingTriangulationUtil.isEarTip(2, outlineNoDup));
assertTrue(EarClippingTriangulationUtil.isEarTip(3, outlineNoDup));
assertFalse(EarClippingTriangulationUtil.isEarTip(4, outlineNoDup));
}
@Test
public void testIsConvex2() {
List<VectorXZ> outlineNoDup = outlineB.subList(0, outlineB.size() - 1);
for (int i = 0; i < outlineNoDup.size(); i++) {
if (i == 4) {
assertFalse(EarClippingTriangulationUtil.isConvex(i, outlineNoDup));
} else {
assertTrue("at " + i, EarClippingTriangulationUtil.isConvex(i, outlineNoDup));
}
}
}
@Test
public void testFindVisibleOutlineVertex3() {
assertNull(
EarClippingTriangulationUtil.findVisibleOutlineVertex(
outlineA, new VectorXZ(0.55f, 0.55f), Arrays.asList(holeA, holeB)));
}
@Test
public void testFindVisibleOutlineVertex1() {
assertNotNull(
EarClippingTriangulationUtil.findVisibleOutlineVertex(
outlineA, new VectorXZ(0.55f, 0.55f), Collections.<SimplePolygonXZ>emptyList()));
}
@Test
public void testIsEarTip1() {
for (int i = 0; i < outlineA.size(); i++) {
assertTrue(EarClippingTriangulationUtil.isEarTip(i, outlineA));
}
}
@Test
public void testTriangulateSimplePolygon() {
List<TriangleXZ> triangles =
new ArrayList<TriangleXZ>(
EarClippingTriangulationUtil.triangulateSimplePolygon(
new ArrayList<VectorXZ>(outlineA)));
assertSame(triangles.size(), 2);
Collection<VectorXZ> vsT0 =
Arrays.asList(triangles.get(0).v1, triangles.get(0).v2, triangles.get(0).v3);
Collection<VectorXZ> vsT1 =
Arrays.asList(triangles.get(1).v1, triangles.get(1).v2, triangles.get(1).v3);
if (vsT0.contains(outlineA0) && vsT0.contains(outlineA1) && vsT0.contains(outlineA2)) {
assertTrue(vsT1.contains(outlineA0) && vsT1.contains(outlineA3) && vsT1.contains(outlineA2));
} else if (vsT0.contains(outlineA1) && vsT0.contains(outlineA2) && vsT0.contains(outlineA3)) {
assertTrue(vsT1.contains(outlineA1) && vsT1.contains(outlineA0) && vsT1.contains(outlineA3));
} else if (vsT0.contains(outlineA2) && vsT0.contains(outlineA3) && vsT0.contains(outlineA0)) {
assertTrue(vsT1.contains(outlineA2) && vsT1.contains(outlineA1) && vsT1.contains(outlineA0));
} else if (vsT0.contains(outlineA3) && vsT0.contains(outlineA0) && vsT0.contains(outlineA1)) {
assertTrue(vsT1.contains(outlineA3) && vsT1.contains(outlineA2) && vsT1.contains(outlineA1));
} else {
fail();
}
}
@Test
public void testFindVisibleOutlineVertex2() {
assertEquals(
outlineA2,
outlineA.get(
EarClippingTriangulationUtil.findVisibleOutlineVertex(
outlineA, new VectorXZ(0.55f, 0.55f), Arrays.asList(holeA))));
}
/** rearrange, invert */
@Test
public void testRearrangeOutline2() {
List<VectorXZ> newOutline = EarClippingTriangulationUtil.rearrangeOutline(outlineA, 3, true);
assertSame(5, newOutline.size());
assertEquals(outlineA3, newOutline.get(0));
assertEquals(outlineA2, newOutline.get(1));
assertEquals(outlineA1, newOutline.get(2));
assertEquals(outlineA0, newOutline.get(3));
assertEquals(outlineA3, newOutline.get(4));
}
@Test
public void testInsertHoleInPolygonOutline() {
List<VectorXZ> newOutline = new LinkedList<VectorXZ>(outlineA);
EarClippingTriangulationUtil.insertHoleInPolygonOutline(
newOutline, holeB, Arrays.asList(holeA));
assertSame(outlineA.size() + holeB.getVertexLoop().size() + 1, newOutline.size());
for (VectorXZ innerVertex : holeB.getVertexLoop()) {
assertTrue(newOutline.contains(innerVertex));
}
}
@Test
public void testInsertVertexInPolygonOutline() {
VectorXZ point = new VectorXZ(0.55f, 0.55f);
List<VectorXZ> newOutline = new LinkedList<VectorXZ>(outlineA);
EarClippingTriangulationUtil.insertVertexInPolygonOutline(newOutline, point);
assertSame(7, newOutline.size());
assertTrue(newOutline.contains(point));
assertEquals(
newOutline.get(newOutline.indexOf(point) - 1),
newOutline.get(newOutline.indexOf(point) + 1));
}
