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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _Geom2dHatch:
_Geom2dHatch.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 _Geom2dHatch.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.gp
import OCC.Core.TColStd
import OCC.Core.TCollection
import OCC.Core.Geom2dAdaptor
import OCC.Core.Adaptor2d
import OCC.Core.Geom2d
import OCC.Core.GeomAbs
import OCC.Core.TColgp
import OCC.Core.IntRes2d
import OCC.Core.TopAbs
import OCC.Core.HatchGen
import OCC.Core.Geom2dInt
import OCC.Core.math
import OCC.Core.Message
import OCC.Core.OSD
import OCC.Core.IntCurve
import OCC.Core.Extrema
import OCC.Core.Adaptor3d
import OCC.Core.Geom
import OCC.Core.GeomAdaptor
import OCC.Core.Intf
import OCC.Core.Bnd
import OCC.Core.BVH

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



class Geom2dHatch_Hatchings(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< int,Geom2dHatch_Hatching,NCollection_DefaultHasher< int > >::iterator":
        return _Geom2dHatch.Geom2dHatch_Hatchings_begin(self)

    def end(self) -> "NCollection_DataMap< int,Geom2dHatch_Hatching,NCollection_DefaultHasher< int > >::iterator":
        return _Geom2dHatch.Geom2dHatch_Hatchings_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,Geom2dHatch_Hatching,NCollection_DefaultHasher< int > >::const_iterator":
        return _Geom2dHatch.Geom2dHatch_Hatchings_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,Geom2dHatch_Hatching,NCollection_DefaultHasher< int > >::const_iterator":
        return _Geom2dHatch.Geom2dHatch_Hatchings_cend(self)

    def __init__(self, *args):
        _Geom2dHatch.Geom2dHatch_Hatchings_swiginit(self, _Geom2dHatch.new_Geom2dHatch_Hatchings(*args))

    def Exchange(self, theOther: "Geom2dHatch_Hatchings") -> "void":
        return _Geom2dHatch.Geom2dHatch_Hatchings_Exchange(self, theOther)

    def Assign(self, theOther: "Geom2dHatch_Hatchings") -> "NCollection_DataMap< Standard_Integer,Geom2dHatch_Hatching,TColStd_MapIntegerHasher > &":
        return _Geom2dHatch.Geom2dHatch_Hatchings_Assign(self, theOther)

    def Set(self, theOther: "Geom2dHatch_Hatchings") -> "NCollection_DataMap< Standard_Integer,Geom2dHatch_Hatching,TColStd_MapIntegerHasher > &":
        return _Geom2dHatch.Geom2dHatch_Hatchings_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "Geom2dHatch_Hatching") -> "Standard_Boolean":
        return _Geom2dHatch.Geom2dHatch_Hatchings_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "Geom2dHatch_Hatching") -> "Geom2dHatch_Hatching *":
        return _Geom2dHatch.Geom2dHatch_Hatchings_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "int const &") -> "Standard_Boolean":
        return _Geom2dHatch.Geom2dHatch_Hatchings_IsBound(self, theKey)

    def UnBind(self, theKey: "int const &") -> "Standard_Boolean":
        return _Geom2dHatch.Geom2dHatch_Hatchings_UnBind(self, theKey)

    def Seek(self, theKey: "int const &") -> "Geom2dHatch_Hatching const *":
        return _Geom2dHatch.Geom2dHatch_Hatchings_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _Geom2dHatch.Geom2dHatch_Hatchings_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "Geom2dHatch_Hatching *":
        return _Geom2dHatch.Geom2dHatch_Hatchings_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "Geom2dHatch_Hatching &":
        return _Geom2dHatch.Geom2dHatch_Hatchings_ChangeFind(self, theKey)

    def __call__(self, *args) -> "Geom2dHatch_Hatching &":
        return _Geom2dHatch.Geom2dHatch_Hatchings___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _Geom2dHatch.Geom2dHatch_Hatchings_Clear(self, *args)
    __swig_destroy__ = _Geom2dHatch.delete_Geom2dHatch_Hatchings

    def Size(self) -> "Standard_Integer":
        return _Geom2dHatch.Geom2dHatch_Hatchings_Size(self)

    def Keys(self) -> "PyObject *":
        return _Geom2dHatch.Geom2dHatch_Hatchings_Keys(self)

