Removed deprecated functionality to maintain compatibility

Author: Onur Rauf Bingol

geomdl/BSpline.py

@@ -284,65 +284,40 @@ def remove_knot(self, param, **kwargs):
     def tangent(self, parpos, **kwargs):
         """ Evaluates the tangent vector of the curve at the given parametric position(s).
 
-        The ``parpos`` argument can be
+        .. deprecated: 5.3.0
 
-        * a float value for evaluation at a single parametric position
-        * a list of float values for evaluation at the multiple parametric positions
-
-        The return value will be in the order of the input parametric position list.
-
-        This method accepts the following keyword arguments:
-
-        * ``normalize``: normalizes the output vector. Default value is *True*.
+            Please use :func:`operations.tangent` instead.
 
         :param parpos: parametric position(s) where the evaluation will be executed
         :type parpos: float, list or tuple
         :return: tangent vector as a tuple of the origin point and the vector components
         :rtype: tuple
         """
-        return operations.tangent(self, parpos, **kwargs)
+        return tuple()
 
     def normal(self, parpos, **kwargs):
         """ Evaluates the normal to the tangent vector of the curve at the given parametric position(s).
 
-        The ``parpos`` argument can be
-
-        * a float value for evaluation at a single parametric position
-        * a list of float values for evaluation at the multiple parametric positions
-
-        The return value will be in the order of the input parametric position list.
-
-        This method accepts the following keyword arguments:
-
-        * ``normalize``: normalizes the output vector. Default value is *True*.
+        .. deprecated: 5.3.0
 
         :param parpos: parametric position(s) where the evaluation will be executed
         :type parpos: float, list or tuple
         :return: normal vector as a tuple of the origin point and the vector components
         :rtype: tuple
         """
-        return operations.normal(self, parpos, **kwargs)
+        return tuple()
 
     def binormal(self, parpos, **kwargs):
         """ Evaluates the binormal vector of the curve at the given parametric position(s).
 
-        The ``parpos`` argument can be
-
-        * a float value for evaluation at a single parametric position
-        * a list of float values for evaluation at the multiple parametric positions
-
-        The return value will be in the order of the input parametric position list.
-
-        This method accepts the following keyword arguments:
-
-        * ``normalize``: normalizes the output vector. Default value is *True*.
+        .. deprecated: 5.3.0
 
         :param parpos: parametric position(s) where the evaluation will be executed
         :type parpos: float, list or tuple
         :return: binormal vector as a tuple of the origin point and the vector components
         :rtype: tuple
         """
-        return operations.binormal(self, parpos, **kwargs)
+        return tuple()
 
 
 @utl.export
@@ -777,46 +752,30 @@ def remove_knot(self, u=None, v=None, **kwargs):
     def tangent(self, parpos, **kwargs):
         """ Evaluates the tangent vectors of the surface at the given parametric position(s).
 
-        The ``param`` argument can be
-
-        * a float value for evaluation at a single parametric position
-        * a list of float values for evaluation at the multiple parametric positions
-
-        The parametric positions should be a pair of (u,v) values. The return value will be in the order of the input
-        parametric position list.
+        .. deprecated: 5.3.0
 
-        This method accepts the following keyword arguments:
-
-        * ``normalize``: normalizes the output vector. Default value is *True*.
+            Please use :func:`operations.tangent` instead.
 
         :param parpos: parametric position(s) where the evaluation will be executed
         :type parpos: list or tuple
         :return: an array containing "point" and "vector"s on u- and v-directions, respectively
         :rtype: tuple
         """
-        return operations.tangent(self, parpos, **kwargs)
+        return tuple()
 
     def normal(self, parpos, **kwargs):
         """ Evaluates the normal vector of the surface at the given parametric position(s).
 
-        The ``param`` argument can be
-
-        * a float value for evaluation at a single parametric position
-        * a list of float values for evaluation at the multiple parametric positions
-
-        The parametric positions should be a pair of (u,v) values. The return value will be in the order of the input
-        parametric position list.
-
-        This method accepts the following keyword arguments:
+        .. deprecated: 5.3.0
 
-        * ``normalize``: normalizes the output vector. Default value is *True*.
+            Please use :func:`operations.normal` instead.
 
         :param parpos: parametric position(s) where the evaluation will be executed
         :type parpos: list or tuple
         :return: an array containing "point" and "vector" pairs
         :rtype: tuple
         """
-        return operations.normal(self, parpos, **kwargs)
+        return tuple()
 
 
 @utl.export

geomdl/_operations.py

@@ -57,99 +57,6 @@ def tangent_curve_single_list(obj, param_list, normalize):
     return tuple(ret_vector)
 
 
