Merge branch 'master' into refactor

Conflicts:
	src/half_edge.c

src/half_edge.c

@@ -28,7 +28,6 @@
 #include "err.h"
 #include "filereader.h"
 #include "half_edge.h"
-#include "print.c"
 #include "vector.h"
 
 #include <stdbool.h>
@@ -299,6 +298,7 @@ static void fill_vertices(VERTICES obj_v, HE_vert *vertices, int32_t *vc)
 		vertices[*vc].edge = NULL;
 		vertices[*vc].edge_array = NULL;
 		vertices[*vc].eac = 0;
+		vertices[*vc].dc = 0;
 
 		/* allocate color struct and set preliminary colors */
 		vertices[*vc].col = malloc(sizeof(color));
@@ -366,8 +366,10 @@ bool vec_normal(HE_vert const * const vert, vector *vec)
 	for (uint32_t i = 0; i < ec; i++) {
 		vector new_vec;
 
-		FACE_NORMAL(edge_array[i], &new_vec);
-		ADD_VECTORS(vec, &new_vec, vec);
+		if (edge_array[i]->face) {
+			FACE_NORMAL(edge_array[i], &new_vec);
+			ADD_VECTORS(vec, &new_vec, vec);
+		}
 	}
 
 	/* normalize the result */
@@ -484,9 +486,9 @@ HE_obj *parse_obj(char const * const obj_string)
 {
 	int32_t vc = 0, /* vertices count */
 			 fc = 0, /* face count */
-			 ec = 0; /* edge count */
+			 ec = 0, /* edge count */
+			 dec = 0; /* dummy edge count */
 	char *string = NULL;
-
 	HE_vert *vertices = NULL;
 	HE_edge *edges = NULL;
 	HE_face *faces = NULL;
@@ -539,6 +541,7 @@ HE_obj *parse_obj(char const * const obj_string)
 			edges[ec].face = &(faces[i]);
 			edges[ec].pair = NULL; /* preliminary */
 			vertices[fv_arr_id].edge = &(edges[ec]); /* last one wins */
+			vertices[fv_arr_id].dummys = NULL; /* preliminary */
 
 			/* Skip j == 0 here, so we don't underrun the arrays,
 			 * since we always look one edge back. The first edge
@@ -589,34 +592,52 @@ HE_obj *parse_obj(char const * const obj_string)
 				edges[i].pair = edges[i].vert->edge_array[j];
 				edges[i].vert->edge_array[j] = NULL;
 
-				/* this is a trick to make sure the
-				 * edge member of HE_vert is never
-				 * a border-edge (unless there are only
-				 * border edges), otherwise
-				 * get_all_emanating_edges() would break
-				 * for vertices that are at the edge
-				 * of an open object */
-				edges[i].vert->edge = &(edges[i]);
-
 				pair_found = true;
 				break;
 			}
 		}
 
-		if (!pair_found) { /* we have a border edge */
-			/* add dummy edge, so get_all_emanating_edges()
-			 * does not break */
-			edges[ec + i].face = NULL;
-			edges[ec + i].next = NULL;
-			edges[ec + i].pair = &(edges[i]);
-			edges[ec + i].vert = edges[i].next->vert;
-			edges[i].pair = &(edges[ec + i]);
+		/* create dummy pair edge if we have a border edge */
+		if (!pair_found) {
+			uint32_t *vert_dc = &(edges[i].next->vert->dc);
+
+			REALLOC(edges[i].next->vert->dummys,
+					sizeof(HE_edge*) * (*vert_dc + 1));
+
+			/* NULL-face indicates border-edge */
+			edges[ec + dec].face = NULL;
+			/* we don't know this one yet */
+			edges[ec + dec].next = NULL;
+			/* set both pairs */
+			edges[ec + dec].pair = &(edges[i]);
+			edges[i].pair = &(edges[ec + dec]);
+			/* set vertex */
+			edges[ec + dec].vert = edges[i].next->vert;
+			/* add the dummy edge to the dummys array of the vertex */
+			edges[ec + dec].vert->dummys[*vert_dc] = &(edges[ec + dec]);
+			(*vert_dc)++;
+
+			dec++;
 		}
 	}
 
