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

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

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

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

# Register SwigPyIterator in _MeshVS:
_MeshVS.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.TColgp
import OCC.Core.SelectMgr
import OCC.Core.PrsMgr
import OCC.Core.Prs3d
import OCC.Core.Graphic3d
import OCC.Core.BVH
import OCC.Core.Quantity
import OCC.Core.TCollection
import OCC.Core.gp
import OCC.Core.Aspect
import OCC.Core.Geom
import OCC.Core.GeomAbs
import OCC.Core.TColStd
import OCC.Core.Bnd
import OCC.Core.Image
import OCC.Core.OSD
import OCC.Core.TopoDS
import OCC.Core.Message
import OCC.Core.TopAbs
import OCC.Core.TopLoc
import OCC.Core.HLRAlgo
import OCC.Core.Poly
import OCC.Core.TShort
import OCC.Core.TopTools
import OCC.Core.V3d
import OCC.Core.SelectBasics
import OCC.Core.Select3D
import OCC.Core.AIS
import OCC.Core.StdSelect
import OCC.Core.DsgPrs
MeshVS_ET_NONE = _MeshVS.MeshVS_ET_NONE
MeshVS_ET_Node = _MeshVS.MeshVS_ET_Node
MeshVS_ET_0D = _MeshVS.MeshVS_ET_0D
MeshVS_ET_Link = _MeshVS.MeshVS_ET_Link
MeshVS_ET_Face = _MeshVS.MeshVS_ET_Face
MeshVS_ET_Volume = _MeshVS.MeshVS_ET_Volume
MeshVS_ET_Element = _MeshVS.MeshVS_ET_Element
MeshVS_ET_All = _MeshVS.MeshVS_ET_All
MeshVS_MSM_PRECISE = _MeshVS.MeshVS_MSM_PRECISE
MeshVS_MSM_NODES = _MeshVS.MeshVS_MSM_NODES
MeshVS_MSM_BOX = _MeshVS.MeshVS_MSM_BOX
MeshVS_SMF_Mesh = _MeshVS.MeshVS_SMF_Mesh
MeshVS_SMF_Node = _MeshVS.MeshVS_SMF_Node
MeshVS_SMF_0D = _MeshVS.MeshVS_SMF_0D
MeshVS_SMF_Link = _MeshVS.MeshVS_SMF_Link
MeshVS_SMF_Face = _MeshVS.MeshVS_SMF_Face
MeshVS_SMF_Volume = _MeshVS.MeshVS_SMF_Volume
MeshVS_SMF_Element = _MeshVS.MeshVS_SMF_Element
MeshVS_SMF_All = _MeshVS.MeshVS_SMF_All
MeshVS_SMF_Group = _MeshVS.MeshVS_SMF_Group
MeshVS_BP_Mesh = _MeshVS.MeshVS_BP_Mesh
MeshVS_BP_NodalColor = _MeshVS.MeshVS_BP_NodalColor
MeshVS_BP_ElemColor = _MeshVS.MeshVS_BP_ElemColor
MeshVS_BP_Text = _MeshVS.MeshVS_BP_Text
MeshVS_BP_Vector = _MeshVS.MeshVS_BP_Vector
MeshVS_BP_User = _MeshVS.MeshVS_BP_User
MeshVS_BP_Default = _MeshVS.MeshVS_BP_Default
MeshVS_DA_InteriorStyle = _MeshVS.MeshVS_DA_InteriorStyle
MeshVS_DA_InteriorColor = _MeshVS.MeshVS_DA_InteriorColor
MeshVS_DA_BackInteriorColor = _MeshVS.MeshVS_DA_BackInteriorColor
MeshVS_DA_EdgeColor = _MeshVS.MeshVS_DA_EdgeColor
MeshVS_DA_EdgeType = _MeshVS.MeshVS_DA_EdgeType
MeshVS_DA_EdgeWidth = _MeshVS.MeshVS_DA_EdgeWidth
MeshVS_DA_HatchStyle = _MeshVS.MeshVS_DA_HatchStyle
MeshVS_DA_FrontMaterial = _MeshVS.MeshVS_DA_FrontMaterial
MeshVS_DA_BackMaterial = _MeshVS.MeshVS_DA_BackMaterial
MeshVS_DA_BeamType = _MeshVS.MeshVS_DA_BeamType
MeshVS_DA_BeamWidth = _MeshVS.MeshVS_DA_BeamWidth
MeshVS_DA_BeamColor = _MeshVS.MeshVS_DA_BeamColor
MeshVS_DA_MarkerType = _MeshVS.MeshVS_DA_MarkerType
MeshVS_DA_MarkerColor = _MeshVS.MeshVS_DA_MarkerColor
MeshVS_DA_MarkerScale = _MeshVS.MeshVS_DA_MarkerScale
MeshVS_DA_TextColor = _MeshVS.MeshVS_DA_TextColor
MeshVS_DA_TextHeight = _MeshVS.MeshVS_DA_TextHeight
MeshVS_DA_TextFont = _MeshVS.MeshVS_DA_TextFont
MeshVS_DA_TextExpansionFactor = _MeshVS.MeshVS_DA_TextExpansionFactor
MeshVS_DA_TextSpace = _MeshVS.MeshVS_DA_TextSpace
MeshVS_DA_TextStyle = _MeshVS.MeshVS_DA_TextStyle
MeshVS_DA_TextDisplayType = _MeshVS.MeshVS_DA_TextDisplayType
MeshVS_DA_TextTexFont = _MeshVS.MeshVS_DA_TextTexFont
MeshVS_DA_TextFontAspect = _MeshVS.MeshVS_DA_TextFontAspect
MeshVS_DA_VectorColor = _MeshVS.MeshVS_DA_VectorColor
MeshVS_DA_VectorMaxLength = _MeshVS.MeshVS_DA_VectorMaxLength
MeshVS_DA_VectorArrowPart = _MeshVS.MeshVS_DA_VectorArrowPart
MeshVS_DA_IsAllowOverlapped = _MeshVS.MeshVS_DA_IsAllowOverlapped
MeshVS_DA_Reflection = _MeshVS.MeshVS_DA_Reflection
MeshVS_DA_ColorReflection = _MeshVS.MeshVS_DA_ColorReflection
MeshVS_DA_ShrinkCoeff = _MeshVS.MeshVS_DA_ShrinkCoeff
MeshVS_DA_MaxFaceNodes = _MeshVS.MeshVS_DA_MaxFaceNodes
MeshVS_DA_ComputeTime = _MeshVS.MeshVS_DA_ComputeTime
MeshVS_DA_ComputeSelectionTime = _MeshVS.MeshVS_DA_ComputeSelectionTime
MeshVS_DA_DisplayNodes = _MeshVS.MeshVS_DA_DisplayNodes
MeshVS_DA_SelectableAuto = _MeshVS.MeshVS_DA_SelectableAuto
MeshVS_DA_ShowEdges = _MeshVS.MeshVS_DA_ShowEdges
MeshVS_DA_SmoothShading = _MeshVS.MeshVS_DA_SmoothShading
MeshVS_DA_SupressBackFaces = _MeshVS.MeshVS_DA_SupressBackFaces
MeshVS_DA_User = _MeshVS.MeshVS_DA_User
MeshVS_DMF_WireFrame = _MeshVS.MeshVS_DMF_WireFrame
MeshVS_DMF_Shading = _MeshVS.MeshVS_DMF_Shading
MeshVS_DMF_Shrink = _MeshVS.MeshVS_DMF_Shrink
MeshVS_DMF_OCCMask = _MeshVS.MeshVS_DMF_OCCMask
MeshVS_DMF_VectorDataPrs = _MeshVS.MeshVS_DMF_VectorDataPrs
MeshVS_DMF_NodalColorDataPrs = _MeshVS.MeshVS_DMF_NodalColorDataPrs
MeshVS_DMF_ElementalColorDataPrs = _MeshVS.MeshVS_DMF_ElementalColorDataPrs
MeshVS_DMF_TextDataPrs = _MeshVS.MeshVS_DMF_TextDataPrs
MeshVS_DMF_EntitiesWithData = _MeshVS.MeshVS_DMF_EntitiesWithData
MeshVS_DMF_DeformedPrsWireFrame = _MeshVS.MeshVS_DMF_DeformedPrsWireFrame
MeshVS_DMF_DeformedPrsShading = _MeshVS.MeshVS_DMF_DeformedPrsShading
MeshVS_DMF_DeformedPrsShrink = _MeshVS.MeshVS_DMF_DeformedPrsShrink
MeshVS_DMF_DeformedMask = _MeshVS.MeshVS_DMF_DeformedMask
MeshVS_DMF_SelectionPrs = _MeshVS.MeshVS_DMF_SelectionPrs
MeshVS_DMF_HilightPrs = _MeshVS.MeshVS_DMF_HilightPrs
MeshVS_DMF_User = _MeshVS.MeshVS_DMF_User
Handle_MeshVS_CommonSensitiveEntity_Create = _MeshVS.Handle_MeshVS_CommonSensitiveEntity_Create
Handle_MeshVS_CommonSensitiveEntity_DownCast = _MeshVS.Handle_MeshVS_CommonSensitiveEntity_DownCast
Handle_MeshVS_CommonSensitiveEntity_IsNull = _MeshVS.Handle_MeshVS_CommonSensitiveEntity_IsNull
Handle_MeshVS_DataSource_Create = _MeshVS.Handle_MeshVS_DataSource_Create
Handle_MeshVS_DataSource_DownCast = _MeshVS.Handle_MeshVS_DataSource_DownCast
Handle_MeshVS_DataSource_IsNull = _MeshVS.Handle_MeshVS_DataSource_IsNull
Handle_MeshVS_Drawer_Create = _MeshVS.Handle_MeshVS_Drawer_Create
Handle_MeshVS_Drawer_DownCast = _MeshVS.Handle_MeshVS_Drawer_DownCast
Handle_MeshVS_Drawer_IsNull = _MeshVS.Handle_MeshVS_Drawer_IsNull
Handle_MeshVS_DummySensitiveEntity_Create = _MeshVS.Handle_MeshVS_DummySensitiveEntity_Create
Handle_MeshVS_DummySensitiveEntity_DownCast = _MeshVS.Handle_MeshVS_DummySensitiveEntity_DownCast
Handle_MeshVS_DummySensitiveEntity_IsNull = _MeshVS.Handle_MeshVS_DummySensitiveEntity_IsNull
Handle_MeshVS_Mesh_Create = _MeshVS.Handle_MeshVS_Mesh_Create
Handle_MeshVS_Mesh_DownCast = _MeshVS.Handle_MeshVS_Mesh_DownCast
Handle_MeshVS_Mesh_IsNull = _MeshVS.Handle_MeshVS_Mesh_IsNull
Handle_MeshVS_MeshEntityOwner_Create = _MeshVS.Handle_MeshVS_MeshEntityOwner_Create
Handle_MeshVS_MeshEntityOwner_DownCast = _MeshVS.Handle_MeshVS_MeshEntityOwner_DownCast
Handle_MeshVS_MeshEntityOwner_IsNull = _MeshVS.Handle_MeshVS_MeshEntityOwner_IsNull
Handle_MeshVS_MeshOwner_Create = _MeshVS.Handle_MeshVS_MeshOwner_Create
Handle_MeshVS_MeshOwner_DownCast = _MeshVS.Handle_MeshVS_MeshOwner_DownCast
Handle_MeshVS_MeshOwner_IsNull = _MeshVS.Handle_MeshVS_MeshOwner_IsNull
Handle_MeshVS_PrsBuilder_Create = _MeshVS.Handle_MeshVS_PrsBuilder_Create
Handle_MeshVS_PrsBuilder_DownCast = _MeshVS.Handle_MeshVS_PrsBuilder_DownCast
Handle_MeshVS_PrsBuilder_IsNull = _MeshVS.Handle_MeshVS_PrsBuilder_IsNull
Handle_MeshVS_SensitiveFace_Create = _MeshVS.Handle_MeshVS_SensitiveFace_Create
Handle_MeshVS_SensitiveFace_DownCast = _MeshVS.Handle_MeshVS_SensitiveFace_DownCast
Handle_MeshVS_SensitiveFace_IsNull = _MeshVS.Handle_MeshVS_SensitiveFace_IsNull
Handle_MeshVS_SensitiveMesh_Create = _MeshVS.Handle_MeshVS_SensitiveMesh_Create
Handle_MeshVS_SensitiveMesh_DownCast = _MeshVS.Handle_MeshVS_SensitiveMesh_DownCast
Handle_MeshVS_SensitiveMesh_IsNull = _MeshVS.Handle_MeshVS_SensitiveMesh_IsNull
Handle_MeshVS_SensitivePolyhedron_Create = _MeshVS.Handle_MeshVS_SensitivePolyhedron_Create
Handle_MeshVS_SensitivePolyhedron_DownCast = _MeshVS.Handle_MeshVS_SensitivePolyhedron_DownCast
Handle_MeshVS_SensitivePolyhedron_IsNull = _MeshVS.Handle_MeshVS_SensitivePolyhedron_IsNull
Handle_MeshVS_SensitiveQuad_Create = _MeshVS.Handle_MeshVS_SensitiveQuad_Create
Handle_MeshVS_SensitiveQuad_DownCast = _MeshVS.Handle_MeshVS_SensitiveQuad_DownCast
Handle_MeshVS_SensitiveQuad_IsNull = _MeshVS.Handle_MeshVS_SensitiveQuad_IsNull
Handle_MeshVS_SensitiveSegment_Create = _MeshVS.Handle_MeshVS_SensitiveSegment_Create
Handle_MeshVS_SensitiveSegment_DownCast = _MeshVS.Handle_MeshVS_SensitiveSegment_DownCast
Handle_MeshVS_SensitiveSegment_IsNull = _MeshVS.Handle_MeshVS_SensitiveSegment_IsNull
Handle_MeshVS_DataSource3D_Create = _MeshVS.Handle_MeshVS_DataSource3D_Create
Handle_MeshVS_DataSource3D_DownCast = _MeshVS.Handle_MeshVS_DataSource3D_DownCast
Handle_MeshVS_DataSource3D_IsNull = _MeshVS.Handle_MeshVS_DataSource3D_IsNull
Handle_MeshVS_DeformedDataSource_Create = _MeshVS.Handle_MeshVS_DeformedDataSource_Create
Handle_MeshVS_DeformedDataSource_DownCast = _MeshVS.Handle_MeshVS_DeformedDataSource_DownCast
Handle_MeshVS_DeformedDataSource_IsNull = _MeshVS.Handle_MeshVS_DeformedDataSource_IsNull
Handle_MeshVS_ElementalColorPrsBuilder_Create = _MeshVS.Handle_MeshVS_ElementalColorPrsBuilder_Create
Handle_MeshVS_ElementalColorPrsBuilder_DownCast = _MeshVS.Handle_MeshVS_ElementalColorPrsBuilder_DownCast
Handle_MeshVS_ElementalColorPrsBuilder_IsNull = _MeshVS.Handle_MeshVS_ElementalColorPrsBuilder_IsNull
Handle_MeshVS_MeshPrsBuilder_Create = _MeshVS.Handle_MeshVS_MeshPrsBuilder_Create
Handle_MeshVS_MeshPrsBuilder_DownCast = _MeshVS.Handle_MeshVS_MeshPrsBuilder_DownCast
Handle_MeshVS_MeshPrsBuilder_IsNull = _MeshVS.Handle_MeshVS_MeshPrsBuilder_IsNull
Handle_MeshVS_NodalColorPrsBuilder_Create = _MeshVS.Handle_MeshVS_NodalColorPrsBuilder_Create
Handle_MeshVS_NodalColorPrsBuilder_DownCast = _MeshVS.Handle_MeshVS_NodalColorPrsBuilder_DownCast
Handle_MeshVS_NodalColorPrsBuilder_IsNull = _MeshVS.Handle_MeshVS_NodalColorPrsBuilder_IsNull
Handle_MeshVS_TextPrsBuilder_Create = _MeshVS.Handle_MeshVS_TextPrsBuilder_Create
Handle_MeshVS_TextPrsBuilder_DownCast = _MeshVS.Handle_MeshVS_TextPrsBuilder_DownCast
Handle_MeshVS_TextPrsBuilder_IsNull = _MeshVS.Handle_MeshVS_TextPrsBuilder_IsNull
Handle_MeshVS_VectorPrsBuilder_Create = _MeshVS.Handle_MeshVS_VectorPrsBuilder_Create
Handle_MeshVS_VectorPrsBuilder_DownCast = _MeshVS.Handle_MeshVS_VectorPrsBuilder_DownCast
Handle_MeshVS_VectorPrsBuilder_IsNull = _MeshVS.Handle_MeshVS_VectorPrsBuilder_IsNull
Handle_MeshVS_HArray1OfSequenceOfInteger_Create = _MeshVS.Handle_MeshVS_HArray1OfSequenceOfInteger_Create
Handle_MeshVS_HArray1OfSequenceOfInteger_DownCast = _MeshVS.Handle_MeshVS_HArray1OfSequenceOfInteger_DownCast
Handle_MeshVS_HArray1OfSequenceOfInteger_IsNull = _MeshVS.Handle_MeshVS_HArray1OfSequenceOfInteger_IsNull
class MeshVS_PolyhedronVerts(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(_MeshVS.MeshVS_PolyhedronVerts_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_PolyhedronVerts_swiginit(self, _MeshVS.new_MeshVS_PolyhedronVerts(*args))
    Size = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_Size)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_Set)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_Clear)
    First = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_First)
    Last = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_Last)
    Append = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_Append)
    Prepend = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_Prepend)
    RemoveFirst = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_RemoveFirst)
    Remove = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_Remove)
    InsertBefore = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_InsertBefore)
    InsertAfter = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_InsertAfter)
    Reverse = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVerts_Reverse)
    __swig_destroy__ = _MeshVS.delete_MeshVS_PolyhedronVerts

