Merge pull request #789 from danieldouglas92/fix_typo

Fix a typo

Author: MFraters

include/world_builder/objects/bezier_curve.h

@@ -41,17 +41,17 @@ namespace WorldBuilder
          * @brief Construct a new Bezier Curve object
          *
          * @param p
-         * @param angle_constrains
+         * @param angle_constraints
          */
         BezierCurve() = default;
 
         /**
          * @brief Construct a new Bezier Curve object
          *
          * @param p
-         * @param angle_constrains
+         * @param angle_constraints
          */
-        BezierCurve(const std::vector<Point<2> > &p, const std::vector<double> &angle_constrains = {});
+        BezierCurve(const std::vector<Point<2> > &p, const std::vector<double> &angle_constraints = {});
 
         /**
          * @brief Finds the closest point on the curve. If the the closest point

source/world_builder/objects/bezier_curve.cc

@@ -32,33 +32,33 @@ namespace WorldBuilder
 {
   namespace Objects
   {
-    BezierCurve::BezierCurve(const std::vector<Point<2> > &p, const std::vector<double> &angle_constrains_input)
+    BezierCurve::BezierCurve(const std::vector<Point<2> > &p, const std::vector<double> &angle_constraints_input)
     {
       points = p;
       const size_t n_points = p.size();
       control_points.resize(n_points-1, {{p[0],p[0]}});
       lengths.resize(n_points-1,NaN::DSNAN);
       angles.resize(n_points,NaN::DSNAN);
-      std::vector<double> angle_constrains = angle_constrains_input;
-      angle_constrains.resize(n_points,NaN::DQNAN);
+      std::vector<double> angle_constraints = angle_constraints_input;
+      angle_constraints.resize(n_points,NaN::DQNAN);
 
       // if no angle is provided, compute the angle as the average angle between the previous and next point.
       // The first angle points at the second point and the last angle points at the second to last point.
       // The check points are set at a distance of 1/10th the line length from the point in the direction of the angle.
-      if (std::isnan(angle_constrains[0]))
+      if (std::isnan(angle_constraints[0]))
         {
           Point<2> P1P2 = points[1]-points[0];
           angles[0] = atan2(P1P2[1],P1P2[0]);
         }
       else
         {
-          angles[0] = angle_constrains[0];
+          angles[0] = angle_constraints[0];
         }
 
       for (size_t p_i = 1; p_i < n_points-1; ++p_i)
         {
           // first determine the angle
-          if (std::isnan(angle_constrains[p_i]))
+          if (std::isnan(angle_constraints[p_i]))
             {
               // get the average angle
               const Point<2> P1P2 = points[p_i-1]-points[p_i];
@@ -72,19 +72,19 @@ namespace WorldBuilder
             }
           else
             {
-              angles[p_i] = angle_constrains[p_i];
+              angles[p_i] = angle_constraints[p_i];
             }
 
         }
 
-      if (std::isnan(angle_constrains[n_points-1]))
+      if (std::isnan(angle_constraints[n_points-1]))
         {
           Point<2> P1P2 = points[n_points-2]-points[n_points-1];
           angles[n_points-1] =  atan2(P1P2[1],P1P2[0]);
         }
       else
         {
-          angles[n_points-1] = angle_constrains[n_points-1];
+          angles[n_points-1] = angle_constraints[n_points-1];
         }
 
       if (points.size() > 2)