-	/* set up obj help struct */
+	/* now we have to connect the dummy edges together */
+	for (uint32_t i = 0; i < (uint32_t) dec; i++) { /* for all dummy edges */
+		/* vertex the dummy edge points to */
+		HE_vert *vert = edges[ec + i].pair->vert;
+
+		/* iterate over the dummy array */
+		for (uint32_t j = 0; j < vert->dc; j++) {
+			if (vert == vert->dummys[j]->vert)
+				edges[ec + i].next = vert->dummys[j];
+			j++;
+		}
+	}
+
+
 	obj = (HE_obj*) malloc(sizeof(HE_obj));
 	CHECK_PTR_VAL(obj);
+
 	obj->edges = edges;
 	obj->vertices = vertices;
 	obj->faces = faces;
@@ -629,6 +650,7 @@ HE_obj *parse_obj(char const * const obj_string)
 		free(obj_f[i]);
 	free(obj_f);
 	for (uint32_t i = 0; i < (uint32_t)vc; i++) {
+		free(vertices[i].dummys);
 		free(vertices[i].edge_array);
 		free(obj_v[i]);
 	}

src/half_edge.h

@@ -147,11 +147,23 @@ struct HE_vert {
 	 */
 	HE_edge **edge_array;
 
+	/**
+	 * Similar as the edge_array acceleration structure,
+	 * except that it is used for connecting the
+	 * dummy edges.
+	 */
+	HE_edge **dummys;
+
 	/**
 	 * Element count of the edge_array.
 	 */
 	uint32_t eac;
 
+	/**
+	 * Element count of dummys.
+	 */
+	uint32_t dc;
+
 	/**
 	 * Color of the vertex.
 	 */

src/test/cunit_half_edge.c

@@ -469,14 +469,19 @@ void test_parse_obj5(void)
 		while(next_edge != start_edge) {
 			CU_ASSERT_PTR_NOT_NULL(next_edge);
 			CU_ASSERT_PTR_NOT_NULL(next_edge->pair->pair);
-			/* check if edges have all the same face */
-			CU_ASSERT_EQUAL(next_edge->face, &(obj->faces[i]));
+
 			/* check if pairs are consistently set */
 			CU_ASSERT_EQUAL(next_edge->pair->pair, next_edge);
 			CU_ASSERT_NOT_EQUAL(next_edge->pair, next_edge);
+
 			/* check if vertices are consistent with edges */
 			CU_ASSERT_PTR_NOT_NULL(next_edge->vert->edge);
 			CU_ASSERT_EQUAL(next_edge->vert->edge->vert, next_edge->vert);
+			CU_ASSERT_EQUAL(next_edge->vert, next_edge->pair->next->vert);
+
+			/* check if edges have all the same face */
+			CU_ASSERT_EQUAL(next_edge->face, &(obj->faces[i]));
+
 			next_edge = next_edge->next;
 		}
 	}
@@ -516,12 +521,13 @@ void test_parse_obj6(void)
 			/* check if pairs are consistently set */
 			CU_ASSERT_EQUAL(edge->pair->pair, edge);
 			CU_ASSERT_NOT_EQUAL(edge->pair, edge);
+
 			/* check if neighbor vertex is consistently connected
 			 * to half-edge */
 			CU_ASSERT_NOT_EQUAL(edge->pair->vert, edge->vert);
 			CU_ASSERT_PTR_NOT_NULL(edge->pair->vert->edge);
-			CU_ASSERT_EQUAL(edge->pair->next->vert, edge->vert);
 			CU_ASSERT_EQUAL(edge->vert->edge->vert, edge->vert);
+			CU_ASSERT_EQUAL(edge->pair->next->vert, edge->vert);
 
 			edge = edge->pair->next;