Skip to content

Commit 55066ac

Browse files
ArtifactFormsArtifactForms
committed
Readded tests
1 parent f883a31 commit 55066ac

File tree

5 files changed

+933
-0
lines changed

5 files changed

+933
-0
lines changed

‎src/test/java/mesh/modifier/subdivision/test/LinearSubdivisionModifierTest.java‎

Lines changed: 308 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,308 @@
1+
package mesh.modifier.subdivision.test;
2+
3+
import static org.junit.jupiter.api.Assertions.assertEquals;
4+
import static org.junit.jupiter.api.Assertions.assertTrue;
5+
6+
import java.util.ArrayList;
7+
import java.util.HashSet;
8+
import java.util.List;
9+
10+
import org.junit.Before;
11+
import org.junit.Test;
12+
13+
import math.Vector3f;
14+
import mesh.Face3D;
15+
import mesh.Mesh3D;
16+
import mesh.creator.archimedian.CuboctahedronCreator;
17+
import mesh.creator.platonic.IcosahedronCreator;
18+
import mesh.creator.primitives.CubeCreator;
19+
import mesh.creator.primitives.PlaneCreator;
20+
import mesh.modifier.IMeshModifier;
21+
import mesh.modifier.subdivision.LinearSubdivisionModifier;
22+
import mesh.util.Bounds3;
23+
import util.MeshTestUtil;
24+
25+
public class LinearSubdivisionModifierTest {
26+
27+
private LinearSubdivisionModifier modifier;
28+
29+
private Mesh3D cubeMesh;
30+
31+
@Before
32+
public void setUp() {
33+
modifier = new LinearSubdivisionModifier();
34+
cubeMesh = new CubeCreator().create();
35+
}
36+
37+
@Test
38+
public void modifierImplementsModifierInterface() {
39+
assertTrue(modifier instanceof IMeshModifier);
40+
}
41+
42+
@Test
43+
public void returnsReferenceToOriginalMeshInstance() {
44+
Mesh3D result = modifier.modify(cubeMesh);
45+
assertTrue(cubeMesh == result);
46+
}
47+
48+
@Test
49+
public void subdividedCubeHasTwentyFourFaces() {
50+
modifier.modify(cubeMesh);
51+
assertEquals(24, cubeMesh.getFaceCount());
52+
}
53+
54+
@Test
55+
public void twiceSubdividedCubeHasNintySixFaces() {
56+
modifier.modify(cubeMesh);
57+
modifier.modify(cubeMesh);
58+
assertEquals(96, cubeMesh.getFaceCount());
59+
}
60+
61+
@Test
62+
public void subdividedCubeHasTwentySixVertices() {
63+
modifier.modify(cubeMesh);
64+
assertEquals(26, cubeMesh.getVertexCount());
65+
}
66+
67+
@Test
68+
public void twiceSubdividedCubeHasNintyEightVertices() {
69+
modifier.modify(cubeMesh);
70+
modifier.modify(cubeMesh);
71+
assertEquals(98, cubeMesh.getVertexCount());
72+
}
73+
74+
@Test
75+
public void subdividedCubeIsManifold() {
76+
modifier.modify(cubeMesh);
77+
assertTrue(MeshTestUtil.isManifold(cubeMesh));
78+
}
79+
80+
@Test
81+
public void subdividedCubeHasNoLooseVertices() {
82+
modifier.modify(cubeMesh);
83+
assertTrue(MeshTestUtil.meshHasNoLooseVertices(cubeMesh));
84+
}
85+
86+
@Test
87+
public void twiceSubdividedCubeHasNoLooseVertices() {
88+
modifier.modify(cubeMesh);
89+
modifier.modify(cubeMesh);
90+
assertTrue(MeshTestUtil.meshHasNoLooseVertices(cubeMesh));
91+
}
92+
93+
@Test
94+
public void subdividedCubeHasFaceNormalPointOutward() {
95+
modifier.modify(cubeMesh);
96+
assertTrue(MeshTestUtil.normalsPointOutwards(cubeMesh));
97+
}
98+
99+
@Test
100+
public void subdividedCubeContainsVerticesAtOriginalCubePositions() {
101+
Mesh3D originalCube = new CubeCreator().create();
102+
Mesh3D subdividedCube = new CubeCreator().create();
103+
modifier.modify(subdividedCube);
104+
for (Vector3f v : originalCube.getVertices()) {
105+
assertTrue(subdividedCube.getVertices().contains(v));
106+
}
107+
}
108+
109+
@Test
110+
public void subdividedCubeContainsFaceCenterVertices() {
111+
Mesh3D originalCube = new CubeCreator().create();
112+
Mesh3D subdividedCube = new CubeCreator().create();
113+
modifier.modify(subdividedCube);
114+
for (Face3D face : originalCube.getFaces()) {
115+
Vector3f center = originalCube.calculateFaceCenter(face);
116+
assertTrue(subdividedCube.getVertices().contains(center));
117+
}
118+
}
119+
120+
@Test
121+
public void subdividedCuveHasNoDuplicatedFaces() {
122+
modifier.modify(cubeMesh);
123+
assertTrue(MeshTestUtil.meshHasNoDuplicatedFaces(cubeMesh));
124+
}
125+
126+
@Test
127+
public void subdividedCubeConsistsOfQuadsOnly() {
128+
modifier.modify(cubeMesh);
129+
int faceCount = cubeMesh.getFaceCount();
130+
assertTrue(MeshTestUtil.isQuadCountEquals(cubeMesh, faceCount));
131+
}
132+
133+
@Test
134+
public void subdividedIcosahedronConsistsOfTrianglesOnly() {
135+
Mesh3D mesh = new IcosahedronCreator().create();
136+
modifier.modify(mesh);
137+
int faceCount = mesh.getFaceCount();
138+
assertTrue(MeshTestUtil.isTriangleCountEquals(mesh, faceCount));
139+
}
140+
141+
@Test
142+
public void subdividedIcosahedronHasEightyFaces() {
143+
Mesh3D mesh = new IcosahedronCreator().create();
144+
modifier.modify(mesh);
145+
assertEquals(80, mesh.getFaceCount());
146+
}
147+
148+
@Test
149+
public void subdividedIcosahedronHasFourtyTwoVertices() {
150+
Mesh3D mesh = new IcosahedronCreator().create();
151+
modifier.modify(mesh);
152+
assertEquals(42, mesh.getVertexCount());
153+
}
154+
155+
@Test
156+
public void subdividedIcosahedronIsManifold() {
157+
Mesh3D mesh = new IcosahedronCreator().create();
158+
modifier.modify(mesh);
159+
assertTrue(MeshTestUtil.isManifold(mesh));
160+
}
161+
162+
@Test
163+
public void subdividedIcosahedronHasNoLooseVertices() {
164+
Mesh3D mesh = new IcosahedronCreator().create();
165+
modifier.modify(mesh);
166+
assertTrue(MeshTestUtil.meshHasNoLooseVertices(mesh));
167+
}
168+
169+
@Test
170+
public void subdividedCubeIsWithinBounds() {
171+
modifier.modify(cubeMesh);
172+
Bounds3 bounds = cubeMesh.calculateBounds();
173+
assertEquals(2, bounds.getWidth(), 0);
174+
assertEquals(2, bounds.getHeight(), 0);
175+
assertEquals(2, bounds.getDepth(), 0);
176+
}
177+
178+
@Test
179+
public void everyFaceContainsCenterVertexIndex() {
180+
Mesh3D plane = new PlaneCreator().create();
181+
Face3D face = plane.getFaceAt(0);
182+
Vector3f center = plane.calculateFaceCenter(face);
183+
modifier.modify(plane);
184+
for (Face3D f : plane.getFaces()) {
185+
boolean containsCenter = false;
186+
for (int i = 0; i < f.indices.length; i++) {
187+
Vector3f v = plane.getVertexAt(f.indices[i]);
188+
containsCenter |= v.equals(center);
189+
}
190+
assertTrue(containsCenter);
191+
}
192+
}
193+
194+
@Test
195+
public void removingCenterAndEdgePointsLeavesOriginalVerticesQuadCase() {
196+
Mesh3D originalCube = new CubeCreator().create();
197+
modifier.modify(cubeMesh);
198+
List<Vector3f> vertices = cubeMesh.getVertices();
199+
vertices.removeAll(calculateEdgePoints(originalCube));
200+
for (Face3D face : originalCube.getFaces()) {
201+
Vector3f center = originalCube.calculateFaceCenter(face);
202+
vertices.remove(center);
203+
}
204+
assertEquals(8, vertices.size());
205+
for (Vector3f v : originalCube.getVertices()) {
206+
assertTrue(vertices.contains(v));
207+
}
208+
}
209+
210+
@Test
211+
public void removingEdgePointsLeavesOriginalVerticesTriangleCase() {
212+
Mesh3D original = new IcosahedronCreator().create();
213+
Mesh3D mesh = new IcosahedronCreator().create();
214+
int expectedVertexCount = original.getVertexCount();
215+
modifier.modify(mesh);
216+
List<Vector3f> vertices = mesh.getVertices();
217+
vertices.removeAll(calculateEdgePoints(original));
218+
assertEquals(expectedVertexCount, vertices.size());
219+
for (Vector3f v : original.getVertices()) {
220+
assertTrue(vertices.contains(v));
221+
}
222+
}
223+
224+
private List<Vector3f> calculateEdgePoints(Mesh3D mesh) {
225+
List<Vector3f> edgePoints = new ArrayList<>();
226+
for (Face3D face : mesh.getFaces()) {
227+
int length = face.indices.length;
228+
for (int i = 0; i < length; i++) {
229+
Vector3f from = mesh.getVertexAt(face.indices[i]);
230+
Vector3f to = mesh.getVertexAt(face.indices[(i + 1) % length]);
231+
Vector3f edgePoint = from.add(to).mult(0.5f);
232+
edgePoints.add(edgePoint);
233+
}
234+
}
235+
return edgePoints;
236+
}
237+
238+
@Test
239+
public void subdividedCuboctahedronHasThrirtyTwoTriangularFaces() {
240+
CuboctahedronCreator creator = new CuboctahedronCreator();
241+
Mesh3D mesh = creator.create();
242+
modifier.modify(mesh);
243+
assertTrue(MeshTestUtil.isTriangleCountEquals(mesh, 32));
244+
}
245+
246+
@Test
247+
public void subdividedCuboctahedronHasTwentyFourQuads() {
248+
CuboctahedronCreator creator = new CuboctahedronCreator();
249+
Mesh3D mesh = creator.create();
250+
modifier.modify(mesh);
251+
assertTrue(MeshTestUtil.isQuadCountEquals(mesh, 24));
252+
}
253+
254+
@Test
255+
public void subdividedCuboctahedronHasNoLooseVertices() {
256+
CuboctahedronCreator creator = new CuboctahedronCreator();
257+
Mesh3D mesh = creator.create();
258+
modifier.modify(mesh);
259+
assertTrue(MeshTestUtil.meshHasNoLooseVertices(mesh));
260+
}
261+
262+
@Test
263+
public void subdividedCuboctahedronHasNoDuplicatedFaces() {
264+
CuboctahedronCreator creator = new CuboctahedronCreator();
265+
Mesh3D mesh = creator.create();
266+
modifier.modify(mesh);
267+
assertTrue(MeshTestUtil.meshHasNoDuplicatedFaces(mesh));
268+
}
269+
270+
@Test
271+
public void subdividedCuboctahedronIsManifold() {
272+
CuboctahedronCreator creator = new CuboctahedronCreator();
273+
Mesh3D mesh = creator.create();
274+
modifier.modify(mesh);
275+
assertTrue(MeshTestUtil.isManifold(mesh));
276+
}
277+
278+
@Test
279+
public void subdividedCuboctahedronHasFourtyTwoVertices() {
280+
CuboctahedronCreator creator = new CuboctahedronCreator();
281+
Mesh3D mesh = creator.create();
282+
modifier.modify(mesh);
283+
assertEquals(42, mesh.getVertexCount());
284+
}
285+
286+
@Test
287+
public void subdividedCuboctahedronHasNoDuplicatedVertices() {
288+
CuboctahedronCreator creator = new CuboctahedronCreator();
289+
Mesh3D mesh = creator.create();
290+
modifier.modify(mesh);
291+
HashSet<Vector3f> vertices = new HashSet<>();
292+
vertices.addAll(mesh.getVertices());
293+
assertEquals(42, mesh.getVertexCount());
294+
}
295+
296+
@Test
297+
public void subdividedCuboctahedronHasNoDuplicatedVerticesThreshold() {
298+
CuboctahedronCreator creator = new CuboctahedronCreator();
299+
Mesh3D mesh = creator.create();
300+
modifier.modify(mesh);
301+
for (Vector3f v : mesh.vertices)
302+
v.roundLocalDecimalPlaces(2);
303+
HashSet<Vector3f> vertices = new HashSet<>();
304+
vertices.addAll(mesh.getVertices());
305+
assertEquals(42, mesh.getVertexCount());
306+
}
307+
308+
}

0 commit comments

Comments
 (0)