csg 0.1.3 → 0.1.4

data/src/poly.h

@@ -1,3 +1,4 @@
+#include <stdbool.h>
 #include <strings.h>
 #include "dbg.h"
 #include "klist.h"
@@ -28,26 +29,48 @@ typedef struct s_poly {
 } poly_t;
 
 poly_t *alloc_poly(void);
+poly_t *poly_make_triangle_guarded(float3 a, float3 b, float3 c, bool guard);
 poly_t *poly_make_triangle(float3 a, float3 b, float3 c);
+poly_t *poly_make_triangle_unsafe(float3 a, float3 b, float3 c);
 poly_t *clone_poly(poly_t *poly);
 void free_poly(poly_t *p, int free_self);
 
+void poly_print(poly_t *p, FILE *stream);
+void poly_print_with_plane_info(poly_t *p, poly_t *plane, FILE *stream);
+
 poly_t *poly_init(poly_t *poly);
 int poly_update(poly_t *poly);
 poly_t *poly_invert(poly_t *poly);
 
+float poly_triangle_2area(poly_t *triangle);
+float poly_triangle_area(poly_t *triangle);
+float poly_area(poly_t *poly);
+float poly_2area(poly_t *poly);
+bool poly_has_area(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);
+bool poly_push_vertex(poly_t *poly, float3 v);
+bool poly_push_vertex_unsafe(poly_t *poly, float3 v);
+bool poly_push_vertex_guarded(poly_t *poly, float3 v, bool guard);
 
 int poly_classify_vertex(poly_t *poly, float3 v);
+const char* poly_classify_vertex_string(poly_t *poly, float3 v);
 int poly_classify_poly(poly_t *this, poly_t *other);
 
 int poly_split(poly_t *divider, poly_t *poly, poly_t **front, poly_t **back);
 
+float poly_max_edge_length2(poly_t *poly);
+float poly_min_edge_length2(poly_t *poly);
+
+// Some polygon helpers that don't explicitly work on `poly_t`
+// but are close enough to be grouped here
+
+float triangle_2area(float3 a, float3 b, float3 c);
+
 #define mp_poly_free(x) free_poly(kl_val(x), 1)
 KLIST_INIT(poly, poly_t*, mp_poly_free)
 

data/src/stl.c

