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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

_swig_new_instance_method = _Poly.SWIG_PyInstanceMethod_New
_swig_new_static_method = _Poly.SWIG_PyStaticMethod_New

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


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


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


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


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


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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _Poly.delete_SwigPyIterator
    value = _swig_new_instance_method(_Poly.SwigPyIterator_value)
    incr = _swig_new_instance_method(_Poly.SwigPyIterator_incr)
    decr = _swig_new_instance_method(_Poly.SwigPyIterator_decr)
    distance = _swig_new_instance_method(_Poly.SwigPyIterator_distance)
    equal = _swig_new_instance_method(_Poly.SwigPyIterator_equal)
    copy = _swig_new_instance_method(_Poly.SwigPyIterator_copy)
    next = _swig_new_instance_method(_Poly.SwigPyIterator_next)
    __next__ = _swig_new_instance_method(_Poly.SwigPyIterator___next__)
    previous = _swig_new_instance_method(_Poly.SwigPyIterator_previous)
    advance = _swig_new_instance_method(_Poly.SwigPyIterator_advance)
    __eq__ = _swig_new_instance_method(_Poly.SwigPyIterator___eq__)
    __ne__ = _swig_new_instance_method(_Poly.SwigPyIterator___ne__)
    __iadd__ = _swig_new_instance_method(_Poly.SwigPyIterator___iadd__)
    __isub__ = _swig_new_instance_method(_Poly.SwigPyIterator___isub__)
    __add__ = _swig_new_instance_method(_Poly.SwigPyIterator___add__)
    __sub__ = _swig_new_instance_method(_Poly.SwigPyIterator___sub__)
    def __iter__(self):
        return self

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


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


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

import OCC.Core.Standard
import OCC.Core.NCollection
import OCC.Core.gp
import OCC.Core.TColgp
import OCC.Core.TColStd
import OCC.Core.TCollection
import OCC.Core.TShort
Handle_Poly_Polygon2D_Create = _Poly.Handle_Poly_Polygon2D_Create
Handle_Poly_Polygon2D_DownCast = _Poly.Handle_Poly_Polygon2D_DownCast
Handle_Poly_Polygon2D_IsNull = _Poly.Handle_Poly_Polygon2D_IsNull
Handle_Poly_Polygon3D_Create = _Poly.Handle_Poly_Polygon3D_Create
Handle_Poly_Polygon3D_DownCast = _Poly.Handle_Poly_Polygon3D_DownCast
Handle_Poly_Polygon3D_IsNull = _Poly.Handle_Poly_Polygon3D_IsNull
Handle_Poly_PolygonOnTriangulation_Create = _Poly.Handle_Poly_PolygonOnTriangulation_Create
Handle_Poly_PolygonOnTriangulation_DownCast = _Poly.Handle_Poly_PolygonOnTriangulation_DownCast
Handle_Poly_PolygonOnTriangulation_IsNull = _Poly.Handle_Poly_PolygonOnTriangulation_IsNull
Handle_Poly_Triangulation_Create = _Poly.Handle_Poly_Triangulation_Create
Handle_Poly_Triangulation_DownCast = _Poly.Handle_Poly_Triangulation_DownCast
Handle_Poly_Triangulation_IsNull = _Poly.Handle_Poly_Triangulation_IsNull
Handle_Poly_HArray1OfTriangle_Create = _Poly.Handle_Poly_HArray1OfTriangle_Create
Handle_Poly_HArray1OfTriangle_DownCast = _Poly.Handle_Poly_HArray1OfTriangle_DownCast
Handle_Poly_HArray1OfTriangle_IsNull = _Poly.Handle_Poly_HArray1OfTriangle_IsNull
class Poly_ListOfTriangulation(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    begin = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_begin)
    end = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_end)
    cbegin = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_cbegin)
    cend = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_cend)

    def __init__(self, *args):
        _Poly.Poly_ListOfTriangulation_swiginit(self, _Poly.new_Poly_ListOfTriangulation(*args))
    Size = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_Size)
    Assign = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_Assign)
    Set = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_Set)
    Clear = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_Clear)
    First = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_First)
    Last = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_Last)
    Append = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_Append)
    Prepend = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_Prepend)
    RemoveFirst = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_RemoveFirst)
    Remove = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_Remove)
    InsertBefore = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_InsertBefore)
    InsertAfter = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_InsertAfter)
    Reverse = _swig_new_instance_method(_Poly.Poly_ListOfTriangulation_Reverse)
    __swig_destroy__ = _Poly.delete_Poly_ListOfTriangulation