-def normal_curve_single(obj, u, normalize):
-    """ Evaluates the vector normal to the tangent vector at the input parameter, u.
-
-    The output returns a list containing the starting point (i.e. origin) of the vector and the vector itself.
-
-    :param obj: input curve
-    :type obj: abstract.Curve
-    :param u: parameter
-    :type u: float
-    :param normalize: if True, the returned vector is converted to a unit vector
-    :type normalize: bool
-    :return: a list containing "point" and "vector" pairs
-    :rtype: tuple
-    """
-    # Find 1st derivative
-    ders = obj.derivatives(u, 1)
-
-    # Apply fix on https://github.com/orbingol/NURBS-Python/pull/50#issuecomment-499354073
-    t = ders[1]
-    tn = [0.0, 0.0, 1.0]
-    n = linalg.vector_cross(t, tn)
-
-    # Normalize the vector component
-    vector = linalg.vector_normalize(n) if normalize else n
-    point = ders[0]
-
-    return tuple(point), tuple(vector)
-
-
-def normal_curve_single_list(obj, param_list, normalize):
-    """ Evaluates the curve normal vectors at the given list of parameter values.
-
-    :param obj: input curve
-    :type obj: abstract.Curve
-    :param param_list: parameter list
-    :type param_list: list or tuple
-    :param normalize: if True, the returned vector is converted to a unit vector
-    :type normalize: bool
-    :return: a list containing "point" and "vector" pairs
-    :rtype: tuple
-    """
-    ret_vector = []
-    for param in param_list:
-        temp = normal_curve_single(obj, param, normalize)
-        ret_vector.append(temp)
-    return tuple(ret_vector)
-
-
-def binormal_curve_single(obj, u, normalize):
-    """ Evaluates the curve binormal vector at the given u parameter.
-
-    Curve binormal is the cross product of the normal and the tangent vectors.
-    The output returns a list containing the starting point (i.e. origin) of the vector and the vector itself.
-
-    :param obj: input curve
-    :type obj: abstract.Curve
-    :param u: parameter
-    :type u: float
-    :param normalize: if True, the returned vector is converted to a unit vector
-    :type normalize: bool
-    :return: a list containing "point" and "vector" pairs
-    :rtype: tuple
-    """
-    # Cross product of tangent and normal vectors gives binormal vector
-    tan_vector = tangent_curve_single(obj, u, normalize)
-    norm_vector = normal_curve_single(obj, u, normalize)
-
-    point = tan_vector[0]
-    vector = linalg.vector_cross(tan_vector[1], norm_vector[1])
-    vector = linalg.vector_normalize(vector) if normalize else vector
-
-    return tuple(point), tuple(vector)
-
-
-def binormal_curve_single_list(obj, param_list, normalize):
-    """ Evaluates the curve binormal vectors at the given list of parameter values.
-
-    :param obj: input curve
-    :type obj: abstract.Curve
-    :param param_list: parameter list
-    :type param_list: list or tuple
-    :param normalize: if True, the returned vector is converted to a unit vector
-    :type normalize: bool
-    :return: a list containing "point" and "vector" pairs
-    :rtype: tuple
-    """
-    ret_vector = []
-    for param in param_list:
-        temp = binormal_curve_single(obj, param, normalize)
-        ret_vector.append(temp)
-    return tuple(ret_vector)
-
-
 def tangent_surface_single(obj, uv, normalize):
     """ Evaluates the surface tangent vector at the given (u,v) parameter pair.
 

geomdl/operations.py

@@ -1421,41 +1421,14 @@ def normal(obj, params, **kwargs):
     """
     normalize = kwargs.get('normalize', True)
     if isinstance(obj, abstract.Curve):
-        if isinstance(params, (list, tuple)):
-            return ops.normal_curve_single_list(obj, params, normalize)
-        else:
-            return ops.normal_curve_single(obj, params, normalize)
+        raise GeomdlException("Not implemented for curves")
     if isinstance(obj, abstract.Surface):
         if isinstance(params[0], float):
             return ops.normal_surface_single(obj, params, normalize)
         else:
             return ops.normal_surface_single_list(obj, params, normalize)
 
 
-@export
-def binormal(obj, params, **kwargs):
-    """ Evaluates the binormal vector of the curves or surfaces at the input parameter values.
-
-    This function is designed to evaluate binormal vectors of the B-Spline and NURBS shapes at single or
-    multiple parameter positions.
-
-    :param obj: input shape
-    :type obj: abstract.Curve or abstract.Surface
-    :param params: parameters
-    :type params: float, list or tuple
-    :return: a list containing "point" and "vector" pairs
-    :rtype: tuple
-    """
-    normalize = kwargs.get('normalize', True)
-    if isinstance(obj, abstract.Curve):
-        if isinstance(params, (list, tuple)):
-            return ops.binormal_curve_single_list(obj, params, normalize)
-        else:
-            return ops.binormal_curve_single(obj, params, normalize)
-    if isinstance(obj, abstract.Surface):
-        raise GeomdlException("Binormal vector evaluation for the surfaces is not implemented!")
-
-
 @export
 def translate(obj, vec, **kwargs):
     """ Translates curves, surface or volumes by the input vector.