style cleanup: compositor operations

1 files changed, 531 insertions, 531 deletions

diff --git a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
index df04b889200..ba54c8ad9d6 100644
--- a/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
+++ b/source/blender/compositor/operations/COM_DoubleEdgeMaskOperation.cpp
@@ -30,735 +30,735 @@
 static void do_adjacentKeepBorders(unsigned int t, unsigned int rw, unsigned int *limask, unsigned int *lomask, unsigned int *lres, float *res, unsigned int *rsize)
 {
 	int x;
-	unsigned int isz=0; // inner edge size
-	unsigned int osz=0; // outer edge size
-	unsigned int gsz=0; // gradient fill area size
+	unsigned int isz = 0; // inner edge size
+	unsigned int osz = 0; // outer edge size
+	unsigned int gsz = 0; // gradient fill area size
 	/* Test the four corners */
 	/* upper left corner */
-	x=t-rw+1;
+	x = t - rw + 1;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if pixel underneath, or to the right, are empty in the inner mask,
 		// but filled in the outer mask
-		if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x+1] && lomask[x+1])) {
+		if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x + 1] && lomask[x + 1])) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
 			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
-	else if (lomask[x]) {                         // inner mask was empty, test if outer mask is filled
+	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
 		osz++;                                   // increment outer edge size
 		lres[x] = 3;                             // flag pixel as outer edge
 	}
 	/* upper right corner */
-	x=t;
+	x = t;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if pixel underneath, or to the left, are empty in the inner mask,
 		// but filled in the outer mask
-		if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x-1] && lomask[x-1])) {
+		if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x - 1] && lomask[x - 1])) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                         // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
 		osz++;                                   // increment outer edge size
-		lres[x]=3;                               // flag pixel as outer edge
+		lres[x] = 3;                             // flag pixel as outer edge
 	}
 	/* lower left corner */
-	x=0;
+	x = 0;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if pixel above, or to the right, are empty in the inner mask,
 		// but filled in the outer mask
-		if ((!limask[x+rw] && lomask[x+rw]) || (!limask[x+1] && lomask[x+1])) {
+		if ((!limask[x + rw] && lomask[x + rw]) || (!limask[x + 1] && lomask[x + 1])) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
 		osz++;                                   // increment outer edge size
-		lres[x]=3;                               // flag pixel as outer edge
+		lres[x] = 3;                             // flag pixel as outer edge
 	}
 	/* lower right corner */
-	x=rw-1;
+	x = rw - 1;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if pixel above, or to the left, are empty in the inner mask,
 		// but filled in the outer mask
-		if ((!limask[x+rw] && lomask[x+rw]) || (!limask[x-1] && lomask[x-1])) {
+		if ((!limask[x + rw] && lomask[x + rw]) || (!limask[x - 1] && lomask[x - 1])) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
 		osz++;                                   // increment outer edge size
-		lres[x]=3;                               // flag pixel as outer edge
+		lres[x] = 3;                             // flag pixel as outer edge
 	}
 	
 	/* Test the TOP row of pixels in buffer, except corners */
-	for (x = t-1; x>=(t-rw)+2; x--) {
+	for (x = t - 1; x >= (t - rw) + 2; x--) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if pixel to the right, or to the left, are empty in the inner mask,
 			// but filled in the outer mask
-			if ((!limask[x-1] && lomask[x-1]) || (!limask[x+1] && lomask[x+1])) {
+			if ((!limask[x - 1] && lomask[x - 1]) || (!limask[x + 1] && lomask[x + 1])) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
 		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 	}
 	
 	/* Test the BOTTOM row of pixels in buffer, except corners */
-	for (x = rw-2; x; x--) {
+	for (x = rw - 2; x; x--) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if pixel to the right, or to the left, are empty in the inner mask,
 			// but filled in the outer mask
-			if ((!limask[x-1] && lomask[x-1]) || (!limask[x+1] && lomask[x+1])) {
+			if ((!limask[x - 1] && lomask[x - 1]) || (!limask[x + 1] && lomask[x + 1])) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
 		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 	}
 	/* Test the LEFT edge of pixels in buffer, except corners */
-	for (x = t-(rw<<1)+1; x>=rw; x-=rw) {
+	for (x = t - (rw << 1) + 1; x >= rw; x -= rw) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if pixel underneath, or above, are empty in the inner mask,
 			// but filled in the outer mask
-			if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x+rw] && lomask[x+rw])) {
+			if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x + rw] && lomask[x + rw])) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 	}
 	
 	/* Test the RIGHT edge of pixels in buffer, except corners */
-	for (x = t-rw; x>rw; x-=rw) {
+	for (x = t - rw; x > rw; x -= rw) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if pixel underneath, or above, are empty in the inner mask,
 			// but filled in the outer mask
-			if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x+rw] && lomask[x+rw])) {
+			if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x + rw] && lomask[x + rw])) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 	}
 	
