Implement #18 and #19. Fix some compiler warnings.

6 files changed, 682 insertions, 613 deletions

diff --git a/ArcWelder/arc_welder.cpp b/ArcWelder/arc_welder.cpp
index c9cd465..5fb9c82 100644
--- a/ArcWelder/arc_welder.cpp
+++ b/ArcWelder/arc_welder.cpp
@@ -42,6 +42,8 @@ arc_welder::arc_welder(
 	double resolution_mm, 
 	double path_tolerance_percent,
 	double max_radius,
+	int min_arc_segments,
+	double mm_per_arc_segment,
 	bool g90_g91_influences_extruder, 
 	bool allow_z_axis_changes,
 	int buffer_size, 
@@ -51,6 +53,8 @@ arc_welder::arc_welder(
 			resolution_mm, 
 			path_tolerance_percent, 
 			max_radius,
+			min_arc_segments,
+			mm_per_arc_segment,
 			allow_z_axis_changes
 		), 
 		segment_statistics_(
@@ -183,11 +187,13 @@ arc_welder_results results;
 	error_logging_enabled_ = p_logger_->is_log_level_enabled(logger_type_, ERROR);
 
 	std::stringstream stream;
-	stream << std::fixed << std::setprecision(5);
+	stream << std::fixed << std::setprecision(2);
 	stream << "arc_welder::process - Parameters received: source_file_path: '" <<
 		source_path_ << "', target_file_path:'" << target_path_ << "', resolution_mm:" <<
 		resolution_mm_ << "mm (+-" << current_arc_.get_resolution_mm() << "mm), path_tolerance_percent: " << current_arc_.get_path_tolerance_percent()  
-		<< ", max_radius_mm:" << current_arc_.get_max_radius() 
+		<< ", max_radius_mm:" << current_arc_.get_max_radius()
+		<< ", min_arc_segments:" << std::setprecision(0) <<current_arc_.get_min_arc_segments() 
+		<< ", mm_per_arc_segment:" << std::setprecision(0) << current_arc_.get_mm_per_arc_segment()
 		<< ", g90_91_influences_extruder: " << (p_source_position_->get_g90_91_influences_extruder() ? "True" : "False")
 		<< ", allow_z_axis_changes: " << (allow_z_axis_changes_ ? "True" : "False");
 	p_logger_->log(logger_type_, INFO, stream.str());
diff --git a/ArcWelder/arc_welder.h b/ArcWelder/arc_welder.h
index 5577267..79b7712 100644
--- a/ArcWelder/arc_welder.h
+++ b/ArcWelder/arc_welder.h
@@ -158,7 +158,7 @@ struct source_target_segment_statistics {
 			int percent = 0;
 			if (source_count > 0)
 			{
-				percent = (((double)target_count - (double)source_count) / (double)source_count) * 100.0;
+				percent = (int)((((double)target_count - (double)source_count) / (double)source_count) * 100.0);
 				if (percent > max_percent)
 				{
 					max_percent = percent;
@@ -419,6 +419,8 @@ public:
 		double resolution_mm,
 		double path_tolerance_percent,
 		double max_radius,
+		int min_arc_segments,
+		double mm_per_arc_segment,
 		bool g90_g91_influences_extruder = DEFAULT_G90_G91_INFLUENCES_EXTRUDER,
 		bool allow_z_axis_changes = DEFAULT_ALLOW_Z_AXIS_CHANGES,
 		int buffer_size = DEFAULT_GCODE_BUFFER_SIZE,
diff --git a/ArcWelder/segmented_arc.cpp b/ArcWelder/segmented_arc.cpp
index de12932..8ee8adb 100644
--- a/ArcWelder/segmented_arc.cpp
+++ b/ArcWelder/segmented_arc.cpp
@@ -33,22 +33,37 @@
 
 segmented_arc::segmented_arc() : segmented_shape(DEFAULT_MIN_SEGMENTS, DEFAULT_MAX_SEGMENTS, DEFAULT_RESOLUTION_MM, ARC_LENGTH_PERCENT_TOLERANCE_DEFAULT)
 {
-	max_radius_mm_ = DEFAULT_MAX_RADIUS_MM;
-	allow_z_axis_changes_ = DEFAULT_ALLOW_Z_AXIS_CHANGES;
+  max_radius_mm_ = DEFAULT_MAX_RADIUS_MM;
+  min_arc_segments_ = DEFAULT_MIN_ARC_SEGMENTS,
+  allow_z_axis_changes_ = DEFAULT_ALLOW_Z_AXIS_CHANGES;
 }
 
 segmented_arc::segmented_arc(
-	int min_segments, 
-	int max_segments, 
-	double resolution_mm, 
-	double path_tolerance_percent, 
-	double max_radius_mm,
-	bool allow_z_axis_changes
-	) : segmented_shape(min_segments, max_segments, resolution_mm, path_tolerance_percent)
+  int min_segments,
+  int max_segments,
+  double resolution_mm,
+  double path_tolerance_percent,
+  double max_radius_mm,
+  int min_arc_segments,
+  double mm_per_arc_segment,
+  bool allow_z_axis_changes
+) : segmented_shape(min_segments, max_segments, resolution_mm, path_tolerance_percent)
 {
-	if (max_radius_mm > DEFAULT_MAX_RADIUS_MM) max_radius_mm_ = DEFAULT_MAX_RADIUS_MM;
-	else max_radius_mm_ = max_radius_mm;
-	allow_z_axis_changes_ = allow_z_axis_changes;
+  max_radius_mm_ = max_radius_mm;
+  if (max_radius_mm > DEFAULT_MAX_RADIUS_MM) {
+    max_radius_mm_ = DEFAULT_MAX_RADIUS_MM;
+  }
+  mm_per_arc_segment_ = mm_per_arc_segment;
+  if (mm_per_arc_segment_ < 0 || utilities::is_zero(mm_per_arc_segment_))
+  {
+    mm_per_arc_segment = 0;
+  }
+  min_arc_segments_ = min_arc_segments;
+  if (min_arc_segments_ < 0)
+  {
+    min_arc_segments_ = 0;
+  }
+  allow_z_axis_changes_ = allow_z_axis_changes;
 }
 
 segmented_arc::~segmented_arc()
@@ -57,226 +72,234 @@ segmented_arc::~segmented_arc()
 
 point segmented_arc::pop_front(double e_relative)
 {
-	e_relative_ -= e_relative;
-	if (points_.count() == get_min_segments())
-	{
-		set_is_shape(false);
-	}
-	return points_.pop_front();
+  e_relative_ -= e_relative;
+  if (points_.count() == get_min_segments())
+  {
+    set_is_shape(false);
+  }
+  return points_.pop_front();
 }
 point segmented_arc::pop_back(double e_relative)
 {
-	e_relative_ -= e_relative;
-	return points_.pop_back();
-	if (points_.count() == get_min_segments())
-	{
-		set_is_shape(false);
-	}
+  e_relative_ -= e_relative;
+  return points_.pop_back();
+  if (points_.count() == get_min_segments())
+  {
+    set_is_shape(false);
+  }
 }
 double segmented_arc::get_max_radius() const
 {
-	return max_radius_mm_;
+  return max_radius_mm_;
 }
 
+int segmented_arc::get_min_arc_segments() const
+{
+  return min_arc_segments_;
+}
 
+double segmented_arc::get_mm_per_arc_segment() const
+{
+  return mm_per_arc_segment_;
+}
 
 bool segmented_arc::is_shape() const
 {
-	return is_shape_;
+  return is_shape_;
 }
 
 bool segmented_arc::try_add_point(point p, double e_relative)
 {
-	
-	bool point_added = false;
-	// if we don't have enough segnemts to check the shape, just add
-	if (points_.count() > get_max_segments() - 1)
-	{
-		// Too many points, we can't add more
-		return false;
-	}
-	double distance = 0;
-	if (points_.count() > 0)
-	{
-		point p1 = points_[points_.count() - 1];
-		if (allow_z_axis_changes_){
-			// If we can draw arcs in 3 space, add in the distance of the z axis changes
-			distance = utilities::get_cartesian_distance(p1.x, p1.y, p1.z, p.x, p.y, p.z);
-		}
-		else {
-			distance = utilities::get_cartesian_distance(p1.x, p1.y, p.x, p.y);
-			if (!utilities::is_equal(p1.z, p.z))
-			{
-				// Z axis changes aren't allowed
-				return false;
-			}
-		}
-		
-		if (utilities::is_zero(distance))
-		{
-			// there must be some distance between the points
-			// to make an arc.
-			return false;
-		}
-		
-	}
-	
-	if (points_.count() < get_min_segments() - 1)
-	{
-		point_added = true;
-		points_.push_back(p);
-		original_shape_length_ += distance;
-		if (points_.count() == get_min_segments())
-		{
-			if (!arc::try_create_arc(points_, current_arc_, original_shape_length_, max_radius_mm_, resolution_mm_, path_tolerance_percent_))
-			{
-				point_added = false;
-				points_.pop_back();
-				original_shape_length_ -= distance;
-			}
-		}
-	}
-	else
-	{
-		// if we're here, we need to see if the new point can be included in the shape
-		point_added = try_add_point_internal_(p, distance);
-	}
-	if (point_added)
-	{
-		
-		if (points_.count() > 1)
-		{
-			// Only add the relative distance to the second point on up.
-			e_relative_ += e_relative;
-		}
-		//std::cout << " success - " << points_.count() << " points.\n";
-	}
-	else if (points_.count() < get_min_segments() && points_.count() > 1)
-	{
-		// If we haven't added a point, and we have exactly min_segments_,
-		// pull off the initial arc point and try again
-
-		point old_initial_point = points_.pop_front();
-		// We have to remove the distance and e relative value
-		// accumulated between the old arc start point and the new
-		point new_initial_point = points_[0];
-		if (allow_z_axis_changes_) {
-			original_shape_length_ -= utilities::get_cartesian_distance(old_initial_point.x, old_initial_point.y, old_initial_point.z, new_initial_point.x, new_initial_point.y, new_initial_point.z);
-		}
-		else {
-			original_shape_length_ -= utilities::get_cartesian_distance(old_initial_point.x, old_initial_point.y, new_initial_point.x, new_initial_point.y);
-		}
-		
-		e_relative_ -= new_initial_point.e_relative;
-		//std::cout << " failed - removing start point and retrying current point.\n";
-		return try_add_point(p, e_relative);
-	}
-
-	return point_added;
+
+  bool point_added = false;
+  // if we don't have enough segnemts to check the shape, just add
+  if (points_.count() > get_max_segments() - 1)
+  {
+    // Too many points, we can't add more
+    return false;
+  }
+  double distance = 0;
+  if (points_.count() > 0)
+  {
+    point p1 = points_[points_.count() - 1];
+    if (allow_z_axis_changes_) {
+      // If we can draw arcs in 3 space, add in the distance of the z axis changes
+      distance = utilities::get_cartesian_distance(p1.x, p1.y, p1.z, p.x, p.y, p.z);
+    }
+    else {
+      distance = utilities::get_cartesian_distance(p1.x, p1.y, p.x, p.y);
+      if (!utilities::is_equal(p1.z, p.z))
+      {
+        // Z axis changes aren't allowed
+        return false;
+      }
+    }
+
+    if (utilities::is_zero(distance))
+    {
+      // there must be some distance between the points
+      // to make an arc.
+      return false;
+    }
+
+  }
+
+  if (points_.count() < get_min_segments() - 1)
+  {
+    point_added = true;
+    points_.push_back(p);
+    original_shape_length_ += distance;
+    if (points_.count() == get_min_segments())
+    {
+      if (!arc::try_create_arc(points_, current_arc_, original_shape_length_, max_radius_mm_, resolution_mm_, path_tolerance_percent_, min_arc_segments_, mm_per_arc_segment_, xyz_precision_, allow_z_axis_changes_))
+      {
+        point_added = false;
+        points_.pop_back();
+        original_shape_length_ -= distance;
+      }
+    }
+  }
+  else
+  {
+    // if we're here, we need to see if the new point can be included in the shape
+    point_added = try_add_point_internal_(p, distance);
+  }
+  if (point_added)
+  {
+
+    if (points_.count() > 1)
+    {
+      // Only add the relative distance to the second point on up.
+      e_relative_ += e_relative;
+    }
+    //std::cout << " success - " << points_.count() << " points.\n";
+  }
+  else if (points_.count() < get_min_segments() && points_.count() > 1)
+  {
+    // If we haven't added a point, and we have exactly min_segments_,
+    // pull off the initial arc point and try again
+
+    point old_initial_point = points_.pop_front();
+    // We have to remove the distance and e relative value
+    // accumulated between the old arc start point and the new
+    point new_initial_point = points_[0];
+    if (allow_z_axis_changes_) {
+      original_shape_length_ -= utilities::get_cartesian_distance(old_initial_point.x, old_initial_point.y, old_initial_point.z, new_initial_point.x, new_initial_point.y, new_initial_point.z);
+    }
+    else {
+      original_shape_length_ -= utilities::get_cartesian_distance(old_initial_point.x, old_initial_point.y, new_initial_point.x, new_initial_point.y);
+    }
+
+    e_relative_ -= new_initial_point.e_relative;
+    //std::cout << " failed - removing start point and retrying current point.\n";
+    return try_add_point(p, e_relative);
+  }
+
+  return point_added;
 }
 
 bool segmented_arc::try_add_point_internal_(point p, double pd)
 {
-	// If we don't have enough points (at least min_segments) return false
-	if (points_.count() < get_min_segments() - 1)
-		return false;
-	
-	// Create a test circle
-	circle target_circle;
-
-	// the circle is new..  we have to test it now, which is expensive :(
-	points_.push_back(p);
-	double previous_shape_length = original_shape_length_;
-	original_shape_length_ += pd;
-
-	if (arc::try_create_arc(points_, current_arc_, original_shape_length_, max_radius_mm_, resolution_mm_, path_tolerance_percent_, xyz_precision_, allow_z_axis_changes_))
-	{
-		if (!is_shape())
-		{	
-			set_is_shape(true);
-		}
-		return true;
-	}
-	// Can't create the arc.  Remove the point and remove the previous segment length.
-	points_.pop_back();
-	original_shape_length_ = previous_shape_length;
-	return false;	
+  // If we don't have enough points (at least min_segments) return false
+  if (points_.count() < get_min_segments() - 1)
+    return false;
+
+  // Create a test circle
+  circle target_circle;
+
+  // the circle is new..  we have to test it now, which is expensive :(
+  points_.push_back(p);
+  double previous_shape_length = original_shape_length_;
+  original_shape_length_ += pd;
+
+  if (arc::try_create_arc(points_, current_arc_, original_shape_length_, max_radius_mm_, resolution_mm_, path_tolerance_percent_, min_arc_segments_, mm_per_arc_segment_, xyz_precision_, allow_z_axis_changes_))
+  {
+    if (!is_shape())
+    {
+      set_is_shape(true);
+    }
+    return true;
+  }
+  // Can't create the arc.  Remove the point and remove the previous segment length.
+  points_.pop_back();
+  original_shape_length_ = previous_shape_length;
+  return false;
 }
 
 std::string segmented_arc::get_shape_gcode_absolute(double e, double f)
 {
-	bool has_e = e_relative_ != 0;
-	return get_shape_gcode_(has_e, e, f);
+  bool has_e = e_relative_ != 0;
+  return get_shape_gcode_(has_e, e, f);
 }
 
 std::string segmented_arc::get_shape_gcode_relative(double f)
 {
-	bool has_e = e_relative_ != 0;
-	return get_shape_gcode_(has_e, e_relative_, f);
+  bool has_e = e_relative_ != 0;
+  return get_shape_gcode_(has_e, e_relative_, f);
 }
 
 std::string segmented_arc::get_shape_gcode_(bool has_e, double e, double f) const
 {
-	
-	char buf[20];
-	std::string gcode;
-
-	double i = current_arc_.center.x - current_arc_.start_point.x;
-	double j = current_arc_.center.y - current_arc_.start_point.y;
-	// Here is where the performance part kicks in (these are expensive calls) that makes things a bit ugly.
-	// there are a few cases we need to take into consideration before choosing our sprintf string
-	// create the XYZ portion
-	
-	if (current_arc_.angle_radians < 0)
-	{
-		gcode = "G2";
-	}
-	else
-	{
-		gcode = "G3";
-	
-	}
-	// Add X, Y, I and J
-	gcode += " X";
-	gcode += utilities::to_string(current_arc_.end_point.x, xyz_precision_, buf, false);
-
-	gcode += " Y";
-	gcode += utilities::to_string(current_arc_.end_point.y, xyz_precision_, buf, false);
-
-	if (allow_z_axis_changes_)
-	{
-		// We may need to add a z coordinate
-		double z_initial = current_arc_.start_point.z;
-		double z_final = current_arc_.end_point.z;
-		if (!utilities::is_equal(z_initial, z_final, std::pow(10.0, -1.0 * xyz_precision_)))
-		{
-			// The z axis has changed within the precision of the gcode coordinates
-			gcode += " Z";
-			gcode += utilities::to_string(current_arc_.end_point.z, xyz_precision_, buf, false);
-		}
-	}
-
-	gcode += " I";
-	gcode += utilities::to_string(i, xyz_precision_, buf, false);
-
-	gcode += " J";
-	gcode += utilities::to_string(j, xyz_precision_, buf, false);
-	
-	// Add E if it appears
-	if (has_e)
-	{
-		gcode += " E";
-		gcode += utilities::to_string(e, e_precision_, buf, false);
-	}
-
-	// Add F if it appears
-	if (utilities::greater_than_or_equal(f, 1))
-	{
-		gcode += " F";
-		gcode += utilities::to_string(f, 0, buf, true);
-	}
-
-	return gcode;
+  char buf[100];
+  std::string gcode;
+
+
+  double i = current_arc_.center.x - current_arc_.start_point.x;
+  double j = current_arc_.center.y - current_arc_.start_point.y;
+  // Here is where the performance part kicks in (these are expensive calls) that makes things a bit ugly.
+  // there are a few cases we need to take into consideration before choosing our sprintf string
+  // create the XYZ portion
+
+  if (current_arc_.angle_radians < 0)
+  {
+    gcode = "G2";
+  }
+  else
+  {
+    gcode = "G3";
+
+  }
+  // Add X, Y, I and J
+  gcode += " X";
+  gcode += utilities::to_string(current_arc_.end_point.x, xyz_precision_, buf, false);
+
+  gcode += " Y";
+  gcode += utilities::to_string(current_arc_.end_point.y, xyz_precision_, buf, false);
+
+  if (allow_z_axis_changes_)
+  {
+    // We may need to add a z coordinate
+    double z_initial = current_arc_.start_point.z;
+    double z_final = current_arc_.end_point.z;
+    if (!utilities::is_equal(z_initial, z_final, std::pow(10.0, -1.0 * xyz_precision_)))
+    {
+      // The z axis has changed within the precision of the gcode coordinates
+      gcode += " Z";
+      gcode += utilities::to_string(current_arc_.end_point.z, xyz_precision_, buf, false);
+    }
+  }
+
+  gcode += " I";
+  gcode += utilities::to_string(i, xyz_precision_, buf, false);
+
+  gcode += " J";
+  gcode += utilities::to_string(j, xyz_precision_, buf, false);
+
+  // Add E if it appears
+  if (has_e)
+  {
+    gcode += " E";
+    gcode += utilities::to_string(e, e_precision_, buf, false);
+  }
+
+  // Add F if it appears
+  if (utilities::greater_than_or_equal(f, 1))
+  {
+    gcode += " F";
+    gcode += utilities::to_string(f, 0, buf, true);
+  }
+
+  return gcode;
 
 }
 
diff --git a/ArcWelder/segmented_arc.h b/ArcWelder/segmented_arc.h
index 9af5f25..6705e2e 100644
--- a/ArcWelder/segmented_arc.h
+++ b/ArcWelder/segmented_arc.h
@@ -40,7 +40,9 @@ public:
 		int max_segments = DEFAULT_MAX_SEGMENTS, 
 		double resolution_mm = DEFAULT_RESOLUTION_MM, 
 		double path_tolerance_percnet = ARC_LENGTH_PERCENT_TOLERANCE_DEFAULT, 
-		double max_radius_mm = DEFAULT_MAX_RADIUS_MM ,
+		double max_radius_mm = DEFAULT_MAX_RADIUS_MM,
+		int min_arc_segments = DEFAULT_MIN_ARC_SEGMENTS,
+		double mm_per_arc_segment = DEFAULT_MM_PER_ARC_SEGMENT,
 		bool allow_z_axis_changes = DEFAULT_ALLOW_Z_AXIS_CHANGES
 	);
 	virtual ~segmented_arc();
@@ -52,13 +54,19 @@ public:
 	point pop_front(double e_relative);
 	point pop_back(double e_relative);
 	double get_max_radius() const;
+	int get_min_arc_segments() const;
+	double get_mm_per_arc_segment() const;
 
 private:
 	bool try_add_point_internal_(point p, double pd);
 	std::string get_shape_gcode_(bool has_e, double e, double f) const;
+	std::string get_g1(double x, double y, double z, double e, double f, bool has_z);
+	std::string interpolate_arc(double f, bool is_relative, double start_e = 0);
 	//circle arc_circle_;
 	arc current_arc_;
 	double max_radius_mm_;
+	int min_arc_segments_;
+	double mm_per_arc_segment_;
 	bool allow_z_axis_changes_;
 };															
 
diff --git a/ArcWelder/segmented_shape.cpp b/ArcWelder/segmented_shape.cpp
index 76bcca1..7a7f8c2 100644
--- a/ArcWelder/segmented_shape.cpp
+++ b/ArcWelder/segmented_shape.cpp
@@ -30,82 +30,82 @@
 #include <iostream>
 #pragma region Operators for Vector and Point
 point operator +(point lhs, const vector rhs) {
-	point p(
-		lhs.x + rhs.x,
-		lhs.y + rhs.y,
-		lhs.z + rhs.z,
-		lhs.e_relative + rhs.e_relative
-	);
-	return p;
+  point p(
+    lhs.x + rhs.x,
+    lhs.y + rhs.y,
+    lhs.z + rhs.z,
+    lhs.e_relative + rhs.e_relative
+  );
+  return p;
 }
 
 point operator -(point lhs, const vector rhs) {
-	return point(
-		lhs.x - rhs.x,
-		lhs.y - rhs.y,
-		lhs.z - rhs.z,
-		lhs.e_relative - rhs.e_relative
-	);
+  return point(
+    lhs.x - rhs.x,
+    lhs.y - rhs.y,
+    lhs.z - rhs.z,
+    lhs.e_relative - rhs.e_relative
+  );
 }
 
 vector operator -(point& lhs, point& rhs) {
-	return vector(
-		lhs.x - rhs.x,
-		lhs.y - rhs.y,
-		lhs.z - rhs.z
-	);
+  return vector(
+    lhs.x - rhs.x,
+    lhs.y - rhs.y,
+    lhs.z - rhs.z
+  );
 }
 
 vector operator -(const point& lhs, const point& rhs) {
-	return vector(
-		lhs.x - rhs.x,
-		lhs.y - rhs.y,
-		lhs.z - rhs.z
-	);
+  return vector(
+    lhs.x - rhs.x,
+    lhs.y - rhs.y,
+    lhs.z - rhs.z
+  );
 }
 
 vector operator *(vector lhs, const double& rhs) {
-	return vector(
-		lhs.x*rhs,
-		lhs.y*rhs,
-		lhs.z*rhs
-	);
+  return vector(
+    lhs.x * rhs,
+    lhs.y * rhs,
+    lhs.z * rhs
+  );
 }
 #pragma endregion Operators for Vector and Point
 
 #pragma region Point Functions
 point point::get_midpoint(point p1, point p2)
 {
-	double x = (p1.x + p2.x) / 2.0;
-	double y = (p1.y + p2.y) / 2.0;
-	double z = (p1.z + p2.z) / 2.0;
+  double x = (p1.x + p2.x) / 2.0;
+  double y = (p1.y + p2.y) / 2.0;
+  double z = (p1.z + p2.z) / 2.0;
 
-	return point(x, y, z, 0);
+  return point(x, y, z, 0);
 }
 #pragma endregion Point Functions
 
 #pragma region Segment Functions
-bool segment::get_closest_perpendicular_point(point c, point &d)
+bool segment::get_closest_perpendicular_point(point c, point& d)
 {
-	return segment::get_closest_perpendicular_point(p1, p2, c, d);
+  return segment::get_closest_perpendicular_point(p1, p2, c, d);
 }
 
-bool segment::get_closest_perpendicular_point(const point &p1, const point &p2, const point &c, point& d)
+bool segment::get_closest_perpendicular_point(const point& p1, const point& p2, const point& c, point& d)
 {
-	// [(Cx - Ax)(Bx - Ax) + (Cy - Ay)(By - Ay)] / [(Bx - Ax) ^ 2 + (By - Ay) ^ 2]
-	double num = (c.x - p1.x)*(p2.x - p1.x) + (c.y - p1.y)*(p2.y - p1.y);
-	double denom = (std::pow((p2.x - p1.x), 2) + std::pow((p2.y - p1.y), 2));
-	double t = num / denom;
+  // [(Cx - Ax)(Bx - Ax) + (Cy - Ay)(By - Ay)] / [(Bx - Ax) ^ 2 + (By - Ay) ^ 2]
+  double num = (c.x - p1.x) * (p2.x - p1.x) + (c.y - p1.y) * (p2.y - p1.y);
+  double denom = (std::pow((p2.x - p1.x), 2) + std::pow((p2.y - p1.y), 2));
+  double t = num / denom;
 
-	// We're considering this a failure if t == 0 or t==1 within our tolerance.  In that case we hit the endpoint, which is OK.
-	// Why are we using the CIRCLE_GENERATION_A_ZERO_TOLERANCE tolerance here??
-	if (utilities::less_than_or_equal(t, 0) || utilities::greater_than_or_equal(t, 1))
-		return false;
+  // We're considering this a failure if t == 0 or t==1 within our tolerance.  In that case we hit the endpoint, which is OK.
+  // Why are we using the CIRCLE_GENERATION_A_ZERO_TOLERANCE tolerance here??
+  if (utilities::less_than_or_equal(t, 0) || utilities::greater_than_or_equal(t, 1))
+    return false;
 
-	d.x = p1.x + t * (p2.x - p1.x);
-	d.y = p1.y + t * (p2.y - p1.y);
+  d.x = p1.x + t * (p2.x - p1.x);
+  d.y = p1.y + t * (p2.y - p1.y);
 
-	return true;
+  return true;
 }
 
 #pragma endregion
@@ -113,12 +113,12 @@ bool segment::get_closest_perpendicular_point(const point &p1, const point &p2,
 #pragma region Vector Functions
 double vector::get_magnitude()
 {
-	return sqrt(x * x + y * y + z * z);
+  return sqrt(x * x + y * y + z * z);
 }
 
 double vector::cross_product_magnitude(vector v1, vector v2)
 {
-	return (v1.x * v2.y - v1.y * v2.x);
+  return (v1.x * v2.y - v1.y * v2.x);
 }
 #pragma endregion Vector Functions
 
@@ -138,20 +138,20 @@ double vector::cross_product_magnitude(vector v1, vector v2)
 
 double distance_from_segment(segment s, point p)
 {
-	vector v = s.p2 - s.p1;
-	vector w = p - s.p1;
+  vector v = s.p2 - s.p1;
+  vector w = p - s.p1;
 
-	double c1 = dot(w, v);
-	if (c1 <= 0)
-		return d(p, s.p1);
+  double c1 = dot(w, v);
+  if (c1 <= 0)
+    return d(p, s.p1);
 
-	double c2 = dot(v, v);
-	if (c2 <= c1)
-		return d(p, s.p2);
+  double c2 = dot(v, v);
+  if (c2 <= c1)
+    return d(p, s.p2);
 
-	double b = c1 / c2;
-	point pb = s.p1 + (v * b);
-	return d(p, pb);
+  double b = c1 / c2;
+  point pb = s.p1 + (v * b);
+  return d(p, pb);
 }
 
 #pragma endregion Distance Calculation Source
@@ -161,474 +161,495 @@ double distance_from_segment(segment s, point p)
 
 bool circle::try_create_circle(const point& p1, const point& p2, const point& p3, const double max_radius, circle& new_circle)
 {
-	double x1 = p1.x;
-	double y1 = p1.y;
-	double x2 = p2.x;
-	double y2 = p2.y;
-	double x3 = p3.x;
-	double y3 = p3.y;
+  double x1 = p1.x;
+  double y1 = p1.y;
+  double x2 = p2.x;
+  double y2 = p2.y;
+  double x3 = p3.x;
+  double y3 = p3.y;
 
-	double a = x1 * (y2 - y3) - y1 * (x2 - x3) + x2 * y3 - x3 * y2;
-	//  Take out to figure out how we handle very small values for a
-	if (utilities::is_zero(a,0.000000001))
-	{
-		return false;
-	}
-	
+  double a = x1 * (y2 - y3) - y1 * (x2 - x3) + x2 * y3 - x3 * y2;
+  //  Take out to figure out how we handle very small values for a
+  if (utilities::is_zero(a, 0.000000001))
+  {
+    return false;
+  }
 
-	double b = (x1 * x1 + y1 * y1) * (y3 - y2)
-		+ (x2 * x2 + y2 * y2) * (y1 - y3)
-		+ (x3 * x3 + y3 * y3) * (y2 - y1);
 
-	double c = (x1 * x1 + y1 * y1) * (x2 - x3)
-		+ (x2 * x2 + y2 * y2) * (x3 - x1)
-		+ (x3 * x3 + y3 * y3) * (x1 - x2);
+  double b = (x1 * x1 + y1 * y1) * (y3 - y2)
+    + (x2 * x2 + y2 * y2) * (y1 - y3)
+    + (x3 * x3 + y3 * y3) * (y2 - y1);
 
-	double x = -b / (2.0 * a);
-	double y = -c / (2.0 * a);
+  double c = (x1 * x1 + y1 * y1) * (x2 - x3)
+    + (x2 * x2 + y2 * y2) * (x3 - x1)
+    + (x3 * x3 + y3 * y3) * (x1 - x2);
 
-	double radius = utilities::get_cartesian_distance(x, y, x1, y1);
-	if (radius > max_radius)
-		return false;
-	new_circle.center.x = x;
-	new_circle.center.y = y;
-	new_circle.center.z = p1.z;
-	new_circle.radius = radius;
+  double x = -b / (2.0 * a);
+  double y = -c / (2.0 * a);
 
-	return true;
+  double radius = utilities::get_cartesian_distance(x, y, x1, y1);
+  if (radius > max_radius)
+    return false;
+  new_circle.center.x = x;
+  new_circle.center.y = y;
+  new_circle.center.z = p1.z;
+  new_circle.radius = radius;
+
+  return true;
 }
 
 bool circle::try_create_circle(const array_list<point>& points, const double max_radius, const double resolution_mm, const int xyz_precision, bool allow_z_axis_changes, bool check_middle_only, circle& new_circle)
 {
-	int middle_index = points.count() / 2;
-	int check_index;
-	int step = 0;
+  int middle_index = points.count() / 2;
+  int check_index;
+  int step = 0;
   bool is_right = true;
-	while (true) {
-		
-		check_index = middle_index + (is_right ? step : -1*step);
-		// Check the index
-		if (circle::try_create_circle(points[0], points[check_index], points[points.count() - 1], max_radius, new_circle))
-		{
-			if (!new_circle.is_over_deviation(points, resolution_mm, xyz_precision, allow_z_axis_changes))
-			{
-				return true;
-			}
-		}
-		if (is_right)
-		{
-			if (check_index == points.count() - 1)
-			{
-				return false;
-			}
-			if (check_index == middle_index)
-			{
-				if (check_middle_only) 
-				{
-					return false;
-				}
-				step++;
-				continue;
-			}
-		}
-		else
-		{
-			if (check_index == 0)
-			{
-				return false;
-			}
-			step++;
-		}
-		is_right = !is_right;
-	}
-	return false;
+  while (true) {
+
+    check_index = middle_index + (is_right ? step : -1 * step);
+    // Check the index
+    if (circle::try_create_circle(points[0], points[check_index], points[points.count() - 1], max_radius, new_circle))
+    {
+      if (!new_circle.is_over_deviation(points, resolution_mm, xyz_precision, allow_z_axis_changes))
+      {
+        return true;
+      }
+    }
+    if (is_right)
+    {
+      if (check_index == points.count() - 1)
+      {
+        return false;
+      }
+      if (check_index == middle_index)
+      {
+        if (check_middle_only)
+        {
+          return false;
+        }
+        step++;
+        continue;
+      }
+    }
+    else
+    {
+      if (check_index == 0)
+      {
+        return false;
+      }
+      step++;
+    }
+    is_right = !is_right;
+  }
+  return false;
 }
 
 double circle::get_radians(const point& p1, const point& p2) const
 {
-	double distance_sq = std::pow(utilities::get_cartesian_distance(p1.x, p1.y, p2.x, p2.y), 2.0);
-	double two_r_sq = 2.0 * radius * radius;
-	return acos((two_r_sq - distance_sq) / two_r_sq);
+  double distance_sq = std::pow(utilities::get_cartesian_distance(p1.x, p1.y, p2.x, p2.y), 2.0);
+  double two_r_sq = 2.0 * radius * radius;
+  return acos((two_r_sq - distance_sq) / two_r_sq);
 }
 
 double circle::get_polar_radians(const point& p1) const
 {
-	double polar_radians = atan2(p1.y - center.y, p1.x - center.x);
-	if (polar_radians < 0)
-		polar_radians = (2.0 * PI_DOUBLE) + polar_radians;
-	return polar_radians;
+  double polar_radians = atan2(p1.y - center.y, p1.x - center.x);
+  if (polar_radians < 0)
+    polar_radians = (2.0 * PI_DOUBLE) + polar_radians;
+  return polar_radians;
 }
 
 point circle::get_closest_point(const point& p) const
 {
-	vector v = p - center;
-	double mag = v.get_magnitude();
-	double px = center.x + v.x / mag * radius;
-	double py = center.y + v.y / mag * radius;
-	double pz = center.z + v.z / mag * radius;
-	return point(px, py, pz, 0);
+  vector v = p - center;
+  double mag = v.get_magnitude();
+  double px = center.x + v.x / mag * radius;
+  double py = center.y + v.y / mag * radius;
+  double pz = center.z + v.z / mag * radius;
+  return point(px, py, pz, 0);
 }
 
 bool circle::is_over_deviation(const array_list<point>& points, const double resolution_mm, const int xyz_precision, const bool allow_z_axis_changes)
 {
-	// We need to ensure that the Z steps are constand per linear travel unit
-	double z_step_per_distance = 0;
-	// Skip the first and last points since they will fit perfectly.
-	// UNLESS allow z changes is set to true, then we need to do some different stuff
-	int final_index = points.count() - 1 + (allow_z_axis_changes ? 1 : 0);
-	for (int index = 1; index < points.count() - 1; index++)
-	{
-		// Make sure the length from the center of our circle to the test point is 
-		// at or below our max distance.
-		double distance = distance = utilities::get_cartesian_distance(points[index].x, points[index].y, center.x, center.y);
-		if (allow_z_axis_changes) {
-			double z1 = points[index - 1].z;
-			double z2 = points[index].z;
-
-			double current_z_stepper_distance = (z2 - z1)/distance;
-			if (z_step_per_distance == 0){
-				z_step_per_distance = current_z_stepper_distance;
-			}
-			if (!utilities::is_equal(z_step_per_distance, current_z_stepper_distance, std::pow(10.0, -1.0 * xyz_precision)))
-			{
-				// The z step is uneven, can't create arc				
-				return true;
-			}
-				
-		}
-		
-		if (std::abs(distance - radius) > resolution_mm)
-		{
-			return true;
-		}
-	}
-	
-	// Check the point perpendicular from the segment to the circle's center, if any such point exists
-	for (int index = 0; index < points.count() - 1; index++)
-	{
-		point point_to_test;
-		if (segment::get_closest_perpendicular_point(points[index], points[index + 1], center, point_to_test))
-		{
-			double distance = utilities::get_cartesian_distance(point_to_test.x, point_to_test.y, center.x, center.y);
-			if (std::abs(distance - radius) > resolution_mm)
-			{
-				return true;
-			}
-		}
-
-	}
-	return false;
+  // We need to ensure that the Z steps are constand per linear travel unit
+  double z_step_per_distance = 0;
+  // Skip the first and last points since they will fit perfectly.
+  // UNLESS allow z changes is set to true, then we need to do some different stuff
+  int final_index = points.count() - 1 + (allow_z_axis_changes ? 1 : 0);
+  for (int index = 1; index < points.count() - 1; index++)
+  {
+    // Make sure the length from the center of our circle to the test point is 
+    // at or below our max distance.
+    double distance = distance = utilities::get_cartesian_distance(points[index].x, points[index].y, center.x, center.y);
+    if (allow_z_axis_changes) {
+      double z1 = points[index - 1].z;
+      double z2 = points[index].z;
+
+      double current_z_stepper_distance = (z2 - z1) / distance;
+      if (z_step_per_distance == 0) {
+        z_step_per_distance = current_z_stepper_distance;
+      }
+      if (!utilities::is_equal(z_step_per_distance, current_z_stepper_distance, std::pow(10.0, -1.0 * xyz_precision)))
+      {
+        // The z step is uneven, can't create arc				
+        return true;
+      }
+
+    }
+
+    if (std::abs(distance - radius) > resolution_mm)
+    {
+      return true;
+    }
+  }
+
+  // Check the point perpendicular from the segment to the circle's center, if any such point exists
+  for (int index = 0; index < points.count() - 1; index++)
+  {
+    point point_to_test;
+    if (segment::get_closest_perpendicular_point(points[index], points[index + 1], center, point_to_test))
+    {
+      double distance = utilities::get_cartesian_distance(point_to_test.x, point_to_test.y, center.x, center.y);
+      if (std::abs(distance - radius) > resolution_mm)
+      {
+        return true;
+      }
+    }
+
+  }
+  return false;
 }
 #pragma endregion Circle Functions
 
 #pragma region Arc Functions
 
 bool arc::try_create_arc(
-	const circle& c, 
-	const point& start_point, 
-	const point& mid_point, 
-	const point& end_point, 
-	arc& target_arc, 
-	double approximate_length,
-	double resolution, 
-	double path_tolerance_percent,
-	bool allow_z_axis_changes)
-{
-	double polar_start_theta = c.get_polar_radians(start_point);
-	double polar_mid_theta = c.get_polar_radians(mid_point);
-	double polar_end_theta = c.get_polar_radians(end_point);
-	
-	// variable to hold radians
-	double angle_radians = 0;
-	int direction = 0;  // 1 = counter clockwise, 2 = clockwise, 3 = unknown.
-	// Determine the direction of the arc
-	if (polar_end_theta > polar_start_theta)
-	{
-		if (polar_start_theta < polar_mid_theta && polar_mid_theta < polar_end_theta) {
-			direction = 1;		
-			angle_radians = polar_end_theta - polar_start_theta;
-		}
-		else if (
-			(0.0 <= polar_mid_theta && polar_mid_theta < polar_start_theta) ||
-			(polar_end_theta < polar_mid_theta && polar_mid_theta < (2.0 * PI_DOUBLE))
-		)
-		{
-			direction = 2;
-			angle_radians = polar_start_theta + ((2.0 * PI_DOUBLE) - polar_end_theta);
-		}
-	}
-	else if (polar_start_theta > polar_end_theta)
-	{
-		if (
-			(polar_start_theta < polar_mid_theta && polar_mid_theta < (2.0 * PI_DOUBLE)) ||
-			(0.0 < polar_mid_theta && polar_mid_theta < polar_end_theta)
-		)
-		{
-			direction = 1;
-			angle_radians = polar_end_theta + ((2.0 * PI_DOUBLE) - polar_start_theta);
-		}
-		else if (polar_end_theta < polar_mid_theta && polar_mid_theta < polar_start_theta)
-		{
-			direction = 2;
-			angle_radians = polar_start_theta - polar_end_theta;
-		}
-	}
-	
-	// this doesn't always work..  in rare situations, the angle may be backward
-	if (direction == 0 || utilities::is_zero(angle_radians)) return false;
-
-	// Let's check the length against the original length
-	// This can trigger simply due to the differing path lengths
-	// but also could indicate that our vector calculation above
-	// got the direction wrong
-	double arc_length = c.radius * angle_radians;
-
-	if (allow_z_axis_changes)
-	{
-		// We may be traveling in 3 space, calculate the arc_length of the spiral
-		if (start_point.z != end_point.z)
-		{
-			arc_length = utilities::hypot(arc_length, end_point.z - start_point.z);
-		}
-	}
-	// Calculate the percent difference of the original path
-	double difference = (arc_length - approximate_length) / approximate_length;
-	if (!utilities::is_zero(difference, path_tolerance_percent))
-	{
-		// So it's possible our vector calculation above got the direction wrong.
-		// This can happen if there is a crazy arrangement of points
-		// extremely close to eachother.  They have to be close enough to 
-		// break our other checks.  However, we may be able to salvage this.
-		// see if an arc moving in the opposite direction had the correct length.
-
-		// Find the rest of the angle across the circle
-		double test_radians = std::abs(angle_radians - 2 * PI_DOUBLE);
-		// Calculate the length of that arc
-		double test_arc_length = c.radius * test_radians;
-		if (allow_z_axis_changes)
-		{
-			// We may be traveling in 3 space, calculate the arc_length of the spiral
-			if (start_point.z != end_point.z)
-			{
-				test_arc_length = utilities::hypot(arc_length, end_point.z - start_point.z);
-			}
-		}
-		difference = (test_arc_length - approximate_length) / approximate_length;
-		if (!utilities::is_zero(difference, path_tolerance_percent))
-		{
-			return false;
-		}
-		// So, let's set the new length and flip the direction (but not the angle)!
-		arc_length = test_arc_length;
-		direction = direction == 1 ? 2 : 1;
-	}
-	
-	if (allow_z_axis_changes)
-	{
-		// Ensure the perimeter of the arc is less than that of a full circle
-		double perimeter = utilities::hypot(c.radius * 2.0 * PI_DOUBLE, end_point.z - start_point.z);
-		if (perimeter <= approximate_length) {
-			return false;
-		}
-
-	}
-
-	if(direction == 2)
-		angle_radians *= -1.0;
-
-	target_arc.center.x = c.center.x;
-	target_arc.center.y = c.center.y;
-	target_arc.center.z = c.center.z;
-	target_arc.radius = c.radius;
-	target_arc.start_point = start_point;
-	target_arc.end_point = end_point;
-	target_arc.length = arc_length;
-	target_arc.angle_radians = angle_radians;
-	target_arc.polar_start_theta = polar_start_theta;
-	target_arc.polar_end_theta = polar_end_theta;
-
-	return true;
-	
+  const circle& c,
+  const point& start_point,
+  const point& mid_point,
+  const point& end_point,
+  arc& target_arc,
+  double approximate_length,
+  double resolution,
+  double path_tolerance_percent,
+  int min_arc_segments,
+  double mm_per_arc_segment,
+  bool allow_z_axis_changes)
+{
+  double polar_start_theta = c.get_polar_radians(start_point);
+  double polar_mid_theta = c.get_polar_radians(mid_point);
+  double polar_end_theta = c.get_polar_radians(end_point);
+
+  // variable to hold radians
+  double angle_radians = 0;
+  int direction = 0;  // 1 = counter clockwise, 2 = clockwise, 3 = unknown.
+  // Determine the direction of the arc
+  if (polar_end_theta > polar_start_theta)
+  {
+    if (polar_start_theta < polar_mid_theta && polar_mid_theta < polar_end_theta) {
+      direction = 1;
+      angle_radians = polar_end_theta - polar_start_theta;
+    }
+    else if (
+      (0.0 <= polar_mid_theta && polar_mid_theta < polar_start_theta) ||
+      (polar_end_theta < polar_mid_theta && polar_mid_theta < (2.0 * PI_DOUBLE))
+      )
+    {
+      direction = 2;
+      angle_radians = polar_start_theta + ((2.0 * PI_DOUBLE) - polar_end_theta);
+    }
+  }
+  else if (polar_start_theta > polar_end_theta)
+  {
+    if (
+      (polar_start_theta < polar_mid_theta && polar_mid_theta < (2.0 * PI_DOUBLE)) ||
+      (0.0 < polar_mid_theta && polar_mid_theta < polar_end_theta)
+      )
+    {
+      direction = 1;
+      angle_radians = polar_end_theta + ((2.0 * PI_DOUBLE) - polar_start_theta);
+    }
+    else if (polar_end_theta < polar_mid_theta && polar_mid_theta < polar_start_theta)
+    {
+      direction = 2;
+      angle_radians = polar_start_theta - polar_end_theta;
+    }
+  }
+
+  // this doesn't always work..  in rare situations, the angle may be backward
+  if (direction == 0 || utilities::is_zero(angle_radians)) return false;
+
+  // Let's check the length against the original length
+  // This can trigger simply due to the differing path lengths
+  // but also could indicate that our vector calculation above
+  // got the direction wrong
+  double arc_length = c.radius * angle_radians;
+
+  if (allow_z_axis_changes)
+  {
+    // We may be traveling in 3 space, calculate the arc_length of the spiral
+    if (start_point.z != end_point.z)
+    {
+      arc_length = utilities::hypot(arc_length, end_point.z - start_point.z);
+    }
+  }
+  // Calculate the percent difference of the original path
+  double difference = (arc_length - approximate_length) / approximate_length;
+  if (!utilities::is_zero(difference, path_tolerance_percent))
+  {
+    // So it's possible our vector calculation above got the direction wrong.
+    // This can happen if there is a crazy arrangement of points
+    // extremely close to eachother.  They have to be close enough to 
+    // break our other checks.  However, we may be able to salvage this.
+    // see if an arc moving in the opposite direction had the correct length.
+
+    // Find the rest of the angle across the circle
+    double test_radians = std::abs(angle_radians - 2 * PI_DOUBLE);
+    // Calculate the length of that arc
+    double test_arc_length = c.radius * test_radians;
+    if (allow_z_axis_changes)
+    {
+      // We may be traveling in 3 space, calculate the arc_length of the spiral
+      if (start_point.z != end_point.z)
+      {
+        test_arc_length = utilities::hypot(arc_length, end_point.z - start_point.z);
+      }
+    }
+    difference = (test_arc_length - approximate_length) / approximate_length;
+    if (!utilities::is_zero(difference, path_tolerance_percent))
+    {
+      return false;
+    }
+    // So, let's set the new length and flip the direction (but not the angle)!
+    arc_length = test_arc_length;
+    direction = direction == 1 ? 2 : 1;
+  }
+
+  if (allow_z_axis_changes)
+  {
+    // Ensure the perimeter of the arc is less than that of a full circle
+    double perimeter = utilities::hypot(c.radius * 2.0 * PI_DOUBLE, end_point.z - start_point.z);
+    if (perimeter <= approximate_length) {
+      return false;
+    }
+
+  }
+
+  if (direction == 2) {
+    angle_radians *= -1.0;
+  }
+
+  // See how many arcs will be interpolated
+  if (min_arc_segments > 0 && mm_per_arc_segment > 0)
+  {
+    double circumference = 2.0*PI_DOUBLE*c.radius;
+    int num_segments = (int)std::ceil(circumference/mm_per_arc_segment);
+    if (num_segments < min_arc_segments) {
+      // We might be able to salvage this.  See if there would be enough segments if we use an arc of the current size
+      num_segments = (int)std::ceil(circumference / arc_length);
+      if (num_segments < min_arc_segments) {
+        return false;
+      }
+    }
+  }
+
+  target_arc.center.x = c.center.x;
+  target_arc.center.y = c.center.y;
+  target_arc.center.z = c.center.z;
+  target_arc.radius = c.radius;
+  target_arc.start_point = start_point;
+  target_arc.end_point = end_point;
+  target_arc.length = arc_length;
+  target_arc.angle_radians = angle_radians;
+  target_arc.polar_start_theta = polar_start_theta;
+  target_arc.polar_end_theta = polar_end_theta;
+
+  return true;
+
 }
 
 bool arc::try_create_arc(
-	const circle& c, 
-	const array_list<point>& points, 
-	arc& target_arc, 
-	double approximate_length,
-	double resolution, 
-	double path_tolerance_percent,
-	bool allow_z_axis_changes)
-{
-	int mid_point_index = ((points.count() - 2) / 2) + 1;
-	return arc::try_create_arc(c, points[0], points[mid_point_index], points[points.count() - 1], target_arc, approximate_length, resolution, path_tolerance_percent, allow_z_axis_changes);
+  const circle& c,
+  const array_list<point>& points,
+  arc& target_arc,
+  double approximate_length,
+  double resolution,
+  double path_tolerance_percent,
+  int min_arc_segments,
+  double mm_per_arc_segment,
+  bool allow_z_axis_changes)
+{
+  int mid_point_index = ((points.count() - 2) / 2) + 1;
+  return arc::try_create_arc(c, points[0], points[mid_point_index], points[points.count() - 1], target_arc, approximate_length, resolution, path_tolerance_percent, min_arc_segments, mm_per_arc_segment, allow_z_axis_changes);
 }
 bool arc::try_create_arc(
-	const array_list<point>& points,
-	arc& target_arc,
-	double approximate_length,
-	double max_radius_mm,
-	double resolution_mm,
-	double path_tolerance_percent,
-	int xyz_precision,
-	bool allow_z_axis_changes)
-{
-	circle test_circle;
-	if (circle::try_create_circle(points, max_radius_mm, resolution_mm, xyz_precision, allow_z_axis_changes, false, test_circle))
-	{
-		int mid_point_index = ((points.count() - 2) / 2) + 1;
-		return arc::try_create_arc(test_circle, points[0], points[mid_point_index], points[points.count()-1], target_arc, approximate_length, resolution_mm, path_tolerance_percent, allow_z_axis_changes);
-	}
-	return false;
+  const array_list<point>& points,
+  arc& target_arc,
+  double approximate_length,
+  double max_radius_mm,
+  double resolution_mm,
+  double path_tolerance_percent,
+  int min_arc_segments,
+  double mm_per_arc_segment,
+  int xyz_precision,
+  bool allow_z_axis_changes)
+{
+  circle test_circle;
+  if (circle::try_create_circle(points, max_radius_mm, resolution_mm, xyz_precision, allow_z_axis_changes, false, test_circle))
+  {
+    int mid_point_index = ((points.count() - 2) / 2) + 1;
+    return arc::try_create_arc(test_circle, points[0], points[mid_point_index], points[points.count() - 1], target_arc, approximate_length, resolution_mm, path_tolerance_percent, min_arc_segments, mm_per_arc_segment, allow_z_axis_changes);
+  }
+  return false;
 }
 #pragma endregion
 
 segmented_shape::segmented_shape(int min_segments, int max_segments, double resolution_mm, double path_tolerance_percnet) : points_(max_segments)
 {
-	
-	xyz_precision_ = DEFAULT_XYZ_PRECISION;
-	e_precision_ = DEFAULT_E_PRECISION;
-	max_segments_ = max_segments;
-	path_tolerance_percent_ = path_tolerance_percnet;
-	resolution_mm_ = resolution_mm / 2.0; // divide by 2 because it is + or - 1/2 of the desired resolution.
-	e_relative_ = 0;
-	is_shape_ = false;
-	// min segments can never be lower than 3 (the default) else there could be no compression.
-	if (min_segments < DEFAULT_MIN_SEGMENTS) min_segments_ = DEFAULT_MIN_SEGMENTS;
-	else min_segments_ = min_segments;
 
-	original_shape_length_ = 0;
-	is_extruding_ = true;
+  xyz_precision_ = DEFAULT_XYZ_PRECISION;
+  e_precision_ = DEFAULT_E_PRECISION;
+  max_segments_ = max_segments;
+  path_tolerance_percent_ = path_tolerance_percnet;
+  resolution_mm_ = resolution_mm / 2.0; // divide by 2 because it is + or - 1/2 of the desired resolution.
+  e_relative_ = 0;
+  is_shape_ = false;
+  // min segments can never be lower than 3 (the default) else there could be no compression.
+  if (min_segments < DEFAULT_MIN_SEGMENTS) min_segments_ = DEFAULT_MIN_SEGMENTS;
+  else min_segments_ = min_segments;
+
+  original_shape_length_ = 0;
+  is_extruding_ = true;
 }
 
 segmented_shape::~segmented_shape()
 {
-	
+
 }
 
 void segmented_shape::reset_precision()
 {
-	xyz_precision_ = DEFAULT_XYZ_PRECISION;
-	e_precision_ = DEFAULT_E_PRECISION;
+  xyz_precision_ = DEFAULT_XYZ_PRECISION;
+  e_precision_ = DEFAULT_E_PRECISION;
 }
 
-void segmented_shape::update_xyz_precision(double precision)
+void segmented_shape::update_xyz_precision(int precision)
 {
-	if (xyz_precision_ < precision)
-	{
-		xyz_precision_ = precision;
-	}
+  if (xyz_precision_ < precision)
+  {
+    xyz_precision_ = precision;
+  }
 }
 
-void segmented_shape::update_e_precision(double precision)
+void segmented_shape::update_e_precision(int precision)
 {
-	if (e_precision_ < precision)
-	{
-		e_precision_ = precision;
-	}
+  if (e_precision_ < precision)
+  {
+    e_precision_ = precision;
+  }
 
 }
 
 bool segmented_shape::is_extruding()
 {
-	return is_extruding_;
+  return is_extruding_;
 }
 
 segmented_shape& segmented_shape::operator=(const segmented_shape& obj)
 {
-	points_.clear();
-	if (obj.max_segments_ != max_segments_)
-	{
-		max_segments_ = obj.max_segments_;
-		
-		points_.resize(max_segments_);
-	}
-	points_.copy(obj.points_);
-		
-	original_shape_length_ = obj.original_shape_length_;
-	e_relative_ = obj.e_relative_;
-	is_shape_ = obj.is_shape_;
-	max_segments_ = obj.max_segments_;
-	resolution_mm_ = obj.resolution_mm_;
-	return *this;
+  points_.clear();
+  if (obj.max_segments_ != max_segments_)
+  {
+    max_segments_ = obj.max_segments_;
+
+    points_.resize(max_segments_);
+  }
+  points_.copy(obj.points_);
+
+  original_shape_length_ = obj.original_shape_length_;
+  e_relative_ = obj.e_relative_;
+  is_shape_ = obj.is_shape_;
+  max_segments_ = obj.max_segments_;
+  resolution_mm_ = obj.resolution_mm_;
+  return *this;
 }
 
 int segmented_shape::get_num_segments()
 {
-	return points_.count();
+  return points_.count();
 }
 
 double segmented_shape::get_shape_length()
 {
-	return original_shape_length_;
+  return original_shape_length_;
 }
 
 double segmented_shape::get_shape_e_relative()
 {
-	return e_relative_;
+  return e_relative_;
 }
 
 void segmented_shape::clear()
 {
-	points_.clear();
-	is_shape_ = false;
-	e_relative_ = 0;
-	original_shape_length_ = 0;
+  points_.clear();
+  is_shape_ = false;
+  e_relative_ = 0;
+  original_shape_length_ = 0;
 }
 bool segmented_shape::is_shape() const
 {
-	// return the pre-calculated value.  This should be updated by the plugin
-	return is_shape_;
+  // return the pre-calculated value.  This should be updated by the plugin
+  return is_shape_;
 }
 void segmented_shape::set_is_shape(bool value)
 {
-	is_shape_ = value;
+  is_shape_ = value;
 }
 
 int segmented_shape::get_min_segments()
 {
-	return min_segments_;
+  return min_segments_;
 }
 int segmented_shape::get_max_segments()
 {
-	return max_segments_;
+  return max_segments_;
 }
 
 double segmented_shape::get_resolution_mm()
 {
-	return resolution_mm_;
+  return resolution_mm_;
 }
 
 double segmented_shape::get_path_tolerance_percent()
 {
-	return path_tolerance_percent_;
+  return path_tolerance_percent_;
 }
 
 void segmented_shape::set_resolution_mm(double resolution_mm)
 {
-	resolution_mm_ = resolution_mm;
-	
+  resolution_mm_ = resolution_mm;
+
 }
 point segmented_shape::pop_front()
 {
-	return points_.pop_front();
+  return points_.pop_front();
 }
 point segmented_shape::pop_back()
 {
-	return points_.pop_back();
+  return points_.pop_back();
 }
 
 bool segmented_shape::try_add_point(point p, double e_relative)
 {
-	throw std::exception();
+  throw std::exception();
 }
 
 std::string segmented_shape::get_shape_gcode_absolute(double e_abs_start)
 {
-	throw std::exception();
+  throw std::exception();
 }
 
 std::string segmented_shape::get_shape_gcode_relative()
 {
-	throw std::exception();
+  throw std::exception();
 }
\ No newline at end of file
diff --git a/ArcWelder/segmented_shape.h b/ArcWelder/segmented_shape.h
index 3c8da0f..af7d8be 100644
--- a/ArcWelder/segmented_shape.h
+++ b/ArcWelder/segmented_shape.h
@@ -122,6 +122,8 @@ struct circle {
 
 #define DEFAULT_RESOLUTION_MM 0.05
 #define DEFAULT_ALLOW_Z_AXIS_CHANGES false
+#define DEFAULT_MIN_ARC_SEGMENTS 0
+#define DEFAULT_MM_PER_ARC_SEGMENT 0
 struct arc : circle
 {
 	arc() {
@@ -158,25 +160,31 @@ struct arc : circle
 		const point& mid_point, 
 		const point& end_point, 
 		arc& target_arc, 
-		double approximate_length, 
+		double approximate_length,
 		double resolution = DEFAULT_RESOLUTION_MM, 
-		double path_tolerance_percent = ARC_LENGTH_PERCENT_TOLERANCE_DEFAULT, 
+		double path_tolerance_percent = ARC_LENGTH_PERCENT_TOLERANCE_DEFAULT,
+		int min_arc_segments = DEFAULT_MIN_ARC_SEGMENTS,
+		double mm_per_arc_segment = DEFAULT_MM_PER_ARC_SEGMENT,
 		bool allow_z_axis_changes = DEFAULT_ALLOW_Z_AXIS_CHANGES);
 	static bool try_create_arc(
 		const circle& c, 
 		const array_list<point>& points, 
 		arc& target_arc, 
-		double approximate_length, 
+		double approximate_length,
 		double resolution = DEFAULT_RESOLUTION_MM, 
 		double path_tolerance_percent = ARC_LENGTH_PERCENT_TOLERANCE_DEFAULT,
+		int min_arc_segments = DEFAULT_MIN_ARC_SEGMENTS,
+		double mm_per_arc_segment = DEFAULT_MM_PER_ARC_SEGMENT,
 		bool allow_z_axis_changes = DEFAULT_ALLOW_Z_AXIS_CHANGES);
 	static bool try_create_arc(
 		const array_list<point>& points, 
 		arc& target_arc, 
 		double approximate_length, 
-		double max_radius = DEFAULT_MAX_RADIUS_MM, 
+		double max_radius = DEFAULT_MAX_RADIUS_MM,
 		double resolution = DEFAULT_RESOLUTION_MM, 
 		double path_tolerance_percent = ARC_LENGTH_PERCENT_TOLERANCE_DEFAULT,
+		int min_arc_segments = DEFAULT_MIN_ARC_SEGMENTS,
+		double mm_per_arc_segment = DEFAULT_MM_PER_ARC_SEGMENT,
 		int xyz_precision = DEFAULT_XYZ_PRECISION,
 		bool allow_z_axis_changes = DEFAULT_ALLOW_Z_AXIS_CHANGES);
 };
@@ -184,6 +192,7 @@ double distance_from_segment(segment s, point p);
 
 #define DEFAULT_MIN_SEGMENTS 3
 #define DEFAULT_MAX_SEGMENTS 50
+
 class segmented_shape
 {
 public:
@@ -204,8 +213,8 @@ public:
 	double get_shape_e_relative();
 	void set_resolution_mm(double resolution_mm);
 	void reset_precision();
-	void update_xyz_precision(double precision);
-	void update_e_precision(double precision);
+	void update_xyz_precision(int precision);
+	void update_e_precision(int precision);
 	virtual bool is_shape() const;
 	// public virtual functions
 	virtual void clear();