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

"""
Geom2dGcc module, see official documentation at
https://www.opencascade.com/doc/occt-7.4.0/refman/html/package_geom2dgcc.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 _Geom2dGcc
else:
    import _Geom2dGcc

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _Geom2dGcc.SWIG_PyInstanceMethod_New
_swig_new_static_method = _Geom2dGcc.SWIG_PyStaticMethod_New

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__ = _Geom2dGcc.delete_SwigPyIterator
    value = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator_value)
    incr = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator_incr)
    decr = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator_decr)
    distance = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator_distance)
    equal = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator_equal)
    copy = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator_copy)
    next = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator_next)
    __next__ = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator___next__)
    previous = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator_previous)
    advance = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator_advance)
    __eq__ = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator___eq__)
    __ne__ = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator___ne__)
    __iadd__ = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator___iadd__)
    __isub__ = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator___isub__)
    __add__ = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator___add__)
    __sub__ = _swig_new_instance_method(_Geom2dGcc.SwigPyIterator___sub__)
    def __iter__(self):
        return self

# Register SwigPyIterator in _Geom2dGcc:
_Geom2dGcc.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


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.Geom2dAdaptor
import OCC.Core.Adaptor2d
import OCC.Core.Geom2d
import OCC.Core.gp
import OCC.Core.GeomAbs
import OCC.Core.TColgp
import OCC.Core.TColStd
import OCC.Core.TCollection
import OCC.Core.GccAna
import OCC.Core.GccEnt
import OCC.Core.GccInt
import OCC.Core.math
import OCC.Core.Message
Geom2dGcc_CuCuOnCu = _Geom2dGcc.Geom2dGcc_CuCuOnCu
Geom2dGcc_CiCuOnCu = _Geom2dGcc.Geom2dGcc_CiCuOnCu
Geom2dGcc_LiCuOnCu = _Geom2dGcc.Geom2dGcc_LiCuOnCu
Geom2dGcc_CuPtOnCu = _Geom2dGcc.Geom2dGcc_CuPtOnCu
Geom2dGcc_CuCuOnLi = _Geom2dGcc.Geom2dGcc_CuCuOnLi
Geom2dGcc_CiCuOnLi = _Geom2dGcc.Geom2dGcc_CiCuOnLi
Geom2dGcc_LiCuOnLi = _Geom2dGcc.Geom2dGcc_LiCuOnLi
Geom2dGcc_CuPtOnLi = _Geom2dGcc.Geom2dGcc_CuPtOnLi
Geom2dGcc_CuCuOnCi = _Geom2dGcc.Geom2dGcc_CuCuOnCi
Geom2dGcc_CiCuOnCi = _Geom2dGcc.Geom2dGcc_CiCuOnCi
Geom2dGcc_LiCuOnCi = _Geom2dGcc.Geom2dGcc_LiCuOnCi
Geom2dGcc_CuPtOnCi = _Geom2dGcc.Geom2dGcc_CuPtOnCi
Geom2dGcc_CuCu = _Geom2dGcc.Geom2dGcc_CuCu
Geom2dGcc_CiCu = _Geom2dGcc.Geom2dGcc_CiCu
Geom2dGcc_CuCuCu = _Geom2dGcc.Geom2dGcc_CuCuCu
Geom2dGcc_CiCuCu = _Geom2dGcc.Geom2dGcc_CiCuCu
Geom2dGcc_CiCiCu = _Geom2dGcc.Geom2dGcc_CiCiCu
Geom2dGcc_CiLiCu = _Geom2dGcc.Geom2dGcc_CiLiCu
Geom2dGcc_LiLiCu = _Geom2dGcc.Geom2dGcc_LiLiCu
Geom2dGcc_LiCuCu = _Geom2dGcc.Geom2dGcc_LiCuCu
class geom2dgcc(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Enclosed = _swig_new_static_method(_Geom2dGcc.geom2dgcc_Enclosed)
    Enclosing = _swig_new_static_method(_Geom2dGcc.geom2dgcc_Enclosing)
    Outside = _swig_new_static_method(_Geom2dGcc.geom2dgcc_Outside)
    Unqualified = _swig_new_static_method(_Geom2dGcc.geom2dgcc_Unqualified)

    __repr__ = _dumps_object


    def __init__(self):
        _Geom2dGcc.geom2dgcc_swiginit(self, _Geom2dGcc.new_geom2dgcc())
    __swig_destroy__ = _Geom2dGcc.delete_geom2dgcc

# Register geom2dgcc in _Geom2dGcc:
_Geom2dGcc.geom2dgcc_swigregister(geom2dgcc)
geom2dgcc_Enclosed = _Geom2dGcc.geom2dgcc_Enclosed
geom2dgcc_Enclosing = _Geom2dGcc.geom2dgcc_Enclosing
geom2dgcc_Outside = _Geom2dGcc.geom2dgcc_Outside
geom2dgcc_Unqualified = _Geom2dGcc.geom2dgcc_Unqualified

class Geom2dGcc_Circ2d2TanOn(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CenterOn3 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOn_CenterOn3)

    def __init__(self, *args):
        r"""
        * This method implements the algorithms used to create 2d circles TANgent to two curves and having the center ON a 2d curve. Param1 is the initial guess on the first curve QualifiedCurv. Param1 is the initial guess on the second curve QualifiedCurv. ParamOn is the initial guess on the center curve OnCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QualifiedCurve
        	:param OnCurve:
        	:type OnCurve: Geom2dAdaptor_Curve
        	:param Tolerance:
        	:type Tolerance: float
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param ParamOn:
        	:type ParamOn: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to one curve and one point and having the center ON a 2d curve. Param1 is the initial guess on the first curve QualifiedCurv. ParamOn is the initial guess on the center curve OnCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param Point:
        	:type Point: Geom2d_Point
        	:param OnCurve:
        	:type OnCurve: Geom2dAdaptor_Curve
        	:param Tolerance:
        	:type Tolerance: float
        	:param Param1:
        	:type Param1: float
        	:param ParamOn:
        	:type ParamOn: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to two points and having the center ON a 2d curve. Tolerance is used for the limit cases.
        	:param Point1:
        	:type Point1: Geom2d_Point
        	:param Point2:
        	:type Point2: Geom2d_Point
        	:param OnCurve:
        	:type OnCurve: Geom2dAdaptor_Curve
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Circ2d2TanOn_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Circ2d2TanOn(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOn_IsDone)
    IsTheSame1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOn_IsTheSame1)
    IsTheSame2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOn_IsTheSame2)
    NbSolutions = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOn_NbSolutions)
    Results = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOn_Results)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOn_Tangency1)
    Tangency2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOn_Tangency2)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOn_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOn_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Circ2d2TanOn