# Register Poly_ListOfTriangulation in _Poly:
_Poly.Poly_ListOfTriangulation_swigregister(Poly_ListOfTriangulation)

class Poly_Array1OfTriangle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    begin = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_begin)
    end = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_end)
    cbegin = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_cbegin)
    cend = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_cend)

    def __init__(self, *args):
        _Poly.Poly_Array1OfTriangle_swiginit(self, _Poly.new_Poly_Array1OfTriangle(*args))
    Init = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_Init)
    Size = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_Size)
    Length = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_Length)
    IsEmpty = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_IsEmpty)
    Lower = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_Lower)
    Upper = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_Upper)
    IsDeletable = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_IsDeletable)
    IsAllocated = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_IsAllocated)
    Assign = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_Assign)
    Move = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_Move)
    Set = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_Set)
    First = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_First)
    ChangeFirst = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_ChangeFirst)
    Last = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_Last)
    ChangeLast = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_ChangeLast)
    Value = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_Value)
    ChangeValue = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_ChangeValue)
    __call__ = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle___call__)
    SetValue = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_SetValue)
    Resize = _swig_new_instance_method(_Poly.Poly_Array1OfTriangle_Resize)
    __swig_destroy__ = _Poly.delete_Poly_Array1OfTriangle

    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 Poly_Array1OfTriangle in _Poly:
_Poly.Poly_Array1OfTriangle_swigregister(Poly_Array1OfTriangle)

