csg 0.1.3 → 0.1.4

data/src/cmd_audit.h

@@ -0,0 +1,9 @@
+#include "mesh.h"
+#include "poly.h"
+
+#ifndef __CMD_AUDIT_H
+#define __CMD_AUDIT_H
+
+int cmd_audit(int argc, char *argv[]);
+
+#endif

data/src/commands.c

@@ -1,11 +1,13 @@
 #include <string.h>
 #include "dbg.h"
 
+#include "util.h"
 #include "commands.h"
 #include "mesh.h"
 #include "bsp.h"
 #include "bsp_mesh.h"
 #include "export.h"
+#include "cmd_audit.h"
 
 typedef bsp_node_t* (*bsp_binary_op)(bsp_node_t *, bsp_node_t *);
 
@@ -26,14 +28,14 @@ bsp_node_t* bsp_binary_operation(char *path1, char *path2, bsp_binary_op op) {
 	check(file1 != NULL, "Failed to read mesh from '%s'", path1);
 	log_info("Loaded file: %s %d facets", path1, file1->poly_count(file1));
 	bsp1 = mesh_to_bsp(file1);
-	check_mem(bsp1);
+	assert_mem(bsp1);
 
 	// Read 2
 	file2 = mesh_read_file(path2);
 	check(file2 != NULL, "Failed to read mesh from '%s'", path2);
 	log_info("Loaded file: %s %d facets", path2, file2->poly_count(file2));
 	bsp2 = mesh_to_bsp(file2);
-	check_mem(bsp2);
+	assert_mem(bsp2);
 
 	// Operate
 	result = op(bsp1, bsp2);
@@ -89,11 +91,54 @@ MAKE_CSG_COMMAND(intersect);
 MAKE_CSG_COMMAND(union);
 MAKE_CSG_COMMAND(subtract);
 
+// Commands that exist only when built with `DEBUG` defined
+// these generally don't do anything useful
+#ifdef DEBUG
+int cmd_DEBUG_bsp(int argc, char **argv) {
+	const char *suffix = ".bsp.stl";
+	char *name = argv[0];
+	char *out_name = NULL;
+	mesh_t *in = NULL;
+	mesh_t *out = NULL;
+	bsp_node_t *bsp = NULL;
+	check(argc >= 1, "Too few args");
+	assert_mem(out_name = calloc(strlen(name) + strlen(suffix) + 1, 1));
+	check(sprintf(out_name, "%s%s", name, suffix) == (strlen(name) + strlen(suffix)), "Failed to build out name.");
+
+	check(in = mesh_read_file(name), "Failed to READ");
+	check(bsp = in->to_bsp(in), "Failed to BSP");
+	check(out = bsp_to_mesh(bsp, 0), "Failed to BSP->mesh wrap");
+	bsp = NULL; // Make it obvs that out now holds the ref
+
+	log_info("Read: [%s]", argv[0]);
+	log_info("Poly Count: [%d]", in->poly_count(in));
+	log_info("BSP: [%p]", out);
+	log_info("BSP Poly Count: [%d]", out->poly_count(out));
+	log_info("Write: [%s](%d)", out_name, out->write(out, out_name, "STL"));
+
+	if(out != NULL) out->destroy(out);
+	if(in != NULL) in->destroy(in);
+	if(out_name != NULL) free(out_name);
+	return 0;
+error:
+	if(out != NULL) out->destroy(out);
+	if(in != NULL) in->destroy(in);
+	if(out_name != NULL) free(out_name);
+	return -1;
+}
+#endif
+
 // Available commands
 const cmd_t commands[] = {
 	{"intersect", "Intersect two geometries", cmd_intersect},
 	{"subtract",  "Subtract two geometries",  cmd_subtract},
 	{"union",     "Union two geometries",     cmd_union},
+	{"audit",     "Audit a mesh on disk for errors",     cmd_audit},
+
+#ifdef DEBUG
+	{"bsp",       "Identity through BSP",     cmd_DEBUG_bsp},
+#endif
+
 	{NULL, NULL, NULL}
 };
 

data/src/export.c

@@ -1,9 +1,9 @@
+#include "util.h"
 #include "export.h"
 #include "bsp_mesh.h"
 
 stl_object *stl_from_polys(klist_t(poly) *polygons) {
 	stl_object *stl = stl_alloc(NULL, polygons->size);
-	check_mem(stl);
 
 	kliter_t(poly) *iter = kl_begin(polygons);
 	stl_facet *facet = stl->facets;
@@ -49,13 +49,11 @@ bsp_node_t *stl_to_bsp(stl_object *stl) {
 		poly = poly_make_triangle(stl->facets[i].vertices[0],
 								  stl->facets[i].vertices[1],
 								  stl->facets[i].vertices[2]);
-		check_mem(polys);
 		*kl_pushp(poly, polys) = poly;
 	}
 	check(polys->size == stl->facet_count, "Wrong number of faces generated.");
 
 	tree = bsp_build(NULL, polys, 1);
-	check_mem(tree);
 
 	kl_destroy(poly, polys);
 	return tree;
@@ -77,33 +75,56 @@ mesh_t* bsp_to_mesh(bsp_node_t* bsp, int copy) {
 	return NEW(bsp_mesh_t, "BSP", input);
 }
 
-klist_t(poly)* polys_to_tris(klist_t(poly) *dst, klist_t(poly) *src) {
+klist_t(poly) *poly_to_tris(klist_t(poly)* dst, poly_t *poly) {
 	klist_t(poly) *result = dst;
 	if(result == NULL) result = kl_init(poly);
 
-	kliter_t(poly) *iter = NULL;
-	for(iter = kl_begin(src); iter != kl_end(src); iter = kl_next(iter)) {
-		poly_t *poly = kl_val(iter);
-		int vertex_count = poly_vertex_count(poly);
+	int vertex_count = poly_vertex_count(poly);
 
-		// Copy triangles, split higher-vertex polygons into triangle fans.
-		if(vertex_count == 3) {
-			poly_t *copy = clone_poly(poly);
-			check_mem(copy);
-			*kl_pushp(poly, result) = copy;
-		}
-		else if(vertex_count > 3) {
-			float3 *v_cur, *v_prev;
-			for(int i = 2; i < vertex_count; i++) {
-				v_cur = &poly->vertices[i];
-				v_prev = &poly->vertices[i - 1];
-				poly_t *tri = poly_make_triangle(poly->vertices[0], *v_prev, *v_cur);
-				check_mem(tri);
+	// Copy triangles, split higher-vertex polygons into triangle fans.
+	if(vertex_count == 3) {
+		*kl_pushp(poly, result) = clone_poly(poly);
+	}
+	else if(vertex_count > 3) {
+		float3 *v_cur, *v_prev;
+		for(int i = 2; i < vertex_count; i++) {
+			v_cur = &poly->vertices[i];
+			v_prev = &poly->vertices[i - 1];
+			poly_t *tri = poly_make_triangle(poly->vertices[0], *v_prev, *v_cur);
+
+			// If we don't create a valid polygon, don't include it in the result.
+			if(tri != NULL) {
 				*kl_pushp(poly, result) = tri;
 			}
-		} else {
-			sentinel("polygon(%p) has less than three(%d) vertices.", poly, poly_vertex_count(poly));
+			else {
+#ifdef DEBUG
+				log_warn("Failed to build triangle:\n(%f, %f, %f)\n(%f, %f, %f)\n(%f, %f, %f)",
+						 FLOAT3_FORMAT(poly->vertices[0]), FLOAT3_FORMAT(*v_prev), FLOAT3_FORMAT(*v_cur));
+				log_warn("Original:");
+				poly_print(poly, dbg_get_log());
+#endif
+			}
 		}
+	} else {
+		sentinel("polygon(%p) has less than three(%d) vertices.", poly, poly_vertex_count(poly));
+	}
+
+	return result;
+error:
+	if(result != dst) if(result != NULL) kl_destroy(poly, result);
+	return NULL;
+}
+
+klist_t(poly)* polys_to_tris(klist_t(poly) *dst, klist_t(poly) *src) {
+	klist_t(poly) *result = dst;
+	if(result == NULL) result = kl_init(poly);
+
+	kliter_t(poly) *iter = NULL;
+	for(iter = kl_begin(src); iter != kl_end(src); iter = kl_next(iter)) {
+		poly_t *poly = kl_val(iter);
+		check(poly_to_tris(result, poly) != NULL,
+			  "Failed to tesselate %p(%d) into triangles.",
+			  poly, poly_vertex_count(poly));
 	}
 
 	return result;

data/src/export.h

@@ -15,6 +15,7 @@ stl_object *bsp_to_stl(bsp_node_t *tree);
 bsp_node_t *stl_to_bsp(stl_object *stl);
 bsp_node_t *mesh_to_bsp(mesh_t *mesh);
 mesh_t* bsp_to_mesh(bsp_node_t *tree, int copy);
+klist_t(poly) *poly_to_tris(klist_t(poly)* dst, poly_t *src);
 klist_t(poly)* polys_to_tris(klist_t(poly)* dst, klist_t(poly)* src);
 
 #endif

data/src/poly.c

@@ -1,14 +1,16 @@
+#include <stdio.h>
 #include <assert.h>
+#include <stdbool.h>
 
 #include "poly.h"
+#include "util.h"
+#include "export.h"
 
 poly_t *alloc_poly(void) {
 	poly_t *poly = malloc(sizeof(poly_t));
-	check_mem(poly);
+	assert_mem(poly);
 	poly_init(poly);
 	return poly;
-error:
-	return NULL;
 }
 
 void free_poly(poly_t *p, int free_self) {
@@ -20,6 +22,24 @@ void free_poly(poly_t *p, int free_self) {
 	if(free_self) free(p);
 }
 
+void poly_print(poly_t *p, FILE *stream) {
+	fprintf(stream, "Poly(%p) Verts: %d Area: %f:\n", p, poly_vertex_count(p), poly_area(p));
+	for(int i = 0; i < poly_vertex_count(p); i++) {
+		fprintf(stream,"\tV[%d]: (%f, %f, %f)\n", i, FLOAT3_FORMAT(p->vertices[i]));
+	}
+}
+
+void poly_print_with_plane_info(poly_t *p, poly_t *plane, FILE *stream) {
+	fprintf(stream, "Poly(%p) w(%f) Verts: %d Area: %f:\n", p, p->w, poly_vertex_count(p), poly_area(p));
+	for(int i = 0; i < poly_vertex_count(p); i++) {
+		float3 diff = FLOAT3_INIT;
+		f3_sub(&diff, p->vertices[i], plane->vertices[0]);
+		float distance = f3_dot(plane->normal, diff);
+		fprintf(stream,"\tV[%d]: (%f, %f, %f) [%s] - %f from plane\n",
+				i, FLOAT3_FORMAT(p->vertices[i]), poly_classify_vertex_string(plane, p->vertices[i]), distance);
+	}
+}
+
 poly_t *poly_init(poly_t *poly) {
 	poly->vertex_count = 0;
 	poly->vertex_max = POLY_MAX_VERTS;
@@ -28,8 +48,7 @@ poly_t *poly_init(poly_t *poly) {
 }
 
 poly_t *clone_poly(poly_t *poly) {
-	poly_t *copy = NULL;
-	check_mem(copy = alloc_poly());
+	poly_t *copy = alloc_poly();
 	memcpy(copy, poly, sizeof(poly_t));
 
 	// Either point the clone at its own copied
@@ -41,14 +60,11 @@ poly_t *clone_poly(poly_t *poly) {
 		// We can lean on the `copy->*` memebers
 		// since they would have been memcpy'd over
 		copy->vertices = malloc(poly_vertex_max(copy) * sizeof(float3));
-		check_mem(copy->vertices);
+		assert_mem(copy->vertices);
 		memcpy(copy->vertices, poly->vertices, poly_vertex_max(copy) * sizeof(float3));
 	}
 
 	return copy;
-error:
-	if(copy != NULL) free_poly(copy, 1);
-	return NULL;
 }
 
 int poly_update(poly_t *poly) {
@@ -70,6 +86,65 @@ int poly_update(poly_t *poly) {
 	return 0;
 }
 
+// Return two times the area of a triangle.
+// Avoids the division in half unless it's required to avoid
+// failing `f > 0.0` when area is used as a predicate
+float poly_triangle_2area(poly_t *triangle) {
+	if(poly_vertex_count(triangle) != 3) return NAN;
+
+	return triangle_2area(
+		triangle->vertices[0],
+		triangle->vertices[1],
+		triangle->vertices[2]
+	);
+}
+
+// The actual area of a triangle `triangle`
+// Works through poly_triangle_2area
+float poly_triangle_area(poly_t *triangle) {
+	return 0.5 * poly_triangle_2area(triangle);
+}
+
+float poly_area(poly_t *poly) {
+	return poly_2area(poly) / 2.0;
+}
+
+float poly_2area(poly_t *poly) {
+	float area2 = 0.0;
+	const int vertex_count = poly_vertex_count(poly);
+
+	// Sanity check that we have at least a polygon
+	if(vertex_count < 3) return NAN;
+
+	// Before we get into this tesselating bullshit, is this just a triangle?
+	if(vertex_count == 3) return poly_triangle_2area(poly);
+
+	// Break the poly into a triangle fan and sum the 2areas of the components
+	// Note that i = 2 on first iteration so that `i - 1` is defined and != 0
+	// This starts the loop on the first triangle in the poly.
+	// Since we're only caring about the magnitude of the cross inside
+	// triangle_2area, the vertex order doesn't matter.
+	for(int i = 2; i < vertex_count; i++) {
+		area2 += triangle_2area(
+			poly->vertices[0],     // Root vertex
+			poly->vertices[i - 1], // Previous vertex
+			poly->vertices[i]      // Current vertex
+	    );
+	}
+
+
+	return area2;
+}
+
+bool poly_has_area(poly_t *poly) {
+	float area = poly_2area(poly);
+	check_debug(!isnan(area), "Polygon(%p) area is NaN", poly);
+
+	return area > 0.0;
+error:
+	return false;
+}
+
 int poly_vertex_count(poly_t *poly) {
 	return poly->vertex_count;
 }
@@ -91,7 +166,7 @@ int poly_vertex_expand(poly_t *poly) {
 	// Not using realloc because the original buffer may be struct-owned
 	int new_size = poly->vertex_max * 2;
 	float3 *new_verts = malloc(new_size * sizeof(float3));
-	check_mem(new_verts);
+	assert_mem(new_verts);
 
 	memcpy(new_verts, poly->vertices, poly->vertex_max * sizeof(float3));
 	poly->vertex_max = new_size;
@@ -105,17 +180,28 @@ int poly_vertex_expand(poly_t *poly) {
 	poly->vertices = new_verts;
 
 	return 0;
-error:
-	if(new_verts != NULL) free(new_verts);
-	return -1;
 }
 
-// add a vertex to the end of the polygon vertex list
-int poly_push_vertex(poly_t *poly, float3 v) {
+// add a vertex to the end of the polygon vertex list, if
+// `guard` is true, a check will be performed to reject
+// verts that cause 0-length edges to appear.
+bool poly_push_vertex_guarded(poly_t *poly, float3 v, bool guard) {
 	if(poly_vertex_available(poly) == 0) {
 		poly_vertex_expand(poly);
 	}
 
+	// We only need to perform zero-length-edge checks if we are
+	// actually going to create an edge through this push.
+	if(guard && (poly_vertex_count(poly) > 0)) {
+		int last_idx = poly_vertex_count(poly) - 1;
+		bool duplicate_first = !(f3_distance2(poly->vertices[0], v) > 0.0);
+		bool duplicate_last  = !(f3_distance2(poly->vertices[last_idx], v) > 0.0);
+
+		// Fail out the addition if we're adding a duplucate first or last vertex
+		// as the new last vert. This would create an edge of length zero.
+		if(duplicate_first || duplicate_last) return false;
+	}
+
 	// Dat assignment copy
 	poly->vertices[poly->vertex_count][0] = v[0];
 	poly->vertices[poly->vertex_count][1] = v[1];
@@ -126,9 +212,20 @@ int poly_push_vertex(poly_t *poly, float3 v) {
 		check(poly_update(poly) == 0, "Failed to update polygon during poly_push_vertex(%p)", poly);
 	}
 
-	return 0;
+	return true;
 error:
-	return -1;
+	return false;
+}
+
+// The default interface to pushing a vertex, force the guard to on
+bool poly_push_vertex(poly_t *poly, float3 v) {
+	return poly_push_vertex_guarded(poly, v, true);
+}
+
+// Unsafe poly push, forces the guard off, allowing 0-length edges
+// to form. Useful in the `audit` command
+bool poly_push_vertex_unsafe(poly_t *poly, float3 v) {
+	return poly_push_vertex_guarded(poly, v, false);
 }
 
 int poly_classify_vertex(poly_t *poly, float3 v) {
@@ -138,6 +235,21 @@ int poly_classify_vertex(poly_t *poly, float3 v) {
 	return COPLANAR;
 }
 
+const char* poly_classify_vertex_string(poly_t *poly, float3 v) {
+	const char *classification = "UNKNOWN";
+	switch(poly_classify_vertex(poly, v)) {
+	case FRONT:
+		classification = "FRONT";
+		break;
+	case BACK:
+		classification = "BACK";
+		break;
+	case COPLANAR:
+		classification = "COPLANAR";
+	}
+	return classification;
+}
+
 int poly_classify_poly(poly_t *this, poly_t *other) {
 	int front, back;
 	int count = poly_vertex_count(other);
@@ -180,6 +292,10 @@ int poly_split(poly_t *divider, poly_t *poly, poly_t **front, poly_t **back) {
 	int count = poly_vertex_count(poly);
 	for(i = 0; i < count; i++) {
 		j = (i + 1) % count;
+
+		// Fill v_cur[..] and v_next[..] with the values of
+		// the current (i) and next (j) vertex (x,y,z) data
+		// from `poly`
 		for(int k = 0; k < 3; k++) {
 			v_cur[k]  = poly->vertices[i][k];
 			v_next[k] = poly->vertices[j][k];
@@ -204,31 +320,38 @@ int poly_split(poly_t *divider, poly_t *poly, poly_t **front, poly_t **back) {
 			float t = divider->w;
 			t = t - f3_dot(divider->normal, v_cur);
 			t = t / f3_dot(divider->normal, diff);
+			t = clampf(t, 0.0, 1.0);
 
 			float3 mid_f = {v_cur[0], v_cur[1], v_cur[2]};
 			f3_interpolate(&mid_f, v_cur, v_next, t);
 
-			check(poly_push_vertex(*front, mid_f) == 0,
-				  "Failed to push midpoint to front poly(%p)", front);
-			check(poly_push_vertex(*back, mid_f) == 0,
-				  "Failed to push midpoint to back poly(%p):", back);
+			poly_push_vertex(*front, mid_f);
+			poly_push_vertex(*back, mid_f);
 		}
 	}
 
+	// Clear any polygons that are not finished by this point
+	if((*front != NULL) && (poly_vertex_count(*front) < 3)) {
+		free_poly(*front, true);
+		*front = NULL;
+	}
+
+	if((*back != NULL) && (poly_vertex_count(*back) < 3)) {
+		free_poly(*back, true);
+		*back = NULL;
+	}
+
 	return 0;
-error:
-	return -1;
 }
 
-poly_t *poly_make_triangle(float3 a, float3 b, float3 c) {
-	poly_t *p = NULL;
-	check_mem(p = alloc_poly());
+poly_t *poly_make_triangle_guarded(float3 a, float3 b, float3 c, bool guard) {
+	poly_t *p = alloc_poly();
 
-	check(poly_push_vertex(p, a) == 0,
+	check_debug(poly_push_vertex_guarded(p, a, guard),
 		  "Failed to add vertex a to poly(%p): (%f, %f, %f)", p, FLOAT3_FORMAT(a));
-	check(poly_push_vertex(p, b) == 0,
+	check_debug(poly_push_vertex_guarded(p, b, guard),
 		  "Failed to add vertex b to poly(%p): (%f, %f, %f)", p, FLOAT3_FORMAT(b));
-	check(poly_push_vertex(p, c) == 0,
+	check_debug(poly_push_vertex_guarded(p, c, guard),
 		  "Failed to add vertex c to poly(%p): (%f, %f, %f)", p, FLOAT3_FORMAT(c));
 
 	return p;
@@ -237,6 +360,14 @@ error:
 	return NULL;
 }
 
+poly_t *poly_make_triangle(float3 a, float3 b, float3 c) {
+	return poly_make_triangle_guarded(a, b, c, true);
+}
+
+poly_t *poly_make_triangle_unsafe(float3 a, float3 b, float3 c) {
+	return poly_make_triangle_guarded(a, b, c, false);
+}
+
 poly_t *poly_invert(poly_t *poly) {
 	f3_scale(&poly->normal, -1.0);
 	poly->w *= -1.0;
@@ -262,3 +393,45 @@ poly_t *poly_invert(poly_t *poly) {
 
 	return poly;
 }
+
+// Compute the length of the lognest edge squared
+float poly_max_edge_length2(poly_t *poly) {
+	const int count = poly_vertex_count(poly);
+	float longest = -INFINITY;
+
+	for(int i = 0; i < count; i++) {
+		int j = (i + 1) % count;
+		float d2 = f3_distance2(poly->vertices[i], poly->vertices[j]);
+
+		longest = (d2 > longest) ? d2 : longest;
+	}
+
+	return longest;
+}
+
+float poly_min_edge_length2(poly_t *poly) {
+	const int count = poly_vertex_count(poly);
+	float min = INFINITY;
+
+	for(int i = 0; i < count; i++) {
+		int j = (i + 1) % count;
+		float d2 = f3_distance2(poly->vertices[i], poly->vertices[j]);
+
+		min = (d2 < min) ? d2 : min;
+	}
+
+	return min;
+}
+
+float triangle_2area(float3 a, float3 b, float3 c) {
+	float3 b_a = FLOAT3_INIT;
+	float3 c_a = FLOAT3_INIT;
+
+	f3_sub(&b_a, b, a);
+	f3_sub(&c_a, c, a);
+
+	float3 cross = FLOAT3_INIT;
+	f3_cross(&cross, b_a, c_a);
+
+	return f3_magnitude(&cross);
+}