# Register Geom2dGcc_Circ2d2TanOn in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Circ2d2TanOn_swigregister(Geom2dGcc_Circ2d2TanOn)

class Geom2dGcc_Circ2d2TanOnGeo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CenterOn3 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnGeo_CenterOn3)

    def __init__(self, *args):
        r"""
        * This method implements the algorithms used to create 2d circles TANgent to two 2d circles and having the center ON a curve.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param Qualified2:
        	:type Qualified2: GccEnt_QualifiedCirc
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a 2d circle and a 2d line having the center ON a curve.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param Qualified2:
        	:type Qualified2: GccEnt_QualifiedLin
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a 2d circle and a point having the center ON a curve.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param Point2:
        	:type Point2: gp_Pnt2d
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to two 2d lines having the center ON a curve.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedLin
        	:param Qualified2:
        	:type Qualified2: GccEnt_QualifiedLin
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a 2d line and a point having the center ON a 2d line.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedLin
        	:param Qualified2:
        	:type Qualified2: gp_Pnt2d
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to two points having the center ON a 2d line.
        	:param Point1:
        	:type Point1: gp_Pnt2d
        	:param Point2:
        	:type Point2: gp_Pnt2d
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Circ2d2TanOnGeo_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Circ2d2TanOnGeo(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnGeo_IsDone)
    IsTheSame1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnGeo_IsTheSame1)
    IsTheSame2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnGeo_IsTheSame2)
    NbSolutions = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnGeo_NbSolutions)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnGeo_Tangency1)
    Tangency2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnGeo_Tangency2)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnGeo_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnGeo_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Circ2d2TanOnGeo

# Register Geom2dGcc_Circ2d2TanOnGeo in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Circ2d2TanOnGeo_swigregister(Geom2dGcc_Circ2d2TanOnGeo)

class Geom2dGcc_Circ2d2TanOnIter(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CenterOn3 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnIter_CenterOn3)

    def __init__(self, *args):
        r"""
        * This method implements the algorithms used to create 2d circles TANgent to a 2d circle and a curve and having the center ON a 2d line. Param2 is the initial guess on the curve QualifiedCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param OnLine:
        	:type OnLine: gp_Lin2d
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a 2d line and a curve and having the center ON a 2d line. Param2 is the initial guess on the curve QualifiedCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedLin
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param OnLine:
        	:type OnLine: gp_Lin2d
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to two curves and having the center ON a 2d line. Param1 is the initial guess on the first QualifiedCurv. Param2 is the initial guess on the first QualifiedCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param OnLine:
        	:type OnLine: gp_Lin2d
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a 2d point and a curve and having the center ON a 2d line. Param2 is the initial guess on the curve QualifiedCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Point2:
        	:type Point2: gp_Pnt2d
        	:param OnLine:
        	:type OnLine: gp_Lin2d
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a 2d circle and a curve and having the center ON a 2d circle. Param2 is the initial guess on the curve QualifiedCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param OnCirc:
        	:type OnCirc: gp_Circ2d
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a 2d line and a curve and having the center ON a 2d circle. Param2 is the initial guess on the curve QualifiedCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedLin
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param OnCirc:
        	:type OnCirc: gp_Circ2d
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to two curves and having the center ON a 2d circle. Param1 is the initial guess on the first QualifiedCurv. Param2 is the initial guess on the first QualifiedCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param OnCirc:
        	:type OnCirc: gp_Circ2d
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a 2d point and a curve and having the center ON a 2d circle. Param2 is the initial guess on the curve QualifiedCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Point2:
        	:type Point2: gp_Pnt2d
        	:param OnCirc:
        	:type OnCirc: gp_Circ2d
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a 2d circle and a curve and having the center ON a 2d curve. Param2 is the initial guess on the curve QualifiedCurv. ParamOn is the initial guess on the center curve OnCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param ParamOn:
        	:type ParamOn: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a 2d line and a curve and having the center ON a 2d curve. Param2 is the initial guess on the curve QualifiedCurv. ParamOn is the initial guess on the center curve OnCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedLin
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param OnCurve:
        	:type OnCurve: Geom2dAdaptor_Curve
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param ParamOn:
        	:type ParamOn: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a 2d Point and a curve and having the center ON a 2d curve. Param1 is the initial guess on the curve QualifiedCurv. ParamOn is the initial guess on the center curve OnCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Point2:
        	:type Point2: gp_Pnt2d
        	:param OnCurve:
        	:type OnCurve: Geom2dAdaptor_Curve
        	:param Param1:
        	:type Param1: float
        	:param ParamOn:
        	:type ParamOn: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to two curves and having the center ON a 2d curve. Param1 is the initial guess on the first curve QualifiedCurv. Param1 is the initial guess on the second curve QualifiedCurv. ParamOn is the initial guess on the center curve OnCurv. Tolerance is used for the limit cases.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param OnCurve:
        	:type OnCurve: Geom2dAdaptor_Curve
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param ParamOn:
        	:type ParamOn: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Circ2d2TanOnIter_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Circ2d2TanOnIter(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnIter_IsDone)
    IsTheSame1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnIter_IsTheSame1)
    IsTheSame2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnIter_IsTheSame2)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnIter_Tangency1)
    Tangency2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnIter_Tangency2)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnIter_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanOnIter_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Circ2d2TanOnIter

