csg 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0156d8c17eb3aa465dccdec30ce073b111c15f31
+  data.tar.gz: ffc2a35116bdd1cdd181943ae3e40ef51fcf5e88
+SHA512:
+  metadata.gz: 9dce1d39a95353b489193bcfa6427127e87b99e2de342e0d571e65678a6c0785dc9b86a53b0f4a5f4e8058a3c8d0050979e7b54002c04275d051cd845073dfe2
+  data.tar.gz: c4f6ec8bf5905402348f7daec9d3db3994aeb237bf9eb49d5057eaa5bd7ab7ce7c9ecda037c5e2274e6aa448c9d0a9fd9877822fafc2daee535543e8cd2667ff

data/Makefile

@@ -26,7 +26,7 @@ clean:
 test:
 	@make -C tests clean test
 
-.PHONY: all clean test libcsg
+.PHONY: all clean test libcsg loc
 
 $(TARGET): $(TARGET).o $(OBJS)
 	$(CC) $(CFLAGS) $^ $(LIBS) -o $@.new
@@ -39,3 +39,9 @@ libcsg: $(LIB_TARGET)
 
 %.o: %.c
 	$(CC) -fPIC $(CFLAGS) -o $@ -c $^
+
+loc:
+	@echo "=> Source:"
+	find src/ -name '*.[ch]' -not -name 'dbg.*' | xargs wc -l csgtool.c
+	@echo "=> Tests:"
+	find tests/ -name '*.[ch]' -not -path '*clar*' | xargs wc -l

data/src/bsp.c

