Changeset 51:0d26d6c7f188 in rrlib_geometry

Timestamp:

25.06.2013 18:48:45 (8 years ago)

Author:

Tobias Föhst <foehst@…>

Branch:

default

Phase:

public

Message:

Adjusted knot type in tBSplineCurve and changed bezier_curve_cache to not being populated before used

Location:

curves

Files:

• tBSplineCurve.h (modified) (4 diffs)
• tBSplineCurve.hpp (modified) (12 diffs)
• tSplineCurve.hpp (modified) (6 diffs)

curves/tBSplineCurve.h

@@ -96 +96 @@
   virtual const unsigned int NumberOfSegments() const;
 
-  const std::vector<double> &Knots() const
+  const std::vector<typename tSplineCurve::tParameter> &Knots() const
   {
     return this->knots;
@@ -122 +122 @@
 private:
   /*! B-spline knot vector (#knots = #control points + degree + 1) */
-  std::vector<double> knots;
+  std::vector<typename tSplineCurve::tParameter> knots;
   /*! Bezier control points used to evaluate b-spline curve which is converted to a set of bezier curves  */
-  std::vector<typename tShape::tPoint> bezier_control_points;
+  mutable std::vector<typename tShape::tPoint> bezier_control_point_cache;
 
   /*!
@@ -134 +134 @@
    * Calculate all Bezier control points by knot insertion, this->bezier_control_points will be modified
    */
-  void CalculateBezierControlPoints();
+  void CalculateBezierControlPoints() const;
 
   /*!
@@ -144 +144 @@
    * @return Control points after knot insertion
    */
-  std::vector<typename tShape::tPoint> InsertKnot(int at, const std::vector<double> &knots_before_insertion, double knot, const std::vector<typename tShape::tPoint> &control_points) const;
+  static std::vector<typename tShape::tPoint> InsertKnot(int at, const std::vector<typename tSplineCurve::tParameter> &knots_before_insertion, typename tSplineCurve::tParameter knot, const std::vector<typename tShape::tPoint> &control_points);
 
   virtual unsigned int GetSegmentForParameter(typename tSplineCurve::tParameter t) const;

curves/tBSplineCurve.hpp

@@ -67 +67 @@
 {
   this->CalculateKnotVector();
-  this->CalculateBezierControlPoints();
 }
 
@@ -78 +77 @@
   std::copy(knots_begin, knots_end, std::back_inserter(this->knots));
   assert(this->knots.size() == this->ControlPoints().size() + Tdegree + 1);
-  this->CalculateBezierControlPoints();
 }
 
@@ -87 +85 @@
 {
   this->CalculateKnotVector();
-  this->CalculateBezierControlPoints();
 }
 
@@ -97 +94 @@
 {
   unsigned int number_of_segments = 0;
-  double current_knot = this->knots[0];
+  typename tSplineCurve::tParameter current_knot = this->knots[0];
   for (size_t i = 1; i < this->knots.size(); ++i)
   {
@@ -109 +106 @@
 };
 
-//template<size_t Tdimension, typename TElement, unsigned int Tdegree>
-//void tBSplineCurve<Tdimension, TElement, Tdegree>::AppendControlPoint(const typename tShape::tPoint &point)
-//{
-//  tSplineCurve::AppendControlPoint(point);
-//  this->CalculateKnotVector();
-//  this->CalculateBezierControlPoints();
-//}
-//
 //----------------------------------------------------------------------
 // tBSplineCurve SetChanged
@@ -125 +114 @@
   tSplineCurve::SetChanged();
   this->CalculateKnotVector();
-  this->CalculateBezierControlPoints();
+  this->bezier_control_point_cache.clear();
 }
 
@@ -156 +145 @@
 
 template<size_t Tdimension, typename TElement, unsigned int Tdegree>