# Register Geom2dGcc_Circ2d2TanOnIter in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Circ2d2TanOnIter_swigregister(Geom2dGcc_Circ2d2TanOnIter)

class Geom2dGcc_Circ2d2TanRad(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"""
        :param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QualifiedCurve
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param Point:
        	:type Point: Geom2d_Point
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* These constructors create one or more 2D circles of radius Radius either - tangential to the 2 curves Qualified1 and Qualified2, or - tangential to the curve Qualified1 and passing through the point Point, or - passing through two points Point1 and Point2. Tolerance is a tolerance criterion used by the algorithm to find a solution when, mathematically, the problem posed does not have a solution, but where there is numeric uncertainty attached to the arguments. For example, take two circles C1 and C2, such that C2 is inside C1, and almost tangential to C1. There is, in fact, no point of intersection between C1 and C2. You now want to find a circle of radius R (smaller than the radius of C2), which is tangential to C1 and C2, and inside these two circles: a pure mathematical resolution will not find a solution. This is where the tolerance criterion is used: the algorithm considers that C1 and C2 are tangential if the shortest distance between these two circles is less than or equal to Tolerance. Thus, a solution is found by the algorithm. Exceptions GccEnt_BadQualifier if a qualifier is inconsistent with the argument it qualifies (for example, enclosing for a line). Standard_NegativeValue if Radius is negative.
        	:param Point1:
        	:type Point1: Geom2d_Point
        	:param Point2:
        	:type Point2: Geom2d_Point
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Circ2d2TanRad_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Circ2d2TanRad(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRad_IsDone)
    IsTheSame1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRad_IsTheSame1)
    IsTheSame2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRad_IsTheSame2)
    NbSolutions = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRad_NbSolutions)
    Results = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRad_Results)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRad_Tangency1)
    Tangency2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRad_Tangency2)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRad_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRad_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Circ2d2TanRad

# Register Geom2dGcc_Circ2d2TanRad in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Circ2d2TanRad_swigregister(Geom2dGcc_Circ2d2TanRad)

class Geom2dGcc_Circ2d2TanRadGeo(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"""
        * This method implements the algorithms used to create 2d circles TANgent to a 2d circle and a curve with a radius of Radius. It raises NegativeValue if Radius is lower than zero.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a 2d line and a curve with a radius of Radius. It raises NegativeValue if Radius is lower than zero.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedLin
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to two curves with a radius of Radius. It raises NegativeValue if Radius is lower than zero.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles TANgent to a curve and a point with a radius of Radius. It raises NegativeValue if Radius is lower than zero.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Point2:
        	:type Point2: gp_Pnt2d
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Circ2d2TanRadGeo_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Circ2d2TanRadGeo(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRadGeo_IsDone)
    IsTheSame1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRadGeo_IsTheSame1)
    IsTheSame2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRadGeo_IsTheSame2)
    NbSolutions = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRadGeo_NbSolutions)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRadGeo_Tangency1)
    Tangency2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRadGeo_Tangency2)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRadGeo_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d2TanRadGeo_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Circ2d2TanRadGeo

# Register Geom2dGcc_Circ2d2TanRadGeo in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Circ2d2TanRadGeo_swigregister(Geom2dGcc_Circ2d2TanRadGeo)

