# This file was automatically generated by SWIG (http://www.swig.org).
# Version 4.0.2
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.

"""
Geom2dAPI module, see official documentation at
https://www.opencascade.com/doc/occt-7.4.0/refman/html/package_geom2dapi.html
"""

from sys import version_info as _swig_python_version_info
if _swig_python_version_info < (2, 7, 0):
    raise RuntimeError("Python 2.7 or later required")

# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _Geom2dAPI
else:
    import _Geom2dAPI

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except __builtin__.Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)


def _swig_setattr_nondynamic_instance_variable(set):
    def set_instance_attr(self, name, value):
        if name == "thisown":
            self.this.own(value)
        elif name == "this":
            set(self, name, value)
        elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
            set(self, name, value)
        else:
            raise AttributeError("You cannot add instance attributes to %s" % self)
    return set_instance_attr


def _swig_setattr_nondynamic_class_variable(set):
    def set_class_attr(cls, name, value):
        if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
            set(cls, name, value)
        else:
            raise AttributeError("You cannot add class attributes to %s" % cls)
    return set_class_attr


def _swig_add_metaclass(metaclass):
    """Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
    def wrapper(cls):
        return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
    return wrapper


class _SwigNonDynamicMeta(type):
    """Meta class to enforce nondynamic attributes (no new attributes) for a class"""
    __setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)


class SwigPyIterator(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Geom2dAPI.delete_SwigPyIterator

    def value(self) -> "PyObject *":
        return _Geom2dAPI.SwigPyIterator_value(self)

    def incr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _Geom2dAPI.SwigPyIterator_incr(self, n)

    def decr(self, n: "size_t"=1) -> "swig::SwigPyIterator *":
        return _Geom2dAPI.SwigPyIterator_decr(self, n)

    def distance(self, x: "SwigPyIterator") -> "ptrdiff_t":
        return _Geom2dAPI.SwigPyIterator_distance(self, x)

    def equal(self, x: "SwigPyIterator") -> "bool":
        return _Geom2dAPI.SwigPyIterator_equal(self, x)

    def copy(self) -> "swig::SwigPyIterator *":
        return _Geom2dAPI.SwigPyIterator_copy(self)

    def next(self) -> "PyObject *":
        return _Geom2dAPI.SwigPyIterator_next(self)

    def __next__(self) -> "PyObject *":
        return _Geom2dAPI.SwigPyIterator___next__(self)

    def previous(self) -> "PyObject *":
        return _Geom2dAPI.SwigPyIterator_previous(self)

    def advance(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _Geom2dAPI.SwigPyIterator_advance(self, n)

    def __eq__(self, x: "SwigPyIterator") -> "bool":
        return _Geom2dAPI.SwigPyIterator___eq__(self, x)

    def __ne__(self, x: "SwigPyIterator") -> "bool":
        return _Geom2dAPI.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _Geom2dAPI.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator &":
        return _Geom2dAPI.SwigPyIterator___isub__(self, n)

    def __add__(self, n: "ptrdiff_t") -> "swig::SwigPyIterator *":
        return _Geom2dAPI.SwigPyIterator___add__(self, n)

    def __sub__(self, *args) -> "ptrdiff_t":
        return _Geom2dAPI.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _Geom2dAPI:
_Geom2dAPI.SwigPyIterator_swigregister(SwigPyIterator)


def _dumps_object(klass):
    """ Overwrite default string output for any wrapped object.
    By default, __repr__ method returns something like:
    <OCC.Core.TopoDS.TopoDS_Shape; proxy of <Swig Object of type 'TopoDS_Shape *' at 0x02BB0758> >
    This is too much verbose.
    We prefer :
    <class 'gp_Pnt'>
    or
    <class 'TopoDS_Shape'>
    """
    klass_name = str(klass.__class__).split(".")[3].split("'")[0]
    repr_string = "<class '" + klass_name + "'"
# for TopoDS_Shape, we also look for the base type
    if klass_name == "TopoDS_Shape":
        if klass.IsNull():
            repr_string += ": Null>"
            return repr_string
        st = klass.ShapeType()
        types = {OCC.Core.TopAbs.TopAbs_VERTEX: "Vertex",
                 OCC.Core.TopAbs.TopAbs_SOLID: "Solid",
                 OCC.Core.TopAbs.TopAbs_EDGE: "Edge",
                 OCC.Core.TopAbs.TopAbs_FACE: "Face",
                 OCC.Core.TopAbs.TopAbs_SHELL: "Shell",
                 OCC.Core.TopAbs.TopAbs_WIRE: "Wire",
                 OCC.Core.TopAbs.TopAbs_COMPOUND: "Compound",
                 OCC.Core.TopAbs.TopAbs_COMPSOLID: "Compsolid"}
        repr_string += "; Type:%s" % types[st]        
    elif hasattr(klass, "IsNull"):
        if klass.IsNull():
            repr_string += "; Null"
    repr_string += ">"
    return repr_string


def process_exception(error: "Standard_Failure", method_name: "std::string", class_name: "std::string") -> "void":
    return _Geom2dAPI.process_exception(error, method_name, class_name)

from six import with_metaclass
import warnings
from OCC.Wrapper.wrapper_utils import Proxy, deprecated

import OCC.Core.Standard
import OCC.Core.NCollection
import OCC.Core.Geom2d
import OCC.Core.gp
import OCC.Core.TColStd
import OCC.Core.TCollection
import OCC.Core.GeomAbs
import OCC.Core.TColgp
import OCC.Core.Extrema
import OCC.Core.math
import OCC.Core.Message
import OCC.Core.OSD
import OCC.Core.Adaptor3d
import OCC.Core.Geom
import OCC.Core.TopAbs
import OCC.Core.Adaptor2d
import OCC.Core.GeomAdaptor
import OCC.Core.Geom2dInt
import OCC.Core.IntRes2d
import OCC.Core.IntCurve
import OCC.Core.Intf
import OCC.Core.Bnd
import OCC.Core.BVH
import OCC.Core.Approx
import OCC.Core.AppCont
import OCC.Core.AppParCurves

from enum import IntEnum
from OCC.Core.Exception import *



class Geom2dAPI_ExtremaCurveCurve(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Computes the extrema between - the portion of the curve c1 limited by the two points of parameter (u1min,u1max), and - the portion of the curve c2 limited by the two points of parameter (u2min,u2max). warning use the function nbextrema to obtain the number of solutions. if this algorithm fails, nbextrema returns 0.

        Parameters
        ----------
        C1: Geom2d_Curve
        C2: Geom2d_Curve
        U1min: float
        U1max: float
        U2min: float
        U2max: float

        Returns
        -------
        None

        """
        _Geom2dAPI.Geom2dAPI_ExtremaCurveCurve_swiginit(self, _Geom2dAPI.new_Geom2dAPI_ExtremaCurveCurve(*args))

    def Distance(self, *args) -> "Standard_Real":
        r"""
        Computes the distance between the end points of the extremum of index index computed by this algorithm. exceptions standard_outofrange if index is not in the range [ 1,nbextrema ], where nbextrema is the number of extrema computed by this algorithm.

        Parameters
        ----------
        Index: int

        Returns
        -------
        float

        """
        return _Geom2dAPI.Geom2dAPI_ExtremaCurveCurve_Distance(self, *args)

    def Extrema(self, *args) -> "Extrema_ExtCC2d const &":
        r"""
        No available documentation.

        Returns
        -------
        Extrema_ExtCC2d

        """
        return _Geom2dAPI.Geom2dAPI_ExtremaCurveCurve_Extrema(self, *args)

    def LowerDistance(self, *args) -> "Standard_Real":
        r"""
        Computes the distance between the end points of the shortest extremum computed by this algorithm. exceptions - stdfail_notdone if this algorithm fails.

        Returns
        -------
        float

        """
        return _Geom2dAPI.Geom2dAPI_ExtremaCurveCurve_LowerDistance(self, *args)

    def LowerDistanceParameters(self, *args) -> "void":
        r"""
        Returns the parameters u1 of the point on the first curve and u2 of the point on the second curve, which are the ends of the shortest extremum computed by this algorithm. exceptions stdfail_notdone if this algorithm fails.

        Parameters
        ----------

        Returns
        -------
        U1: float
        U2: float

        """
        return _Geom2dAPI.Geom2dAPI_ExtremaCurveCurve_LowerDistanceParameters(self, *args)

    def NbExtrema(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of extrema computed by this algorithm. note: if this algorithm fails, nbextrema returns 0.

        Returns
        -------
        int

        """
        return _Geom2dAPI.Geom2dAPI_ExtremaCurveCurve_NbExtrema(self, *args)

    def NearestPoints(self, *args) -> "void":
        r"""
        Returns the points p1 on the first curve and p2 on the second curve, which are the ends of the shortest extremum computed by this algorithm. exceptions stdfail_notdone if this algorithm fails.

        Parameters
        ----------
        P1: gp_Pnt2d
        P2: gp_Pnt2d

        Returns
        -------
        None

        """
        return _Geom2dAPI.Geom2dAPI_ExtremaCurveCurve_NearestPoints(self, *args)

    def Parameters(self, *args) -> "void":
        r"""
        Returns the parameters u1 of the point on the first curve and u2 of the point on the second curve, which are the ends of the extremum of index index computed by this algorithm. exceptions standard_outofrange if index is not in the range [ 1,nbextrema ], where nbextrema is the number of extrema computed by this algorithm.

        Parameters
        ----------
        Index: int

        Returns
        -------
        U1: float
        U2: float

        """
        return _Geom2dAPI.Geom2dAPI_ExtremaCurveCurve_Parameters(self, *args)

    def Points(self, *args) -> "void":
        r"""
        Returns the points p1 on the first curve and p2 on the second curve, which are the ends of the extremum of index index computed by this algorithm. exceptions standard_outofrange if index is not in the range [ 1,nbextrema ], where nbextrema is the number of extrema computed by this algorithm.

        Parameters
        ----------
        Index: int
        P1: gp_Pnt2d
        P2: gp_Pnt2d

        Returns
        -------
        None

        """
        return _Geom2dAPI.Geom2dAPI_ExtremaCurveCurve_Points(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dAPI.delete_Geom2dAPI_ExtremaCurveCurve

# Register Geom2dAPI_ExtremaCurveCurve in _Geom2dAPI:
_Geom2dAPI.Geom2dAPI_ExtremaCurveCurve_swigregister(Geom2dAPI_ExtremaCurveCurve)

class Geom2dAPI_InterCurveCurve(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Create an empty intersector. use the function init for further initialization of the intersection algorithm by curves or curve.

        Returns
        -------
        None
        Creates an object and computes the intersections between the curves c1 and c2.

        Parameters
        ----------
        C1: Geom2d_Curve
        C2: Geom2d_Curve
        Tol: float,optional
        	default value is 1.0e-6

        Returns
        -------
        None
        Creates an object and computes self-intersections of the curve c1. tolerance value tol, defaulted to 1.0e-6, defines the precision of computing the intersection points. in case of a tangential intersection, tol also defines the size of intersection segments (limited portions of the curves) where the distance between all points from two curves (or a curve in case of self-intersection) is less than tol. warning use functions nbpoints and nbsegments to obtain the number of solutions. if the algorithm finds no intersections nbpoints and nbsegments return 0.

        Parameters
        ----------
        C1: Geom2d_Curve
        Tol: float,optional
        	default value is 1.0e-6

        Returns
        -------
        None

        """
        _Geom2dAPI.Geom2dAPI_InterCurveCurve_swiginit(self, _Geom2dAPI.new_Geom2dAPI_InterCurveCurve(*args))

    def Init(self, *args) -> "void":
        r"""
        Initializes an algorithm with the given arguments and computes the intersections between the curves c1. and c2.

        Parameters
        ----------
        C1: Geom2d_Curve
        C2: Geom2d_Curve
        Tol: float,optional
        	default value is 1.0e-6

        Returns
        -------
        None
        Initializes an algorithm with the given arguments and computes the self-intersections of the curve c1. tolerance value tol, defaulted to 1.0e-6, defines the precision of computing the intersection points. in case of a tangential intersection, tol also defines the size of intersection segments (limited portions of the curves) where the distance between all points from two curves (or a curve in case of self-intersection) is less than tol. warning use functions nbpoints and nbsegments to obtain the number of solutions. if the algorithm finds no intersections nbpoints and nbsegments return 0.

        Parameters
        ----------
        C1: Geom2d_Curve
        Tol: float,optional
        	default value is 1.0e-6

        Returns
        -------
        None

        """
        return _Geom2dAPI.Geom2dAPI_InterCurveCurve_Init(self, *args)

    def Intersector(self, *args) -> "Geom2dInt_GInter const &":
        r"""
        Return the algorithmic object from intersection.

        Returns
        -------
        Geom2dInt_GInter

        """
        return _Geom2dAPI.Geom2dAPI_InterCurveCurve_Intersector(self, *args)

    def NbPoints(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of intersection-points in case of cross intersections. nbpoints returns 0 if no intersections were found.

        Returns
        -------
        int

        """
        return _Geom2dAPI.Geom2dAPI_InterCurveCurve_NbPoints(self, *args)

    def NbSegments(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of tangential intersections. nbsegments returns 0 if no intersections were found.

        Returns
        -------
        int

        """
        return _Geom2dAPI.Geom2dAPI_InterCurveCurve_NbSegments(self, *args)

    def Point(self, *args) -> "gp_Pnt2d":
        r"""
        Returns the intersection point of index index. intersection points are computed in case of cross intersections with a precision equal to the tolerance value assigned at the time of construction or in the function init (this value is defaulted to 1.0e-6). exceptions standard_outofrange if index is not in the range [ 1,nbpoints ], where nbpoints is the number of computed intersection points.

        Parameters
        ----------
        Index: int

        Returns
        -------
        gp_Pnt2d

        """
        return _Geom2dAPI.Geom2dAPI_InterCurveCurve_Point(self, *args)

    def Segment(self, *args) -> "void":
        r"""
        Use this syntax only to get solutions of tangential intersection between two curves. output values curve1 and curve2 are the intersection segments on the first curve and on the second curve accordingly. parameter index defines a number of computed solution. an intersection segment is a portion of an initial curve limited by two points. the distance from each point of this segment to the other curve is less or equal to the tolerance value assigned at the time of construction or in function init (this value is defaulted to 1.0e-6). exceptions standard_outofrange if index is not in the range [ 1,nbsegments ], where nbsegments is the number of computed tangential intersections. standard_nullobject if the algorithm is initialized for the computing of self-intersections on a curve.

        Parameters
        ----------
        Index: int
        Curve1: Geom2d_Curve
        Curve2: Geom2d_Curve

        Returns
        -------
        None

        """
        return _Geom2dAPI.Geom2dAPI_InterCurveCurve_Segment(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dAPI.delete_Geom2dAPI_InterCurveCurve

# Register Geom2dAPI_InterCurveCurve in _Geom2dAPI:
_Geom2dAPI.Geom2dAPI_InterCurveCurve_swigregister(Geom2dAPI_InterCurveCurve)

class Geom2dAPI_Interpolate(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Tolerance is to check if the points are not too close to one an other it is also used to check if the tangent vector is not too small. there should be at least 2 points if periodicflag is true then the curve will be periodic.

        Parameters
        ----------
        Points: TColgp_HArray1OfPnt2d
        PeriodicFlag: bool
        Tolerance: float

        Returns
        -------
        None
        If periodicflag is true then the curve will be periodic warning: there should be as many parameters as there are points except if periodicflag is true : then there should be one more parameter to close the curve.

        Parameters
        ----------
        Points: TColgp_HArray1OfPnt2d
        Parameters: TColStd_HArray1OfReal
        PeriodicFlag: bool
        Tolerance: float

        Returns
        -------
        None

        """
        _Geom2dAPI.Geom2dAPI_Interpolate_swiginit(self, _Geom2dAPI.new_Geom2dAPI_Interpolate(*args))

    def Curve(self, *args) -> "opencascade::handle< Geom2d_BSplineCurve > const &":
        r"""
        Returns the computed bspline curve. raises stdfail_notdone if the interpolation fails.

        Returns
        -------
        opencascade::handle<Geom2d_BSplineCurve>

        """
        return _Geom2dAPI.Geom2dAPI_Interpolate_Curve(self, *args)

    def IsDone(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the constrained bspline curve is successfully constructed. note: in this case, the result is given by the function curve.

        Returns
        -------
        bool

        """
        return _Geom2dAPI.Geom2dAPI_Interpolate_IsDone(self, *args)

    def Load(self, *args) -> "void":
        r"""
        Assigns this constrained bspline curve to be tangential to vectors initialtangent and finaltangent at its first and last points respectively (i.e. the first and last points of the table of points through which the curve passes, as defined at the time of initialization). <scale> - boolean flag defining whether tangent vectors are to be scaled according to derivatives of lagrange interpolation.

        Parameters
        ----------
        InitialTangent: gp_Vec2d
        FinalTangent: gp_Vec2d
        Scale: bool,optional
        	default value is Standard_True

        Returns
        -------
        None
        Assigns this constrained bspline curve to be tangential to vectors defined in the table tangents, which is parallel to the table of points through which the curve passes, as defined at the time of initialization. vectors in the table tangents are defined only if the flag given in the parallel table tangentflags is true: only these vectors are set as tangency constraints. <scale> - boolean flag defining whether tangent vectors are to be scaled according to derivatives of lagrange interpolation.

        Parameters
        ----------
        Tangents: TColgp_Array1OfVec2d
        TangentFlags: TColStd_HArray1OfBoolean
        Scale: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        return _Geom2dAPI.Geom2dAPI_Interpolate_Load(self, *args)

    def Perform(self, *args) -> "void":
        r"""
        Computes the constrained bspline curve. use the function isdone to verify that the computation is successful, and then the function curve to obtain the result.

        Returns
        -------
        None

        """
        return _Geom2dAPI.Geom2dAPI_Interpolate_Perform(self, *args)

    __repr__ = _dumps_object

    @methodnotwrapped
    def ClearTangents(self):
    	pass

    __swig_destroy__ = _Geom2dAPI.delete_Geom2dAPI_Interpolate

# Register Geom2dAPI_Interpolate in _Geom2dAPI:
_Geom2dAPI.Geom2dAPI_Interpolate_swigregister(Geom2dAPI_Interpolate)

class Geom2dAPI_PointsToBSpline(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Constructs an empty approximation algorithm. use an init function to define and build the bspline curve.

        Returns
        -------
        None
        Approximate a bspline curve passing through an array of point. the resulting bspline will have the following properties: 1- his degree will be in the range [degmin,degmax] 2- his continuity will be at least <continuity> 3- the distance from the point <points> to the bspline will be lower to tol2d.

        Parameters
        ----------
        Points: TColgp_Array1OfPnt2d
        DegMin: int,optional
        	default value is 3
        DegMax: int,optional
        	default value is 8
        Continuity: GeomAbs_Shape,optional
        	default value is GeomAbs_C2
        Tol2D: float,optional
        	default value is 1.0e-6

        Returns
        -------
        None
        Approximate a bspline curve passing through an array of point. of coordinates : //! x = x0 + dx * (i-yvalues.lower()) y = yvalues(i) //! with i in the range yvalues.lower(), yvalues.upper() //! the bspline will be parametrized from t = x0 to x0 + dx * (yvalues.upper() - yvalues.lower()) //! and will satisfy x(t) = t //! the resulting bspline will have the following properties: 1- his degree will be in the range [degmin,degmax] 2- his continuity will be at least <continuity> 3- the distance from the point <points> to the bspline will be lower to tol2d.

        Parameters
        ----------
        YValues: TColStd_Array1OfReal
        X0: float
        DX: float
        DegMin: int,optional
        	default value is 3
        DegMax: int,optional
        	default value is 8
        Continuity: GeomAbs_Shape,optional
        	default value is GeomAbs_C2
        Tol2D: float,optional
        	default value is 1.0e-6

        Returns
        -------
        None
        Approximate a bspline curve passing through an array of point. the resulting bspline will have the following properties: 1- his degree will be in the range [degmin,degmax] 2- his continuity will be at least <continuity> 3- the distance from the point <points> to the bspline will be lower to tol2d.

        Parameters
        ----------
        Points: TColgp_Array1OfPnt2d
        ParType: Approx_ParametrizationType
        DegMin: int,optional
        	default value is 3
        DegMax: int,optional
        	default value is 8
        Continuity: GeomAbs_Shape,optional
        	default value is GeomAbs_C2
        Tol2D: float,optional
        	default value is 1.0e-3

        Returns
        -------
        None
        Approximate a bspline curve passing through an array of point, which parameters are given by the array <parameters>. the resulting bspline will have the following properties: 1- his degree will be in the range [degmin,degmax] 2- his continuity will be at least <continuity> 3- the distance from the point <points> to the bspline will be lower to tol2d.

        Parameters
        ----------
        Points: TColgp_Array1OfPnt2d
        Parameters: TColStd_Array1OfReal
        DegMin: int,optional
        	default value is 3
        DegMax: int,optional
        	default value is 8
        Continuity: GeomAbs_Shape,optional
        	default value is GeomAbs_C2
        Tol2D: float,optional
        	default value is 1.0e-3

        Returns
        -------
        None
        Approximate a bspline curve passing through an array of point using variational smoothing algorithm, which tries to minimize additional criterium: weight1*curvelength + weight2*curvature + weight3*torsion.

        Parameters
        ----------
        Points: TColgp_Array1OfPnt2d
        Weight1: float
        Weight2: float
        Weight3: float
        DegMax: int,optional
        	default value is 8
        Continuity: GeomAbs_Shape,optional
        	default value is GeomAbs_C2
        Tol3D: float,optional
        	default value is 1.0e-3

        Returns
        -------
        None

        """
        _Geom2dAPI.Geom2dAPI_PointsToBSpline_swiginit(self, _Geom2dAPI.new_Geom2dAPI_PointsToBSpline(*args))

    def Curve(self, *args) -> "opencascade::handle< Geom2d_BSplineCurve > const &":
        r"""
        Returns the approximate bspline curve.

        Returns
        -------
        opencascade::handle<Geom2d_BSplineCurve>

        """
        return _Geom2dAPI.Geom2dAPI_PointsToBSpline_Curve(self, *args)

    def Init(self, *args) -> "void":
        r"""
        Approximate a bspline curve passing through an array of point. the resulting bspline will have the following properties: 1- his degree will be in the range [degmin,degmax] 2- his continuity will be at least <continuity> 3- the distance from the point <points> to the bspline will be lower to tol2d.

        Parameters
        ----------
        Points: TColgp_Array1OfPnt2d
        DegMin: int,optional
        	default value is 3
        DegMax: int,optional
        	default value is 8
        Continuity: GeomAbs_Shape,optional
        	default value is GeomAbs_C2
        Tol2D: float,optional
        	default value is 1.0e-6

        Returns
        -------
        None
        Approximate a bspline curve passing through an array of point. of coordinates : //! x = x0 + dx * (i-yvalues.lower()) y = yvalues(i) //! with i in the range yvalues.lower(), yvalues.upper() //! the bspline will be parametrized from t = x0 to x0 + dx * (yvalues.upper() - yvalues.lower()) //! and will satisfy x(t) = t //! the resulting bspline will have the following properties: 1- his degree will be in the range [degmin,degmax] 2- his continuity will be at least <continuity> 3- the distance from the point <points> to the bspline will be lower to tol2d.

        Parameters
        ----------
        YValues: TColStd_Array1OfReal
        X0: float
        DX: float
        DegMin: int,optional
        	default value is 3
        DegMax: int,optional
        	default value is 8
        Continuity: GeomAbs_Shape,optional
        	default value is GeomAbs_C2
        Tol2D: float,optional
        	default value is 1.0e-6

        Returns
        -------
        None
        Approximate a bspline curve passing through an array of point. the resulting bspline will have the following properties: 1- his degree will be in the range [degmin,degmax] 2- his continuity will be at least <continuity> 3- the distance from the point <points> to the bspline will be lower to tol2d.

        Parameters
        ----------
        Points: TColgp_Array1OfPnt2d
        ParType: Approx_ParametrizationType
        DegMin: int,optional
        	default value is 3
        DegMax: int,optional
        	default value is 8
        Continuity: GeomAbs_Shape,optional
        	default value is GeomAbs_C2
        Tol2D: float,optional
        	default value is 1.0e-3

        Returns
        -------
        None
        Approximate a bspline curve passing through an array of point, which parameters are given by the array <parameters>. the resulting bspline will have the following properties: 1- his degree will be in the range [degmin,degmax] 2- his continuity will be at least <continuity> 3- the distance from the point <points> to the bspline will be lower to tol2d.

        Parameters
        ----------
        Points: TColgp_Array1OfPnt2d
        Parameters: TColStd_Array1OfReal
        DegMin: int,optional
        	default value is 3
        DegMax: int,optional
        	default value is 8
        Continuity: GeomAbs_Shape,optional
        	default value is GeomAbs_C2
        Tol2D: float,optional
        	default value is 1.0e-3

        Returns
        -------
        None
        Approximate a bspline curve passing through an array of point using variational smoothing algorithm, which tries to minimize additional criterium: weight1*curvelength + weight2*curvature + weight3*torsion.

        Parameters
        ----------
        Points: TColgp_Array1OfPnt2d
        Weight1: float
        Weight2: float
        Weight3: float
        DegMax: int,optional
        	default value is 8
        Continuity: GeomAbs_Shape,optional
        	default value is GeomAbs_C2
        Tol2D: float,optional
        	default value is 1.0e-3

        Returns
        -------
        None

        """
        return _Geom2dAPI.Geom2dAPI_PointsToBSpline_Init(self, *args)

    def IsDone(self, *args) -> "Standard_Boolean":
        r"""
        No available documentation.

        Returns
        -------
        bool

        """
        return _Geom2dAPI.Geom2dAPI_PointsToBSpline_IsDone(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dAPI.delete_Geom2dAPI_PointsToBSpline

# Register Geom2dAPI_PointsToBSpline in _Geom2dAPI:
_Geom2dAPI.Geom2dAPI_PointsToBSpline_swigregister(Geom2dAPI_PointsToBSpline)

class Geom2dAPI_ProjectPointOnCurve(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        Constructs an empty projector algorithm. use an init function to define the point and the curve on which it is going to work.

        Returns
        -------
        None
        Create the projection of a point <p> on a curve <curve>.

        Parameters
        ----------
        P: gp_Pnt2d
        Curve: Geom2d_Curve

        Returns
        -------
        None
        Create the projection of a point <p> on a curve <curve> limited by the two points of parameter umin and usup. warning use the function nbpoints to obtain the number of solutions. if projection fails, nbpoints returns 0.

        Parameters
        ----------
        P: gp_Pnt2d
        Curve: Geom2d_Curve
        Umin: float
        Usup: float

        Returns
        -------
        None

        """
        _Geom2dAPI.Geom2dAPI_ProjectPointOnCurve_swiginit(self, _Geom2dAPI.new_Geom2dAPI_ProjectPointOnCurve(*args))

    def Distance(self, *args) -> "Standard_Real":
        r"""
        Computes the distance between the point and its computed orthogonal projection on the curve. index is a number of computed projected point. exceptions standard_outofrange if index is not in the range [ 1,nbpoints ], where nbpoints is the number of solution points.

        Parameters
        ----------
        Index: int

        Returns
        -------
        float

        """
        return _Geom2dAPI.Geom2dAPI_ProjectPointOnCurve_Distance(self, *args)

    def Extrema(self, *args) -> "Extrema_ExtPC2d const &":
        r"""
        Return the algorithmic object from extrema.

        Returns
        -------
        Extrema_ExtPC2d

        """
        return _Geom2dAPI.Geom2dAPI_ProjectPointOnCurve_Extrema(self, *args)

    def Init(self, *args) -> "void":
        r"""
        Initializes this algorithm with the given arguments, and computes the orthogonal projections of a point <p> on a curve <curve>.

        Parameters
        ----------
        P: gp_Pnt2d
        Curve: Geom2d_Curve

        Returns
        -------
        None
        Initializes this algorithm with the given arguments, and computes the orthogonal projections of the point p onto the portion of the curve curve limited by the two points of parameter umin and usup.

        Parameters
        ----------
        P: gp_Pnt2d
        Curve: Geom2d_Curve
        Umin: float
        Usup: float

        Returns
        -------
        None

        """
        return _Geom2dAPI.Geom2dAPI_ProjectPointOnCurve_Init(self, *args)

    def LowerDistance(self, *args) -> "Standard_Real":
        r"""
        Computes the distance between the point and its nearest orthogonal projection on the curve. exceptions stdfail_notdone if this algorithm fails.

        Returns
        -------
        float

        """
        return _Geom2dAPI.Geom2dAPI_ProjectPointOnCurve_LowerDistance(self, *args)

    def LowerDistanceParameter(self, *args) -> "Standard_Real":
        r"""
        Returns the parameter on the curve of the nearest orthogonal projection of the point. exceptions stdfail_notdone if this algorithm fails.

        Returns
        -------
        float

        """
        return _Geom2dAPI.Geom2dAPI_ProjectPointOnCurve_LowerDistanceParameter(self, *args)

    def NbPoints(self, *args) -> "Standard_Integer":
        r"""
        Return the number of of computed orthogonal projectionn points.

        Returns
        -------
        int

        """
        return _Geom2dAPI.Geom2dAPI_ProjectPointOnCurve_NbPoints(self, *args)

    def NearestPoint(self, *args) -> "gp_Pnt2d":
        r"""
        Returns the nearest orthogonal projection of the point on the curve. exceptions stdfail_notdone if this algorithm fails.

        Returns
        -------
        gp_Pnt2d

        """
        return _Geom2dAPI.Geom2dAPI_ProjectPointOnCurve_NearestPoint(self, *args)

    def Parameter(self, *args) -> "void":
        r"""
        Returns the parameter on the curve of a point which is the orthogonal projection. index is a number of a computed projected point. exceptions standard_outofrange if index is not in the range [ 1,nbpoints ], where nbpoints is the number of solution points.

        Parameters
        ----------
        Index: int

        Returns
        -------
        float
        Returns the parameter on the curve of a point which is the orthogonal projection. index is a number of a computed projected point. exceptions standard_outofrange if index is not in the range [ 1,nbpoints ], where nbpoints is the number of solution points.

        Parameters
        ----------
        Index: int

        Returns
        -------
        U: float

        """
        return _Geom2dAPI.Geom2dAPI_ProjectPointOnCurve_Parameter(self, *args)

    def Point(self, *args) -> "gp_Pnt2d":
        r"""
        Returns the orthogonal projection on the curve. index is a number of a computed point. exceptions standard_outofrange if index is not in the range [ 1,nbpoints ], where nbpoints is the number of solution points.

        Parameters
        ----------
        Index: int

        Returns
        -------
        gp_Pnt2d

        """
        return _Geom2dAPI.Geom2dAPI_ProjectPointOnCurve_Point(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dAPI.delete_Geom2dAPI_ProjectPointOnCurve

# Register Geom2dAPI_ProjectPointOnCurve in _Geom2dAPI:
_Geom2dAPI.Geom2dAPI_ProjectPointOnCurve_swigregister(Geom2dAPI_ProjectPointOnCurve)