-void tBSplineCurve<Tdimension, TElement, Tdegree>::CalculateBezierControlPoints()
-{
-  this->bezier_control_points.clear();
-  std::vector<double> new_knots;
+void tBSplineCurve<Tdimension, TElement, Tdegree>::CalculateBezierControlPoints() const
+{
+  this->bezier_control_point_cache.clear();
+  std::vector<typename tSplineCurve::tParameter> new_knots;
   new_knots.reserve(this->knots.size() * Tdegree);
   std::copy(this->knots.begin(), this->knots.end(), std::back_inserter(new_knots));
-  std::copy(this->ControlPoints().begin(), this->ControlPoints().end(), std::back_inserter(this->bezier_control_points));
-
-  double knot = new_knots[0];
+  std::copy(this->ControlPoints().begin(), this->ControlPoints().end(), std::back_inserter(this->bezier_control_point_cache));
+
+  typename tSplineCurve::tParameter knot = new_knots[0];
   unsigned int multiplicity = 1;
 
-  for (std::vector<double>::iterator it = (++new_knots.begin()); it < new_knots.end(); ++it)
+  for (auto it = (++new_knots.begin()); it < new_knots.end(); ++it)
   {
     if (knot == *it)
@@ -179 +168 @@
         for (unsigned int s = multiplicity; s < Tdegree; s++)
         {
-          this->bezier_control_points = InsertKnot((it - new_knots.begin()) - multiplicity, new_knots, knot, this->bezier_control_points);
+          this->bezier_control_point_cache = InsertKnot((it - new_knots.begin()) - multiplicity, new_knots, knot, this->bezier_control_point_cache);
           new_knots.insert(it, knot);
         }
@@ -194 +183 @@
 
 template<size_t Tdimension, typename TElement, unsigned int Tdegree>
-std::vector<typename tBSplineCurve<Tdimension, TElement, Tdegree>::tShape::tPoint> tBSplineCurve<Tdimension, TElement, Tdegree>::InsertKnot(int at, const std::vector<double> &knots_before_insertion, double knot, const std::vector <
-    typename tShape::tPoint > &control_points) const
+std::vector<typename tBSplineCurve<Tdimension, TElement, Tdegree>::tShape::tPoint> tBSplineCurve<Tdimension, TElement, Tdegree>::InsertKnot(int at, const std::vector<typename tSplineCurve::tParameter> &knots_before_insertion, typename tSplineCurve::tParameter knot, const std::vector<typename tShape::tPoint> &control_points)
 {
   std::vector<typename tShape::tPoint> new_control_points;
@@ -206 +194 @@
   for (int i = at - Tdegree + 1; i <= at; i++)
   {
-    double a = (knot - knots_before_insertion[i]) / (knots_before_insertion[i + Tdegree] - knots_before_insertion[i]);
+    typename tSplineCurve::tParameter a = (knot - knots_before_insertion[i]) / (knots_before_insertion[i + Tdegree] - knots_before_insertion[i]);
     new_control_points.push_back((1 - a) * control_points[i - 1] + a * control_points[i]);
   }
@@ -250 +238 @@
 std::shared_ptr<const typename tSplineCurve<Tdimension, TElement, Tdegree>::tBezierCurve> tBSplineCurve<Tdimension, TElement, Tdegree>::CreateBezierCurveForSegment(unsigned int i) const
 {
+  if (this->bezier_control_point_cache.empty())
+  {
+    this->CalculateBezierControlPoints();
+  }
   std::vector<typename tShape::tPoint> segment_control_points;
-  std::copy(this->bezier_control_points.begin() + i * Tdegree, this->bezier_control_points.begin() + i * Tdegree + Tdegree + 1, std::back_inserter(segment_control_points));
+  std::copy(this->bezier_control_point_cache.begin() + i * Tdegree, this->bezier_control_point_cache.begin() + i * Tdegree + Tdegree + 1, std::back_inserter(segment_control_points));
   return std::shared_ptr<const typename tSplineCurve::tBezierCurve>(new typename tSplineCurve::tBezierCurve(segment_control_points.begin(), segment_control_points.end()));
 }
@@ -278 +270 @@
   size_t number_of_knots;
   stream >> number_of_knots;
-  double knots[number_of_knots];
+  typename tSplineCurve<Tdimension, TElement, Tdegree>::tParameter knots[number_of_knots];
   for (size_t i = 0; i < number_of_knots; ++i)
   {

curves/tSplineCurve.hpp

@@ -72 +72 @@
   static_assert(Tdegree > 0, "The degree of spline curves must be greater than zero");
   assert(control_points.size() > Tdegree && "A spline curve needs at least degree + 1 control points");
-  this->bezier_curve_cache.resize(this->NumberOfSegments());
 }
 
@@ -82 +81 @@
   std::copy(begin, end, std::back_inserter(this->control_points));
   assert(control_points.size() > Tdegree && "A spline curve needs at least degree + 1 control points");
-  this->bezier_curve_cache.resize(this->NumberOfSegments());
 }
 
@@ -92 +90 @@
   static_assert(sizeof...(rest) + 2 > Tdegree, "A spline curve needs at least degree + 1 control points");
   util::ProcessVariadicValues<typename tShape::tPoint>([this](const typename tShape::tPoint & x) mutable { this->control_points.push_back(x); }, p1, p2, rest...);
-  this->bezier_curve_cache.resize(this->NumberOfSegments());
 }
 
@@ -123 +120 @@
   this->control_points.push_back(point);
   this->SetChanged();
-  this->bezier_curve_cache.emplace_back();
 };
 
@@ -135 +131 @@
   this->control_points.insert(this->control_points.begin() + position, point);
   this->SetChanged();
-  this->bezier_curve_cache.emplace_back();
 };
 
@@ -184 +179 @@
 {
   assert(i < this->NumberOfSegments());
-  assert(this->bezier_curve_cache.size() == this->NumberOfSegments());
+  this->bezier_curve_cache.resize(this->NumberOfSegments());
   if (!this->bezier_curve_cache[i])
   {