class Geom2dGcc_Circ2d3Tan(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 one or more 2D circles tangential to three curves Qualified1, Qualified2 and Qualified3, where Param1, Param2 and Param3 are used, respectively, as the initial values of the parameters on Qualified1, Qualified2 and Qualified3 of the tangency point between these arguments and the solution sought, if the algorithm chooses an iterative method to find the solution (i.e. if either Qualified1, Qualified2 or Qualified3 is more complex than a line or a circle).
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QualifiedCurve
        	:param Qualified3:
        	:type Qualified3: Geom2dGcc_QualifiedCurve
        	:param Tolerance:
        	:type Tolerance: float
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:rtype: None* Constructs one or more 2D circles tangential to two curves Qualified1 and Qualified2 and passing through the point Point, where Param1 and Param2 are used, respectively, as the initial values of the parameters on Qualified1 and Qualified2 of the tangency point between this argument and the solution sought, if the algorithm chooses an iterative method to find the solution (i.e. if either Qualified1 or Qualified2 is more complex than a line or a circle).
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QualifiedCurve
        	:param Point:
        	:type Point: Geom2d_Point
        	:param Tolerance:
        	:type Tolerance: float
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:rtype: None* Constructs one or more 2D circles tangential to the curve Qualified1 and passing through two points Point1 and Point2, where Param1 is used as the initial value of the parameter on Qualified1 of the tangency point between this argument and the solution sought, if the algorithm chooses an iterative method to find the solution (i.e. if Qualified1 is more complex than a line or a circle)
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param Point1:
        	:type Point1: Geom2d_Point
        	:param Point2:
        	:type Point2: Geom2d_Point
        	:param Tolerance:
        	:type Tolerance: float
        	:param Param1:
        	:type Param1: float
        	:rtype: None* Constructs one or more 2D circles passing through three points Point1, Point2 and Point3. Tolerance is a tolerance criterion used by the algorithm to find a solution when, mathematically, the problem posed does not have a solution, but where there is numeric uncertainty attached to the arguments. For example, take: - two circles C1 and C2, such that C2 is inside C1, and almost tangential to C1; there is in fact no point of intersection between C1 and C2; and - a circle C3 outside C1. You now want to find a circle which is tangential to C1, C2 and C3: a pure mathematical resolution will not find a solution. This is where the tolerance criterion is used: the algorithm considers that C1 and C2 are tangential if the shortest distance between these two circles is less than or equal to Tolerance. Thus, the algorithm finds a solution. Warning An iterative algorithm is used if Qualified1, Qualified2 or Qualified3 is more complex than a line or a circle. In such cases, the algorithm constructs only one solution. Exceptions GccEnt_BadQualifier if a qualifier is inconsistent with the argument it qualifies (for example, enclosing for a line).
        	:param Point1:
        	:type Point1: Geom2d_Point
        	:param Point2:
        	:type Point2: Geom2d_Point
        	:param Point3:
        	:type Point3: Geom2d_Point
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Circ2d3Tan_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Circ2d3Tan(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3Tan_IsDone)
    IsTheSame1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3Tan_IsTheSame1)
    IsTheSame2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3Tan_IsTheSame2)
    IsTheSame3 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3Tan_IsTheSame3)
    NbSolutions = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3Tan_NbSolutions)
    Results = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3Tan_Results)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3Tan_Tangency1)
    Tangency2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3Tan_Tangency2)
    Tangency3 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3Tan_Tangency3)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3Tan_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3Tan_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Circ2d3Tan

# Register Geom2dGcc_Circ2d3Tan in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Circ2d3Tan_swigregister(Geom2dGcc_Circ2d3Tan)

class Geom2dGcc_Circ2d3TanIter(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"""
        * This method implements the algorithms used to create 2d circles tangent to 2 circles and a curve.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param Qualified2:
        	:type Qualified2: GccEnt_QualifiedCirc
        	:param Qualified3:
        	:type Qualified3: Geom2dGcc_QCurve
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles tangent to a circle and 2 curves.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param Qualified3:
        	:type Qualified3: Geom2dGcc_QCurve
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles tangent to a circle and a line and a curve.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param Qualified2:
        	:type Qualified2: GccEnt_QualifiedLin
        	:param Qualified3:
        	:type Qualified3: Geom2dGcc_QCurve
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles tangent to a circle and a point and a curve.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param Point3:
        	:type Point3: gp_Pnt2d
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles tangent to 2 lines and a curve.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedLin
        	:param Qualified2:
        	:type Qualified2: GccEnt_QualifiedLin
        	:param Qualified3:
        	:type Qualified3: Geom2dGcc_QCurve
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles tangent to a line and 2 curves.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedLin
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param Qualified3:
        	:type Qualified3: Geom2dGcc_QCurve
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles tangent to a line and a curve and a point.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedLin
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param Point3:
        	:type Point3: gp_Pnt2d
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles tangent to a curve and 2 points.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Point1:
        	:type Point1: gp_Pnt2d
        	:param Point2:
        	:type Point2: gp_Pnt2d
        	:param Param1:
        	:type Param1: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles tangent to 2 curves and a point.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param Point2:
        	:type Point2: gp_Pnt2d
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This method implements the algorithms used to create 2d circles tangent to 3 curves.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param Qualified3:
        	:type Qualified3: Geom2dGcc_QCurve
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Param3:
        	:type Param3: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Circ2d3TanIter_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Circ2d3TanIter(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3TanIter_IsDone)
    IsTheSame1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3TanIter_IsTheSame1)
    IsTheSame2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3TanIter_IsTheSame2)
    IsTheSame3 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3TanIter_IsTheSame3)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3TanIter_Tangency1)
    Tangency2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3TanIter_Tangency2)
    Tangency3 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3TanIter_Tangency3)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3TanIter_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2d3TanIter_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Circ2d3TanIter

# Register Geom2dGcc_Circ2d3TanIter in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Circ2d3TanIter_swigregister(Geom2dGcc_Circ2d3TanIter)

class Geom2dGcc_Circ2dTanCen(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 one or more 2D circles tangential to the curve Qualified1 and centered on the point Pcenter. Tolerance is a tolerance criterion used by the algorithm to find a solution when, mathematically, the problem posed does not have a solution, but where there is numeric uncertainty attached to the arguments. Tolerance is only used in these algorithms in very specific cases where the center of the solution is very close to the circle to which it is tangential, and where the solution is thus a very small circle. Exceptions GccEnt_BadQualifier if a qualifier is inconsistent with the argument it qualifies (for example, enclosing for a line).
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param Pcenter:
        	:type Pcenter: Geom2d_Point
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Circ2dTanCen_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Circ2dTanCen(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanCen_IsDone)
    IsTheSame1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanCen_IsTheSame1)
    NbSolutions = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanCen_NbSolutions)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanCen_Tangency1)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanCen_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanCen_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Circ2dTanCen

# Register Geom2dGcc_Circ2dTanCen in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Circ2dTanCen_swigregister(Geom2dGcc_Circ2dTanCen)

class Geom2dGcc_Circ2dTanCenGeo(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"""
        * This method implements the algorithms used to create 2d circles tangent to a circle and centered on a point.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Pcenter:
        	:type Pcenter: gp_Pnt2d
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Circ2dTanCenGeo_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Circ2dTanCenGeo(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanCenGeo_IsDone)
    NbSolutions = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanCenGeo_NbSolutions)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanCenGeo_Tangency1)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanCenGeo_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanCenGeo_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Circ2dTanCenGeo

