style cleanup: changes to brace placement / newlines - for/while/if/switch

1 files changed, 133 insertions, 266 deletions

diff --git a/source/blender/blenlib/intern/graph.c b/source/blender/blenlib/intern/graph.c
index 75131f81ade..432a74a5890 100644
--- a/source/blender/blenlib/intern/graph.c
+++ b/source/blender/blenlib/intern/graph.c
@@ -46,13 +46,11 @@ static void flagAxialSymmetry(BNode *root_node, BNode *end_node, BArc *arc, int
 
 void BLI_freeNode(BGraph *graph, BNode *node)
 {
-	if (node->arcs)
-	{
+	if (node->arcs) {
 		MEM_freeN(node->arcs);
 	}
 	
-	if (graph->free_node)
-	{
+	if (graph->free_node) {
 		graph->free_node(node);
 	}
 }
@@ -70,8 +68,7 @@ BNode *BLI_otherNode(BArc *arc, BNode *node)
 
 void BLI_removeArc(BGraph *graph, BArc *arc)
 {
-	if (graph->free_arc)
-	{
+	if (graph->free_arc) {
 		graph->free_arc(arc);
 	}
 
@@ -82,8 +79,7 @@ void BLI_flagNodes(BGraph *graph, int flag)
 {
 	BNode *node;
 	
-	for (node = graph->nodes.first; node; node = node->next)
-	{
+	for (node = graph->nodes.first; node; node = node->next) {
 		node->flag = flag;
 	}
 }
@@ -92,8 +88,7 @@ void BLI_flagArcs(BGraph *graph, int flag)
 {
 	BArc *arc;
 	
-	for (arc = graph->arcs.first; arc; arc = arc->next)
-	{
+	for (arc = graph->arcs.first; arc; arc = arc->next) {
 		arc->flag = flag;
 	}
 }
@@ -109,10 +104,8 @@ void BLI_buildAdjacencyList(BGraph *graph)
 	BNode *node;
 	BArc *arc;
 
-	for (node = graph->nodes.first; node; node = node->next)
-	{
-		if (node->arcs != NULL)
-		{
+	for (node = graph->nodes.first; node; node = node->next) {
+		if (node->arcs != NULL) {
 			MEM_freeN(node->arcs);
 		}
 		
@@ -122,16 +115,13 @@ void BLI_buildAdjacencyList(BGraph *graph)
 		node->flag = 0;
 	}
 
-	for (arc = graph->arcs.first; arc; arc= arc->next)
-	{
+	for (arc = graph->arcs.first; arc; arc= arc->next) {
 		addArcToNodeAdjacencyList(arc->head, arc);
 		addArcToNodeAdjacencyList(arc->tail, arc);
 	}
 
-	for (node = graph->nodes.first; node; node = node->next)
-	{
-		if (node->degree != node->flag)
-		{
+	for (node = graph->nodes.first; node; node = node->next) {
+		if (node->degree != node->flag) {
 			printf("error in node [%p]. Added only %i arcs out of %i\n", (void *)node, node->flag, node->degree);
 		}
 	}
@@ -141,8 +131,7 @@ void BLI_rebuildAdjacencyListForNode(BGraph* graph, BNode *node)
 {
 	BArc *arc;
 
-	if (node->arcs != NULL)
-	{
+	if (node->arcs != NULL) {
 		MEM_freeN(node->arcs);
 	}
 	
@@ -151,20 +140,16 @@ void BLI_rebuildAdjacencyListForNode(BGraph* graph, BNode *node)
 	/* temporary use to indicate the first index available in the lists */
 	node->flag = 0;
 
-	for (arc = graph->arcs.first; arc; arc= arc->next)
-	{
-		if (arc->head == node)
-		{
+	for (arc = graph->arcs.first; arc; arc= arc->next) {
+		if (arc->head == node) {
 			addArcToNodeAdjacencyList(arc->head, arc);
 		}
-		else if (arc->tail == node)
-		{
+		else if (arc->tail == node) {
 			addArcToNodeAdjacencyList(arc->tail, arc);
 		}
 	}
 
-	if (node->degree != node->flag)
-	{
+	if (node->degree != node->flag) {
 		printf("error in node [%p]. Added only %i arcs out of %i\n", (void *)node, node->flag, node->degree);
 	}
 }
@@ -173,10 +158,8 @@ void BLI_freeAdjacencyList(BGraph *graph)
 {
 	BNode *node;
 
-	for (node = graph->nodes.first; node; node = node->next)
-	{
-		if (node->arcs != NULL)
-		{
+	for (node = graph->nodes.first; node; node = node->next) {
+		if (node->arcs != NULL) {
 			MEM_freeN(node->arcs);
 			node->arcs = NULL;
 		}
@@ -187,10 +170,8 @@ int BLI_hasAdjacencyList(BGraph *graph)
 {
 	BNode *node;
 	
-	for (node = graph->nodes.first; node; node = node->next)
-	{
-		if (node->arcs == NULL)
-		{
+	for (node = graph->nodes.first; node; node = node->next) {
+		if (node->arcs == NULL) {
 			return 0;
 		}
 	}
@@ -200,28 +181,24 @@ int BLI_hasAdjacencyList(BGraph *graph)
 
 void BLI_replaceNodeInArc(BGraph *graph, BArc *arc, BNode *node_src, BNode *node_replaced)
 {
-	if (arc->head == node_replaced)
-	{
+	if (arc->head == node_replaced) {
 		arc->head = node_src;
 		node_src->degree++;
 	}
 
-	if (arc->tail == node_replaced)
-	{
+	if (arc->tail == node_replaced) {
 		arc->tail = node_src;
 		node_src->degree++;
 	}
 	
-	if (arc->head == arc->tail)
-	{
+	if (arc->head == arc->tail) {
 		node_src->degree -= 2;
 		
 		graph->free_arc(arc);
 		BLI_freelinkN(&graph->arcs, arc);
 	}
 
-	if (node_replaced->degree == 0)
-	{
+	if (node_replaced->degree == 0) {
 		BLI_removeNode(graph, node_replaced);
 	}
 }
@@ -230,26 +207,22 @@ void BLI_replaceNode(BGraph *graph, BNode *node_src, BNode *node_replaced)
 {
 	BArc *arc, *next_arc;
 	
-	for (arc = graph->arcs.first; arc; arc = next_arc)
-	{
+	for (arc = graph->arcs.first; arc; arc = next_arc) {
 		next_arc = arc->next;
 		
-		if (arc->head == node_replaced)
-		{
+		if (arc->head == node_replaced) {
 			arc->head = node_src;
 			node_replaced->degree--;
 			node_src->degree++;
 		}
 
-		if (arc->tail == node_replaced)
-		{
+		if (arc->tail == node_replaced) {
 			arc->tail = node_src;
 			node_replaced->degree--;
 			node_src->degree++;
 		}
 		
-		if (arc->head == arc->tail)
-		{
+		if (arc->head == arc->tail) {
 			node_src->degree -= 2;
 			
 			graph->free_arc(arc);
@@ -257,8 +230,7 @@ void BLI_replaceNode(BGraph *graph, BNode *node_src, BNode *node_replaced)
 		}
 	}
 	
-	if (node_replaced->degree == 0)
-	{
+	if (node_replaced->degree == 0) {
 		BLI_removeNode(graph, node_replaced);
 	}
 }
@@ -267,12 +239,9 @@ void BLI_removeDoubleNodes(BGraph *graph, float limit)
 {
 	BNode *node_src, *node_replaced;
 	
-	for (node_src = graph->nodes.first; node_src; node_src = node_src->next)
-	{
-		for (node_replaced = graph->nodes.first; node_replaced; node_replaced = node_replaced->next)
-		{
-			if (node_replaced != node_src && len_v3v3(node_replaced->p, node_src->p) <= limit)
-			{
+	for (node_src = graph->nodes.first; node_src; node_src = node_src->next) {
+		for (node_replaced = graph->nodes.first; node_replaced; node_replaced = node_replaced->next) {
+			if (node_replaced != node_src && len_v3v3(node_replaced->p, node_src->p) <= limit) {
 				BLI_replaceNode(graph, node_src, node_replaced);
 			}
 		}
@@ -285,11 +254,9 @@ BNode * BLI_FindNodeByPosition(BGraph *graph, float *p, float limit)
 	BNode *closest_node = NULL, *node;
 	float min_distance = 0.0f;
 	
-	for (node = graph->nodes.first; node; node = node->next)
-	{
+	for (node = graph->nodes.first; node; node = node->next) {
 		float distance = len_v3v3(p, node->p); 
-		if (distance <= limit && (closest_node == NULL || distance < min_distance))
-		{
+		if (distance <= limit && (closest_node == NULL || distance < min_distance)) {
 			closest_node = node;
 			min_distance = distance;
 		}
@@ -301,15 +268,13 @@ BNode * BLI_FindNodeByPosition(BGraph *graph, float *p, float limit)
 
 static void flagSubgraph(BNode *node, int subgraph)
 {
-	if (node->subgraph_index == 0)
-	{
+	if (node->subgraph_index == 0) {
 		BArc *arc;
 		int i;
 		
 		node->subgraph_index = subgraph;
 		
-		for (i = 0; i < node->degree; i++)
-		{
+		for (i = 0; i < node->degree; i++) {
 			arc = node->arcs[i];
 			flagSubgraph(BLI_otherNode(arc, node), subgraph);
 		}
@@ -321,20 +286,16 @@ int BLI_FlagSubgraphs(BGraph *graph)
 	BNode *node;
 	int subgraph = 0;
 
-	if (BLI_hasAdjacencyList(graph) == 0)
-	{
+	if (BLI_hasAdjacencyList(graph) == 0) {
 		BLI_buildAdjacencyList(graph);
 	}
 	
-	for (node = graph->nodes.first; node; node = node->next)
-	{
+	for (node = graph->nodes.first; node; node = node->next) {
 		node->subgraph_index = 0;
 	}
 	
-	for (node = graph->nodes.first; node; node = node->next)
-	{
-		if (node->subgraph_index == 0)
-		{
+	for (node = graph->nodes.first; node; node = node->next) {
+		if (node->subgraph_index == 0) {
 			subgraph++;
 			flagSubgraph(node, subgraph);
 		}
@@ -347,10 +308,8 @@ void BLI_ReflagSubgraph(BGraph *graph, int old_subgraph, int new_subgraph)
 {
 	BNode *node;
 
-	for (node = graph->nodes.first; node; node = node->next)
-	{
-		if (node->flag == old_subgraph)
-		{
+	for (node = graph->nodes.first; node; node = node->next) {
+		if (node->flag == old_subgraph) {
 			node->flag = new_subgraph;
 		}
 	}
@@ -362,26 +321,22 @@ static int detectCycle(BNode *node, BArc *src_arc)
 {
 	int value = 0;
 	
-	if (node->flag == 0)
-	{
+	if (node->flag == 0) {
 		int i;
 
 		/* mark node as visited */
 		node->flag = 1;
 
-		for (i = 0; i < node->degree && value == 0; i++)
-		{
+		for (i = 0; i < node->degree && value == 0; i++) {
 			BArc *arc = node->arcs[i];
 			
 			/* don't go back on the source arc */
-			if (arc != src_arc)
-			{
+			if (arc != src_arc) {
 				value = detectCycle(BLI_otherNode(arc, node), arc);
 			}
 		}
 	}
-	else
-	{
+	else {
 		value = 1;
 	}
 	
@@ -399,11 +354,9 @@ int	BLI_isGraphCyclic(BGraph *graph)
 	BLI_flagNodes(graph, 0);
 
 	/* detectCycles in subgraphs */	
-	for (node = graph->nodes.first; node && value == 0; node = node->next)
-	{
+	for (node = graph->nodes.first; node && value == 0; node = node->next) {
 		/* only for nodes in subgraphs that haven't been visited yet */
-		if (node->flag == 0)
-		{
+		if (node->flag == 0) {
 			value = value || detectCycle(node, NULL);
 		}		
 	}
@@ -415,10 +368,8 @@ BArc * BLI_findConnectedArc(BGraph *graph, BArc *arc, BNode *v)
 {
 	BArc *nextArc;
 	
-	for (nextArc = graph->arcs.first; nextArc; nextArc = nextArc->next)
-	{
-		if (arc != nextArc && (nextArc->head == v || nextArc->tail == v))
-		{
+	for (nextArc = graph->arcs.first; nextArc; nextArc = nextArc->next) {
+		if (arc != nextArc && (nextArc->head == v || nextArc->tail == v)) {
 			break;
 		}
 	}
@@ -434,30 +385,24 @@ static int subtreeShape(BNode *node, BArc *rootArc, int include_root)
 	
 	node->flag = 1;
 	
-	if (include_root)
-	{
+	if (include_root) {
 		BNode *newNode = BLI_otherNode(rootArc, node);
 		return subtreeShape(newNode, rootArc, 0);
 	}
-	else
-	{
+	else {
 		/* Base case, no arcs leading away */
-		if (node->arcs == NULL || *(node->arcs) == NULL)
-		{
+		if (node->arcs == NULL || *(node->arcs) == NULL) {
 			return 0;
 		}
-		else
-		{
+		else {
 			int i;
 	
-			for (i = 0; i < node->degree; i++)
-			{
+			for (i = 0; i < node->degree; i++) {
 				BArc *arc = node->arcs[i];
 				BNode *newNode = BLI_otherNode(arc, node);
 				
 				/* stop immediate and cyclic backtracking */
-				if (arc != rootArc && newNode->flag == 0)
-				{
+				if (arc != rootArc && newNode->flag == 0) {
 					depth += subtreeShape(newNode, arc, 0);
 				}
 			}
@@ -480,13 +425,11 @@ float BLI_subtreeLength(BNode *node)
 
 	node->flag = 0; /* flag node as visited */
 
-	for (i = 0; i < node->degree; i++)
-	{
+	for (i = 0; i < node->degree; i++) {
 		BArc *arc = node->arcs[i];
 		BNode *other_node = BLI_otherNode(arc, node);
 		
-		if (other_node->flag != 0)
-		{
+		if (other_node->flag != 0) {
 			float subgraph_length = arc->length + BLI_subtreeLength(other_node); 
 			length = MAX2(length, subgraph_length);
 		}
@@ -503,15 +446,12 @@ void BLI_calcGraphLength(BGraph *graph)
 	
 	nb_subgraphs = BLI_FlagSubgraphs(graph);
 	
-	for (i = 1; i <= nb_subgraphs; i++)
-	{
+	for (i = 1; i <= nb_subgraphs; i++) {
 		BNode *node;
 		
-		for (node = graph->nodes.first; node; node = node->next)
-		{
+		for (node = graph->nodes.first; node; node = node->next) {
 			/* start on an external node  of the subgraph */
-			if (node->subgraph_index == i && node->degree == 1)
-			{
+			if (node->subgraph_index == i && node->degree == 1) {
 				float subgraph_length = BLI_subtreeLength(node);
 				length = MAX2(length, subgraph_length);
 				break;
@@ -542,32 +482,27 @@ static void testRadialSymmetry(BGraph *graph, BNode* root_node, RadialArc* ring,
 	int i;
 	
 	/* sort ring by angle */
-	for (i = 0; i < total - 1; i++)
-	{
+	for (i = 0; i < total - 1; i++) {
 		float minAngle = FLT_MAX;
 		int minIndex = -1;
 		int j;
 
-		for (j = i + 1; j < total; j++)
-		{
+		for (j = i + 1; j < total; j++) {
 			float angle = dot_v3v3(ring[i].n, ring[j].n);
 
 			/* map negative values to 1..2 */
-			if (angle < 0)
-			{
+			if (angle < 0) {
 				angle = 1 - angle;
 			}
 
-			if (angle < minAngle)
-			{
+			if (angle < minAngle) {
 				minIndex = j;
 				minAngle = angle;
 			}
 		}
 
 		/* swap if needed */
-		if (minIndex != i + 1)
-		{
+		if (minIndex != i + 1) {
 			RadialArc tmp;
 			tmp = ring[i + 1];
 			ring[i + 1] = ring[minIndex];
@@ -575,8 +510,7 @@ static void testRadialSymmetry(BGraph *graph, BNode* root_node, RadialArc* ring,
 		}
 	}
 
-	for (i = 0; i < total && symmetric; i++)
-	{
+	for (i = 0; i < total && symmetric; i++) {
 		BNode *node1, *node2;
 		float tangent[3];
 		float normal[3];
@@ -593,29 +527,25 @@ static void testRadialSymmetry(BGraph *graph, BNode* root_node, RadialArc* ring,
 		BLI_mirrorAlongAxis(p, root_node->p, normal);
 		
 		/* check if it's within limit before continuing */
-		if (len_v3v3(node1->p, p) > limit)
-		{
+		if (len_v3v3(node1->p, p) > limit) {
 			symmetric = 0;
 		}
 
 	}
 
-	if (symmetric)
-	{
+	if (symmetric) {
 		/* mark node as symmetric physically */
 		copy_v3_v3(root_node->symmetry_axis, axis);
 		root_node->symmetry_flag |= SYM_PHYSICAL;
 		root_node->symmetry_flag |= SYM_RADIAL;
 		
 		/* FLAG SYMMETRY GROUP */
-		for (i = 0; i < total; i++)
-		{
+		for (i = 0; i < total; i++) {
 			ring[i].arc->symmetry_group = group;
 			ring[i].arc->symmetry_flag = SYM_SIDE_RADIAL + i;
 		}
 
-		if (graph->radial_symmetry)
-		{
+		if (graph->radial_symmetry) {
 			graph->radial_symmetry(root_node, ring, total);
 		}
 	}
@@ -634,13 +564,11 @@ static void handleRadialSymmetry(BGraph *graph, BNode *root_node, int depth, flo
 	root_node->symmetry_flag |= SYM_TOPOLOGICAL;
 
 	/* total the number of arcs in the symmetry ring */
-	for (i = 0; i < root_node->degree; i++)
-	{
+	for (i = 0; i < root_node->degree; i++) {
 		BArc *connectedArc = root_node->arcs[i];
 		
 		/* depth is store as a negative in flag. symmetry level is positive */
-		if (connectedArc->symmetry_level == -depth)
-		{
+		if (connectedArc->symmetry_level == -depth) {
 			total++;
 		}
 	}
@@ -649,13 +577,11 @@ static void handleRadialSymmetry(BGraph *graph, BNode *root_node, int depth, flo
 	unit = ring;
 
 	/* fill in the ring */
-	for (unit = ring, i = 0; i < root_node->degree; i++)
-	{
+	for (unit = ring, i = 0; i < root_node->degree; i++) {
 		BArc *connectedArc = root_node->arcs[i];
 		
 		/* depth is store as a negative in flag. symmetry level is positive */
-		if (connectedArc->symmetry_level == -depth)
-		{
+		if (connectedArc->symmetry_level == -depth) {
 			BNode *otherNode = BLI_otherNode(connectedArc, root_node);
 			float vec[3];
 
@@ -676,19 +602,16 @@ static void handleRadialSymmetry(BGraph *graph, BNode *root_node, int depth, flo
 	 * using a rather bogus insertion sort
 	 * butrings will never get too big to matter
 	 * */
-	for (i = 0; i < total; i++)
-	{
+	for (i = 0; i < total; i++) {
 		int j;
 
-		for (j = i - 1; j >= 0; j--)
-		{
+		for (j = i - 1; j >= 0; j--) {
 			BArc *arc1, *arc2;
 			
 			arc1 = ring[j].arc;
 			arc2 = ring[j + 1].arc;
 			
-			if (arc1->length > arc2->length)
-			{
+			if (arc1->length > arc2->length) {
 				/* swap with smaller */
 				RadialArc tmp;
 				
@@ -696,8 +619,7 @@ static void handleRadialSymmetry(BGraph *graph, BNode *root_node, int depth, flo
 				ring[j + 1] = ring[j];
 				ring[j] = tmp;
 			}
-			else
-			{
+			else {
 				break;
 			}
 		}
@@ -707,38 +629,32 @@ static void handleRadialSymmetry(BGraph *graph, BNode *root_node, int depth, flo
 	first = 0;
 	group = 0;
 	
-	for (i = 1; i < total; i++)
-	{
+	for (i = 1; i < total; i++) {
 		int dispatch = 0;
 		int last = i - 1;
 		
-		if (fabsf(ring[first].arc->length - ring[i].arc->length) > limit)
-		{
+		if (fabsf(ring[first].arc->length - ring[i].arc->length) > limit) {
 			dispatch = 1;
 		}
 
 		/* if not dispatching already and on last arc
 		 * Dispatch using current arc as last
 		 * */		
-		if (dispatch == 0 && i == total - 1)
-		{
+		if (dispatch == 0 && i == total - 1) {
 			last = i;
 			dispatch = 1;
 		} 
 		
-		if (dispatch)
-		{
+		if (dispatch) {
 			int sub_total = last - first + 1; 
 
 			group += 1;
 
-			if (sub_total == 1)
-			{
+			if (sub_total == 1) {
 				group -= 1; /* not really a group so decrement */
 				/* NOTHING TO DO */
 			}
-			else if (sub_total == 2)
-			{
+			else if (sub_total == 2) {
 				BArc *arc1, *arc2;
 				BNode *node1, *node2;
 				
@@ -750,14 +666,12 @@ static void handleRadialSymmetry(BGraph *graph, BNode *root_node, int depth, flo
 				
 				testAxialSymmetry(graph, root_node, node1, node2, arc1, arc2, axis, limit, group);
 			}
-			else if (sub_total != total) /* allocate a new sub ring if needed */
-			{
+			else if (sub_total != total) /* allocate a new sub ring if needed */ {
 				RadialArc *sub_ring = MEM_callocN(sizeof(RadialArc) * sub_total, "radial symmetry ring");
 				int sub_i;
 				
 				/* fill in the sub ring */
-				for (sub_i = 0; sub_i < sub_total; sub_i++)
-				{
+				for (sub_i = 0; sub_i < sub_total; sub_i++) {
 					sub_ring[sub_i] = ring[first + sub_i];
 				}
 				
@@ -765,8 +679,7 @@ static void handleRadialSymmetry(BGraph *graph, BNode *root_node, int depth, flo
 			
 				MEM_freeN(sub_ring);
 			}
-			else if (sub_total == total)
-			{
+			else if (sub_total == total) {
 				testRadialSymmetry(graph, root_node, ring, total, axis, limit, group);
 			}
 			
@@ -786,12 +699,10 @@ static void flagAxialSymmetry(BNode *root_node, BNode *end_node, BArc *arc, int
 	
 	sub_v3_v3v3(vec, end_node->p, root_node->p);
 	
-	if (dot_v3v3(vec, root_node->symmetry_axis) < 0)
-	{
+	if (dot_v3v3(vec, root_node->symmetry_axis) < 0) {
 		arc->symmetry_flag |= SYM_SIDE_NEGATIVE;
 	}
-	else
-	{
+	else {
 		arc->symmetry_flag |= SYM_SIDE_POSITIVE;
 	}
 }
@@ -809,16 +720,13 @@ static void testAxialSymmetry(BGraph *graph, BNode* root_node, BNode* node1, BNo
 	
 	cross_v3_v3v3(nor, vec, axis);
 	
-	if (abs(nor[0]) > abs(nor[1]) && abs(nor[0]) > abs(nor[2]) && nor[0] < 0)
-	{
+	if (abs(nor[0]) > abs(nor[1]) && abs(nor[0]) > abs(nor[2]) && nor[0] < 0) {
 		negate_v3(nor);
 	}
-	else if (abs(nor[1]) > abs(nor[0]) && abs(nor[1]) > abs(nor[2]) && nor[1] < 0)
-	{
+	else if (abs(nor[1]) > abs(nor[0]) && abs(nor[1]) > abs(nor[2]) && nor[1] < 0) {
 		negate_v3(nor);
 	}
-	else if (abs(nor[2]) > abs(nor[1]) && abs(nor[2]) > abs(nor[0]) && nor[2] < 0)
-	{
+	else if (abs(nor[2]) > abs(nor[1]) && abs(nor[2]) > abs(nor[0]) && nor[2] < 0) {
 		negate_v3(nor);
 	}
 	
@@ -827,8 +735,7 @@ static void testAxialSymmetry(BGraph *graph, BNode* root_node, BNode* node1, BNo
 	BLI_mirrorAlongAxis(p, root_node->p, nor);
 	
 	/* check if it's within limit before continuing */
-	if (len_v3v3(node1->p, p) <= limit)
-	{
+	if (len_v3v3(node1->p, p) <= limit) {
 		/* mark node as symmetric physically */
 		copy_v3_v3(root_node->symmetry_axis, nor);
 		root_node->symmetry_flag |= SYM_PHYSICAL;
@@ -838,13 +745,11 @@ static void testAxialSymmetry(BGraph *graph, BNode* root_node, BNode* node1, BNo
 		flagAxialSymmetry(root_node, node1, arc1, group);
 		flagAxialSymmetry(root_node, node2, arc2, group);
 		
-		if (graph->axial_symmetry)
-		{
+		if (graph->axial_symmetry) {
 			graph->axial_symmetry(root_node, node1, node2, arc1, arc2);
 		}
 	}
-	else
-	{
+	else {
 		/* NOT SYMMETRIC */
 	}
 }
@@ -858,20 +763,16 @@ static void handleAxialSymmetry(BGraph *graph, BNode *root_node, int depth, floa
 	/* mark topological symmetry */
 	root_node->symmetry_flag |= SYM_TOPOLOGICAL;
 
-	for (i = 0; i < root_node->degree; i++)
-	{
+	for (i = 0; i < root_node->degree; i++) {
 		BArc *connectedArc = root_node->arcs[i];
 		
 		/* depth is store as a negative in flag. symmetry level is positive */
-		if (connectedArc->symmetry_level == -depth)
-		{
-			if (arc1 == NULL)
-			{
+		if (connectedArc->symmetry_level == -depth) {
+			if (arc1 == NULL) {
 				arc1 = connectedArc;
 				node1 = BLI_otherNode(arc1, root_node);
 			}
-			else
-			{
+			else {
 				arc2 = connectedArc;
 				node2 = BLI_otherNode(arc2, root_node);
 				break; /* Can stop now, the two arcs have been found */
@@ -880,8 +781,7 @@ static void handleAxialSymmetry(BGraph *graph, BNode *root_node, int depth, floa
 	}
 	
 	/* shouldn't happen, but just to be sure */
-	if (node1 == NULL || node2 == NULL)
-	{
+	if (node1 == NULL || node2 == NULL) {
 		return;
 	}
 	
@@ -897,18 +797,15 @@ static void markdownSecondarySymmetry(BGraph *graph, BNode *node, int depth, int
 	/* count the number of branches in this symmetry group
 	 * and determinate the axis of symmetry
 	 *  */	
-	for (i = 0; i < node->degree; i++)
-	{
+	for (i = 0; i < node->degree; i++) {
 		BArc *connectedArc = node->arcs[i];
 		
 		/* depth is store as a negative in flag. symmetry level is positive */
-		if (connectedArc->symmetry_level == -depth)
-		{
+		if (connectedArc->symmetry_level == -depth) {
 			count++;
 		}
 		/* If arc is on the axis */
-		else if (connectedArc->symmetry_level == level)
-		{
+		else if (connectedArc->symmetry_level == level) {
 			add_v3_v3(axis, connectedArc->head->p);
 			sub_v3_v3v3(axis, axis, connectedArc->tail->p);
 		}
@@ -917,22 +814,18 @@ static void markdownSecondarySymmetry(BGraph *graph, BNode *node, int depth, int
 	normalize_v3(axis);
 
 	/* Split between axial and radial symmetry */
-	if (count == 2)
-	{
+	if (count == 2) {
 		handleAxialSymmetry(graph, node, depth, axis, limit);
 	}
-	else
-	{
+	else {
 		handleRadialSymmetry(graph, node, depth, axis, limit);
 	}
 		
 	/* markdown secondary symetries */	
-	for (i = 0; i < node->degree; i++)
-	{
+	for (i = 0; i < node->degree; i++) {
 		BArc *connectedArc = node->arcs[i];
 		
-		if (connectedArc->symmetry_level == -depth)
-		{
+		if (connectedArc->symmetry_level == -depth) {
 			/* markdown symmetry for branches corresponding to the depth */
 			markdownSymmetryArc(graph, connectedArc, node, level + 1, limit);
 		}
@@ -944,19 +837,16 @@ static void markdownSymmetryArc(BGraph *graph, BArc *arc, BNode *node, int level
 	int i;
 
 	/* if arc is null, we start straight from a node */	
-	if (arc)
-	{
+	if (arc) {
 		arc->symmetry_level = level;
 		
 		node = BLI_otherNode(arc, node);
 	}
 	
-	for (i = 0; i < node->degree; i++)
-	{
+	for (i = 0; i < node->degree; i++) {
 		BArc *connectedArc = node->arcs[i];
 		
-		if (connectedArc != arc)
-		{
+		if (connectedArc != arc) {
 			BNode *connectedNode = BLI_otherNode(connectedArc, node);
 			
 			/* symmetry level is positive value, negative values is subtree depth */
@@ -966,26 +856,22 @@ static void markdownSymmetryArc(BGraph *graph, BArc *arc, BNode *node, int level
 
 	arc = NULL;
 
-	for (i = 0; i < node->degree; i++)
-	{
+	for (i = 0; i < node->degree; i++) {
 		int issymmetryAxis = 0;
 		BArc *connectedArc = node->arcs[i];
 		
 		/* only arcs not already marked as symetric */
-		if (connectedArc->symmetry_level < 0)
-		{
+		if (connectedArc->symmetry_level < 0) {
 			int j;
 			
 			/* true by default */
 			issymmetryAxis = 1;
 			
-			for (j = 0; j < node->degree; j++)
-			{
+			for (j = 0; j < node->degree; j++) {
 				BArc *otherArc = node->arcs[j];
 				
 				/* different arc, same depth */
-				if (otherArc != connectedArc && otherArc->symmetry_level == connectedArc->symmetry_level)
-				{
+				if (otherArc != connectedArc && otherArc->symmetry_level == connectedArc->symmetry_level) {
 					/* not on the symmetry axis */
 					issymmetryAxis = 0;
 					break;
@@ -994,15 +880,12 @@ static void markdownSymmetryArc(BGraph *graph, BArc *arc, BNode *node, int level
 		}
 		
 		/* arc could be on the symmetry axis */
-		if (issymmetryAxis == 1)
-		{
+		if (issymmetryAxis == 1) {
 			/* no arc as been marked previously, keep this one */
-			if (arc == NULL)
-			{
+			if (arc == NULL) {
 				arc = connectedArc;
 			}
-			else if (connectedArc->symmetry_level < arc->symmetry_level)
-			{
+			else if (connectedArc->symmetry_level < arc->symmetry_level) {
 				/* go with more complex subtree as symmetry arc */
 				arc = connectedArc;
 			}
@@ -1010,20 +893,17 @@ static void markdownSymmetryArc(BGraph *graph, BArc *arc, BNode *node, int level
 	}
 	
 	/* go down the arc continuing the symmetry axis */
-	if (arc)
-	{
+	if (arc) {
 		markdownSymmetryArc(graph, arc, node, level, limit);
 	}
 
 	
 	/* secondary symmetry */
-	for (i = 0; i < node->degree; i++)
-	{
+	for (i = 0; i < node->degree; i++) {
 		BArc *connectedArc = node->arcs[i];
 		
 		/* only arcs not already marked as symetric and is not the next arc on the symmetry axis */
-		if (connectedArc->symmetry_level < 0)
-		{
+		if (connectedArc->symmetry_level < 0) {
 			/* subtree depth is store as a negative value in the symmetry */
 			markdownSecondarySymmetry(graph, node, -connectedArc->symmetry_level, level, limit);
 		}
@@ -1035,13 +915,11 @@ void BLI_markdownSymmetry(BGraph *graph, BNode *root_node, float limit)
 	BNode *node;
 	BArc *arc;
 	
-	if (root_node == NULL)
-	{
+	if (root_node == NULL) {
 		return;
 	}
 	
-	if (BLI_isGraphCyclic(graph))
-	{
+	if (BLI_isGraphCyclic(graph)) {
 		return;
 	}
 	
@@ -1054,37 +932,29 @@ void BLI_markdownSymmetry(BGraph *graph, BNode *root_node, float limit)
 	node = root_node;
 	
 	/* sanity check REMOVE ME */
-	if (node->degree > 0)
-	{
+	if (node->degree > 0) {
 		arc = node->arcs[0];
 		
-		if (node->degree == 1)
-		{
+		if (node->degree == 1) {
 			markdownSymmetryArc(graph, arc, node, 1, limit);
 		}
-		else
-		{
+		else {
 			markdownSymmetryArc(graph, NULL, node, 1, limit);
 		}
 		
 
 
 		/* mark down non-symetric arcs */
-		for (arc = graph->arcs.first; arc; arc = arc->next)
-		{
-			if (arc->symmetry_level < 0)
-			{
+		for (arc = graph->arcs.first; arc; arc = arc->next) {
+			if (arc->symmetry_level < 0) {
 				arc->symmetry_level = 0;
 			}
-			else
-			{
+			else {
 				/* mark down nodes with the lowest level symmetry axis */
-				if (arc->head->symmetry_level == 0 || arc->head->symmetry_level > arc->symmetry_level)
-				{
+				if (arc->head->symmetry_level == 0 || arc->head->symmetry_level > arc->symmetry_level) {
 					arc->head->symmetry_level = arc->symmetry_level;
 				}
-				if (arc->tail->symmetry_level == 0 || arc->tail->symmetry_level > arc->symmetry_level)
-				{
+				if (arc->tail->symmetry_level == 0 || arc->tail->symmetry_level > arc->symmetry_level) {
 					arc->tail->symmetry_level = arc->symmetry_level;
 				}
 			}
@@ -1108,16 +978,13 @@ void* IT_peek(void* arg, int n)
 {
 	BArcIterator *iter = (BArcIterator*)arg;
 	
-	if (iter->index + n < 0)
-	{
+	if (iter->index + n < 0) {
 		return iter->head(iter);
 	}
-	else if (iter->index + n >= iter->length)
-	{
+	else if (iter->index + n >= iter->length) {
 		return iter->tail(iter);
 	}
-	else
-	{
+	else {
 		return iter->peek(iter, n);
 	}
 }