# Register MeshVS_PolyhedronVerts in _MeshVS:
_MeshVS.MeshVS_PolyhedronVerts_swigregister(MeshVS_PolyhedronVerts)

class MeshVS_PolyhedronVertsIter(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):
        _MeshVS.MeshVS_PolyhedronVertsIter_swiginit(self, _MeshVS.new_MeshVS_PolyhedronVertsIter(*args))
    More = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVertsIter_More)
    Next = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVertsIter_Next)
    Value = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVertsIter_Value)
    ChangeValue = _swig_new_instance_method(_MeshVS.MeshVS_PolyhedronVertsIter_ChangeValue)
    __swig_destroy__ = _MeshVS.delete_MeshVS_PolyhedronVertsIter

# Register MeshVS_PolyhedronVertsIter in _MeshVS:
_MeshVS.MeshVS_PolyhedronVertsIter_swigregister(MeshVS_PolyhedronVertsIter)

class MeshVS_Array1OfSequenceOfInteger(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(_MeshVS.MeshVS_Array1OfSequenceOfInteger_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_Array1OfSequenceOfInteger_swiginit(self, _MeshVS.new_MeshVS_Array1OfSequenceOfInteger(*args))
    Init = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_Init)
    Size = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_Size)
    Length = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_Length)
    IsEmpty = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_IsEmpty)
    Lower = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_Lower)
    Upper = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_Upper)
    IsDeletable = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_IsDeletable)
    IsAllocated = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_IsAllocated)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_Assign)
    Move = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_Move)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_Set)
    First = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_First)
    ChangeFirst = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_ChangeFirst)
    Last = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_Last)
    ChangeLast = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_ChangeLast)
    Value = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_Value)
    ChangeValue = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_ChangeValue)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger___call__)
    SetValue = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_SetValue)
    Resize = _swig_new_instance_method(_MeshVS.MeshVS_Array1OfSequenceOfInteger_Resize)
    __swig_destroy__ = _MeshVS.delete_MeshVS_Array1OfSequenceOfInteger

    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 MeshVS_Array1OfSequenceOfInteger in _MeshVS:
