[brlcad-commits] SF.net SVN: brlcad:[36609] brlcad/trunk/src/conv/step/OpenNurbsInterfaces. cpp

[<ind...@us...>]

Revision: 36609
          http://brlcad.svn.sourceforge.net/brlcad/?rev=36609&view=rev
Author:   indianlarry
Date:     2009-11-24 15:22:10 +0000 (Tue, 24 Nov 2009)

Log Message:
-----------
some code cleanup and WS formatting

Modified Paths:
--------------
    brlcad/trunk/src/conv/step/OpenNurbsInterfaces.cpp

Modified: brlcad/trunk/src/conv/step/OpenNurbsInterfaces.cpp
===================================================================
--- brlcad/trunk/src/conv/step/OpenNurbsInterfaces.cpp	2009-11-24 11:00:27 UTC (rev 36608)
+++ brlcad/trunk/src/conv/step/OpenNurbsInterfaces.cpp	2009-11-24 15:22:10 UTC (rev 36609)
@@ -100,29 +100,30 @@
 ON_Brep *
 AdvancedBrepShapeRepresentation::GetONBrep()
 {
-	ON_Brep *brep = ON_Brep::New();
+    ON_Brep *brep = ON_Brep::New();
 
-	if (!LoadONBrep(brep)) {
-		cerr << "Error: " << entityname << "::GetONBrep() - Error loading openNURBS brep." << endl;
-		//still return brep may contain something useful to diagnose
-		return brep;
-	}
-
+    if (!LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::GetONBrep() - Error loading openNURBS brep." << endl;
+	//still return brep may contain something useful to diagnose
 	return brep;
+    }
+
+    return brep;
 }
+
 bool
 AdvancedBrepShapeRepresentation::LoadONBrep(ON_Brep *brep)
 {
-	LIST_OF_REPRESENTATION_ITEMS::iterator i;
+    LIST_OF_REPRESENTATION_ITEMS::iterator i;
 
-	for(i=items.begin(); i!=items.end();i++) {
-		if ( !(*i)->LoadONBrep(brep)) {
-			cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-			return false;
-		}
+    for (i = items.begin(); i != items.end(); i++) {
+	if (!(*i)->LoadONBrep(brep)) {
+	    cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	    return false;
 	}
+    }
 
-	return true;
+    return true;
 }
 
 //
@@ -131,19 +132,19 @@
 bool
 BezierCurve::LoadONBrep(ON_Brep *brep)
 {
-	cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << " id: " << id << endl;
-	return false;
+    cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << " id: " << id << endl;
+    return false;
 }
 
 bool
 BSplineCurve::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id >= 0)
-		return true;
+    if (ON_id >= 0)
+	return true;
 
-	int t_size = control_points_list.size();
+    int t_size = control_points_list.size();
 
-    ON_NurbsCurve* curve = ON_NurbsCurve::New( 3, false,degree+1,t_size);
+    ON_NurbsCurve* curve = ON_NurbsCurve::New(3, false, degree + 1, t_size);
 
     // knot index ( >= 0 and < Order + CV_count - 2 )
     // generate u-knots
@@ -151,126 +152,126 @@
     int p = degree;
     int m = n + p - 1;
     for (int i = 0; i < p; i++) {
-    	curve->SetKnot(i, 0.0);
+	curve->SetKnot(i, 0.0);
     }
-    for (int j = 1; j < n-p; j++) {
-    	double x = (double)j/(double)(n-p);
-    	int knot_index = j+p-1;
-    	curve->SetKnot(knot_index, x);
+    for (int j = 1; j < n - p; j++) {
+	double x = (double) j / (double) (n - p);
+	int knot_index = j + p - 1;
+	curve->SetKnot(knot_index, x);
     }
-    for (int i = m-p; i < m; i++) {
-    	curve->SetKnot(i, 1.0);
+    for (int i = m - p; i < m; i++) {
+	curve->SetKnot(i, 1.0);
     }
 
-	LIST_OF_POINTS::iterator i;
-	int t=0;
-	for(i=control_points_list.begin(); i != control_points_list.end(); ++i) {
-		curve->SetCV(t, ON_3dPoint((*i)->X()*LocalUnits::length,(*i)->Y()*LocalUnits::length,(*i)->Z()*LocalUnits::length));
-		t++;
-	}
-	ON_id = brep->AddEdgeCurve(curve);
+    LIST_OF_POINTS::iterator i;
+    int t = 0;
+    for (i = control_points_list.begin(); i != control_points_list.end(); ++i) {
+	curve->SetCV(t, ON_3dPoint((*i)->X() * LocalUnits::length, (*i)->Y() * LocalUnits::length, (*i)->Z() * LocalUnits::length));
+	t++;
+    }
+    ON_id = brep->AddEdgeCurve(curve);
 
-	return true;
+    return true;
 }
 
 bool
 BSplineCurveWithKnots::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id >= 0)
-		return true;
+    if (ON_id >= 0)
+	return true;
 
-	int t_size = control_points_list.size();
+    int t_size = control_points_list.size();
 
-    ON_NurbsCurve* curve = ON_NurbsCurve::New( 3, false,degree+1,t_size);
+    ON_NurbsCurve* curve = ON_NurbsCurve::New(3, false, degree + 1, t_size);
 
-    if ( closed_curve == 1 ) {
-		LIST_OF_INTEGERS::iterator m = knot_multiplicities.begin();
-		LIST_OF_REALS::iterator r = knots.begin();
-		int multiplicity = (*m);
-		double knot_value = (*r);
+    if (closed_curve == 1) {
+	LIST_OF_INTEGERS::iterator m = knot_multiplicities.begin();
+	LIST_OF_REALS::iterator r = knots.begin();
+	int multiplicity = (*m);
+	double knot_value = (*r);
 
-		if ((multiplicity < degree) && (knot_value < 0.0)) {
-			//skip fist multiplicity and knot value
-			m++;
-			r++;
-		}
-		int knot_index = 0;
-		while (m != knot_multiplicities.end()) {
-			LIST_OF_INTEGERS::iterator n=m;
-			n++;
-			multiplicity = (*m);
-			knot_value = (*r);
-			if (n == knot_multiplicities.end() && (multiplicity < degree) && (knot_value > 1.0) ) {
-				break;
-			}
-			if ((multiplicity > degree) || (n == knot_multiplicities.end()))
-				multiplicity = degree;
-			for (int j = 0; j < multiplicity; j++,knot_index++) {
-				curve->SetKnot(knot_index, knot_value);
-			}
-			r++;
-			m++;
-		}
+	if ((multiplicity < degree) && (knot_value < 0.0)) {
+	    //skip fist multiplicity and knot value
+	    m++;
+	    r++;
+	}
+	int knot_index = 0;
+	while (m != knot_multiplicities.end()) {
+	    LIST_OF_INTEGERS::iterator n = m;
+	    n++;
+	    multiplicity = (*m);
+	    knot_value = (*r);
+	    if (n == knot_multiplicities.end() && (multiplicity < degree) && (knot_value > 1.0)) {
+		break;
+	    }
+	    if ((multiplicity > degree) || (n == knot_multiplicities.end()))
+		multiplicity = degree;
+	    for (int j = 0; j < multiplicity; j++, knot_index++) {
+		curve->SetKnot(knot_index, knot_value);
+	    }
+	    r++;
+	    m++;
+	}
     } else {
-		// knot index ( >= 0 and < Order + CV_count - 2 )
-		LIST_OF_INTEGERS::iterator m = knot_multiplicities.begin();
-		LIST_OF_REALS::iterator r = knots.begin();
-		int knot_index = 0;
-		while (m != knot_multiplicities.end()) {
-			LIST_OF_INTEGERS::iterator n=m;
-			n++;
-			int multiplicity = (*m);
-			double knot_value = (*r);
-			if ((multiplicity > degree) || (n == knot_multiplicities.end()))
-				multiplicity = degree;
-			for (int j = 0; j < multiplicity; j++,knot_index++) {
-				curve->SetKnot(knot_index, knot_value);
-			}
-			r++;
-			m++;
-		}
-    }
-	LIST_OF_POINTS::iterator i;
-	int t=0;
-	for(i=control_points_list.begin(); i != control_points_list.end(); ++i) {
-		curve->SetCV(t, ON_3dPoint((*i)->X()*LocalUnits::length,(*i)->Y()*LocalUnits::length,(*i)->Z()*LocalUnits::length));
-		t++;
+	// knot index ( >= 0 and < Order + CV_count - 2 )
+	LIST_OF_INTEGERS::iterator m = knot_multiplicities.begin();
+	LIST_OF_REALS::iterator r = knots.begin();
+	int knot_index = 0;
+	while (m != knot_multiplicities.end()) {
+	    LIST_OF_INTEGERS::iterator n = m;
+	    n++;
+	    int multiplicity = (*m);
+	    double knot_value = (*r);
+	    if ((multiplicity > degree) || (n == knot_multiplicities.end()))
+		multiplicity = degree;
+	    for (int j = 0; j < multiplicity; j++, knot_index++) {
+		curve->SetKnot(knot_index, knot_value);
+	    }
+	    r++;
+	    m++;
 	}
+    }
+    LIST_OF_POINTS::iterator i;
+    int t = 0;
+    for (i = control_points_list.begin(); i != control_points_list.end(); ++i) {
+	curve->SetCV(t, ON_3dPoint((*i)->X() * LocalUnits::length, (*i)->Y() * LocalUnits::length, (*i)->Z() * LocalUnits::length));
+	t++;
+    }
 
-	ON_id = brep->AddEdgeCurve(curve);
+    ON_id = brep->AddEdgeCurve(curve);
 
-	return true;
+    return true;
 }
 
 bool
 QuasiUniformCurve::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id >= 0)
