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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

# Register SwigPyIterator in _BRepClass:
_BRepClass.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 _BRepClass.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.TopoDS
import OCC.Core.Message
import OCC.Core.TCollection
import OCC.Core.OSD
import OCC.Core.TColStd
import OCC.Core.TopAbs
import OCC.Core.TopLoc
import OCC.Core.gp
import OCC.Core.IntRes2d
import OCC.Core.Geom2dInt
import OCC.Core.Adaptor2d
import OCC.Core.Geom2d
import OCC.Core.GeomAbs
import OCC.Core.TColgp
import OCC.Core.math
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 BRepClass_Edge(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
        ----------
        E: TopoDS_Edge
        F: TopoDS_Face

        Returns
        -------
        None

        """
        _BRepClass.BRepClass_Edge_swiginit(self, _BRepClass.new_BRepClass_Edge(*args))

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

        Returns
        -------
        TopoDS_Edge

        """
        return _BRepClass.BRepClass_Edge_Edge(self, *args)

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

        Returns
        -------
        TopoDS_Face

        """
        return _BRepClass.BRepClass_Edge_Face(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BRepClass.delete_BRepClass_Edge

# Register BRepClass_Edge in _BRepClass:
_BRepClass.BRepClass_Edge_swigregister(BRepClass_Edge)

class BRepClass_FClass2dOfFClassifier(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

        """
        _BRepClass.BRepClass_FClass2dOfFClassifier_swiginit(self, _BRepClass.new_BRepClass_FClass2dOfFClassifier(*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 _BRepClass.BRepClass_FClass2dOfFClassifier_ClosestIntersection(self, *args)

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

        Parameters
        ----------
        E: BRepClass_Edge
        Or: TopAbs_Orientation

        Returns
        -------
        None

        """
        return _BRepClass.BRepClass_FClass2dOfFClassifier_Compare(self, *args)

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

        Returns
        -------
        BRepClass_Intersector

        """
        return _BRepClass.BRepClass_FClass2dOfFClassifier_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 _BRepClass.BRepClass_FClass2dOfFClassifier_IsHeadOrEnd(self, *args)

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

        Returns
        -------
        float

        """
        return _BRepClass.BRepClass_FClass2dOfFClassifier_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 _BRepClass.BRepClass_FClass2dOfFClassifier_Reset(self, *args)

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

        Returns
        -------
        TopAbs_State

        """
        return _BRepClass.BRepClass_FClass2dOfFClassifier_State(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BRepClass.delete_BRepClass_FClass2dOfFClassifier

# Register BRepClass_FClass2dOfFClassifier in _BRepClass:
_BRepClass.BRepClass_FClass2dOfFClassifier_swigregister(BRepClass_FClass2dOfFClassifier)

class BRepClass_FClassifier(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: BRepClass_FaceExplorer
        P: gp_Pnt2d
        Tol: float

        Returns
        -------
        None

        """
        _BRepClass.BRepClass_FClassifier_swiginit(self, _BRepClass.new_BRepClass_FClassifier(*args))

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

        Returns
        -------
        BRepClass_Edge

        """
        return _BRepClass.BRepClass_FClassifier_Edge(self, *args)

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

        Returns
        -------
        float

        """
        return _BRepClass.BRepClass_FClassifier_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 _BRepClass.BRepClass_FClassifier_NoWires(self, *args)

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

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

        Returns
        -------
        None

        """
        return _BRepClass.BRepClass_FClassifier_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 _BRepClass.BRepClass_FClassifier_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 _BRepClass.BRepClass_FClassifier_Rejected(self, *args)

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

        Returns
        -------
        TopAbs_State

        """
        return _BRepClass.BRepClass_FClassifier_State(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BRepClass.delete_BRepClass_FClassifier

# Register BRepClass_FClassifier in _BRepClass:
_BRepClass.BRepClass_FClassifier_swigregister(BRepClass_FClassifier)

class BRepClass_FaceExplorer(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
        ----------
        F: TopoDS_Face

        Returns
        -------
        None

        """
        _BRepClass.BRepClass_FaceExplorer_swiginit(self, _BRepClass.new_BRepClass_FaceExplorer(*args))

    def CheckPoint(self, *args) -> "Standard_Boolean":
        r"""
        Checks the point and change its coords if it is located too far from the bounding box of the face. new coordinates of the point will be on the line between the point and the center of the bounding box. returns true if point was not changed.

        Parameters
        ----------
        thePoint: gp_Pnt2d

        Returns
        -------
        bool

        """
        return _BRepClass.BRepClass_FaceExplorer_CheckPoint(self, *args)

    def CurrentEdge(self, *args) -> "void":
        r"""
        Current edge in current wire and its orientation.

        Parameters
        ----------
        E: BRepClass_Edge
        Or: TopAbs_Orientation

        Returns
        -------
        None

        """
        return _BRepClass.BRepClass_FaceExplorer_CurrentEdge(self, *args)

    def InitEdges(self, *args) -> "void":
        r"""
        Starts an exploration of the edges of the current wire.

        Returns
        -------
        None

        """
        return _BRepClass.BRepClass_FaceExplorer_InitEdges(self, *args)

    def InitWires(self, *args) -> "void":
        r"""
        Starts an exploration of the wires.

        Returns
        -------
        None

        """
        return _BRepClass.BRepClass_FaceExplorer_InitWires(self, *args)

    def MoreEdges(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if there is a current edge.

        Returns
        -------
        bool

        """
        return _BRepClass.BRepClass_FaceExplorer_MoreEdges(self, *args)

    def MoreWires(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if there is a current wire.

        Returns
        -------
        bool

        """
        return _BRepClass.BRepClass_FaceExplorer_MoreWires(self, *args)

    def NextEdge(self, *args) -> "void":
        r"""
        Sets the explorer to the next edge.

        Returns
        -------
        None

        """
        return _BRepClass.BRepClass_FaceExplorer_NextEdge(self, *args)

    def NextWire(self, *args) -> "void":
        r"""
        Sets the explorer to the next wire.

        Returns
        -------
        None

        """
        return _BRepClass.BRepClass_FaceExplorer_NextWire(self, *args)

    def OtherSegment(self, *args) -> "Standard_Boolean":
        r"""
        Returns in <l>, <par> a segment having at least one intersection with the face boundary to compute intersections. each call gives another segment.

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

        Returns
        -------
        Par: float

        """
        return _BRepClass.BRepClass_FaceExplorer_OtherSegment(self, *args)

    def Reject(self, *args) -> "Standard_Boolean":
        r"""
        Should return true if the point is outside a bounding volume of the face.

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

        Returns
        -------
        bool

        """
        return _BRepClass.BRepClass_FaceExplorer_Reject(self, *args)

    def RejectEdge(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the edge bounding volume does not intersect the segment.

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

        Returns
        -------
        bool

        """
        return _BRepClass.BRepClass_FaceExplorer_RejectEdge(self, *args)

    def RejectWire(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the wire bounding volume does not intersect the segment.

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

        Returns
        -------
        bool

        """
        return _BRepClass.BRepClass_FaceExplorer_RejectWire(self, *args)

    def Segment(self, *args) -> "Standard_Boolean":
        r"""
        Returns in <l>, <par> a segment having at least one intersection with the face boundary to compute intersections.

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

        Returns
        -------
        Par: float

        """
        return _BRepClass.BRepClass_FaceExplorer_Segment(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BRepClass.delete_BRepClass_FaceExplorer

# Register BRepClass_FaceExplorer in _BRepClass:
_BRepClass.BRepClass_FaceExplorer_swigregister(BRepClass_FaceExplorer)

class BRepClass_FacePassiveClassifier(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

        """
        _BRepClass.BRepClass_FacePassiveClassifier_swiginit(self, _BRepClass.new_BRepClass_FacePassiveClassifier(*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 _BRepClass.BRepClass_FacePassiveClassifier_ClosestIntersection(self, *args)

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

        Parameters
        ----------
        E: BRepClass_Edge
        Or: TopAbs_Orientation

        Returns
        -------
        None

        """
        return _BRepClass.BRepClass_FacePassiveClassifier_Compare(self, *args)

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

        Returns
        -------
        BRepClass_Intersector

        """
        return _BRepClass.BRepClass_FacePassiveClassifier_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 _BRepClass.BRepClass_FacePassiveClassifier_IsHeadOrEnd(self, *args)

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

        Returns
        -------
        float

        """
        return _BRepClass.BRepClass_FacePassiveClassifier_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 _BRepClass.BRepClass_FacePassiveClassifier_Reset(self, *args)

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

        Returns
        -------
        TopAbs_State

        """
        return _BRepClass.BRepClass_FacePassiveClassifier_State(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BRepClass.delete_BRepClass_FacePassiveClassifier

# Register BRepClass_FacePassiveClassifier in _BRepClass:
_BRepClass.BRepClass_FacePassiveClassifier_swigregister(BRepClass_FacePassiveClassifier)

class BRepClass_Intersector(OCC.Core.Geom2dInt.Geom2dInt_IntConicCurveOfGInter):
    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

        """
        _BRepClass.BRepClass_Intersector_swiginit(self, _BRepClass.new_BRepClass_Intersector(*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: BRepClass_Edge
        U: float
        T: gp_Dir2d
        N: gp_Dir2d

        Returns
        -------
        C: float

        """
        return _BRepClass.BRepClass_Intersector_LocalGeometry(self, *args)

    def Perform(self, *args) -> "void":
        r"""
        Intersect the line segment and the edge.

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

        Returns
        -------
        None

        """
        return _BRepClass.BRepClass_Intersector_Perform(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BRepClass.delete_BRepClass_Intersector

# Register BRepClass_Intersector in _BRepClass:
_BRepClass.BRepClass_Intersector_swigregister(BRepClass_Intersector)

class BRepClass_FaceClassifier(BRepClass_FClassifier):
    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: BRepClass_FaceExplorer
        P: gp_Pnt2d
        Tol: float

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

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

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

        Parameters
        ----------
        F: TopoDS_Face
        P: gp_Pnt
        Tol: float

        Returns
        -------
        None

        """
        _BRepClass.BRepClass_FaceClassifier_swiginit(self, _BRepClass.new_BRepClass_FaceClassifier(*args))

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

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

        Returns
        -------
        None
        Classify the point p with tolerance <t> on the face described by <f>.

        Parameters
        ----------
        F: TopoDS_Face
        P: gp_Pnt
        Tol: float

        Returns
        -------
        None

        """
        return _BRepClass.BRepClass_FaceClassifier_Perform(self, *args)

    __repr__ = _dumps_object

    __swig_destroy__ = _BRepClass.delete_BRepClass_FaceClassifier

# Register BRepClass_FaceClassifier in _BRepClass:
_BRepClass.BRepClass_FaceClassifier_swigregister(BRepClass_FaceClassifier)