_MeshVS.MeshVS_Array1OfSequenceOfInteger_swigregister(MeshVS_Array1OfSequenceOfInteger)

class MeshVS_MapOfTwoNodes(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_MapOfTwoNodes_swiginit(self, _MeshVS.new_MeshVS_MapOfTwoNodes(*args))
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Exchange)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Set)
    ReSize = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_ReSize)
    Add = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Add)
    Added = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Added)
    Remove = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Remove)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Clear)
    __swig_destroy__ = _MeshVS.delete_MeshVS_MapOfTwoNodes
    Size = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Size)
    IsEqual = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_IsEqual)
    Contains = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Contains)
    Union = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Union)
    Unite = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Unite)
    HasIntersection = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_HasIntersection)
    Intersection = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Intersection)
    Intersect = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Intersect)
    Subtraction = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Subtraction)
    Subtract = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Subtract)
    Difference = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Difference)
    Differ = _swig_new_instance_method(_MeshVS.MeshVS_MapOfTwoNodes_Differ)

# Register MeshVS_MapOfTwoNodes in _MeshVS:
_MeshVS.MeshVS_MapOfTwoNodes_swigregister(MeshVS_MapOfTwoNodes)

class MeshVS_DataMapOfIntegerBoolean(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(_MeshVS.MeshVS_DataMapOfIntegerBoolean_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerBoolean_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerBoolean(*args))
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_Exchange)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_Set)
    ReSize = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_ReSize)
    Bind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_Bind)
    Bound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_Bound)
    IsBound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_IsBound)
    UnBind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_UnBind)
    Seek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_Seek)
    Find = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_Find)
    ChangeSeek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_ChangeSeek)
    ChangeFind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_ChangeFind)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean___call__)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_Clear)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerBoolean
    Size = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_Size)
    Keys = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerBoolean_Keys)

# Register MeshVS_DataMapOfIntegerBoolean in _MeshVS:
_MeshVS.MeshVS_DataMapOfIntegerBoolean_swigregister(MeshVS_DataMapOfIntegerBoolean)

class MeshVS_DataMapOfTwoColorsMapOfInteger(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(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_swiginit(self, _MeshVS.new_MeshVS_DataMapOfTwoColorsMapOfInteger(*args))
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Exchange)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Set)
    ReSize = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_ReSize)
    Bind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Bind)
    Bound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Bound)
    IsBound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_IsBound)
    UnBind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_UnBind)
    Seek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Seek)
    Find = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Find)
    ChangeSeek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_ChangeSeek)
    ChangeFind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_ChangeFind)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger___call__)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Clear)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfTwoColorsMapOfInteger
    Size = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Size)

# Register MeshVS_DataMapOfTwoColorsMapOfInteger in _MeshVS:
_MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_swigregister(MeshVS_DataMapOfTwoColorsMapOfInteger)

class MeshVS_DataMapOfIntegerMeshEntityOwner(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(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerMeshEntityOwner(*args))
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Exchange)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Set)
    ReSize = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_ReSize)
    Bind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Bind)
    Bound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Bound)
    IsBound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_IsBound)
    UnBind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_UnBind)
    Seek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Seek)
    Find = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Find)
    ChangeSeek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_ChangeSeek)
    ChangeFind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_ChangeFind)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner___call__)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Clear)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerMeshEntityOwner
    Size = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Size)
    Keys = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Keys)

# Register MeshVS_DataMapOfIntegerMeshEntityOwner in _MeshVS:
_MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_swigregister(MeshVS_DataMapOfIntegerMeshEntityOwner)

class MeshVS_DataMapOfHArray1OfSequenceOfInteger(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(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_swiginit(self, _MeshVS.new_MeshVS_DataMapOfHArray1OfSequenceOfInteger(*args))
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Exchange)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Set)
    ReSize = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_ReSize)
    Bind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Bind)
    Bound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Bound)
    IsBound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_IsBound)
    UnBind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_UnBind)
    Seek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Seek)
    Find = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Find)
    ChangeSeek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_ChangeSeek)
    ChangeFind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_ChangeFind)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger___call__)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Clear)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfHArray1OfSequenceOfInteger
    Size = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Size)
    Keys = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Keys)

# Register MeshVS_DataMapOfHArray1OfSequenceOfInteger in _MeshVS:
_MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_swigregister(MeshVS_DataMapOfHArray1OfSequenceOfInteger)

class MeshVS_TwoNodesHasher(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    HashCode = _swig_new_static_method(_MeshVS.MeshVS_TwoNodesHasher_HashCode)
    IsEqual = _swig_new_static_method(_MeshVS.MeshVS_TwoNodesHasher_IsEqual)

    def __init__(self):
        _MeshVS.MeshVS_TwoNodesHasher_swiginit(self, _MeshVS.new_MeshVS_TwoNodesHasher())
    __swig_destroy__ = _MeshVS.delete_MeshVS_TwoNodesHasher

# Register MeshVS_TwoNodesHasher in _MeshVS:
_MeshVS.MeshVS_TwoNodesHasher_swigregister(MeshVS_TwoNodesHasher)
MeshVS_TwoNodesHasher_HashCode = _MeshVS.MeshVS_TwoNodesHasher_HashCode
MeshVS_TwoNodesHasher_IsEqual = _MeshVS.MeshVS_TwoNodesHasher_IsEqual

class MeshVS_SequenceOfPrsBuilder(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(_MeshVS.MeshVS_SequenceOfPrsBuilder_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_SequenceOfPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_SequenceOfPrsBuilder(*args))
    Size = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Size)
    Length = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Length)
    Lower = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Lower)
    Upper = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Upper)
    IsEmpty = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_IsEmpty)
    Reverse = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Reverse)
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Exchange)
    delNode = _swig_new_static_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_delNode)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Clear)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Set)
    Remove = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Remove)
    Append = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Append)
    Prepend = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Prepend)
    InsertBefore = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_InsertBefore)
    InsertAfter = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_InsertAfter)
    Split = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Split)
    First = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_First)
    ChangeFirst = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_ChangeFirst)
    Last = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Last)
    ChangeLast = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_ChangeLast)
    Value = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_Value)
    ChangeValue = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_ChangeValue)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder___call__)
    SetValue = _swig_new_instance_method(_MeshVS.MeshVS_SequenceOfPrsBuilder_SetValue)
    __swig_destroy__ = _MeshVS.delete_MeshVS_SequenceOfPrsBuilder

# Register MeshVS_SequenceOfPrsBuilder in _MeshVS:
_MeshVS.MeshVS_SequenceOfPrsBuilder_swigregister(MeshVS_SequenceOfPrsBuilder)
MeshVS_SequenceOfPrsBuilder_delNode = _MeshVS.MeshVS_SequenceOfPrsBuilder_delNode