-		return true;
-
-	if (!BSplineCurve::LoadONBrep(brep)) {
-		cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << " id: " << id << endl;
-		return false;
-	}
+    if (ON_id >= 0)
 	return true;
+
+    if (!BSplineCurve::LoadONBrep(brep)) {
+	cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << " id: " << id << endl;
+	return false;
+    }
+    return true;
 }
 
 bool
 RationalBezierCurve::LoadONBrep(ON_Brep *brep)
 {
-	cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << " id: " << id << endl;
-	return false;
+    cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << " id: " << id << endl;
+    return false;
 }
 
 bool
 RationalBSplineCurve::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id >= 0)
-		return true;
+    if (ON_id >= 0)
+	return true;
 
-	int t_size = control_points_list.size();
+    int t_size = control_points_list.size();
 
-    ON_NurbsCurve* curve = ON_NurbsCurve::New( 3, true,degree+1,t_size);
+    ON_NurbsCurve* curve = ON_NurbsCurve::New(3, true, degree + 1, t_size);
 
     // knot index ( >= 0 and < Order + CV_count - 2 )
     // generate u-knots
@@ -278,138 +279,139 @@
     int p = degree;
     int m = n + p - 1;
     for (int i = 0; i < p; i++) {
-    	curve->SetKnot(i, 0.0);
+	curve->SetKnot(i, 0.0);
     }
-    for (int j = 1; j < n-p; j++) {
-    	double x = (double)j/(double)(n-p);
-    	int knot_index = j+p-1;
-    	curve->SetKnot(knot_index, x);
+    for (int j = 1; j < n - p; j++) {
+	double x = (double) j / (double) (n - p);
+	int knot_index = j + p - 1;
+	curve->SetKnot(knot_index, x);
     }
-    for (int i = m-p; i < m; i++) {
-    	curve->SetKnot(i, 1.0);
+    for (int i = m - p; i < m; i++) {
+	curve->SetKnot(i, 1.0);
     }
 
-	LIST_OF_POINTS::iterator i;
-	LIST_OF_REALS::iterator r = weights_data.begin();
-	int t=0;
-	for(i=control_points_list.begin(); i != control_points_list.end(); ++i) {
-		double w = (*r);
-		curve->SetCV(t, ON_4dPoint((*i)->X()*LocalUnits::length*w,(*i)->Y()*LocalUnits::length*w,(*i)->Z()*LocalUnits::length*w,w));
-		t++;
-		r++;
-	}
+    LIST_OF_POINTS::iterator i;
+    LIST_OF_REALS::iterator r = weights_data.begin();
+    int t = 0;
+    for (i = control_points_list.begin(); i != control_points_list.end(); ++i) {
+	double w = (*r);
+	curve->SetCV(t, ON_4dPoint((*i)->X() * LocalUnits::length * w, (*i)->Y() * LocalUnits::length * w, (*i)->Z() * LocalUnits::length * w, w));
+	t++;
+	r++;
+    }
 
-	ON_id = brep->AddEdgeCurve(curve);
+    ON_id = brep->AddEdgeCurve(curve);
 
-	return true;
+    return true;
 }
 
 bool
 RationalBSplineCurveWithKnots::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id >= 0 )
-		return true;
+    if (ON_id >= 0)
+	return true;
 
-	int t_size = control_points_list.size();
+    int t_size = control_points_list.size();
 
-    ON_NurbsCurve* curve = ON_NurbsCurve::New( 3, true,degree+1,t_size);
+    ON_NurbsCurve* curve = ON_NurbsCurve::New(3, true, degree + 1, t_size);
 
-    if ( closed_curve == 1 ) {
-		LIST_OF_INTEGERS::iterator m = knot_multiplicities.begin();
-		LIST_OF_REALS::iterator r = knots.begin();
-		int multiplicity = (*m);
-		double knot_value = (*r);
+    if (closed_curve == 1) {
+	LIST_OF_INTEGERS::iterator m = knot_multiplicities.begin();
+	LIST_OF_REALS::iterator r = knots.begin();
+	int multiplicity = (*m);
+	double knot_value = (*r);
 
-		if ((multiplicity < degree) && (knot_value < 0.0)) {
-			//skip fist multiplicity and knot value
-			m++;
-			r++;
-		}
-		int knot_index = 0;
-		while (m != knot_multiplicities.end()) {
-			LIST_OF_INTEGERS::iterator n=m;
-			n++;
-			multiplicity = (*m);
-			knot_value = (*r);
-			if (n == knot_multiplicities.end() && (multiplicity < degree) && (knot_value > 1.0) ) {
-				break;
-			}
-			if ((multiplicity > degree) || (n == knot_multiplicities.end()))
-				multiplicity = degree;
-			for (int j = 0; j < multiplicity; j++,knot_index++) {
-				curve->SetKnot(knot_index, knot_value);
-			}
-			r++;
-			m++;
-		}
+	if ((multiplicity < degree) && (knot_value < 0.0)) {
+	    //skip fist multiplicity and knot value
+	    m++;
+	    r++;
+	}
+	int knot_index = 0;
+	while (m != knot_multiplicities.end()) {
+	    LIST_OF_INTEGERS::iterator n = m;
+	    n++;
+	    multiplicity = (*m);
+	    knot_value = (*r);
+	    if (n == knot_multiplicities.end() && (multiplicity < degree) && (knot_value > 1.0)) {
+		break;
+	    }
+	    if ((multiplicity > degree) || (n == knot_multiplicities.end()))
+		multiplicity = degree;
+	    for (int j = 0; j < multiplicity; j++, knot_index++) {
+		curve->SetKnot(knot_index, knot_value);
+	    }
+	    r++;
+	    m++;
+	}
     } else {
-		LIST_OF_INTEGERS::iterator m = knot_multiplicities.begin();
-		LIST_OF_REALS::iterator r = knots.begin();
-		int knot_index = 0;
-		while (m != knot_multiplicities.end()) {
-			int multiplicity = (*m);
-			double knot_value = (*r);
-			if (multiplicity > degree) multiplicity = degree;
-			for (int j = 0; j < multiplicity; j++,knot_index++) {
-				curve->SetKnot(knot_index, knot_value);
-			}
-			r++;
-			m++;
-		}
+	LIST_OF_INTEGERS::iterator m = knot_multiplicities.begin();
+	LIST_OF_REALS::iterator r = knots.begin();
+	int knot_index = 0;
+	while (m != knot_multiplicities.end()) {
+	    int multiplicity = (*m);
+	    double knot_value = (*r);
+	    if (multiplicity > degree)
+		multiplicity = degree;
+	    for (int j = 0; j < multiplicity; j++, knot_index++) {
+		curve->SetKnot(knot_index, knot_value);
+	    }
+	    r++;
+	    m++;
+	}
     }
 
-	LIST_OF_POINTS::iterator i;
-	LIST_OF_REALS::iterator r = weights_data.begin();
-	int t=0;
-	for(i=control_points_list.begin(); i != control_points_list.end(); ++i) {
-		double w = (*r);
-		curve->SetCV(t, ON_4dPoint((*i)->X()*LocalUnits::length*w,(*i)->Y()*LocalUnits::length*w,(*i)->Z()*LocalUnits::length*w,w));
-		t++;
-		r++;
-	}
+    LIST_OF_POINTS::iterator i;
+    LIST_OF_REALS::iterator r = weights_data.begin();
+    int t = 0;
+    for (i = control_points_list.begin(); i != control_points_list.end(); ++i) {
+	double w = (*r);
+	curve->SetCV(t, ON_4dPoint((*i)->X() * LocalUnits::length * w, (*i)->Y() * LocalUnits::length * w, (*i)->Z() * LocalUnits::length * w, w));
+	t++;
+	r++;
+    }
 
-	ON_id = brep->AddEdgeCurve(curve);
+    ON_id = brep->AddEdgeCurve(curve);
 
-	return true;
+    return true;
 }
 
 bool
 RationalQuasiUniformCurve::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id >= 0)
-		return true;
-
-	if (!RationalBSplineCurve::LoadONBrep(brep)) {
-		cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << " id: " << id << endl;
-		return false;
-	}
+    if (ON_id >= 0)
 	return true;
+
+    if (!RationalBSplineCurve::LoadONBrep(brep)) {
+	cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << " id: " << id << endl;
+	return false;
+    }
+    return true;
 }
 
 bool
 RationalUniformCurve::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id >= 0)
-		return true;
-
-	if (!RationalBSplineCurve::LoadONBrep(brep)) {
-		cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << " id: " << id << endl;
-		return false;
-	}
+    if (ON_id >= 0)
 	return true;
+
+    if (!RationalBSplineCurve::LoadONBrep(brep)) {
+	cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << " id: " << id << endl;
+	return false;
+    }
+    return true;
 }
 
 bool
 UniformCurve::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id >= 0)
-		return true;
-
-	if (!BSplineCurve::LoadONBrep(brep)) {
-		cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << " id: " << id << endl;
-		return false;
-	}
+    if (ON_id >= 0)
 	return true;
+
+    if (!BSplineCurve::LoadONBrep(brep)) {
+	cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << " id: " << id << endl;
+	return false;
+    }
+    return true;
 }
 
 //