# Register Geom2dHatch_Hatchings in _Geom2dHatch:
_Geom2dHatch.Geom2dHatch_Hatchings_swigregister(Geom2dHatch_Hatchings)

class Geom2dHatch_MapOfElements(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< int,Geom2dHatch_Element,NCollection_DefaultHasher< int > >::iterator":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_begin(self)

    def end(self) -> "NCollection_DataMap< int,Geom2dHatch_Element,NCollection_DefaultHasher< int > >::iterator":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,Geom2dHatch_Element,NCollection_DefaultHasher< int > >::const_iterator":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,Geom2dHatch_Element,NCollection_DefaultHasher< int > >::const_iterator":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_cend(self)

    def __init__(self, *args):
        _Geom2dHatch.Geom2dHatch_MapOfElements_swiginit(self, _Geom2dHatch.new_Geom2dHatch_MapOfElements(*args))

    def Exchange(self, theOther: "Geom2dHatch_MapOfElements") -> "void":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_Exchange(self, theOther)

    def Assign(self, theOther: "Geom2dHatch_MapOfElements") -> "NCollection_DataMap< Standard_Integer,Geom2dHatch_Element,TColStd_MapIntegerHasher > &":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_Assign(self, theOther)

    def Set(self, theOther: "Geom2dHatch_MapOfElements") -> "NCollection_DataMap< Standard_Integer,Geom2dHatch_Element,TColStd_MapIntegerHasher > &":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "Geom2dHatch_Element") -> "Standard_Boolean":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "Geom2dHatch_Element") -> "Geom2dHatch_Element *":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "int const &") -> "Standard_Boolean":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_IsBound(self, theKey)

    def UnBind(self, theKey: "int const &") -> "Standard_Boolean":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_UnBind(self, theKey)

    def Seek(self, theKey: "int const &") -> "Geom2dHatch_Element const *":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "Geom2dHatch_Element *":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "Geom2dHatch_Element &":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_ChangeFind(self, theKey)

    def __call__(self, *args) -> "Geom2dHatch_Element &":
        return _Geom2dHatch.Geom2dHatch_MapOfElements___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_Clear(self, *args)
    __swig_destroy__ = _Geom2dHatch.delete_Geom2dHatch_MapOfElements

    def Size(self) -> "Standard_Integer":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_Size(self)

    def Keys(self) -> "PyObject *":
        return _Geom2dHatch.Geom2dHatch_MapOfElements_Keys(self)

# Register Geom2dHatch_MapOfElements in _Geom2dHatch:
_Geom2dHatch.Geom2dHatch_MapOfElements_swigregister(Geom2dHatch_MapOfElements)