# Register Geom2dGcc_Circ2dTanCenGeo in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Circ2dTanCenGeo_swigregister(Geom2dGcc_Circ2dTanCenGeo)

class Geom2dGcc_Circ2dTanOnRad(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CenterOn3 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRad_CenterOn3)

    def __init__(self, *args):
        r"""
        * Constructs one or more 2D circles of radius Radius, centered on the 2D curve OnCurv and: - tangential to the curve Qualified1
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* Constructs one or more 2D circles of radius Radius, centered on the 2D curve OnCurv and: passing through the point Point1. OnCurv is an adapted curve, i.e. an object which is an interface between: - the services provided by a 2D curve from the package Geom2d, - and those required on the curve by the construction algorithm. Similarly, the qualified curve Qualified1 is created from an adapted curve. Adapted curves are created in the following way: opencascade::handle<Geom2d_Curve> myCurveOn = ... ; Geom2dAdaptor_Curve OnCurv ( myCurveOn ) ; The algorithm is then constructed with this object: opencascade::handle<Geom2d_Curve> myCurve1 = ... ; Geom2dAdaptor_Curve Adapted1 ( myCurve1 ) ; Geom2dGcc_QualifiedCurve Qualified1 = Geom2dGcc::Outside(Adapted1); Standard_Real Radius = ... , Tolerance = ... ; Geom2dGcc_Circ2dTanOnRad myAlgo ( Qualified1 , OnCurv , Radius , Tolerance ) ; if ( myAlgo.IsDone() ) { Standard_Integer Nbr = myAlgo.NbSolutions() ; gp_Circ2d Circ ; for ( Standard_Integer i = 1 ; i <= nbr ; i++ ) { Circ = myAlgo.ThisSolution (i) ; ... } }
        	:param Point1:
        	:type Point1: Geom2d_Point
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Circ2dTanOnRad_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Circ2dTanOnRad(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRad_IsDone)
    IsTheSame1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRad_IsTheSame1)
    NbSolutions = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRad_NbSolutions)
    Results = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRad_Results)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRad_Tangency1)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRad_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRad_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Circ2dTanOnRad

# Register Geom2dGcc_Circ2dTanOnRad in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Circ2dTanOnRad_swigregister(Geom2dGcc_Circ2dTanOnRad)

class Geom2dGcc_Circ2dTanOnRadGeo(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CenterOn3 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRadGeo_CenterOn3)

    def __init__(self, *args):
        r"""
        * This methods implements the algorithms used to create 2d Circles tangent to a curve and centered on a 2d Line with a given radius. Tolerance is used to find solution in every limit cases. raises NegativeValue in case of NegativeRadius.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param OnLine:
        	:type OnLine: gp_Lin2d
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This methods implements the algorithms used to create 2d Circles tangent to a curve and centered on a 2d Circle with a given radius. Tolerance is used to find solution in every limit cases. raises NegativeValue in case of NegativeRadius.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param OnCirc:
        	:type OnCirc: gp_Circ2d
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This methods implements the algorithms used to create 2d Circles tangent to a circle and centered on a 2d curve with a given radius. Tolerance is used to find solution in every limit cases. raises NegativeValue in case of NegativeRadius.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This methods implements the algorithms used to create 2d Circles tangent to a 2d Line and centered on a 2d curve with a given radius. Tolerance is used to find solution in every limit cases. raises NegativeValue in case of NegativeRadius.
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedLin
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This methods implements the algorithms used to create 2d Circles tangent to a 2d curve and centered on a 2d curve with a given radius. Tolerance is used to find solution in every limit cases. raises NegativeValue in case of NegativeRadius.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None* This methods implements the algorithms used to create 2d Circles passing through a 2d point and centered on a 2d curve with a given radius. Tolerance is used to find solution in every limit cases. raises NegativeValue in case of NegativeRadius.
        	:param Point1:
        	:type Point1: gp_Pnt2d
        	:param OnCurv:
        	:type OnCurv: Geom2dAdaptor_Curve
        	:param Radius:
        	:type Radius: float
        	:param Tolerance:
        	:type Tolerance: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Circ2dTanOnRadGeo_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Circ2dTanOnRadGeo(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRadGeo_IsDone)
    IsTheSame1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRadGeo_IsTheSame1)
    NbSolutions = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRadGeo_NbSolutions)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRadGeo_Tangency1)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRadGeo_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Circ2dTanOnRadGeo_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Circ2dTanOnRadGeo

# Register Geom2dGcc_Circ2dTanOnRadGeo in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Circ2dTanOnRadGeo_swigregister(Geom2dGcc_Circ2dTanOnRadGeo)

class Geom2dGcc_CurveTool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    D1 = _swig_new_static_method(_Geom2dGcc.Geom2dGcc_CurveTool_D1)
    D2 = _swig_new_static_method(_Geom2dGcc.Geom2dGcc_CurveTool_D2)
    D3 = _swig_new_static_method(_Geom2dGcc.Geom2dGcc_CurveTool_D3)
    EpsX = _swig_new_static_method(_Geom2dGcc.Geom2dGcc_CurveTool_EpsX)
    FirstParameter = _swig_new_static_method(_Geom2dGcc.Geom2dGcc_CurveTool_FirstParameter)
    LastParameter = _swig_new_static_method(_Geom2dGcc.Geom2dGcc_CurveTool_LastParameter)
    NbSamples = _swig_new_static_method(_Geom2dGcc.Geom2dGcc_CurveTool_NbSamples)
    Value = _swig_new_static_method(_Geom2dGcc.Geom2dGcc_CurveTool_Value)

    __repr__ = _dumps_object


    def __init__(self):
        _Geom2dGcc.Geom2dGcc_CurveTool_swiginit(self, _Geom2dGcc.new_Geom2dGcc_CurveTool())
    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_CurveTool

