Simplify evaluators API

Author: Onur R. Bingol

geomdl/BSpline.py

@@ -171,10 +171,13 @@ def evaluate_single(self, param):
         if self._kv_normalize:
             utilities.check_params([param])
 
-        # Evaluate
-        return self._evaluator.evaluate_single(parameter=param, degree=self.degree, knotvector=self.knotvector,
-                                               ctrlpts=self._control_points, dimension=self._dimension,
-                                               precision=self._precision)
+        # Evaluate the curve point
+        pt = self._evaluator.evaluate(start=param, stop=param,
+                                      degree=self.degree, knotvector=self.knotvector,
+                                      ctrlpts=self._control_points, sample_size=self.sample_size,
+                                      dimension=self._dimension, precision=self._precision)
+
+        return pt[0]
 
     def evaluate_list(self, param_list):
         """ Evaluates the curve for an input range of parameters.
@@ -212,9 +215,9 @@ def derivatives(self, u, order=0, **kwargs):
         super(Curve, self).derivatives(u=u, order=order, **kwargs)
 
         # Evaluate and return the derivative at knot u
-        return self._evaluator.derivatives_single(parameter=u, deriv_order=order, degree=self.degree,
-                                                  knotvector=self.knotvector, ctrlpts=self._control_points,
-                                                  dimension=self._dimension)
+        return self._evaluator.derivatives(parameter=u, deriv_order=order, degree=self.degree,
+                                           knotvector=self.knotvector, ctrlpts=self._control_points,
+                                           dimension=self._dimension)
 
     # Knot insertion
     def insert_knot(self, u, **kwargs):
@@ -640,12 +643,14 @@ def evaluate_single(self, param):
         # Call parent method
         super(Surface, self).evaluate_single(param)
 
-        # Evaluate the surface
-        spt = self._evaluator.evaluate_single(parameter=param, degree=self._degree, knotvector=self._knot_vector,
-                                              ctrlpts_size=self._control_points_size, ctrlpts=self._control_points,
-                                              dimension=self._dimension, precision=self._precision)
+        # Evaluate the surface point
+        pt = self._evaluator.evaluate(start=param, stop=param,
+                                      degree=self._degree, knotvector=self._knot_vector,
+                                      ctrlpts_size=self._control_points_size, ctrlpts=self._control_points,
+                                      sample_size=self.sample_size, dimension=self._dimension,
+                                      precision=self._precision)
 
-        return spt
+        return pt[0]
 
     def evaluate_list(self, param_list):
         """ Evaluates the surface for a given list of (u, v) parameters.
@@ -689,10 +694,10 @@ def derivatives(self, u, v, order=0, **kwargs):
         super(Surface, self).derivatives(u=u, v=v, order=order, **kwargs)
 
         # Evaluate and return the derivatives
-        return self._evaluator.derivatives_single(parameter=(u, v), deriv_order=order,
-                                                  degree=self._degree, knotvector=self._knot_vector,
-                                                  ctrlpts_size=self._control_points_size, ctrlpts=self._control_points,
-                                                  dimension=self.dimension)
+        return self._evaluator.derivatives(parameter=(u, v), deriv_order=order,
+                                           degree=self._degree, knotvector=self._knot_vector,
+                                           ctrlpts_size=self._control_points_size, ctrlpts=self._control_points,
+                                           dimension=self.dimension)
 
     # Insert knot 'r' times at the given (u, v) parametric coordinates
     def insert_knot(self, u=None, v=None, **kwargs):
@@ -966,13 +971,14 @@ def evaluate_single(self, param):
         if self._kv_normalize:
             utilities.check_params(param)
 
-        # Evaluate the volume
-        vpt = self._evaluator.evaluate_single(parameter=param,
-                                              degree=self._degree, knotvector=self._knot_vector,
-                                              ctrlpts_size=self._control_points_size, ctrlpts=self._control_points,
-                                              dimension=self._dimension, precision=self._precision)
+        # Evaluate the volume point
+        pt = self._evaluator.evaluate(start=param, stop=param,
+                                      degree=self._degree, knotvector=self._knot_vector,
+                                      ctrlpts_size=self._control_points_size, ctrlpts=self._control_points,
+                                      sample_size=self.sample_size, dimension=self._dimension,
+                                      precision=self._precision)
 