class MeshVS_DataMapOfIntegerColor(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(_MeshVS.MeshVS_DataMapOfIntegerColor_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerColor_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerColor(*args))
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_Exchange)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_Set)
    ReSize = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_ReSize)
    Bind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_Bind)
    Bound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_Bound)
    IsBound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_IsBound)
    UnBind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_UnBind)
    Seek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_Seek)
    Find = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_Find)
    ChangeSeek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_ChangeSeek)
    ChangeFind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_ChangeFind)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor___call__)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_Clear)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerColor
    Size = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_Size)
    Keys = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerColor_Keys)

# Register MeshVS_DataMapOfIntegerColor in _MeshVS:
_MeshVS.MeshVS_DataMapOfIntegerColor_swigregister(MeshVS_DataMapOfIntegerColor)

class MeshVS_DataMapOfIntegerOwner(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(_MeshVS.MeshVS_DataMapOfIntegerOwner_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerOwner_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerOwner(*args))
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_Exchange)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_Set)
    ReSize = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_ReSize)
    Bind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_Bind)
    Bound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_Bound)
    IsBound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_IsBound)
    UnBind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_UnBind)
    Seek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_Seek)
    Find = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_Find)
    ChangeSeek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_ChangeSeek)
    ChangeFind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_ChangeFind)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner___call__)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_Clear)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerOwner
    Size = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_Size)
    Keys = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerOwner_Keys)

# Register MeshVS_DataMapOfIntegerOwner in _MeshVS:
_MeshVS.MeshVS_DataMapOfIntegerOwner_swigregister(MeshVS_DataMapOfIntegerOwner)

class MeshVS_DataMapOfIntegerTwoColors(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(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerTwoColors_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerTwoColors(*args))
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_Exchange)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_Set)
    ReSize = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_ReSize)
    Bind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_Bind)
    Bound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_Bound)
    IsBound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_IsBound)
    UnBind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_UnBind)
    Seek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_Seek)
    Find = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_Find)
    ChangeSeek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_ChangeSeek)
    ChangeFind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_ChangeFind)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors___call__)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_Clear)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerTwoColors
    Size = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_Size)
    Keys = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerTwoColors_Keys)

# Register MeshVS_DataMapOfIntegerTwoColors in _MeshVS:
_MeshVS.MeshVS_DataMapOfIntegerTwoColors_swigregister(MeshVS_DataMapOfIntegerTwoColors)

class MeshVS_DataMapOfIntegerVector(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(_MeshVS.MeshVS_DataMapOfIntegerVector_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerVector_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerVector(*args))
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_Exchange)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_Set)
    ReSize = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_ReSize)
    Bind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_Bind)
    Bound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_Bound)
    IsBound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_IsBound)
    UnBind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_UnBind)
    Seek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_Seek)
    Find = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_Find)
    ChangeSeek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_ChangeSeek)
    ChangeFind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_ChangeFind)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector___call__)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_Clear)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerVector
    Size = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_Size)
    Keys = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerVector_Keys)

# Register MeshVS_DataMapOfIntegerVector in _MeshVS:
_MeshVS.MeshVS_DataMapOfIntegerVector_swigregister(MeshVS_DataMapOfIntegerVector)

class MeshVS_DataMapOfIntegerAsciiString(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(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerAsciiString_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerAsciiString(*args))
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_Exchange)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_Set)
    ReSize = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_ReSize)
    Bind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_Bind)
    Bound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_Bound)
    IsBound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_IsBound)
    UnBind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_UnBind)
    Seek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_Seek)
    Find = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_Find)
    ChangeSeek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_ChangeSeek)
    ChangeFind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_ChangeFind)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString___call__)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_Clear)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerAsciiString
    Size = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_Size)
    Keys = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerAsciiString_Keys)

# Register MeshVS_DataMapOfIntegerAsciiString in _MeshVS:
_MeshVS.MeshVS_DataMapOfIntegerAsciiString_swigregister(MeshVS_DataMapOfIntegerAsciiString)

class MeshVS_TwoColorsHasher(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    HashCode = _swig_new_static_method(_MeshVS.MeshVS_TwoColorsHasher_HashCode)
    IsEqual = _swig_new_static_method(_MeshVS.MeshVS_TwoColorsHasher_IsEqual)

    def __init__(self):
        _MeshVS.MeshVS_TwoColorsHasher_swiginit(self, _MeshVS.new_MeshVS_TwoColorsHasher())
    __swig_destroy__ = _MeshVS.delete_MeshVS_TwoColorsHasher

# Register MeshVS_TwoColorsHasher in _MeshVS:
_MeshVS.MeshVS_TwoColorsHasher_swigregister(MeshVS_TwoColorsHasher)
MeshVS_TwoColorsHasher_HashCode = _MeshVS.MeshVS_TwoColorsHasher_HashCode
MeshVS_TwoColorsHasher_IsEqual = _MeshVS.MeshVS_TwoColorsHasher_IsEqual

class MeshVS_DataMapOfColorMapOfInteger(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(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfColorMapOfInteger_swiginit(self, _MeshVS.new_MeshVS_DataMapOfColorMapOfInteger(*args))
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_Exchange)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_Set)
    ReSize = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_ReSize)
    Bind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_Bind)
    Bound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_Bound)
    IsBound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_IsBound)
    UnBind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_UnBind)
    Seek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_Seek)
    Find = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_Find)
    ChangeSeek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_ChangeSeek)
    ChangeFind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_ChangeFind)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger___call__)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_Clear)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfColorMapOfInteger
    Size = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfColorMapOfInteger_Size)

# Register MeshVS_DataMapOfColorMapOfInteger in _MeshVS:
_MeshVS.MeshVS_DataMapOfColorMapOfInteger_swigregister(MeshVS_DataMapOfColorMapOfInteger)

class MeshVS_DataMapOfIntegerMaterial(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(_MeshVS.MeshVS_DataMapOfIntegerMaterial_begin)
    end = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_end)
    cbegin = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_cbegin)
    cend = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_cend)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerMaterial_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerMaterial(*args))
    Exchange = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_Exchange)
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_Assign)
    Set = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_Set)
    ReSize = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_ReSize)
    Bind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_Bind)
    Bound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_Bound)
    IsBound = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_IsBound)
    UnBind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_UnBind)
    Seek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_Seek)
    Find = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_Find)
    ChangeSeek = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_ChangeSeek)
    ChangeFind = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_ChangeFind)
    __call__ = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial___call__)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_Clear)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerMaterial
    Size = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_Size)
    Keys = _swig_new_instance_method(_MeshVS.MeshVS_DataMapOfIntegerMaterial_Keys)

# Register MeshVS_DataMapOfIntegerMaterial in _MeshVS:
_MeshVS.MeshVS_DataMapOfIntegerMaterial_swigregister(MeshVS_DataMapOfIntegerMaterial)

class MeshVS_Buffer(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"""
        * Constructor of the buffer of the requested size
        	:param theSize:
        	:type theSize: Standard_Size
        	:rtype: None
        """
        _MeshVS.MeshVS_Buffer_swiginit(self, _MeshVS.new_MeshVS_Buffer(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_Buffer

# Register MeshVS_Buffer in _MeshVS:
_MeshVS.MeshVS_Buffer_swigregister(MeshVS_Buffer)

class MeshVS_CommonSensitiveEntity(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BoundingBox = _swig_new_instance_method(_MeshVS.MeshVS_CommonSensitiveEntity_BoundingBox)
    Box = _swig_new_instance_method(_MeshVS.MeshVS_CommonSensitiveEntity_Box)
    Center = _swig_new_instance_method(_MeshVS.MeshVS_CommonSensitiveEntity_Center)
    CenterOfGeometry = _swig_new_instance_method(_MeshVS.MeshVS_CommonSensitiveEntity_CenterOfGeometry)
    GetConnected = _swig_new_instance_method(_MeshVS.MeshVS_CommonSensitiveEntity_GetConnected)

    def __init__(self, *args):
        r"""
        * Default constructor.
        	:param theOwner:
        	:type theOwner: SelectMgr_EntityOwner
        	:param theParentMesh:
        	:type theParentMesh: MeshVS_Mesh
        	:param theSelMethod:
        	:type theSelMethod: MeshVS_MeshSelectionMethod
        	:rtype: None
        """
        _MeshVS.MeshVS_CommonSensitiveEntity_swiginit(self, _MeshVS.new_MeshVS_CommonSensitiveEntity(*args))
    NbSubElements = _swig_new_instance_method(_MeshVS.MeshVS_CommonSensitiveEntity_NbSubElements)
    Size = _swig_new_instance_method(_MeshVS.MeshVS_CommonSensitiveEntity_Size)
    Swap = _swig_new_instance_method(_MeshVS.MeshVS_CommonSensitiveEntity_Swap)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_CommonSensitiveEntity

# Register MeshVS_CommonSensitiveEntity in _MeshVS:
_MeshVS.MeshVS_CommonSensitiveEntity_swigregister(MeshVS_CommonSensitiveEntity)

class MeshVS_DataSource(OCC.Core.Standard.Standard_Transient):
    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")
    __repr__ = _swig_repr
    Get3DGeom = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_Get3DGeom)
    GetAddr = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetAddr)
    GetAllElements = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetAllElements)
    GetAllGroups = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetAllGroups)
    GetAllNodes = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetAllNodes)
    GetBoundingBox = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetBoundingBox)
    GetDetectedEntities = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetDetectedEntities)
    GetGeom = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetGeom)
    GetGeomType = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetGeomType)
    GetGroup = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetGroup)
    GetGroupAddr = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetGroupAddr)
    GetNodeNormal = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetNodeNormal)
    GetNodesByElement = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetNodesByElement)
    GetNormal = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetNormal)
    GetNormalsByElement = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_GetNormalsByElement)
    IsAdvancedSelectionEnabled = _swig_new_instance_method(_MeshVS.MeshVS_DataSource_IsAdvancedSelectionEnabled)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_DataSource