@@ -18,7 +18,7 @@ void stl_free(stl_object *obj) {
 
 stl_object *stl_alloc(char *header, uint32_t n_facets) {
 		stl_object *obj = (stl_object*)calloc(1, sizeof(stl_object));
-		check_mem(obj);
+		assert_mem(obj);
 
 		if(header != NULL) {
 				memcpy(obj->header, header, sizeof(obj->header));
@@ -27,12 +27,10 @@ stl_object *stl_alloc(char *header, uint32_t n_facets) {
 		obj->facet_count = n_facets;
 		if(n_facets > 0) {
 				obj->facets = (stl_facet*)calloc(n_facets, sizeof(stl_facet));
-				check_mem(obj->facets);
+				assert_mem(obj->facets);
 		}
 
 		return obj;
-error:
-		exit(-1);
 }
 
 void v3_cross(float3 *result, float3 v1, float3 v2, int normalize) {
@@ -42,10 +40,7 @@ void v3_cross(float3 *result, float3 v1, float3 v2, int normalize) {
 				v1[0]*v2[1] - v1[1]*v2[0]
 		};
 		if(normalize) {
-				float mag = sqrt(v1_x_v2[0]*v1_x_v2[0] + v1_x_v2[1]*v1_x_v2[1] + v1_x_v2[2]*v1_x_v2[2]);
-				v1_x_v2[0] /= mag;
-				v1_x_v2[1] /= mag;
-				v1_x_v2[2] /= mag;
+				f3_normalize(&v1_x_v2);
 		}
 		memcpy(result, &v1_x_v2, sizeof(float3));
 }
@@ -60,7 +55,7 @@ void stl_facet_update_normal(stl_facet *facet) {
 stl_facet *stl_read_facet(int fd) {
 		int rc = -1;
 		stl_facet *facet = (stl_facet*)calloc(1, sizeof(stl_facet));
-		check_mem(facet);
+		assert_mem(facet);
 
 		rc = read(fd, &facet->normal, sizeof(facet->normal));
 		check(rc == sizeof(facet->normal), "Failed to read normal. Read %d expected %zu", rc, sizeof(facet->normal));
@@ -79,7 +74,7 @@ stl_facet *stl_read_text_facet(const char *declaration, FILE *f) {
 		int rc = -1;
 		char *line = NULL;
 
-		check_mem(facet);
+		assert_mem(facet);
 		rc = sscanf(declaration, "facet normal %f %f %f", &facet->normal[0], &facet->normal[1], &facet->normal[2]);
 		check(rc == 3, "stl_Read_text_facet(%s): Normal line malformed", declaration);
 
@@ -149,7 +144,7 @@ stl_object *stl_read_text_object(int fd) {
 
 			obj->facet_count = facets->size;
 			obj->facets = calloc(facets->size, sizeof(stl_facet));
-			check_mem(obj->facets);
+			assert_mem(obj->facets);
 
 			stl_facet *facet = NULL;
 			for(int i = 0; kl_shift(stl_facet, facets, &facet) != -1; i++) {

data/src/stl_mesh.c

@@ -1,17 +1,16 @@
 #include "stl_mesh.h"
+#include "util.h"
 
 // Mesh type prototype methods
 int stl_mesh_init(void *self, void *data) {
 	stl_mesh_t *mesh = (stl_mesh_t*)self;
 	if(data == NULL) {
-		check_mem(mesh->stl = stl_alloc(NULL, 0));
+		assert_mem(mesh->stl = stl_alloc(NULL, 0));
 	}
 	else {
 		mesh->stl = (stl_object*)data;
 	}
 	return 0;
-error:
-	return -1;
 }
 
 void stl_mesh_destroy(void *self) {
@@ -25,24 +24,31 @@ int stl_mesh_poly_count(void *self) {
 	return mesh->stl->facet_count;
 }
 
-klist_t(poly)* stl_mesh_to_polygons(void *self) {
+klist_t(poly)* stl_mesh_to_polygons_guarded(void *self, bool guard) {
 	stl_mesh_t *mesh = (stl_mesh_t*)self;
 	int count = mesh->_(poly_count)(mesh);
 	klist_t(poly)* polys = kl_init(poly);
 
 	for(int i = 0; i < count; i++) {
-		poly_t *poly = poly_make_triangle(mesh->stl->facets[i].vertices[0],
-										  mesh->stl->facets[i].vertices[1],
-										  mesh->stl->facets[i].vertices[2]);
-		check_mem(poly);
-		*kl_pushp(poly, polys) = poly;
+		poly_t *poly = poly_make_triangle_guarded(mesh->stl->facets[i].vertices[0],
+												  mesh->stl->facets[i].vertices[1],
+												  mesh->stl->facets[i].vertices[2],
+												  guard);
+		if(poly != NULL) {
+			*kl_pushp(poly, polys) = poly;
+		}
 	}
 
 
 	return polys;
-error:
-	if(polys != NULL) kl_destroy(poly, polys);
-	return NULL;
+}
+
+klist_t(poly)* stl_mesh_to_polygons(void *self) {
+	return stl_mesh_to_polygons_guarded(self, true);
+}
+
+klist_t(poly)* stl_mesh_to_polygons_unsafe(void *self) {
+	return stl_mesh_to_polygons_guarded(self, false);
 }
 
 // Mesh type definitions

data/src/stl_mesh.h

@@ -12,4 +12,11 @@ typedef struct s_stl_mesh_t {
 	stl_object *stl;
 } stl_mesh_t;
 
+// Alternative implementations for `to_polygons` are available.
+// The default performs sanity checks on the constructed polygons,
+// the `_unsafe` variant ignores these checks and returns a polygon
+// list as-defined, but possibly mathematically useless.
+klist_t(poly)* stl_mesh_to_polygons(void *self);
+klist_t(poly)* stl_mesh_to_polygons_unsafe(void *self);
+
 #endif

data/src/util.c

@@ -1,14 +1,12 @@
-#include "ctype.h"
+#include <ctype.h>
 
 #include "util.h"
 
 char *str_dup(char *str) {
 	char *copy_str = NULL;
-	check_mem(copy_str = calloc(strlen(str) + 1, sizeof(char)));
+	assert_mem(copy_str = calloc(strlen(str) + 1, sizeof(char)));
 	strncpy(copy_str, str, strlen(str));
 	return copy_str;
-error:
-	return NULL;
 }
 
 char *str_ltrim(char *str, bool copy) {
@@ -34,12 +32,9 @@ char *str_ltrim(char *str, bool copy) {
 		return str;
 	}
 	else {
-		char *copy_str = NULL;
-		check_mem(copy_str = str_dup(str));
+		char *copy_str = str_dup(str);
 		return str_ltrim(copy_str, false);
 	}
-error:
-	return NULL;
 }
 
 char *str_rtrim(char *str, bool copy) {
@@ -51,25 +46,19 @@ char *str_rtrim(char *str, bool copy) {
 		return str;
 	}
 	else {
-		char *copy_str = NULL;
-		check_mem(copy_str = str_dup(str));
+		char *copy_str = str_dup(str);
 		return str_ltrim(copy_str, false);
 	}
-error:
-	return NULL;
 }
 
 char *str_trim(char *str, bool copy) {
 	char *trim_str = copy ? str_dup(str) : str;
-	check_mem(trim_str);
 
 	// Since we have already made a copy if we need one,
 	// we can just chain these two together, since non-copy
 	// operations can't throw out a NULL and the pointer itself
 	// cannot change.
 	return str_ltrim(str_rtrim(trim_str, false), false);
-error:
-	return NULL;
 }
 
 char *read_line(FILE *f, bool downcase, bool trim) {
@@ -89,7 +78,7 @@ char *read_line(FILE *f, bool downcase, bool trim) {
 	if((rc == NULL) && feof(f)) return NULL;
 
 	check_debug(rc != NULL, "Failed to read line from FILE(%p)", f);
-	check_mem(line = calloc(strlen(read_buffer) + 1, sizeof(char)));
+	assert_mem(line = calloc(strlen(read_buffer) + 1, sizeof(char)));
 	strncpy(line, read_buffer, strlen(read_buffer));
 
 	// See if we need to finish reading the line
@@ -104,7 +93,7 @@ char *read_line(FILE *f, bool downcase, bool trim) {
 			// Append the new data to the end of the line
 			char *new_line = NULL;
 			check(rc != NULL, "Error finishing line from FILE(%p)", f);
-			check_mem(new_line = calloc(strlen(line) + strlen(read_buffer) + 1, sizeof(char)));
+			assert_mem(new_line = calloc(strlen(line) + strlen(read_buffer) + 1, sizeof(char)));
 
 			strncpy(new_line, line, strlen(line));
 			strncpy(new_line + strlen(new_line), read_buffer, strlen(read_buffer));
@@ -130,8 +119,8 @@ char *read_line(FILE *f, bool downcase, bool trim) {
 	return line;
 error:
 	if(line != NULL) free(line);
-	if(feof(f)) debug("FILE(%p) EOF", f);
-	if(ferror(f)) debug("FILE(%p): ERROR. %s", f, clean_errno());
+	if(feof(f)) { debug("FILE(%p) EOF", f); }
+	if(ferror(f)) { debug("FILE(%p): ERROR. %s", f, clean_errno()); }
 	return NULL;
 }
 
@@ -147,3 +136,9 @@ char *next_line(FILE *f, bool downcase, bool trim) {
 
 	return line;
 }
+
+float clampf(float val, float min, float max) {
+	if(val > max) return max;
+	if(val < min) return min;
+	return val;
+}

data/src/util.h

@@ -1,12 +1,19 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <assert.h>
 
 #include "dbg.h"
 
 #ifndef __UTIL_H
 #define __UTIL_H
 
+// Fatal memory check
+#define assert_mem(A) if((A) == NULL) {			\
+		assert("Out of memory." && false);		\
+		abort();								\
+	}
+
 
 char *str_dup(char *str);
 
@@ -24,4 +31,6 @@ char *read_line(FILE *f, bool downcase, bool trim);
 // Gets the "next" non-blank line
 char *next_line(FILE *f, bool downcase, bool trim);
 
+float clampf(float val, float min, float max);
+
 #endif

data/src/vector.c

@@ -10,10 +10,15 @@ float3 *clone_f3(float3 f) {
 	return clone;
 }
 
+float f3_magnitude(float3 *v) {
+	return sqrt((*v)[0] * (*v)[0] +
+				(*v)[1] * (*v)[1] +
+				(*v)[2] * (*v)[2]);
+}
+
 float3 *f3_normalize(float3 *v) {
-	float mag = sqrt((*v)[0] * (*v)[0] +
-					 (*v)[1] * (*v)[1] +
-					 (*v)[2] * (*v)[2]);
+	float mag = f3_magnitude(v);
+
 	(*v)[0] /= mag;
 	(*v)[1] /= mag;
 	(*v)[2] /= mag;
@@ -53,3 +58,13 @@ float3 *f3_interpolate(float3 *result, float3 start, float3 v, float alpha) {
 	}
 	return result;
 }
+
+float f3_distance(float3 a, float3 b) {
+	return sqrt(f3_distance2(a, b));
+}
+
+float f3_distance2(float3 a, float3 b) {
+	float3 diff = FLOAT3_INIT;
+	f3_sub(&diff, a, b);
+	return f3_dot(diff, diff);
+}

data/src/vector.h

@@ -19,6 +19,7 @@ typedef float float3[3];
 float3 *clone_f3(float3 f);
 
 // Vector Updating operations
+float f3_magnitude(float3 *v);
 float3 *f3_normalize(float3 *v);
 float3 *f3_scale(float3 *f, float c);
 
@@ -27,6 +28,8 @@ float3 *f3_cross(float3 *result, float3 v1, float3 v2);
 float f3_dot(float3 v1, float3 v2);
 float3 *f3_sub(float3 *result, float3 v1, float3 v2);
 float3 *f3_interpolate(float3 *result, float3 start, float3 v, float alpha);
+float f3_distance(float3 a, float3 b);
+float f3_distance2(float3 a, float3 b);
 
 // Containers
 #define mp_float3_free(x) free(kl_val(x))

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: csg
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Yaroslav Shirokov
@@ -9,20 +9,20 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-01 00:00:00.000000000 Z
+date: 2014-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: A fast library for Constructive Solid Geometry
@@ -35,32 +35,34 @@ extensions:
 extra_rdoc_files: []
 files:
 - Makefile
+- ext/Rakefile
 - lib/csg.rb
 - src/bsp.c
-- src/commands.c
-- src/dbg.c
-- src/export.c
-- src/mesh.c
-- src/poly.c
-- src/reader.c
-- src/stl.c
-- src/stl_mesh.c
-- src/util.c
-- src/vector.c
 - src/bsp.h
 - src/bsp_mesh.h
+- src/cmd_audit.c
+- src/cmd_audit.h
+- src/commands.c
 - src/commands.h
+- src/dbg.c
 - src/dbg.h
+- src/export.c
 - src/export.h
 - src/klist.h
+- src/mesh.c
 - src/mesh.h
+- src/poly.c
 - src/poly.h
+- src/reader.c
 - src/reader.h
+- src/stl.c
 - src/stl.h
+- src/stl_mesh.c
 - src/stl_mesh.h
+- src/util.c
 - src/util.h
+- src/vector.c
 - src/vector.h
-- ext/Rakefile
 homepage: https://github.com/sshirokov/csgtool/
 licenses:
 - MIT
@@ -71,17 +73,17 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A fast library for Constructive Solid Geometry