use the flat data API for CSG to convert to and from Manifold objects

Author: madhephaestus

src/main/java/com/neuronrobotics/manifold3d/CSGManifold3d.java

@@ -49,95 +49,15 @@ public MemorySegment toManifold(CSG csg) throws Throwable {
 		if (csg == null)
 			throw new IllegalArgumentException("csg must not be null");
 
-		List<Polygon> polygons = csg.getPolygons();
-		if (polygons == null || polygons.isEmpty())
-			throw new IllegalArgumentException("CSG has no polygons");
-
-		// Build an indexed triangle mesh.
-		// Use a tolerance-free exact key so we don't merge
-		// numerically-close-but-distinct verts.
-		Map<String, Integer> vertexIndex = new HashMap<>();
-		List<double[]> vertexList = new ArrayList<>();
-		List<Long> triList = new ArrayList<>();
-
-		for (Polygon incoming : polygons) {
-			for (Polygon poly : PolygonUtil.triangulatePolygon(incoming)) {
-				List<Vertex> pverts = poly.getVertices();
-				if (pverts == null || pverts.size() < 3)
-					continue;
-
-				// Fan triangulation: (0,1,2), (0,2,3), (0,3,4), ...
-				int i0 = intern(pverts.get(0), vertexIndex, vertexList);
-				for (int i = 1; i < pverts.size() - 1; i++) {
-					int i1 = intern(pverts.get(i), vertexIndex, vertexList);
-					int i2 = intern(pverts.get(i + 1), vertexIndex, vertexList);
-
-					// Skip degenerate triangles (two or more identical indices).
-					if (i0 == i1 || i1 == i2 || i0 == i2)
-						continue;
-
-					triList.add((long) i0);
-					triList.add((long) i1);
-					triList.add((long) i2);
-				}
-			}
-		}
 
-		if (triList.isEmpty())
-			throw new IllegalArgumentException("CSG produced no valid triangles after triangulation");
+		double[] vertices = csg.getVertices();
 
-		long nVerts = vertexList.size();
-		long nTris = triList.size() / 3;
-
-		// Flatten vertex list into a primitive array.
-		double[] vertices = new double[(int) (nVerts * 3)];
-		for (int i = 0; i < nVerts; i++) {
-			double[] v = vertexList.get(i);
-			vertices[i * 3] = v[0];
-			vertices[i * 3 + 1] = v[1];
-			vertices[i * 3 + 2] = v[2];
-		}
-
-		// Flatten triangle index list.
-		long[] triangles = new long[triList.size()];
-		for (int i = 0; i < triList.size(); i++) {
-			triangles[i] = triList.get(i);
-		}
-
-		MemorySegment ms = manifold.importMeshGL64(vertices, triangles, nVerts, nTris);
+		long[] triangles = csg.getTriangles();
+		MemorySegment ms = manifold.importMeshGL64(vertices, triangles, vertices.length, triangles.length);
 		checkResult(ms);
 		return ms;
 	}
 