# Register MeshVS_DataSource in _MeshVS:
_MeshVS.MeshVS_DataSource_swigregister(MeshVS_DataSource)

class MeshVS_Drawer(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
    Assign = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_Assign)
    GetAsciiString = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_GetAsciiString)
    GetBoolean = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_GetBoolean)
    GetColor = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_GetColor)
    GetDouble = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_GetDouble)
    GetInteger = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_GetInteger)
    GetMaterial = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_GetMaterial)
    RemoveAsciiString = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_RemoveAsciiString)
    RemoveBoolean = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_RemoveBoolean)
    RemoveColor = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_RemoveColor)
    RemoveDouble = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_RemoveDouble)
    RemoveInteger = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_RemoveInteger)
    RemoveMaterial = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_RemoveMaterial)
    SetAsciiString = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_SetAsciiString)
    SetBoolean = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_SetBoolean)
    SetColor = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_SetColor)
    SetDouble = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_SetDouble)
    SetInteger = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_SetInteger)
    SetMaterial = _swig_new_instance_method(_MeshVS.MeshVS_Drawer_SetMaterial)


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


    __repr__ = _dumps_object


    def __init__(self):
        _MeshVS.MeshVS_Drawer_swiginit(self, _MeshVS.new_MeshVS_Drawer())
    __swig_destroy__ = _MeshVS.delete_MeshVS_Drawer

# Register MeshVS_Drawer in _MeshVS:
_MeshVS.MeshVS_Drawer_swigregister(MeshVS_Drawer)

class MeshVS_DummySensitiveEntity(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BVH = _swig_new_instance_method(_MeshVS.MeshVS_DummySensitiveEntity_BVH)
    BoundingBox = _swig_new_instance_method(_MeshVS.MeshVS_DummySensitiveEntity_BoundingBox)
    CenterOfGeometry = _swig_new_instance_method(_MeshVS.MeshVS_DummySensitiveEntity_CenterOfGeometry)
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_DummySensitiveEntity_Clear)
    HasInitLocation = _swig_new_instance_method(_MeshVS.MeshVS_DummySensitiveEntity_HasInitLocation)
    InvInitLocation = _swig_new_instance_method(_MeshVS.MeshVS_DummySensitiveEntity_InvInitLocation)
    Matches = _swig_new_instance_method(_MeshVS.MeshVS_DummySensitiveEntity_Matches)

    def __init__(self, *args):
        r"""
        :param theOwnerId:
        	:type theOwnerId: SelectMgr_EntityOwner
        	:rtype: None
        """
        _MeshVS.MeshVS_DummySensitiveEntity_swiginit(self, _MeshVS.new_MeshVS_DummySensitiveEntity(*args))
    NbSubElements = _swig_new_instance_method(_MeshVS.MeshVS_DummySensitiveEntity_NbSubElements)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_DummySensitiveEntity

# Register MeshVS_DummySensitiveEntity in _MeshVS:
_MeshVS.MeshVS_DummySensitiveEntity_swigregister(MeshVS_DummySensitiveEntity)

class MeshVS_Mesh(OCC.Core.AIS.AIS_InteractiveObject):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AcceptDisplayMode = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_AcceptDisplayMode)
    AddBuilder = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_AddBuilder)
    Compute = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_Compute)
    ComputeSelection = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_ComputeSelection)
    FindBuilder = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_FindBuilder)
    GetBuilder = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_GetBuilder)
    GetBuilderById = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_GetBuilderById)
    GetBuildersCount = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_GetBuildersCount)
    GetDataSource = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_GetDataSource)
    GetDrawer = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_GetDrawer)
    GetFreeId = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_GetFreeId)
    GetHiddenElems = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_GetHiddenElems)
    GetHiddenNodes = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_GetHiddenNodes)
    GetHilighter = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_GetHilighter)
    GetMeshSelMethod = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_GetMeshSelMethod)
    GetOwnerMaps = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_GetOwnerMaps)
    GetSelectableNodes = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_GetSelectableNodes)
    IsHiddenElem = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_IsHiddenElem)
    IsHiddenNode = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_IsHiddenNode)
    IsSelectableElem = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_IsSelectableElem)
    IsSelectableNode = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_IsSelectableNode)
    IsWholeMeshOwner = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_IsWholeMeshOwner)

    def __init__(self, *args):
        r"""
        * Constructor. theIsAllowOverlapped is Standard_True, if it is allowed to draw edges overlapped with beams Its value is stored in drawer
        	:param theIsAllowOverlapped: default value is Standard_False
        	:type theIsAllowOverlapped: bool
        	:rtype: None
        """
        _MeshVS.MeshVS_Mesh_swiginit(self, _MeshVS.new_MeshVS_Mesh(*args))
    RemoveBuilder = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_RemoveBuilder)
    RemoveBuilderById = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_RemoveBuilderById)
    SetDataSource = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_SetDataSource)
    SetDrawer = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_SetDrawer)
    SetHiddenElems = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_SetHiddenElems)
    SetHiddenNodes = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_SetHiddenNodes)
    SetHilighter = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_SetHilighter)
    SetHilighterById = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_SetHilighterById)
    SetMeshSelMethod = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_SetMeshSelMethod)
    SetSelectableNodes = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_SetSelectableNodes)
    UpdateSelectableNodes = _swig_new_instance_method(_MeshVS.MeshVS_Mesh_UpdateSelectableNodes)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_Mesh

# Register MeshVS_Mesh in _MeshVS:
_MeshVS.MeshVS_Mesh_swigregister(MeshVS_Mesh)

class MeshVS_MeshEntityOwner(OCC.Core.SelectMgr.SelectMgr_EntityOwner):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    Clear = _swig_new_instance_method(_MeshVS.MeshVS_MeshEntityOwner_Clear)
    ID = _swig_new_instance_method(_MeshVS.MeshVS_MeshEntityOwner_ID)
    IsGroup = _swig_new_instance_method(_MeshVS.MeshVS_MeshEntityOwner_IsGroup)
    IsHilighted = _swig_new_instance_method(_MeshVS.MeshVS_MeshEntityOwner_IsHilighted)

    def __init__(self, *args):
        r"""
        :param SelObj:
        	:type SelObj: SelectMgr_SOPtr
        	:param ID:
        	:type ID: int
        	:param MeshEntity:
        	:type MeshEntity: Standard_Address
        	:param Type:
        	:type Type: MeshVS_EntityType
        	:param Priority: default value is 0
        	:type Priority: int
        	:param IsGroup: default value is Standard_False
        	:type IsGroup: bool
        	:rtype: None
        """
        _MeshVS.MeshVS_MeshEntityOwner_swiginit(self, _MeshVS.new_MeshVS_MeshEntityOwner(*args))
    Owner = _swig_new_instance_method(_MeshVS.MeshVS_MeshEntityOwner_Owner)
    Type = _swig_new_instance_method(_MeshVS.MeshVS_MeshEntityOwner_Type)
    Unhilight = _swig_new_instance_method(_MeshVS.MeshVS_MeshEntityOwner_Unhilight)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_MeshEntityOwner

# Register MeshVS_MeshEntityOwner in _MeshVS:
_MeshVS.MeshVS_MeshEntityOwner_swigregister(MeshVS_MeshEntityOwner)

