# 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.

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

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__ = _IntTools.delete_SwigPyIterator

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _IntTools:
_IntTools.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 _IntTools.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.BRepAdaptor
import OCC.Core.Adaptor3d
import OCC.Core.Geom
import OCC.Core.gp
import OCC.Core.TColStd
import OCC.Core.TCollection
import OCC.Core.GeomAbs
import OCC.Core.TColgp
import OCC.Core.TopAbs
import OCC.Core.Adaptor2d
import OCC.Core.Geom2d
import OCC.Core.math
import OCC.Core.Message
import OCC.Core.OSD
import OCC.Core.TopoDS
import OCC.Core.TopLoc
import OCC.Core.GeomAdaptor
import OCC.Core.Geom2dAdaptor
import OCC.Core.Bnd
import OCC.Core.BVH
import OCC.Core.Geom2dHatch
import OCC.Core.IntRes2d
import OCC.Core.HatchGen
import OCC.Core.Geom2dInt
import OCC.Core.IntCurve
import OCC.Core.Extrema
import OCC.Core.Intf
import OCC.Core.GeomAPI
import OCC.Core.Approx
import OCC.Core.AppCont
import OCC.Core.AppParCurves
import OCC.Core.BRepClass3d
import OCC.Core.IntCurveSurface
import OCC.Core.IntSurf
import OCC.Core.TopTools
import OCC.Core.IntCurvesFace
import OCC.Core.IntPatch
import OCC.Core.IntAna
import OCC.Core.GeomInt
import OCC.Core.IntImp
import OCC.Core.ApproxInt

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




def Handle_IntTools_Context_Create() -> "opencascade::handle< IntTools_Context >":
    return _IntTools.Handle_IntTools_Context_Create()

def Handle_IntTools_Context_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< IntTools_Context >":
    return _IntTools.Handle_IntTools_Context_DownCast(t)

def Handle_IntTools_Context_IsNull(t: "opencascade::handle< IntTools_Context > const &") -> "bool":
    return _IntTools.Handle_IntTools_Context_IsNull(t)

def Handle_IntTools_TopolTool_Create() -> "opencascade::handle< IntTools_TopolTool >":
    return _IntTools.Handle_IntTools_TopolTool_Create()

def Handle_IntTools_TopolTool_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< IntTools_TopolTool >":
    return _IntTools.Handle_IntTools_TopolTool_DownCast(t)

def Handle_IntTools_TopolTool_IsNull(t: "opencascade::handle< IntTools_TopolTool > const &") -> "bool":
    return _IntTools.Handle_IntTools_TopolTool_IsNull(t)
class IntTools_Array1OfRange(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self) -> "NCollection_Array1< IntTools_Range >::iterator":
        return _IntTools.IntTools_Array1OfRange_begin(self)

    def end(self) -> "NCollection_Array1< IntTools_Range >::iterator":
        return _IntTools.IntTools_Array1OfRange_end(self)

    def cbegin(self) -> "NCollection_Array1< IntTools_Range >::const_iterator":
        return _IntTools.IntTools_Array1OfRange_cbegin(self)

    def cend(self) -> "NCollection_Array1< IntTools_Range >::const_iterator":
        return _IntTools.IntTools_Array1OfRange_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_Array1OfRange_swiginit(self, _IntTools.new_IntTools_Array1OfRange(*args))

    def Init(self, theValue: "IntTools_Range") -> "void":
        return _IntTools.IntTools_Array1OfRange_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_Array1OfRange_Size(self)

    def Length(self) -> "Standard_Integer":
        return _IntTools.IntTools_Array1OfRange_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _IntTools.IntTools_Array1OfRange_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _IntTools.IntTools_Array1OfRange_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _IntTools.IntTools_Array1OfRange_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _IntTools.IntTools_Array1OfRange_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _IntTools.IntTools_Array1OfRange_IsAllocated(self)

    def Assign(self, theOther: "IntTools_Array1OfRange") -> "NCollection_Array1< IntTools_Range > &":
        return _IntTools.IntTools_Array1OfRange_Assign(self, theOther)

    def Move(self, theOther: "IntTools_Array1OfRange") -> "NCollection_Array1< IntTools_Range > &":
        return _IntTools.IntTools_Array1OfRange_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< IntTools_Range > &":
        return _IntTools.IntTools_Array1OfRange_Set(self, *args)

    def First(self) -> "IntTools_Range const &":
        return _IntTools.IntTools_Array1OfRange_First(self)

    def ChangeFirst(self) -> "IntTools_Range &":
        return _IntTools.IntTools_Array1OfRange_ChangeFirst(self)

    def Last(self) -> "IntTools_Range const &":
        return _IntTools.IntTools_Array1OfRange_Last(self)

    def ChangeLast(self) -> "IntTools_Range &":
        return _IntTools.IntTools_Array1OfRange_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "IntTools_Range const &":
        return _IntTools.IntTools_Array1OfRange_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "IntTools_Range &":
        return _IntTools.IntTools_Array1OfRange_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "IntTools_Range &":
        return _IntTools.IntTools_Array1OfRange___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "IntTools_Range") -> "void":
        return _IntTools.IntTools_Array1OfRange_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _IntTools.IntTools_Array1OfRange_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _IntTools.delete_IntTools_Array1OfRange

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register IntTools_Array1OfRange in _IntTools:
_IntTools.IntTools_Array1OfRange_swigregister(IntTools_Array1OfRange)

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

    def begin(self) -> "NCollection_Array1< IntTools_Root >::iterator":
        return _IntTools.IntTools_Array1OfRoots_begin(self)

    def end(self) -> "NCollection_Array1< IntTools_Root >::iterator":
        return _IntTools.IntTools_Array1OfRoots_end(self)

    def cbegin(self) -> "NCollection_Array1< IntTools_Root >::const_iterator":
        return _IntTools.IntTools_Array1OfRoots_cbegin(self)

    def cend(self) -> "NCollection_Array1< IntTools_Root >::const_iterator":
        return _IntTools.IntTools_Array1OfRoots_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_Array1OfRoots_swiginit(self, _IntTools.new_IntTools_Array1OfRoots(*args))

    def Init(self, theValue: "IntTools_Root") -> "void":
        return _IntTools.IntTools_Array1OfRoots_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_Array1OfRoots_Size(self)

    def Length(self) -> "Standard_Integer":
        return _IntTools.IntTools_Array1OfRoots_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _IntTools.IntTools_Array1OfRoots_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _IntTools.IntTools_Array1OfRoots_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _IntTools.IntTools_Array1OfRoots_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _IntTools.IntTools_Array1OfRoots_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _IntTools.IntTools_Array1OfRoots_IsAllocated(self)

    def Assign(self, theOther: "IntTools_Array1OfRoots") -> "NCollection_Array1< IntTools_Root > &":
        return _IntTools.IntTools_Array1OfRoots_Assign(self, theOther)

    def Move(self, theOther: "IntTools_Array1OfRoots") -> "NCollection_Array1< IntTools_Root > &":
        return _IntTools.IntTools_Array1OfRoots_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< IntTools_Root > &":
        return _IntTools.IntTools_Array1OfRoots_Set(self, *args)

    def First(self) -> "IntTools_Root const &":
        return _IntTools.IntTools_Array1OfRoots_First(self)

    def ChangeFirst(self) -> "IntTools_Root &":
        return _IntTools.IntTools_Array1OfRoots_ChangeFirst(self)

    def Last(self) -> "IntTools_Root const &":
        return _IntTools.IntTools_Array1OfRoots_Last(self)

    def ChangeLast(self) -> "IntTools_Root &":
        return _IntTools.IntTools_Array1OfRoots_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "IntTools_Root const &":
        return _IntTools.IntTools_Array1OfRoots_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "IntTools_Root &":
        return _IntTools.IntTools_Array1OfRoots_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "IntTools_Root &":
        return _IntTools.IntTools_Array1OfRoots___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "IntTools_Root") -> "void":
        return _IntTools.IntTools_Array1OfRoots_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _IntTools.IntTools_Array1OfRoots_Resize(self, theLower, theUpper, theToCopyData)
    __swig_destroy__ = _IntTools.delete_IntTools_Array1OfRoots

    def __getitem__(self, index):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            return self.Value(index + self.Lower())

    def __setitem__(self, index, value):
        if index + self.Lower() > self.Upper():
            raise IndexError("index out of range")
        else:
            self.SetValue(index + self.Lower(), value)

    def __len__(self):
        return self.Length()

    def __iter__(self):
        self.low = self.Lower()
        self.up = self.Upper()
        self.current = self.Lower() - 1
        return self

    def next(self):
        if self.current >= self.Upper():
            raise StopIteration
        else:
            self.current += 1
        return self.Value(self.current)

    __next__ = next


# Register IntTools_Array1OfRoots in _IntTools:
_IntTools.IntTools_Array1OfRoots_swigregister(IntTools_Array1OfRoots)

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

    def begin(self) -> "NCollection_DataMap< IntTools_CurveRangeSample,Bnd_Box,IntTools_CurveRangeSampleMapHasher >::iterator":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_begin(self)

    def end(self) -> "NCollection_DataMap< IntTools_CurveRangeSample,Bnd_Box,IntTools_CurveRangeSampleMapHasher >::iterator":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_end(self)

    def cbegin(self) -> "NCollection_DataMap< IntTools_CurveRangeSample,Bnd_Box,IntTools_CurveRangeSampleMapHasher >::const_iterator":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_cbegin(self)

    def cend(self) -> "NCollection_DataMap< IntTools_CurveRangeSample,Bnd_Box,IntTools_CurveRangeSampleMapHasher >::const_iterator":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_DataMapOfCurveSampleBox_swiginit(self, _IntTools.new_IntTools_DataMapOfCurveSampleBox(*args))

    def Exchange(self, theOther: "IntTools_DataMapOfCurveSampleBox") -> "void":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_Exchange(self, theOther)

    def Assign(self, theOther: "IntTools_DataMapOfCurveSampleBox") -> "NCollection_DataMap< IntTools_CurveRangeSample,Bnd_Box,IntTools_CurveRangeSampleMapHasher > &":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_Assign(self, theOther)

    def Set(self, theOther: "IntTools_DataMapOfCurveSampleBox") -> "NCollection_DataMap< IntTools_CurveRangeSample,Bnd_Box,IntTools_CurveRangeSampleMapHasher > &":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_Set(self, theOther)

    def ReSize(self, N: "Standard_Integer const") -> "void":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_ReSize(self, N)

    def Bind(self, theKey: "IntTools_CurveRangeSample", theItem: "Bnd_Box") -> "Standard_Boolean":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_Bind(self, theKey, theItem)

    def Bound(self, theKey: "IntTools_CurveRangeSample", theItem: "Bnd_Box") -> "Bnd_Box *":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "IntTools_CurveRangeSample") -> "Standard_Boolean":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_IsBound(self, theKey)

    def UnBind(self, theKey: "IntTools_CurveRangeSample") -> "Standard_Boolean":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_UnBind(self, theKey)

    def Seek(self, theKey: "IntTools_CurveRangeSample") -> "Bnd_Box const *":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_Find(self, *args)

    def ChangeSeek(self, theKey: "IntTools_CurveRangeSample") -> "Bnd_Box *":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "IntTools_CurveRangeSample") -> "Bnd_Box &":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_ChangeFind(self, theKey)

    def __call__(self, *args) -> "Bnd_Box &":
        return _IntTools.IntTools_DataMapOfCurveSampleBox___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_Clear(self, *args)
    __swig_destroy__ = _IntTools.delete_IntTools_DataMapOfCurveSampleBox

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_DataMapOfCurveSampleBox_Size(self)

# Register IntTools_DataMapOfCurveSampleBox in _IntTools:
_IntTools.IntTools_DataMapOfCurveSampleBox_swigregister(IntTools_DataMapOfCurveSampleBox)

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

    def begin(self) -> "NCollection_DataMap< IntTools_SurfaceRangeSample,Bnd_Box,IntTools_SurfaceRangeSampleMapHasher >::iterator":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_begin(self)

    def end(self) -> "NCollection_DataMap< IntTools_SurfaceRangeSample,Bnd_Box,IntTools_SurfaceRangeSampleMapHasher >::iterator":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_end(self)

    def cbegin(self) -> "NCollection_DataMap< IntTools_SurfaceRangeSample,Bnd_Box,IntTools_SurfaceRangeSampleMapHasher >::const_iterator":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_cbegin(self)

    def cend(self) -> "NCollection_DataMap< IntTools_SurfaceRangeSample,Bnd_Box,IntTools_SurfaceRangeSampleMapHasher >::const_iterator":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_DataMapOfSurfaceSampleBox_swiginit(self, _IntTools.new_IntTools_DataMapOfSurfaceSampleBox(*args))

    def Exchange(self, theOther: "IntTools_DataMapOfSurfaceSampleBox") -> "void":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_Exchange(self, theOther)

    def Assign(self, theOther: "IntTools_DataMapOfSurfaceSampleBox") -> "NCollection_DataMap< IntTools_SurfaceRangeSample,Bnd_Box,IntTools_SurfaceRangeSampleMapHasher > &":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_Assign(self, theOther)

    def Set(self, theOther: "IntTools_DataMapOfSurfaceSampleBox") -> "NCollection_DataMap< IntTools_SurfaceRangeSample,Bnd_Box,IntTools_SurfaceRangeSampleMapHasher > &":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_Set(self, theOther)

    def ReSize(self, N: "Standard_Integer const") -> "void":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_ReSize(self, N)

    def Bind(self, theKey: "IntTools_SurfaceRangeSample", theItem: "Bnd_Box") -> "Standard_Boolean":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_Bind(self, theKey, theItem)

    def Bound(self, theKey: "IntTools_SurfaceRangeSample", theItem: "Bnd_Box") -> "Bnd_Box *":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "IntTools_SurfaceRangeSample") -> "Standard_Boolean":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_IsBound(self, theKey)

    def UnBind(self, theKey: "IntTools_SurfaceRangeSample") -> "Standard_Boolean":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_UnBind(self, theKey)

    def Seek(self, theKey: "IntTools_SurfaceRangeSample") -> "Bnd_Box const *":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_Find(self, *args)

    def ChangeSeek(self, theKey: "IntTools_SurfaceRangeSample") -> "Bnd_Box *":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "IntTools_SurfaceRangeSample") -> "Bnd_Box &":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_ChangeFind(self, theKey)

    def __call__(self, *args) -> "Bnd_Box &":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_Clear(self, *args)
    __swig_destroy__ = _IntTools.delete_IntTools_DataMapOfSurfaceSampleBox

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_DataMapOfSurfaceSampleBox_Size(self)

# Register IntTools_DataMapOfSurfaceSampleBox in _IntTools:
_IntTools.IntTools_DataMapOfSurfaceSampleBox_swigregister(IntTools_DataMapOfSurfaceSampleBox)

class IntTools_ListIteratorOfListOfBox(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):
        _IntTools.IntTools_ListIteratorOfListOfBox_swiginit(self, _IntTools.new_IntTools_ListIteratorOfListOfBox(*args))

    def More(self) -> "Standard_Boolean":
        return _IntTools.IntTools_ListIteratorOfListOfBox_More(self)

    def Next(self) -> "void":
        return _IntTools.IntTools_ListIteratorOfListOfBox_Next(self)

    def Value(self) -> "Bnd_Box const &":
        return _IntTools.IntTools_ListIteratorOfListOfBox_Value(self)

    def ChangeValue(self) -> "Bnd_Box &":
        return _IntTools.IntTools_ListIteratorOfListOfBox_ChangeValue(self)
    __swig_destroy__ = _IntTools.delete_IntTools_ListIteratorOfListOfBox

# Register IntTools_ListIteratorOfListOfBox in _IntTools:
_IntTools.IntTools_ListIteratorOfListOfBox_swigregister(IntTools_ListIteratorOfListOfBox)

class IntTools_ListIteratorOfListOfCurveRangeSample(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):
        _IntTools.IntTools_ListIteratorOfListOfCurveRangeSample_swiginit(self, _IntTools.new_IntTools_ListIteratorOfListOfCurveRangeSample(*args))

    def More(self) -> "Standard_Boolean":
        return _IntTools.IntTools_ListIteratorOfListOfCurveRangeSample_More(self)

    def Next(self) -> "void":
        return _IntTools.IntTools_ListIteratorOfListOfCurveRangeSample_Next(self)

    def Value(self) -> "IntTools_CurveRangeSample const &":
        return _IntTools.IntTools_ListIteratorOfListOfCurveRangeSample_Value(self)

    def ChangeValue(self) -> "IntTools_CurveRangeSample &":
        return _IntTools.IntTools_ListIteratorOfListOfCurveRangeSample_ChangeValue(self)
    __swig_destroy__ = _IntTools.delete_IntTools_ListIteratorOfListOfCurveRangeSample

# Register IntTools_ListIteratorOfListOfCurveRangeSample in _IntTools:
_IntTools.IntTools_ListIteratorOfListOfCurveRangeSample_swigregister(IntTools_ListIteratorOfListOfCurveRangeSample)

class IntTools_ListIteratorOfListOfSurfaceRangeSample(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):
        _IntTools.IntTools_ListIteratorOfListOfSurfaceRangeSample_swiginit(self, _IntTools.new_IntTools_ListIteratorOfListOfSurfaceRangeSample(*args))

    def More(self) -> "Standard_Boolean":
        return _IntTools.IntTools_ListIteratorOfListOfSurfaceRangeSample_More(self)

    def Next(self) -> "void":
        return _IntTools.IntTools_ListIteratorOfListOfSurfaceRangeSample_Next(self)

    def Value(self) -> "IntTools_SurfaceRangeSample const &":
        return _IntTools.IntTools_ListIteratorOfListOfSurfaceRangeSample_Value(self)

    def ChangeValue(self) -> "IntTools_SurfaceRangeSample &":
        return _IntTools.IntTools_ListIteratorOfListOfSurfaceRangeSample_ChangeValue(self)
    __swig_destroy__ = _IntTools.delete_IntTools_ListIteratorOfListOfSurfaceRangeSample