class poly(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Catenate = _swig_new_static_method(_Poly.poly_Catenate)
    ComputeNormals = _swig_new_static_method(_Poly.poly_ComputeNormals)
    Dump = _swig_new_static_method(_Poly.poly_Dump)
    PointOnTriangle = _swig_new_static_method(_Poly.poly_PointOnTriangle)
    ReadPolygon2DFromString = _swig_new_instance_method(_Poly.poly_ReadPolygon2DFromString)
    ReadPolygon3DFromString = _swig_new_instance_method(_Poly.poly_ReadPolygon3DFromString)
    ReadTriangulationFromString = _swig_new_instance_method(_Poly.poly_ReadTriangulationFromString)
    Write = _swig_new_static_method(_Poly.poly_Write)

    __repr__ = _dumps_object


    def __init__(self):
        r"""__init__(poly self) -> poly"""
        _Poly.poly_swiginit(self, _Poly.new_poly())
    __swig_destroy__ = _Poly.delete_poly

# Register poly in _Poly:
_Poly.poly_swigregister(poly)
poly_Catenate = _Poly.poly_Catenate
poly_ComputeNormals = _Poly.poly_ComputeNormals
poly_Dump = _Poly.poly_Dump
poly_PointOnTriangle = _Poly.poly_PointOnTriangle
poly_Write = _Poly.poly_Write

class Poly_CoherentLink(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    GetAttribute = _swig_new_instance_method(_Poly.Poly_CoherentLink_GetAttribute)
    IsEmpty = _swig_new_instance_method(_Poly.Poly_CoherentLink_IsEmpty)
    Node = _swig_new_instance_method(_Poly.Poly_CoherentLink_Node)
    Nullify = _swig_new_instance_method(_Poly.Poly_CoherentLink_Nullify)
    OppositeNode = _swig_new_instance_method(_Poly.Poly_CoherentLink_OppositeNode)

    def __init__(self, *args):
        r"""
        * /** * Empty constructor. */
        	:rtype: None* /** * Constructor. Creates a Link that has no reference to 'opposite nodes'. * This constructor is useful to create temporary object that is not * inserted into any existing triangulation. */
        	:param iNode0:
        	:type iNode0: int
        	:param iNode1:
        	:type iNode1: int
        	:rtype: None* /** * Constructor, takes a triangle and a side. A link is created always such * that myNode[0] < myNode[1]. Unlike the previous constructor, this one * assigns the 'opposite node' fields. This constructor is used when a * link is inserted into a Poly_CoherentTriangulation structure. * @param theTri * Triangle containing the link that is created * @param iSide * Can be 0, 1 or 2. Index of the node */
        	:param theTri:
        	:type theTri: Poly_CoherentTriangle
        	:param iSide:
        	:type iSide: int
        	:rtype: None
        """
        _Poly.Poly_CoherentLink_swiginit(self, _Poly.new_Poly_CoherentLink(*args))
    SetAttribute = _swig_new_instance_method(_Poly.Poly_CoherentLink_SetAttribute)

    __repr__ = _dumps_object

    __swig_destroy__ = _Poly.delete_Poly_CoherentLink

# Register Poly_CoherentLink in _Poly:
_Poly.Poly_CoherentLink_swigregister(Poly_CoherentLink)

class Poly_CoherentNode(OCC.Core.gp.gp_XYZ):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AddTriangle = _swig_new_instance_method(_Poly.Poly_CoherentNode_AddTriangle)
    Clear = _swig_new_instance_method(_Poly.Poly_CoherentNode_Clear)
    DumpToString = _swig_new_instance_method(_Poly.Poly_CoherentNode_DumpToString)
    GetIndex = _swig_new_instance_method(_Poly.Poly_CoherentNode_GetIndex)
    GetNormal = _swig_new_instance_method(_Poly.Poly_CoherentNode_GetNormal)
    GetU = _swig_new_instance_method(_Poly.Poly_CoherentNode_GetU)
    GetV = _swig_new_instance_method(_Poly.Poly_CoherentNode_GetV)
    HasNormal = _swig_new_instance_method(_Poly.Poly_CoherentNode_HasNormal)
    IsFreeNode = _swig_new_instance_method(_Poly.Poly_CoherentNode_IsFreeNode)

    def __init__(self, *args):
        r"""
        * /** * Empty constructor. */
        	:rtype: None* /** * Constructor. */
        	:param thePnt:
        	:type thePnt: gp_XYZ
        	:rtype: None
        """
        _Poly.Poly_CoherentNode_swiginit(self, _Poly.new_Poly_CoherentNode(*args))
    RemoveTriangle = _swig_new_instance_method(_Poly.Poly_CoherentNode_RemoveTriangle)
    SetIndex = _swig_new_instance_method(_Poly.Poly_CoherentNode_SetIndex)
    SetNormal = _swig_new_instance_method(_Poly.Poly_CoherentNode_SetNormal)
    SetUV = _swig_new_instance_method(_Poly.Poly_CoherentNode_SetUV)
    TriangleIterator = _swig_new_instance_method(_Poly.Poly_CoherentNode_TriangleIterator)

    __repr__ = _dumps_object

    __swig_destroy__ = _Poly.delete_Poly_CoherentNode

# Register Poly_CoherentNode in _Poly:
_Poly.Poly_CoherentNode_swigregister(Poly_CoherentNode)

class Poly_CoherentTriangle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    FindConnection = _swig_new_instance_method(_Poly.Poly_CoherentTriangle_FindConnection)
    GetConnectedNode = _swig_new_instance_method(_Poly.Poly_CoherentTriangle_GetConnectedNode)
    GetConnectedTri = _swig_new_instance_method(_Poly.Poly_CoherentTriangle_GetConnectedTri)
    GetLink = _swig_new_instance_method(_Poly.Poly_CoherentTriangle_GetLink)
    IsEmpty = _swig_new_instance_method(_Poly.Poly_CoherentTriangle_IsEmpty)
    NConnections = _swig_new_instance_method(_Poly.Poly_CoherentTriangle_NConnections)
    Node = _swig_new_instance_method(_Poly.Poly_CoherentTriangle_Node)

    def __init__(self, *args):
        r"""
        * /** * Empty constructor. */
        	:rtype: None* /** * Constructor. */
        	:param iNode0:
        	:type iNode0: int
        	:param iNode1:
        	:type iNode1: int
        	:param iNode2:
        	:type iNode2: int
        	:rtype: None
        """
        _Poly.Poly_CoherentTriangle_swiginit(self, _Poly.new_Poly_CoherentTriangle(*args))
    RemoveConnection = _swig_new_instance_method(_Poly.Poly_CoherentTriangle_RemoveConnection)
    SetConnection = _swig_new_instance_method(_Poly.Poly_CoherentTriangle_SetConnection)

    __repr__ = _dumps_object

    __swig_destroy__ = _Poly.delete_Poly_CoherentTriangle

# Register Poly_CoherentTriangle in _Poly:
_Poly.Poly_CoherentTriangle_swigregister(Poly_CoherentTriangle)

class Poly_Connect(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Initialize = _swig_new_instance_method(_Poly.Poly_Connect_Initialize)
    Load = _swig_new_instance_method(_Poly.Poly_Connect_Load)
    More = _swig_new_instance_method(_Poly.Poly_Connect_More)
    Next = _swig_new_instance_method(_Poly.Poly_Connect_Next)
    Nodes = _swig_new_instance_method(_Poly.Poly_Connect_Nodes)

    def __init__(self, *args):
        r"""
        * Constructs an uninitialized algorithm.
        	:rtype: None* Constructs an algorithm to explore the adjacency data of nodes or triangles for the triangulation T.
        	:param theTriangulation:
        	:type theTriangulation: Poly_Triangulation
        	:rtype: None
        """
        _Poly.Poly_Connect_swiginit(self, _Poly.new_Poly_Connect(*args))
    Triangle = _swig_new_instance_method(_Poly.Poly_Connect_Triangle)
    Triangles = _swig_new_instance_method(_Poly.Poly_Connect_Triangles)
    Triangulation = _swig_new_instance_method(_Poly.Poly_Connect_Triangulation)
    Value = _swig_new_instance_method(_Poly.Poly_Connect_Value)

    __repr__ = _dumps_object

    __swig_destroy__ = _Poly.delete_Poly_Connect

# Register Poly_Connect in _Poly:
_Poly.Poly_Connect_swigregister(Poly_Connect)

class Poly_Polygon2D(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
    Deflection = _swig_new_instance_method(_Poly.Poly_Polygon2D_Deflection)
    NbNodes = _swig_new_instance_method(_Poly.Poly_Polygon2D_NbNodes)
    Nodes = _swig_new_instance_method(_Poly.Poly_Polygon2D_Nodes)

    def __init__(self, *args):
        r"""
        * Constructs a 2D polygon defined by the table of points, <Nodes>.
        	:param Nodes:
        	:type Nodes: TColgp_Array1OfPnt2d
        	:rtype: None
        """
        _Poly.Poly_Polygon2D_swiginit(self, _Poly.new_Poly_Polygon2D(*args))


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


    __repr__ = _dumps_object

    __swig_destroy__ = _Poly.delete_Poly_Polygon2D

# Register Poly_Polygon2D in _Poly:
_Poly.Poly_Polygon2D_swigregister(Poly_Polygon2D)

class Poly_Polygon3D(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
    ChangeParameters = _swig_new_instance_method(_Poly.Poly_Polygon3D_ChangeParameters)
    Copy = _swig_new_instance_method(_Poly.Poly_Polygon3D_Copy)
    Deflection = _swig_new_instance_method(_Poly.Poly_Polygon3D_Deflection)
    HasParameters = _swig_new_instance_method(_Poly.Poly_Polygon3D_HasParameters)
    NbNodes = _swig_new_instance_method(_Poly.Poly_Polygon3D_NbNodes)
    Nodes = _swig_new_instance_method(_Poly.Poly_Polygon3D_Nodes)
    Parameters = _swig_new_instance_method(_Poly.Poly_Polygon3D_Parameters)

    def __init__(self, *args):
        r"""
        * onstructs a 3D polygon defined by the table of points, Nodes.
        	:param Nodes:
        	:type Nodes: TColgp_Array1OfPnt
        	:rtype: None* Constructs a 3D polygon defined by the table of points, Nodes, and the parallel table of parameters, Parameters, where each value of the table Parameters is the parameter of the corresponding point on the curve approximated by the constructed polygon. Warning Both the Nodes and Parameters tables must have the same bounds. This property is not checked at construction time.
        	:param Nodes:
        	:type Nodes: TColgp_Array1OfPnt
        	:param Parameters:
        	:type Parameters: TColStd_Array1OfReal
        	:rtype: None
        """
        _Poly.Poly_Polygon3D_swiginit(self, _Poly.new_Poly_Polygon3D(*args))


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


    __repr__ = _dumps_object

    __swig_destroy__ = _Poly.delete_Poly_Polygon3D

# Register Poly_Polygon3D in _Poly:
_Poly.Poly_Polygon3D_swigregister(Poly_Polygon3D)

class Poly_PolygonOnTriangulation(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
    Copy = _swig_new_instance_method(_Poly.Poly_PolygonOnTriangulation_Copy)
    Deflection = _swig_new_instance_method(_Poly.Poly_PolygonOnTriangulation_Deflection)
    HasParameters = _swig_new_instance_method(_Poly.Poly_PolygonOnTriangulation_HasParameters)
    NbNodes = _swig_new_instance_method(_Poly.Poly_PolygonOnTriangulation_NbNodes)
    Nodes = _swig_new_instance_method(_Poly.Poly_PolygonOnTriangulation_Nodes)
    Parameters = _swig_new_instance_method(_Poly.Poly_PolygonOnTriangulation_Parameters)

    def __init__(self, *args):
        r"""
        * Constructs a 3D polygon on the triangulation of a shape, defined by the table of nodes, <Nodes>.
        	:param Nodes:
        	:type Nodes: TColStd_Array1OfInteger
        	:rtype: None* Constructs a 3D polygon on the triangulation of a shape, defined by: - the table of nodes, Nodes, and the table of parameters, <Parameters>. where: - a node value is an index in the table of nodes specific to an existing triangulation of a shape - and a parameter value is the value of the parameter of the corresponding point on the curve approximated by the constructed polygon. Warning The tables Nodes and Parameters must be the same size. This property is not checked at construction time.
        	:param Nodes:
        	:type Nodes: TColStd_Array1OfInteger
        	:param Parameters:
        	:type Parameters: TColStd_Array1OfReal
        	:rtype: None
        """
        _Poly.Poly_PolygonOnTriangulation_swiginit(self, _Poly.new_Poly_PolygonOnTriangulation(*args))


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


    __repr__ = _dumps_object

    __swig_destroy__ = _Poly.delete_Poly_PolygonOnTriangulation

# Register Poly_PolygonOnTriangulation in _Poly:
_Poly.Poly_PolygonOnTriangulation_swigregister(Poly_PolygonOnTriangulation)

class Poly_Triangle(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    GetChangeValue = _swig_new_instance_method(_Poly.Poly_Triangle_GetChangeValue)
    SetChangeValue = _swig_new_instance_method(_Poly.Poly_Triangle_SetChangeValue)
    Get = _swig_new_instance_method(_Poly.Poly_Triangle_Get)

    def __init__(self, *args):
        r"""
        * Constructs a triangle and sets all indices to zero.
        	:rtype: None* Constructs a triangle and sets its three indices to N1, N2 and N3 respectively, where these node values are indices in the table of nodes specific to an existing triangulation of a shape.
        	:param N1:
        	:type N1: int
        	:param N2:
        	:type N2: int
        	:param N3:
        	:type N3: int
        	:rtype: None
        """
        _Poly.Poly_Triangle_swiginit(self, _Poly.new_Poly_Triangle(*args))
    Set = _swig_new_instance_method(_Poly.Poly_Triangle_Set)
    Value = _swig_new_instance_method(_Poly.Poly_Triangle_Value)

    __repr__ = _dumps_object

    __swig_destroy__ = _Poly.delete_Poly_Triangle

# Register Poly_Triangle in _Poly:
_Poly.Poly_Triangle_swigregister(Poly_Triangle)

class Poly_Triangulation(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
    ChangeNode = _swig_new_instance_method(_Poly.Poly_Triangulation_ChangeNode)
    ChangeNodes = _swig_new_instance_method(_Poly.Poly_Triangulation_ChangeNodes)
    ChangeNormals = _swig_new_instance_method(_Poly.Poly_Triangulation_ChangeNormals)
    ChangeTriangle = _swig_new_instance_method(_Poly.Poly_Triangulation_ChangeTriangle)
    ChangeTriangles = _swig_new_instance_method(_Poly.Poly_Triangulation_ChangeTriangles)
    ChangeUVNode = _swig_new_instance_method(_Poly.Poly_Triangulation_ChangeUVNode)
    ChangeUVNodes = _swig_new_instance_method(_Poly.Poly_Triangulation_ChangeUVNodes)
    Copy = _swig_new_instance_method(_Poly.Poly_Triangulation_Copy)
    Deflection = _swig_new_instance_method(_Poly.Poly_Triangulation_Deflection)
    HasNormals = _swig_new_instance_method(_Poly.Poly_Triangulation_HasNormals)
    HasUVNodes = _swig_new_instance_method(_Poly.Poly_Triangulation_HasUVNodes)
    NbNodes = _swig_new_instance_method(_Poly.Poly_Triangulation_NbNodes)
    NbTriangles = _swig_new_instance_method(_Poly.Poly_Triangulation_NbTriangles)
    Node = _swig_new_instance_method(_Poly.Poly_Triangulation_Node)
    Nodes = _swig_new_instance_method(_Poly.Poly_Triangulation_Nodes)
    Normal = _swig_new_instance_method(_Poly.Poly_Triangulation_Normal)
    Normals = _swig_new_instance_method(_Poly.Poly_Triangulation_Normals)

    def __init__(self, *args):
        r"""
        * Constructs a triangulation from a set of triangles. The triangulation is initialized without a triangle or a node, but capable of containing nbNodes nodes, and nbTriangles triangles. Here the UVNodes flag indicates whether 2D nodes will be associated with 3D ones, (i.e. to enable a 2D representation).
        	:param nbNodes:
        	:type nbNodes: int
        	:param nbTriangles:
        	:type nbTriangles: int
        	:param UVNodes:
        	:type UVNodes: bool
        	:rtype: None* Constructs a triangulation from a set of triangles. The triangulation is initialized with 3D points from Nodes and triangles from Triangles.
        	:param Nodes:
        	:type Nodes: TColgp_Array1OfPnt
        	:param Triangles:
        	:type Triangles: Poly_Array1OfTriangle
        	:rtype: None* Constructs a triangulation from a set of triangles. The triangulation is initialized with 3D points from Nodes, 2D points from UVNodes and triangles from Triangles, where coordinates of a 2D point from UVNodes are the (u, v) parameters of the corresponding 3D point from Nodes on the surface approximated by the constructed triangulation.
        	:param Nodes:
        	:type Nodes: TColgp_Array1OfPnt
        	:param UVNodes:
        	:type UVNodes: TColgp_Array1OfPnt2d
        	:param Triangles:
        	:type Triangles: Poly_Array1OfTriangle
        	:rtype: None* Copy constructor for triangulation.
        	:param theTriangulation:
        	:type theTriangulation: Poly_Triangulation
        	:rtype: None
        """
        _Poly.Poly_Triangulation_swiginit(self, _Poly.new_Poly_Triangulation(*args))
    RemoveUVNodes = _swig_new_instance_method(_Poly.Poly_Triangulation_RemoveUVNodes)
    SetNormal = _swig_new_instance_method(_Poly.Poly_Triangulation_SetNormal)
    SetNormals = _swig_new_instance_method(_Poly.Poly_Triangulation_SetNormals)
    Triangle = _swig_new_instance_method(_Poly.Poly_Triangulation_Triangle)
    Triangles = _swig_new_instance_method(_Poly.Poly_Triangulation_Triangles)
    UVNode = _swig_new_instance_method(_Poly.Poly_Triangulation_UVNode)
    UVNodes = _swig_new_instance_method(_Poly.Poly_Triangulation_UVNodes)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _Poly.delete_Poly_Triangulation

# Register Poly_Triangulation in _Poly:
_Poly.Poly_Triangulation_swigregister(Poly_Triangulation)

class Poly_HArray1OfTriangle(Poly_Array1OfTriangle, 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):
        _Poly.Poly_HArray1OfTriangle_swiginit(self, _Poly.new_Poly_HArray1OfTriangle(*args))
    Array1 = _swig_new_instance_method(_Poly.Poly_HArray1OfTriangle_Array1)
    ChangeArray1 = _swig_new_instance_method(_Poly.Poly_HArray1OfTriangle_ChangeArray1)


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

    __swig_destroy__ = _Poly.delete_Poly_HArray1OfTriangle

# Register Poly_HArray1OfTriangle in _Poly:
_Poly.Poly_HArray1OfTriangle_swigregister(Poly_HArray1OfTriangle)