class MeshVS_MeshOwner(OCC.Core.SelectMgr.SelectMgr_EntityOwner):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AddSelectedEntities = _swig_new_instance_method(_MeshVS.MeshVS_MeshOwner_AddSelectedEntities)
    ClearSelectedEntities = _swig_new_instance_method(_MeshVS.MeshVS_MeshOwner_ClearSelectedEntities)
    GetDataSource = _swig_new_instance_method(_MeshVS.MeshVS_MeshOwner_GetDataSource)
    GetDetectedElements = _swig_new_instance_method(_MeshVS.MeshVS_MeshOwner_GetDetectedElements)
    GetDetectedNodes = _swig_new_instance_method(_MeshVS.MeshVS_MeshOwner_GetDetectedNodes)
    GetSelectedElements = _swig_new_instance_method(_MeshVS.MeshVS_MeshOwner_GetSelectedElements)
    GetSelectedNodes = _swig_new_instance_method(_MeshVS.MeshVS_MeshOwner_GetSelectedNodes)
    IsForcedHilight = _swig_new_instance_method(_MeshVS.MeshVS_MeshOwner_IsForcedHilight)

    def __init__(self, *args):
        r"""
        :param theSelObj:
        	:type theSelObj: SelectMgr_SOPtr
        	:param theDS:
        	:type theDS: MeshVS_DataSource
        	:param thePriority: default value is 0
        	:type thePriority: int
        	:rtype: None
        """
        _MeshVS.MeshVS_MeshOwner_swiginit(self, _MeshVS.new_MeshVS_MeshOwner(*args))
    SetDetectedEntities = _swig_new_instance_method(_MeshVS.MeshVS_MeshOwner_SetDetectedEntities)
    Unhilight = _swig_new_instance_method(_MeshVS.MeshVS_MeshOwner_Unhilight)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_MeshOwner

# Register MeshVS_MeshOwner in _MeshVS:
_MeshVS.MeshVS_MeshOwner_swigregister(MeshVS_MeshOwner)

class MeshVS_PrsBuilder(OCC.Core.Standard.Standard_Transient):
    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")
    __repr__ = _swig_repr
    Build = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_Build)
    CustomBuild = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_CustomBuild)
    CustomSensitiveEntity = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_CustomSensitiveEntity)
    GetDataSource = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_GetDataSource)
    GetDrawer = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_GetDrawer)
    GetFlags = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_GetFlags)
    GetId = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_GetId)
    GetPresentationManager = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_GetPresentationManager)
    GetPriority = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_GetPriority)
    IsExcludingOn = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_IsExcludingOn)
    SetDataSource = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_SetDataSource)
    SetDrawer = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_SetDrawer)
    SetExcluding = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_SetExcluding)
    SetPresentationManager = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_SetPresentationManager)
    TestFlags = _swig_new_instance_method(_MeshVS.MeshVS_PrsBuilder_TestFlags)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_PrsBuilder

# Register MeshVS_PrsBuilder in _MeshVS:
_MeshVS.MeshVS_PrsBuilder_swigregister(MeshVS_PrsBuilder)