@@ -418,19 +420,19 @@
 bool
 BezierSurface::LoadONBrep(ON_Brep *brep)
 {
-	//TODO: add bezier surface
-	//ON_BezierSurface* surf = ON_BezierSurface::New( 3, false,u_degree+1,v_degree+1);
-	cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << endl;
-	return false;
+    //TODO: add bezier surface
+    //ON_BezierSurface* surf = ON_BezierSurface::New( 3, false,u_degree+1,v_degree+1);
+    cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << endl;
+    return false;
 }
 
 bool
 BSplineSurface::LoadONBrep(ON_Brep *brep)
 {
-	int u_size = control_points_list->size();
-	int v_size = (*control_points_list->begin())->size();
+    int u_size = control_points_list->size();
+    int v_size = (*control_points_list->begin())->size();
 
-    ON_NurbsSurface* surf = ON_NurbsSurface::New( 3, false,u_degree+1,v_degree+1,u_size,v_size);
+    ON_NurbsSurface* surf = ON_NurbsSurface::New(3, false, u_degree + 1, v_degree + 1, u_size, v_size);
 
     // knot index ( >= 0 and < Order + CV_count - 2 )
     // generate u-knots
@@ -438,189 +440,193 @@
     int p = u_degree;
     int m = n + p - 1;
     for (int i = 0; i < p; i++) {
-    	surf->SetKnot(0, i, 0.0);
+	surf->SetKnot(0, i, 0.0);
     }
-    for (int j = 1; j < n-p; j++) {
-    	double x = (double)j/(double)(n-p);
-    	int knot_index = j+p-1;
-    	surf->SetKnot(0, knot_index, x);
+    for (int j = 1; j < n - p; j++) {
+	double x = (double) j / (double) (n - p);
+	int knot_index = j + p - 1;
+	surf->SetKnot(0, knot_index, x);
     }
-    for (int i = m-p; i < m; i++) {
-    	surf->SetKnot(0, i, 1.0);
+    for (int i = m - p; i < m; i++) {
+	surf->SetKnot(0, i, 1.0);
     }
     // generate v-knots
     n = v_size;
     p = v_degree;
     m = n + p - 1;
     for (int i = 0; i < p; i++) {
-    	surf->SetKnot(1, i, 0.0);
+	surf->SetKnot(1, i, 0.0);
     }
-    for (int j = 1; j < n-p; j++) {
-    	double x = (double)j/(double)(n-p);
-    	int knot_index = j+p-1;
-    	surf->SetKnot(1, knot_index, x);
+    for (int j = 1; j < n - p; j++) {
+	double x = (double) j / (double) (n - p);
+	int knot_index = j + p - 1;
+	surf->SetKnot(1, knot_index, x);
     }
-    for (int i = m-p; i < m; i++) {
-    	surf->SetKnot(1, i, 1.0);
+    for (int i = m - p; i < m; i++) {
+	surf->SetKnot(1, i, 1.0);
     }
 
-	LIST_OF_LIST_OF_POINTS::iterator i;
-	int u=0;
-	for(i=control_points_list->begin(); i != control_points_list->end(); ++i) {
-		LIST_OF_POINTS::iterator j;
-		LIST_OF_POINTS *p = *i;
-		int v=0;
-		for(j=p->begin(); j != p->end(); ++j) {
-			surf->SetCV(u, v, ON_3dPoint((*j)->X()*LocalUnits::length,(*j)->Y()*LocalUnits::length,(*j)->Z()*LocalUnits::length));
-			v++;
-		}
-		u++;
+    LIST_OF_LIST_OF_POINTS::iterator i;
+    int u = 0;
+    for (i = control_points_list->begin(); i != control_points_list->end(); ++i) {
+	LIST_OF_POINTS::iterator j;
+	LIST_OF_POINTS *p = *i;
+	int v = 0;
+	for (j = p->begin(); j != p->end(); ++j) {
+	    surf->SetCV(u, v, ON_3dPoint((*j)->X() * LocalUnits::length, (*j)->Y() * LocalUnits::length, (*j)->Z() * LocalUnits::length));
+	    v++;
 	}
+	u++;
+    }
     ON_id = brep->AddSurface(surf);
 
-	return true;
+    return true;
 }
 
 bool
 BSplineSurfaceWithKnots::LoadONBrep(ON_Brep *brep)
 {
-	int u_size = control_points_list->size();
-	int v_size = (*control_points_list->begin())->size();
+    int u_size = control_points_list->size();
+    int v_size = (*control_points_list->begin())->size();
 
-    ON_NurbsSurface* surf = ON_NurbsSurface::New( 3, false,u_degree+1,v_degree+1,u_size,v_size);
+    ON_NurbsSurface* surf = ON_NurbsSurface::New(3, false, u_degree + 1, v_degree + 1, u_size, v_size);
 
-    if ( u_closed == 1 ) {
- 		LIST_OF_INTEGERS::iterator m = u_multiplicities.begin();
- 		LIST_OF_REALS::iterator r = u_knots.begin();
+    if (u_closed == 1) {
+	LIST_OF_INTEGERS::iterator m = u_multiplicities.begin();
+	LIST_OF_REALS::iterator r = u_knots.begin();
 
- 		int multiplicity = (*m);
- 		double knot_value = (*r);
- 		if ((multiplicity < u_degree) && (knot_value < 0.0)) {
- 			//skip fist multiplicity and knot value
- 			m++;
- 			r++;
- 		}
- 		int knot_index = 0;
- 		while (m != u_multiplicities.end()) {
- 			LIST_OF_INTEGERS::iterator n=m;
- 			n++;
+	int multiplicity = (*m);
+	double knot_value = (*r);
+	if ((multiplicity < u_degree) && (knot_value < 0.0)) {
+	    //skip fist multiplicity and knot value
+	    m++;
+	    r++;
+	}
+	int knot_index = 0;
+	while (m != u_multiplicities.end()) {
+	    LIST_OF_INTEGERS::iterator n = m;
+	    n++;
 
- 			multiplicity = (*m);
- 			knot_value = (*r);
+	    multiplicity = (*m);
+	    knot_value = (*r);
 
- 			if (n == this->u_multiplicities.end() && (multiplicity < u_degree) && (knot_value > 1.0) ) {
- 				break;
- 			}
+	    if (n == this->u_multiplicities.end() && (multiplicity < u_degree) && (knot_value > 1.0)) {
+		break;
+	    }
 
- 			if (multiplicity > u_degree) multiplicity = u_degree;
- 			for (int j = 0; j < multiplicity; j++) {
- 				surf->SetKnot(0, knot_index++, knot_value);
- 			}
- 			r++;
- 			m++;
- 		}
-      } else {
- 		LIST_OF_INTEGERS::iterator m = u_multiplicities.begin();
- 		LIST_OF_REALS::iterator r = u_knots.begin();
- 		int knot_index = 0;
- 		while (m != u_multiplicities.end()) {
- 			int multiplicity = (*m);
- 			double knot_value = (*r);
- 			if (multiplicity > u_degree) multiplicity = u_degree;
- 			for (int j = 0; j < multiplicity; j++) {
- 				surf->SetKnot(0, knot_index++, knot_value);
- 			}
- 			r++;
- 			m++;
- 		}
-     }
-    if ( v_closed == 1 ) {
- 		LIST_OF_INTEGERS::iterator m = v_multiplicities.begin();
- 		LIST_OF_REALS::iterator r = v_knots.begin();
+	    if (multiplicity > u_degree)
+		multiplicity = u_degree;
+	    for (int j = 0; j < multiplicity; j++) {
+		surf->SetKnot(0, knot_index++, knot_value);
+	    }
+	    r++;
+	    m++;
+	}
+    } else {
+	LIST_OF_INTEGERS::iterator m = u_multiplicities.begin();
+	LIST_OF_REALS::iterator r = u_knots.begin();
+	int knot_index = 0;
+	while (m != u_multiplicities.end()) {
+	    int multiplicity = (*m);
+	    double knot_value = (*r);
+	    if (multiplicity > u_degree)
+		multiplicity = u_degree;
+	    for (int j = 0; j < multiplicity; j++) {
+		surf->SetKnot(0, knot_index++, knot_value);
+	    }
+	    r++;
+	    m++;
+	}
+    }
+    if (v_closed == 1) {
+	LIST_OF_INTEGERS::iterator m = v_multiplicities.begin();
+	LIST_OF_REALS::iterator r = v_knots.begin();
 
- 		int multiplicity = (*m);
- 		double knot_value = (*r);
- 		if ((multiplicity < v_degree) && (knot_value < 0.0)) {
- 			//skip fist multiplicity and knot value
- 			m++;
- 			r++;
- 		}
- 		int knot_index = 0;
- 		while (m != v_multiplicities.end()) {
- 			LIST_OF_INTEGERS::iterator n=m;
- 			n++;
+	int multiplicity = (*m);
+	double knot_value = (*r);
+	if ((multiplicity < v_degree) && (knot_value < 0.0)) {
+	    //skip fist multiplicity and knot value
+	    m++;
+	    r++;
+	}
+	int knot_index = 0;
+	while (m != v_multiplicities.end()) {
+	    LIST_OF_INTEGERS::iterator n = m;
+	    n++;
 
- 			int multiplicity = (*m);
- 			double knot_value = (*r);
+	    int multiplicity = (*m);
+	    double knot_value = (*r);
 
- 			if (n == v_multiplicities.end() && (multiplicity < v_degree) && (knot_value > 1.0) ) {
- 				break;
- 			}
+	    if (n == v_multiplicities.end() && (multiplicity < v_degree) && (knot_value > 1.0)) {
+		break;
+	    }
 
- 			if (multiplicity > v_degree) multiplicity = v_degree;
- 			for (int j = 0; j < multiplicity; j++,knot_index++) {
- 				surf->SetKnot(1, knot_index, knot_value);
- 			}
- 			r++;
- 			m++;
- 		}
-     } else {
- 		LIST_OF_INTEGERS::iterator m = v_multiplicities.begin();
- 		LIST_OF_REALS::iterator r = v_knots.begin();
- 		int knot_index = 0;
-  		while (m != v_multiplicities.end()) {
- 			int multiplicity = (*m);
- 			double knot_value = (*r);
- 			if (multiplicity > v_degree) multiplicity = v_degree;
- 			for (int j = 0; j < multiplicity; j++,knot_index++) {
- 				surf->SetKnot(1, knot_index, knot_value);
- 			}
- 			r++;
- 			m++;
- 		}
-     }
-	LIST_OF_LIST_OF_POINTS::iterator i;
-	int u=0;
-	for(i=control_points_list->begin(); i != control_points_list->end(); ++i) {
-		LIST_OF_POINTS::iterator j;
-		LIST_OF_POINTS *p = *i;
-		int v=0;
-		for(j=p->begin(); j != p->end(); ++j) {
-			surf->SetCV(u, v, ON_3dPoint((*j)->X()*LocalUnits::length,(*j)->Y()*LocalUnits::length,(*j)->Z()*LocalUnits::length));
-			v++;
-		}
-		u++;
+	    if (multiplicity > v_degree)
+		multiplicity = v_degree;
+	    for (int j = 0; j < multiplicity; j++, knot_index++) {
+		surf->SetKnot(1, knot_index, knot_value);
+	    }
+	    r++;
+	    m++;
 	}
+    } else {
+	LIST_OF_INTEGERS::iterator m = v_multiplicities.begin();
+	LIST_OF_REALS::iterator r = v_knots.begin();
+	int knot_index = 0;
+	while (m != v_multiplicities.end()) {
+	    int multiplicity = (*m);
+	    double knot_value = (*r);
+	    if (multiplicity > v_degree)
+		multiplicity = v_degree;
+	    for (int j = 0; j < multiplicity; j++, knot_index++) {
+		surf->SetKnot(1, knot_index, knot_value);
+	    }
+	    r++;
+	    m++;
+	}
+    }
+    LIST_OF_LIST_OF_POINTS::iterator i;
+    int u = 0;
+    for (i = control_points_list->begin(); i != control_points_list->end(); ++i) {
+	LIST_OF_POINTS::iterator j;
+	LIST_OF_POINTS *p = *i;
+	int v = 0;
+	for (j = p->begin(); j != p->end(); ++j) {
+	    surf->SetCV(u, v, ON_3dPoint((*j)->X() * LocalUnits::length, (*j)->Y() * LocalUnits::length, (*j)->Z() * LocalUnits::length));
+	    v++;
+	}
+	u++;
+    }
     ON_id = brep->AddSurface(surf);
 
-	return true;
+    return true;
 }
 
 bool
 QuasiUniformSurface::LoadONBrep(ON_Brep *brep)
 {
-	if (!BSplineSurface::LoadONBrep(brep)) {
-		cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-		return false;
-	}
-	return true;
+    if (!BSplineSurface::LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	return false;
+    }
+    return true;
 }
 
 bool
 RationalBezierSurface::LoadONBrep(ON_Brep *brep)
 {
-	//TODO: add rational bezier surface
-	cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << endl;
-	return false;
+    //TODO: add rational bezier surface
+    cerr << "Error: ::LoadONBrep(ON_Brep *brep) not implemented for " << entityname << endl;
+    return false;
 }
 
 bool
 RationalBSplineSurface::LoadONBrep(ON_Brep *brep)
 {
-	int u_size = control_points_list->size();
-	int v_size = (*control_points_list->begin())->size();
+    int u_size = control_points_list->size();
+    int v_size = (*control_points_list->begin())->size();
 
-    ON_NurbsSurface* surf = ON_NurbsSurface::New( 3, false,u_degree+1,v_degree+1,u_size,v_size);
+    ON_NurbsSurface* surf = ON_NurbsSurface::New(3, false, u_degree + 1, v_degree + 1, u_size, v_size);
 
     // knot index ( >= 0 and < Order + CV_count - 2 )
     // generate u-knots
@@ -628,417 +634,431 @@
     int p = u_degree;
     int m = n + p - 1;
     for (int i = 0; i < p; i++) {
-    	surf->SetKnot(0, i, 0.0);
+	surf->SetKnot(0, i, 0.0);
     }
-    for (int j = 1; j < n-p; j++) {
-    	double x = (double)j/(double)(n-p);
-    	int knot_index = j+p-1;
-    	surf->SetKnot(0, knot_index, x);
+    for (int j = 1; j < n - p; j++) {
+	double x = (double) j / (double) (n - p);
+	int knot_index = j + p - 1;
+	surf->SetKnot(0, knot_index, x);
     }
-    for (int i = m-p; i < m; i++) {
-    	surf->SetKnot(0, i, 1.0);
+    for (int i = m - p; i < m; i++) {
+	surf->SetKnot(0, i, 1.0);
     }
     // generate v-knots
     n = v_size;
     p = v_degree;
     m = n + p - 1;
     for (int i = 0; i < p; i++) {
-    	surf->SetKnot(1, i, 0.0);
+	surf->SetKnot(1, i, 0.0);
     }
-    for (int j = 1; j < n-p; j++) {
-    	double x = (double)j/(double)(n-p);
-    	int knot_index = j+p-1;
-    	surf->SetKnot(1, knot_index, x);
+    for (int j = 1; j < n - p; j++) {
+	double x = (double) j / (double) (n - p);
+	int knot_index = j + p - 1;
+	surf->SetKnot(1, knot_index, x);
     }
-    for (int i = m-p; i < m; i++) {
-    	surf->SetKnot(1, i, 1.0);
+    for (int i = m - p; i < m; i++) {
+	surf->SetKnot(1, i, 1.0);
     }
 
-	LIST_OF_LIST_OF_POINTS::iterator i = control_points_list->begin();
-	LIST_OF_LIST_OF_REALS::iterator w = weights_data.begin();
-	LIST_OF_REALS::iterator r;
-	int u=0;
-	for(i=control_points_list->begin(); i != control_points_list->end(); ++i) {
-		LIST_OF_POINTS::iterator j;
-		LIST_OF_POINTS *p = *i;
-		r = (*w)->begin();
-		int v=0;
-		for(j=p->begin(); j != p->end(); ++j,r++,v++) {
-			double w = (*r);
-			surf->SetCV(u, v, ON_4dPoint((*j)->X()*LocalUnits::length*w,(*j)->Y()*LocalUnits::length*w,(*j)->Z()*LocalUnits::length*w,w));
-		}
-		u++;
-		w++;
+    LIST_OF_LIST_OF_POINTS::iterator i = control_points_list->begin();
+    LIST_OF_LIST_OF_REALS::iterator w = weights_data.begin();
+    LIST_OF_REALS::iterator r;
+    int u = 0;
+    for (i = control_points_list->begin(); i != control_points_list->end(); ++i) {
+	LIST_OF_POINTS::iterator j;
+	LIST_OF_POINTS *p = *i;
+	r = (*w)->begin();
+	int v = 0;
+	for (j = p->begin(); j != p->end(); ++j, r++, v++) {
+	    double w = (*r);
+	    surf->SetCV(u, v, ON_4dPoint((*j)->X() * LocalUnits::length * w, (*j)->Y() * LocalUnits::length * w, (*j)->Z() * LocalUnits::length * w, w));
 	}
+	u++;
+	w++;
+    }
     ON_id = brep->AddSurface(surf);
 
-	return true;
+    return true;
 }
 
 bool
 RationalBSplineSurfaceWithKnots::LoadONBrep(ON_Brep *brep)
 {
-	int u_size = control_points_list->size();
-	int v_size = (*control_points_list->begin())->size();
+    int u_size = control_points_list->size();
+    int v_size = (*control_points_list->begin())->size();
 
-	if (self_intersect) {
-	}
-	if (u_closed) {
-	}
-	if (v_closed) {
-	}
+    if (self_intersect) {
+    }
+    if (u_closed) {
+    }
+    if (v_closed) {
+    }
 
-    ON_NurbsSurface* surf = ON_NurbsSurface::New( 3, true,u_degree+1,v_degree+1,u_size,v_size);
+    ON_NurbsSurface* surf = ON_NurbsSurface::New(3, true, u_degree + 1, v_degree + 1, u_size, v_size);
 
     // knot index ( >= 0 and < Order + CV_count - 2 )
     LIST_OF_INTEGERS::iterator m = u_multiplicities.begin();
     LIST_OF_REALS::iterator r = u_knots.begin();
     int knot_index = 0;
     while (m != u_multiplicities.end()) {
-    	int multiplicity = (*m);
-		double knot_value = (*r);
-		if (multiplicity > u_degree) multiplicity = u_degree;
-    	for (int j = 0; j < multiplicity; j++,knot_index++) {
-    		surf->SetKnot(0, knot_index, knot_value);
-    	}
-    	r++;
-    	m++;
+	int multiplicity = (*m);
+	double knot_value = (*r);
+	if (multiplicity > u_degree)
+	    multiplicity = u_degree;
+	for (int j = 0; j < multiplicity; j++, knot_index++) {
+	    surf->SetKnot(0, knot_index, knot_value);
+	}
+	r++;
+	m++;
     }
     m = v_multiplicities.begin();
     r = v_knots.begin();
     knot_index = 0;
     while (m != v_multiplicities.end()) {
-    	int multiplicity = (*m);
-		double knot_value = (*r);
-		if (multiplicity > v_degree) multiplicity = v_degree;
-    	for (int j = 0; j < multiplicity; j++) {
-    		surf->SetKnot(1, knot_index++, knot_value);
-    	}
-    	r++;
-    	m++;
+	int multiplicity = (*m);
+	double knot_value = (*r);
+	if (multiplicity > v_degree)
+	    multiplicity = v_degree;
+	for (int j = 0; j < multiplicity; j++) {
+	    surf->SetKnot(1, knot_index++, knot_value);
+	}
+	r++;
+	m++;
     }
 
-	LIST_OF_LIST_OF_POINTS::iterator i = control_points_list->begin();
-	LIST_OF_LIST_OF_REALS::iterator w = weights_data.begin();
-	int u=0;
-	for(i=control_points_list->begin(); i != control_points_list->end(); ++i) {
-		LIST_OF_POINTS::iterator j;
-		LIST_OF_POINTS *p = *i;
-		r = (*w)->begin();
-		int v=0;
-		for(j=p->begin(); j != p->end(); ++j,r++,v++) {
-			double w = (*r);
-			surf->SetCV(u, v, ON_4dPoint((*j)->X()*LocalUnits::length*w,(*j)->Y()*LocalUnits::length*w,(*j)->Z()*LocalUnits::length*w,w));
-		}
-		u++;
-		w++;
+    LIST_OF_LIST_OF_POINTS::iterator i = control_points_list->begin();
+    LIST_OF_LIST_OF_REALS::iterator w = weights_data.begin();
+    int u = 0;
+    for (i = control_points_list->begin(); i != control_points_list->end(); ++i) {
+	LIST_OF_POINTS::iterator j;
+	LIST_OF_POINTS *p = *i;
+	r = (*w)->begin();
+	int v = 0;
+	for (j = p->begin(); j != p->end(); ++j, r++, v++) {
+	    double w = (*r);
+	    surf->SetCV(u, v, ON_4dPoint((*j)->X() * LocalUnits::length * w, (*j)->Y() * LocalUnits::length * w, (*j)->Z() * LocalUnits::length * w, w));
 	}
+	u++;
+	w++;
+    }
 
-	ON_id = brep->AddSurface(surf);
+    ON_id = brep->AddSurface(surf);
 
-	return true;
+    return true;
 }
 
 bool
 RationalQuasiUniformSurface::LoadONBrep(ON_Brep *brep)
 {
-	if (!RationalBSplineSurface::LoadONBrep(brep)) {
-		cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-		return false;
-	}
-	return true;
+    if (!RationalBSplineSurface::LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	return false;
+    }
+    return true;
 }
 
 bool
 RationalUniformSurface::LoadONBrep(ON_Brep *brep)
 {
-	if (!RationalBSplineSurface::LoadONBrep(brep)) {
-		cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-		return false;
-	}
-	return true;
+    if (!RationalBSplineSurface::LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	return false;
+    }
+    return true;
 }
 
 bool
 UniformSurface::LoadONBrep(ON_Brep *brep)
 {
-	if (!BSplineSurface::LoadONBrep(brep)) {
-		cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-		return false;
-	}
-	return true;
+    if (!BSplineSurface::LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	return false;
+    }
+    return true;
 }
 void
 FaceSurface::AddFace(ON_Brep *brep)
 {
-	ON_BrepFace& face = brep->NewFace(face_geometry->GetONId());
-	if (same_sense == 1) {
-		face.m_bRev = false;
-	} else {
-		face.m_bRev = true;
-		face.Reverse(0);
-	}
+    ON_BrepFace& face = brep->NewFace(face_geometry->GetONId());
+    if (same_sense == 1) {
+	face.m_bRev = false;
+    } else {
+	face.m_bRev = true;
+	face.Reverse(0);
+    }
 
-	ON_id = face.m_face_index;
+    ON_id = face.m_face_index;
 }
 
 bool
 FaceSurface::LoadONBrep(ON_Brep *brep)
 {
-	// need edge bounds to determine extents for some of the infinitely
-	// defined surfaces like cones/cylinders/planes
-	ON_BoundingBox *bb = GetEdgeBounds(brep);
-	face_geometry->SetCurveBounds(bb);
+    //TODO: remove debugging code
+    if ((false) && (brep->m_F.Count() == 84)) {
+	cerr << "Debug:LoadONBrep for FaceSurface:" << brep->m_F.Count() << endl;
+    }
+    // need edge bounds to determine extents for some of the infinitely
+    // defined surfaces like cones/cylinders/planes
+    ON_BoundingBox *bb = GetEdgeBounds(brep);
+    face_geometry->SetCurveBounds(bb);
 
-	if (!face_geometry->LoadONBrep(brep)) {
-		cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-		return false;
-	}
+    if (!face_geometry->LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	return false;
+    }
 
-	AddFace(brep);
+    AddFace(brep);
 
-	//TODO: remove debugging code
-	if ((false) && ( ON_id == 39 )) {
-		cerr << "We are here" << endl;
-	}
-	if (!Face::LoadONBrep(brep)) {
-		cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-		return false;
-	}
+    //TODO: remove debugging code
+    if ((false) && (ON_id == 72)) {
+	cerr << "Debug:LoadONBrep for FaceSurface:" << ON_id << endl;
+    }
+    if (!Face::LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	return false;
+    }
 
-	return true;
+    return true;
 }
 
 void
 Point::AddVertex(ON_Brep *brep)
 {
-	cerr << "Warning: " << entityname << "::AddVertex()  should be overridden by parent class." << endl;
+    cerr << "Warning: " << entityname << "::AddVertex()  should be overridden by parent class." << endl;
 }
 
 void
 CartesianPoint::AddVertex(ON_Brep *brep)
 {
-	if (vertex_index < 0) {
-		ON_3dPoint p(coordinates[0]*LocalUnits::length,coordinates[1]*LocalUnits::length,coordinates[2]*LocalUnits::length);
-		ON_BrepVertex& v = brep->NewVertex(p);
-		vertex_index = v.m_vertex_index;
-		v.m_tolerance = 1e-3;
-		ON_id = v.m_vertex_index;
-	}
+    if (vertex_index < 0) {
+	ON_3dPoint p(coordinates[0] * LocalUnits::length, coordinates[1] * LocalUnits::length, coordinates[2] * LocalUnits::length);
+	ON_BrepVertex& v = brep->NewVertex(p);
+	vertex_index = v.m_vertex_index;
+	v.m_tolerance = 1e-3;
+	ON_id = v.m_vertex_index;
+    }
 }
 
 void
 BSplineCurve::AddPolyLine(ON_Brep *brep)
 {
-	if (ON_id < 0) {
-		int num_control_points = control_points_list.size();
+    if (ON_id < 0) {
+	int num_control_points = control_points_list.size();
 
-	    if ((degree == 1) && (num_control_points >= 2)) {
-	    	LIST_OF_POINTS::iterator i = control_points_list.begin();
-	    	CartesianPoint *cp = (*i);
-	    	while ((++i) != control_points_list.end()) {
-	    		ON_3dPoint start(cp->X()*LocalUnits::length,cp->Y()*LocalUnits::length,cp->Z()*LocalUnits::length);
-	    		cp = (*i);
-	    		ON_3dPoint end(cp->X()*LocalUnits::length,cp->Y()*LocalUnits::length,cp->Z()*LocalUnits::length);
-	    		ON_LineCurve* line = new ON_LineCurve(ON_3dPoint(start),ON_3dPoint(end));
-	    		brep->m_C3.Append(line);
-	    	}
-	    } else if (num_control_points > 2) {
-			ON_NurbsCurve* c = ON_NurbsCurve::New(3,
-							  false,
-							  degree+1,
-							  num_control_points);
-	    } else {
-			cerr << "Error: " << entityname << "::LoadONBrep() - Error loading polyLine." << endl;
+	if ((degree == 1) && (num_control_points >= 2)) {
+	    LIST_OF_POINTS::iterator i = control_points_list.begin();
+	    CartesianPoint *cp = (*i);
+	    while ((++i) != control_points_list.end()) {
+		ON_3dPoint start(cp->X() * LocalUnits::length, cp->Y() * LocalUnits::length, cp->Z() * LocalUnits::length);
+		cp = (*i);
+		ON_3dPoint end(cp->X() * LocalUnits::length, cp->Y() * LocalUnits::length, cp->Z() * LocalUnits::length);
+		ON_LineCurve* line = new ON_LineCurve(ON_3dPoint(start), ON_3dPoint(end));
+		brep->m_C3.Append(line);
 	    }
+	} else if (num_control_points > 2) {
+	    ON_NurbsCurve* c = ON_NurbsCurve::New(3, false, degree + 1, num_control_points);
+	} else {
+	    cerr << "Error: " << entityname << "::LoadONBrep() - Error loading polyLine." << endl;
 	}
+    }
 }
 
 void
 VertexPoint::AddVertex(ON_Brep *brep)
 {
-	vertex_geometry->AddVertex(brep);
+    vertex_geometry->AddVertex(brep);
 }
 
 ON_BoundingBox *
-Face::GetEdgeBounds(ON_Brep *brep) {
-	ON_BoundingBox *u = NULL;
-	LIST_OF_FACE_BOUNDS::iterator i;
-	for(i=bounds.begin();i!=bounds.end();i++){
-		ON_BoundingBox *bb = (*i)->GetEdgeBounds(brep);
-		if (bb != NULL) {
-			if (u == NULL)
-				u = new ON_BoundingBox();
-			u->Union(*bb);
-		}
-		delete bb;
+Face::GetEdgeBounds(ON_Brep *brep)
+{
+    ON_BoundingBox *u = NULL;
+    LIST_OF_FACE_BOUNDS::iterator i;
+    for (i = bounds.begin(); i != bounds.end(); i++) {
+	ON_BoundingBox *bb = (*i)->GetEdgeBounds(brep);
+	if (bb != NULL) {
+	    if (u == NULL)
+		u = new ON_BoundingBox();
+	    u->Union(*bb);
 	}
-	return u;
+	delete bb;
+    }
+    return u;
 }
 
 bool
 Face::LoadONBrep(ON_Brep *brep)
 {
-	//TODO: Check for Outer bound if none check for
-	// direction perhaps offer input option possibly
-	// check for outer spanning to bounds
-	int cnt = 0;
-	LIST_OF_FACE_BOUNDS::reverse_iterator i;
-	for(i=bounds.rbegin();i!=bounds.rend();i++){
-		(*i)->SetFaceIndex(ON_id);
-		if (!(*i)->LoadONBrep(brep)) {
-			//(*i)->GetONId()
-			cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-			return false;
-		}
-		ON_BrepFace& face = brep->m_F[GetONId()];
-		cnt++;
+    //TODO: Check for Outer bound if none check for
+    // direction perhaps offer input option possibly
+    // check for outer spanning to bounds
+    int cnt = 0;
+    LIST_OF_FACE_BOUNDS::reverse_iterator i;
+    for (i = bounds.rbegin(); i != bounds.rend(); i++) {
+	(*i)->SetFaceIndex(ON_id);
+	if (!(*i)->LoadONBrep(brep)) {
+	    //(*i)->GetONId()
+	    cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	    return false;
 	}
-	return true;
+	ON_BrepFace& face = brep->m_F[GetONId()];
+	cnt++;
+    }
+    return true;
 }
 
 bool
 FaceOuterBound::LoadONBrep(ON_Brep *brep)
 {
-	SetOuter();
+    SetOuter();
 
-	if (!FaceBound::LoadONBrep(brep)) {
-		cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-		return false;
-	}
-	return true;
+    if (!FaceBound::LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	return false;
+    }
+    return true;
 }
 
 ON_BoundingBox *
-FaceBound::GetEdgeBounds(ON_Brep *brep) {
-	return bound->GetEdgeBounds(brep);
+FaceBound::GetEdgeBounds(ON_Brep *brep)
+{
+    return bound->GetEdgeBounds(brep);
 }
 
 bool
 FaceBound::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id < 0) {
-		enum ON_BrepLoop::TYPE btype;
-		if (IsInner()) {
-			btype = ON_BrepLoop::inner;
-		} else {
-			btype = ON_BrepLoop::outer;
-		}
-		ON_BrepLoop& loop = brep->NewLoop(btype, brep->m_F[ON_face_index]);
-		ON_id = loop.m_loop_index;
-	}
-	bound->SetLoopIndex(ON_id);
-	if (!bound->LoadONBrep(brep)) {
-		cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-		return false;
-	}
+    if (ON_id < 0) {
+	enum ON_BrepLoop::TYPE btype;
 	if (IsInner()) {
-		ON_BrepLoop& loop = brep->m_L[ON_id];
-		if (brep->LoopDirection((const ON_BrepLoop&)loop) > 0) {
-			brep->FlipLoop(loop);
-		}
+	    btype = ON_BrepLoop::inner;
 	} else {
-		ON_BrepLoop& loop = brep->m_L[ON_id];
-		if (brep->LoopDirection((const ON_BrepLoop&)loop) < 0) {
-			brep->FlipLoop(loop);
-		}
+	    btype = ON_BrepLoop::outer;
 	}
-	return true;
+	ON_BrepLoop& loop = brep->NewLoop(btype, brep->m_F[ON_face_index]);
+	ON_id = loop.m_loop_index;
+    }
+    bound->SetLoopIndex(ON_id);
+    if (!bound->LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	return false;
+    }
+    if (IsInner()) {
+	ON_BrepLoop& loop = brep->m_L[ON_id];
+	if (brep->LoopDirection((const ON_BrepLoop&) loop) > 0) {
+	    brep->FlipLoop(loop);
+	}
+    } else {
+	ON_BrepLoop& loop = brep->m_L[ON_id];
+	if (brep->LoopDirection((const ON_BrepLoop&) loop) < 0) {
+	    brep->FlipLoop(loop);
+	}
+    }
+    return true;
 }
 
 bool
 EdgeCurve::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id >= 0)
-		return true; // already loaded
+    if (ON_id >= 0)
+	return true; // already loaded
 
-	edge_geometry->Start(edge_start);
-	edge_geometry->End(edge_end);
-	if (!edge_geometry->LoadONBrep(brep)) {
-		cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-		return false;
-	}
+    if ((false) && (brep->m_E.Count() == 484)) {
+	cerr << "Debug:LoadONBrep for EdgeCurve:" << brep->m_E.Count() << endl;
+    }
 
-	int se,ee,eg;
-	se = edge_start->GetONId();
-	ee = edge_end->GetONId();
-	eg = edge_geometry->GetONId();
+    edge_geometry->Start(edge_start);
+    edge_geometry->End(edge_end);
+    if (!edge_geometry->LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	return false;
+    }
 
-	ON_BrepEdge& edge = brep->NewEdge(brep->m_V[edge_start->GetONId()], brep->m_V[edge_end->GetONId()], edge_geometry->GetONId());
+    int se, ee, eg;
+    se = edge_start->GetONId();
+    ee = edge_end->GetONId();
+    eg = edge_geometry->GetONId();
+
+    ON_BrepEdge& edge = brep->NewEdge(brep->m_V[edge_start->GetONId()], brep->m_V[edge_end->GetONId()], edge_geometry->GetONId());
     edge.m_tolerance = 1e-3; //TODO: - need tolerance definition or constant
     ON_id = edge.m_edge_index;
 
-	return true;
+    return true;
 }
 
 bool
 OrientedEdge::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id >= 0)
-		return true; //already loaded
+    if (ON_id >= 0)
+	return true; //already loaded
 
-	if (!edge_start->LoadONBrep(brep)) {
-		cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-		return false;
-	}
-	if (!edge_end->LoadONBrep(brep)) {
-		cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-		return false;
-	}
-	if ( !edge_element->LoadONBrep(brep) ) {
-		cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-		return false;
-	}
+    if ((false) && (brep->m_E.Count() == 5)) {
+	cerr << "Debug:LoadONBrep for OrientedEdge:" << brep->m_E.Count() << endl;
+    }
 
-	ON_id = edge_element->GetONId();
+    if (!edge_start->LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	return false;
+    }
+    if (!edge_end->LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	return false;
+    }
+    if (!edge_element->LoadONBrep(brep)) {
+	cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	return false;
+    }
 
-	//TODO: remove debugging code
-	if ((false) && (ON_id == 31 )) {
-		cerr << "We are here!!!" << endl;
-	}
-	return true;
+    ON_id = edge_element->GetONId();
+
+    //TODO: remove debugging code
+    if ((false) && (ON_id == 31)) {
+	cerr << "Debug:LoadONBrep for OrientedEdge:" << ON_id << endl;
+    }
+    return true;
 }
 
 ON_BoundingBox *
-Path::GetEdgeBounds(ON_Brep *brep) {
-	ON_BoundingBox *u = NULL;
-	LIST_OF_ORIENTED_EDGES::iterator i;
-	for(i=edge_list.begin();i!=edge_list.end();i++) {
-		if (!(*i)->LoadONBrep(brep)) {
-			cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-			return false;
-		}
-		if (u == NULL)
-			u = new ON_BoundingBox();
-	    const ON_BrepEdge* edge = &brep->m_E[(*i)->GetONId()];
-	    const ON_Curve* curve = edge->EdgeCurveOf();
-	    u->Union(curve->BoundingBox());
+Path::GetEdgeBounds(ON_Brep *brep)
+{
+    ON_BoundingBox *u = NULL;
+    LIST_OF_ORIENTED_EDGES::iterator i;
+    for (i = edge_list.begin(); i != edge_list.end(); i++) {
+	if (!(*i)->LoadONBrep(brep)) {
+	    cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	    return false;
 	}
+	if (u == NULL)
+	    u = new ON_BoundingBox();
+	const ON_BrepEdge* edge = &brep->m_E[(*i)->GetONId()];
+	const ON_Curve* curve = edge->EdgeCurveOf();
+	u->Union(curve->BoundingBox());
+    }
 
-	return u;
+    return u;
 }
 
 bool
 Path::LoadONBrep(ON_Brep *brep)
 {
     ON_TextLog tl;
-	LIST_OF_ORIENTED_EDGES::iterator i;
+    LIST_OF_ORIENTED_EDGES::iterator i;
 
-	for(i=edge_list.begin();i!=edge_list.end();i++) {
-		if (!(*i)->LoadONBrep(brep)) {
-			cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
-			return false;
-		}
+    for (i = edge_list.begin(); i != edge_list.end(); i++) {
+	if (!(*i)->LoadONBrep(brep)) {
+	    cerr << "Error: " << entityname << "::LoadONBrep() - Error loading openNURBS brep." << endl;
+	    return false;
 	}
-	//TODO: remove debugging code
-	if ((false) && (id == 124)) {
-		cerr << "We are here." << endl;
-	}
-	if (!LoadONTrimmingCurves(brep)) {
-		return false;
-	}
+    }
+    //TODO: remove debugging code
+    if ((false) && (id == 26089)) {
+	cerr << "Debug:LoadONBrep for Path:" << id << endl;
+    }
+    if (!LoadONTrimmingCurves(brep)) {
+	return false;
+    }
 
-	return true;
+    return true;
 }
 
 bool
@@ -1048,40 +1068,40 @@
     const ON_BrepFace* face = loop->Face();
     const ON_Surface* surface = face->SurfaceOf();
     double ang_min = 0.0;
-    double smin,smax;
+    double smin, smax;
 
-    if ( surface->IsCone() || surface->IsCylinder()) {
-    	if (surface->IsClosed(0) ) {
-			surface->GetDomain(0,&smin,&smax);
-    	} else {
-    		surface->GetDomain(1,&smin,&smax);
-    	}
+    if (surface->IsCone() || surface->IsCylinder()) {
+	if (surface->IsClosed(0)) {
+	    surface->GetDomain(0, &smin, &smax);
+	} else {
+	    surface->GetDomain(1, &smin, &smax);
+	}
 
-		LIST_OF_ORIENTED_EDGES::iterator i;
-		for (i = edge_list.begin(); i != edge_list.end(); i++) {
-			// grab the curve for this edge,face and surface
-			const ON_BrepEdge* edge = &brep->m_E[(*i)->GetONId()];
-			const ON_Curve* curve = edge->EdgeCurveOf();
-			double tmin, tmax;
-			curve->GetDomain(&tmin, &tmax);
+	LIST_OF_ORIENTED_EDGES::iterator i;
+	for (i = edge_list.begin(); i != edge_list.end(); i++) {
+	    // grab the curve for this edge,face and surface
+	    const ON_BrepEdge* edge = &brep->m_E[(*i)->GetONId()];
+	    const ON_Curve* curve = edge->EdgeCurveOf();
+	    double tmin, tmax;
+	    curve->GetDomain(&tmin, &tmax);
 
-			if (((tmin < 0.0) && (tmax > 0.0)) &&
-					((tmin > smin) ) || (tmax < smax)) {
-				if (tmin < ang_min)
-					ang_min = tmin;
-			}
+	    if (((tmin < 0.0) && (tmax > 0.0)) && ((tmin > smin)) || (tmax < smax)) {
+		if (tmin < ang_min)
+		    ang_min = tmin;
+	    }
 
-		}
+	}
 
-		if (ang_min < 0.0) {
-			*t = ang_min;
-			return true;
-		}
+	if (ang_min < 0.0) {
+	    *t = ang_min;
+	    return true;
+	}
     }
-	return false;
+    return false;
 }
 
-bool Path::LoadONTrimmingCurves(ON_Brep *brep)
+bool
+Path::LoadONTrimmingCurves(ON_Brep *brep)
 {
     ON_TextLog tl;
     LIST_OF_ORIENTED_EDGES::iterator i;
@@ -1096,8 +1116,8 @@
     SurfaceTree* st = new SurfaceTree((ON_BrepFace*) face, removeTrimmed);
 
     //TODO: remove debugging code
-    if ((false) && (id == 33316)) {
-	cerr << "We are here !!!" << endl;
+    if ((false) && (id == 24894)) {
+	cerr << "Debug:LoadONTrimmingCurves for Path:" << id << endl;
     }
     PBCData *data = NULL;
     LIST_OF_ORIENTED_EDGES::iterator prev, next;
@@ -1146,7 +1166,7 @@
     }
     list<PBCData *>::iterator cs = curve_pullback_samples.begin();
     list<PBCData *>::iterator next_cs;
-    int trimcnt = 0;
+
     cs = curve_pullback_samples.begin();
     while (cs != curve_pullback_samples.end()) {
 	next_cs = cs;
@@ -1179,7 +1199,7 @@
 	    int trimCurve = brep->m_C2.Count();
 	    //TODO: remove debugging code
 	    if ((false) && (trimCurve == 68)) {
-		cerr << "We are here!!!" << endl;
+		cerr << "Debug:LoadONTrimmingCurves for Path:" << trimCurve << endl;
 	    }
 	    ON_Curve* c2d = interpolateCurve(*samples);
 	    brep->m_C2.Append(c2d);
@@ -1191,26 +1211,23 @@
 	    trim.m_iso = surface->IsIsoparametric(*c2d, &PD);
 
 	    if (!trim.IsValid(&tl)) {
-		ON_NurbsCurve nurbs_curve;
-		c2d->GetNurbForm(nurbs_curve);
-		cerr << "Num_knots - " << nurbs_curve.KnotCount() << endl;
-		cerr << "CV count - " << nurbs_curve.CVCount() << endl;
-		//knot[17959]=0.310448 >= knot[17960]=0.310448
-		for (int i = 17955; i < 17970; i++) {
-		    cerr << "Knot[" << i << "] - " << nurbs_curve.Knot(i) << endl;
+		//TODO: remove debugging code
+		if (false) {
+		    ON_NurbsCurve nurbs_curve;
+		    c2d->GetNurbForm(nurbs_curve);
+		    cerr << "Num_knots - " << nurbs_curve.KnotCount() << endl;
+		    cerr << "CV count - " << nurbs_curve.CVCount() << endl;
+		    for (int i = 0; i < nurbs_curve.KnotCount(); i++) {
+			cerr << "Knot[" << i << "] - " << nurbs_curve.Knot(i) << endl;
+		    }
+		    for (int i = 0; i < nurbs_curve.CVCount(); i++) {
+			ON_3dPoint p;
+			nurbs_curve.GetCV(i, p);
+			cerr << "CV[" << i << "] - " << p.x << "," << p.y << endl;
+		    }
 		}
-		for (int i = 17955; i < 17970; i++) {
-		    ON_3dPoint p;
-		    nurbs_curve.GetCV(i, p);
-		    cerr << "CV[" << i << "] - " << p.x << "," << p.y << endl;
-		}
-		for (int i = 8970; i < 8989; i++) {
-		    cerr << "samples[" << i << "] - " << (*samples)[i].x << "," << (*samples)[i].y << endl;
-		}
 	    }
 
-	    int ilast = samples->Count() - 1;
-
 	    // check for bridging trim, trims along singularities
 	    // are implicitly expected
 	    ON_2dPoint end_current, start_next;
@@ -1218,12 +1235,12 @@
 	    start_next = (*nsamples)[0];
 
 	    if (end_current.DistanceTo(start_next) > PBC_TOL) {
-		//cerr << "endpoints don't connect" << endl;
+		// endpoints don't connect
 		int is;
 		const ON_Surface *surf = data->surftree->getSurface();
 		if ((is = check_pullback_singularity_bridge(surf, end_current, start_next)) >= 0) {
 		    // insert trim
-		    //cerr << "insert singular trim along ";
+		    // insert singular trim along
 		    // 0 = south, 1 = east, 2 = north, 3 = west
 		    ON_Surface::ISO iso;
 		    switch (is) {
@@ -1276,317 +1293,318 @@
 bool
 Plane::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id >= 0)
-		return true; // already loaded
+    if (ON_id >= 0)
+	return true; // already loaded
 
-	ON_3dPoint origin=GetOrigin();
-	ON_3dVector xaxis=GetXAxis();
-	ON_3dVector yaxis=GetYAxis();
-	ON_3dVector norm=GetNormal();
+    ON_3dPoint origin = GetOrigin();
+    ON_3dVector xaxis = GetXAxis();
+    ON_3dVector yaxis = GetYAxis();
+    ON_3dVector norm = GetNormal();
 
-	origin = origin*LocalUnits::length;
+    origin = origin * LocalUnits::length;
 
-	ON_Plane p(origin,xaxis,yaxis);
+    ON_Plane p(origin, xaxis, yaxis);
 
+    ON_PlaneSurface *s = new ON_PlaneSurface(p);
 
-	ON_PlaneSurface *s= new ON_PlaneSurface(p);
+    double bbdiag = trim_curve_3d_bbox->Diagonal().Length();
+    // origin may not lie within face so include in extent
+    double maxdist = origin.DistanceTo(trim_curve_3d_bbox->m_max);
+    double mindist = origin.DistanceTo(trim_curve_3d_bbox->m_min);
+    bbdiag += MAX(maxdist,mindist);
 
-	double bbdiag = trim_curve_3d_bbox->Diagonal().Length();
-	// origin may not lie within face so include in extent
-	double maxdist = origin.DistanceTo(trim_curve_3d_bbox->m_max);
-	double mindist = origin.DistanceTo(trim_curve_3d_bbox->m_min);
-	bbdiag += MAX(maxdist,mindist);
+    //TODO: look into line curves that are just point and direction
+    ON_Interval extents(-bbdiag, bbdiag);
+    s->SetExtents(0, extents);
+    s->SetExtents(1, extents);
+    s->SetDomain(0, 0.0, 1.0);
+    s->SetDomain(1, 0.0, 1.0);
 
-	//TODO: look into line curves that are just point and direction
-	ON_Interval extents(-bbdiag, bbdiag);
-    s->SetExtents(0, extents );
-    s->SetExtents(1, extents );
-    s->SetDomain(0, 0.0, 1.0 );
-    s->SetDomain(1, 0.0, 1.0 );
+    ON_id = brep->AddSurface(s);
 
-	ON_id = brep->AddSurface(s);
-
-	return true;
+    return true;
 }
 
 bool
 CylindricalSurface::LoadONBrep(ON_Brep *brep)
 {
-	// new surface if reused because of bounding
-	//if (ON_id >= 0)
-	//	return true; // already loaded
+    // new surface if reused because of bounding
+    //if (ON_id >= 0)
+    //	return true; // already loaded
 
-	ON_3dPoint origin=GetOrigin();
-	ON_3dVector norm=GetNormal();
-	ON_3dVector xaxis=GetXAxis();
-	ON_3dVector yaxis=GetYAxis();
+    if (brep->m_S.Count() == 56) {
+	cerr << "LoadONBrep for CylindricalSurface: " << 55 << endl;
+    }
+    ON_3dPoint origin = GetOrigin();
+    ON_3dVector norm = GetNormal();
+    ON_3dVector xaxis = GetXAxis();
+    ON_3dVector yaxis = GetYAxis();
 
-	origin = origin*LocalUnits::length;
+    origin = origin * LocalUnits::length;
 
-	// make sure origin is part of the bbox
-	trim_curve_3d_bbox->Set(origin, true);
+    // make sure origin is part of the bbox
+    trim_curve_3d_bbox->Set(origin, true);
 
-	double bbdiag = trim_curve_3d_bbox->Diagonal().Length();
-	origin=origin - bbdiag*norm;
-	ON_Plane p(origin,xaxis,yaxis);
+    double bbdiag = trim_curve_3d_bbox->Diagonal().Length();
+    origin = origin - bbdiag * norm;
+    ON_Plane p(origin, xaxis, yaxis);
 
-	// Creates a circle parallel to the plane
-	// with given center and radius.
-	ON_Circle c(p,origin,radius*LocalUnits::length);
+    // Creates a circle parallel to the plane
+    // with given center and radius.
+    ON_Circle c(p, origin, radius * LocalUnits::length);
 
+    //ON_Cylinder cyl(c,ON_DBL_MAX);
+    ON_Cylinder cyl(c, 2.0 * bbdiag);
 
-	//ON_Cylinder cyl(c,ON_DBL_MAX);
-	ON_Cylinder cyl(c,2.0*bbdiag);
+    ON_RevSurface* s = cyl.RevSurfaceForm();
+    if (s) {
+	double r = fabs(cyl.circle.radius);
+	if (r <= ON_SQRT_EPSILON)
+	    r = 1.0;
+	s->SetDomain(0, 0.0, 2.0 * ON_PI * r);
+    }
+    ON_id = brep->AddSurface(s);
 
-	ON_RevSurface* s = cyl.RevSurfaceForm();
-	if ( s )
-	{
-		double r = fabs(cyl.circle.radius);
-		if ( r <= ON_SQRT_EPSILON )
-			r = 1.0;
-		s->SetDomain(0,0.0,2.0*ON_PI*r);
-	}
-	ON_id = brep->AddSurface(s);
-
-	return true;
+    return true;
 }
 
 bool
 ConicalSurface::LoadONBrep(ON_Brep *brep)
 {
-	if (ON_id >= 0)
-		return true; // already loaded
+    if (ON_id >= 0)
+	return true; // already loaded
 
-	ON_3dPoint origin=GetOrigin();
-	ON_3dVector norm=GetNormal();
-	ON_3dVector xaxis=GetXAxis();
-	ON_3dVector yaxis=GetYAxis();
+    ON_3dPoint origin = GetOrigin();
+    ON_3dVector norm = GetNormal();
+    ON_3dVector xaxis = GetXAxis();
+    ON_3dVector yaxis = GetYAxis();
 
-	origin = origin*LocalUnits::length;
+    origin = origin * LocalUnits::length;
 
-	double tan_semi_angle = tan(semi_angle*LocalUnits::planeangle);
-	double height = (radius*LocalUnits::length)/tan_semi_angle;
-	double hplus = height*1.01;
-	double r1 = hplus*tan_semi_angle;
+    double tan_semi_angle = tan(semi_angle * LocalUnits::planeangle);
+    double height = (radius * LocalUnits::length) / tan_semi_angle;
+    double hplus = height * 1.01;
+    double r1 = hplus * tan_semi_angle;
 
-	origin = origin + norm*(-height);
-	ON_Plane p(origin,xaxis,yaxis);
-	ON_Cone c(p,hplus,r1);
+    origin = origin + norm * (-height);
+    ON_Plane p(origin, xaxis, yaxis);
+    ON_Cone c(p, hplus, r1);
 
-	ON_RevSurface* s = c.RevSurfaceForm();
-	if ( s )
-	{
-		double r = fabs(c.radius);
-		if ( r <= ON_SQRT_EPSILON )
-			r = 1.0;
-		s->SetDomain(0,0.0,2.0*ON_PI);
-	}
+    ON_RevSurface* s = c.RevSurfaceForm();
+    if (s) {
+	double r = fabs(c.radius);
+	if (r <= ON_SQRT_EPSILON)
+	    r = 1.0;
+	s->SetDomain(0, 0.0, 2.0 * ON_PI);
+    }
 
-	ON_id = brep->AddSurface(s);
+    ON_id = brep->AddSurface(s);
 
-	return true;
+    return true;
 }
 
 int
-intersectLines(ON_Line &l1,ON_Line &l2, ON_3dPoint &out) {
-	fastf_t t,u;
-	point_t p,a;
-	vect_t d,c;
-	struct bn_tol tol;
+intersectLines(ON_Line &l1, ON_Line &l2, ON_3dPoint &out)
+{
+    fastf_t t, u;
+    point_t p, a;
+    vect_t d, c;
+    struct bn_tol tol;
 
-	tol.magic = BN_TOL_MAGIC;
-	tol.dist = 0.005;
-	tol.dist_sq = tol.dist * tol.dist;
-	tol.perp = 1e-6;
-	tol.para = 1 - tol.perp;
+    tol.magic = BN_TOL_MAGIC;
+    tol.dist = 0.005;
+    tol.dist_sq = tol.dist * tol.dist;
+    tol.perp = 1e-6;
+    tol.para = 1 - tol.perp;
 
-	VMOVE(p,l1.from);
-	VMOVE(a,l2.from);
-	VMOVE(d,l1.Direction());
-	VMOVE(c,l2.Direction());
-	int i = bn_isect_line3_line3(&t, &u, p, d, a, c, &tol);
-	if (i == 1) {
-		VMOVE(out,l1.from);
-		out = out + t*l1.Direction();
-	}
-	return i;
+    VMOVE(p,l1.from);
+    VMOVE(a,l2.from);
+    VMOVE(d,l1.Direction());
+    VMOVE(c,l2.Direction());
+    int i = bn_isect_line3_line3(&t, &u, p, d, a, c, &tol);
+    if (i == 1) {
+	VMOVE(out,l1.from);
+	out = out + t * l1.Direction();
+    }
+    return i;
 }
 
 void
-Circle::SetParameterTrim(double start, double end) {
-	double startpoint[3];
-	double endpoint[3];
+Circle::SetParameterTrim(double start, double end)
+{
+    double startpoint[3];
+    double endpoint[3];
 
-	t = start*LocalUnits::planeangle;
-	s = end*LocalUnits::planeangle;
+    t = start * LocalUnits::planeangle;
+    s = end * LocalUnits::planeangle;
 
-	if (s < t) {
-		t = t - 2*ON_PI;
-	}
-	ON_3dPoint origin=GetOrigin();
-	ON_3dVector xaxis=GetXAxis();
-	ON_3dVector yaxis=GetYAxis();
-	ON_Plane p(origin,xaxis,yaxis);
+    if (s < t) {
+	t = t - 2 * ON_PI;
+    }
+    ON_3dPoint origin = GetOrigin();
+    ON_3dVector xaxis = GetXAxis();
+    ON_3dVector yaxis = GetYAxis();
+    ON_Plane p(origin, xaxis, yaxis);
 
-	// Creates a circle parallel to the plane
-	// with given center and radius.
-	ON_Circle c(p,origin,radius);
+    // Creates a circle parallel to the plane
+    // with given center and radius.
+    ON_Circle c(p, origin, radius);
 
-	ON_3dPoint P = c.PointAt(t);
-	startpoint[0] = P.x;
-	startpoint[1] = P.y;
-	startpoint[2] = P.z;
+    ON_3dPoint P = c.PointAt(t);
+    startpoint[0] = P.x;
+    startpoint[1] = P.y;
+    startpoint[2] = P.z;
 
-	//TODO: debugging
-	P = P * LocalUnits::length;
+    //TODO: debugging
+    P = P * LocalUnits::length;
 
-	P = c.PointAt(s);
-	endpoint[0] = P.x;
-	endpoint[1] = P.y;
-	endpoint[2] = P.z;
+    P = c.PointAt(s);
+    endpoint[0] = P.x;
+    endpoint[1] = P.y;
+    endpoint[2] = P.z;
 
-	//TODO: debugging
-	P = P * LocalUnits::length;
+    //TODO: debugging
+    P = P * LocalUnits::length;
 
-	SetPointTrim(startpoint, endpoint);
+    SetPointTrim(startpoint, endp...
 
[truncated message content]