# Register Geom2dGcc_CurveTool in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_CurveTool_swigregister(Geom2dGcc_CurveTool)
Geom2dGcc_CurveTool_D1 = _Geom2dGcc.Geom2dGcc_CurveTool_D1
Geom2dGcc_CurveTool_D2 = _Geom2dGcc.Geom2dGcc_CurveTool_D2
Geom2dGcc_CurveTool_D3 = _Geom2dGcc.Geom2dGcc_CurveTool_D3
Geom2dGcc_CurveTool_EpsX = _Geom2dGcc.Geom2dGcc_CurveTool_EpsX
Geom2dGcc_CurveTool_FirstParameter = _Geom2dGcc.Geom2dGcc_CurveTool_FirstParameter
Geom2dGcc_CurveTool_LastParameter = _Geom2dGcc.Geom2dGcc_CurveTool_LastParameter
Geom2dGcc_CurveTool_NbSamples = _Geom2dGcc.Geom2dGcc_CurveTool_NbSamples
Geom2dGcc_CurveTool_Value = _Geom2dGcc.Geom2dGcc_CurveTool_Value

class Geom2dGcc_FunctionTanCirCu(OCC.Core.math.math_FunctionWithDerivative):
    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"""
        :param Circ:
        	:type Circ: gp_Circ2d
        	:param Curv:
        	:type Curv: Geom2dAdaptor_Curve
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_FunctionTanCirCu_swiginit(self, _Geom2dGcc.new_Geom2dGcc_FunctionTanCirCu(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_FunctionTanCirCu

# Register Geom2dGcc_FunctionTanCirCu in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_FunctionTanCirCu_swigregister(Geom2dGcc_FunctionTanCirCu)

class Geom2dGcc_FunctionTanCuCu(OCC.Core.math.math_FunctionSetWithDerivatives):
    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"""
        :param Curv1:
        	:type Curv1: Geom2dAdaptor_Curve
        	:param Curv2:
        	:type Curv2: Geom2dAdaptor_Curve
        	:rtype: None:param Circ1:
        	:type Circ1: gp_Circ2d
        	:param Curv2:
        	:type Curv2: Geom2dAdaptor_Curve
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_FunctionTanCuCu_swiginit(self, _Geom2dGcc.new_Geom2dGcc_FunctionTanCuCu(*args))
    InitDerivative = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_FunctionTanCuCu_InitDerivative)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_FunctionTanCuCu

# Register Geom2dGcc_FunctionTanCuCu in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_FunctionTanCuCu_swigregister(Geom2dGcc_FunctionTanCuCu)