# Register IntTools_ListIteratorOfListOfSurfaceRangeSample in _IntTools:
_IntTools.IntTools_ListIteratorOfListOfSurfaceRangeSample_swigregister(IntTools_ListIteratorOfListOfSurfaceRangeSample)

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

    def begin(self) -> "NCollection_List< Bnd_Box >::iterator":
        return _IntTools.IntTools_ListOfBox_begin(self)

    def end(self) -> "NCollection_List< Bnd_Box >::iterator":
        return _IntTools.IntTools_ListOfBox_end(self)

    def cbegin(self) -> "NCollection_List< Bnd_Box >::const_iterator":
        return _IntTools.IntTools_ListOfBox_cbegin(self)

    def cend(self) -> "NCollection_List< Bnd_Box >::const_iterator":
        return _IntTools.IntTools_ListOfBox_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_ListOfBox_swiginit(self, _IntTools.new_IntTools_ListOfBox(*args))

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_ListOfBox_Size(self)

    def Assign(self, theOther: "IntTools_ListOfBox") -> "NCollection_List< Bnd_Box > &":
        return _IntTools.IntTools_ListOfBox_Assign(self, theOther)

    def Set(self, theOther: "IntTools_ListOfBox") -> "NCollection_List< Bnd_Box > &":
        return _IntTools.IntTools_ListOfBox_Set(self, theOther)

    def Clear(self, theAllocator: "IntSurf_Allocator"=0) -> "void":
        return _IntTools.IntTools_ListOfBox_Clear(self, theAllocator)

    def First(self) -> "Bnd_Box const &":
        return _IntTools.IntTools_ListOfBox_First(self)

    def Last(self) -> "Bnd_Box const &":
        return _IntTools.IntTools_ListOfBox_Last(self)

    def Append(self, *args) -> "void":
        return _IntTools.IntTools_ListOfBox_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _IntTools.IntTools_ListOfBox_Prepend(self, *args)

    def RemoveFirst(self) -> "void":
        return _IntTools.IntTools_ListOfBox_RemoveFirst(self)

    def Remove(self, theIter: "IntTools_ListIteratorOfListOfBox") -> "void":
        return _IntTools.IntTools_ListOfBox_Remove(self, theIter)

    def InsertBefore(self, *args) -> "void":
        return _IntTools.IntTools_ListOfBox_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _IntTools.IntTools_ListOfBox_InsertAfter(self, *args)

    def Reverse(self) -> "void":
        return _IntTools.IntTools_ListOfBox_Reverse(self)
    __swig_destroy__ = _IntTools.delete_IntTools_ListOfBox

    def __len__(self):
        return self.Size()


# Register IntTools_ListOfBox in _IntTools:
_IntTools.IntTools_ListOfBox_swigregister(IntTools_ListOfBox)

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

    def begin(self) -> "NCollection_List< IntTools_CurveRangeSample >::iterator":
        return _IntTools.IntTools_ListOfCurveRangeSample_begin(self)

    def end(self) -> "NCollection_List< IntTools_CurveRangeSample >::iterator":
        return _IntTools.IntTools_ListOfCurveRangeSample_end(self)

    def cbegin(self) -> "NCollection_List< IntTools_CurveRangeSample >::const_iterator":
        return _IntTools.IntTools_ListOfCurveRangeSample_cbegin(self)

    def cend(self) -> "NCollection_List< IntTools_CurveRangeSample >::const_iterator":
        return _IntTools.IntTools_ListOfCurveRangeSample_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_ListOfCurveRangeSample_swiginit(self, _IntTools.new_IntTools_ListOfCurveRangeSample(*args))

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_ListOfCurveRangeSample_Size(self)

    def Assign(self, theOther: "IntTools_ListOfCurveRangeSample") -> "NCollection_List< IntTools_CurveRangeSample > &":
        return _IntTools.IntTools_ListOfCurveRangeSample_Assign(self, theOther)

    def Set(self, theOther: "IntTools_ListOfCurveRangeSample") -> "NCollection_List< IntTools_CurveRangeSample > &":
        return _IntTools.IntTools_ListOfCurveRangeSample_Set(self, theOther)

    def Clear(self, theAllocator: "IntSurf_Allocator"=0) -> "void":
        return _IntTools.IntTools_ListOfCurveRangeSample_Clear(self, theAllocator)

    def First(self) -> "IntTools_CurveRangeSample const &":
        return _IntTools.IntTools_ListOfCurveRangeSample_First(self)

    def Last(self) -> "IntTools_CurveRangeSample const &":
        return _IntTools.IntTools_ListOfCurveRangeSample_Last(self)

    def Append(self, *args) -> "void":
        return _IntTools.IntTools_ListOfCurveRangeSample_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _IntTools.IntTools_ListOfCurveRangeSample_Prepend(self, *args)

    def RemoveFirst(self) -> "void":
        return _IntTools.IntTools_ListOfCurveRangeSample_RemoveFirst(self)

    def Remove(self, theIter: "IntTools_ListIteratorOfListOfCurveRangeSample") -> "void":
        return _IntTools.IntTools_ListOfCurveRangeSample_Remove(self, theIter)

    def InsertBefore(self, *args) -> "void":
        return _IntTools.IntTools_ListOfCurveRangeSample_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _IntTools.IntTools_ListOfCurveRangeSample_InsertAfter(self, *args)

    def Reverse(self) -> "void":
        return _IntTools.IntTools_ListOfCurveRangeSample_Reverse(self)
    __swig_destroy__ = _IntTools.delete_IntTools_ListOfCurveRangeSample

    def __len__(self):
        return self.Size()


# Register IntTools_ListOfCurveRangeSample in _IntTools:
_IntTools.IntTools_ListOfCurveRangeSample_swigregister(IntTools_ListOfCurveRangeSample)

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

    def begin(self) -> "NCollection_List< IntTools_SurfaceRangeSample >::iterator":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_begin(self)

    def end(self) -> "NCollection_List< IntTools_SurfaceRangeSample >::iterator":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_end(self)

    def cbegin(self) -> "NCollection_List< IntTools_SurfaceRangeSample >::const_iterator":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_cbegin(self)

    def cend(self) -> "NCollection_List< IntTools_SurfaceRangeSample >::const_iterator":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_ListOfSurfaceRangeSample_swiginit(self, _IntTools.new_IntTools_ListOfSurfaceRangeSample(*args))

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_Size(self)

    def Assign(self, theOther: "IntTools_ListOfSurfaceRangeSample") -> "NCollection_List< IntTools_SurfaceRangeSample > &":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_Assign(self, theOther)

    def Set(self, theOther: "IntTools_ListOfSurfaceRangeSample") -> "NCollection_List< IntTools_SurfaceRangeSample > &":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_Set(self, theOther)

    def Clear(self, theAllocator: "IntSurf_Allocator"=0) -> "void":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_Clear(self, theAllocator)

    def First(self) -> "IntTools_SurfaceRangeSample const &":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_First(self)

    def Last(self) -> "IntTools_SurfaceRangeSample const &":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_Last(self)

    def Append(self, *args) -> "void":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_Prepend(self, *args)

    def RemoveFirst(self) -> "void":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_RemoveFirst(self)

    def Remove(self, theIter: "IntTools_ListIteratorOfListOfSurfaceRangeSample") -> "void":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_Remove(self, theIter)

    def InsertBefore(self, *args) -> "void":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_InsertAfter(self, *args)

    def Reverse(self) -> "void":
        return _IntTools.IntTools_ListOfSurfaceRangeSample_Reverse(self)
    __swig_destroy__ = _IntTools.delete_IntTools_ListOfSurfaceRangeSample

    def __len__(self):
        return self.Size()