-        return vpt
+        return pt[0]
 
     def evaluate_list(self, param_list):
         """ Evaluates the volume for a given list of (u, v, w) parameters.

geomdl/evaluators.py

@@ -43,16 +43,6 @@ def name(self):
         """
         return self._name
 
-    @abc.abstractmethod
-    def evaluate_single(self, **kwargs):
-        """ Abstract method for computation of a single point at a single parameter.
-
-        .. note::
-
-            This is an abstract method and it must be implemented in the subclass.
-        """
-        pass
-
     @abc.abstractmethod
     def evaluate(self, **kwargs):
         """ Abstract method for computation of points over a range of parameters.
@@ -64,7 +54,7 @@ def evaluate(self, **kwargs):
         pass
 
     @abc.abstractmethod
-    def derivatives_single(self, **kwargs):
+    def derivatives(self, **kwargs):
         """ Abstract method for computation of derivatives at a single parameter.
 
         .. note::
@@ -122,24 +112,6 @@ def __init__(self, **kwargs):
         super(CurveEvaluator, self).__init__(**kwargs)
         self._span_func = kwargs.get('find_span_func', helpers.find_span_linear)
 
-    def evaluate_single(self, **kwargs):
-        """ Evaluates a single curve point. """
-        # Call parent method
-        super(CurveEvaluator, self).evaluate_single(**kwargs)
-
-        param = kwargs.get('parameter')
-        degree = kwargs.get('degree')
-        knotvector = kwargs.get('knotvector')
-        ctrlpts = kwargs.get('ctrlpts')
-        dimension = kwargs.get('dimension')
-        precision = kwargs.get('precision')
-
-        # Algorithm A3.1
-        crvpt = self.evaluate(start=param, stop=param, degree=degree, knotvector=knotvector,
-                              ctrlpts=ctrlpts, sample_size=1, dimension=dimension, precision=precision)
-
-        return crvpt[0]
-
     def evaluate(self, **kwargs):
         """ Evaluates the curve. """
         # Call parent method
@@ -170,10 +142,10 @@ def evaluate(self, **kwargs):
 
         return eval_points
 
-    def derivatives_single(self, **kwargs):
+    def derivatives(self, **kwargs):
         """ Evaluates the derivatives at the input parameter. """
         # Call parent method
-        super(CurveEvaluator, self).derivatives_single(**kwargs)
+        super(CurveEvaluator, self).derivatives(**kwargs)
 
         param = kwargs.get('parameter')
         deriv_order = kwargs.get('deriv_order', 0)
@@ -310,10 +282,10 @@ def derivatives_ctrlpts(**kwargs):
         # Return a 2-dimensional list of control points
         return PK
 
-    def derivatives_single(self, **kwargs):
+    def derivatives(self, **kwargs):
         """ Evaluates the derivatives at the input parameter. """
         # Call parent method
-        super(CurveEvaluator2, self).derivatives_single(**kwargs)
+        super(CurveEvaluator2, self).derivatives(**kwargs)
 
         param = kwargs.get('parameter')
         deriv_order = kwargs.get('deriv_order', 0)
@@ -381,13 +353,13 @@ def evaluate(self, **kwargs):
 
         return eval_points
 
-    def derivatives_single(self, **kwargs):
+    def derivatives(self, **kwargs):
         """ Evaluates the derivatives at the input parameter. """
         deriv_order = kwargs.get('deriv_order')
         dimension = kwargs.get('dimension')
 
         # Call the parent function to evaluate A(u) and w(u) derivatives
-        CKw = super(CurveEvaluatorRational, self).derivatives_single(**kwargs)
+        CKw = super(CurveEvaluatorRational, self).derivatives(**kwargs)
 
         # Algorithm A4.2
         CK = [[0.0 for _ in range(dimension - 1)] for _ in range(deriv_order + 1)]
@@ -421,24 +393,6 @@ def __init__(self, **kwargs):
         super(SurfaceEvaluator, self).__init__(**kwargs)
         self._span_func = kwargs.get('find_span_func', helpers.find_span_linear)
 