-	/**
-	 * Returns the index of {@code v} in {@code vertexList}, inserting it if not
-	 * already present. The key is an exact string representation of (x, y, z) using
-	 * {@link Double#toHexString} so that only bit-identical positions are merged,
-	 * matching the BSP's behavior.
-	 */
-	private static int intern(Vertex v, Map<String, Integer> index, List<double[]> list) {
-		// 1. Lower the precision slightly. 1e9 is too high for 'double' stability 
-		// after multiple CSG operations. 1e7 (0.1 nanometer) is the "sweet spot".
-		double precision = 1e7;
-
-		long x = Math.round(v.pos.x * precision);
-		long y = Math.round(v.pos.y * precision);
-		long z = Math.round(v.pos.z * precision);
-
-		String key = x + "," + y + "," + z;
-
-		return index.computeIfAbsent(key, k -> {
-			int idx = list.size();
-			// Use the RAW position for the first instance of this vertex.
-			// This keeps the geometry as true to the BSP as possible.
-			list.add(new double[] { v.pos.x, v.pos.y, v.pos.z });
-			return idx;
-		});
-	}
-	// -------------------------------------------------------------------------
-	// helpers
-
-
 	/**
 	 * Converts a native manifold {@link MemorySegment} to a JCSG {@link CSG}.
 	 *
@@ -168,31 +88,9 @@ public CSG fromManifold(MemorySegment ms) throws Throwable {
 		if (triCount == 0)
 			return new CSG();
 
-		ArrayList<Polygon> polygons = new ArrayList<>(triCount);
-
-		for (int t = 0; t < triCount; t++) {
-			int base = t * 3;
-
-			Vector3d p0 = vertexAt(verts, (int) tris[base]);
-			Vector3d p1 = vertexAt(verts, (int) tris[base + 1]);
-			Vector3d p2 = vertexAt(verts, (int) tris[base + 2]);
-
-			List<Vertex> vertices = Arrays.asList(new Vertex(p0), new Vertex(p1), new Vertex(p2));
-
-			polygons.add(new Polygon(vertices));
-		}
-
-		return CSG.fromPolygons(polygons);
+		return new CSG(verts, tris, verts.length, triCount);
 	}
 
-	// -------------------------------------------------------------------------
-	// helpers
-
-
-	private static Vector3d vertexAt(double[] verts, int index) {
-		int base = index * 3;
-		return new Vector3d(verts[base], verts[base + 1], verts[base + 2]);
-	}
 
 	/**
 	 * Slices the given CSG at Z=0 and returns the resulting cross-section as a list
@@ -366,7 +264,7 @@ private void checkResult(MemorySegment... memorySegments) throws Throwable {
 				System.out.println("Tris: " + manifold.numTri(ms));
 				System.out.println("Genus: " + manifold.genus(ms));
 				throw new NonManifoldShapeError("Error was " + err);
-			}else {
+			} else {
 				System.out.println("Manifold check ok!");
 			}
 		}
@@ -387,7 +285,7 @@ public CSG hull(List<Vector3d> points) throws Throwable {
 
 			CSG fromManifold = fromManifold(mem);
 			manifold.delete(mem);
-			mem=null;
+			mem = null;
 			return fromManifold;
 		} finally {
 			manifold.delete(mem);

src/main/java/eu/mihosoft/vrl/v3d/CSG.java

@@ -263,7 +263,7 @@ private static Vector3d vertexAt(double[] verts, long index) {
 	}
 
 	public Vector3d vertexAt(long i) {
-		return vertexAt(vertices, i);
+		return vertexAt(getVertices(), i);
 	}
 
 	public List<Vector3d> getPoints() {
@@ -275,9 +275,9 @@ public List<Vector3d> getPoints() {
 
 	public Polygon getPolygonByIndex(int faceIndex) throws ColinearPointsException {
 		List<Vertex> points = new ArrayList<Vertex>();
-		points.add(new Vertex(vertexAt(triangles[faceIndex * 3])));
-		points.add(new Vertex(vertexAt(triangles[faceIndex * 3 + 1])));
-		points.add(new Vertex(vertexAt(triangles[faceIndex * 3 + 2])));
+		points.add(new Vertex(vertexAt(getTriangles()[faceIndex * 3])));
+		points.add(new Vertex(vertexAt(getTriangles()[faceIndex * 3 + 1])));
+		points.add(new Vertex(vertexAt(getTriangles()[faceIndex * 3 + 2])));
 		return new Polygon(points);
 	}
 
@@ -323,15 +323,15 @@ public CSG processPolygonsToTriangles(ArrayList<Polygon> polygons) throws Coline
 		vertices = new double[(int) (vertCount * 3)];
 		for (int i = 0; i < vertCount; i++) {
 			Vector3d v = vertexList.get(i);
-			vertices[i * 3] = v.x;
-			vertices[i * 3 + 1] = v.y;
-			vertices[i * 3 + 2] = v.z;
+			getVertices()[i * 3] = v.x;
+			getVertices()[i * 3 + 1] = v.y;
+			getVertices()[i * 3 + 2] = v.z;
 		}
 
 		// Flatten triangle index list.
 		triangles = new long[(int) triCount * 3];
-		for (int i = 0; i < triangles.length; i++) {
-			triangles[i] = triList.get(i);
+		for (int i = 0; i < getTriangles().length; i++) {
+			getTriangles()[i] = triList.get(i);
 		}
 		return this;
 	}
@@ -995,7 +995,7 @@ public CSG clone() {
 	}
 
 	public CSG cloneShallow() {
-		return new CSG(vertices.clone(), triangles.clone(), vertCount, triCount);
+		return new CSG(getVertices().clone(), getTriangles().clone(), vertCount, triCount);
 	}
 
 	/**
@@ -1305,7 +1305,7 @@ public CSG hull(List<CSG> csgs) {
 
 		for (CSG c : csgs) {
 			for (int i = 0; i < c.vertCount; i++) {
-				points.add(vertexAt(c.vertices, i));
+				points.add(vertexAt(c.getVertices(), i));
 			}
 		}
 
@@ -2010,8 +2010,8 @@ public CSG makeManifold() throws ColinearPointsException {
 	}
 
 	private void setData(CSG csg) {
-		vertices = csg.vertices.clone();
-		triangles = csg.triangles.clone();
+		vertices = csg.getVertices().clone();
+		triangles = csg.getTriangles().clone();
 		vertCount = csg.vertCount;
 		triCount = csg.triCount;
 	}
@@ -2718,10 +2718,10 @@ public String toObjString() {
 	 */
 	private void flip() {
 		for (int i = 0; i < triCount; i++) {
-			long a = triangles[i * 3 + 1];
-			long b = triangles[i * 3 + 2];
-			triangles[i * 3 + 1] = b;
-			triangles[i * 3 + 2] = a;
+			long a = getTriangles()[i * 3 + 1];
+			long b = getTriangles()[i * 3 + 2];
+			getTriangles()[i * 3 + 1] = b;
+			getTriangles()[i * 3 + 2] = a;
 		}
 	}
 