@@ -69,7 +69,9 @@ int bsp_subdivide(poly_t *divider, poly_t *poly,
 				  poly_t **coplanar_front, int *n_cp_front,
 				  poly_t **coplanar_back,  int *n_cp_back,
 				  poly_t **front,          int *n_front,
-				  poly_t **back,           int *n_back) {
+				  poly_t **back,           int *n_back,
+				  poly_t **unused,         int *n_unused,
+				  poly_t **created,        int *n_created) {
 	switch(poly_classify_poly(divider, poly)) {
 	case FRONT:
 		front[*n_front] = poly;
@@ -99,6 +101,21 @@ int bsp_subdivide(poly_t *divider, poly_t *poly,
 
 		back[*n_back] = b;
 		*n_back += 1;
+
+		// Do we care about telling the caller about polygons
+		// who's pointers are not in any of the "real" lists?
+		if(unused != NULL) {
+			unused[*n_unused] = poly;
+			*n_unused += 1;
+		}
+
+		// How about polygons that we just made?
+		if(created != NULL) {
+			created[*n_created] = f;
+			*n_created += 1;
+			created[*n_created] = b;
+			*n_created += 1;
+		}
 		break;
 	}
 	}
@@ -122,7 +139,7 @@ bsp_node_t *bsp_build(bsp_node_t *node, klist_t(poly) *polygons, int copy) {
 		polys[i] = poly;
 	}
 
-	check((node = bsp_build_array(node, polys, polygons->size)),
+	check((node = bsp_build_array(node, polys, polygons->size, copy)),
 		  "Failed to build node from list(%p) of %zd polys", polygons, polygons->size);
 	free(polys);
 
@@ -131,7 +148,8 @@ error:
 	if(polys) free(polys);
 	return NULL;
 }
-bsp_node_t *bsp_build_array(bsp_node_t *node, poly_t **polygons, size_t n_polys) {
+
+bsp_node_t *bsp_build_array(bsp_node_t *node, poly_t **polygons, size_t n_polys, int free_unused) {
 	int rc = 0;
 
 	// Polygon lists and counters
@@ -142,6 +160,14 @@ bsp_node_t *bsp_build_array(bsp_node_t *node, poly_t **polygons, size_t n_polys)
 	poly_t **front_p  = NULL;
 	poly_t **back_p   = NULL;
 
+	// List and counter of unused polygons
+	// These will get freed after the build
+	// because they will not appear with identity
+	// in coplanar, front_p, or back_p if free_unused
+	// is true
+	int n_unused = 0;
+	poly_t **unused = NULL;
+
 	// Iterators
 	poly_t *poly = NULL;
 	size_t poly_i = 0;
@@ -172,20 +198,34 @@ bsp_node_t *bsp_build_array(bsp_node_t *node, poly_t **polygons, size_t n_polys)
 	check_mem(coplanar = malloc(sizeof(poly_t*) * n_polys));
 	check_mem(front_p = malloc(sizeof(poly_t*) * n_polys));
 	check_mem(back_p = malloc(sizeof(poly_t*) * n_polys));
+	check_mem(unused = malloc(sizeof(poly_t*) * n_polys));
 	for(; poly_i < n_polys; poly_i++) {
 		poly = polygons[poly_i];
 		rc = bsp_subdivide(node->divider, poly,
 						   coplanar, &n_coplanar,
 						   coplanar, &n_coplanar,
 						   front_p, &n_front,
-						   back_p, &n_back);
+						   back_p, &n_back,
+						   unused, &n_unused,
+						   NULL, NULL);
 		check(rc == 0, "Failed to subdivide: %p => %p", node->divider, poly);
 	}
 
+	// Destroy the unused polygons now, if we're asked,
+	// otherwise we'll lose the references
+	int i = 0;
+	if(free_unused != 0) {
+		for(i = 0; i < n_unused; i++) {
+			free_poly(unused[i], 1);
+		}
+	}
+	// Free now and mark NULL to make sure it's not double free'd on `error:`
+	free(unused);
+	unused = NULL;
+
 	// Store the coplanar nodes in this node's polygon list
 	// and free the container, letting the list destructor
 	// clean up
-	int i = 0;
 	for(i = 0; i < n_coplanar; i++) {
 		*kl_pushp(poly, node->polygons) = coplanar[i];
 	}
@@ -195,13 +235,13 @@ bsp_node_t *bsp_build_array(bsp_node_t *node, poly_t **polygons, size_t n_polys)
 	if((n_front > 0)) {
 		if(node->front == NULL) node->front = alloc_bsp_node();
 		check_mem(node->front);
-		check(bsp_build_array(node->front, front_p, n_front) != NULL,
+		check(bsp_build_array(node->front, front_p, n_front, free_unused) != NULL,
 			  "Failed to build front tree of bsp_node_array(%p)", node);
 	}
 	if((n_back > 0)) {
 		if(node->back == NULL) node->back = alloc_bsp_node();
 		check_mem(node->back);
-		check(bsp_build_array(node->back, back_p, n_back) != NULL,
+		check(bsp_build_array(node->back, back_p, n_back, free_unused) != NULL,
 			  "Failed to build back tree of bsp_node(%p)", node);
 	}
 	free(front_p);
@@ -213,6 +253,7 @@ error:
 	if(coplanar) free(coplanar);
 	if(back_p) free(back_p);
 	if(front_p) free(front_p);
+	if(unused) free(unused);
 	return NULL;
 }
 
@@ -316,24 +357,28 @@ klist_t(poly) *bsp_clip_polygon_array(bsp_node_t *node, poly_t **polygons, size_
 	poly_t **poly_buffer = static_poly_buffer;
 	poly_t **front_array = NULL;
 	poly_t **back_array = NULL;
+	poly_t **created_array = NULL;
 	int n_front = 0;
 	int n_back = 0;
+	int n_created = 0;
 
 	// Let's end this quick if there's nothing to do.
 	if(n_polys == 0) return result;
 
 	if(node->divider != NULL) {
-		if((n_polys * 2) > STATIC_POLY_BUFFER_SIZE) {
-			check_mem(poly_buffer = malloc((sizeof(poly_t*) * n_polys) * 2));
+		if((n_polys * 3) > STATIC_POLY_BUFFER_SIZE) {
+			check_mem(poly_buffer = malloc((sizeof(poly_t*) * n_polys) * 3));
 		}
 		front_array = poly_buffer;
 		back_array = poly_buffer + n_polys;
+		created_array = poly_buffer + (n_polys * 2);
 		// Sort this node's polygons into the front or back
 		for(i = 0; i < n_polys; i++) {
 			p = polygons[i];
 			rc = bsp_subdivide(node->divider, p,
 							   front_array, &n_front, back_array, &n_back,
-							   front_array, &n_front, back_array, &n_back);
+							   front_array, &n_front, back_array, &n_back,
+							   NULL, NULL, created_array, &n_created);
 			check(rc != -1, "Failed to subdivide poly %p", p);
 		}
 
@@ -358,8 +403,15 @@ klist_t(poly) *bsp_clip_polygon_array(bsp_node_t *node, poly_t **polygons, size_
 			check(result != NULL, "Failed to clip back tree");
 		}
 
-		if(poly_buffer != static_poly_buffer) free(poly_buffer);
+		// Free all the polygons in 'created_array` since they would have
+		// been cloned if they were important, and the input set is not our
+		// responsibility
+		for(int j = 0; j < n_created; j++) {
+			free_poly(created_array[j], 1);
+		}
+
 		// Clean up the result halves, now that they're copied into `result`
+		if(poly_buffer != static_poly_buffer) free(poly_buffer);
 	}
 	else {
 		// If we don't have a divider we just copy out the polygons
@@ -386,23 +438,27 @@ klist_t(poly) *bsp_clip_polygons(bsp_node_t *node, klist_t(poly) *polygons, klis
 	poly_t **poly_buffer = static_poly_buffer;
 	poly_t **front_array = NULL;
 	poly_t **back_array = NULL;
+	poly_t **created_array = NULL;
 	int n_front = 0;
 	int n_back = 0;
+	int n_created = 0;
 
 	// Let's end this quick if there's nothing to do.
 	if(polygons->size == 0) return result;
 
 	if(node->divider != NULL) {
-		if((polygons->size * 2) > STATIC_POLY_BUFFER_SIZE) {
-			check_mem(poly_buffer = malloc(sizeof(poly_t*) * polygons->size * 2));
+		if((polygons->size * 3) > STATIC_POLY_BUFFER_SIZE) {
+			check_mem(poly_buffer = malloc(sizeof(poly_t*) * polygons->size * 3));
 		}
 		front_array = poly_buffer;
 		back_array = poly_buffer + polygons->size;
+		created_array = poly_buffer + (polygons->size * 2);
 		// Sort this node's polygons into the front or back
 		for(iter = kl_begin(polygons); iter != kl_end(polygons); iter = kl_next(iter)) {
 			rc = bsp_subdivide(node->divider, kl_val(iter),
 							   front_array, &n_front, back_array, &n_back,
-							   front_array, &n_front, back_array, &n_back);
+							   front_array, &n_front, back_array, &n_back,
+							   NULL, NULL, created_array, &n_created);
 			check(rc != -1, "Failed to subdivide poly %p", kl_val(iter));
 		}
 
@@ -427,8 +483,15 @@ klist_t(poly) *bsp_clip_polygons(bsp_node_t *node, klist_t(poly) *polygons, klis
 			check(result != NULL, "Failed to clip back tree");
 		}
 
+		// Free all the polygons in 'created_array` since they would have
+		// been cloned if they were important, and the input set is not our
+		// responsibility
+		for(int j = 0; j < n_created; j++) {
+			free_poly(created_array[j], 1);
+		}
+
+
 		if(poly_buffer != static_poly_buffer) free(poly_buffer);
-		// Clean up the result halves, now that they're copied into `result`
 	}
 	else {
 		// If we don't have a divider we just copy out the polygons

data/src/bsp.h

@@ -33,10 +33,12 @@ int bsp_subdivide(poly_t *divider, poly_t *poly,
 				  poly_t **coplanar_front, int *n_cp_front,
 				  poly_t **coplanar_back,  int *n_cp_back,
 				  poly_t **front,          int *n_front,
-				  poly_t **back,           int *n_back);
+				  poly_t **back,           int *n_back,
+				  poly_t **unused,         int *n_unused,
+				  poly_t **created,        int *n_created);
 
 bsp_node_t *bsp_build(bsp_node_t *node, klist_t(poly) *polygons, int copy);
-bsp_node_t *bsp_build_array(bsp_node_t *node, poly_t **polygons, size_t n_polys);
+bsp_node_t *bsp_build_array(bsp_node_t *node, poly_t **polygons, size_t n_polys, int free_unused);
 klist_t(poly) *bsp_to_polygons(bsp_node_t *tree,  int make_triangles, klist_t(poly) *dst);
 
 bsp_node_t *bsp_invert(bsp_node_t *tree);

data/src/commands.c

@@ -0,0 +1,105 @@
+#include <string.h>
+#include "dbg.h"
+
+#include "commands.h"
+#include "stl.h"
+#include "bsp.h"
+#include "export.h"
+
+typedef bsp_node_t* (*bsp_binary_op)(bsp_node_t *, bsp_node_t *);
+
+// A generalization of a binary CSG operation being performed on an STL
+// in `path1` and `path1` defined by an operation `op` from` bsp.h
+// Result is freshly allocated, and needs to be freed with `free_bsp_tree()`
+bsp_node_t* bsp_binary_operation(char *path1, char *path2, bsp_binary_op op) {
+	stl_object *file1 = NULL;
+	bsp_node_t *bsp1 = NULL;
+
+	stl_object *file2 = NULL;
+	bsp_node_t *bsp2 = NULL;
+
+	bsp_node_t *result = NULL;
+
+	// Read 1
+	file1 = stl_read_file(path1, 1);
+	check(file1 != NULL, "Failed to read .stl from '%s'", path1);
+	log_info("Loaded file: %s %d facets", path1, file1->facet_count);
+	bsp1 = stl_to_bsp(file1);
+	check_mem(bsp1);
+
+	// Read 2
+	file2 = stl_read_file(path2, 1);
+	check(file2 != NULL, "Failed to read .stl from '%s'", path2);
+	log_info("Loaded file: %s %d facets", path2, file2->facet_count);
+	bsp2 = stl_to_bsp(file2);
+	check_mem(bsp2);
+
+	// Operate
+	result = op(bsp1, bsp2);
+
+	if(file1 != NULL) stl_free(file1);
+	if(file2 != NULL) stl_free(file2);
+	if(bsp1 != NULL) free_bsp_tree(bsp1);
+	if(bsp2 != NULL) free_bsp_tree(bsp2);
+	return result;
+error:
+	if(file1 != NULL) stl_free(file1);
+	if(file2 != NULL) stl_free(file2);
+	if(bsp1 != NULL) free_bsp_tree(bsp1);
+	if(bsp2 != NULL) free_bsp_tree(bsp2);
+	if(result != NULL) free_bsp_tree(result);
+	return NULL;
+}
+
+// Constructor for commands named after the CSG functions they perform.
+// Produces a function named `cmd_<name>(int argc, char **argv) that reads
+// two files and an optional output path and calls a matching function
+// bsp_<name>(bsp_node_t*,bsp_node_t*) and writes the resulting mesh
+// to disk as either `./out.stl` or the value of argv[2]
+// Uses the above `bsp_binary_operation(..)` wrapper to do most of the
+// heavy lifting.
+#define MAKE_CSG_COMMAND(name)                                                        \
+int cmd_##name(int argc, char **argv) {                                               \
+	bsp_node_t *result = NULL;                                                        \
+	stl_object *out = NULL;                                                           \
+	char *out_path = "./out.stl";                                                     \
+                                                                                      \
+	check(argc >= 2, "At least two input files required.");                           \
+	if(argc > 2) out_path = argv[2];                                                  \
+                                                                                      \
+	result = bsp_binary_operation(argv[0], argv[1], bsp_##name);                   \
+	out = bsp_to_stl(result);                                                         \
+    log_info("Writing output to %s", out_path);                                       \
+	check(stl_write_file(out, out_path) == 0, "Failed to write STL to %s", out_path); \
+                                                                                      \
+	if(result != NULL) free_bsp_tree(result);                                         \
+	if(out != NULL) stl_free(out);                                                    \
+	return 0;                                                                         \
+error:                                                                                \
+	if(result != NULL) free_bsp_tree(result);                                         \
+	if(out != NULL) stl_free(out);                                                    \
+	return -1;                                                                        \
+}
+
+// Each MAKE_BSP_COMMAND(name) results in a function named
+// cmd_<name>(int argc, argv) which calls bsp_<name>() with
+// two trees built from files in argv[0] and argv[1]
+MAKE_CSG_COMMAND(intersect);
+MAKE_CSG_COMMAND(union);
+MAKE_CSG_COMMAND(subtract);
+
+// Available commands
+const cmd_t commands[] = {
+	{"intersect", "Intersect two geometries", cmd_intersect},
+	{"subtract",  "Subtract two geometries",  cmd_subtract},
+	{"union",     "Union two geometries",     cmd_union},
+	{NULL, NULL, NULL}
+};
+
+// Search for a command by name.
+cmd_fun_t cmd_find(const char *name) {
+	for(cmd_t *c = (cmd_t*)commands; c->name != NULL; c++) {
+		if(0 == strcmp(c->name, name)) return c->fun;
+	}
+	return NULL;
+}

data/src/commands.h

@@ -0,0 +1,17 @@
+#include <stdio.h>
+
+#ifndef __COMMANDS_H
+#define __COMMANDS_H
+
+typedef int (*cmd_fun_t)(int argc, char **argv);
+
+typedef struct s_cmd_t {
+	char *name;
+	char *description;
+	cmd_fun_t fun;
+} cmd_t;
+
+extern const cmd_t commands[];
+cmd_fun_t cmd_find(const char *name);
+
+#endif

data/src/poly.c

@@ -13,11 +13,17 @@ error:
 
 void free_poly(poly_t *p, int free_self) {
 	if(p == NULL) return;
+	if(poly_vertex_dynamic_p(p) == 1) {
+		if(p->vertices != NULL) free(p->vertices);
+		p->vertices = NULL;
+	}
 	if(free_self) free(p);
 }
 
 poly_t *poly_init(poly_t *poly) {
 	poly->vertex_count = 0;
+	poly->vertex_max = POLY_MAX_VERTS;
+	poly->vertices = poly->_vbuffer;
 	return poly;
 }
 
@@ -25,8 +31,23 @@ poly_t *clone_poly(poly_t *poly) {
 	poly_t *copy = NULL;
 	check_mem(copy = alloc_poly());
 	memcpy(copy, poly, sizeof(poly_t));
+
+	// Either point the clone at its own copied
+	// buffer, or copy over the dynamic vertex buffer
+	if(poly_vertex_dynamic_p(poly) == 0) {
+		copy->vertices = copy->_vbuffer;
+	}
+	else {
+		// 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);
+		memcpy(copy->vertices, poly->vertices, poly_vertex_max(copy) * sizeof(float3));
+	}
+
 	return copy;
 error:
+	if(copy != NULL) free_poly(copy, 1);
 	return NULL;
 }
 
@@ -53,10 +74,47 @@ int poly_vertex_count(poly_t *poly) {
 	return poly->vertex_count;
 }
 
-// Add a vertex to the end of the polygon vertex list
+int poly_vertex_max(poly_t *poly) {
+	return poly->vertex_max;
+}
+
+int poly_vertex_available(poly_t *poly) {
+	return poly->vertex_max - poly->vertex_count;
+}
+
+// Has the vertex buffer been dynamically allocated?
+int poly_vertex_dynamic_p(poly_t *poly) {
+	return (poly->vertices != poly->_vbuffer) ? 1 : 0;
+}
+
+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);
+
+	memcpy(new_verts, poly->vertices, poly->vertex_max * sizeof(float3));
+	poly->vertex_max = new_size;
+
+	// Free the existing buffer if it's not part of the struct's space
+	if(poly_vertex_dynamic_p(poly) == 1) {
+		free(poly->vertices);
+	}
+
+	// Install the new vertex buffer
+	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) {
-	// TODO: Don't assert, grow
-	assert(poly->vertex_count < POLY_MAX_VERTS);
+	if(poly_vertex_available(poly) == 0) {
+		poly_vertex_expand(poly);
+	}
 
 	// Dat assignment copy
 	poly->vertices[poly->vertex_count][0] = v[0];

data/src/poly.h

@@ -12,14 +12,19 @@
 #define BACK 2
 #define SPANNING 3
 
+#ifndef POLY_MAX_VERTS
 #define POLY_MAX_VERTS 40
+#endif
 
 typedef struct s_poly {
-	float3 vertices[POLY_MAX_VERTS];
+	float3 *vertices;
 	int vertex_count;
+	int vertex_max;
 
 	float3 normal;
 	float w;
+
+	float3 _vbuffer[POLY_MAX_VERTS];
 } poly_t;
 
 poly_t *alloc_poly(void);
@@ -32,6 +37,10 @@ int poly_update(poly_t *poly);
 poly_t *poly_invert(poly_t *poly);
 
 int poly_vertex_count(poly_t *poly);
+int poly_vertex_max(poly_t *poly);
+int poly_vertex_available(poly_t *poly);
+int poly_vertex_dynamic_p(poly_t *poly);
+int poly_vertex_expand(poly_t *poly);
 int poly_push_vertex(poly_t *poly, float3 v);
 
 int poly_classify_vertex(poly_t *poly, float3 v);

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: csg
 version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+  version: 0.0.3
 platform: ruby
 authors:
 - Yaroslav Shirokov
@@ -10,22 +9,20 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-11 00:00:00.000000000 Z
+date: 2013-09-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
 description: A fast library for Constructive Solid Geometry
@@ -40,12 +37,14 @@ files:
 - Makefile
 - lib/csg.rb
 - src/bsp.c
+- src/commands.c
 - src/dbg.c
 - src/export.c
 - src/poly.c
 - src/stl.c
 - src/vector.c
 - src/bsp.h
+- src/commands.h
 - src/dbg.h
 - src/export.h
 - src/klist.h
@@ -55,26 +54,25 @@ files:
 - ext/Rakefile
 homepage: https://github.com/sshirokov/csgtool/
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A fast library for Constructive Solid Geometry
 test_files: []