class MeshVS_SensitiveFace(OCC.Core.Select3D.Select3D_SensitiveFace):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        :param theOwner:
        	:type theOwner: SelectMgr_EntityOwner
        	:param thePoints:
        	:type thePoints: TColgp_Array1OfPnt
        	:param theSensType: default value is Select3D_TOS_INTERIOR
        	:type theSensType: Select3D_TypeOfSensitivity
        	:rtype: None
        """
        _MeshVS.MeshVS_SensitiveFace_swiginit(self, _MeshVS.new_MeshVS_SensitiveFace(*args))


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_SensitiveFace

# Register MeshVS_SensitiveFace in _MeshVS:
_MeshVS.MeshVS_SensitiveFace_swigregister(MeshVS_SensitiveFace)

class MeshVS_SensitiveMesh(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BoundingBox = _swig_new_instance_method(_MeshVS.MeshVS_SensitiveMesh_BoundingBox)
    CenterOfGeometry = _swig_new_instance_method(_MeshVS.MeshVS_SensitiveMesh_CenterOfGeometry)
    GetConnected = _swig_new_instance_method(_MeshVS.MeshVS_SensitiveMesh_GetConnected)
    GetMode = _swig_new_instance_method(_MeshVS.MeshVS_SensitiveMesh_GetMode)
    Matches = _swig_new_instance_method(_MeshVS.MeshVS_SensitiveMesh_Matches)

    def __init__(self, *args):
        r"""
        :param theOwner:
        	:type theOwner: SelectMgr_EntityOwner
        	:param theMode: default value is 0
        	:type theMode: int
        	:rtype: None
        """
        _MeshVS.MeshVS_SensitiveMesh_swiginit(self, _MeshVS.new_MeshVS_SensitiveMesh(*args))
    NbSubElements = _swig_new_instance_method(_MeshVS.MeshVS_SensitiveMesh_NbSubElements)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_SensitiveMesh

# Register MeshVS_SensitiveMesh in _MeshVS:
_MeshVS.MeshVS_SensitiveMesh_swigregister(MeshVS_SensitiveMesh)

class MeshVS_SensitivePolyhedron(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BoundingBox = _swig_new_instance_method(_MeshVS.MeshVS_SensitivePolyhedron_BoundingBox)
    CenterOfGeometry = _swig_new_instance_method(_MeshVS.MeshVS_SensitivePolyhedron_CenterOfGeometry)
    GetConnected = _swig_new_instance_method(_MeshVS.MeshVS_SensitivePolyhedron_GetConnected)
    Matches = _swig_new_instance_method(_MeshVS.MeshVS_SensitivePolyhedron_Matches)

    def __init__(self, *args):
        r"""
        :param theOwner:
        	:type theOwner: SelectMgr_EntityOwner
        	:param theNodes:
        	:type theNodes: TColgp_Array1OfPnt
        	:param theTopo:
        	:type theTopo: MeshVS_HArray1OfSequenceOfInteger
        	:rtype: None
        """
        _MeshVS.MeshVS_SensitivePolyhedron_swiginit(self, _MeshVS.new_MeshVS_SensitivePolyhedron(*args))
    NbSubElements = _swig_new_instance_method(_MeshVS.MeshVS_SensitivePolyhedron_NbSubElements)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_SensitivePolyhedron

# Register MeshVS_SensitivePolyhedron in _MeshVS:
_MeshVS.MeshVS_SensitivePolyhedron_swigregister(MeshVS_SensitivePolyhedron)

class MeshVS_SensitiveQuad(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    BoundingBox = _swig_new_instance_method(_MeshVS.MeshVS_SensitiveQuad_BoundingBox)
    CenterOfGeometry = _swig_new_instance_method(_MeshVS.MeshVS_SensitiveQuad_CenterOfGeometry)
    GetConnected = _swig_new_instance_method(_MeshVS.MeshVS_SensitiveQuad_GetConnected)
    Matches = _swig_new_instance_method(_MeshVS.MeshVS_SensitiveQuad_Matches)

    def __init__(self, *args):
        r"""
        * Creates a new instance and initializes quadrangle vertices with the given points
        	:param theOwner:
        	:type theOwner: SelectMgr_EntityOwner
        	:param theQuadVerts:
        	:type theQuadVerts: TColgp_Array1OfPnt
        	:rtype: None* Creates a new instance and initializes quadrangle vertices with the given points
        	:param theOwner:
        	:type theOwner: SelectMgr_EntityOwner
        	:param thePnt1:
        	:type thePnt1: gp_Pnt
        	:param thePnt2:
        	:type thePnt2: gp_Pnt
        	:param thePnt3:
        	:type thePnt3: gp_Pnt
        	:param thePnt4:
        	:type thePnt4: gp_Pnt
        	:rtype: None
        """
        _MeshVS.MeshVS_SensitiveQuad_swiginit(self, _MeshVS.new_MeshVS_SensitiveQuad(*args))
    NbSubElements = _swig_new_instance_method(_MeshVS.MeshVS_SensitiveQuad_NbSubElements)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_SensitiveQuad

# Register MeshVS_SensitiveQuad in _MeshVS:
_MeshVS.MeshVS_SensitiveQuad_swigregister(MeshVS_SensitiveQuad)

class MeshVS_SensitiveSegment(OCC.Core.Select3D.Select3D_SensitiveSegment):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def __init__(self, *args):
        r"""
        :param theOwner:
        	:type theOwner: SelectMgr_EntityOwner
        	:param theFirstPnt:
        	:type theFirstPnt: gp_Pnt
        	:param theLastPnt:
        	:type theLastPnt: gp_Pnt
        	:rtype: None
        """
        _MeshVS.MeshVS_SensitiveSegment_swiginit(self, _MeshVS.new_MeshVS_SensitiveSegment(*args))


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_SensitiveSegment

# Register MeshVS_SensitiveSegment in _MeshVS:
_MeshVS.MeshVS_SensitiveSegment_swigregister(MeshVS_SensitiveSegment)

class MeshVS_SymmetricPairHasher(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    HashCode = _swig_new_static_method(_MeshVS.MeshVS_SymmetricPairHasher_HashCode)
    IsEqual = _swig_new_static_method(_MeshVS.MeshVS_SymmetricPairHasher_IsEqual)

    __repr__ = _dumps_object


    def __init__(self):
        _MeshVS.MeshVS_SymmetricPairHasher_swiginit(self, _MeshVS.new_MeshVS_SymmetricPairHasher())
    __swig_destroy__ = _MeshVS.delete_MeshVS_SymmetricPairHasher

# Register MeshVS_SymmetricPairHasher in _MeshVS:
_MeshVS.MeshVS_SymmetricPairHasher_swigregister(MeshVS_SymmetricPairHasher)
MeshVS_SymmetricPairHasher_HashCode = _MeshVS.MeshVS_SymmetricPairHasher_HashCode
MeshVS_SymmetricPairHasher_IsEqual = _MeshVS.MeshVS_SymmetricPairHasher_IsEqual

class MeshVS_Tool(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    CreateAspectFillArea3d = _swig_new_static_method(_MeshVS.MeshVS_Tool_CreateAspectFillArea3d)
    CreateAspectLine3d = _swig_new_static_method(_MeshVS.MeshVS_Tool_CreateAspectLine3d)
    CreateAspectMarker3d = _swig_new_static_method(_MeshVS.MeshVS_Tool_CreateAspectMarker3d)
    CreateAspectText3d = _swig_new_static_method(_MeshVS.MeshVS_Tool_CreateAspectText3d)
    GetAverageNormal = _swig_new_static_method(_MeshVS.MeshVS_Tool_GetAverageNormal)
    GetNormal = _swig_new_static_method(_MeshVS.MeshVS_Tool_GetNormal)

    __repr__ = _dumps_object


    def __init__(self):
        _MeshVS.MeshVS_Tool_swiginit(self, _MeshVS.new_MeshVS_Tool())
    __swig_destroy__ = _MeshVS.delete_MeshVS_Tool

# Register MeshVS_Tool in _MeshVS:
_MeshVS.MeshVS_Tool_swigregister(MeshVS_Tool)
MeshVS_Tool_CreateAspectFillArea3d = _MeshVS.MeshVS_Tool_CreateAspectFillArea3d
MeshVS_Tool_CreateAspectLine3d = _MeshVS.MeshVS_Tool_CreateAspectLine3d
MeshVS_Tool_CreateAspectMarker3d = _MeshVS.MeshVS_Tool_CreateAspectMarker3d
MeshVS_Tool_CreateAspectText3d = _MeshVS.MeshVS_Tool_CreateAspectText3d
MeshVS_Tool_GetAverageNormal = _MeshVS.MeshVS_Tool_GetAverageNormal
MeshVS_Tool_GetNormal = _MeshVS.MeshVS_Tool_GetNormal

class MeshVS_TwoColors(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    r1 = property(_MeshVS.MeshVS_TwoColors_r1_get, _MeshVS.MeshVS_TwoColors_r1_set)
    g1 = property(_MeshVS.MeshVS_TwoColors_g1_get, _MeshVS.MeshVS_TwoColors_g1_set)
    b1 = property(_MeshVS.MeshVS_TwoColors_b1_get, _MeshVS.MeshVS_TwoColors_b1_set)
    r2 = property(_MeshVS.MeshVS_TwoColors_r2_get, _MeshVS.MeshVS_TwoColors_r2_set)
    g2 = property(_MeshVS.MeshVS_TwoColors_g2_get, _MeshVS.MeshVS_TwoColors_g2_set)
    b2 = property(_MeshVS.MeshVS_TwoColors_b2_get, _MeshVS.MeshVS_TwoColors_b2_set)

    __repr__ = _dumps_object


    def __init__(self):
        _MeshVS.MeshVS_TwoColors_swiginit(self, _MeshVS.new_MeshVS_TwoColors())
    __swig_destroy__ = _MeshVS.delete_MeshVS_TwoColors

# Register MeshVS_TwoColors in _MeshVS:
_MeshVS.MeshVS_TwoColors_swigregister(MeshVS_TwoColors)

class MeshVS_TwoNodes(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    First = property(_MeshVS.MeshVS_TwoNodes_First_get, _MeshVS.MeshVS_TwoNodes_First_set)
    Second = property(_MeshVS.MeshVS_TwoNodes_Second_get, _MeshVS.MeshVS_TwoNodes_Second_set)

    def __init__(self, *args):
        r"""
        :param aFirst: default value is 0
        	:type aFirst: int
        	:param aSecond: default value is 0
        	:type aSecond: int
        	:rtype: None
        """
        _MeshVS.MeshVS_TwoNodes_swiginit(self, _MeshVS.new_MeshVS_TwoNodes(*args))

    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_TwoNodes

# Register MeshVS_TwoNodes in _MeshVS:
_MeshVS.MeshVS_TwoNodes_swigregister(MeshVS_TwoNodes)

class MeshVS_DataSource3D(MeshVS_DataSource):
    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")
    __repr__ = _swig_repr
    CreatePrismTopology = _swig_new_static_method(_MeshVS.MeshVS_DataSource3D_CreatePrismTopology)
    CreatePyramidTopology = _swig_new_static_method(_MeshVS.MeshVS_DataSource3D_CreatePyramidTopology)
    GetPrismTopology = _swig_new_instance_method(_MeshVS.MeshVS_DataSource3D_GetPrismTopology)
    GetPyramidTopology = _swig_new_instance_method(_MeshVS.MeshVS_DataSource3D_GetPyramidTopology)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_DataSource3D

# Register MeshVS_DataSource3D in _MeshVS:
_MeshVS.MeshVS_DataSource3D_swigregister(MeshVS_DataSource3D)
MeshVS_DataSource3D_CreatePrismTopology = _MeshVS.MeshVS_DataSource3D_CreatePrismTopology
MeshVS_DataSource3D_CreatePyramidTopology = _MeshVS.MeshVS_DataSource3D_CreatePyramidTopology

class MeshVS_DeformedDataSource(MeshVS_DataSource):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    GetMagnify = _swig_new_instance_method(_MeshVS.MeshVS_DeformedDataSource_GetMagnify)
    GetNonDeformedDataSource = _swig_new_instance_method(_MeshVS.MeshVS_DeformedDataSource_GetNonDeformedDataSource)
    GetVector = _swig_new_instance_method(_MeshVS.MeshVS_DeformedDataSource_GetVector)
    GetVectors = _swig_new_instance_method(_MeshVS.MeshVS_DeformedDataSource_GetVectors)

    def __init__(self, *args):
        r"""
        * Constructor theNonDeformDS is canonical non-deformed data source, by which we are able to calculate deformed mesh geometry theMagnify is coefficient of displacement magnify
        	:param theNonDeformDS:
        	:type theNonDeformDS: MeshVS_DataSource
        	:param theMagnify:
        	:type theMagnify: float
        	:rtype: None
        """
        _MeshVS.MeshVS_DeformedDataSource_swiginit(self, _MeshVS.new_MeshVS_DeformedDataSource(*args))
    SetMagnify = _swig_new_instance_method(_MeshVS.MeshVS_DeformedDataSource_SetMagnify)
    SetNonDeformedDataSource = _swig_new_instance_method(_MeshVS.MeshVS_DeformedDataSource_SetNonDeformedDataSource)
    SetVector = _swig_new_instance_method(_MeshVS.MeshVS_DeformedDataSource_SetVector)
    SetVectors = _swig_new_instance_method(_MeshVS.MeshVS_DeformedDataSource_SetVectors)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_DeformedDataSource

# Register MeshVS_DeformedDataSource in _MeshVS:
_MeshVS.MeshVS_DeformedDataSource_swigregister(MeshVS_DeformedDataSource)

class MeshVS_ElementalColorPrsBuilder(MeshVS_PrsBuilder):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    GetColor1 = _swig_new_instance_method(_MeshVS.MeshVS_ElementalColorPrsBuilder_GetColor1)
    GetColor2 = _swig_new_instance_method(_MeshVS.MeshVS_ElementalColorPrsBuilder_GetColor2)
    GetColors1 = _swig_new_instance_method(_MeshVS.MeshVS_ElementalColorPrsBuilder_GetColors1)
    GetColors2 = _swig_new_instance_method(_MeshVS.MeshVS_ElementalColorPrsBuilder_GetColors2)
    HasColors1 = _swig_new_instance_method(_MeshVS.MeshVS_ElementalColorPrsBuilder_HasColors1)
    HasColors2 = _swig_new_instance_method(_MeshVS.MeshVS_ElementalColorPrsBuilder_HasColors2)

    def __init__(self, *args):
        r"""
        * Constructor
        	:param Parent:
        	:type Parent: MeshVS_Mesh
        	:param Flags: default value is MeshVS_DMF_ElementalColorDataPrs
        	:type Flags: int
        	:param DS: default value is 0
        	:type DS: MeshVS_DataSource
        	:param Id: default value is -1
        	:type Id: int
        	:param Priority: default value is MeshVS_BP_ElemColor
        	:type Priority: int
        	:rtype: None
        """
        _MeshVS.MeshVS_ElementalColorPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_ElementalColorPrsBuilder(*args))
    SetColor1 = _swig_new_instance_method(_MeshVS.MeshVS_ElementalColorPrsBuilder_SetColor1)
    SetColor2 = _swig_new_instance_method(_MeshVS.MeshVS_ElementalColorPrsBuilder_SetColor2)
    SetColors1 = _swig_new_instance_method(_MeshVS.MeshVS_ElementalColorPrsBuilder_SetColors1)
    SetColors2 = _swig_new_instance_method(_MeshVS.MeshVS_ElementalColorPrsBuilder_SetColors2)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_ElementalColorPrsBuilder

# Register MeshVS_ElementalColorPrsBuilder in _MeshVS:
_MeshVS.MeshVS_ElementalColorPrsBuilder_swigregister(MeshVS_ElementalColorPrsBuilder)

class MeshVS_MeshPrsBuilder(MeshVS_PrsBuilder):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AddVolumePrs = _swig_new_static_method(_MeshVS.MeshVS_MeshPrsBuilder_AddVolumePrs)
    BuildElements = _swig_new_instance_method(_MeshVS.MeshVS_MeshPrsBuilder_BuildElements)
    BuildHilightPrs = _swig_new_instance_method(_MeshVS.MeshVS_MeshPrsBuilder_BuildHilightPrs)
    BuildNodes = _swig_new_instance_method(_MeshVS.MeshVS_MeshPrsBuilder_BuildNodes)
    HowManyPrimitives = _swig_new_static_method(_MeshVS.MeshVS_MeshPrsBuilder_HowManyPrimitives)

    def __init__(self, *args):
        r"""
        * Creates builder with certain display mode flags, data source, ID and priority
        	:param Parent:
        	:type Parent: MeshVS_Mesh
        	:param Flags: default value is MeshVS_DMF_OCCMask
        	:type Flags: int
        	:param DS: default value is 0
        	:type DS: MeshVS_DataSource
        	:param Id: default value is -1
        	:type Id: int
        	:param Priority: default value is MeshVS_BP_Mesh
        	:type Priority: int
        	:rtype: None
        """
        _MeshVS.MeshVS_MeshPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_MeshPrsBuilder(*args))


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_MeshPrsBuilder

# Register MeshVS_MeshPrsBuilder in _MeshVS:
_MeshVS.MeshVS_MeshPrsBuilder_swigregister(MeshVS_MeshPrsBuilder)
MeshVS_MeshPrsBuilder_AddVolumePrs = _MeshVS.MeshVS_MeshPrsBuilder_AddVolumePrs
MeshVS_MeshPrsBuilder_HowManyPrimitives = _MeshVS.MeshVS_MeshPrsBuilder_HowManyPrimitives

class MeshVS_NodalColorPrsBuilder(MeshVS_PrsBuilder):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    AddVolumePrs = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_AddVolumePrs)
    GetColor = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_GetColor)
    GetColorMap = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_GetColorMap)
    GetColors = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_GetColors)
    GetInvalidColor = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_GetInvalidColor)
    GetTextureCoord = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_GetTextureCoord)
    GetTextureCoords = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_GetTextureCoords)
    HasColors = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_HasColors)
    IsUseTexture = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_IsUseTexture)

    def __init__(self, *args):
        r"""
        :param Parent:
        	:type Parent: MeshVS_Mesh
        	:param Flags: default value is MeshVS_DMF_NodalColorDataPrs
        	:type Flags: int
        	:param DS: default value is 0
        	:type DS: MeshVS_DataSource
        	:param Id: default value is -1
        	:type Id: int
        	:param Priority: default value is MeshVS_BP_NodalColor
        	:type Priority: int
        	:rtype: None
        """
        _MeshVS.MeshVS_NodalColorPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_NodalColorPrsBuilder(*args))
    SetColor = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_SetColor)
    SetColorMap = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_SetColorMap)
    SetColors = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_SetColors)
    SetInvalidColor = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_SetInvalidColor)
    SetTextureCoord = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_SetTextureCoord)
    SetTextureCoords = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_SetTextureCoords)
    UseTexture = _swig_new_instance_method(_MeshVS.MeshVS_NodalColorPrsBuilder_UseTexture)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_NodalColorPrsBuilder

# Register MeshVS_NodalColorPrsBuilder in _MeshVS:
_MeshVS.MeshVS_NodalColorPrsBuilder_swigregister(MeshVS_NodalColorPrsBuilder)

class MeshVS_TextPrsBuilder(MeshVS_PrsBuilder):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    GetText = _swig_new_instance_method(_MeshVS.MeshVS_TextPrsBuilder_GetText)
    GetTexts = _swig_new_instance_method(_MeshVS.MeshVS_TextPrsBuilder_GetTexts)
    HasTexts = _swig_new_instance_method(_MeshVS.MeshVS_TextPrsBuilder_HasTexts)

    def __init__(self, *args):
        r"""
        :param Parent:
        	:type Parent: MeshVS_Mesh
        	:param Height:
        	:type Height: float
        	:param Color:
        	:type Color: Quantity_Color
        	:param Flags: default value is MeshVS_DMF_TextDataPrs
        	:type Flags: int
        	:param DS: default value is 0
        	:type DS: MeshVS_DataSource
        	:param Id: default value is -1
        	:type Id: int
        	:param Priority: default value is MeshVS_BP_Text
        	:type Priority: int
        	:rtype: None
        """
        _MeshVS.MeshVS_TextPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_TextPrsBuilder(*args))
    SetText = _swig_new_instance_method(_MeshVS.MeshVS_TextPrsBuilder_SetText)
    SetTexts = _swig_new_instance_method(_MeshVS.MeshVS_TextPrsBuilder_SetTexts)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_TextPrsBuilder

# Register MeshVS_TextPrsBuilder in _MeshVS:
_MeshVS.MeshVS_TextPrsBuilder_swigregister(MeshVS_TextPrsBuilder)

class MeshVS_VectorPrsBuilder(MeshVS_PrsBuilder):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr
    DrawVector = _swig_new_instance_method(_MeshVS.MeshVS_VectorPrsBuilder_DrawVector)
    GetMinMaxVectorValue = _swig_new_instance_method(_MeshVS.MeshVS_VectorPrsBuilder_GetMinMaxVectorValue)
    GetVector = _swig_new_instance_method(_MeshVS.MeshVS_VectorPrsBuilder_GetVector)
    GetVectors = _swig_new_instance_method(_MeshVS.MeshVS_VectorPrsBuilder_GetVectors)
    HasVectors = _swig_new_instance_method(_MeshVS.MeshVS_VectorPrsBuilder_HasVectors)

    def __init__(self, *args):
        r"""
        :param Parent:
        	:type Parent: MeshVS_Mesh
        	:param MaxLength:
        	:type MaxLength: float
        	:param VectorColor:
        	:type VectorColor: Quantity_Color
        	:param Flags: default value is MeshVS_DMF_VectorDataPrs
        	:type Flags: int
        	:param DS: default value is 0
        	:type DS: MeshVS_DataSource
        	:param Id: default value is -1
        	:type Id: int
        	:param Priority: default value is MeshVS_BP_Vector
        	:type Priority: int
        	:param IsSimplePrs: default value is Standard_False
        	:type IsSimplePrs: bool
        	:rtype: None
        """
        _MeshVS.MeshVS_VectorPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_VectorPrsBuilder(*args))
    SetSimplePrsMode = _swig_new_instance_method(_MeshVS.MeshVS_VectorPrsBuilder_SetSimplePrsMode)
    SetSimplePrsParams = _swig_new_instance_method(_MeshVS.MeshVS_VectorPrsBuilder_SetSimplePrsParams)
    SetVector = _swig_new_instance_method(_MeshVS.MeshVS_VectorPrsBuilder_SetVector)
    SetVectors = _swig_new_instance_method(_MeshVS.MeshVS_VectorPrsBuilder_SetVectors)
    calculateArrow = _swig_new_static_method(_MeshVS.MeshVS_VectorPrsBuilder_calculateArrow)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshVS.delete_MeshVS_VectorPrsBuilder

# Register MeshVS_VectorPrsBuilder in _MeshVS:
_MeshVS.MeshVS_VectorPrsBuilder_swigregister(MeshVS_VectorPrsBuilder)
MeshVS_VectorPrsBuilder_calculateArrow = _MeshVS.MeshVS_VectorPrsBuilder_calculateArrow

class MeshVS_HArray1OfSequenceOfInteger(MeshVS_Array1OfSequenceOfInteger, 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):
        _MeshVS.MeshVS_HArray1OfSequenceOfInteger_swiginit(self, _MeshVS.new_MeshVS_HArray1OfSequenceOfInteger(*args))
    Array1 = _swig_new_instance_method(_MeshVS.MeshVS_HArray1OfSequenceOfInteger_Array1)
    ChangeArray1 = _swig_new_instance_method(_MeshVS.MeshVS_HArray1OfSequenceOfInteger_ChangeArray1)


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

    __swig_destroy__ = _MeshVS.delete_MeshVS_HArray1OfSequenceOfInteger

# Register MeshVS_HArray1OfSequenceOfInteger in _MeshVS:
_MeshVS.MeshVS_HArray1OfSequenceOfInteger_swigregister(MeshVS_HArray1OfSequenceOfInteger)