-	rsize[0]=isz;  // fill in our return sizes for edges + fill
-	rsize[1]=osz;
-	rsize[2]=gsz;
+	rsize[0] = isz;  // fill in our return sizes for edges + fill
+	rsize[1] = osz;
+	rsize[2] = gsz;
 }
 
 static void do_adjacentBleedBorders(unsigned int t, unsigned int rw, unsigned int *limask, unsigned int *lomask, unsigned int *lres, float *res, unsigned int *rsize)
 {
 	int x;
-	unsigned int isz=0; // inner edge size
-	unsigned int osz=0; // outer edge size
-	unsigned int gsz=0; // gradient fill area size
+	unsigned int isz = 0; // inner edge size
+	unsigned int osz = 0; // outer edge size
+	unsigned int gsz = 0; // gradient fill area size
 	/* Test the four corners */
 	/* upper left corner */
-	x=t-rw+1;
+	x = t - rw + 1;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if pixel underneath, or to the right, are empty in the inner mask,
 		// but filled in the outer mask
-		if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x+1] && lomask[x+1])) {
+		if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x + 1] && lomask[x + 1])) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
-		if (!lomask[x-rw] || !lomask[x+1]) {      // test if outer mask is empty underneath or to the right
+		if (!lomask[x - rw] || !lomask[x + 1]) { // test if outer mask is empty underneath or to the right
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 		else {
 			gsz++;                               // increment the gradient pixel count
-			lres[x]=2;                           // flag pixel as gradient
+			lres[x] = 2;                         // flag pixel as gradient
 		}
 	}
 	/* upper right corner */
-	x=t;
+	x = t;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if pixel underneath, or to the left, are empty in the inner mask,
 		// but filled in the outer mask
-		if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x-1] && lomask[x-1])) {
+		if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x - 1] && lomask[x - 1])) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
-		if (!lomask[x-rw] || !lomask[x-1]) {      // test if outer mask is empty underneath or to the left
+		if (!lomask[x - rw] || !lomask[x - 1]) { // test if outer mask is empty underneath or to the left
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 		else {
 			gsz++;                               // increment the gradient pixel count
-			lres[x]=2;                           // flag pixel as gradient
+			lres[x] = 2;                         // flag pixel as gradient
 		}
 	}
 	/* lower left corner */
-	x=0;
+	x = 0;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if pixel above, or to the right, are empty in the inner mask,
 		// but filled in the outer mask
-		if ((!limask[x+rw] && lomask[x+rw]) || (!limask[x+1] && lomask[x+1])) {
+		if ((!limask[x + rw] && lomask[x + rw]) || (!limask[x + 1] && lomask[x + 1])) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
-		if (!lomask[x+rw] || !lomask[x+1]) {      // test if outer mask is empty above or to the right
+		if (!lomask[x + rw] || !lomask[x + 1]) { // test if outer mask is empty above or to the right
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 		else {
 			gsz++;                               // increment the gradient pixel count
-			lres[x]=2;                           // flag pixel as gradient
+			lres[x] = 2;                         // flag pixel as gradient
 		}
 	}
 	/* lower right corner */
-	x=rw-1;
+	x = rw - 1;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if pixel above, or to the left, are empty in the inner mask,
 		// but filled in the outer mask
-		if ((!limask[x+rw] && lomask[x+rw]) || (!limask[x-1] && lomask[x-1])) {
+		if ((!limask[x + rw] && lomask[x + rw]) || (!limask[x - 1] && lomask[x - 1])) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
-		if (!lomask[x+rw] || !lomask[x-1]) {      // test if outer mask is empty above or to the left
+		if (!lomask[x + rw] || !lomask[x - 1]) { // test if outer mask is empty above or to the left
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 		else {
 			gsz++;                               // increment the gradient pixel count
-			lres[x]=2;                           // flag pixel as gradient
+			lres[x] = 2;                         // flag pixel as gradient
 		}
 	}
 	/* Test the TOP row of pixels in buffer, except corners */
-	for (x = t-1; x>=(t-rw)+2; x--) {
+	for (x = t - 1; x >= (t - rw) + 2; x--) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if pixel to the left, or to the right, are empty in the inner mask,
 			// but filled in the outer mask
-			if ((!limask[x-1] && lomask[x-1]) || (!limask[x+1] && lomask[x+1])) {
+			if ((!limask[x - 1] && lomask[x - 1]) || (!limask[x + 1] && lomask[x + 1])) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-			if (!lomask[x-1] || !lomask[x+1]) {   // test if outer mask is empty to the left or to the right
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
+			if (!lomask[x - 1] || !lomask[x + 1]) {   // test if outer mask is empty to the left or to the right
 				osz++;                           // increment outer edge size
-				lres[x]=3;                       // flag pixel as outer edge
+				lres[x] = 3;                     // flag pixel as outer edge
 			}
 			else {
 				gsz++;                           // increment the gradient pixel count
-				lres[x]=2;                       // flag pixel as gradient
+				lres[x] = 2;                     // flag pixel as gradient
 			}
 		}
 	}
 	
 	/* Test the BOTTOM row of pixels in buffer, except corners */
-	for (x = rw-2; x; x--) {
+	for (x = rw - 2; x; x--) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if pixel to the left, or to the right, are empty in the inner mask,
 			// but filled in the outer mask
-			if ((!limask[x-1] && lomask[x-1]) || (!limask[x+1] && lomask[x+1])) {
+			if ((!limask[x - 1] && lomask[x - 1]) || (!limask[x + 1] && lomask[x + 1])) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                     // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-			if (!lomask[x-1] || !lomask[x+1]) {   // test if outer mask is empty to the left or to the right
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
+			if (!lomask[x - 1] || !lomask[x + 1]) { // test if outer mask is empty to the left or to the right
 				osz++;                           // increment outer edge size
-				lres[x]=3;                       // flag pixel as outer edge
+				lres[x] = 3;                     // flag pixel as outer edge
 			}
 			else {
 				gsz++;                           // increment the gradient pixel count
-				lres[x]=2;                       // flag pixel as gradient
+				lres[x] = 2;                     // flag pixel as gradient
 			}
 		}
 	}
 	/* Test the LEFT edge of pixels in buffer, except corners */
-	for (x = t-(rw<<1)+1; x>=rw; x-=rw) {
+	for (x = t - (rw << 1) + 1; x >= rw; x -= rw) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if pixel underneath, or above, are empty in the inner mask,
 			// but filled in the outer mask
-			if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x+rw] && lomask[x+rw])) {
+			if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x + rw] && lomask[x + rw])) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-			if (!lomask[x-rw] || !lomask[x+rw]) { // test if outer mask is empty underneath or above
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
+			if (!lomask[x - rw] || !lomask[x + rw]) { // test if outer mask is empty underneath or above
 				osz++;                           // increment outer edge size
-				lres[x]=3;                       // flag pixel as outer edge
+				lres[x] = 3;                     // flag pixel as outer edge
 			}
 			else {
 				gsz++;                           // increment the gradient pixel count
-				lres[x]=2;                       // flag pixel as gradient
+				lres[x] = 2;                     // flag pixel as gradient
 			}
 		}
 	}
 	
 	/* Test the RIGHT edge of pixels in buffer, except corners */
-	for (x = t-rw; x>rw; x-=rw) {
+	for (x = t - rw; x > rw; x -= rw) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if pixel underneath, or above, are empty in the inner mask,
 			// but filled in the outer mask
-			if ((!limask[x-rw] && lomask[x-rw]) || (!limask[x+rw] && lomask[x+rw])) {
+			if ((!limask[x - rw] && lomask[x - rw]) || (!limask[x + rw] && lomask[x + rw])) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-			if (!lomask[x-rw] || !lomask[x+rw]) { // test if outer mask is empty underneath or above
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
+			if (!lomask[x - rw] || !lomask[x + rw]) { // test if outer mask is empty underneath or above
 				osz++;                           // increment outer edge size
-				lres[x]=3;                       // flag pixel as outer edge
+				lres[x] = 3;                     // flag pixel as outer edge
 			}
 			else {
 				gsz++;                           // increment the gradient pixel count
-				lres[x]=2;                       // flag pixel as gradient
+				lres[x] = 2;                     // flag pixel as gradient
 			}
 		}
 	}
 	
-	rsize[0]=isz;  // fill in our return sizes for edges + fill
-	rsize[1]=osz;
-	rsize[2]=gsz;
+	rsize[0] = isz;  // fill in our return sizes for edges + fill
+	rsize[1] = osz;
+	rsize[2] = gsz;
 }
 
 static void do_allKeepBorders(unsigned int t, unsigned int rw, unsigned int *limask, unsigned int *lomask, unsigned int *lres, float *res, unsigned int *rsize)
 {
 	int x;
-	unsigned int isz=0; // inner edge size
-	unsigned int osz=0; // outer edge size
-	unsigned int gsz=0; // gradient fill area size
+	unsigned int isz = 0; // inner edge size
+	unsigned int osz = 0; // outer edge size
+	unsigned int gsz = 0; // gradient fill area size
 	/* Test the four corners */
 	/* upper left corner */
-	x=t-rw+1;
+	x = t - rw + 1;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if the inner mask is empty underneath or to the right
-		if (!limask[x-rw] || !limask[x+1]) {
+		if (!limask[x - rw] || !limask[x + 1]) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
 		osz++;                                   // increment outer edge size
-		lres[x]=3;                               // flag pixel as outer edge
+		lres[x] = 3;                             // flag pixel as outer edge
 	}
 	/* upper right corner */
-	x=t;
+	x = t;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if the inner mask is empty underneath or to the left
-		if (!limask[x-rw] || !limask[x-1]) {
+		if (!limask[x - rw] || !limask[x - 1]) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
 		osz++;                                   // increment outer edge size
-		lres[x]=3;                               // flag pixel as outer edge
+		lres[x] = 3;                             // flag pixel as outer edge
 	}
 	/* lower left corner */
-	x=0;
+	x = 0;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if inner mask is empty above or to the right
-		if (!limask[x+rw] || !limask[x+1]) {
+		if (!limask[x + rw] || !limask[x + 1]) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
 		osz++;                                   // increment outer edge size
-		lres[x]=3;                               // flag pixel as outer edge
+		lres[x] = 3;                             // flag pixel as outer edge
 	}
 	/* lower right corner */
-	x=rw-1;
+	x = rw - 1;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if inner mask is empty above or to the left
-		if (!limask[x+rw] || !limask[x-1]) {
+		if (!limask[x + rw] || !limask[x - 1]) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
 		osz++;                                   // increment outer edge size
-		lres[x]=3;                               // flag pixel as outer edge
+		lres[x] = 3;                             // flag pixel as outer edge
 	}
 	
 	/* Test the TOP row of pixels in buffer, except corners */
-	for (x = t-1; x>=(t-rw)+2; x--) {
+	for (x = t - 1; x >= (t - rw) + 2; x--) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if inner mask is empty to the left or to the right
-			if (!limask[x-1] || !limask[x+1]) {
+			if (!limask[x - 1] || !limask[x + 1]) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 	}
 	
 	/* Test the BOTTOM row of pixels in buffer, except corners */
-	for (x = rw-2; x; x--) {
+	for (x = rw - 2; x; x--) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if inner mask is empty to the left or to the right
-			if (!limask[x-1] || !limask[x+1]) {
+			if (!limask[x - 1] || !limask[x + 1]) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 	}
 	/* Test the LEFT edge of pixels in buffer, except corners */
-	for (x = t-(rw<<1)+1; x>=rw; x-=rw) {
+	for (x = t - (rw << 1) + 1; x >= rw; x -= rw) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if inner mask is empty underneath or above
-			if (!limask[x-rw] || !limask[x+rw]) {
+			if (!limask[x - rw] || !limask[x + rw]) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 	}
 	
 	/* Test the RIGHT edge of pixels in buffer, except corners */
-	for (x = t-rw; x>rw; x-=rw) {
+	for (x = t - rw; x > rw; x -= rw) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if inner mask is empty underneath or above
-			if (!limask[x-rw] || !limask[x+rw]) {
+			if (!limask[x - rw] || !limask[x + rw]) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 	}
 	
-	rsize[0]=isz;  // fill in our return sizes for edges + fill
-	rsize[1]=osz;
-	rsize[2]=gsz;
+	rsize[0] = isz;  // fill in our return sizes for edges + fill
+	rsize[1] = osz;
+	rsize[2] = gsz;
 }
 
 static void do_allBleedBorders(unsigned int t, unsigned int rw, unsigned int *limask, unsigned int *lomask, unsigned int *lres, float *res, unsigned int *rsize)
 {
 	int x;
-	unsigned int isz=0; // inner edge size
-	unsigned int osz=0; // outer edge size
-	unsigned int gsz=0; // gradient fill area size
+	unsigned int isz = 0; // inner edge size
+	unsigned int osz = 0; // outer edge size
+	unsigned int gsz = 0; // gradient fill area size
 	/* Test the four corners */
 	/* upper left corner */
-	x=t-rw+1;
+	x = t - rw + 1;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if the inner mask is empty underneath or to the right
-		if (!limask[x-rw] || !limask[x+1]) {
+		if (!limask[x - rw] || !limask[x + 1]) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
-		if (!lomask[x-rw] || !lomask[x+1]) {      // test if outer mask is empty underneath or to the right
+		if (!lomask[x - rw] || !lomask[x + 1]) { // test if outer mask is empty underneath or to the right
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 		else {
 			gsz++;                               // increment the gradient pixel count
-			lres[x]=2;                           // flag pixel as gradient
+			lres[x] = 2;                         // flag pixel as gradient
 		}
 	}
 	/* upper right corner */
-	x=t;
+	x = t;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if the inner mask is empty underneath or to the left
-		if (!limask[x-rw] || !limask[x-1]) {
+		if (!limask[x - rw] || !limask[x - 1]) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
-		if (!lomask[x-rw] || !lomask[x-1]) {      // test if outer mask is empty above or to the left
+		if (!lomask[x - rw] || !lomask[x - 1]) { // test if outer mask is empty above or to the left
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                           // flag pixel as outer edge
 		}
 		else {
 			gsz++;                               // increment the gradient pixel count
-			lres[x]=2;                           // flag pixel as gradient
+			lres[x] = 2;                         // flag pixel as gradient
 		}
 	}
 	/* lower left corner */
-	x=0;
+	x = 0;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if inner mask is empty above or to the right
-		if (!limask[x+rw] || !limask[x+1]) {
+		if (!limask[x + rw] || !limask[x + 1]) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
-		if (!lomask[x+rw] || !lomask[x+1]) {      // test if outer mask is empty underneath or to the right
+		if (!lomask[x + rw] || !lomask[x + 1]) { // test if outer mask is empty underneath or to the right
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 		else {
 			gsz++;                               // increment the gradient pixel count
-			lres[x]=2;                           // flag pixel as gradient
+			lres[x] = 2;                         // flag pixel as gradient
 		}
 	}
 	/* lower right corner */
-	x=rw-1;
+	x = rw - 1;
 	// test if inner mask is filled
 	if (limask[x]) {
 		// test if inner mask is empty above or to the left
-		if (!limask[x+rw] || !limask[x-1]) {
+		if (!limask[x + rw] || !limask[x - 1]) {
 			isz++;                               // increment inner edge size
-			lres[x]=4;                           // flag pixel as inner edge
+			lres[x] = 4;                         // flag pixel as inner edge
 		}
 		else {
-			res[x]=1.0f;                         // pixel is just part of inner mask, and it's not an edge
+			res[x] = 1.0f;                       // pixel is just part of inner mask, and it's not an edge
 		}
 	}
 	else if (lomask[x]) {                        // inner mask was empty, test if outer mask is filled
-		if (!lomask[x+rw] || !lomask[x-1]) {      // test if outer mask is empty underneath or to the left
+		if (!lomask[x + rw] || !lomask[x - 1]) { // test if outer mask is empty underneath or to the left
 			osz++;                               // increment outer edge size
-			lres[x]=3;                           // flag pixel as outer edge
+			lres[x] = 3;                         // flag pixel as outer edge
 		}
 		else {
 			gsz++;                               // increment the gradient pixel count
-			lres[x]=2;                           // flag pixel as gradient
+			lres[x] = 2;                         // flag pixel as gradient
 		}
 	}
 	/* Test the TOP row of pixels in buffer, except corners */
-	for (x = t-1; x>=(t-rw)+2; x--) {
+	for (x = t - 1; x >= (t - rw) + 2; x--) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if inner mask is empty to the left or to the right
-			if (!limask[x-1] || !limask[x+1]) {
+			if (!limask[x - 1] || !limask[x + 1]) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-			if (!lomask[x-1] || !lomask[x+1]) {   // test if outer mask is empty to the left or to the right
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
+			if (!lomask[x - 1] || !lomask[x + 1]) { // test if outer mask is empty to the left or to the right
 				osz++;                           // increment outer edge size
-				lres[x]=3;                       // flag pixel as outer edge
+				lres[x] = 3;                     // flag pixel as outer edge
 			}
 			else {
 				gsz++;                           // increment the gradient pixel count
-				lres[x]=2;                       // flag pixel as gradient
+				lres[x] = 2;                     // flag pixel as gradient
 			}
 		}
 	}
 	
 	/* Test the BOTTOM row of pixels in buffer, except corners */
-	for (x = rw-2; x; x--) {
+	for (x = rw - 2; x; x--) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if inner mask is empty to the left or to the right
-			if (!limask[x-1] || !limask[x+1]) {
+			if (!limask[x - 1] || !limask[x + 1]) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-			if (!lomask[x-1] || !lomask[x+1]) {   // test if outer mask is empty to the left or to the right
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
+			if (!lomask[x - 1] || !lomask[x + 1]) {   // test if outer mask is empty to the left or to the right
 				osz++;                           // increment outer edge size
-				lres[x]=3;                       // flag pixel as outer edge
+				lres[x] = 3;                     // flag pixel as outer edge
 			}
 			else {
 				gsz++;                           // increment the gradient pixel count
-				lres[x]=2;                       // flag pixel as gradient
+				lres[x] = 2;                     // flag pixel as gradient
 			}
 		}
 	}
 	/* Test the LEFT edge of pixels in buffer, except corners */
-	for (x = t-(rw<<1)+1; x>=rw; x-=rw) {
+	for (x = t - (rw << 1) + 1; x >= rw; x -= rw) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if inner mask is empty underneath or above
-			if (!limask[x-rw] || !limask[x+rw]) {
+			if (!limask[x - rw] || !limask[x + rw]) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
 		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-			if (!lomask[x-rw] || !lomask[x+rw]) { // test if outer mask is empty underneath or above
+			if (!lomask[x - rw] || !lomask[x + rw]) { // test if outer mask is empty underneath or above
 				osz++;                           // increment outer edge size
-				lres[x]=3;                       // flag pixel as outer edge
+				lres[x] = 3;                     // flag pixel as outer edge
 			}
 			else {
 				gsz++;                           // increment the gradient pixel count
-				lres[x]=2;                       // flag pixel as gradient
+				lres[x] = 2;                     // flag pixel as gradient
 			}
 		}
 	}
 	
 	/* Test the RIGHT edge of pixels in buffer, except corners */
-	for (x = t-rw; x>rw; x-=rw) {
+	for (x = t - rw; x > rw; x -= rw) {
 		// test if inner mask is filled
 		if (limask[x]) {
 			// test if inner mask is empty underneath or above
-			if (!limask[x-rw] || !limask[x+rw]) {
+			if (!limask[x - rw] || !limask[x + rw]) {
 				isz++;                           // increment inner edge size
-				lres[x]=4;                       // flag pixel as inner edge
+				lres[x] = 4;                     // flag pixel as inner edge
 			}
 			else {
-				res[x]=1.0f;                     // pixel is just part of inner mask, and it's not an edge
+				res[x] = 1.0f;                   // pixel is just part of inner mask, and it's not an edge
 			}
 		}
-		else if (lomask[x]) {                   // inner mask was empty, test if outer mask is filled
-			if (!lomask[x-rw] || !lomask[x+rw]) { // test if outer mask is empty underneath or above
+		else if (lomask[x]) {                    // inner mask was empty, test if outer mask is filled
+			if (!lomask[x - rw] || !lomask[x + rw]) { // test if outer mask is empty underneath or above
 				osz++;                           // increment outer edge size
-				lres[x]=3;                       // flag pixel as outer edge
+				lres[x] = 3;                     // flag pixel as outer edge
 			}
 			else {
 				gsz++;                           // increment the gradient pixel count
-				lres[x]=2;                       // flag pixel as gradient
+				lres[x] = 2;                     // flag pixel as gradient
 			}
 		}
 	}
 	
-	rsize[0]=isz;  // fill in our return sizes for edges + fill
-	rsize[1]=osz;
-	rsize[2]=gsz;
+	rsize[0] = isz;  // fill in our return sizes for edges + fill
+	rsize[1] = osz;
+	rsize[2] = gsz;
 }
 
 static void do_allEdgeDetection(unsigned int t, unsigned int rw, unsigned int *limask, unsigned int *lomask, unsigned int *lres, float *res, unsigned int *rsize, unsigned int in_isz, unsigned int in_osz, unsigned int in_gsz)
@@ -771,43 +771,43 @@ static void do_allEdgeDetection(unsigned int t, unsigned int rw, unsigned int *l
 	int pix_prevCol;                   // pix_prevCol = pixel one column behind the one we are testing in a loop
 	int pix_nextCol;                   // pix_nextCol = pixel one column in front of the one we are testing in a loop
 	/* Test all rows between the FIRST and LAST rows, excluding left and right edges */
-	for (x = (t-rw)+1, dx=x-(rw-2); dx>rw; x-=rw,dx-=rw) {
-		a=x-2;
-		pix_prevRow=a+rw;
-		pix_nextRow=a-rw;
-		pix_prevCol=a+1;
-		pix_nextCol=a-1;
-		while (a>dx-2) {
+	for (x = (t - rw) + 1, dx = x - (rw - 2); dx > rw; x -= rw, dx -= rw) {
+		a = x - 2;
+		pix_prevRow = a + rw;
+		pix_nextRow = a - rw;
+		pix_prevCol = a + 1;
+		pix_nextCol = a - 1;
+		while (a > dx - 2) {
 			if (!limask[a]) {             // if the inner mask is empty
 				if (lomask[a]) {          // if the outer mask is full
 					/*
-	   Next we test all 4 directions around the current pixel: next/prev/up/down
-	   The test ensures that the outer mask is empty and that the inner mask
-	   is also empty. If both conditions are true for any one of the 4 adjacent pixels
-	   then the current pixel is counted as being a true outer edge pixel.
-	  */
+					   Next we test all 4 directions around the current pixel: next/prev/up/down
+					   The test ensures that the outer mask is empty and that the inner mask
+					   is also empty. If both conditions are true for any one of the 4 adjacent pixels
+					   then the current pixel is counted as being a true outer edge pixel.
+					 */
 					if ((!lomask[pix_nextCol] && !limask[pix_nextCol]) ||
 					    (!lomask[pix_prevCol] && !limask[pix_prevCol]) ||
 					    (!lomask[pix_nextRow] && !limask[pix_nextRow]) ||
 					    (!lomask[pix_prevRow] && !limask[pix_prevRow]))
 					{
-						in_osz++;           // increment the outer boundary pixel count
-						lres[a]=3;       // flag pixel as part of outer edge
+						in_osz++;                // increment the outer boundary pixel count
+						lres[a] = 3;             // flag pixel as part of outer edge
 					}
-					else {             // it's not a boundary pixel, but it is a gradient pixel
-						in_gsz++;           // increment the gradient pixel count
-						lres[a]=2;       // flag pixel as gradient
+					else {                       // it's not a boundary pixel, but it is a gradient pixel
+						in_gsz++;                // increment the gradient pixel count
+						lres[a] = 2;             // flag pixel as gradient
 					}
 				}
 				
 			}
 			else {
 				if (!limask[pix_nextCol] || !limask[pix_prevCol] || !limask[pix_nextRow] || !limask[pix_prevRow]) {
-					in_isz++;               // increment the inner boundary pixel count
-					lres[a]=4;           // flag pixel as part of inner edge
+					in_isz++;                    // increment the inner boundary pixel count
+					lres[a] = 4;                 // flag pixel as part of inner edge
 				}
 				else {
-					res[a]=1.0f;         // pixel is part of inner mask, but not at an edge
+					res[a] = 1.0f;               // pixel is part of inner mask, but not at an edge
 				}
 			}
 			a--;
@@ -818,9 +818,9 @@ static void do_allEdgeDetection(unsigned int t, unsigned int rw, unsigned int *l
 		}
 	}
 	
-	rsize[0]=in_isz;  // fill in our return sizes for edges + fill
-	rsize[1]=in_osz;
-	rsize[2]=in_gsz;
+	rsize[0] = in_isz;  // fill in our return sizes for edges + fill
+	rsize[1] = in_osz;
+	rsize[2] = in_gsz;
 }
 
 static void do_adjacentEdgeDetection(unsigned int t, unsigned int rw, unsigned int *limask, unsigned int *lomask, unsigned int *lres, float *res, unsigned int *rsize, unsigned int in_isz, unsigned int in_osz, unsigned int in_gsz)
@@ -833,32 +833,32 @@ static void do_adjacentEdgeDetection(unsigned int t, unsigned int rw, unsigned i
 	int pix_prevCol;                   // pix_prevCol = pixel one column behind the one we are testing in a loop
 	int pix_nextCol;                   // pix_nextCol = pixel one column in front of the one we are testing in a loop
 	/* Test all rows between the FIRST and LAST rows, excluding left and right edges */
-	for (x = (t-rw)+1, dx=x-(rw-2); dx>rw; x-=rw,dx-=rw) {
-		a=x-2;
-		pix_prevRow=a+rw;
-		pix_nextRow=a-rw;
-		pix_prevCol=a+1;
-		pix_nextCol=a-1;
-		while (a>dx-2) {
-			if (!limask[a]) {             // if the inner mask is empty
-				if (lomask[a]) {          // if the outer mask is full
+	for (x = (t - rw) + 1, dx = x - (rw - 2); dx > rw; x -= rw, dx -= rw) {
+		a = x - 2;
+		pix_prevRow = a + rw;
+		pix_nextRow = a - rw;
+		pix_prevCol = a + 1;
+		pix_nextCol = a - 1;
+		while (a > dx - 2) {
+			if (!limask[a]) {                    // if the inner mask is empty
+				if (lomask[a]) {                 // if the outer mask is full
 					/*
-	   Next we test all 4 directions around the current pixel: next/prev/up/down
-	   The test ensures that the outer mask is empty and that the inner mask
-	   is also empty. If both conditions are true for any one of the 4 adjacent pixels
-	   then the current pixel is counted as being a true outer edge pixel.
-	  */
+					   Next we test all 4 directions around the current pixel: next/prev/up/down
+					   The test ensures that the outer mask is empty and that the inner mask
+					   is also empty. If both conditions are true for any one of the 4 adjacent pixels
+					   then the current pixel is counted as being a true outer edge pixel.
+					 */
 					if ((!lomask[pix_nextCol] && !limask[pix_nextCol]) ||
 					    (!lomask[pix_prevCol] && !limask[pix_prevCol]) ||
 					    (!lomask[pix_nextRow] && !limask[pix_nextRow]) ||
 					    (!lomask[pix_prevRow] && !limask[pix_prevRow]))
 					{
-						in_osz++;           // increment the outer boundary pixel count
-						lres[a]=3;       // flag pixel as part of outer edge
+						in_osz++;                // increment the outer boundary pixel count
+						lres[a] = 3;             // flag pixel as part of outer edge
 					}
-					else {             // it's not a boundary pixel, but it is a gradient pixel
-						in_gsz++;           // increment the gradient pixel count
-						lres[a]=2;       // flag pixel as gradient
+					else {                       // it's not a boundary pixel, but it is a gradient pixel
+						in_gsz++;                // increment the gradient pixel count
+						lres[a] = 2;             // flag pixel as gradient
 					}
 				}
 				
@@ -869,24 +869,24 @@ static void do_adjacentEdgeDetection(unsigned int t, unsigned int rw, unsigned i
 				    (!limask[pix_nextRow] && lomask[pix_nextRow]) ||
 				    (!limask[pix_prevRow] && lomask[pix_prevRow]))
 				{
-					in_isz++;               // increment the inner boundary pixel count
-					lres[a]=4;           // flag pixel as part of inner edge
+					in_isz++;                    // increment the inner boundary pixel count
+					lres[a] = 4;                 // flag pixel as part of inner edge
 				}
 				else {
-					res[a]=1.0f;         // pixel is part of inner mask, but not at an edge
+					res[a] = 1.0f;               // pixel is part of inner mask, but not at an edge
 				}
 			}
 			a--;
-			pix_prevRow--;              // advance all four "surrounding" pixel pointers
+			pix_prevRow--;                       // advance all four "surrounding" pixel pointers
 			pix_nextRow--;
 			pix_prevCol--;
 			pix_nextCol--;
 		}
 	}
 	
-	rsize[0]=in_isz;  // fill in our return sizes for edges + fill
-	rsize[1]=in_osz;
-	rsize[2]=in_gsz;
+	rsize[0] = in_isz;  // fill in our return sizes for edges + fill
+	rsize[1] = in_osz;
+	rsize[2] = in_gsz;
 }
 
 static void do_createEdgeLocationBuffer(unsigned int t, unsigned int rw, unsigned int *lres, float *res, unsigned short *gbuf, unsigned int *innerEdgeOffset, unsigned int *outerEdgeOffset, unsigned int isz, unsigned int gsz)
@@ -898,102 +898,102 @@ static void do_createEdgeLocationBuffer(unsigned int t, unsigned int rw, unsigne
 	
 	unsigned int rsl;                  // long used for finding fast 1.0/sqrt
 	unsigned int gradientFillOffset;
-	unsigned int innerAccum=0;         // for looping inner edge pixel indexes, represents current position from offset
-	unsigned int outerAccum=0;         // for looping outer edge pixel indexes, represents current position from offset
-	unsigned int gradientAccum=0;      // for looping gradient pixel indexes, represents current position from offset
+	unsigned int innerAccum = 0;       // for looping inner edge pixel indexes, represents current position from offset
+	unsigned int outerAccum = 0;       // for looping outer edge pixel indexes, represents current position from offset
+	unsigned int gradientAccum = 0;    // for looping gradient pixel indexes, represents current position from offset
 	/*
- Here we compute the size of buffer needed to hold (row,col) coordinates
- for each pixel previously determined to be either gradient, inner edge,
- or outer edge.
- 
- Allocation is done by requesting 4 bytes "sizeof(int)" per pixel, even
- though gbuf[] is declared as unsigned short* (2 bytes) because we don't
- store the pixel indexes, we only store x,y location of pixel in buffer.
- 
- This does make the assumption that x and y can fit in 16 unsigned bits
- so if Blender starts doing renders greater than 65536 in either direction
- this will need to allocate gbuf[] as unsigned int *and allocate 8 bytes
- per flagged pixel.
- 
- In general, the buffer on-screen:
- 
- Example:  9 by 9 pixel block
- 
- . = pixel non-white in both outer and inner mask
- o = pixel white in outer, but not inner mask, adjacent to "." pixel
- g = pixel white in outer, but not inner mask, not adjacent to "." pixel
- i = pixel white in inner mask, adjacent to "g" or "." pixel
- F = pixel white in inner mask, only adjacent to other pixels white in the inner mask
- 
- 
-	  .........   <----- pixel #80
-	  ..oooo...
-	  .oggggo..
-	  .oggiggo.
-	  .ogiFigo.
-	  .oggiggo.
-	  .oggggo..
-	  ..oooo...
- pixel #00 -----> .........
- 
- gsz = 18   (18 "g" pixels above)
- isz = 4    (4 "i" pixels above)
- osz = 18   (18 "o" pixels above)
- 
- 
- The memory in gbuf[] after filling will look like this:
- 
-  gradientFillOffset (0 pixels)                   innerEdgeOffset (18 pixels)    outerEdgeOffset (22 pixels)
- /                                               /                              /
- /                                               /                              /
- |X   Y   X   Y   X   Y   X   Y   >     <X   Y   X   Y   >     <X   Y   X   Y   X   Y   >     <X   Y   X   Y   | <- (x,y)
- +-------------------------------->     <---------------->     <------------------------>     <----------------+
- |0   2   4   6   8   10  12  14  > ... <68  70  72  74  > ... <80  82  84  86  88  90  > ... <152 154 156 158 | <- bytes
- +-------------------------------->     <---------------->     <------------------------>     <----------------+
- |g0  g0  g1  g1  g2  g2  g3  g3  >     <g17 g17 i0  i0  >     <i2  i2  i3  i3  o0  o0  >     <o16 o16 o17 o17 | <- pixel
-			 /                              /                              /
-			/                              /                              /
-			  /                              /                              /
-   +---------- gradientAccum (18) ---------+      +--- innerAccum (22) ---+      +--- outerAccum (40) ---+
-   
-   
- Ultimately we do need the pixel's memory buffer index to set the output
- pixel color, but it's faster to reconstruct the memory buffer location
- each iteration of the final gradient calculation than it is to deconstruct
- a memory location into x,y pairs each round.
-*/
-	
-	
-	gradientFillOffset=0;                              // since there are likely "more" of these, put it first. :)
-	*innerEdgeOffset=gradientFillOffset+gsz;           // set start of inner edge indexes
-	*outerEdgeOffset=(*innerEdgeOffset)+isz;           // set start of outer edge indexes
+	   Here we compute the size of buffer needed to hold (row,col) coordinates
+	   for each pixel previously determined to be either gradient, inner edge,
+	   or outer edge.
+
+	   Allocation is done by requesting 4 bytes "sizeof(int)" per pixel, even
+	   though gbuf[] is declared as unsigned short* (2 bytes) because we don't
+	   store the pixel indexes, we only store x,y location of pixel in buffer.
+
+	   This does make the assumption that x and y can fit in 16 unsigned bits
+	   so if Blender starts doing renders greater than 65536 in either direction
+	   this will need to allocate gbuf[] as unsigned int *and allocate 8 bytes
+	   per flagged pixel.
+
+	   In general, the buffer on-screen:
+
+	   Example:  9 by 9 pixel block
+
+	   . = pixel non-white in both outer and inner mask
+	   o = pixel white in outer, but not inner mask, adjacent to "." pixel
+	   g = pixel white in outer, but not inner mask, not adjacent to "." pixel
+	   i = pixel white in inner mask, adjacent to "g" or "." pixel
+	   F = pixel white in inner mask, only adjacent to other pixels white in the inner mask
+
+
+	   .........   <----- pixel #80
+	   ..oooo...
+	   .oggggo..
+	   .oggiggo.
+	   .ogiFigo.
+	   .oggiggo.
+	   .oggggo..
+	   ..oooo...
+	   pixel #00 -----> .........
+
+	   gsz = 18   (18 "g" pixels above)
+	   isz = 4    (4 "i" pixels above)
+	   osz = 18   (18 "o" pixels above)
+
+
+	   The memory in gbuf[] after filling will look like this:
+
+	   gradientFillOffset (0 pixels)                   innerEdgeOffset (18 pixels)    outerEdgeOffset (22 pixels)
+	   /                                               /                              /
+	   /                                               /                              /
+	   |X   Y   X   Y   X   Y   X   Y   >     <X   Y   X   Y   >     <X   Y   X   Y   X   Y   >     <X   Y   X   Y   | <- (x,y)
+	   +-------------------------------->     <---------------->     <------------------------>     <----------------+
+	   |0   2   4   6   8   10  12  14  > ... <68  70  72  74  > ... <80  82  84  86  88  90  > ... <152 154 156 158 | <- bytes
+	   +-------------------------------->     <---------------->     <------------------------>     <----------------+
+	   |g0  g0  g1  g1  g2  g2  g3  g3  >     <g17 g17 i0  i0  >     <i2  i2  i3  i3  o0  o0  >     <o16 o16 o17 o17 | <- pixel
+	         /                              /                              /
+	        /                              /                              /
+	          /                              /                              /
+	   +---------- gradientAccum (18) ---------+      +--- innerAccum (22) ---+      +--- outerAccum (40) ---+
+
+
+	   Ultimately we do need the pixel's memory buffer index to set the output
+	   pixel color, but it's faster to reconstruct the memory buffer location
+	   each iteration of the final gradient calculation than it is to deconstruct
+	   a memory location into x,y pairs each round.
+	 */
+
+
+	gradientFillOffset = 0;                            // since there are likely "more" of these, put it first. :)
+	*innerEdgeOffset = gradientFillOffset + gsz;       // set start of inner edge indexes
+	*outerEdgeOffset = (*innerEdgeOffset) + isz;       // set start of outer edge indexes
 	/* set the accumulators to correct positions */    // set up some accumulator variables for loops
 	gradientAccum = gradientFillOffset;                // each accumulator variable starts at its respective
 	innerAccum = *innerEdgeOffset;                     // section's offset so when we start filling, each
 	outerAccum = *outerEdgeOffset;                     // section fills up it's allocated space in gbuf
 	//uses dmin=row, rsl=col
-	for (x=0,dmin=0; x<t; x+=rw,dmin++) {
-		for (rsl=0; rsl<rw; rsl++) {
-			a=x+rsl;
-			if (lres[a]==2) {           // it is a gradient pixel flagged by 2
-				ud=gradientAccum<<1;   // double the index to reach correct unsigned short location
-				gbuf[ud]=dmin;         // insert pixel's row into gradient pixel location buffer
-				gbuf[ud+1]=rsl;        // insert pixel's column into gradient pixel location buffer
-				gradientAccum++;       // increment gradient index buffer pointer
+	for (x = 0, dmin = 0; x < t; x += rw, dmin++) {
+		for (rsl = 0; rsl < rw; rsl++) {
+			a = x + rsl;
+			if (lres[a] == 2) {                  // it is a gradient pixel flagged by 2
+				ud = gradientAccum << 1;         // double the index to reach correct unsigned short location
+				gbuf[ud] = dmin;                 // insert pixel's row into gradient pixel location buffer
+				gbuf[ud + 1] = rsl;              // insert pixel's column into gradient pixel location buffer
+				gradientAccum++;                 // increment gradient index buffer pointer
 			}
-			else if (lres[a]==3) {    // it is an outer edge pixel flagged by 3
-				ud=outerAccum<<1;      // double the index to reach correct unsigned short location
-				gbuf[ud]=dmin;         // insert pixel's row into outer edge pixel location buffer
-				gbuf[ud+1]=rsl;        // insert pixel's column into outer edge pixel location buffer
-				outerAccum++;          // increment outer edge index buffer pointer
-				res[a]=0.0f;           // set output pixel intensity now since it won't change later
+			else if (lres[a] == 3) {             // it is an outer edge pixel flagged by 3
+				ud = outerAccum << 1;            // double the index to reach correct unsigned short location
+				gbuf[ud] = dmin;                 // insert pixel's row into outer edge pixel location buffer
+				gbuf[ud + 1] = rsl;              // insert pixel's column into outer edge pixel location buffer
+				outerAccum++;                    // increment outer edge index buffer pointer
+				res[a] = 0.0f;                   // set output pixel intensity now since it won't change later
 			}
-			else if (lres[a]==4) {    // it is an inner edge pixel flagged by 4
-				ud=innerAccum<<1;      // double int index to reach correct unsigned short location
-				gbuf[ud]=dmin;         // insert pixel's row into inner edge pixel location buffer
-				gbuf[ud+1]=rsl;        // insert pixel's column into inner edge pixel location buffer
-				innerAccum++;          // increment inner edge index buffer pointer
-				res[a]=1.0f;           // set output pixel intensity now since it won't change later
+			else if (lres[a] == 4) {             // it is an inner edge pixel flagged by 4
+				ud = innerAccum << 1;            // double int index to reach correct unsigned short location
+				gbuf[ud] = dmin;                 // insert pixel's row into inner edge pixel location buffer
+				gbuf[ud + 1] = rsl;              // insert pixel's column into inner edge pixel location buffer
+				innerAccum++;                    // increment inner edge index buffer pointer
+				res[a] = 1.0f;                   // set output pixel intensity now since it won't change later
 			}
 		}
 	}
@@ -1019,111 +1019,111 @@ static void do_fillGradientBuffer(unsigned int rw, float *res, unsigned short *g
 	int dy;                            // dy = Y-delta (used for distance proportion calculation)
 	
 	/*
-  The general algorithm used to color each gradient pixel is:
-  
-  1.) Loop through all gradient pixels.
-  A.) For each gradient pixel:
-   a.) Loop though all outside edge pixels, looking for closest one
-	to the gradient pixel we are in.
-   b.) Loop through all inside edge pixels, looking for closest one
-	to the gradient pixel we are in.
-   c.) Find proportion of distance from gradient pixel to inside edge
-	pixel compared to sum of distance to inside edge and distance to
-	outside edge.
-	
-	In an image where:
-	. = blank (black) pixels, not covered by inner mask or outer mask
-	+ = desired gradient pixels, covered only by outer mask
-	* = white full mask pixels, covered by at least inner mask
-	
-	...............................
-	...............+++++++++++.....
-	...+O++++++..++++++++++++++....
-	..+++\++++++++++++++++++++.....
-	.+++++G+++++++++*******+++.....
-	.+++++|+++++++*********+++.....
-	.++***I****************+++.....
-	.++*******************+++......
-	.+++*****************+++.......
-	..+++***************+++........
-	....+++**********+++...........
-	......++++++++++++.............
-	...............................
-	
-	 O = outside edge pixel
-	  \
-	   G = gradient pixel
-	   |
-	   I = inside edge pixel
-	   
-		 __
-	   *note that IO does not need to be a straight line, in fact
-		many cases can arise where straight lines do not work
-		correctly.
-		
-		   __       __     __
-   d.) Pixel color is assigned as |GO| / ( |GI| + |GO| )
-   
-  The implementation does not compute distance, but the reciprocal of the
-  distance. This is done to avoid having to compute a square root, as a
-  reciprocal square root can be computed faster. Therefore, the code computes
-  pixel color as |GI| / (|GI| + |GO|). Since these are reciprocals, GI serves the
-  purpose of GO for the proportion calculation.
-  
-  For the purposes of the minimun distance comparisons, we only check
-  the sums-of-squares against eachother, since they are in the same
-  mathematical sort-order as if we did go ahead and take square roots
-  
-  Loop through all gradient pixels.
-  */
-	
-	for (x = gsz-1; x>=0; x--) {
-		gradientFillOffset=x<<1;
-		t=gbuf[gradientFillOffset];         // calculate column of pixel indexed by gbuf[x]
-		fsz=gbuf[gradientFillOffset+1];     // calculate row of pixel indexed by gbuf[x]
-		dmin=0xffffffff;                    // reset min distance to edge pixel
-		for (a=outerEdgeOffset+osz-1; a>=outerEdgeOffset; a--) {   // loop through all outer edge buffer pixels
-			ud=a<<1;
-			dy=t-gbuf[ud];                  // set dx to gradient pixel column - outer edge pixel row
-			dx=fsz-gbuf[ud+1];              // set dy to gradient pixel row - outer edge pixel column
-			ud=dx*dx+dy*dy;                 // compute sum of squares
-			if (ud<dmin) {                   // if our new sum of squares is less than the current minimum
-				dmin=ud;                    // set a new minimum equal to the new lower value
+	 * The general algorithm used to color each gradient pixel is:
+	 *
+	 * 1.) Loop through all gradient pixels.
+	 * A.) For each gradient pixel:
+	 * a.) Loop though all outside edge pixels, looking for closest one
+	 * to the gradient pixel we are in.
+	 * b.) Loop through all inside edge pixels, looking for closest one
+	 * to the gradient pixel we are in.
+	 * c.) Find proportion of distance from gradient pixel to inside edge
+	 * pixel compared to sum of distance to inside edge and distance to
+	 * outside edge.
+	 *
+	 * In an image where:
+	 * . = blank (black) pixels, not covered by inner mask or outer mask
+	 * + = desired gradient pixels, covered only by outer mask
+	 * * = white full mask pixels, covered by at least inner mask
+	 *
+	 * ...............................
+	 * ...............+++++++++++.....
+	 * ...+O++++++..++++++++++++++....
+	 * ..+++\++++++++++++++++++++.....
+	 * .+++++G+++++++++*******+++.....
+	 * .+++++|+++++++*********+++.....
+	 * .++***I****************+++.....
+	 * .++*******************+++......
+	 * .+++*****************+++.......
+	 * ..+++***************+++........
+	 * ....+++**********+++...........
+	 * ......++++++++++++.............
+	 * ...............................
+	 *
+	 * O = outside edge pixel
+	 * \
+	 *  G = gradient pixel
+	 *  |
+	 *  I = inside edge pixel
+	 * 
+	 *   __
+	 *  *note that IO does not need to be a straight line, in fact
+	 *  many cases can arise where straight lines do not work
+	 *  correctly.
+	 *
+	 *     __       __     __
+	 * d.) Pixel color is assigned as |GO| / ( |GI| + |GO| )
+	 *
+	 * The implementation does not compute distance, but the reciprocal of the
+	 * distance. This is done to avoid having to compute a square root, as a
+	 * reciprocal square root can be computed faster. Therefore, the code computes
+	 * pixel color as |GI| / (|GI| + |GO|). Since these are reciprocals, GI serves the
+	 * purpose of GO for the proportion calculation.
+	 *
+	 * For the purposes of the minimun distance comparisons, we only check
+	 * the sums-of-squares against eachother, since they are in the same
+	 * mathematical sort-order as if we did go ahead and take square roots
+	 *
+	 * Loop through all gradient pixels.
+	 */
+
+	for (x = gsz - 1; x >= 0; x--) {
+		gradientFillOffset = x << 1;
+		t = gbuf[gradientFillOffset];            // calculate column of pixel indexed by gbuf[x]
+		fsz = gbuf[gradientFillOffset + 1];      // calculate row of pixel indexed by gbuf[x]
+		dmin = 0xffffffff;                       // reset min distance to edge pixel
+		for (a = outerEdgeOffset + osz - 1; a >= outerEdgeOffset; a--) {   // loop through all outer edge buffer pixels
+			ud = a << 1;
+			dy = t - gbuf[ud];                   // set dx to gradient pixel column - outer edge pixel row
+			dx = fsz - gbuf[ud + 1];             // set dy to gradient pixel row - outer edge pixel column
+			ud = dx * dx + dy * dy;              // compute sum of squares
+			if (ud < dmin) {                     // if our new sum of squares is less than the current minimum
+				dmin = ud;                       // set a new minimum equal to the new lower value
 			}
 		}
-		odist=(float)(dmin);                     // cast outer min to a float
-		rsf=odist*0.5f;                          //
-		rsl=*(unsigned int*)&odist;              // use some peculiar properties of the way bits are stored
-		rsl=0x5f3759df-(rsl>>1);                 // in floats vs. unsigned ints to compute an approximate
-		odist=*(float*)&rsl;                     // reciprocal square root
-		odist=odist*(rsopf-(rsf*odist*odist));   // -- ** this line can be iterated for more accuracy ** --
-		dmin=0xffffffff;                         // reset min distance to edge pixel
-		for (a = innerEdgeOffset+isz-1; a>=innerEdgeOffset; a--) {   // loop through all inside edge pixels
-			ud=a<<1;
-			dy=t-gbuf[ud];         // compute delta in Y from gradient pixel to inside edge pixel
-			dx=fsz-gbuf[ud+1];     // compute delta in X from gradient pixel to inside edge pixel
-			ud=dx*dx+dy*dy;        // compute sum of squares
-			if (ud<dmin) {          // if our new sum of squares is less than the current minimum we've found
-				dmin=ud;           // set a new minimum equal to the new lower value
+		odist = (float)(dmin);                   // cast outer min to a float
+		rsf = odist * 0.5f;                      //
+		rsl = *(unsigned int *)&odist;           // use some peculiar properties of the way bits are stored
+		rsl = 0x5f3759df - (rsl >> 1);           // in floats vs. unsigned ints to compute an approximate
+		odist = *(float *)&rsl;                  // reciprocal square root
+		odist = odist * (rsopf - (rsf * odist * odist));   // -- ** this line can be iterated for more accuracy ** --
+		dmin = 0xffffffff;                       // reset min distance to edge pixel
+		for (a = innerEdgeOffset + isz - 1; a >= innerEdgeOffset; a--) {   // loop through all inside edge pixels
+			ud = a << 1;
+			dy = t - gbuf[ud];         // compute delta in Y from gradient pixel to inside edge pixel
+			dx = fsz - gbuf[ud + 1];     // compute delta in X from gradient pixel to inside edge pixel
+			ud = dx * dx + dy * dy;        // compute sum of squares
+			if (ud < dmin) {          // if our new sum of squares is less than the current minimum we've found
+				dmin = ud;           // set a new minimum equal to the new lower value
 			}
 		}
-		idist=(float)(dmin);                     // cast inner min to a float
-		rsf=idist*0.5f;                          //
-		rsl=*(unsigned int*)&idist;              //
-		rsl=0x5f3759df-(rsl>>1);                 // see notes above
-		idist=*(float*)&rsl;                     //
-		idist=idist*(rsopf-(rsf*idist*idist));   //
+		idist = (float)(dmin);                   // cast inner min to a float
+		rsf = idist * 0.5f;                      //
+		rsl = *(unsigned int *)&idist;           //
+		rsl = 0x5f3759df - (rsl >> 1);           // see notes above
+		idist = *(float *)&rsl;                  //
+		idist = idist * (rsopf - (rsf * idist * idist));   //
 		/*
-   Note once again that since we are using reciprocals of distance values our
-   proportion is already the correct intensity, and does not need to be
-   subracted from 1.0 like it would have if we used real distances.
-   */
+		 * Note once again that since we are using reciprocals of distance values our
+		 * proportion is already the correct intensity, and does not need to be
+		 * subracted from 1.0 like it would have if we used real distances.
+		 */
 		
 		/*
-   Here we reconstruct the pixel's memory location in the CompBuf by
-   Pixel Index = Pixel Column + ( Pixel Row * Row Width )
-   */
-		res[gbuf[gradientFillOffset+1]+(gbuf[gradientFillOffset]*rw)]=(idist/(idist+odist));	//set intensity
+		 * Here we reconstruct the pixel's memory location in the CompBuf by
+		 * Pixel Index = Pixel Column + ( Pixel Row * Row Width )
+		 */
+		res[gbuf[gradientFillOffset + 1] + (gbuf[gradientFillOffset] * rw)] = (idist / (idist + odist));    //set intensity
 	}
 	
 }
@@ -1140,92 +1140,92 @@ void DoubleEdgeMaskOperation::doDoubleEdgeMask(float *imask, float *omask, float
 	int t;                             // t = total number of pixels in buffer - 1 (used for loop starts)
 	int fsz;                           // size of the frame
 	
-	unsigned int isz=0;                // size (in pixels) of inside edge pixel index buffer
-	unsigned int osz=0;                // size (in pixels) of outside edge pixel index buffer
-	unsigned int gsz=0;                // size (in pixels) of gradient pixel index buffer
-	unsigned int rsize[3];             // size storage to pass to helper functions
-	unsigned int innerEdgeOffset=0;    // offset into final buffer where inner edge pixel indexes start
-	unsigned int outerEdgeOffset=0;    // offset into final buffer where outer edge pixel indexes start
+	unsigned int isz = 0;                // size (in pixels) of inside edge pixel index buffer
+	unsigned int osz = 0;                // size (in pixels) of outside edge pixel index buffer
+	unsigned int gsz = 0;                // size (in pixels) of gradient pixel index buffer
+	unsigned int rsize[3];               // size storage to pass to helper functions
+	unsigned int innerEdgeOffset = 0;    // offset into final buffer where inner edge pixel indexes start
+	unsigned int outerEdgeOffset = 0;    // offset into final buffer where outer edge pixel indexes start
 	
 	unsigned short *gbuf;              // gradient/inner/outer pixel location index buffer
 	
 	if (true) {                    // if both input sockets have some data coming in...
 		
-		t=(this->getWidth()*this->getHeight())-1;                                // determine size of the frame
+		t = (this->getWidth() * this->getHeight()) - 1;                                // determine size of the frame
 		
-		lres = (unsigned int*)res;      // unsigned int pointer to output buffer (for bit level ops)
-		limask=(unsigned int*)imask;   // unsigned int pointer to input mask (for bit level ops)
-		lomask=(unsigned int*)omask;   // unsigned int pointer to output mask (for bit level ops)
+		lres = (unsigned int *)res;      // unsigned int pointer to output buffer (for bit level ops)
+		limask = (unsigned int *)imask;   // unsigned int pointer to input mask (for bit level ops)
+		lomask = (unsigned int *)omask;   // unsigned int pointer to output mask (for bit level ops)
 		rw = this->getWidth();                   // width of a row of pixels
 		
 		
 		/*
-		 The whole buffer is broken up into 4 parts. The four CORNERS, the FIRST and LAST rows, the
-		 LEFT and RIGHT edges (excluding the corner pixels), and all OTHER rows.
-		 This allows for quick computation of outer edge pixels where
-		 a screen edge pixel is marked to be gradient.
-		 
-		 The pixel type (gradient vs inner-edge vs outer-edge) tests change
-		 depending on the user selected "Inner Edge Mode" and the user selected
-		 "Buffer Edge Mode" on the node's GUI. There are 4 sets of basically the
-		 same algorithm:
-		 
-		 1.) Inner Edge -> Adjacent Only
-			 Buffer Edge -> Keep Inside
-			 
-		 2.) Inner Edge -> Adjacent Only
-			 Buffer Edge -> Bleed Out
-			 
-		 3.) Inner Edge -> All
-			 Buffer Edge -> Keep Inside
-			 
-		 4.) Inner Edge -> All
-			 Buffer Edge -> Bleed Out
-			 
-		 Each version has slightly different criteria for detecting an edge pixel.
+		 * The whole buffer is broken up into 4 parts. The four CORNERS, the FIRST and LAST rows, the
+		 * LEFT and RIGHT edges (excluding the corner pixels), and all OTHER rows.
+		 * This allows for quick computation of outer edge pixels where
+		 * a screen edge pixel is marked to be gradient.
+		 *
+		 * The pixel type (gradient vs inner-edge vs outer-edge) tests change
+		 * depending on the user selected "Inner Edge Mode" and the user selected
+		 * "Buffer Edge Mode" on the node's GUI. There are 4 sets of basically the
+		 * same algorithm:
+		 *
+		 * 1.) Inner Edge -> Adjacent Only
+		 *   Buffer Edge -> Keep Inside
+		 *
+		 * 2.) Inner Edge -> Adjacent Only
+		 *   Buffer Edge -> Bleed Out
+		 *
+		 * 3.) Inner Edge -> All
+		 *   Buffer Edge -> Keep Inside
+		 *
+		 * 4.) Inner Edge -> All
+		 *   Buffer Edge -> Bleed Out
+		 *
+		 * Each version has slightly different criteria for detecting an edge pixel.
 		 */
-		if (this->adjecentOnly) {            // if "adjacent only" inner edge mode is turned on
-			if (this->keepInside) {          // if "keep inside" buffer edge mode is turned on
-				do_adjacentKeepBorders(t,rw,limask,lomask,lres,res,rsize);
+		if (this->adjecentOnly) {                // if "adjacent only" inner edge mode is turned on
+			if (this->keepInside) {              // if "keep inside" buffer edge mode is turned on
+				do_adjacentKeepBorders(t, rw, limask, lomask, lres, res, rsize);
 			}
-			else {                     // "bleed out" buffer edge mode is turned on
-				do_adjacentBleedBorders(t,rw,limask,lomask,lres,res,rsize);
+			else {                               // "bleed out" buffer edge mode is turned on
+				do_adjacentBleedBorders(t, rw, limask, lomask, lres, res, rsize);
 			}
-			isz=rsize[0];              // set up inner edge, outer edge, and gradient buffer sizes after border pass
-			osz=rsize[1];
-			gsz=rsize[2];
+			isz = rsize[0];                      // set up inner edge, outer edge, and gradient buffer sizes after border pass
+			osz = rsize[1];
+			gsz = rsize[2];
 			// detect edges in all non-border pixels in the buffer
-			do_adjacentEdgeDetection(t,rw,limask,lomask,lres,res,rsize,isz,osz,gsz);
+			do_adjacentEdgeDetection(t, rw, limask, lomask, lres, res, rsize, isz, osz, gsz);
 		}
-		else {                            // "all" inner edge mode is turned on
-			if (this->keepInside) {        // if "keep inside" buffer edge mode is turned on
-				do_allKeepBorders(t,rw,limask,lomask,lres,res,rsize);
+		else {                                   // "all" inner edge mode is turned on
+			if (this->keepInside) {              // if "keep inside" buffer edge mode is turned on
+				do_allKeepBorders(t, rw, limask, lomask, lres, res, rsize);
 			}
-			else {                     // "bleed out" buffer edge mode is turned on
-				do_allBleedBorders(t,rw,limask,lomask,lres,res,rsize);
+			else {                               // "bleed out" buffer edge mode is turned on
+				do_allBleedBorders(t, rw, limask, lomask, lres, res, rsize);
 			}
-			isz=rsize[0];              // set up inner edge, outer edge, and gradient buffer sizes after border pass
-			osz=rsize[1];
-			gsz=rsize[2];
+			isz = rsize[0];                      // set up inner edge, outer edge, and gradient buffer sizes after border pass
+			osz = rsize[1];
+			gsz = rsize[2];
 			// detect edges in all non-border pixels in the buffer
-			do_allEdgeDetection(t,rw,limask,lomask,lres,res,rsize,isz,osz,gsz);
+			do_allEdgeDetection(t, rw, limask, lomask, lres, res, rsize, isz, osz, gsz);
 		}
 		
-		isz=rsize[0];                  // set edge and gradient buffer sizes once again...
-		osz=rsize[1];                  // the sizes in rsize[] may have been modified
-		gsz=rsize[2];                  // by the do_*EdgeDetection() function.
+		isz = rsize[0];                          // set edge and gradient buffer sizes once again...
+		osz = rsize[1];                          // the sizes in rsize[] may have been modified
+		gsz = rsize[2];                          // by the do_*EdgeDetection() function.
 		
-		fsz=gsz+isz+osz;                                   // calculate size of pixel index buffer needed
-		gbuf = (unsigned short*)MEM_callocN(sizeof (unsigned short)*fsz*2, "DEM"); // allocate edge/gradient pixel index buffer
+		fsz = gsz + isz + osz;                                   // calculate size of pixel index buffer needed
+		gbuf = (unsigned short *)MEM_callocN(sizeof (unsigned short) * fsz * 2, "DEM"); // allocate edge/gradient pixel index buffer
 		
-		do_createEdgeLocationBuffer(t,rw,lres,res,gbuf,&innerEdgeOffset,&outerEdgeOffset,isz,gsz);
-		do_fillGradientBuffer(rw,res,gbuf,isz,osz,gsz,innerEdgeOffset,outerEdgeOffset);
+		do_createEdgeLocationBuffer(t, rw, lres, res, gbuf, &innerEdgeOffset, &outerEdgeOffset, isz, gsz);
+		do_fillGradientBuffer(rw, res, gbuf, isz, osz, gsz, innerEdgeOffset, outerEdgeOffset);
 		
-		MEM_freeN(gbuf);          // free the gradient index buffer
+		MEM_freeN(gbuf);                         // free the gradient index buffer
 	}
 }
 
-DoubleEdgeMaskOperation::DoubleEdgeMaskOperation(): NodeOperation()
+DoubleEdgeMaskOperation::DoubleEdgeMaskOperation() : NodeOperation()
 {
 	this->addInputSocket(COM_DT_VALUE);
 	this->addInputSocket(COM_DT_VALUE);
@@ -1266,9 +1266,9 @@ void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect, MemoryBuffer **mem
 	
 	lockMutex();
 	if (this->cachedInstance == NULL) {
-		MemoryBuffer *innerMask = (MemoryBuffer*)inputInnerMask->initializeTileData(rect, memoryBuffers);
-		MemoryBuffer *outerMask = (MemoryBuffer*)inputOuterMask->initializeTileData(rect, memoryBuffers);
-		float *data = new float[this->getWidth()*this->getHeight()];
+		MemoryBuffer *innerMask = (MemoryBuffer *)inputInnerMask->initializeTileData(rect, memoryBuffers);
+		MemoryBuffer *outerMask = (MemoryBuffer *)inputOuterMask->initializeTileData(rect, memoryBuffers);
+		float *data = new float[this->getWidth() * this->getHeight()];
 		float *imask = innerMask->convertToValueBuffer();
 		float *omask = outerMask->convertToValueBuffer();
 		doDoubleEdgeMask(imask, omask, data);
@@ -1281,12 +1281,12 @@ void *DoubleEdgeMaskOperation::initializeTileData(rcti *rect, MemoryBuffer **mem
 }
 void DoubleEdgeMaskOperation::executePixel(float *color, int x, int y, MemoryBuffer *inputBuffers[], void *data)
 {
-	float *buffer = (float*) data;
-	int index = (y*this->getWidth() + x);
+	float *buffer = (float *) data;
+	int index = (y * this->getWidth() + x);
 	color[0] = buffer[index];
-	color[1] = buffer[index+1];
-	color[2] = buffer[index+2];
-	color[3] = buffer[index+3];
+	color[1] = buffer[index + 1];
+	color[2] = buffer[index + 2];
+	color[3] = buffer[index + 3];
 }
 
 void DoubleEdgeMaskOperation::deinitExecution()