class Geom2dGcc_FunctionTanCuCuOnCu(OCC.Core.math.math_FunctionSetWithDerivatives):
    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"""
        :param C1:
        	:type C1: Geom2dAdaptor_Curve
        	:param C2:
        	:type C2: Geom2dAdaptor_Curve
        	:param OnCi:
        	:type OnCi: gp_Circ2d
        	:param Rad:
        	:type Rad: float
        	:rtype: None:param C1:
        	:type C1: gp_Circ2d
        	:param C2:
        	:type C2: Geom2dAdaptor_Curve
        	:param OnCi:
        	:type OnCi: gp_Circ2d
        	:param Rad:
        	:type Rad: float
        	:rtype: None:param L1:
        	:type L1: gp_Lin2d
        	:param C2:
        	:type C2: Geom2dAdaptor_Curve
        	:param OnCi:
        	:type OnCi: gp_Circ2d
        	:param Rad:
        	:type Rad: float
        	:rtype: None:param C1:
        	:type C1: Geom2dAdaptor_Curve
        	:param P2:
        	:type P2: gp_Pnt2d
        	:param OnCi:
        	:type OnCi: gp_Circ2d
        	:param Rad:
        	:type Rad: float
        	:rtype: None:param C1:
        	:type C1: Geom2dAdaptor_Curve
        	:param C2:
        	:type C2: Geom2dAdaptor_Curve
        	:param OnLi:
        	:type OnLi: gp_Lin2d
        	:param Rad:
        	:type Rad: float
        	:rtype: None:param C1:
        	:type C1: gp_Circ2d
        	:param C2:
        	:type C2: Geom2dAdaptor_Curve
        	:param OnLi:
        	:type OnLi: gp_Lin2d
        	:param Rad:
        	:type Rad: float
        	:rtype: None:param L1:
        	:type L1: gp_Lin2d
        	:param C2:
        	:type C2: Geom2dAdaptor_Curve
        	:param OnLi:
        	:type OnLi: gp_Lin2d
        	:param Rad:
        	:type Rad: float
        	:rtype: None:param C1:
        	:type C1: Geom2dAdaptor_Curve
        	:param P2:
        	:type P2: gp_Pnt2d
        	:param OnLi:
        	:type OnLi: gp_Lin2d
        	:param Rad:
        	:type Rad: float
        	:rtype: None:param C1:
        	:type C1: Geom2dAdaptor_Curve
        	:param C2:
        	:type C2: Geom2dAdaptor_Curve
        	:param OnCu:
        	:type OnCu: Geom2dAdaptor_Curve
        	:param Rad:
        	:type Rad: float
        	:rtype: None:param C1:
        	:type C1: gp_Circ2d
        	:param C2:
        	:type C2: Geom2dAdaptor_Curve
        	:param OnCu:
        	:type OnCu: Geom2dAdaptor_Curve
        	:param Rad:
        	:type Rad: float
        	:rtype: None:param L1:
        	:type L1: gp_Lin2d
        	:param C2:
        	:type C2: Geom2dAdaptor_Curve
        	:param OnCu:
        	:type OnCu: Geom2dAdaptor_Curve
        	:param Rad:
        	:type Rad: float
        	:rtype: None:param C1:
        	:type C1: Geom2dAdaptor_Curve
        	:param P1:
        	:type P1: gp_Pnt2d
        	:param OnCu:
        	:type OnCu: Geom2dAdaptor_Curve
        	:param Rad:
        	:type Rad: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_FunctionTanCuCuOnCu_swiginit(self, _Geom2dGcc.new_Geom2dGcc_FunctionTanCuCuOnCu(*args))
    InitDerivative = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_FunctionTanCuCuOnCu_InitDerivative)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_FunctionTanCuCuOnCu

# Register Geom2dGcc_FunctionTanCuCuOnCu in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_FunctionTanCuCuOnCu_swigregister(Geom2dGcc_FunctionTanCuCuOnCu)

class Geom2dGcc_FunctionTanCuPnt(OCC.Core.math.math_FunctionWithDerivative):
    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"""
        :param C:
        	:type C: Geom2dAdaptor_Curve
        	:param Point:
        	:type Point: gp_Pnt2d
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_FunctionTanCuPnt_swiginit(self, _Geom2dGcc.new_Geom2dGcc_FunctionTanCuPnt(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_FunctionTanCuPnt

# Register Geom2dGcc_FunctionTanCuPnt in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_FunctionTanCuPnt_swigregister(Geom2dGcc_FunctionTanCuPnt)

class Geom2dGcc_FunctionTanObl(OCC.Core.math.math_FunctionWithDerivative):
    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"""
        :param Curve:
        	:type Curve: Geom2dAdaptor_Curve
        	:param Dir:
        	:type Dir: gp_Dir2d
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_FunctionTanObl_swiginit(self, _Geom2dGcc.new_Geom2dGcc_FunctionTanObl(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_FunctionTanObl

# Register Geom2dGcc_FunctionTanObl in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_FunctionTanObl_swigregister(Geom2dGcc_FunctionTanObl)

class Geom2dGcc_Lin2d2Tan(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"""
        * This class implements the algorithms used to create 2d line tangent to two curves. Tolang is used to determine the tolerance for the tangency points.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QualifiedCurve
        	:param Tolang:
        	:type Tolang: float
        	:rtype: None* This class implements the algorithms used to create 2d lines passing thrue a point and tangent to a curve. Tolang is used to determine the tolerance for the tangency points.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param ThePoint:
        	:type ThePoint: gp_Pnt2d
        	:param Tolang:
        	:type Tolang: float
        	:rtype: None* This class implements the algorithms used to create 2d line tangent to two curves. Tolang is used to determine the tolerance for the tangency points. Param1 is used for the initial guess on the first curve. Param2 is used for the initial guess on the second curve.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QualifiedCurve
        	:param Tolang:
        	:type Tolang: float
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:rtype: None* This class implements the algorithms used to create 2d lines passing thrue a point and tangent to a curve. Tolang is used to determine the tolerance for the tangency points. Param2 is used for the initial guess on the curve.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param ThePoint:
        	:type ThePoint: gp_Pnt2d
        	:param Tolang:
        	:type Tolang: float
        	:param Param1:
        	:type Param1: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Lin2d2Tan_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Lin2d2Tan(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2d2Tan_IsDone)
    NbSolutions = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2d2Tan_NbSolutions)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2d2Tan_Tangency1)
    Tangency2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2d2Tan_Tangency2)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2d2Tan_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2d2Tan_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Lin2d2Tan

# Register Geom2dGcc_Lin2d2Tan in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Lin2d2Tan_swigregister(Geom2dGcc_Lin2d2Tan)

class Geom2dGcc_Lin2d2TanIter(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"""
        * This class implements the algorithms used to create 2d lines passing thrue a point and tangent to a curve. Tolang is used to determine the tolerance for the tangency points. Param2 is used for the initial guess on the curve.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param ThePoint:
        	:type ThePoint: gp_Pnt2d
        	:param Param1:
        	:type Param1: float
        	:param Tolang:
        	:type Tolang: float
        	:rtype: None* This class implements the algorithms used to create 2d line tangent to a circle and to a cuve. Tolang is used to determine the tolerance for the tangency points. Param2 is used for the initial guess on the curve. Exception BadQualifier is raised in the case of EnclosedCirc
        	:param Qualified1:
        	:type Qualified1: GccEnt_QualifiedCirc
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param Param2:
        	:type Param2: float
        	:param Tolang:
        	:type Tolang: float
        	:rtype: None* This class implements the algorithms used to create 2d line tangent to two curves. Tolang is used to determine the tolerance for the tangency points. Param1 is used for the initial guess on the first curve. Param2 is used for the initial guess on the second curve.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param Qualified2:
        	:type Qualified2: Geom2dGcc_QCurve
        	:param Param1:
        	:type Param1: float
        	:param Param2:
        	:type Param2: float
        	:param Tolang:
        	:type Tolang: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Lin2d2TanIter_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Lin2d2TanIter(*args))
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2d2TanIter_IsDone)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2d2TanIter_Tangency1)
    Tangency2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2d2TanIter_Tangency2)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2d2TanIter_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2d2TanIter_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Lin2d2TanIter

# Register Geom2dGcc_Lin2d2TanIter in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Lin2d2TanIter_swigregister(Geom2dGcc_Lin2d2TanIter)

class Geom2dGcc_Lin2dTanObl(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"""
        * This class implements the algorithm used to create 2d line tangent to a curve and doing an angle Angle with the line TheLin. Angle must be in Radian. Tolang is the angular tolerance.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param TheLin:
        	:type TheLin: gp_Lin2d
        	:param TolAng:
        	:type TolAng: float
        	:param Angle:
        	:type Angle: float
        	:rtype: None* This class implements the algorithm used to create 2d line tangent to a curve and doing an angle Angle with the line TheLin. Angle must be in Radian. Param2 is the initial guess on the curve QualifiedCurv. Tolang is the angular tolerance. Warning An iterative algorithm is used if Qualified1 is more complex than a line or a circle. In such cases, the algorithm constructs only one solution. Exceptions GccEnt_BadQualifier if a qualifier is inconsistent with the argument it qualifies (for example, enclosed for a circle).
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QualifiedCurve
        	:param TheLin:
        	:type TheLin: gp_Lin2d
        	:param TolAng:
        	:type TolAng: float
        	:param Param1:
        	:type Param1: float
        	:param Angle:
        	:type Angle: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Lin2dTanObl_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Lin2dTanObl(*args))
    Intersection2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2dTanObl_Intersection2)
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2dTanObl_IsDone)
    NbSolutions = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2dTanObl_NbSolutions)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2dTanObl_Tangency1)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2dTanObl_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2dTanObl_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Lin2dTanObl