-    def evaluate_single(self, **kwargs):
-        """ Evaluates a single surface point. """
-        # Call parent method
-        super(SurfaceEvaluator, self).evaluate_single(**kwargs)
-
-        param = kwargs.get('parameter')
-        degree = kwargs.get('degree')
-        knotvector = kwargs.get('knotvector')
-        ctrlpts = kwargs.get('ctrlpts')
-        ctrlpts_size = kwargs.get('ctrlpts_size')
-        dimension = kwargs.get('dimension')
-        precision = kwargs.get('precision')
-
-        spt = self.evaluate(start=param, stop=param, degree=degree, knotvector=knotvector, ctrlpts=ctrlpts,
-                            ctrlpts_size=ctrlpts_size, sample_size=(1, 1), dimension=dimension, precision=precision)
-
-        return spt[0]
-
     def evaluate(self, **kwargs):
         """ Evaluates the surface. """
         # Call parent method
@@ -479,10 +433,10 @@ def evaluate(self, **kwargs):
 
         return eval_points
 
-    def derivatives_single(self, **kwargs):
+    def derivatives(self, **kwargs):
         """ Evaluates the derivatives at the input parameter. """
         # Call parent method
-        super(SurfaceEvaluator, self).derivatives_single(**kwargs)
+        super(SurfaceEvaluator, self).derivatives(**kwargs)
 
         deriv_order = kwargs.get('deriv_order')
         param = kwargs.get('parameter')
@@ -614,7 +568,7 @@ def derivatives_ctrlpts(**kwargs):
 
         return PKL
 
-    def derivatives_single(self, **kwargs):
+    def derivatives(self, **kwargs):
         """ Evaluates the derivatives at the input parameter. """
         deriv_order = kwargs.get('deriv_order')
         param = kwargs.get('parameter')
@@ -691,13 +645,13 @@ def evaluate(self, **kwargs):
 
         return eval_points
 
-    def derivatives_single(self, **kwargs):
+    def derivatives(self, **kwargs):
         """ Evaluates the derivatives at the input parameter. """
         deriv_order = kwargs.get('deriv_order')
         dimension = kwargs.get('dimension')
 
         # Call the parent function to evaluate A(u) and w(u) derivatives
-        SKLw = super(SurfaceEvaluatorRational, self).derivatives_single(**kwargs)
+        SKLw = super(SurfaceEvaluatorRational, self).derivatives(**kwargs)
 
         # Generate an empty list of derivatives
         SKL = [[[0.0 for _ in range(dimension)] for _ in range(deriv_order + 1)] for _ in range(deriv_order + 1)]
@@ -739,24 +693,6 @@ def __init__(self, **kwargs):
         super(VolumeEvaluator, self).__init__(**kwargs)
         self._span_func = kwargs.get('find_span_func', helpers.find_span_linear)
 
-    def evaluate_single(self, **kwargs):
-        """ Evaluates a single point. """
-        # Call parent method
-        super(VolumeEvaluator, self).evaluate_single(**kwargs)
-
-        param = kwargs.get('parameter')
-        degree = kwargs.get('degree')
-        knotvector = kwargs.get('knotvector')
-        ctrlpts = kwargs.get('ctrlpts')
-        ctrlpts_size = kwargs.get('ctrlpts_size')
-        dimension = kwargs.get('dimension')
-        precision = kwargs.get('precision')
-
-        spt = self.evaluate(start=param, stop=param, degree=degree, knotvector=knotvector, ctrlpts=ctrlpts,
-                            ctrlpts_size=ctrlpts_size, sample_size=(1, 1, 1), dimension=dimension, precision=precision)
-
-        return spt[0]
-
     def evaluate(self, **kwargs):
         """ Evaluates the volume. """
         # Call parent method
@@ -802,7 +738,7 @@ def evaluate(self, **kwargs):
 
         return eval_points
 
-    def derivatives_single(self, **kwargs):
+    def derivatives(self, **kwargs):
         """ Evaluates the derivative at the given parametric coordinate. """
         pass
 
@@ -834,6 +770,6 @@ def evaluate(self, **kwargs):
 
         return eval_points
 
-    def derivatives_single(self, **kwargs):
+    def derivatives(self, **kwargs):
         """ Evaluates the derivatives at the input parameter. """
         pass