@@ -2742,9 +2742,9 @@ public CSG transformed(Transform transform) {
 		CSG csg = clone();
 
 		for (int i = 0; i < vertCount; i++) {
-			double vectx = csg.vertices[i * 3];
-			double vecty = csg.vertices[i * 3 + 1];
-			double vectz = csg.vertices[i * 3 + 2];
+			double vectx = csg.getVertices()[i * 3];
+			double vecty = csg.getVertices()[i * 3 + 1];
+			double vectz = csg.getVertices()[i * 3 + 2];
 			double prevX = vectx;
 			double prevY = vecty;
 			double prevZ = vectz;
@@ -2763,9 +2763,9 @@ public CSG transformed(Transform transform) {
 			double diffY = vecty - prevY;
 			double diffZ = vectz - prevZ;
 
-			csg.vertices[i * 3] = prevX + (diffX);
-			csg.vertices[i * 3 + 1] = prevY + (diffY);
-			csg.vertices[i * 3 + 2] = prevZ + (diffZ);
+			csg.getVertices()[i * 3] = prevX + (diffX);
+			csg.getVertices()[i * 3 + 1] = prevY + (diffY);
+			csg.getVertices()[i * 3 + 2] = prevZ + (diffZ);
 		}
 		if (transform.isMirror()) {
 			flip();
@@ -2846,7 +2846,7 @@ public Bounds getBounds() {
 
 		for (int i = 0; i < vertCount; i++) {
 
-			Vector3d vert = vertexAt(vertices, i);
+			Vector3d vert = vertexAt(getVertices(), i);
 
 			if (vert.x < minX) {
 				minX = vert.x;
@@ -4534,4 +4534,12 @@ public static CSGManifold3d getManifold() {
 		return manifold;
 	}
 
+	public double[] getVertices() {
+		return vertices;
+	}
+
+	public long[] getTriangles() {
+		return triangles;
+	}
+
 }