class Geom2dHatch_Classifier(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, undefined algorithm.

        Returns
        -------
        None
        Creates an algorithm to classify the point p with tolerance <t> on the face described by <f>.

        Parameters
        ----------
        F: Geom2dHatch_Elements
        P: gp_Pnt2d
        Tol: float

        Returns
        -------
        None

        """
        _Geom2dHatch.Geom2dHatch_Classifier_swiginit(self, _Geom2dHatch.new_Geom2dHatch_Classifier(*args))

    def Edge(self, *args) -> "Geom2dAdaptor_Curve const &":
        r"""
        Returns the edge used to determine the classification. when the state is on this is the edge containing the point.

        Returns
        -------
        Geom2dAdaptor_Curve

        """
        return _Geom2dHatch.Geom2dHatch_Classifier_Edge(self, *args)

    def EdgeParameter(self, *args) -> "Standard_Real":
        r"""
        Returns the parameter on edge() used to determine the classification.

        Returns
        -------
        float

        """
        return _Geom2dHatch.Geom2dHatch_Classifier_EdgeParameter(self, *args)

    def NoWires(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the face contains no wire. the state is in.

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Classifier_NoWires(self, *args)

    def Perform(self, *args) -> "void":
        r"""
        Classify the point p with tolerance <t> on the face described by <f>.

        Parameters
        ----------
        F: Geom2dHatch_Elements
        P: gp_Pnt2d
        Tol: float

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Classifier_Perform(self, *args)

    def Position(self, *args) -> "IntRes2d_Position":
        r"""
        Returns the position of the point on the edge returned by edge.

        Returns
        -------
        IntRes2d_Position

        """
        return _Geom2dHatch.Geom2dHatch_Classifier_Position(self, *args)

    def Rejected(self, *args) -> "Standard_Boolean":
        r"""
        Returns true when the state was computed by a rejection. the state is out.

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Classifier_Rejected(self, *args)

    def State(self, *args) -> "TopAbs_State":
        r"""
        Returns the result of the classification.

        Returns
        -------
        TopAbs_State

        """
        return _Geom2dHatch.Geom2dHatch_Classifier_State(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dHatch.delete_Geom2dHatch_Classifier

# Register Geom2dHatch_Classifier in _Geom2dHatch:
_Geom2dHatch.Geom2dHatch_Classifier_swigregister(Geom2dHatch_Classifier)

class Geom2dHatch_Element(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
        Creates an element.

        Parameters
        ----------
        Curve: Geom2dAdaptor_Curve
        Orientation: TopAbs_Orientation,optional
        	default value is TopAbs_FORWARD

        Returns
        -------
        None

        """
        _Geom2dHatch.Geom2dHatch_Element_swiginit(self, _Geom2dHatch.new_Geom2dHatch_Element(*args))

    def ChangeCurve(self, *args) -> "Geom2dAdaptor_Curve &":
        r"""
        Returns the curve associated to the element.

        Returns
        -------
        Geom2dAdaptor_Curve

        """
        return _Geom2dHatch.Geom2dHatch_Element_ChangeCurve(self, *args)

    def Curve(self, *args) -> "Geom2dAdaptor_Curve const &":
        r"""
        Returns the curve associated to the element.

        Returns
        -------
        Geom2dAdaptor_Curve

        """
        return _Geom2dHatch.Geom2dHatch_Element_Curve(self, *args)

    def Orientation(self, *args) -> "TopAbs_Orientation":
        r"""
        Sets the orientation of the element.

        Parameters
        ----------
        Orientation: TopAbs_Orientation

        Returns
        -------
        None
        Returns the orientation of the element.

        Returns
        -------
        TopAbs_Orientation

        """
        return _Geom2dHatch.Geom2dHatch_Element_Orientation(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dHatch.delete_Geom2dHatch_Element

# Register Geom2dHatch_Element in _Geom2dHatch:
_Geom2dHatch.Geom2dHatch_Element_swigregister(Geom2dHatch_Element)

class Geom2dHatch_Elements(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
        ----------
        Other: Geom2dHatch_Elements

        Returns
        -------
        None

        """
        _Geom2dHatch.Geom2dHatch_Elements_swiginit(self, _Geom2dHatch.new_Geom2dHatch_Elements(*args))

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

        Parameters
        ----------
        K: int
        I: Geom2dHatch_Element

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Elements_Bind(self, *args)

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

        Parameters
        ----------
        K: int

        Returns
        -------
        Geom2dHatch_Element

        """
        return _Geom2dHatch.Geom2dHatch_Elements_ChangeFind(self, *args)

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

        Parameters
        ----------
        P: gp_Pnt2d

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Elements_CheckPoint(self, *args)

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

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Elements_Clear(self, *args)

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

        Parameters
        ----------
        E: Geom2dAdaptor_Curve
        Or: TopAbs_Orientation

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Elements_CurrentEdge(self, *args)

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

        Parameters
        ----------
        K: int

        Returns
        -------
        Geom2dHatch_Element

        """
        return _Geom2dHatch.Geom2dHatch_Elements_Find(self, *args)

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

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Elements_InitEdges(self, *args)

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

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Elements_InitWires(self, *args)

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

        Parameters
        ----------
        K: int

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Elements_IsBound(self, *args)

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

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Elements_MoreEdges(self, *args)

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

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Elements_MoreWires(self, *args)

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

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Elements_NextEdge(self, *args)

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

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Elements_NextWire(self, *args)

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

        Parameters
        ----------
        P: gp_Pnt2d
        L: gp_Lin2d

        Returns
        -------
        Par: float

        """
        return _Geom2dHatch.Geom2dHatch_Elements_OtherSegment(self, *args)

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

        Parameters
        ----------
        P: gp_Pnt2d

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Elements_Reject(self, *args)

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

        Parameters
        ----------
        L: gp_Lin2d
        Par: float

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Elements_RejectEdge(self, *args)

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

        Parameters
        ----------
        L: gp_Lin2d
        Par: float

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Elements_RejectWire(self, *args)

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

        Parameters
        ----------
        P: gp_Pnt2d
        L: gp_Lin2d

        Returns
        -------
        Par: float

        """
        return _Geom2dHatch.Geom2dHatch_Elements_Segment(self, *args)

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

        Parameters
        ----------
        K: int

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Elements_UnBind(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dHatch.delete_Geom2dHatch_Elements

# Register Geom2dHatch_Elements in _Geom2dHatch:
_Geom2dHatch.Geom2dHatch_Elements_swigregister(Geom2dHatch_Elements)

class Geom2dHatch_FClass2dOfClassifier(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"""
        Creates an undefined classifier.

        Returns
        -------
        None

        """
        _Geom2dHatch.Geom2dHatch_FClass2dOfClassifier_swiginit(self, _Geom2dHatch.new_Geom2dHatch_FClass2dOfClassifier(*args))

    def ClosestIntersection(self, *args) -> "Standard_Integer":
        r"""
        Returns 0 if the last compared edge had no relevant intersection. else returns the index of this intersection in the last intersection algorithm.

        Returns
        -------
        int

        """
        return _Geom2dHatch.Geom2dHatch_FClass2dOfClassifier_ClosestIntersection(self, *args)

    def Compare(self, *args) -> "void":
        r"""
        Updates the classification process with the edge <e> from the boundary.

        Parameters
        ----------
        E: Geom2dAdaptor_Curve
        Or: TopAbs_Orientation

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_FClass2dOfClassifier_Compare(self, *args)

    def Intersector(self, *args) -> "Geom2dHatch_Intersector &":
        r"""
        Returns the intersecting algorithm.

        Returns
        -------
        Geom2dHatch_Intersector

        """
        return _Geom2dHatch.Geom2dHatch_FClass2dOfClassifier_Intersector(self, *args)

    def IsHeadOrEnd(self, *args) -> "Standard_Boolean":
        r"""
        Returns the standard_true if the closest intersection point represents head or end of the edge. returns standard_false otherwise.

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_FClass2dOfClassifier_IsHeadOrEnd(self, *args)

    def Parameter(self, *args) -> "Standard_Real":
        r"""
        Returns the current value of the parameter.

        Returns
        -------
        float

        """
        return _Geom2dHatch.Geom2dHatch_FClass2dOfClassifier_Parameter(self, *args)

    def Reset(self, *args) -> "void":
        r"""
        Starts a classification process. the point to classify is the origin of the line <l>. <p> is the original length of the segment on <l> used to compute intersections. <tol> is the tolerance attached to the line segment in intersections.

        Parameters
        ----------
        L: gp_Lin2d
        P: float
        Tol: float

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_FClass2dOfClassifier_Reset(self, *args)

    def State(self, *args) -> "TopAbs_State":
        r"""
        Returns the current state of the point.

        Returns
        -------
        TopAbs_State

        """
        return _Geom2dHatch.Geom2dHatch_FClass2dOfClassifier_State(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dHatch.delete_Geom2dHatch_FClass2dOfClassifier

# Register Geom2dHatch_FClass2dOfClassifier in _Geom2dHatch:
_Geom2dHatch.Geom2dHatch_FClass2dOfClassifier_swigregister(Geom2dHatch_FClass2dOfClassifier)

class Geom2dHatch_Hatcher(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"""
        Returns an empty hatcher.

        Parameters
        ----------
        Intersector: Geom2dHatch_Intersector
        Confusion2d: float
        Confusion3d: float
        KeepPnt: bool,optional
        	default value is Standard_False
        KeepSeg: bool,optional
        	default value is Standard_False

        Returns
        -------
        None

        """
        _Geom2dHatch.Geom2dHatch_Hatcher_swiginit(self, _Geom2dHatch.new_Geom2dHatch_Hatcher(*args))

    def AddElement(self, *args) -> "Standard_Integer":
        r"""
        Adds an element to the hatcher and returns its index.

        Parameters
        ----------
        Curve: Geom2dAdaptor_Curve
        Orientation: TopAbs_Orientation,optional
        	default value is TopAbs_FORWARD

        Returns
        -------
        int
        Adds an element to the hatcher and returns its index.

        Parameters
        ----------
        Curve: Geom2d_Curve
        Orientation: TopAbs_Orientation,optional
        	default value is TopAbs_FORWARD

        Returns
        -------
        int

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_AddElement(self, *args)

    def AddHatching(self, *args) -> "Standard_Integer":
        r"""
        Adds a hatching to the hatcher and returns its index.

        Parameters
        ----------
        Curve: Geom2dAdaptor_Curve

        Returns
        -------
        int

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_AddHatching(self, *args)

    def ChangeIntersector(self, *args) -> "Geom2dHatch_Intersector &":
        r"""
        Returns the associated intersector.

        Returns
        -------
        Geom2dHatch_Intersector

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_ChangeIntersector(self, *args)

    def Clear(self, *args) -> "void":
        r"""
        Removes all the hatchings and all the elements.

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_Clear(self, *args)

    def ClrElements(self, *args) -> "void":
        r"""
        Removes all the elements from the hatcher.

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_ClrElements(self, *args)

    def ClrHatchings(self, *args) -> "void":
        r"""
        Removes all the hatchings from the hatcher.

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_ClrHatchings(self, *args)

    def ComputeDomains(self, *args) -> "void":
        r"""
        Computes the domains of all the hatchings.

        Returns
        -------
        None
        Computes the domains of the indh-th hatching.

        Parameters
        ----------
        IndH: int

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_ComputeDomains(self, *args)

    def Confusion2d(self, *args) -> "Standard_Real":
        r"""
        Sets the confusion tolerance.

        Parameters
        ----------
        Confusion: float

        Returns
        -------
        None
        Returns the 2d confusion tolerance, i.e. the value under which two points are considered identical in the parametric space of the hatching.

        Returns
        -------
        float

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_Confusion2d(self, *args)

    def Confusion3d(self, *args) -> "Standard_Real":
        r"""
        Sets the confusion tolerance.

        Parameters
        ----------
        Confusion: float

        Returns
        -------
        None
        Returns the 3d confusion tolerance, i.e. the value under which two points are considered identical in the 3d space of the hatching.

        Returns
        -------
        float

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_Confusion3d(self, *args)

    def Domain(self, *args) -> "HatchGen_Domain const &":
        r"""
        Returns the idom-th domain of the indh-th hatching.

        Parameters
        ----------
        IndH: int
        IDom: int

        Returns
        -------
        HatchGen_Domain

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_Domain(self, *args)

    def Dump(self, *args) -> "void":
        r"""
        Dump the hatcher.

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_Dump(self, *args)

    def ElementCurve(self, *args) -> "Geom2dAdaptor_Curve const &":
        r"""
        Returns the curve associated to the inde-th element.

        Parameters
        ----------
        IndE: int

        Returns
        -------
        Geom2dAdaptor_Curve

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_ElementCurve(self, *args)

    def HatchingCurve(self, *args) -> "Geom2dAdaptor_Curve const &":
        r"""
        Returns the curve associated to the indh-th hatching.

        Parameters
        ----------
        IndH: int

        Returns
        -------
        Geom2dAdaptor_Curve

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_HatchingCurve(self, *args)

    def Intersector(self, *args) -> "Geom2dHatch_Intersector const &":
        r"""
        Sets the associated intersector.

        Parameters
        ----------
        Intersector: Geom2dHatch_Intersector

        Returns
        -------
        None
        Returns the associated intersector.

        Returns
        -------
        Geom2dHatch_Intersector

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_Intersector(self, *args)

    def KeepPoints(self, *args) -> "Standard_Boolean":
        r"""
        Sets the above flag.

        Parameters
        ----------
        Keep: bool

        Returns
        -------
        None
        Returns the flag about the points consideration.

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_KeepPoints(self, *args)

    def KeepSegments(self, *args) -> "Standard_Boolean":
        r"""
        Sets the above flag.

        Parameters
        ----------
        Keep: bool

        Returns
        -------
        None
        Returns the flag about the segments consideration.

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_KeepSegments(self, *args)

    def NbDomains(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of domains of the indh-th hatching. only one 'infinite' domain means that the hatching is fully included in the contour defined by the elements.

        Parameters
        ----------
        IndH: int

        Returns
        -------
        int

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_NbDomains(self, *args)

    def NbPoints(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of intersection points of the indh-th hatching.

        Parameters
        ----------
        IndH: int

        Returns
        -------
        int

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_NbPoints(self, *args)

    def Point(self, *args) -> "HatchGen_PointOnHatching const &":
        r"""
        Returns the indp-th intersection point of the indh-th hatching.

        Parameters
        ----------
        IndH: int
        IndP: int

        Returns
        -------
        HatchGen_PointOnHatching

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_Point(self, *args)

    def RemElement(self, *args) -> "void":
        r"""
        Removes the inde-th element from the hatcher.

        Parameters
        ----------
        IndE: int

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_RemElement(self, *args)

    def RemHatching(self, *args) -> "void":
        r"""
        Removes the indh-th hatching from the hatcher.

        Parameters
        ----------
        IndH: int

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_RemHatching(self, *args)

    def Status(self, *args) -> "HatchGen_ErrorStatus":
        r"""
        Returns the status about the indh-th hatching.

        Parameters
        ----------
        IndH: int

        Returns
        -------
        HatchGen_ErrorStatus

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_Status(self, *args)

    def Trim(self, *args) -> "void":
        r"""
        Trims all the hatchings of the hatcher by all the elements of the hatcher.

        Returns
        -------
        None
        Adds a hatching to the hatcher and trims it by the elements already given and returns its index.

        Parameters
        ----------
        Curve: Geom2dAdaptor_Curve

        Returns
        -------
        int
        Trims the indh-th hatching by the elements already given.

        Parameters
        ----------
        IndH: int

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_Trim(self, *args)

    def TrimDone(self, *args) -> "Standard_Boolean":
        r"""
        Returns the fact that the intersections were computed for the indh-th hatching.

        Parameters
        ----------
        IndH: int

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_TrimDone(self, *args)

    def TrimFailed(self, *args) -> "Standard_Boolean":
        r"""
        Returns the fact that the intersections failed for the indh-th hatching.

        Parameters
        ----------
        IndH: int

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Hatcher_TrimFailed(self, *args)

    __repr__ = _dumps_object

    @methodnotwrapped
    def IsDone(self):
    	pass

    __swig_destroy__ = _Geom2dHatch.delete_Geom2dHatch_Hatcher

# Register Geom2dHatch_Hatcher in _Geom2dHatch:
_Geom2dHatch.Geom2dHatch_Hatcher_swigregister(Geom2dHatch_Hatcher)

class Geom2dHatch_Hatching(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
        Creates a hatching.

        Parameters
        ----------
        Curve: Geom2dAdaptor_Curve

        Returns
        -------
        None

        """
        _Geom2dHatch.Geom2dHatch_Hatching_swiginit(self, _Geom2dHatch.new_Geom2dHatch_Hatching(*args))

    def AddDomain(self, *args) -> "void":
        r"""
        Adds a domain to the hatching.

        Parameters
        ----------
        Domain: HatchGen_Domain

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_AddDomain(self, *args)

    def AddPoint(self, *args) -> "void":
        r"""
        Adds an intersection point to the hatching.

        Parameters
        ----------
        Point: HatchGen_PointOnHatching
        Confusion: float

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_AddPoint(self, *args)

    def ChangeCurve(self, *args) -> "Geom2dAdaptor_Curve &":
        r"""
        Returns the curve associated to the hatching.

        Returns
        -------
        Geom2dAdaptor_Curve

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_ChangeCurve(self, *args)

    def ChangePoint(self, *args) -> "HatchGen_PointOnHatching &":
        r"""
        Returns the index-th intersection point of the hatching. the exception outofrange is raised if index < 1 or index > nbpoints.

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

        Returns
        -------
        HatchGen_PointOnHatching

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_ChangePoint(self, *args)

    def ClassificationPoint(self, *args) -> "gp_Pnt2d":
        r"""
        Returns a point on the curve. this point will be used for the classification.

        Returns
        -------
        gp_Pnt2d

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_ClassificationPoint(self, *args)

    def ClrDomains(self, *args) -> "void":
        r"""
        Removes all the domains of the hatching.

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_ClrDomains(self, *args)

    def ClrPoints(self, *args) -> "void":
        r"""
        Removes all the intersection points of the hatching.

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_ClrPoints(self, *args)

    def Curve(self, *args) -> "Geom2dAdaptor_Curve const &":
        r"""
        Returns the curve associated to the hatching.

        Returns
        -------
        Geom2dAdaptor_Curve

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_Curve(self, *args)

    def Domain(self, *args) -> "HatchGen_Domain const &":
        r"""
        Returns the index-th domain of the hatching. the exception outofrange is raised if index < 1 or index > nbdomains.

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

        Returns
        -------
        HatchGen_Domain

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_Domain(self, *args)

    def IsDone(self, *args) -> "Standard_Boolean":
        r"""
        Sets the flag about the domains computation to the given value.

        Parameters
        ----------
        Flag: bool

        Returns
        -------
        None
        Returns the flag about the domains computation.

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_IsDone(self, *args)

    def NbDomains(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of domains of the hatching.

        Returns
        -------
        int

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_NbDomains(self, *args)

    def NbPoints(self, *args) -> "Standard_Integer":
        r"""
        Returns the number of intersection points of the hatching.

        Returns
        -------
        int

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_NbPoints(self, *args)

    def Point(self, *args) -> "HatchGen_PointOnHatching const &":
        r"""
        Returns the index-th intersection point of the hatching. the exception outofrange is raised if index < 1 or index > nbpoints.

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

        Returns
        -------
        HatchGen_PointOnHatching

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_Point(self, *args)

    def RemDomain(self, *args) -> "void":
        r"""
        Removes the index-th domain of the hatching. the exception outofrange is raised if index < 1 or index > nbdomains.

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

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_RemDomain(self, *args)

    def RemPoint(self, *args) -> "void":
        r"""
        Removes the index-th intersection point of the hatching. the exception outofrange is raised if index < 1 or index > nbpoints.

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

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_RemPoint(self, *args)

    def Status(self, *args) -> "HatchGen_ErrorStatus":
        r"""
        Sets the error status.

        Parameters
        ----------
        theStatus: HatchGen_ErrorStatus

        Returns
        -------
        None
        Returns the error status.

        Returns
        -------
        HatchGen_ErrorStatus

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_Status(self, *args)

    def TrimDone(self, *args) -> "Standard_Boolean":
        r"""
        Sets the flag about the trimming computations to the given value.

        Parameters
        ----------
        Flag: bool

        Returns
        -------
        None
        Returns the flag about the trimming computations.

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_TrimDone(self, *args)

    def TrimFailed(self, *args) -> "Standard_Boolean":
        r"""
        Sets the flag about the trimming failure to the given value.

        Parameters
        ----------
        Flag: bool

        Returns
        -------
        None
        Returns the flag about the trimming failure.

        Returns
        -------
        bool

        """
        return _Geom2dHatch.Geom2dHatch_Hatching_TrimFailed(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dHatch.delete_Geom2dHatch_Hatching

# Register Geom2dHatch_Hatching in _Geom2dHatch:
_Geom2dHatch.Geom2dHatch_Hatching_swigregister(Geom2dHatch_Hatching)

class Geom2dHatch_Intersector(OCC.Core.Geom2dInt.Geom2dInt_GInter):
    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"""
        Creates an intersector.

        Parameters
        ----------
        Confusion: float
        Tangency: float

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

        Returns
        -------
        None

        """
        _Geom2dHatch.Geom2dHatch_Intersector_swiginit(self, _Geom2dHatch.new_Geom2dHatch_Intersector(*args))

    def ConfusionTolerance(self, *args) -> "Standard_Real":
        r"""
        Returns the confusion tolerance of the intersector.

        Returns
        -------
        float

        """
        return _Geom2dHatch.Geom2dHatch_Intersector_ConfusionTolerance(self, *args)

    def Intersect(self, *args) -> "void":
        r"""
        Intersects the curves c1 and c2. the results are retreived by the usual methods described in intres2d_intersection. creates an intersector.

        Parameters
        ----------
        C1: Geom2dAdaptor_Curve
        C2: Geom2dAdaptor_Curve

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Intersector_Intersect(self, *args)

    def LocalGeometry(self, *args) -> "void":
        r"""
        Returns in <t>, <n> and <c> the tangent, normal and curvature of the edge <e> at parameter value <u>.

        Parameters
        ----------
        E: Geom2dAdaptor_Curve
        U: float
        T: gp_Dir2d
        N: gp_Dir2d

        Returns
        -------
        C: float

        """
        return _Geom2dHatch.Geom2dHatch_Intersector_LocalGeometry(self, *args)

    def Perform(self, *args) -> "void":
        r"""
        Performs the intersection between the 2d line segment (<l>, <p>) and the curve <e>. the line segment is the part of the 2d line <l> of parameter range [0, <p>] (p is positive and can be reallast()). tol is the tolerance on the segment. the order is relevant, the first argument is the segment, the second the edge.

        Parameters
        ----------
        L: gp_Lin2d
        P: float
        Tol: float
        E: Geom2dAdaptor_Curve

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Intersector_Perform(self, *args)

    def SetConfusionTolerance(self, *args) -> "void":
        r"""
        Sets the confusion tolerance of the intersector.

        Parameters
        ----------
        Confusion: float

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Intersector_SetConfusionTolerance(self, *args)

    def SetTangencyTolerance(self, *args) -> "void":
        r"""
        Sets the tangency tolerance of the intersector.

        Parameters
        ----------
        Tangency: float

        Returns
        -------
        None

        """
        return _Geom2dHatch.Geom2dHatch_Intersector_SetTangencyTolerance(self, *args)

    def TangencyTolerance(self, *args) -> "Standard_Real":
        r"""
        Returns the tangency tolerance of the intersector.

        Returns
        -------
        float

        """
        return _Geom2dHatch.Geom2dHatch_Intersector_TangencyTolerance(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _Geom2dHatch.delete_Geom2dHatch_Intersector

# Register Geom2dHatch_Intersector in _Geom2dHatch:
_Geom2dHatch.Geom2dHatch_Intersector_swigregister(Geom2dHatch_Intersector)