# Register IntTools_ListOfSurfaceRangeSample in _IntTools:
_IntTools.IntTools_ListOfSurfaceRangeSample_swigregister(IntTools_ListOfSurfaceRangeSample)

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

    def cbegin(self) -> "NCollection_Map< IntTools_CurveRangeSample,IntTools_CurveRangeSampleMapHasher >::const_iterator":
        return _IntTools.IntTools_MapOfCurveSample_cbegin(self)

    def cend(self) -> "NCollection_Map< IntTools_CurveRangeSample,IntTools_CurveRangeSampleMapHasher >::const_iterator":
        return _IntTools.IntTools_MapOfCurveSample_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_MapOfCurveSample_swiginit(self, _IntTools.new_IntTools_MapOfCurveSample(*args))

    def Exchange(self, theOther: "IntTools_MapOfCurveSample") -> "void":
        return _IntTools.IntTools_MapOfCurveSample_Exchange(self, theOther)

    def Assign(self, theOther: "IntTools_MapOfCurveSample") -> "NCollection_Map< IntTools_CurveRangeSample,IntTools_CurveRangeSampleMapHasher > &":
        return _IntTools.IntTools_MapOfCurveSample_Assign(self, theOther)

    def Set(self, theOther: "IntTools_MapOfCurveSample") -> "NCollection_Map< IntTools_CurveRangeSample,IntTools_CurveRangeSampleMapHasher > &":
        return _IntTools.IntTools_MapOfCurveSample_Set(self, theOther)

    def ReSize(self, N: "Standard_Integer const") -> "void":
        return _IntTools.IntTools_MapOfCurveSample_ReSize(self, N)

    def Add(self, K: "IntTools_CurveRangeSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfCurveSample_Add(self, K)

    def Added(self, K: "IntTools_CurveRangeSample") -> "IntTools_CurveRangeSample const &":
        return _IntTools.IntTools_MapOfCurveSample_Added(self, K)

    def Remove(self, K: "IntTools_CurveRangeSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfCurveSample_Remove(self, K)

    def Clear(self, *args) -> "void":
        return _IntTools.IntTools_MapOfCurveSample_Clear(self, *args)
    __swig_destroy__ = _IntTools.delete_IntTools_MapOfCurveSample

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_MapOfCurveSample_Size(self)

    def IsEqual(self, theOther: "IntTools_MapOfCurveSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfCurveSample_IsEqual(self, theOther)

    def Contains(self, *args) -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfCurveSample_Contains(self, *args)

    def Union(self, theLeft: "IntTools_MapOfCurveSample", theRight: "IntTools_MapOfCurveSample") -> "void":
        return _IntTools.IntTools_MapOfCurveSample_Union(self, theLeft, theRight)

    def Unite(self, theOther: "IntTools_MapOfCurveSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfCurveSample_Unite(self, theOther)

    def HasIntersection(self, theMap: "IntTools_MapOfCurveSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfCurveSample_HasIntersection(self, theMap)

    def Intersection(self, theLeft: "IntTools_MapOfCurveSample", theRight: "IntTools_MapOfCurveSample") -> "void":
        return _IntTools.IntTools_MapOfCurveSample_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther: "IntTools_MapOfCurveSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfCurveSample_Intersect(self, theOther)

    def Subtraction(self, theLeft: "IntTools_MapOfCurveSample", theRight: "IntTools_MapOfCurveSample") -> "void":
        return _IntTools.IntTools_MapOfCurveSample_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther: "IntTools_MapOfCurveSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfCurveSample_Subtract(self, theOther)

    def Difference(self, theLeft: "IntTools_MapOfCurveSample", theRight: "IntTools_MapOfCurveSample") -> "void":
        return _IntTools.IntTools_MapOfCurveSample_Difference(self, theLeft, theRight)

    def Differ(self, theOther: "IntTools_MapOfCurveSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfCurveSample_Differ(self, theOther)

# Register IntTools_MapOfCurveSample in _IntTools:
_IntTools.IntTools_MapOfCurveSample_swigregister(IntTools_MapOfCurveSample)

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

    def cbegin(self) -> "NCollection_Map< IntTools_SurfaceRangeSample,IntTools_SurfaceRangeSampleMapHasher >::const_iterator":
        return _IntTools.IntTools_MapOfSurfaceSample_cbegin(self)

    def cend(self) -> "NCollection_Map< IntTools_SurfaceRangeSample,IntTools_SurfaceRangeSampleMapHasher >::const_iterator":
        return _IntTools.IntTools_MapOfSurfaceSample_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_MapOfSurfaceSample_swiginit(self, _IntTools.new_IntTools_MapOfSurfaceSample(*args))

    def Exchange(self, theOther: "IntTools_MapOfSurfaceSample") -> "void":
        return _IntTools.IntTools_MapOfSurfaceSample_Exchange(self, theOther)

    def Assign(self, theOther: "IntTools_MapOfSurfaceSample") -> "NCollection_Map< IntTools_SurfaceRangeSample,IntTools_SurfaceRangeSampleMapHasher > &":
        return _IntTools.IntTools_MapOfSurfaceSample_Assign(self, theOther)

    def Set(self, theOther: "IntTools_MapOfSurfaceSample") -> "NCollection_Map< IntTools_SurfaceRangeSample,IntTools_SurfaceRangeSampleMapHasher > &":
        return _IntTools.IntTools_MapOfSurfaceSample_Set(self, theOther)

    def ReSize(self, N: "Standard_Integer const") -> "void":
        return _IntTools.IntTools_MapOfSurfaceSample_ReSize(self, N)

    def Add(self, K: "IntTools_SurfaceRangeSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfSurfaceSample_Add(self, K)

    def Added(self, K: "IntTools_SurfaceRangeSample") -> "IntTools_SurfaceRangeSample const &":
        return _IntTools.IntTools_MapOfSurfaceSample_Added(self, K)

    def Remove(self, K: "IntTools_SurfaceRangeSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfSurfaceSample_Remove(self, K)

    def Clear(self, *args) -> "void":
        return _IntTools.IntTools_MapOfSurfaceSample_Clear(self, *args)
    __swig_destroy__ = _IntTools.delete_IntTools_MapOfSurfaceSample

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_MapOfSurfaceSample_Size(self)

    def IsEqual(self, theOther: "IntTools_MapOfSurfaceSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfSurfaceSample_IsEqual(self, theOther)

    def Contains(self, *args) -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfSurfaceSample_Contains(self, *args)

    def Union(self, theLeft: "IntTools_MapOfSurfaceSample", theRight: "IntTools_MapOfSurfaceSample") -> "void":
        return _IntTools.IntTools_MapOfSurfaceSample_Union(self, theLeft, theRight)

    def Unite(self, theOther: "IntTools_MapOfSurfaceSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfSurfaceSample_Unite(self, theOther)

    def HasIntersection(self, theMap: "IntTools_MapOfSurfaceSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfSurfaceSample_HasIntersection(self, theMap)

    def Intersection(self, theLeft: "IntTools_MapOfSurfaceSample", theRight: "IntTools_MapOfSurfaceSample") -> "void":
        return _IntTools.IntTools_MapOfSurfaceSample_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther: "IntTools_MapOfSurfaceSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfSurfaceSample_Intersect(self, theOther)

    def Subtraction(self, theLeft: "IntTools_MapOfSurfaceSample", theRight: "IntTools_MapOfSurfaceSample") -> "void":
        return _IntTools.IntTools_MapOfSurfaceSample_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther: "IntTools_MapOfSurfaceSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfSurfaceSample_Subtract(self, theOther)

    def Difference(self, theLeft: "IntTools_MapOfSurfaceSample", theRight: "IntTools_MapOfSurfaceSample") -> "void":
        return _IntTools.IntTools_MapOfSurfaceSample_Difference(self, theLeft, theRight)

    def Differ(self, theOther: "IntTools_MapOfSurfaceSample") -> "Standard_Boolean":
        return _IntTools.IntTools_MapOfSurfaceSample_Differ(self, theOther)

# Register IntTools_MapOfSurfaceSample in _IntTools:
_IntTools.IntTools_MapOfSurfaceSample_swigregister(IntTools_MapOfSurfaceSample)

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

    def begin(self) -> "NCollection_Sequence< IntTools_CommonPrt >::iterator":
        return _IntTools.IntTools_SequenceOfCommonPrts_begin(self)

    def end(self) -> "NCollection_Sequence< IntTools_CommonPrt >::iterator":
        return _IntTools.IntTools_SequenceOfCommonPrts_end(self)

    def cbegin(self) -> "NCollection_Sequence< IntTools_CommonPrt >::const_iterator":
        return _IntTools.IntTools_SequenceOfCommonPrts_cbegin(self)

    def cend(self) -> "NCollection_Sequence< IntTools_CommonPrt >::const_iterator":
        return _IntTools.IntTools_SequenceOfCommonPrts_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_SequenceOfCommonPrts_swiginit(self, _IntTools.new_IntTools_SequenceOfCommonPrts(*args))

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfCommonPrts_Size(self)

    def Length(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfCommonPrts_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfCommonPrts_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfCommonPrts_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _IntTools.IntTools_SequenceOfCommonPrts_IsEmpty(self)

    def Reverse(self) -> "void":
        return _IntTools.IntTools_SequenceOfCommonPrts_Reverse(self)

    def Exchange(self, I: "Standard_Integer const", J: "Standard_Integer const") -> "void":
        return _IntTools.IntTools_SequenceOfCommonPrts_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode: "NCollection_SeqNode *", theAl: "IntSurf_Allocator") -> "void":
        return _IntTools.IntTools_SequenceOfCommonPrts_delNode(theNode, theAl)

    def Clear(self, theAllocator: "IntSurf_Allocator"=0) -> "void":
        return _IntTools.IntTools_SequenceOfCommonPrts_Clear(self, theAllocator)

    def Assign(self, theOther: "IntTools_SequenceOfCommonPrts") -> "NCollection_Sequence< IntTools_CommonPrt > &":
        return _IntTools.IntTools_SequenceOfCommonPrts_Assign(self, theOther)

    def Set(self, theOther: "IntTools_SequenceOfCommonPrts") -> "NCollection_Sequence< IntTools_CommonPrt > &":
        return _IntTools.IntTools_SequenceOfCommonPrts_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfCommonPrts_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfCommonPrts_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfCommonPrts_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfCommonPrts_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfCommonPrts_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "IntTools_SequenceOfCommonPrts") -> "void":
        return _IntTools.IntTools_SequenceOfCommonPrts_Split(self, theIndex, theSeq)

    def First(self) -> "IntTools_CommonPrt const &":
        return _IntTools.IntTools_SequenceOfCommonPrts_First(self)

    def ChangeFirst(self) -> "IntTools_CommonPrt &":
        return _IntTools.IntTools_SequenceOfCommonPrts_ChangeFirst(self)

    def Last(self) -> "IntTools_CommonPrt const &":
        return _IntTools.IntTools_SequenceOfCommonPrts_Last(self)

    def ChangeLast(self) -> "IntTools_CommonPrt &":
        return _IntTools.IntTools_SequenceOfCommonPrts_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "IntTools_CommonPrt const &":
        return _IntTools.IntTools_SequenceOfCommonPrts_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "IntTools_CommonPrt &":
        return _IntTools.IntTools_SequenceOfCommonPrts_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "IntTools_CommonPrt &":
        return _IntTools.IntTools_SequenceOfCommonPrts___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "IntTools_CommonPrt") -> "void":
        return _IntTools.IntTools_SequenceOfCommonPrts_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _IntTools.delete_IntTools_SequenceOfCommonPrts

    def __len__(self):
        return self.Size()


# Register IntTools_SequenceOfCommonPrts in _IntTools:
_IntTools.IntTools_SequenceOfCommonPrts_swigregister(IntTools_SequenceOfCommonPrts)

def IntTools_SequenceOfCommonPrts_delNode(theNode: "NCollection_SeqNode *", theAl: "IntSurf_Allocator") -> "void":
    return _IntTools.IntTools_SequenceOfCommonPrts_delNode(theNode, theAl)

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

    def begin(self) -> "NCollection_Sequence< IntTools_Curve >::iterator":
        return _IntTools.IntTools_SequenceOfCurves_begin(self)

    def end(self) -> "NCollection_Sequence< IntTools_Curve >::iterator":
        return _IntTools.IntTools_SequenceOfCurves_end(self)

    def cbegin(self) -> "NCollection_Sequence< IntTools_Curve >::const_iterator":
        return _IntTools.IntTools_SequenceOfCurves_cbegin(self)

    def cend(self) -> "NCollection_Sequence< IntTools_Curve >::const_iterator":
        return _IntTools.IntTools_SequenceOfCurves_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_SequenceOfCurves_swiginit(self, _IntTools.new_IntTools_SequenceOfCurves(*args))

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfCurves_Size(self)

    def Length(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfCurves_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfCurves_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfCurves_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _IntTools.IntTools_SequenceOfCurves_IsEmpty(self)

    def Reverse(self) -> "void":
        return _IntTools.IntTools_SequenceOfCurves_Reverse(self)

    def Exchange(self, I: "Standard_Integer const", J: "Standard_Integer const") -> "void":
        return _IntTools.IntTools_SequenceOfCurves_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode: "NCollection_SeqNode *", theAl: "IntSurf_Allocator") -> "void":
        return _IntTools.IntTools_SequenceOfCurves_delNode(theNode, theAl)

    def Clear(self, theAllocator: "IntSurf_Allocator"=0) -> "void":
        return _IntTools.IntTools_SequenceOfCurves_Clear(self, theAllocator)

    def Assign(self, theOther: "IntTools_SequenceOfCurves") -> "NCollection_Sequence< IntTools_Curve > &":
        return _IntTools.IntTools_SequenceOfCurves_Assign(self, theOther)

    def Set(self, theOther: "IntTools_SequenceOfCurves") -> "NCollection_Sequence< IntTools_Curve > &":
        return _IntTools.IntTools_SequenceOfCurves_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfCurves_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfCurves_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfCurves_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfCurves_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfCurves_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "IntTools_SequenceOfCurves") -> "void":
        return _IntTools.IntTools_SequenceOfCurves_Split(self, theIndex, theSeq)

    def First(self) -> "IntTools_Curve const &":
        return _IntTools.IntTools_SequenceOfCurves_First(self)

    def ChangeFirst(self) -> "IntTools_Curve &":
        return _IntTools.IntTools_SequenceOfCurves_ChangeFirst(self)

    def Last(self) -> "IntTools_Curve const &":
        return _IntTools.IntTools_SequenceOfCurves_Last(self)

    def ChangeLast(self) -> "IntTools_Curve &":
        return _IntTools.IntTools_SequenceOfCurves_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "IntTools_Curve const &":
        return _IntTools.IntTools_SequenceOfCurves_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "IntTools_Curve &":
        return _IntTools.IntTools_SequenceOfCurves_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "IntTools_Curve &":
        return _IntTools.IntTools_SequenceOfCurves___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "IntTools_Curve") -> "void":
        return _IntTools.IntTools_SequenceOfCurves_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _IntTools.delete_IntTools_SequenceOfCurves

    def __len__(self):
        return self.Size()


# Register IntTools_SequenceOfCurves in _IntTools:
_IntTools.IntTools_SequenceOfCurves_swigregister(IntTools_SequenceOfCurves)

def IntTools_SequenceOfCurves_delNode(theNode: "NCollection_SeqNode *", theAl: "IntSurf_Allocator") -> "void":
    return _IntTools.IntTools_SequenceOfCurves_delNode(theNode, theAl)

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

    def begin(self) -> "NCollection_Sequence< IntTools_PntOn2Faces >::iterator":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_begin(self)

    def end(self) -> "NCollection_Sequence< IntTools_PntOn2Faces >::iterator":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_end(self)

    def cbegin(self) -> "NCollection_Sequence< IntTools_PntOn2Faces >::const_iterator":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_cbegin(self)

    def cend(self) -> "NCollection_Sequence< IntTools_PntOn2Faces >::const_iterator":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_SequenceOfPntOn2Faces_swiginit(self, _IntTools.new_IntTools_SequenceOfPntOn2Faces(*args))

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Size(self)

    def Length(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_IsEmpty(self)

    def Reverse(self) -> "void":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Reverse(self)

    def Exchange(self, I: "Standard_Integer const", J: "Standard_Integer const") -> "void":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode: "NCollection_SeqNode *", theAl: "IntSurf_Allocator") -> "void":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_delNode(theNode, theAl)

    def Clear(self, theAllocator: "IntSurf_Allocator"=0) -> "void":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Clear(self, theAllocator)

    def Assign(self, theOther: "IntTools_SequenceOfPntOn2Faces") -> "NCollection_Sequence< IntTools_PntOn2Faces > &":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Assign(self, theOther)

    def Set(self, theOther: "IntTools_SequenceOfPntOn2Faces") -> "NCollection_Sequence< IntTools_PntOn2Faces > &":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "IntTools_SequenceOfPntOn2Faces") -> "void":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Split(self, theIndex, theSeq)

    def First(self) -> "IntTools_PntOn2Faces const &":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_First(self)

    def ChangeFirst(self) -> "IntTools_PntOn2Faces &":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_ChangeFirst(self)

    def Last(self) -> "IntTools_PntOn2Faces const &":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Last(self)

    def ChangeLast(self) -> "IntTools_PntOn2Faces &":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "IntTools_PntOn2Faces const &":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "IntTools_PntOn2Faces &":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "IntTools_PntOn2Faces &":
        return _IntTools.IntTools_SequenceOfPntOn2Faces___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "IntTools_PntOn2Faces") -> "void":
        return _IntTools.IntTools_SequenceOfPntOn2Faces_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _IntTools.delete_IntTools_SequenceOfPntOn2Faces

    def __len__(self):
        return self.Size()


# Register IntTools_SequenceOfPntOn2Faces in _IntTools:
_IntTools.IntTools_SequenceOfPntOn2Faces_swigregister(IntTools_SequenceOfPntOn2Faces)

def IntTools_SequenceOfPntOn2Faces_delNode(theNode: "NCollection_SeqNode *", theAl: "IntSurf_Allocator") -> "void":
    return _IntTools.IntTools_SequenceOfPntOn2Faces_delNode(theNode, theAl)

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

    def begin(self) -> "NCollection_Sequence< IntTools_Range >::iterator":
        return _IntTools.IntTools_SequenceOfRanges_begin(self)

    def end(self) -> "NCollection_Sequence< IntTools_Range >::iterator":
        return _IntTools.IntTools_SequenceOfRanges_end(self)

    def cbegin(self) -> "NCollection_Sequence< IntTools_Range >::const_iterator":
        return _IntTools.IntTools_SequenceOfRanges_cbegin(self)

    def cend(self) -> "NCollection_Sequence< IntTools_Range >::const_iterator":
        return _IntTools.IntTools_SequenceOfRanges_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_SequenceOfRanges_swiginit(self, _IntTools.new_IntTools_SequenceOfRanges(*args))

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfRanges_Size(self)

    def Length(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfRanges_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfRanges_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfRanges_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _IntTools.IntTools_SequenceOfRanges_IsEmpty(self)

    def Reverse(self) -> "void":
        return _IntTools.IntTools_SequenceOfRanges_Reverse(self)

    def Exchange(self, I: "Standard_Integer const", J: "Standard_Integer const") -> "void":
        return _IntTools.IntTools_SequenceOfRanges_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode: "NCollection_SeqNode *", theAl: "IntSurf_Allocator") -> "void":
        return _IntTools.IntTools_SequenceOfRanges_delNode(theNode, theAl)

    def Clear(self, theAllocator: "IntSurf_Allocator"=0) -> "void":
        return _IntTools.IntTools_SequenceOfRanges_Clear(self, theAllocator)

    def Assign(self, theOther: "IntTools_SequenceOfRanges") -> "NCollection_Sequence< IntTools_Range > &":
        return _IntTools.IntTools_SequenceOfRanges_Assign(self, theOther)

    def Set(self, theOther: "IntTools_SequenceOfRanges") -> "NCollection_Sequence< IntTools_Range > &":
        return _IntTools.IntTools_SequenceOfRanges_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfRanges_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfRanges_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfRanges_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfRanges_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfRanges_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "IntTools_SequenceOfRanges") -> "void":
        return _IntTools.IntTools_SequenceOfRanges_Split(self, theIndex, theSeq)

    def First(self) -> "IntTools_Range const &":
        return _IntTools.IntTools_SequenceOfRanges_First(self)

    def ChangeFirst(self) -> "IntTools_Range &":
        return _IntTools.IntTools_SequenceOfRanges_ChangeFirst(self)

    def Last(self) -> "IntTools_Range const &":
        return _IntTools.IntTools_SequenceOfRanges_Last(self)

    def ChangeLast(self) -> "IntTools_Range &":
        return _IntTools.IntTools_SequenceOfRanges_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "IntTools_Range const &":
        return _IntTools.IntTools_SequenceOfRanges_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "IntTools_Range &":
        return _IntTools.IntTools_SequenceOfRanges_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "IntTools_Range &":
        return _IntTools.IntTools_SequenceOfRanges___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "IntTools_Range") -> "void":
        return _IntTools.IntTools_SequenceOfRanges_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _IntTools.delete_IntTools_SequenceOfRanges

    def __len__(self):
        return self.Size()


# Register IntTools_SequenceOfRanges in _IntTools:
_IntTools.IntTools_SequenceOfRanges_swigregister(IntTools_SequenceOfRanges)

def IntTools_SequenceOfRanges_delNode(theNode: "NCollection_SeqNode *", theAl: "IntSurf_Allocator") -> "void":
    return _IntTools.IntTools_SequenceOfRanges_delNode(theNode, theAl)

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

    def begin(self) -> "NCollection_Sequence< IntTools_Root >::iterator":
        return _IntTools.IntTools_SequenceOfRoots_begin(self)

    def end(self) -> "NCollection_Sequence< IntTools_Root >::iterator":
        return _IntTools.IntTools_SequenceOfRoots_end(self)

    def cbegin(self) -> "NCollection_Sequence< IntTools_Root >::const_iterator":
        return _IntTools.IntTools_SequenceOfRoots_cbegin(self)

    def cend(self) -> "NCollection_Sequence< IntTools_Root >::const_iterator":
        return _IntTools.IntTools_SequenceOfRoots_cend(self)

    def __init__(self, *args):
        _IntTools.IntTools_SequenceOfRoots_swiginit(self, _IntTools.new_IntTools_SequenceOfRoots(*args))

    def Size(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfRoots_Size(self)

    def Length(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfRoots_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfRoots_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _IntTools.IntTools_SequenceOfRoots_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _IntTools.IntTools_SequenceOfRoots_IsEmpty(self)

    def Reverse(self) -> "void":
        return _IntTools.IntTools_SequenceOfRoots_Reverse(self)

    def Exchange(self, I: "Standard_Integer const", J: "Standard_Integer const") -> "void":
        return _IntTools.IntTools_SequenceOfRoots_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode: "NCollection_SeqNode *", theAl: "IntSurf_Allocator") -> "void":
        return _IntTools.IntTools_SequenceOfRoots_delNode(theNode, theAl)

    def Clear(self, theAllocator: "IntSurf_Allocator"=0) -> "void":
        return _IntTools.IntTools_SequenceOfRoots_Clear(self, theAllocator)

    def Assign(self, theOther: "IntTools_SequenceOfRoots") -> "NCollection_Sequence< IntTools_Root > &":
        return _IntTools.IntTools_SequenceOfRoots_Assign(self, theOther)

    def Set(self, theOther: "IntTools_SequenceOfRoots") -> "NCollection_Sequence< IntTools_Root > &":
        return _IntTools.IntTools_SequenceOfRoots_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfRoots_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfRoots_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfRoots_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfRoots_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _IntTools.IntTools_SequenceOfRoots_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "IntTools_SequenceOfRoots") -> "void":
        return _IntTools.IntTools_SequenceOfRoots_Split(self, theIndex, theSeq)

    def First(self) -> "IntTools_Root const &":
        return _IntTools.IntTools_SequenceOfRoots_First(self)

    def ChangeFirst(self) -> "IntTools_Root &":
        return _IntTools.IntTools_SequenceOfRoots_ChangeFirst(self)

    def Last(self) -> "IntTools_Root const &":
        return _IntTools.IntTools_SequenceOfRoots_Last(self)

    def ChangeLast(self) -> "IntTools_Root &":
        return _IntTools.IntTools_SequenceOfRoots_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "IntTools_Root const &":
        return _IntTools.IntTools_SequenceOfRoots_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "IntTools_Root &":
        return _IntTools.IntTools_SequenceOfRoots_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "IntTools_Root &":
        return _IntTools.IntTools_SequenceOfRoots___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "IntTools_Root") -> "void":
        return _IntTools.IntTools_SequenceOfRoots_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _IntTools.delete_IntTools_SequenceOfRoots

    def __len__(self):
        return self.Size()


# Register IntTools_SequenceOfRoots in _IntTools:
_IntTools.IntTools_SequenceOfRoots_swigregister(IntTools_SequenceOfRoots)

def IntTools_SequenceOfRoots_delNode(theNode: "NCollection_SeqNode *", theAl: "IntSurf_Allocator") -> "void":
    return _IntTools.IntTools_SequenceOfRoots_delNode(theNode, theAl)

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

    @staticmethod
    def FindRootStates(*args) -> "void":
        r"""
        Find the states (before and after) for each root from the sequence aseq.

        Parameters
        ----------
        aSeq: IntTools_SequenceOfRoots
        anEpsNull: float

        Returns
        -------
        None

        """
        return _IntTools.inttools_FindRootStates(*args)

    @staticmethod
    def GetRadius(*args) -> "Standard_Real &":
        r"""
        No available documentation.

        Parameters
        ----------
        C: BRepAdaptor_Curve
        t1: float
        t3: float

        Returns
        -------
        R: float

        """
        return _IntTools.inttools_GetRadius(*args)

    @staticmethod
    def Length(*args) -> "Standard_Real":
        r"""
        Returns the length of the edge;.

        Parameters
        ----------
        E: TopoDS_Edge

        Returns
        -------
        float

        """
        return _IntTools.inttools_Length(*args)

    @staticmethod
    def Parameter(*args) -> "Standard_Real &":
        r"""
        No available documentation.

        Parameters
        ----------
        P: gp_Pnt
        Curve: Geom_Curve

        Returns
        -------
        aParm: float

        """
        return _IntTools.inttools_Parameter(*args)

    @staticmethod
    def PrepareArgs(*args) -> "Standard_Integer":
        r"""
        No available documentation.

        Parameters
        ----------
        C: BRepAdaptor_Curve
        tMax: float
        tMin: float
        Discret: int
        Deflect: float
        anArgs: IntTools_CArray1OfReal

        Returns
        -------
        int

        """
        return _IntTools.inttools_PrepareArgs(*args)

    @staticmethod
    def RemoveIdenticalRoots(*args) -> "void":
        r"""
        Remove from the sequence aseq the roots that have values ti and tj such as |ti-tj] < anepst.

        Parameters
        ----------
        aSeq: IntTools_SequenceOfRoots
        anEpsT: float

        Returns
        -------
        None

        """
        return _IntTools.inttools_RemoveIdenticalRoots(*args)

    @staticmethod
    def SortRoots(*args) -> "void":
        r"""
        Sort the sequence aseq of the roots to arrange the roons in increasing order.

        Parameters
        ----------
        aSeq: IntTools_SequenceOfRoots
        anEpsT: float

        Returns
        -------
        None

        """
        return _IntTools.inttools_SortRoots(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _IntTools.inttools_swiginit(self, _IntTools.new_inttools())
    __swig_destroy__ = _IntTools.delete_inttools

# Register inttools in _IntTools:
_IntTools.inttools_swigregister(inttools)

def inttools_FindRootStates(*args) -> "void":
    r"""
    Find the states (before and after) for each root from the sequence aseq.

    Parameters
    ----------
    aSeq: IntTools_SequenceOfRoots
    anEpsNull: float

    Returns
    -------
    None

    """
    return _IntTools.inttools_FindRootStates(*args)

def inttools_GetRadius(*args) -> "Standard_Real &":
    r"""
    No available documentation.

    Parameters
    ----------
    C: BRepAdaptor_Curve
    t1: float
    t3: float

    Returns
    -------
    R: float

    """
    return _IntTools.inttools_GetRadius(*args)

def inttools_Length(*args) -> "Standard_Real":
    r"""
    Returns the length of the edge;.

    Parameters
    ----------
    E: TopoDS_Edge

    Returns
    -------
    float

    """
    return _IntTools.inttools_Length(*args)

def inttools_Parameter(*args) -> "Standard_Real &":
    r"""
    No available documentation.

    Parameters
    ----------
    P: gp_Pnt
    Curve: Geom_Curve

    Returns
    -------
    aParm: float

    """
    return _IntTools.inttools_Parameter(*args)

def inttools_PrepareArgs(*args) -> "Standard_Integer":
    r"""
    No available documentation.

    Parameters
    ----------
    C: BRepAdaptor_Curve
    tMax: float
    tMin: float
    Discret: int
    Deflect: float
    anArgs: IntTools_CArray1OfReal

    Returns
    -------
    int

    """
    return _IntTools.inttools_PrepareArgs(*args)

def inttools_RemoveIdenticalRoots(*args) -> "void":
    r"""
    Remove from the sequence aseq the roots that have values ti and tj such as |ti-tj] < anepst.

    Parameters
    ----------
    aSeq: IntTools_SequenceOfRoots
    anEpsT: float

    Returns
    -------
    None

    """
    return _IntTools.inttools_RemoveIdenticalRoots(*args)

def inttools_SortRoots(*args) -> "void":
    r"""
    Sort the sequence aseq of the roots to arrange the roons in increasing order.

    Parameters
    ----------
    aSeq: IntTools_SequenceOfRoots
    anEpsT: float

    Returns
    -------
    None

    """
    return _IntTools.inttools_SortRoots(*args)

class IntTools_BaseRangeSample(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"""
        No available documentation.

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        theDepth: int

        Returns
        -------
        None

        """
        _IntTools.IntTools_BaseRangeSample_swiginit(self, _IntTools.new_IntTools_BaseRangeSample(*args))

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

        Returns
        -------
        int

        """
        return _IntTools.IntTools_BaseRangeSample_GetDepth(self, *args)

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

        Parameters
        ----------
        theDepth: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_BaseRangeSample_SetDepth(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_BaseRangeSample

# Register IntTools_BaseRangeSample in _IntTools:
_IntTools.IntTools_BaseRangeSample_swigregister(IntTools_BaseRangeSample)

class IntTools_BeanFaceIntersector(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"""
        No available documentation.

        Returns
        -------
        None
        Initializes the algorithm //! warning: the parts of the edge which are on the surface of the face and belong to the whole in the face (if there is) is considered as result.

        Parameters
        ----------
        theEdge: TopoDS_Edge
        theFace: TopoDS_Face

        Returns
        -------
        None
        Initializes the algorithm.

        Parameters
        ----------
        theCurve: BRepAdaptor_Curve
        theSurface: BRepAdaptor_Surface
        theBeanTolerance: float
        theFaceTolerance: float

        Returns
        -------
        None
        Initializes the algorithm theuminparameter, ... are used for optimization purposes.

        Parameters
        ----------
        theCurve: BRepAdaptor_Curve
        theSurface: BRepAdaptor_Surface
        theFirstParOnCurve: float
        theLastParOnCurve: float
        theUMinParameter: float
        theUMaxParameter: float
        theVMinParameter: float
        theVMaxParameter: float
        theBeanTolerance: float
        theFaceTolerance: float

        Returns
        -------
        None

        """
        _IntTools.IntTools_BeanFaceIntersector_swiginit(self, _IntTools.new_IntTools_BeanFaceIntersector(*args))

    def Context(self, *args) -> "opencascade::handle< IntTools_Context > const &":
        r"""
        Gets the intersecton context.

        Returns
        -------
        opencascade::handle<IntTools_Context>

        """
        return _IntTools.IntTools_BeanFaceIntersector_Context(self, *args)

    def Init(self, *args) -> "void":
        r"""
        Initializes the algorithm //! warning: the parts of the edge which are on the surface of the face and belong to the whole in the face (if there is) is considered as result.

        Parameters
        ----------
        theEdge: TopoDS_Edge
        theFace: TopoDS_Face

        Returns
        -------
        None
        Initializes the algorithm.

        Parameters
        ----------
        theCurve: BRepAdaptor_Curve
        theSurface: BRepAdaptor_Surface
        theBeanTolerance: float
        theFaceTolerance: float

        Returns
        -------
        None
        Initializes the algorithm theuminparameter, ... are used for optimization purposes.

        Parameters
        ----------
        theCurve: BRepAdaptor_Curve
        theSurface: BRepAdaptor_Surface
        theFirstParOnCurve: float
        theLastParOnCurve: float
        theUMinParameter: float
        theUMaxParameter: float
        theVMinParameter: float
        theVMaxParameter: float
        theBeanTolerance: float
        theFaceTolerance: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_BeanFaceIntersector_Init(self, *args)

    def IsDone(self, *args) -> "Standard_Boolean":
        r"""
        Returns done/notdone state of the algorithm.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_BeanFaceIntersector_IsDone(self, *args)

    def MinimalSquareDistance(self, *args) -> "Standard_Real":
        r"""
        Returns the minimal distance found between edge and face.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_BeanFaceIntersector_MinimalSquareDistance(self, *args)

    def Perform(self, *args) -> "void":
        r"""
        Launches the algorithm.

        Returns
        -------
        None

        """
        return _IntTools.IntTools_BeanFaceIntersector_Perform(self, *args)

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

        Returns
        -------
        IntTools_SequenceOfRanges
        No available documentation.

        Parameters
        ----------
        theResults: IntTools_SequenceOfRanges

        Returns
        -------
        None

        """
        return _IntTools.IntTools_BeanFaceIntersector_Result(self, *args)

    def SetBeanParameters(self, *args) -> "void":
        r"""
        Set restrictions for curve.

        Parameters
        ----------
        theFirstParOnCurve: float
        theLastParOnCurve: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_BeanFaceIntersector_SetBeanParameters(self, *args)

    def SetContext(self, *args) -> "void":
        r"""
        Sets the intersecton context.

        Parameters
        ----------
        theContext: IntTools_Context

        Returns
        -------
        None

        """
        return _IntTools.IntTools_BeanFaceIntersector_SetContext(self, *args)

    def SetSurfaceParameters(self, *args) -> "void":
        r"""
        Set restrictions for surface.

        Parameters
        ----------
        theUMinParameter: float
        theUMaxParameter: float
        theVMinParameter: float
        theVMaxParameter: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_BeanFaceIntersector_SetSurfaceParameters(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_BeanFaceIntersector

# Register IntTools_BeanFaceIntersector in _IntTools:
_IntTools.IntTools_BeanFaceIntersector_swigregister(IntTools_BeanFaceIntersector)

class IntTools_CommonPrt(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"""
        Empty constructor.

        Returns
        -------
        None
        Copy constructor.

        Parameters
        ----------
        aCPrt: IntTools_CommonPrt

        Returns
        -------
        None

        """
        _IntTools.IntTools_CommonPrt_swiginit(self, _IntTools.new_IntTools_CommonPrt(*args))

    def AllNullFlag(self, *args) -> "Standard_Boolean":
        r"""
        Modifier.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_CommonPrt_AllNullFlag(self, *args)

    def AppendRange2(self, *args) -> "void":
        r"""
        Appends the range of second edge.

        Parameters
        ----------
        aR: IntTools_Range

        Returns
        -------
        None
        Appends the range of second edge.

        Parameters
        ----------
        tf: float
        tl: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CommonPrt_AppendRange2(self, *args)

    def Assign(self, *args) -> "IntTools_CommonPrt &":
        r"""
        No available documentation.

        Parameters
        ----------
        Other: IntTools_CommonPrt

        Returns
        -------
        IntTools_CommonPrt

        """
        return _IntTools.IntTools_CommonPrt_Assign(self, *args)

    def BoundingPoints(self, *args) -> "void":
        r"""
        Selector.

        Parameters
        ----------
        aP1: gp_Pnt
        aP2: gp_Pnt

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CommonPrt_BoundingPoints(self, *args)

    def ChangeRanges2(self, *args) -> "IntTools_SequenceOfRanges &":
        r"""
        Returns the ranges of second edge.

        Returns
        -------
        IntTools_SequenceOfRanges

        """
        return _IntTools.IntTools_CommonPrt_ChangeRanges2(self, *args)

    def Copy(self, *args) -> "void":
        r"""
        Copies me to another.

        Parameters
        ----------
        anOther: IntTools_CommonPrt

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CommonPrt_Copy(self, *args)

    def Edge1(self, *args) -> "TopoDS_Edge const":
        r"""
        Returns the first edge.

        Returns
        -------
        TopoDS_Edge

        """
        return _IntTools.IntTools_CommonPrt_Edge1(self, *args)

    def Edge2(self, *args) -> "TopoDS_Edge const":
        r"""
        Returns the second edge.

        Returns
        -------
        TopoDS_Edge

        """
        return _IntTools.IntTools_CommonPrt_Edge2(self, *args)

    def Range1(self, *args) -> "void":
        r"""
        Returns the range of first edge.

        Returns
        -------
        IntTools_Range
        Returns the range of first edge.

        Parameters
        ----------

        Returns
        -------
        tf: float
        tl: float

        """
        return _IntTools.IntTools_CommonPrt_Range1(self, *args)

    def Ranges2(self, *args) -> "IntTools_SequenceOfRanges const &":
        r"""
        Returns the ranges of second edge.

        Returns
        -------
        IntTools_SequenceOfRanges

        """
        return _IntTools.IntTools_CommonPrt_Ranges2(self, *args)

    def SetAllNullFlag(self, *args) -> "void":
        r"""
        Selector.

        Parameters
        ----------
        aFlag: bool

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CommonPrt_SetAllNullFlag(self, *args)

    def SetBoundingPoints(self, *args) -> "void":
        r"""
        Modifier.

        Parameters
        ----------
        aP1: gp_Pnt
        aP2: gp_Pnt

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CommonPrt_SetBoundingPoints(self, *args)

    def SetEdge1(self, *args) -> "void":
        r"""
        Sets the first edge.

        Parameters
        ----------
        anE: TopoDS_Edge

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CommonPrt_SetEdge1(self, *args)

    def SetEdge2(self, *args) -> "void":
        r"""
        Sets the second edge.

        Parameters
        ----------
        anE: TopoDS_Edge

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CommonPrt_SetEdge2(self, *args)

    def SetRange1(self, *args) -> "void":
        r"""
        Sets the range of first edge.

        Parameters
        ----------
        aR: IntTools_Range

        Returns
        -------
        None
        Sets the range of first edge.

        Parameters
        ----------
        tf: float
        tl: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CommonPrt_SetRange1(self, *args)

    def SetType(self, *args) -> "void":
        r"""
        Sets the type of the common part vertex or edge.

        Parameters
        ----------
        aType: TopAbs_ShapeEnum

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CommonPrt_SetType(self, *args)

    def SetVertexParameter1(self, *args) -> "void":
        r"""
        Sets a parameter of first vertex.

        Parameters
        ----------
        tV: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CommonPrt_SetVertexParameter1(self, *args)

    def SetVertexParameter2(self, *args) -> "void":
        r"""
        Sets a parameter of second vertex.

        Parameters
        ----------
        tV: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CommonPrt_SetVertexParameter2(self, *args)

    def Type(self, *args) -> "TopAbs_ShapeEnum":
        r"""
        Returns the type of the common part.

        Returns
        -------
        TopAbs_ShapeEnum

        """
        return _IntTools.IntTools_CommonPrt_Type(self, *args)

    def VertexParameter1(self, *args) -> "Standard_Real":
        r"""
        Returns parameter of first vertex.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_CommonPrt_VertexParameter1(self, *args)

    def VertexParameter2(self, *args) -> "Standard_Real":
        r"""
        Returns parameter of second vertex.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_CommonPrt_VertexParameter2(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_CommonPrt

# Register IntTools_CommonPrt in _IntTools:
_IntTools.IntTools_CommonPrt_swigregister(IntTools_CommonPrt)

class IntTools_Context(OCC.Core.Standard.Standard_Transient):
    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"""
        No available documentation.

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        theAllocator: NCollection_BaseAllocator

        Returns
        -------
        None

        """
        _IntTools.IntTools_Context_swiginit(self, _IntTools.new_IntTools_Context(*args))

    def BndBox(self, *args) -> "Bnd_Box &":
        r"""
        No available documentation.

        Parameters
        ----------
        theS: TopoDS_Shape

        Returns
        -------
        Bnd_Box

        """
        return _IntTools.IntTools_Context_BndBox(self, *args)

    def ComputePE(self, *args) -> "Standard_Integer":
        r"""
        Computes parameter of the point thep on the edge ae. returns zero if the distance between point and edge is less than sum of tolerance value of edge and thetopp, otherwise and for following conditions returns negative value 1. the edge is degenerated (-1) 2. the edge does not contain 3d curve and pcurves (-2) 3. projection algorithm failed (-3).

        Parameters
        ----------
        theP: gp_Pnt
        theTolP: float
        theE: TopoDS_Edge

        Returns
        -------
        theT: float
        theDist: float

        """
        return _IntTools.IntTools_Context_ComputePE(self, *args)

    def ComputeVE(self, *args) -> "Standard_Integer":
        r"""
        Computes parameter of the vertex av on the edge ae and correct tolerance value for the vertex on the edge. returns zero if the distance between vertex and edge is less than sum of tolerances and the fuzzy value, otherwise and for following conditions returns negative value: 1. the edge is degenerated (-1) 2. the edge does not contain 3d curve and pcurves (-2) 3. projection algorithm failed (-3).

        Parameters
        ----------
        theV: TopoDS_Vertex
        theE: TopoDS_Edge
        theFuzz: float,optional
        	default value is Precision::Confusion()

        Returns
        -------
        theT: float
        theTol: float

        """
        return _IntTools.IntTools_Context_ComputeVE(self, *args)

    def ComputeVF(self, *args) -> "Standard_Integer":
        r"""
        Computes uv parameters of the vertex av on face af and correct tolerance value for the vertex on the face. returns zero if the distance between vertex and face is less than or equal the sum of tolerances and the fuzzy value and the projection point lays inside boundaries of the face. for following conditions returns negative value 1. projection algorithm failed (-1) 2. distance is more than sum of tolerances (-2) 3. projection point out or on the boundaries of face (-3).

        Parameters
        ----------
        theVertex: TopoDS_Vertex
        theFace: TopoDS_Face
        theFuzz: float,optional
        	default value is Precision::Confusion()

        Returns
        -------
        theU: float
        theV: float
        theTol: float

        """
        return _IntTools.IntTools_Context_ComputeVF(self, *args)

    def FClass2d(self, *args) -> "IntTools_FClass2d &":
        r"""
        Returns a reference to point classifier for given face.

        Parameters
        ----------
        aF: TopoDS_Face

        Returns
        -------
        IntTools_FClass2d

        """
        return _IntTools.IntTools_Context_FClass2d(self, *args)

    def Hatcher(self, *args) -> "Geom2dHatch_Hatcher &":
        r"""
        Returns a reference to 2d hatcher for given face.

        Parameters
        ----------
        aF: TopoDS_Face

        Returns
        -------
        Geom2dHatch_Hatcher

        """
        return _IntTools.IntTools_Context_Hatcher(self, *args)

    def IsInfiniteFace(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the solid <theface> has infinite bounds.

        Parameters
        ----------
        theFace: TopoDS_Face

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Context_IsInfiniteFace(self, *args)

    def IsPointInFace(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the point ap2d is inside the boundaries of the face af, otherwise returns false.

        Parameters
        ----------
        aF: TopoDS_Face
        aP2D: gp_Pnt2d

        Returns
        -------
        bool
        Returns true if the point ap2d is inside the boundaries of the face af, otherwise returns false.

        Parameters
        ----------
        aP3D: gp_Pnt
        aF: TopoDS_Face
        aTol: float

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Context_IsPointInFace(self, *args)

    def IsPointInOnFace(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the point ap2d is inside or on the boundaries of af.

        Parameters
        ----------
        aF: TopoDS_Face
        aP2D: gp_Pnt2d

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Context_IsPointInOnFace(self, *args)

    def IsValidBlockForFace(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if isvalidpointforface returns true for some 3d point that lay on the curve aic bounded by parameters at1 and at2.

        Parameters
        ----------
        aT1: float
        aT2: float
        aIC: IntTools_Curve
        aF: TopoDS_Face
        aTol: float

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Context_IsValidBlockForFace(self, *args)

    def IsValidBlockForFaces(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if isvalidblockforface returns true for both faces af1 and af2.

        Parameters
        ----------
        aT1: float
        aT2: float
        aIC: IntTools_Curve
        aF1: TopoDS_Face
        aF2: TopoDS_Face
        aTol: float

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Context_IsValidBlockForFaces(self, *args)

    def IsValidPointForFace(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the distance between point ap3d and face af is less or equal to tolerance atol and projection point is inside or on the boundaries of the face af.

        Parameters
        ----------
        aP3D: gp_Pnt
        aF: TopoDS_Face
        aTol: float

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Context_IsValidPointForFace(self, *args)

    def IsValidPointForFaces(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if isvalidpointforface returns true for both face af1 and af2.

        Parameters
        ----------
        aP3D: gp_Pnt
        aF1: TopoDS_Face
        aF2: TopoDS_Face
        aTol: float

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Context_IsValidPointForFaces(self, *args)

    def IsVertexOnLine(self, *args) -> "Standard_Boolean":
        r"""
        Computes parameter of the vertex av on the curve aic. returns true if the distance between vertex and curve is less than sum of tolerance of av and atolc, otherwise or if projection algorithm failed returns false (in this case at isn't significant).

        Parameters
        ----------
        aV: TopoDS_Vertex
        aIC: IntTools_Curve
        aTolC: float

        Returns
        -------
        aT: float
        Computes parameter of the vertex av on the curve aic. returns true if the distance between vertex and curve is less than sum of tolerance of av and atolc, otherwise or if projection algorithm failed returns false (in this case at isn't significant).

        Parameters
        ----------
        aV: TopoDS_Vertex
        aTolV: float
        aIC: IntTools_Curve
        aTolC: float

        Returns
        -------
        aT: float

        """
        return _IntTools.IntTools_Context_IsVertexOnLine(self, *args)

    def OBB(self, *args) -> "Bnd_OBB &":
        r"""
        Builds and stores an oriented bounding box for the shape. returns a reference to obb.

        Parameters
        ----------
        theShape: TopoDS_Shape
        theFuzzyValue: float,optional
        	default value is Precision::Confusion()

        Returns
        -------
        Bnd_OBB

        """
        return _IntTools.IntTools_Context_OBB(self, *args)

    def ProjPC(self, *args) -> "GeomAPI_ProjectPointOnCurve &":
        r"""
        Returns a reference to point projector for given edge.

        Parameters
        ----------
        aE: TopoDS_Edge

        Returns
        -------
        GeomAPI_ProjectPointOnCurve

        """
        return _IntTools.IntTools_Context_ProjPC(self, *args)

    def ProjPS(self, *args) -> "GeomAPI_ProjectPointOnSurf &":
        r"""
        Returns a reference to point projector for given face.

        Parameters
        ----------
        aF: TopoDS_Face

        Returns
        -------
        GeomAPI_ProjectPointOnSurf

        """
        return _IntTools.IntTools_Context_ProjPS(self, *args)

    def ProjPT(self, *args) -> "GeomAPI_ProjectPointOnCurve &":
        r"""
        Returns a reference to point projector for given curve.

        Parameters
        ----------
        aC: Geom_Curve

        Returns
        -------
        GeomAPI_ProjectPointOnCurve

        """
        return _IntTools.IntTools_Context_ProjPT(self, *args)

    def ProjectPointOnEdge(self, *args) -> "Standard_Boolean":
        r"""
        Computes parameter of the point ap on the edge ae. returns false if projection algorithm failed other wiese returns true.

        Parameters
        ----------
        aP: gp_Pnt
        aE: TopoDS_Edge

        Returns
        -------
        aT: float

        """
        return _IntTools.IntTools_Context_ProjectPointOnEdge(self, *args)

    def SetPOnSProjectionTolerance(self, *args) -> "void":
        r"""
        Sets tolerance to be used for projection of point on surface. clears map of already cached projectors in order to maintain correct value for all projectors.

        Parameters
        ----------
        theValue: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Context_SetPOnSProjectionTolerance(self, *args)

    def SolidClassifier(self, *args) -> "BRepClass3d_SolidClassifier &":
        r"""
        Returns a reference to solid classifier for given solid.

        Parameters
        ----------
        aSolid: TopoDS_Solid

        Returns
        -------
        BRepClass3d_SolidClassifier

        """
        return _IntTools.IntTools_Context_SolidClassifier(self, *args)

    def StatePointFace(self, *args) -> "TopAbs_State":
        r"""
        Returns the state of the point ap2d relative to face af.

        Parameters
        ----------
        aF: TopoDS_Face
        aP2D: gp_Pnt2d

        Returns
        -------
        TopAbs_State

        """
        return _IntTools.IntTools_Context_StatePointFace(self, *args)

    def SurfaceAdaptor(self, *args) -> "BRepAdaptor_Surface &":
        r"""
        Returns a reference to surface adaptor for given face.

        Parameters
        ----------
        theFace: TopoDS_Face

        Returns
        -------
        BRepAdaptor_Surface

        """
        return _IntTools.IntTools_Context_SurfaceAdaptor(self, *args)

    def SurfaceData(self, *args) -> "IntTools_SurfaceRangeLocalizeData &":
        r"""
        Returns a reference to surface localization data for given face.

        Parameters
        ----------
        aF: TopoDS_Face

        Returns
        -------
        IntTools_SurfaceRangeLocalizeData

        """
        return _IntTools.IntTools_Context_SurfaceData(self, *args)

    def UVBounds(self, *args) -> "void":
        r"""
        Computes the boundaries of the face using surface adaptor.

        Parameters
        ----------
        theFace: TopoDS_Face

        Returns
        -------
        UMin: float
        UMax: float
        VMin: float
        VMax: float

        """
        return _IntTools.IntTools_Context_UVBounds(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_IntTools_Context_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_Context

# Register IntTools_Context in _IntTools:
_IntTools.IntTools_Context_swigregister(IntTools_Context)

class IntTools_Curve(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"""
        Empty constructor.

        Returns
        -------
        None
        Constructor taking 3d curve, two 2d curves and two tolerance values.

        Parameters
        ----------
        the3dCurve3d: Geom_Curve
        the2dCurve1: Geom2d_Curve
        the2dCurve2: Geom2d_Curve
        theTolerance: float,optional
        	default value is 0.0
        theTangentialTolerance: float,optional
        	default value is 0.0

        Returns
        -------
        None

        """
        _IntTools.IntTools_Curve_swiginit(self, _IntTools.new_IntTools_Curve(*args))

    def Bounds(self, *args) -> "Standard_Boolean":
        r"""
        If the 3d curve is bounded curve the method will return true and modify the output parameters with boundary parameters of the curve and corresponded 3d points. if the curve does not have bounds, the method will return false and the output parameters will stay untouched.

        Parameters
        ----------
        theFirstPnt: gp_Pnt
        theLastPnt: gp_Pnt

        Returns
        -------
        theFirst: float
        theLast: float

        """
        return _IntTools.IntTools_Curve_Bounds(self, *args)

    def Curve(self, *args) -> "opencascade::handle< Geom_Curve > const &":
        r"""
        Returns 3d curve.

        Returns
        -------
        opencascade::handle<Geom_Curve>

        """
        return _IntTools.IntTools_Curve_Curve(self, *args)

    def D0(self, *args) -> "Standard_Boolean":
        r"""
        Computes 3d point corresponded to the given parameter if this parameter is inside the boundaries of the curve. returns true in this case. otherwise, the point will not be computed and the method will return false.

        Parameters
        ----------
        thePar: float
        thePnt: gp_Pnt

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Curve_D0(self, *args)

    def FirstCurve2d(self, *args) -> "opencascade::handle< Geom2d_Curve > const &":
        r"""
        Returns first 2d curve.

        Returns
        -------
        opencascade::handle<Geom2d_Curve>

        """
        return _IntTools.IntTools_Curve_FirstCurve2d(self, *args)

    def HasBounds(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if 3d curve is boundedcurve.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Curve_HasBounds(self, *args)

    def SecondCurve2d(self, *args) -> "opencascade::handle< Geom2d_Curve > const &":
        r"""
        Returns second 2d curve.

        Returns
        -------
        opencascade::handle<Geom2d_Curve>

        """
        return _IntTools.IntTools_Curve_SecondCurve2d(self, *args)

    def SetCurve(self, *args) -> "void":
        r"""
        Sets the 3d curve.

        Parameters
        ----------
        the3dCurve: Geom_Curve

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Curve_SetCurve(self, *args)

    def SetCurves(self, *args) -> "void":
        r"""
        Sets the curves.

        Parameters
        ----------
        the3dCurve: Geom_Curve
        the2dCurve1: Geom2d_Curve
        the2dCurve2: Geom2d_Curve

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Curve_SetCurves(self, *args)

    def SetFirstCurve2d(self, *args) -> "void":
        r"""
        Sets the first 2d curve.

        Parameters
        ----------
        the2dCurve1: Geom2d_Curve

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Curve_SetFirstCurve2d(self, *args)

    def SetSecondCurve2d(self, *args) -> "void":
        r"""
        Sets the second 2d curve.

        Parameters
        ----------
        the2dCurve2: Geom2d_Curve

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Curve_SetSecondCurve2d(self, *args)

    def SetTangentialTolerance(self, *args) -> "void":
        r"""
        Sets the tangential tolerance.

        Parameters
        ----------
        theTangentialTolerance: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Curve_SetTangentialTolerance(self, *args)

    def SetTolerance(self, *args) -> "void":
        r"""
        Sets the tolerance for the curve.

        Parameters
        ----------
        theTolerance: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Curve_SetTolerance(self, *args)

    def TangentialTolerance(self, *args) -> "Standard_Real":
        r"""
        Returns the tangential tolerance.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_Curve_TangentialTolerance(self, *args)

    def Tolerance(self, *args) -> "Standard_Real":
        r"""
        Returns the tolerance.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_Curve_Tolerance(self, *args)

    def Type(self, *args) -> "GeomAbs_CurveType":
        r"""
        Returns the type of the 3d curve.

        Returns
        -------
        GeomAbs_CurveType

        """
        return _IntTools.IntTools_Curve_Type(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_Curve

# Register IntTools_Curve in _IntTools:
_IntTools.IntTools_Curve_swigregister(IntTools_Curve)

class IntTools_CurveRangeLocalizeData(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"""
        No available documentation.

        Parameters
        ----------
        theNbSample: int
        theMinRange: float

        Returns
        -------
        None

        """
        _IntTools.IntTools_CurveRangeLocalizeData_swiginit(self, _IntTools.new_IntTools_CurveRangeLocalizeData(*args))

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

        Parameters
        ----------
        theRange: IntTools_CurveRangeSample
        theBox: Bnd_Box

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CurveRangeLocalizeData_AddBox(self, *args)

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

        Parameters
        ----------
        theRange: IntTools_CurveRangeSample

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CurveRangeLocalizeData_AddOutRange(self, *args)

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

        Parameters
        ----------
        theRange: IntTools_CurveRangeSample
        theBox: Bnd_Box

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_CurveRangeLocalizeData_FindBox(self, *args)

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

        Returns
        -------
        float

        """
        return _IntTools.IntTools_CurveRangeLocalizeData_GetMinRange(self, *args)

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

        Returns
        -------
        int

        """
        return _IntTools.IntTools_CurveRangeLocalizeData_GetNbSample(self, *args)

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

        Parameters
        ----------
        theRange: IntTools_CurveRangeSample

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_CurveRangeLocalizeData_IsRangeOut(self, *args)

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

        Parameters
        ----------
        theList: IntTools_ListOfCurveRangeSample

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CurveRangeLocalizeData_ListRangeOut(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_CurveRangeLocalizeData

# Register IntTools_CurveRangeLocalizeData in _IntTools:
_IntTools.IntTools_CurveRangeLocalizeData_swigregister(IntTools_CurveRangeLocalizeData)

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

    @staticmethod
    def HashCode(*args) -> "Standard_Integer":
        r"""
        Computes a hash code for the given key, in the range [1, theupperbound] @param thekey the key which hash code is to be computed @param theupperbound the upper bound of the range a computing hash code must be within returns a computed hash code, in the range [1, theupperbound].

        Parameters
        ----------
        theKey: IntTools_CurveRangeSample
        theUpperBound: int

        Returns
        -------
        int

        """
        return _IntTools.IntTools_CurveRangeSampleMapHasher_HashCode(*args)

    @staticmethod
    def IsEqual(*args) -> "Standard_Boolean":
        r"""
        Returns true when the two keys are the same. two same keys must have the same hashcode, the contrary is not necessary.

        Parameters
        ----------
        S1: IntTools_CurveRangeSample
        S2: IntTools_CurveRangeSample

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_CurveRangeSampleMapHasher_IsEqual(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _IntTools.IntTools_CurveRangeSampleMapHasher_swiginit(self, _IntTools.new_IntTools_CurveRangeSampleMapHasher())
    __swig_destroy__ = _IntTools.delete_IntTools_CurveRangeSampleMapHasher

# Register IntTools_CurveRangeSampleMapHasher in _IntTools:
_IntTools.IntTools_CurveRangeSampleMapHasher_swigregister(IntTools_CurveRangeSampleMapHasher)

def IntTools_CurveRangeSampleMapHasher_HashCode(*args) -> "Standard_Integer":
    r"""
    Computes a hash code for the given key, in the range [1, theupperbound] @param thekey the key which hash code is to be computed @param theupperbound the upper bound of the range a computing hash code must be within returns a computed hash code, in the range [1, theupperbound].

    Parameters
    ----------
    theKey: IntTools_CurveRangeSample
    theUpperBound: int

    Returns
    -------
    int

    """
    return _IntTools.IntTools_CurveRangeSampleMapHasher_HashCode(*args)

def IntTools_CurveRangeSampleMapHasher_IsEqual(*args) -> "Standard_Boolean":
    r"""
    Returns true when the two keys are the same. two same keys must have the same hashcode, the contrary is not necessary.

    Parameters
    ----------
    S1: IntTools_CurveRangeSample
    S2: IntTools_CurveRangeSample

    Returns
    -------
    bool

    """
    return _IntTools.IntTools_CurveRangeSampleMapHasher_IsEqual(*args)

class IntTools_EdgeEdge(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"""
        Empty contructor.

        Returns
        -------
        None
        Contructor.

        Parameters
        ----------
        theEdge1: TopoDS_Edge
        theEdge2: TopoDS_Edge

        Returns
        -------
        None
        Contructor.

        Parameters
        ----------
        theEdge1: TopoDS_Edge
        aT11: float
        aT12: float
        theEdge2: TopoDS_Edge
        aT21: float
        aT22: float

        Returns
        -------
        None

        """
        _IntTools.IntTools_EdgeEdge_swiginit(self, _IntTools.new_IntTools_EdgeEdge(*args))

    def CommonParts(self, *args) -> "IntTools_SequenceOfCommonPrts const &":
        r"""
        Returns common parts.

        Returns
        -------
        IntTools_SequenceOfCommonPrts

        """
        return _IntTools.IntTools_EdgeEdge_CommonParts(self, *args)

    def FuzzyValue(self, *args) -> "Standard_Real":
        r"""
        Returns fuzzy value.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_EdgeEdge_FuzzyValue(self, *args)

    def IsCoincidenceCheckedQuickly(self, *args) -> "Standard_Boolean":
        r"""
        Returns the flag myquickcoincidencecheck.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_EdgeEdge_IsCoincidenceCheckedQuickly(self, *args)

    def IsDone(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if common part(s) is(are) found.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_EdgeEdge_IsDone(self, *args)

    def Perform(self, *args) -> "void":
        r"""
        Performs the intersection between edges.

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeEdge_Perform(self, *args)

    def SetEdge1(self, *args) -> "void":
        r"""
        Sets the first edge.

        Parameters
        ----------
        theEdge: TopoDS_Edge

        Returns
        -------
        None
        Sets the first edge and its range.

        Parameters
        ----------
        theEdge: TopoDS_Edge
        aT1: float
        aT2: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeEdge_SetEdge1(self, *args)

    def SetEdge2(self, *args) -> "void":
        r"""
        Sets the second edge.

        Parameters
        ----------
        theEdge: TopoDS_Edge

        Returns
        -------
        None
        Sets the first edge and its range.

        Parameters
        ----------
        theEdge: TopoDS_Edge
        aT1: float
        aT2: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeEdge_SetEdge2(self, *args)

    def SetFuzzyValue(self, *args) -> "void":
        r"""
        Sets the fuzzy value.

        Parameters
        ----------
        theFuzz: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeEdge_SetFuzzyValue(self, *args)

    def SetRange1(self, *args) -> "void":
        r"""
        Sets the range for the first edge.

        Parameters
        ----------
        theRange1: IntTools_Range

        Returns
        -------
        None
        Sets the range for the first edge.

        Parameters
        ----------
        aT1: float
        aT2: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeEdge_SetRange1(self, *args)

    def SetRange2(self, *args) -> "void":
        r"""
        Sets the range for the second edge.

        Parameters
        ----------
        theRange: IntTools_Range

        Returns
        -------
        None
        Sets the range for the second edge.

        Parameters
        ----------
        aT1: float
        aT2: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeEdge_SetRange2(self, *args)

    def UseQuickCoincidenceCheck(self, *args) -> "void":
        r"""
        Sets the flag myquickcoincidencecheck.

        Parameters
        ----------
        bFlag: bool

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeEdge_UseQuickCoincidenceCheck(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_EdgeEdge

# Register IntTools_EdgeEdge in _IntTools:
_IntTools.IntTools_EdgeEdge_swigregister(IntTools_EdgeEdge)

class IntTools_EdgeFace(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"""
        Empty constructor.

        Returns
        -------
        None

        """
        _IntTools.IntTools_EdgeFace_swiginit(self, _IntTools.new_IntTools_EdgeFace(*args))

    def CommonParts(self, *args) -> "IntTools_SequenceOfCommonPrts const &":
        r"""
        Returns resulting common parts.

        Returns
        -------
        IntTools_SequenceOfCommonPrts

        """
        return _IntTools.IntTools_EdgeFace_CommonParts(self, *args)

    def Context(self, *args) -> "opencascade::handle< IntTools_Context > const &":
        r"""
        Returns the intersection context.

        Returns
        -------
        opencascade::handle<IntTools_Context>

        """
        return _IntTools.IntTools_EdgeFace_Context(self, *args)

    def Edge(self, *args) -> "TopoDS_Edge const":
        r"""
        Returns the edge.

        Returns
        -------
        TopoDS_Edge

        """
        return _IntTools.IntTools_EdgeFace_Edge(self, *args)

    def ErrorStatus(self, *args) -> "Standard_Integer":
        r"""
        Returns the code of completion: 0 - means successful completion; 1 - the process was not started; 2,3 - invalid source data for the algorithm; 4 - projection failed.

        Returns
        -------
        int

        """
        return _IntTools.IntTools_EdgeFace_ErrorStatus(self, *args)

    def Face(self, *args) -> "TopoDS_Face const":
        r"""
        Returns the face.

        Returns
        -------
        TopoDS_Face

        """
        return _IntTools.IntTools_EdgeFace_Face(self, *args)

    def FuzzyValue(self, *args) -> "Standard_Real":
        r"""
        Returns the fuzzy value.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_EdgeFace_FuzzyValue(self, *args)

    def IsCoincidenceCheckedQuickly(self, *args) -> "Standard_Boolean":
        r"""
        Returns the flag myquickcoincidencecheck.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_EdgeFace_IsCoincidenceCheckedQuickly(self, *args)

    def IsDone(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if computation was successful. otherwise returns false.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_EdgeFace_IsDone(self, *args)

    def MinimalDistance(self, *args) -> "Standard_Real":
        r"""
        Returns the minimal distance found between edge and face.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_EdgeFace_MinimalDistance(self, *args)

    def Perform(self, *args) -> "void":
        r"""
        Launches the process.

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeFace_Perform(self, *args)

    def Range(self, *args) -> "IntTools_Range const &":
        r"""
        Returns intersection range of the edge.

        Returns
        -------
        IntTools_Range

        """
        return _IntTools.IntTools_EdgeFace_Range(self, *args)

    def SetContext(self, *args) -> "void":
        r"""
        Sets the intersection context.

        Parameters
        ----------
        theContext: IntTools_Context

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeFace_SetContext(self, *args)

    def SetEdge(self, *args) -> "void":
        r"""
        Sets the edge for intersection.

        Parameters
        ----------
        theEdge: TopoDS_Edge

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeFace_SetEdge(self, *args)

    def SetFace(self, *args) -> "void":
        r"""
        Sets the face for intersection.

        Parameters
        ----------
        theFace: TopoDS_Face

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeFace_SetFace(self, *args)

    def SetFuzzyValue(self, *args) -> "void":
        r"""
        Sets the fuzzy value.

        Parameters
        ----------
        theFuzz: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeFace_SetFuzzyValue(self, *args)

    def SetRange(self, *args) -> "void":
        r"""
        Sets the boundaries for the edge. the algorithm processes edge inside these boundaries.

        Parameters
        ----------
        theRange: IntTools_Range

        Returns
        -------
        None
        Sets the boundaries for the edge. the algorithm processes edge inside these boundaries.

        Parameters
        ----------
        theFirst: float
        theLast: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeFace_SetRange(self, *args)

    def UseQuickCoincidenceCheck(self, *args) -> "void":
        r"""
        Sets the flag for quick coincidence check. it is safe to use the quick check for coincidence only if both of the following conditions are met: - the vertices of edge are lying on the face; - the edge does not intersect the boundaries of the face on the given range.

        Parameters
        ----------
        theFlag: bool

        Returns
        -------
        None

        """
        return _IntTools.IntTools_EdgeFace_UseQuickCoincidenceCheck(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_EdgeFace

# Register IntTools_EdgeFace in _IntTools:
_IntTools.IntTools_EdgeFace_swigregister(IntTools_EdgeFace)

class IntTools_FClass2d(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"""
        Empty constructor.

        Returns
        -------
        None
        Initializes algorithm by the face f and tolerance tol.

        Parameters
        ----------
        F: TopoDS_Face
        Tol: float

        Returns
        -------
        None

        """
        _IntTools.IntTools_FClass2d_swiginit(self, _IntTools.new_IntTools_FClass2d(*args))

    def Destroy(self, *args) -> "void":
        r"""
        Destructor.

        Returns
        -------
        None

        """
        return _IntTools.IntTools_FClass2d_Destroy(self, *args)

    def Init(self, *args) -> "void":
        r"""
        Initializes algorithm by the face f and tolerance tol.

        Parameters
        ----------
        F: TopoDS_Face
        Tol: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_FClass2d_Init(self, *args)

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

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_FClass2d_IsHole(self, *args)

    def Perform(self, *args) -> "TopAbs_State":
        r"""
        Returns state of the 2d point puv. if recadreonperiodic is true (defalut value), for the periodic surface 2d point, adjusted to period, is classified.

        Parameters
        ----------
        Puv: gp_Pnt2d
        RecadreOnPeriodic: bool,optional
        	default value is Standard_True

        Returns
        -------
        TopAbs_State

        """
        return _IntTools.IntTools_FClass2d_Perform(self, *args)

    def PerformInfinitePoint(self, *args) -> "TopAbs_State":
        r"""
        Returns state of infinite 2d point relatively to (0, 0).

        Returns
        -------
        TopAbs_State

        """
        return _IntTools.IntTools_FClass2d_PerformInfinitePoint(self, *args)

    def TestOnRestriction(self, *args) -> "TopAbs_State":
        r"""
        Test a point with +- an offset (tol) and returns on if some points are out an some are in (caution: internal use . see the code for more details).

        Parameters
        ----------
        Puv: gp_Pnt2d
        Tol: float
        RecadreOnPeriodic: bool,optional
        	default value is Standard_True

        Returns
        -------
        TopAbs_State

        """
        return _IntTools.IntTools_FClass2d_TestOnRestriction(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_FClass2d

# Register IntTools_FClass2d in _IntTools:
_IntTools.IntTools_FClass2d_swigregister(IntTools_FClass2d)

class IntTools_FaceFace(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"""
        Empty constructor.

        Returns
        -------
        None

        """
        _IntTools.IntTools_FaceFace_swiginit(self, _IntTools.new_IntTools_FaceFace(*args))

    def Context(self, *args) -> "opencascade::handle< IntTools_Context > const &":
        r"""
        Gets the intersecton context.

        Returns
        -------
        opencascade::handle<IntTools_Context>

        """
        return _IntTools.IntTools_FaceFace_Context(self, *args)

    def Face1(self, *args) -> "TopoDS_Face const":
        r"""
        Returns first of processed faces.

        Returns
        -------
        TopoDS_Face

        """
        return _IntTools.IntTools_FaceFace_Face1(self, *args)

    def Face2(self, *args) -> "TopoDS_Face const":
        r"""
        Returns second of processed faces.

        Returns
        -------
        TopoDS_Face

        """
        return _IntTools.IntTools_FaceFace_Face2(self, *args)

    def FuzzyValue(self, *args) -> "Standard_Real":
        r"""
        Returns fuzzy value.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_FaceFace_FuzzyValue(self, *args)

    def IsDone(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the intersection was successful.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_FaceFace_IsDone(self, *args)

    def Lines(self, *args) -> "IntTools_SequenceOfCurves const &":
        r"""
        Returns sequence of 3d curves as result of intersection.

        Returns
        -------
        IntTools_SequenceOfCurves

        """
        return _IntTools.IntTools_FaceFace_Lines(self, *args)

    def Perform(self, *args) -> "void":
        r"""
        Intersects underliing surfaces of f1 and f2 use sum of tolerance of f1 and f2 as intersection criteria.

        Parameters
        ----------
        F1: TopoDS_Face
        F2: TopoDS_Face

        Returns
        -------
        None

        """
        return _IntTools.IntTools_FaceFace_Perform(self, *args)

    def Points(self, *args) -> "IntTools_SequenceOfPntOn2Faces const &":
        r"""
        Returns sequence of 3d curves as result of intersection.

        Returns
        -------
        IntTools_SequenceOfPntOn2Faces

        """
        return _IntTools.IntTools_FaceFace_Points(self, *args)

    def PrepareLines3D(self, *args) -> "void":
        r"""
        Provides post-processing the result lines. <btosplit> - the flag. in case of <btosplit> is true the closed 3d-curves will be splitted on parts. in case of <btosplit> is false the closed 3d-curves remain untouched.

        Parameters
        ----------
        bToSplit: bool,optional
        	default value is Standard_True

        Returns
        -------
        None

        """
        return _IntTools.IntTools_FaceFace_PrepareLines3D(self, *args)

    def SetContext(self, *args) -> "void":
        r"""
        Sets the intersecton context.

        Parameters
        ----------
        aContext: IntTools_Context

        Returns
        -------
        None

        """
        return _IntTools.IntTools_FaceFace_SetContext(self, *args)

    def SetFuzzyValue(self, *args) -> "void":
        r"""
        Sets the fuzzy value.

        Parameters
        ----------
        theFuzz: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_FaceFace_SetFuzzyValue(self, *args)

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

        Parameters
        ----------
        ListOfPnts: IntSurf_ListOfPntOn2S

        Returns
        -------
        None

        """
        return _IntTools.IntTools_FaceFace_SetList(self, *args)

    def SetParameters(self, *args) -> "void":
        r"""
        Modifier.

        Parameters
        ----------
        ApproxCurves: bool
        ComputeCurveOnS1: bool
        ComputeCurveOnS2: bool
        ApproximationTolerance: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_FaceFace_SetParameters(self, *args)

    def TangentFaces(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if faces are tangent.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_FaceFace_TangentFaces(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_FaceFace

# Register IntTools_FaceFace in _IntTools:
_IntTools.IntTools_FaceFace_swigregister(IntTools_FaceFace)

class IntTools_MarkedRangeSet(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"""
        Empty constructor.

        Returns
        -------
        None
        Build set of ranges which consists of one range with boundary values thefirstboundary and thelastboundary.

        Parameters
        ----------
        theFirstBoundary: float
        theLastBoundary: float
        theInitFlag: int

        Returns
        -------
        None
        Build set of ranges based on the array of progressive sorted values //! warning: the constructor do not check if the values of array are not sorted it should be checked before function invocation.

        Parameters
        ----------
        theSortedArray: IntTools_CArray1OfReal
        theInitFlag: int

        Returns
        -------
        None

        """
        _IntTools.IntTools_MarkedRangeSet_swiginit(self, _IntTools.new_IntTools_MarkedRangeSet(*args))

    def Flag(self, *args) -> "Standard_Integer":
        r"""
        Returns flag of the range with index theindex.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        int

        """
        return _IntTools.IntTools_MarkedRangeSet_Flag(self, *args)

    def GetIndex(self, *args) -> "Standard_Integer":
        r"""
        Returns index of range which contains thevalue. if thevalue do not belong any range returns 0.

        Parameters
        ----------
        theValue: float

        Returns
        -------
        int
        Returns index of range which contains thevalue if thevalue do not belong any range returns 0. if uselower is standard_true then lower boundary of the range can be equal to thevalue, otherwise upper boundary of the range can be equal to thevalue.

        Parameters
        ----------
        theValue: float
        UseLower: bool

        Returns
        -------
        int

        """
        return _IntTools.IntTools_MarkedRangeSet_GetIndex(self, *args)

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

        Parameters
        ----------
        theValue: float

        Returns
        -------
        TColStd_SequenceOfInteger

        """
        return _IntTools.IntTools_MarkedRangeSet_GetIndices(self, *args)

    def InsertRange(self, *args) -> "Standard_Boolean":
        r"""
        Inserts a new range marked with flag theflag it replace the existing ranges or parts of ranges and their flags. returns true if the range is inside the initial boundaries, otherwise or in case of some error returns false.

        Parameters
        ----------
        theFirstBoundary: float
        theLastBoundary: float
        theFlag: int

        Returns
        -------
        bool
        Inserts a new range marked with flag theflag it replace the existing ranges or parts of ranges and their flags. returns true if the range is inside the initial boundaries, otherwise or in case of some error returns false.

        Parameters
        ----------
        theRange: IntTools_Range
        theFlag: int

        Returns
        -------
        bool
        Inserts a new range marked with flag theflag it replace the existing ranges or parts of ranges and their flags. the index theindex is a position where the range will be inserted. returns true if the range is inside the initial boundaries, otherwise or in case of some error returns false.

        Parameters
        ----------
        theFirstBoundary: float
        theLastBoundary: float
        theFlag: int
        theIndex: int

        Returns
        -------
        bool
        Inserts a new range marked with flag theflag it replace the existing ranges or parts of ranges and their flags. the index theindex is a position where the range will be inserted. returns true if the range is inside the initial boundaries, otherwise or in case of some error returns false.

        Parameters
        ----------
        theRange: IntTools_Range
        theFlag: int
        theIndex: int

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_MarkedRangeSet_InsertRange(self, *args)

    def Length(self, *args) -> "Standard_Integer":
        r"""
        Returns number of ranges.

        Returns
        -------
        int

        """
        return _IntTools.IntTools_MarkedRangeSet_Length(self, *args)

    def Range(self, *args) -> "IntTools_Range":
        r"""
        Returns the range with index theindex. the index can be from 1 to length().

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        IntTools_Range

        """
        return _IntTools.IntTools_MarkedRangeSet_Range(self, *args)

    def SetBoundaries(self, *args) -> "void":
        r"""
        Build set of ranges which consists of one range with boundary values thefirstboundary and thelastboundary.

        Parameters
        ----------
        theFirstBoundary: float
        theLastBoundary: float
        theInitFlag: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_MarkedRangeSet_SetBoundaries(self, *args)

    def SetFlag(self, *args) -> "void":
        r"""
        Set flag theflag for range with index theindex.

        Parameters
        ----------
        theIndex: int
        theFlag: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_MarkedRangeSet_SetFlag(self, *args)

    def SetRanges(self, *args) -> "void":
        r"""
        Build set of ranges based on the array of progressive sorted values //! warning: the function do not check if the values of array are not sorted it should be checked before function invocation.

        Parameters
        ----------
        theSortedArray: IntTools_CArray1OfReal
        theInitFlag: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_MarkedRangeSet_SetRanges(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_MarkedRangeSet

# Register IntTools_MarkedRangeSet in _IntTools:
_IntTools.IntTools_MarkedRangeSet_swigregister(IntTools_MarkedRangeSet)

class IntTools_PntOn2Faces(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"""
        Empty constructor.

        Returns
        -------
        None
        Initializes me by two points ap1 and ap2.

        Parameters
        ----------
        aP1: IntTools_PntOnFace
        aP2: IntTools_PntOnFace

        Returns
        -------
        None

        """
        _IntTools.IntTools_PntOn2Faces_swiginit(self, _IntTools.new_IntTools_PntOn2Faces(*args))

    def IsValid(self, *args) -> "Standard_Boolean":
        r"""
        Selector.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_PntOn2Faces_IsValid(self, *args)

    def P1(self, *args) -> "IntTools_PntOnFace const &":
        r"""
        Selector.

        Returns
        -------
        IntTools_PntOnFace

        """
        return _IntTools.IntTools_PntOn2Faces_P1(self, *args)

    def P2(self, *args) -> "IntTools_PntOnFace const &":
        r"""
        Selector.

        Returns
        -------
        IntTools_PntOnFace

        """
        return _IntTools.IntTools_PntOn2Faces_P2(self, *args)

    def SetP1(self, *args) -> "void":
        r"""
        Modifier.

        Parameters
        ----------
        aP1: IntTools_PntOnFace

        Returns
        -------
        None

        """
        return _IntTools.IntTools_PntOn2Faces_SetP1(self, *args)

    def SetP2(self, *args) -> "void":
        r"""
        Modifier.

        Parameters
        ----------
        aP2: IntTools_PntOnFace

        Returns
        -------
        None

        """
        return _IntTools.IntTools_PntOn2Faces_SetP2(self, *args)

    def SetValid(self, *args) -> "void":
        r"""
        Modifier.

        Parameters
        ----------
        bF: bool

        Returns
        -------
        None

        """
        return _IntTools.IntTools_PntOn2Faces_SetValid(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_PntOn2Faces

# Register IntTools_PntOn2Faces in _IntTools:
_IntTools.IntTools_PntOn2Faces_swigregister(IntTools_PntOn2Faces)

class IntTools_PntOnFace(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"""
        Empty constructor.

        Returns
        -------
        None

        """
        _IntTools.IntTools_PntOnFace_swiginit(self, _IntTools.new_IntTools_PntOnFace(*args))

    def Face(self, *args) -> "TopoDS_Face const":
        r"""
        Selector.

        Returns
        -------
        TopoDS_Face

        """
        return _IntTools.IntTools_PntOnFace_Face(self, *args)

    def Init(self, *args) -> "void":
        r"""
        Initializes me by aface, a 3d point and it's uv parameters on face.

        Parameters
        ----------
        aF: TopoDS_Face
        aP: gp_Pnt
        U: float
        V: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_PntOnFace_Init(self, *args)

    def Parameters(self, *args) -> "void":
        r"""
        Selector.

        Parameters
        ----------

        Returns
        -------
        U: float
        V: float

        """
        return _IntTools.IntTools_PntOnFace_Parameters(self, *args)

    def Pnt(self, *args) -> "gp_Pnt const":
        r"""
        Selector.

        Returns
        -------
        gp_Pnt

        """
        return _IntTools.IntTools_PntOnFace_Pnt(self, *args)

    def SetFace(self, *args) -> "void":
        r"""
        Modifier.

        Parameters
        ----------
        aF: TopoDS_Face

        Returns
        -------
        None

        """
        return _IntTools.IntTools_PntOnFace_SetFace(self, *args)

    def SetParameters(self, *args) -> "void":
        r"""
        Modifier.

        Parameters
        ----------
        U: float
        V: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_PntOnFace_SetParameters(self, *args)

    def SetPnt(self, *args) -> "void":
        r"""
        Modifier.

        Parameters
        ----------
        aP: gp_Pnt

        Returns
        -------
        None

        """
        return _IntTools.IntTools_PntOnFace_SetPnt(self, *args)

    def SetValid(self, *args) -> "void":
        r"""
        Modifier.

        Parameters
        ----------
        bF: bool

        Returns
        -------
        None

        """
        return _IntTools.IntTools_PntOnFace_SetValid(self, *args)

    def Valid(self, *args) -> "Standard_Boolean":
        r"""
        Selector.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_PntOnFace_Valid(self, *args)

    __repr__ = _dumps_object

    @methodnotwrapped
    def IsValid(self):
    	pass

    __swig_destroy__ = _IntTools.delete_IntTools_PntOnFace

# Register IntTools_PntOnFace in _IntTools:
_IntTools.IntTools_PntOnFace_swigregister(IntTools_PntOnFace)

class IntTools_Range(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"""
        Empty constructor.

        Returns
        -------
        None
        Initialize me by range boundaries.

        Parameters
        ----------
        aFirst: float
        aLast: float

        Returns
        -------
        None

        """
        _IntTools.IntTools_Range_swiginit(self, _IntTools.new_IntTools_Range(*args))

    def First(self, *args) -> "Standard_Real":
        r"""
        Selector.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_Range_First(self, *args)

    def Last(self, *args) -> "Standard_Real":
        r"""
        Selector.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_Range_Last(self, *args)

    def Range(self, *args) -> "void":
        r"""
        Selector.

        Parameters
        ----------

        Returns
        -------
        aFirst: float
        aLast: float

        """
        return _IntTools.IntTools_Range_Range(self, *args)

    def SetFirst(self, *args) -> "void":
        r"""
        Modifier.

        Parameters
        ----------
        aFirst: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Range_SetFirst(self, *args)

    def SetLast(self, *args) -> "void":
        r"""
        Modifier.

        Parameters
        ----------
        aLast: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Range_SetLast(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_Range

# Register IntTools_Range in _IntTools:
_IntTools.IntTools_Range_swigregister(IntTools_Range)

class IntTools_Root(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"""
        Empty constructor.

        Returns
        -------
        None
        Initializes my by range of parameters and type of root.

        Parameters
        ----------
        aRoot: float
        aType: int

        Returns
        -------
        None

        """
        _IntTools.IntTools_Root_swiginit(self, _IntTools.new_IntTools_Root(*args))

    def Interval(self, *args) -> "void":
        r"""
        Returns the values of interval from which the root was found [t1,t2] and the corresponding values of the function on the bounds f(t1), f(t2).

        Parameters
        ----------

        Returns
        -------
        t1: float
        t2: float
        f1: float
        f2: float

        """
        return _IntTools.IntTools_Root_Interval(self, *args)

    def IsValid(self, *args) -> "Standard_Boolean":
        r"""
        Returns the validity flag for the root, true if mystatebefore==topabs_out && mystateafter==topabs_in or mystatebefore==topabs_out && mystateafter==topabs_on or mystatebefore==topabs_on && mystateafter==topabs_out or mystatebefore==topabs_in && mystateafter==topabs_out . for other cases it returns false.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Root_IsValid(self, *args)

    def LayerHeight(self, *args) -> "Standard_Real":
        r"""
        Not used in edge/edge algorithm.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_Root_LayerHeight(self, *args)

    def Root(self, *args) -> "Standard_Real":
        r"""
        Returns the root value.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_Root_Root(self, *args)

    def SetInterval(self, *args) -> "void":
        r"""
        Sets the interval from which the root was found [t1,t2] and the corresponding values of the function on the bounds f(t1), f(t2).

        Parameters
        ----------
        t1: float
        t2: float
        f1: float
        f2: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Root_SetInterval(self, *args)

    def SetLayerHeight(self, *args) -> "void":
        r"""
        Not used in edge/edge algorithm.

        Parameters
        ----------
        aHeight: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Root_SetLayerHeight(self, *args)

    def SetRoot(self, *args) -> "void":
        r"""
        Sets the root's value.

        Parameters
        ----------
        aRoot: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Root_SetRoot(self, *args)

    def SetStateAfter(self, *args) -> "void":
        r"""
        Set the value of the state after the root (at t=root-dt).

        Parameters
        ----------
        aState: TopAbs_State

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Root_SetStateAfter(self, *args)

    def SetStateBefore(self, *args) -> "void":
        r"""
        Set the value of the state before the root (at t=root-dt).

        Parameters
        ----------
        aState: TopAbs_State

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Root_SetStateBefore(self, *args)

    def SetType(self, *args) -> "void":
        r"""
        Sets the root's type.

        Parameters
        ----------
        aType: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Root_SetType(self, *args)

    def StateAfter(self, *args) -> "TopAbs_State":
        r"""
        Returns the state after the root.

        Returns
        -------
        TopAbs_State

        """
        return _IntTools.IntTools_Root_StateAfter(self, *args)

    def StateBefore(self, *args) -> "TopAbs_State":
        r"""
        Returns the state before the root.

        Returns
        -------
        TopAbs_State

        """
        return _IntTools.IntTools_Root_StateBefore(self, *args)

    def Type(self, *args) -> "Standard_Integer":
        r"""
        Returns the type of the root =0 - simple (was found by bisection method); =2 - smart when f1=0, f2!=0 or vice versa (was found by fibbonacci method); =1 - pure (pure zero for all t [t1,t2] );.

        Returns
        -------
        int

        """
        return _IntTools.IntTools_Root_Type(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_Root

# Register IntTools_Root in _IntTools:
_IntTools.IntTools_Root_swigregister(IntTools_Root)

class IntTools_ShrunkRange(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"""
        No available documentation.

        Returns
        -------
        None

        """
        _IntTools.IntTools_ShrunkRange_swiginit(self, _IntTools.new_IntTools_ShrunkRange(*args))

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

        Returns
        -------
        Bnd_Box

        """
        return _IntTools.IntTools_ShrunkRange_BndBox(self, *args)

    def Context(self, *args) -> "opencascade::handle< IntTools_Context > const &":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<IntTools_Context>

        """
        return _IntTools.IntTools_ShrunkRange_Context(self, *args)

    def Edge(self, *args) -> "TopoDS_Edge const":
        r"""
        No available documentation.

        Returns
        -------
        TopoDS_Edge

        """
        return _IntTools.IntTools_ShrunkRange_Edge(self, *args)

    def IsDone(self, *args) -> "Standard_Boolean":
        r"""
        Returns true in case the shrunk range is computed.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_ShrunkRange_IsDone(self, *args)

    def IsSplittable(self, *args) -> "Standard_Boolean":
        r"""
        Returns false in case the shrunk range is too short and the edge cannot be split, otherwise returns true.

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_ShrunkRange_IsSplittable(self, *args)

    def Length(self, *args) -> "Standard_Real":
        r"""
        Returns the length of the edge if computed.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_ShrunkRange_Length(self, *args)

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

        Returns
        -------
        None

        """
        return _IntTools.IntTools_ShrunkRange_Perform(self, *args)

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

        Parameters
        ----------
        aCtx: IntTools_Context

        Returns
        -------
        None

        """
        return _IntTools.IntTools_ShrunkRange_SetContext(self, *args)

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

        Parameters
        ----------
        aE: TopoDS_Edge
        aT1: float
        aT2: float
        aV1: TopoDS_Vertex
        aV2: TopoDS_Vertex

        Returns
        -------
        None

        """
        return _IntTools.IntTools_ShrunkRange_SetData(self, *args)

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

        Parameters
        ----------
        aT1: float
        aT2: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_ShrunkRange_SetShrunkRange(self, *args)

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

        Parameters
        ----------

        Returns
        -------
        aT1: float
        aT2: float

        """
        return _IntTools.IntTools_ShrunkRange_ShrunkRange(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_ShrunkRange

# Register IntTools_ShrunkRange in _IntTools:
_IntTools.IntTools_ShrunkRange_swigregister(IntTools_ShrunkRange)

class IntTools_SurfaceRangeLocalizeData(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"""
        No available documentation.

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        theNbSampleU: int
        theNbSampleV: int
        theMinRangeU: float
        theMinRangeV: float

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        Other: IntTools_SurfaceRangeLocalizeData

        Returns
        -------
        None

        """
        _IntTools.IntTools_SurfaceRangeLocalizeData_swiginit(self, _IntTools.new_IntTools_SurfaceRangeLocalizeData(*args))

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

        Parameters
        ----------
        theRange: IntTools_SurfaceRangeSample
        theBox: Bnd_Box

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_AddBox(self, *args)

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

        Parameters
        ----------
        theRange: IntTools_SurfaceRangeSample

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_AddOutRange(self, *args)

    def Assign(self, *args) -> "IntTools_SurfaceRangeLocalizeData &":
        r"""
        No available documentation.

        Parameters
        ----------
        Other: IntTools_SurfaceRangeLocalizeData

        Returns
        -------
        IntTools_SurfaceRangeLocalizeData

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_Assign(self, *args)

    def ClearGrid(self, *args) -> "void":
        r"""
        Clears the grid of points.

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_ClearGrid(self, *args)

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

        Parameters
        ----------
        theRange: IntTools_SurfaceRangeSample
        theBox: Bnd_Box

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_FindBox(self, *args)

    def GetGridDeflection(self, *args) -> "Standard_Real":
        r"""
        Query the grid deflection.

        Returns
        -------
        float

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetGridDeflection(self, *args)

    def GetGridPoint(self, *args) -> "gp_Pnt const":
        r"""
        Set the grid point.

        Parameters
        ----------
        theUIndex: int
        theVIndex: int

        Returns
        -------
        gp_Pnt

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetGridPoint(self, *args)

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

        Returns
        -------
        float

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetMinRangeU(self, *args)

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

        Returns
        -------
        float

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetMinRangeV(self, *args)

    def GetNBUPointsInFrame(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of grid points on u direction in frame.

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetNBUPointsInFrame(self, *args)

    def GetNBVPointsInFrame(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of grid points on v direction in frame.

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetNBVPointsInFrame(self, *args)

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

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetNbSampleU(self, *args)

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

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetNbSampleV(self, *args)

    def GetPointInFrame(self, *args) -> "gp_Pnt const":
        r"""
        Returns the grid point in frame.

        Parameters
        ----------
        theUIndex: int
        theVIndex: int

        Returns
        -------
        gp_Pnt

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetPointInFrame(self, *args)

    def GetRangeUGrid(self, *args) -> "Standard_Integer":
        r"""
        Query the range u of the grid of points.

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetRangeUGrid(self, *args)

    def GetRangeVGrid(self, *args) -> "Standard_Integer":
        r"""
        Query the range v of the grid of points.

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetRangeVGrid(self, *args)

    def GetUParam(self, *args) -> "Standard_Real":
        r"""
        Query the u parameter of the grid points at that index.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        float

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetUParam(self, *args)

    def GetUParamInFrame(self, *args) -> "Standard_Real":
        r"""
        Query the u parameter of the grid points at that index in frame.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        float

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetUParamInFrame(self, *args)

    def GetVParam(self, *args) -> "Standard_Real":
        r"""
        Query the v parameter of the grid points at that index.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        float

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetVParam(self, *args)

    def GetVParamInFrame(self, *args) -> "Standard_Real":
        r"""
        Query the v parameter of the grid points at that index in frame.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        float

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_GetVParamInFrame(self, *args)

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

        Parameters
        ----------
        theRange: IntTools_SurfaceRangeSample

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_IsRangeOut(self, *args)

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

        Parameters
        ----------
        theList: IntTools_ListOfSurfaceRangeSample

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_ListRangeOut(self, *args)

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

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_RemoveRangeOutAll(self, *args)

    def SetFrame(self, *args) -> "void":
        r"""
        Sets the frame area. used to work with grid points.

        Parameters
        ----------
        theUMin: float
        theUMax: float
        theVMin: float
        theVMax: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_SetFrame(self, *args)

    def SetGridDeflection(self, *args) -> "void":
        r"""
        Set the grid deflection.

        Parameters
        ----------
        theDeflection: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_SetGridDeflection(self, *args)

    def SetGridPoint(self, *args) -> "void":
        r"""
        Set the grid point.

        Parameters
        ----------
        theUIndex: int
        theVIndex: int
        thePoint: gp_Pnt

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_SetGridPoint(self, *args)

    def SetRangeUGrid(self, *args) -> "void":
        r"""
        Set the range u of the grid of points.

        Parameters
        ----------
        theNbUGrid: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_SetRangeUGrid(self, *args)

    def SetRangeVGrid(self, *args) -> "void":
        r"""
        Set the range v of the grid of points.

        Parameters
        ----------
        theNbVGrid: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_SetRangeVGrid(self, *args)

    def SetUParam(self, *args) -> "void":
        r"""
        Set the u parameter of the grid points at that index.

        Parameters
        ----------
        theIndex: int
        theUParam: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_SetUParam(self, *args)

    def SetVParam(self, *args) -> "void":
        r"""
        Set the v parameter of the grid points at that index.

        Parameters
        ----------
        theIndex: int
        theVParam: float

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeLocalizeData_SetVParam(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_SurfaceRangeLocalizeData

# Register IntTools_SurfaceRangeLocalizeData in _IntTools:
_IntTools.IntTools_SurfaceRangeLocalizeData_swigregister(IntTools_SurfaceRangeLocalizeData)

class IntTools_SurfaceRangeSample(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"""
        No available documentation.

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        theIndexU: int
        theDepthU: int
        theIndexV: int
        theDepthV: int

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        theRangeU: IntTools_CurveRangeSample
        theRangeV: IntTools_CurveRangeSample

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        Other: IntTools_SurfaceRangeSample

        Returns
        -------
        None

        """
        _IntTools.IntTools_SurfaceRangeSample_swiginit(self, _IntTools.new_IntTools_SurfaceRangeSample(*args))

    def Assign(self, *args) -> "IntTools_SurfaceRangeSample &":
        r"""
        No available documentation.

        Parameters
        ----------
        Other: IntTools_SurfaceRangeSample

        Returns
        -------
        IntTools_SurfaceRangeSample

        """
        return _IntTools.IntTools_SurfaceRangeSample_Assign(self, *args)

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

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetDepthU(self, *args)

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

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetDepthV(self, *args)

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

        Parameters
        ----------

        Returns
        -------
        theDepthU: int
        theDepthV: int

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetDepths(self, *args)

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

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetIndexU(self, *args)

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

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetIndexV(self, *args)

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

        Parameters
        ----------

        Returns
        -------
        theIndexU: int
        theIndexV: int

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetIndexes(self, *args)

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

        Parameters
        ----------
        theNbSampleU: int

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetRangeIndexUDeeper(self, *args)

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

        Parameters
        ----------
        theNbSampleV: int

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetRangeIndexVDeeper(self, *args)

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

        Parameters
        ----------
        theFirstU: float
        theLastU: float
        theNbSampleU: int

        Returns
        -------
        IntTools_Range

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetRangeU(self, *args)

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

        Parameters
        ----------
        theFirstV: float
        theLastV: float
        theNbSampleV: int

        Returns
        -------
        IntTools_Range

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetRangeV(self, *args)

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

        Parameters
        ----------
        theRangeU: IntTools_CurveRangeSample
        theRangeV: IntTools_CurveRangeSample

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetRanges(self, *args)

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

        Returns
        -------
        IntTools_CurveRangeSample

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetSampleRangeU(self, *args)

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

        Returns
        -------
        IntTools_CurveRangeSample

        """
        return _IntTools.IntTools_SurfaceRangeSample_GetSampleRangeV(self, *args)

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

        Parameters
        ----------
        Other: IntTools_SurfaceRangeSample

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_SurfaceRangeSample_IsEqual(self, *args)

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

        Parameters
        ----------
        theDepthU: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeSample_SetDepthU(self, *args)

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

        Parameters
        ----------
        theDepthV: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeSample_SetDepthV(self, *args)

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

        Parameters
        ----------
        theIndexU: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeSample_SetIndexU(self, *args)

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

        Parameters
        ----------
        theIndexV: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeSample_SetIndexV(self, *args)

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

        Parameters
        ----------
        theIndexU: int
        theIndexV: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeSample_SetIndexes(self, *args)

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

        Parameters
        ----------
        theRangeU: IntTools_CurveRangeSample
        theRangeV: IntTools_CurveRangeSample

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeSample_SetRanges(self, *args)

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

        Parameters
        ----------
        theRangeSampleU: IntTools_CurveRangeSample

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeSample_SetSampleRangeU(self, *args)

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

        Parameters
        ----------
        theRangeSampleV: IntTools_CurveRangeSample

        Returns
        -------
        None

        """
        return _IntTools.IntTools_SurfaceRangeSample_SetSampleRangeV(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_SurfaceRangeSample

# Register IntTools_SurfaceRangeSample in _IntTools:
_IntTools.IntTools_SurfaceRangeSample_swigregister(IntTools_SurfaceRangeSample)

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

    @staticmethod
    def HashCode(*args) -> "Standard_Integer":
        r"""
        Computes a hash code for the given key, in the range [1, theupperbound] @param thekey the key which hash code is to be computed @param theupperbound the upper bound of the range a computing hash code must be within returns a computed hash code, in the range [1, theupperbound].

        Parameters
        ----------
        theKey: IntTools_SurfaceRangeSample
        theUpperBound: int

        Returns
        -------
        int

        """
        return _IntTools.IntTools_SurfaceRangeSampleMapHasher_HashCode(*args)

    @staticmethod
    def IsEqual(*args) -> "Standard_Boolean":
        r"""
        Returns true when the two keys are the same. two same keys must have the same hashcode, the contrary is not necessary.

        Parameters
        ----------
        S1: IntTools_SurfaceRangeSample
        S2: IntTools_SurfaceRangeSample

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_SurfaceRangeSampleMapHasher_IsEqual(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _IntTools.IntTools_SurfaceRangeSampleMapHasher_swiginit(self, _IntTools.new_IntTools_SurfaceRangeSampleMapHasher())
    __swig_destroy__ = _IntTools.delete_IntTools_SurfaceRangeSampleMapHasher

# Register IntTools_SurfaceRangeSampleMapHasher in _IntTools:
_IntTools.IntTools_SurfaceRangeSampleMapHasher_swigregister(IntTools_SurfaceRangeSampleMapHasher)

def IntTools_SurfaceRangeSampleMapHasher_HashCode(*args) -> "Standard_Integer":
    r"""
    Computes a hash code for the given key, in the range [1, theupperbound] @param thekey the key which hash code is to be computed @param theupperbound the upper bound of the range a computing hash code must be within returns a computed hash code, in the range [1, theupperbound].

    Parameters
    ----------
    theKey: IntTools_SurfaceRangeSample
    theUpperBound: int

    Returns
    -------
    int

    """
    return _IntTools.IntTools_SurfaceRangeSampleMapHasher_HashCode(*args)

def IntTools_SurfaceRangeSampleMapHasher_IsEqual(*args) -> "Standard_Boolean":
    r"""
    Returns true when the two keys are the same. two same keys must have the same hashcode, the contrary is not necessary.

    Parameters
    ----------
    S1: IntTools_SurfaceRangeSample
    S2: IntTools_SurfaceRangeSample

    Returns
    -------
    bool

    """
    return _IntTools.IntTools_SurfaceRangeSampleMapHasher_IsEqual(*args)

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

    @staticmethod
    def CheckCurve(*args) -> "Standard_Boolean":
        r"""
        Checks if the curve is not covered by the default tolerance (confusion). builds bounding box for the curve and stores it into <thebox>.

        Parameters
        ----------
        theCurve: IntTools_Curve
        theBox: Bnd_Box

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Tools_CheckCurve(*args)

    @staticmethod
    def ClassifyPointByFace(*args) -> "TopAbs_State":
        r"""
        No available documentation.

        Parameters
        ----------
        aF: TopoDS_Face
        P: gp_Pnt2d

        Returns
        -------
        TopAbs_State

        """
        return _IntTools.IntTools_Tools_ClassifyPointByFace(*args)

    @staticmethod
    def ComputeIntRange(*args) -> "Standard_Real":
        r"""
        Computes the correct intersection range for line/line, line/plane and plane/plane intersections.

        Parameters
        ----------
        theTol1: float
        theTol2: float
        theAngle: float

        Returns
        -------
        float

        """
        return _IntTools.IntTools_Tools_ComputeIntRange(*args)

    @staticmethod
    def ComputeTolerance(*args) -> "Standard_Real &, Standard_Real &":
        r"""
        Computes the max distance between points taken from 3d and 2d curves by the same parameter.

        Parameters
        ----------
        theCurve3D: Geom_Curve
        theCurve2D: Geom2d_Curve
        theSurf: Geom_Surface
        theFirst: float
        theLast: float
        theTolRange: float,optional
        	default value is Precision::PConfusion()

        Returns
        -------
        theMaxDist: float
        theMaxPar: float

        """
        return _IntTools.IntTools_Tools_ComputeTolerance(*args)

    @staticmethod
    def ComputeVV(*args) -> "Standard_Integer":
        r"""
        Computes distance between vertex v1 and vertex v2, if the distance is less than sum of vertex tolerances returns zero, otherwise returns negative value.

        Parameters
        ----------
        V1: TopoDS_Vertex
        V2: TopoDS_Vertex

        Returns
        -------
        int

        """
        return _IntTools.IntTools_Tools_ComputeVV(*args)

    @staticmethod
    def CurveTolerance(*args) -> "Standard_Real":
        r"""
        Returns adaptive tolerance for given atolbase if ac is trimmed curve and basis curve is parabola, otherwise returns value of atolbase.

        Parameters
        ----------
        aC: Geom_Curve
        aTolBase: float

        Returns
        -------
        float

        """
        return _IntTools.IntTools_Tools_CurveTolerance(*args)

    @staticmethod
    def HasInternalEdge(*args) -> "Standard_Boolean":
        r"""
        Returns true if wire aw contains edges with internal orientation.

        Parameters
        ----------
        aW: TopoDS_Wire

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Tools_HasInternalEdge(*args)

    @staticmethod
    def IntermediatePoint(*args) -> "Standard_Real":
        r"""
        Returns some value between afirst and alast.

        Parameters
        ----------
        aFirst: float
        aLast: float

        Returns
        -------
        float

        """
        return _IntTools.IntTools_Tools_IntermediatePoint(*args)

    @staticmethod
    def IsClosed(*args) -> "Standard_Boolean":
        r"""
        Returns true if ac is boundedcurve from geom and the distance between first point of the curve ac and last point is less than 1.e-12.

        Parameters
        ----------
        aC: Geom_Curve

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Tools_IsClosed(*args)

    @staticmethod
    def IsDirsCoinside(*args) -> "Standard_Boolean":
        r"""
        Returns true if d1 and d2 coinside.

        Parameters
        ----------
        D1: gp_Dir
        D2: gp_Dir

        Returns
        -------
        bool
        Returns true if d1 and d2 coinside with given tolerance.

        Parameters
        ----------
        D1: gp_Dir
        D2: gp_Dir
        aTol: float

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Tools_IsDirsCoinside(*args)

    @staticmethod
    def IsInRange(*args) -> "Standard_Boolean":
        r"""
        Checks if the range <ther> interfere with the range <therref>.

        Parameters
        ----------
        theRRef: IntTools_Range
        theR: IntTools_Range
        theTol: float

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Tools_IsInRange(*args)

    @staticmethod
    def IsMiddlePointsEqual(*args) -> "Standard_Boolean":
        r"""
        Gets boundary of parameters of e1 and e2. computes 3d points on each corresponded to average parameters. returns true if distance between computed points is less than sum of edge tolerance, otherwise returns false.

        Parameters
        ----------
        E1: TopoDS_Edge
        E2: TopoDS_Edge

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Tools_IsMiddlePointsEqual(*args)

    @staticmethod
    def IsOnPave(*args) -> "Standard_Boolean":
        r"""
        No available documentation.

        Parameters
        ----------
        theT: float
        theRange: IntTools_Range
        theTol: float

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Tools_IsOnPave(*args)

    @staticmethod
    def IsOnPave1(*args) -> "Standard_Boolean":
        r"""
        No available documentation.

        Parameters
        ----------
        theT: float
        theRange: IntTools_Range
        theTol: float

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Tools_IsOnPave1(*args)

    @staticmethod
    def IsVertex(*args) -> "Standard_Boolean":
        r"""
        Computes square distance between a point on the edge e corresponded to parameter t and vertices of edge e. returns true if this distance is less than square tolerance of vertex, otherwise returns false.

        Parameters
        ----------
        E: TopoDS_Edge
        t: float

        Returns
        -------
        bool
        Returns true if square distance between vertex v and a point on the edge e corresponded to parameter t is less than square tolerance of v.

        Parameters
        ----------
        E: TopoDS_Edge
        V: TopoDS_Vertex
        t: float

        Returns
        -------
        bool
        Returns true if isvertx for middle parameter of fist range and first edge returns true and if isvertex for middle parameter of second range and second range returns true, otherwise returns false.

        Parameters
        ----------
        aCmnPrt: IntTools_CommonPrt

        Returns
        -------
        bool
        Returns true if the distance between point ap and vertex av is less or equal to sum of atolpv and vertex tolerance, otherwise returns false.

        Parameters
        ----------
        aP: gp_Pnt
        aTolPV: float
        aV: TopoDS_Vertex

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_Tools_IsVertex(*args)

    @staticmethod
    def MakeFaceFromWireAndFace(*args) -> "void":
        r"""
        Build a face based on surface of given face af and bounded by wire aw.

        Parameters
        ----------
        aW: TopoDS_Wire
        aF: TopoDS_Face
        aFNew: TopoDS_Face

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Tools_MakeFaceFromWireAndFace(*args)

    @staticmethod
    def RejectLines(*args) -> "void":
        r"""
        Puts curves from asin to asout except those curves that are coincide with first curve from asin.

        Parameters
        ----------
        aSIn: IntTools_SequenceOfCurves
        aSOut: IntTools_SequenceOfCurves

        Returns
        -------
        None

        """
        return _IntTools.IntTools_Tools_RejectLines(*args)

    @staticmethod
    def SegPln(*args) -> "Standard_Real &, Standard_Real &, Standard_Real &, Standard_Real &":
        r"""
        No available documentation.

        Parameters
        ----------
        theLin: gp_Lin
        theTLin1: float
        theTLin2: float
        theTolLin: float
        thePln: gp_Pln
        theTolPln: float
        theP: gp_Pnt

        Returns
        -------
        theT: float
        theTolP: float
        theTmin: float
        theTmax: float

        """
        return _IntTools.IntTools_Tools_SegPln(*args)

    @staticmethod
    def SplitCurve(*args) -> "Standard_Integer":
        r"""
        Split ac by average parameter if ac is closed in 3d. returns positive value if splitting has been done, otherwise returns zero.

        Parameters
        ----------
        aC: IntTools_Curve
        aS: IntTools_SequenceOfCurves

        Returns
        -------
        int

        """
        return _IntTools.IntTools_Tools_SplitCurve(*args)

    @staticmethod
    def VertexParameter(*args) -> "Standard_Real &":
        r"""
        No available documentation.

        Parameters
        ----------
        theCP: IntTools_CommonPrt

        Returns
        -------
        theT: float

        """
        return _IntTools.IntTools_Tools_VertexParameter(*args)

    @staticmethod
    def VertexParameters(*args) -> "Standard_Real &, Standard_Real &":
        r"""
        No available documentation.

        Parameters
        ----------
        theCP: IntTools_CommonPrt

        Returns
        -------
        theT1: float
        theT2: float

        """
        return _IntTools.IntTools_Tools_VertexParameters(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _IntTools.IntTools_Tools_swiginit(self, _IntTools.new_IntTools_Tools())
    __swig_destroy__ = _IntTools.delete_IntTools_Tools

# Register IntTools_Tools in _IntTools:
_IntTools.IntTools_Tools_swigregister(IntTools_Tools)

def IntTools_Tools_CheckCurve(*args) -> "Standard_Boolean":
    r"""
    Checks if the curve is not covered by the default tolerance (confusion). builds bounding box for the curve and stores it into <thebox>.

    Parameters
    ----------
    theCurve: IntTools_Curve
    theBox: Bnd_Box

    Returns
    -------
    bool

    """
    return _IntTools.IntTools_Tools_CheckCurve(*args)

def IntTools_Tools_ClassifyPointByFace(*args) -> "TopAbs_State":
    r"""
    No available documentation.

    Parameters
    ----------
    aF: TopoDS_Face
    P: gp_Pnt2d

    Returns
    -------
    TopAbs_State

    """
    return _IntTools.IntTools_Tools_ClassifyPointByFace(*args)

def IntTools_Tools_ComputeIntRange(*args) -> "Standard_Real":
    r"""
    Computes the correct intersection range for line/line, line/plane and plane/plane intersections.

    Parameters
    ----------
    theTol1: float
    theTol2: float
    theAngle: float

    Returns
    -------
    float

    """
    return _IntTools.IntTools_Tools_ComputeIntRange(*args)

def IntTools_Tools_ComputeTolerance(*args) -> "Standard_Real &, Standard_Real &":
    r"""
    Computes the max distance between points taken from 3d and 2d curves by the same parameter.

    Parameters
    ----------
    theCurve3D: Geom_Curve
    theCurve2D: Geom2d_Curve
    theSurf: Geom_Surface
    theFirst: float
    theLast: float
    theTolRange: float,optional
    	default value is Precision::PConfusion()

    Returns
    -------
    theMaxDist: float
    theMaxPar: float

    """
    return _IntTools.IntTools_Tools_ComputeTolerance(*args)

def IntTools_Tools_ComputeVV(*args) -> "Standard_Integer":
    r"""
    Computes distance between vertex v1 and vertex v2, if the distance is less than sum of vertex tolerances returns zero, otherwise returns negative value.

    Parameters
    ----------
    V1: TopoDS_Vertex
    V2: TopoDS_Vertex

    Returns
    -------
    int

    """
    return _IntTools.IntTools_Tools_ComputeVV(*args)

def IntTools_Tools_CurveTolerance(*args) -> "Standard_Real":
    r"""
    Returns adaptive tolerance for given atolbase if ac is trimmed curve and basis curve is parabola, otherwise returns value of atolbase.

    Parameters
    ----------
    aC: Geom_Curve
    aTolBase: float

    Returns
    -------
    float

    """
    return _IntTools.IntTools_Tools_CurveTolerance(*args)

def IntTools_Tools_HasInternalEdge(*args) -> "Standard_Boolean":
    r"""
    Returns true if wire aw contains edges with internal orientation.

    Parameters
    ----------
    aW: TopoDS_Wire

    Returns
    -------
    bool

    """
    return _IntTools.IntTools_Tools_HasInternalEdge(*args)

def IntTools_Tools_IntermediatePoint(*args) -> "Standard_Real":
    r"""
    Returns some value between afirst and alast.

    Parameters
    ----------
    aFirst: float
    aLast: float

    Returns
    -------
    float

    """
    return _IntTools.IntTools_Tools_IntermediatePoint(*args)

def IntTools_Tools_IsClosed(*args) -> "Standard_Boolean":
    r"""
    Returns true if ac is boundedcurve from geom and the distance between first point of the curve ac and last point is less than 1.e-12.

    Parameters
    ----------
    aC: Geom_Curve

    Returns
    -------
    bool

    """
    return _IntTools.IntTools_Tools_IsClosed(*args)

def IntTools_Tools_IsDirsCoinside(*args) -> "Standard_Boolean":
    r"""
    Returns true if d1 and d2 coinside.

    Parameters
    ----------
    D1: gp_Dir
    D2: gp_Dir

    Returns
    -------
    bool
    Returns true if d1 and d2 coinside with given tolerance.

    Parameters
    ----------
    D1: gp_Dir
    D2: gp_Dir
    aTol: float

    Returns
    -------
    bool

    """
    return _IntTools.IntTools_Tools_IsDirsCoinside(*args)

def IntTools_Tools_IsInRange(*args) -> "Standard_Boolean":
    r"""
    Checks if the range <ther> interfere with the range <therref>.

    Parameters
    ----------
    theRRef: IntTools_Range
    theR: IntTools_Range
    theTol: float

    Returns
    -------
    bool

    """
    return _IntTools.IntTools_Tools_IsInRange(*args)

def IntTools_Tools_IsMiddlePointsEqual(*args) -> "Standard_Boolean":
    r"""
    Gets boundary of parameters of e1 and e2. computes 3d points on each corresponded to average parameters. returns true if distance between computed points is less than sum of edge tolerance, otherwise returns false.

    Parameters
    ----------
    E1: TopoDS_Edge
    E2: TopoDS_Edge

    Returns
    -------
    bool

    """
    return _IntTools.IntTools_Tools_IsMiddlePointsEqual(*args)

def IntTools_Tools_IsOnPave(*args) -> "Standard_Boolean":
    r"""
    No available documentation.

    Parameters
    ----------
    theT: float
    theRange: IntTools_Range
    theTol: float

    Returns
    -------
    bool

    """
    return _IntTools.IntTools_Tools_IsOnPave(*args)

def IntTools_Tools_IsOnPave1(*args) -> "Standard_Boolean":
    r"""
    No available documentation.

    Parameters
    ----------
    theT: float
    theRange: IntTools_Range
    theTol: float

    Returns
    -------
    bool

    """
    return _IntTools.IntTools_Tools_IsOnPave1(*args)

def IntTools_Tools_IsVertex(*args) -> "Standard_Boolean":
    r"""
    Computes square distance between a point on the edge e corresponded to parameter t and vertices of edge e. returns true if this distance is less than square tolerance of vertex, otherwise returns false.

    Parameters
    ----------
    E: TopoDS_Edge
    t: float

    Returns
    -------
    bool
    Returns true if square distance between vertex v and a point on the edge e corresponded to parameter t is less than square tolerance of v.

    Parameters
    ----------
    E: TopoDS_Edge
    V: TopoDS_Vertex
    t: float

    Returns
    -------
    bool
    Returns true if isvertx for middle parameter of fist range and first edge returns true and if isvertex for middle parameter of second range and second range returns true, otherwise returns false.

    Parameters
    ----------
    aCmnPrt: IntTools_CommonPrt

    Returns
    -------
    bool
    Returns true if the distance between point ap and vertex av is less or equal to sum of atolpv and vertex tolerance, otherwise returns false.

    Parameters
    ----------
    aP: gp_Pnt
    aTolPV: float
    aV: TopoDS_Vertex

    Returns
    -------
    bool

    """
    return _IntTools.IntTools_Tools_IsVertex(*args)

def IntTools_Tools_MakeFaceFromWireAndFace(*args) -> "void":
    r"""
    Build a face based on surface of given face af and bounded by wire aw.

    Parameters
    ----------
    aW: TopoDS_Wire
    aF: TopoDS_Face
    aFNew: TopoDS_Face

    Returns
    -------
    None

    """
    return _IntTools.IntTools_Tools_MakeFaceFromWireAndFace(*args)

def IntTools_Tools_RejectLines(*args) -> "void":
    r"""
    Puts curves from asin to asout except those curves that are coincide with first curve from asin.

    Parameters
    ----------
    aSIn: IntTools_SequenceOfCurves
    aSOut: IntTools_SequenceOfCurves

    Returns
    -------
    None

    """
    return _IntTools.IntTools_Tools_RejectLines(*args)

def IntTools_Tools_SegPln(*args) -> "Standard_Real &, Standard_Real &, Standard_Real &, Standard_Real &":
    r"""
    No available documentation.

    Parameters
    ----------
    theLin: gp_Lin
    theTLin1: float
    theTLin2: float
    theTolLin: float
    thePln: gp_Pln
    theTolPln: float
    theP: gp_Pnt

    Returns
    -------
    theT: float
    theTolP: float
    theTmin: float
    theTmax: float

    """
    return _IntTools.IntTools_Tools_SegPln(*args)

def IntTools_Tools_SplitCurve(*args) -> "Standard_Integer":
    r"""
    Split ac by average parameter if ac is closed in 3d. returns positive value if splitting has been done, otherwise returns zero.

    Parameters
    ----------
    aC: IntTools_Curve
    aS: IntTools_SequenceOfCurves

    Returns
    -------
    int

    """
    return _IntTools.IntTools_Tools_SplitCurve(*args)

def IntTools_Tools_VertexParameter(*args) -> "Standard_Real &":
    r"""
    No available documentation.

    Parameters
    ----------
    theCP: IntTools_CommonPrt

    Returns
    -------
    theT: float

    """
    return _IntTools.IntTools_Tools_VertexParameter(*args)

def IntTools_Tools_VertexParameters(*args) -> "Standard_Real &, Standard_Real &":
    r"""
    No available documentation.

    Parameters
    ----------
    theCP: IntTools_CommonPrt

    Returns
    -------
    theT1: float
    theT2: float

    """
    return _IntTools.IntTools_Tools_VertexParameters(*args)

class IntTools_TopolTool(OCC.Core.Adaptor3d.Adaptor3d_TopolTool):
    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"""
        Empty constructor.

        Returns
        -------
        None
        Initializes me by surface.

        Parameters
        ----------
        theSurface: Adaptor3d_HSurface

        Returns
        -------
        None

        """
        _IntTools.IntTools_TopolTool_swiginit(self, _IntTools.new_IntTools_TopolTool(*args))

    def Initialize(self, *args) -> "void":
        r"""
        Redefined empty initializer //! warning: raises the exception notimplemented.

        Returns
        -------
        None
        Initializes me by surface.

        Parameters
        ----------
        theSurface: Adaptor3d_HSurface

        Returns
        -------
        None

        """
        return _IntTools.IntTools_TopolTool_Initialize(self, *args)


    @staticmethod
    def DownCast(t):
      return Handle_IntTools_TopolTool_DownCast(t)


    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_TopolTool

# Register IntTools_TopolTool in _IntTools:
_IntTools.IntTools_TopolTool_swigregister(IntTools_TopolTool)

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

    @staticmethod
    def DecompositionOfWLine(*args) -> "Standard_Real &":
        r"""
        No available documentation.

        Parameters
        ----------
        theWLine: IntPatch_WLine
        theSurface1: GeomAdaptor_HSurface
        theSurface2: GeomAdaptor_HSurface
        theFace1: TopoDS_Face
        theFace2: TopoDS_Face
        theLConstructor: GeomInt_LineConstructor
        theAvoidLConstructor: bool
        theTol: float
        theNewLines: IntPatch_SequenceOfLine
        &: IntTools_Context

        Returns
        -------
        theReachedTol3d: float

        """
        return _IntTools.IntTools_WLineTool_DecompositionOfWLine(*args)

    @staticmethod
    def NotUseSurfacesForApprox(*args) -> "Standard_Boolean":
        r"""
        No available documentation.

        Parameters
        ----------
        aF1: TopoDS_Face
        aF2: TopoDS_Face
        WL: IntPatch_WLine
        ifprm: int
        ilprm: int

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_WLineTool_NotUseSurfacesForApprox(*args)

    __repr__ = _dumps_object


    def __init__(self):
        _IntTools.IntTools_WLineTool_swiginit(self, _IntTools.new_IntTools_WLineTool())
    __swig_destroy__ = _IntTools.delete_IntTools_WLineTool

# Register IntTools_WLineTool in _IntTools:
_IntTools.IntTools_WLineTool_swigregister(IntTools_WLineTool)

def IntTools_WLineTool_DecompositionOfWLine(*args) -> "Standard_Real &":
    r"""
    No available documentation.

    Parameters
    ----------
    theWLine: IntPatch_WLine
    theSurface1: GeomAdaptor_HSurface
    theSurface2: GeomAdaptor_HSurface
    theFace1: TopoDS_Face
    theFace2: TopoDS_Face
    theLConstructor: GeomInt_LineConstructor
    theAvoidLConstructor: bool
    theTol: float
    theNewLines: IntPatch_SequenceOfLine
    &: IntTools_Context

    Returns
    -------
    theReachedTol3d: float

    """
    return _IntTools.IntTools_WLineTool_DecompositionOfWLine(*args)

def IntTools_WLineTool_NotUseSurfacesForApprox(*args) -> "Standard_Boolean":
    r"""
    No available documentation.

    Parameters
    ----------
    aF1: TopoDS_Face
    aF2: TopoDS_Face
    WL: IntPatch_WLine
    ifprm: int
    ilprm: int

    Returns
    -------
    bool

    """
    return _IntTools.IntTools_WLineTool_NotUseSurfacesForApprox(*args)

class IntTools_CurveRangeSample(IntTools_BaseRangeSample):
    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"""
        No available documentation.

        Returns
        -------
        None
        No available documentation.

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        None

        """
        _IntTools.IntTools_CurveRangeSample_swiginit(self, _IntTools.new_IntTools_CurveRangeSample(*args))

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

        Parameters
        ----------
        theFirst: float
        theLast: float
        theNbSample: int

        Returns
        -------
        IntTools_Range

        """
        return _IntTools.IntTools_CurveRangeSample_GetRange(self, *args)

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

        Returns
        -------
        int

        """
        return _IntTools.IntTools_CurveRangeSample_GetRangeIndex(self, *args)

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

        Parameters
        ----------
        theNbSample: int

        Returns
        -------
        int

        """
        return _IntTools.IntTools_CurveRangeSample_GetRangeIndexDeeper(self, *args)

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

        Parameters
        ----------
        Other: IntTools_CurveRangeSample

        Returns
        -------
        bool

        """
        return _IntTools.IntTools_CurveRangeSample_IsEqual(self, *args)

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

        Parameters
        ----------
        theIndex: int

        Returns
        -------
        None

        """
        return _IntTools.IntTools_CurveRangeSample_SetRangeIndex(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _IntTools.delete_IntTools_CurveRangeSample

# Register IntTools_CurveRangeSample in _IntTools:
_IntTools.IntTools_CurveRangeSample_swigregister(IntTools_CurveRangeSample)


@classnotwrapped
class IntTools_CArray1OfInteger:
	pass

@classnotwrapped
class IntTools_CArray1OfReal:
	pass