# Register Geom2dGcc_Lin2dTanObl in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Lin2dTanObl_swigregister(Geom2dGcc_Lin2dTanObl)

class Geom2dGcc_Lin2dTanOblIter(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"""
        * This class implements the algorithm used to create 2d line tangent to a curve and doing an angle Angle with the line TheLin. Angle must be in Radian. Param2 is the initial guess on the curve QualifiedCurv. Tolang is the angular tolerance.
        	:param Qualified1:
        	:type Qualified1: Geom2dGcc_QCurve
        	:param TheLin:
        	:type TheLin: gp_Lin2d
        	:param Param1:
        	:type Param1: float
        	:param TolAng:
        	:type TolAng: float
        	:param Angle: default value is 0
        	:type Angle: float
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_Lin2dTanOblIter_swiginit(self, _Geom2dGcc.new_Geom2dGcc_Lin2dTanOblIter(*args))
    Intersection2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2dTanOblIter_Intersection2)
    IsDone = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2dTanOblIter_IsDone)
    IsParallel2 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2dTanOblIter_IsParallel2)
    Tangency1 = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2dTanOblIter_Tangency1)
    ThisSolution = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2dTanOblIter_ThisSolution)
    WhichQualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_Lin2dTanOblIter_WhichQualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_Lin2dTanOblIter

# Register Geom2dGcc_Lin2dTanOblIter in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_Lin2dTanOblIter_swigregister(Geom2dGcc_Lin2dTanOblIter)

class Geom2dGcc_QCurve(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"""
        :param Curve:
        	:type Curve: Geom2dAdaptor_Curve
        	:param Qualifier:
        	:type Qualifier: GccEnt_Position
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_QCurve_swiginit(self, _Geom2dGcc.new_Geom2dGcc_QCurve(*args))
    IsEnclosed = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_QCurve_IsEnclosed)
    IsEnclosing = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_QCurve_IsEnclosing)
    IsOutside = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_QCurve_IsOutside)
    IsUnqualified = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_QCurve_IsUnqualified)
    Qualified = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_QCurve_Qualified)
    Qualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_QCurve_Qualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_QCurve

# Register Geom2dGcc_QCurve in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_QCurve_swigregister(Geom2dGcc_QCurve)

class Geom2dGcc_QualifiedCurve(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 a qualified curve by assigning the qualifier Qualifier to the curve Curve. Qualifier may be: - GccEnt_enclosing if the solution of a construction algorithm using the qualified curve encloses the curve, or - GccEnt_enclosed if the solution is enclosed by the curve, or - GccEnt_outside if both the solution and the curve are external to one another, or - GccEnt_unqualified if all solutions apply. Note: The interior of a curve is defined as the left-hand side of the curve in relation to its orientation. Warning Curve is an adapted curve, i.e. an object which is an interface between: - the services provided by a 2D curve from the package Geom2d, - and those required on the curve by a computation algorithm. The adapted curve is created in the following way: opencascade::handle<Geom2d_Curve> mycurve = ... ; Geom2dAdaptor_Curve Curve ( mycurve ) ; The qualified curve is then constructed with this object: GccEnt_Position myQualif = GccEnt_outside ; Geom2dGcc_QualifiedCurve myQCurve ( Curve, myQualif ); is private;
        	:param Curve:
        	:type Curve: Geom2dAdaptor_Curve
        	:param Qualifier:
        	:type Qualifier: GccEnt_Position
        	:rtype: None
        """
        _Geom2dGcc.Geom2dGcc_QualifiedCurve_swiginit(self, _Geom2dGcc.new_Geom2dGcc_QualifiedCurve(*args))
    IsEnclosed = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_QualifiedCurve_IsEnclosed)
    IsEnclosing = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_QualifiedCurve_IsEnclosing)
    IsOutside = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_QualifiedCurve_IsOutside)
    IsUnqualified = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_QualifiedCurve_IsUnqualified)
    Qualified = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_QualifiedCurve_Qualified)
    Qualifier = _swig_new_instance_method(_Geom2dGcc.Geom2dGcc_QualifiedCurve_Qualifier)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dGcc.delete_Geom2dGcc_QualifiedCurve

# Register Geom2dGcc_QualifiedCurve in _Geom2dGcc:
_Geom2dGcc.Geom2dGcc_QualifiedCurve_swigregister(Geom2dGcc_QualifiedCurve)



