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

"""
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__

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args) -> "ptrdiff_t":
        return _MeshVS.SwigPyIterator___sub__(self, *args)
    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


def process_exception(error: "Standard_Failure", method_name: "std::string", class_name: "std::string") -> "void":
    return _MeshVS.process_exception(error, method_name, class_name)

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

import OCC.Core.Standard
import OCC.Core.NCollection
import OCC.Core.TColgp
import OCC.Core.SelectMgr
import OCC.Core.Graphic3d
import OCC.Core.BVH
import OCC.Core.Quantity
import OCC.Core.TCollection
import OCC.Core.gp
import OCC.Core.TColStd
import OCC.Core.Aspect
import OCC.Core.Image
import OCC.Core.TopLoc
import OCC.Core.Bnd
import OCC.Core.OSD
import OCC.Core.Media
import OCC.Core.Select3D
import OCC.Core.SelectBasics
import OCC.Core.Geom
import OCC.Core.GeomAbs
import OCC.Core.PrsMgr
import OCC.Core.Prs3d
import OCC.Core.Poly
import OCC.Core.TShort
import OCC.Core.V3d
import OCC.Core.TopAbs
import OCC.Core.AIS
import OCC.Core.TopoDS
import OCC.Core.Message
import OCC.Core.StdSelect

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

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


class MeshVS_EntityType(IntEnum):
	MeshVS_ET_NONE = 0
	MeshVS_ET_Node = 1
	MeshVS_ET_0D = 2
	MeshVS_ET_Link = 4
	MeshVS_ET_Face = 8
	MeshVS_ET_Volume = 16
	MeshVS_ET_Element = MeshVS_ET_0D | MeshVS_ET_Link | MeshVS_ET_Face | MeshVS_ET_Volume
	MeshVS_ET_All = MeshVS_ET_Element | MeshVS_ET_Node
MeshVS_ET_NONE = MeshVS_EntityType.MeshVS_ET_NONE
MeshVS_ET_Node = MeshVS_EntityType.MeshVS_ET_Node
MeshVS_ET_0D = MeshVS_EntityType.MeshVS_ET_0D
MeshVS_ET_Link = MeshVS_EntityType.MeshVS_ET_Link
MeshVS_ET_Face = MeshVS_EntityType.MeshVS_ET_Face
MeshVS_ET_Volume = MeshVS_EntityType.MeshVS_ET_Volume
MeshVS_ET_Element = MeshVS_EntityType.MeshVS_ET_Element
MeshVS_ET_All = MeshVS_EntityType.MeshVS_ET_All

class MeshVS_MeshSelectionMethod(IntEnum):
	MeshVS_MSM_PRECISE = 0
	MeshVS_MSM_NODES = 1
	MeshVS_MSM_BOX = 2
MeshVS_MSM_PRECISE = MeshVS_MeshSelectionMethod.MeshVS_MSM_PRECISE
MeshVS_MSM_NODES = MeshVS_MeshSelectionMethod.MeshVS_MSM_NODES
MeshVS_MSM_BOX = MeshVS_MeshSelectionMethod.MeshVS_MSM_BOX

class MeshVS_SelectionModeFlags(IntEnum):
	MeshVS_SMF_Mesh = 0
	MeshVS_SMF_Node = 1
	MeshVS_SMF_0D = 2
	MeshVS_SMF_Link = 4
	MeshVS_SMF_Face = 8
	MeshVS_SMF_Volume = 16
	MeshVS_SMF_Element = MeshVS_SMF_0D | MeshVS_SMF_Link | MeshVS_SMF_Face | MeshVS_SMF_Volume
	MeshVS_SMF_All = MeshVS_SMF_Element | MeshVS_SMF_Node
	MeshVS_SMF_Group = 256
MeshVS_SMF_Mesh = MeshVS_SelectionModeFlags.MeshVS_SMF_Mesh
MeshVS_SMF_Node = MeshVS_SelectionModeFlags.MeshVS_SMF_Node
MeshVS_SMF_0D = MeshVS_SelectionModeFlags.MeshVS_SMF_0D
MeshVS_SMF_Link = MeshVS_SelectionModeFlags.MeshVS_SMF_Link
MeshVS_SMF_Face = MeshVS_SelectionModeFlags.MeshVS_SMF_Face
MeshVS_SMF_Volume = MeshVS_SelectionModeFlags.MeshVS_SMF_Volume
MeshVS_SMF_Element = MeshVS_SelectionModeFlags.MeshVS_SMF_Element
MeshVS_SMF_All = MeshVS_SelectionModeFlags.MeshVS_SMF_All
MeshVS_SMF_Group = MeshVS_SelectionModeFlags.MeshVS_SMF_Group

class MeshVS_DrawerAttribute(IntEnum):
	MeshVS_DA_InteriorStyle = 0
	MeshVS_DA_InteriorColor = 1
	MeshVS_DA_BackInteriorColor = 2
	MeshVS_DA_EdgeColor = 3
	MeshVS_DA_EdgeType = 4
	MeshVS_DA_EdgeWidth = 5
	MeshVS_DA_HatchStyle = 6
	MeshVS_DA_FrontMaterial = 7
	MeshVS_DA_BackMaterial = 8
	MeshVS_DA_BeamType = 9
	MeshVS_DA_BeamWidth = 10
	MeshVS_DA_BeamColor = 11
	MeshVS_DA_MarkerType = 12
	MeshVS_DA_MarkerColor = 13
	MeshVS_DA_MarkerScale = 14
	MeshVS_DA_TextColor = 15
	MeshVS_DA_TextHeight = 16
	MeshVS_DA_TextFont = 17
	MeshVS_DA_TextExpansionFactor = 18
	MeshVS_DA_TextSpace = 19
	MeshVS_DA_TextStyle = 20
	MeshVS_DA_TextDisplayType = 21
	MeshVS_DA_TextTexFont = 22
	MeshVS_DA_TextFontAspect = 23
	MeshVS_DA_VectorColor = 24
	MeshVS_DA_VectorMaxLength = 25
	MeshVS_DA_VectorArrowPart = 26
	MeshVS_DA_IsAllowOverlapped = 27
	MeshVS_DA_Reflection = 28
	MeshVS_DA_ColorReflection = 29
	MeshVS_DA_ShrinkCoeff = 30
	MeshVS_DA_MaxFaceNodes = 31
	MeshVS_DA_ComputeTime = 32
	MeshVS_DA_ComputeSelectionTime = 33
	MeshVS_DA_DisplayNodes = 34
	MeshVS_DA_SelectableAuto = 35
	MeshVS_DA_ShowEdges = 36
	MeshVS_DA_SmoothShading = 37
	MeshVS_DA_SupressBackFaces = 38
	MeshVS_DA_User = 39
MeshVS_DA_InteriorStyle = MeshVS_DrawerAttribute.MeshVS_DA_InteriorStyle
MeshVS_DA_InteriorColor = MeshVS_DrawerAttribute.MeshVS_DA_InteriorColor
MeshVS_DA_BackInteriorColor = MeshVS_DrawerAttribute.MeshVS_DA_BackInteriorColor
MeshVS_DA_EdgeColor = MeshVS_DrawerAttribute.MeshVS_DA_EdgeColor
MeshVS_DA_EdgeType = MeshVS_DrawerAttribute.MeshVS_DA_EdgeType
MeshVS_DA_EdgeWidth = MeshVS_DrawerAttribute.MeshVS_DA_EdgeWidth
MeshVS_DA_HatchStyle = MeshVS_DrawerAttribute.MeshVS_DA_HatchStyle
MeshVS_DA_FrontMaterial = MeshVS_DrawerAttribute.MeshVS_DA_FrontMaterial
MeshVS_DA_BackMaterial = MeshVS_DrawerAttribute.MeshVS_DA_BackMaterial
MeshVS_DA_BeamType = MeshVS_DrawerAttribute.MeshVS_DA_BeamType
MeshVS_DA_BeamWidth = MeshVS_DrawerAttribute.MeshVS_DA_BeamWidth
MeshVS_DA_BeamColor = MeshVS_DrawerAttribute.MeshVS_DA_BeamColor
MeshVS_DA_MarkerType = MeshVS_DrawerAttribute.MeshVS_DA_MarkerType
MeshVS_DA_MarkerColor = MeshVS_DrawerAttribute.MeshVS_DA_MarkerColor
MeshVS_DA_MarkerScale = MeshVS_DrawerAttribute.MeshVS_DA_MarkerScale
MeshVS_DA_TextColor = MeshVS_DrawerAttribute.MeshVS_DA_TextColor
MeshVS_DA_TextHeight = MeshVS_DrawerAttribute.MeshVS_DA_TextHeight
MeshVS_DA_TextFont = MeshVS_DrawerAttribute.MeshVS_DA_TextFont
MeshVS_DA_TextExpansionFactor = MeshVS_DrawerAttribute.MeshVS_DA_TextExpansionFactor
MeshVS_DA_TextSpace = MeshVS_DrawerAttribute.MeshVS_DA_TextSpace
MeshVS_DA_TextStyle = MeshVS_DrawerAttribute.MeshVS_DA_TextStyle
MeshVS_DA_TextDisplayType = MeshVS_DrawerAttribute.MeshVS_DA_TextDisplayType
MeshVS_DA_TextTexFont = MeshVS_DrawerAttribute.MeshVS_DA_TextTexFont
MeshVS_DA_TextFontAspect = MeshVS_DrawerAttribute.MeshVS_DA_TextFontAspect
MeshVS_DA_VectorColor = MeshVS_DrawerAttribute.MeshVS_DA_VectorColor
MeshVS_DA_VectorMaxLength = MeshVS_DrawerAttribute.MeshVS_DA_VectorMaxLength
MeshVS_DA_VectorArrowPart = MeshVS_DrawerAttribute.MeshVS_DA_VectorArrowPart
MeshVS_DA_IsAllowOverlapped = MeshVS_DrawerAttribute.MeshVS_DA_IsAllowOverlapped
MeshVS_DA_Reflection = MeshVS_DrawerAttribute.MeshVS_DA_Reflection
MeshVS_DA_ColorReflection = MeshVS_DrawerAttribute.MeshVS_DA_ColorReflection
MeshVS_DA_ShrinkCoeff = MeshVS_DrawerAttribute.MeshVS_DA_ShrinkCoeff
MeshVS_DA_MaxFaceNodes = MeshVS_DrawerAttribute.MeshVS_DA_MaxFaceNodes
MeshVS_DA_ComputeTime = MeshVS_DrawerAttribute.MeshVS_DA_ComputeTime
MeshVS_DA_ComputeSelectionTime = MeshVS_DrawerAttribute.MeshVS_DA_ComputeSelectionTime
MeshVS_DA_DisplayNodes = MeshVS_DrawerAttribute.MeshVS_DA_DisplayNodes
MeshVS_DA_SelectableAuto = MeshVS_DrawerAttribute.MeshVS_DA_SelectableAuto
MeshVS_DA_ShowEdges = MeshVS_DrawerAttribute.MeshVS_DA_ShowEdges
MeshVS_DA_SmoothShading = MeshVS_DrawerAttribute.MeshVS_DA_SmoothShading
MeshVS_DA_SupressBackFaces = MeshVS_DrawerAttribute.MeshVS_DA_SupressBackFaces
MeshVS_DA_User = MeshVS_DrawerAttribute.MeshVS_DA_User


def Handle_MeshVS_CommonSensitiveEntity_Create() -> "opencascade::handle< MeshVS_CommonSensitiveEntity >":
    return _MeshVS.Handle_MeshVS_CommonSensitiveEntity_Create()

def Handle_MeshVS_CommonSensitiveEntity_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_CommonSensitiveEntity >":
    return _MeshVS.Handle_MeshVS_CommonSensitiveEntity_DownCast(t)

def Handle_MeshVS_CommonSensitiveEntity_IsNull(t: "opencascade::handle< MeshVS_CommonSensitiveEntity > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_CommonSensitiveEntity_IsNull(t)

def Handle_MeshVS_DataSource_Create() -> "opencascade::handle< MeshVS_DataSource >":
    return _MeshVS.Handle_MeshVS_DataSource_Create()

def Handle_MeshVS_DataSource_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_DataSource >":
    return _MeshVS.Handle_MeshVS_DataSource_DownCast(t)

def Handle_MeshVS_DataSource_IsNull(t: "opencascade::handle< MeshVS_DataSource > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_DataSource_IsNull(t)

def Handle_MeshVS_Drawer_Create() -> "opencascade::handle< MeshVS_Drawer >":
    return _MeshVS.Handle_MeshVS_Drawer_Create()

def Handle_MeshVS_Drawer_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_Drawer >":
    return _MeshVS.Handle_MeshVS_Drawer_DownCast(t)

def Handle_MeshVS_Drawer_IsNull(t: "opencascade::handle< MeshVS_Drawer > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_Drawer_IsNull(t)

def Handle_MeshVS_DummySensitiveEntity_Create() -> "opencascade::handle< MeshVS_DummySensitiveEntity >":
    return _MeshVS.Handle_MeshVS_DummySensitiveEntity_Create()

def Handle_MeshVS_DummySensitiveEntity_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_DummySensitiveEntity >":
    return _MeshVS.Handle_MeshVS_DummySensitiveEntity_DownCast(t)

def Handle_MeshVS_DummySensitiveEntity_IsNull(t: "opencascade::handle< MeshVS_DummySensitiveEntity > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_DummySensitiveEntity_IsNull(t)

def Handle_MeshVS_Mesh_Create() -> "opencascade::handle< MeshVS_Mesh >":
    return _MeshVS.Handle_MeshVS_Mesh_Create()

def Handle_MeshVS_Mesh_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_Mesh >":
    return _MeshVS.Handle_MeshVS_Mesh_DownCast(t)

def Handle_MeshVS_Mesh_IsNull(t: "opencascade::handle< MeshVS_Mesh > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_Mesh_IsNull(t)

def Handle_MeshVS_MeshEntityOwner_Create() -> "opencascade::handle< MeshVS_MeshEntityOwner >":
    return _MeshVS.Handle_MeshVS_MeshEntityOwner_Create()

def Handle_MeshVS_MeshEntityOwner_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_MeshEntityOwner >":
    return _MeshVS.Handle_MeshVS_MeshEntityOwner_DownCast(t)

def Handle_MeshVS_MeshEntityOwner_IsNull(t: "opencascade::handle< MeshVS_MeshEntityOwner > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_MeshEntityOwner_IsNull(t)

def Handle_MeshVS_MeshOwner_Create() -> "opencascade::handle< MeshVS_MeshOwner >":
    return _MeshVS.Handle_MeshVS_MeshOwner_Create()

def Handle_MeshVS_MeshOwner_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_MeshOwner >":
    return _MeshVS.Handle_MeshVS_MeshOwner_DownCast(t)

def Handle_MeshVS_MeshOwner_IsNull(t: "opencascade::handle< MeshVS_MeshOwner > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_MeshOwner_IsNull(t)

def Handle_MeshVS_PrsBuilder_Create() -> "opencascade::handle< MeshVS_PrsBuilder >":
    return _MeshVS.Handle_MeshVS_PrsBuilder_Create()

def Handle_MeshVS_PrsBuilder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_PrsBuilder >":
    return _MeshVS.Handle_MeshVS_PrsBuilder_DownCast(t)

def Handle_MeshVS_PrsBuilder_IsNull(t: "opencascade::handle< MeshVS_PrsBuilder > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_PrsBuilder_IsNull(t)

def Handle_MeshVS_SensitiveFace_Create() -> "opencascade::handle< MeshVS_SensitiveFace >":
    return _MeshVS.Handle_MeshVS_SensitiveFace_Create()

def Handle_MeshVS_SensitiveFace_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_SensitiveFace >":
    return _MeshVS.Handle_MeshVS_SensitiveFace_DownCast(t)

def Handle_MeshVS_SensitiveFace_IsNull(t: "opencascade::handle< MeshVS_SensitiveFace > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_SensitiveFace_IsNull(t)

def Handle_MeshVS_SensitiveMesh_Create() -> "opencascade::handle< MeshVS_SensitiveMesh >":
    return _MeshVS.Handle_MeshVS_SensitiveMesh_Create()

def Handle_MeshVS_SensitiveMesh_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_SensitiveMesh >":
    return _MeshVS.Handle_MeshVS_SensitiveMesh_DownCast(t)

def Handle_MeshVS_SensitiveMesh_IsNull(t: "opencascade::handle< MeshVS_SensitiveMesh > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_SensitiveMesh_IsNull(t)

def Handle_MeshVS_SensitivePolyhedron_Create() -> "opencascade::handle< MeshVS_SensitivePolyhedron >":
    return _MeshVS.Handle_MeshVS_SensitivePolyhedron_Create()

def Handle_MeshVS_SensitivePolyhedron_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_SensitivePolyhedron >":
    return _MeshVS.Handle_MeshVS_SensitivePolyhedron_DownCast(t)

def Handle_MeshVS_SensitivePolyhedron_IsNull(t: "opencascade::handle< MeshVS_SensitivePolyhedron > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_SensitivePolyhedron_IsNull(t)

def Handle_MeshVS_SensitiveQuad_Create() -> "opencascade::handle< MeshVS_SensitiveQuad >":
    return _MeshVS.Handle_MeshVS_SensitiveQuad_Create()

def Handle_MeshVS_SensitiveQuad_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_SensitiveQuad >":
    return _MeshVS.Handle_MeshVS_SensitiveQuad_DownCast(t)

def Handle_MeshVS_SensitiveQuad_IsNull(t: "opencascade::handle< MeshVS_SensitiveQuad > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_SensitiveQuad_IsNull(t)

def Handle_MeshVS_SensitiveSegment_Create() -> "opencascade::handle< MeshVS_SensitiveSegment >":
    return _MeshVS.Handle_MeshVS_SensitiveSegment_Create()

def Handle_MeshVS_SensitiveSegment_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_SensitiveSegment >":
    return _MeshVS.Handle_MeshVS_SensitiveSegment_DownCast(t)

def Handle_MeshVS_SensitiveSegment_IsNull(t: "opencascade::handle< MeshVS_SensitiveSegment > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_SensitiveSegment_IsNull(t)

def Handle_MeshVS_DataSource3D_Create() -> "opencascade::handle< MeshVS_DataSource3D >":
    return _MeshVS.Handle_MeshVS_DataSource3D_Create()

def Handle_MeshVS_DataSource3D_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_DataSource3D >":
    return _MeshVS.Handle_MeshVS_DataSource3D_DownCast(t)

def Handle_MeshVS_DataSource3D_IsNull(t: "opencascade::handle< MeshVS_DataSource3D > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_DataSource3D_IsNull(t)

def Handle_MeshVS_DeformedDataSource_Create() -> "opencascade::handle< MeshVS_DeformedDataSource >":
    return _MeshVS.Handle_MeshVS_DeformedDataSource_Create()

def Handle_MeshVS_DeformedDataSource_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_DeformedDataSource >":
    return _MeshVS.Handle_MeshVS_DeformedDataSource_DownCast(t)

def Handle_MeshVS_DeformedDataSource_IsNull(t: "opencascade::handle< MeshVS_DeformedDataSource > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_DeformedDataSource_IsNull(t)

def Handle_MeshVS_ElementalColorPrsBuilder_Create() -> "opencascade::handle< MeshVS_ElementalColorPrsBuilder >":
    return _MeshVS.Handle_MeshVS_ElementalColorPrsBuilder_Create()

def Handle_MeshVS_ElementalColorPrsBuilder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_ElementalColorPrsBuilder >":
    return _MeshVS.Handle_MeshVS_ElementalColorPrsBuilder_DownCast(t)

def Handle_MeshVS_ElementalColorPrsBuilder_IsNull(t: "opencascade::handle< MeshVS_ElementalColorPrsBuilder > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_ElementalColorPrsBuilder_IsNull(t)

def Handle_MeshVS_MeshPrsBuilder_Create() -> "opencascade::handle< MeshVS_MeshPrsBuilder >":
    return _MeshVS.Handle_MeshVS_MeshPrsBuilder_Create()

def Handle_MeshVS_MeshPrsBuilder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_MeshPrsBuilder >":
    return _MeshVS.Handle_MeshVS_MeshPrsBuilder_DownCast(t)

def Handle_MeshVS_MeshPrsBuilder_IsNull(t: "opencascade::handle< MeshVS_MeshPrsBuilder > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_MeshPrsBuilder_IsNull(t)

def Handle_MeshVS_NodalColorPrsBuilder_Create() -> "opencascade::handle< MeshVS_NodalColorPrsBuilder >":
    return _MeshVS.Handle_MeshVS_NodalColorPrsBuilder_Create()

def Handle_MeshVS_NodalColorPrsBuilder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_NodalColorPrsBuilder >":
    return _MeshVS.Handle_MeshVS_NodalColorPrsBuilder_DownCast(t)

def Handle_MeshVS_NodalColorPrsBuilder_IsNull(t: "opencascade::handle< MeshVS_NodalColorPrsBuilder > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_NodalColorPrsBuilder_IsNull(t)

def Handle_MeshVS_TextPrsBuilder_Create() -> "opencascade::handle< MeshVS_TextPrsBuilder >":
    return _MeshVS.Handle_MeshVS_TextPrsBuilder_Create()

def Handle_MeshVS_TextPrsBuilder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_TextPrsBuilder >":
    return _MeshVS.Handle_MeshVS_TextPrsBuilder_DownCast(t)

def Handle_MeshVS_TextPrsBuilder_IsNull(t: "opencascade::handle< MeshVS_TextPrsBuilder > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_TextPrsBuilder_IsNull(t)

def Handle_MeshVS_VectorPrsBuilder_Create() -> "opencascade::handle< MeshVS_VectorPrsBuilder >":
    return _MeshVS.Handle_MeshVS_VectorPrsBuilder_Create()

def Handle_MeshVS_VectorPrsBuilder_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_VectorPrsBuilder >":
    return _MeshVS.Handle_MeshVS_VectorPrsBuilder_DownCast(t)

def Handle_MeshVS_VectorPrsBuilder_IsNull(t: "opencascade::handle< MeshVS_VectorPrsBuilder > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_VectorPrsBuilder_IsNull(t)

def Handle_MeshVS_HArray1OfSequenceOfInteger_Create() -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >":
    return _MeshVS.Handle_MeshVS_HArray1OfSequenceOfInteger_Create()

def Handle_MeshVS_HArray1OfSequenceOfInteger_DownCast(t: "opencascade::handle< Standard_Transient > const &") -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >":
    return _MeshVS.Handle_MeshVS_HArray1OfSequenceOfInteger_DownCast(t)

def Handle_MeshVS_HArray1OfSequenceOfInteger_IsNull(t: "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger > const &") -> "bool":
    return _MeshVS.Handle_MeshVS_HArray1OfSequenceOfInteger_IsNull(t)
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

    def begin(self) -> "NCollection_Array1< NCollection_Sequence< int > >::iterator":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_begin(self)

    def end(self) -> "NCollection_Array1< NCollection_Sequence< int > >::iterator":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_end(self)

    def cbegin(self) -> "NCollection_Array1< NCollection_Sequence< int > >::const_iterator":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_cbegin(self)

    def cend(self) -> "NCollection_Array1< NCollection_Sequence< int > >::const_iterator":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_Array1OfSequenceOfInteger_swiginit(self, _MeshVS.new_MeshVS_Array1OfSequenceOfInteger(*args))

    def Init(self, theValue: "TColStd_SequenceOfInteger") -> "void":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Init(self, theValue)

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Size(self)

    def Length(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Length(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_IsEmpty(self)

    def Lower(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Upper(self)

    def IsDeletable(self) -> "Standard_Boolean":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_IsDeletable(self)

    def IsAllocated(self) -> "Standard_Boolean":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_IsAllocated(self)

    def Assign(self, theOther: "MeshVS_Array1OfSequenceOfInteger") -> "NCollection_Array1< TColStd_SequenceOfInteger > &":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Assign(self, theOther)

    def Move(self, theOther: "MeshVS_Array1OfSequenceOfInteger") -> "NCollection_Array1< TColStd_SequenceOfInteger > &":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Move(self, theOther)

    def Set(self, *args) -> "NCollection_Array1< TColStd_SequenceOfInteger > &":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Set(self, *args)

    def First(self) -> "NCollection_Sequence< int > const &":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_First(self)

    def ChangeFirst(self) -> "NCollection_Sequence< int > &":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_ChangeFirst(self)

    def Last(self) -> "NCollection_Sequence< int > const &":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Last(self)

    def ChangeLast(self) -> "NCollection_Sequence< int > &":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "NCollection_Sequence< int > const &":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "NCollection_Sequence< int > &":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "NCollection_Sequence< int > &":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "TColStd_SequenceOfInteger") -> "void":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_SetValue(self, theIndex, theItem)

    def Resize(self, theLower: "Standard_Integer const", theUpper: "Standard_Integer const", theToCopyData: "Standard_Boolean const") -> "void":
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Resize(self, theLower, theUpper, theToCopyData)
    __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_DataMapOfColorMapOfInteger(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def begin(self) -> "NCollection_DataMap< Quantity_Color,NCollection_Map< int,TColStd_MapIntegerHasher >,Quantity_ColorHasher >::iterator":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_begin(self)

    def end(self) -> "NCollection_DataMap< Quantity_Color,NCollection_Map< int,TColStd_MapIntegerHasher >,Quantity_ColorHasher >::iterator":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_end(self)

    def cbegin(self) -> "NCollection_DataMap< Quantity_Color,NCollection_Map< int,TColStd_MapIntegerHasher >,Quantity_ColorHasher >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_cbegin(self)

    def cend(self) -> "NCollection_DataMap< Quantity_Color,NCollection_Map< int,TColStd_MapIntegerHasher >,Quantity_ColorHasher >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfColorMapOfInteger_swiginit(self, _MeshVS.new_MeshVS_DataMapOfColorMapOfInteger(*args))

    def Exchange(self, theOther: "MeshVS_DataMapOfColorMapOfInteger") -> "void":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Exchange(self, theOther)

    def Assign(self, theOther: "MeshVS_DataMapOfColorMapOfInteger") -> "NCollection_DataMap< Quantity_Color,TColStd_MapOfInteger,Quantity_ColorHasher > &":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_DataMapOfColorMapOfInteger") -> "NCollection_DataMap< Quantity_Color,TColStd_MapOfInteger,Quantity_ColorHasher > &":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Set(self, theOther)

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

    def Bind(self, theKey: "Quantity_Color", theItem: "NCollection_Map< int,NCollection_DefaultHasher< int > > const &") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey: "Quantity_Color", theItem: "NCollection_Map< int,NCollection_DefaultHasher< int > > const &") -> "NCollection_Map< int,NCollection_DefaultHasher< int > > *":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "Quantity_Color") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_IsBound(self, theKey)

    def UnBind(self, theKey: "Quantity_Color") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_UnBind(self, theKey)

    def Seek(self, theKey: "Quantity_Color") -> "NCollection_Map< int,NCollection_DefaultHasher< int > > const *":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Find(self, *args)

    def ChangeSeek(self, theKey: "Quantity_Color") -> "NCollection_Map< int,NCollection_DefaultHasher< int > > *":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "Quantity_Color") -> "NCollection_Map< int,NCollection_DefaultHasher< int > > &":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_ChangeFind(self, theKey)

    def __call__(self, *args) -> "NCollection_Map< int,NCollection_DefaultHasher< int > > &":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Clear(self, *args)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfColorMapOfInteger

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Size(self)

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

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

    def begin(self) -> "NCollection_DataMap< int,opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_begin(self)

    def end(self) -> "NCollection_DataMap< int,opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_swiginit(self, _MeshVS.new_MeshVS_DataMapOfHArray1OfSequenceOfInteger(*args))

    def Exchange(self, theOther: "MeshVS_DataMapOfHArray1OfSequenceOfInteger") -> "void":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Exchange(self, theOther)

    def Assign(self, theOther: "MeshVS_DataMapOfHArray1OfSequenceOfInteger") -> "NCollection_DataMap< Standard_Integer,opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_DataMapOfHArray1OfSequenceOfInteger") -> "NCollection_DataMap< Standard_Integer,opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger > const &") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger > const &") -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger > *":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger > const *":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger > *":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger > &":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_ChangeFind(self, theKey)

    def __call__(self, *args) -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger > &":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Clear(self, *args)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfHArray1OfSequenceOfInteger

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Size(self)

    def Keys(self) -> "PyObject *":
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Keys(self)

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

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

    def begin(self) -> "NCollection_DataMap< int,TCollection_AsciiString,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_begin(self)

    def end(self) -> "NCollection_DataMap< int,TCollection_AsciiString,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,TCollection_AsciiString,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,TCollection_AsciiString,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerAsciiString_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerAsciiString(*args))

    def Exchange(self, theOther: "MeshVS_DataMapOfIntegerAsciiString") -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Exchange(self, theOther)

    def Assign(self, theOther: "MeshVS_DataMapOfIntegerAsciiString") -> "NCollection_DataMap< Standard_Integer,TCollection_AsciiString,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_DataMapOfIntegerAsciiString") -> "NCollection_DataMap< Standard_Integer,TCollection_AsciiString,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "TCollection_AsciiString") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "TCollection_AsciiString") -> "TCollection_AsciiString *":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "TCollection_AsciiString const *":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "TCollection_AsciiString *":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "TCollection_AsciiString &":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_ChangeFind(self, theKey)

    def __call__(self, *args) -> "TCollection_AsciiString &":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Clear(self, *args)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerAsciiString

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Size(self)

    def Keys(self) -> "PyObject *":
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Keys(self)

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

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

    def begin(self) -> "NCollection_DataMap< int,bool,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_begin(self)

    def end(self) -> "NCollection_DataMap< int,bool,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,bool,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,bool,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerBoolean_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerBoolean(*args))

    def Exchange(self, theOther: "MeshVS_DataMapOfIntegerBoolean") -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Exchange(self, theOther)

    def Assign(self, theOther: "MeshVS_DataMapOfIntegerBoolean") -> "NCollection_DataMap< Standard_Integer,Standard_Boolean,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_DataMapOfIntegerBoolean") -> "NCollection_DataMap< Standard_Integer,Standard_Boolean,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "bool const &") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "bool const &") -> "bool *":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "bool const *":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "bool *":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "bool &":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_ChangeFind(self, theKey)

    def __call__(self, *args) -> "bool &":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Clear(self, *args)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerBoolean

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Size(self)

    def Keys(self) -> "PyObject *":
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Keys(self)

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

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

    def begin(self) -> "NCollection_DataMap< int,Quantity_Color,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_begin(self)

    def end(self) -> "NCollection_DataMap< int,Quantity_Color,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,Quantity_Color,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,Quantity_Color,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerColor_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerColor(*args))

    def Exchange(self, theOther: "MeshVS_DataMapOfIntegerColor") -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Exchange(self, theOther)

    def Assign(self, theOther: "MeshVS_DataMapOfIntegerColor") -> "NCollection_DataMap< Standard_Integer,Quantity_Color,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_DataMapOfIntegerColor") -> "NCollection_DataMap< Standard_Integer,Quantity_Color,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "Quantity_Color") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "Quantity_Color") -> "Quantity_Color *":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "Quantity_Color const *":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "Quantity_Color *":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "Quantity_Color &":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_ChangeFind(self, theKey)

    def __call__(self, *args) -> "Quantity_Color &":
        return _MeshVS.MeshVS_DataMapOfIntegerColor___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Clear(self, *args)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerColor

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Size(self)

    def Keys(self) -> "PyObject *":
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Keys(self)

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

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

    def begin(self) -> "NCollection_DataMap< int,Graphic3d_MaterialAspect,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_begin(self)

    def end(self) -> "NCollection_DataMap< int,Graphic3d_MaterialAspect,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,Graphic3d_MaterialAspect,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,Graphic3d_MaterialAspect,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerMaterial_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerMaterial(*args))

    def Exchange(self, theOther: "MeshVS_DataMapOfIntegerMaterial") -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Exchange(self, theOther)

    def Assign(self, theOther: "MeshVS_DataMapOfIntegerMaterial") -> "NCollection_DataMap< Standard_Integer,Graphic3d_MaterialAspect,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_DataMapOfIntegerMaterial") -> "NCollection_DataMap< Standard_Integer,Graphic3d_MaterialAspect,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "Graphic3d_MaterialAspect") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "Graphic3d_MaterialAspect") -> "Graphic3d_MaterialAspect *":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "Graphic3d_MaterialAspect const *":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "Graphic3d_MaterialAspect *":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "Graphic3d_MaterialAspect &":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_ChangeFind(self, theKey)

    def __call__(self, *args) -> "Graphic3d_MaterialAspect &":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Clear(self, *args)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerMaterial

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Size(self)

    def Keys(self) -> "PyObject *":
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Keys(self)

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

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

    def begin(self) -> "NCollection_DataMap< int,opencascade::handle< MeshVS_MeshEntityOwner >,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_begin(self)

    def end(self) -> "NCollection_DataMap< int,opencascade::handle< MeshVS_MeshEntityOwner >,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,opencascade::handle< MeshVS_MeshEntityOwner >,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,opencascade::handle< MeshVS_MeshEntityOwner >,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerMeshEntityOwner(*args))

    def Exchange(self, theOther: "MeshVS_DataMapOfIntegerMeshEntityOwner") -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Exchange(self, theOther)

    def Assign(self, theOther: "MeshVS_DataMapOfIntegerMeshEntityOwner") -> "NCollection_DataMap< Standard_Integer,opencascade::handle< MeshVS_MeshEntityOwner >,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_DataMapOfIntegerMeshEntityOwner") -> "NCollection_DataMap< Standard_Integer,opencascade::handle< MeshVS_MeshEntityOwner >,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "opencascade::handle< MeshVS_MeshEntityOwner > const &") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "opencascade::handle< MeshVS_MeshEntityOwner > const &") -> "opencascade::handle< MeshVS_MeshEntityOwner > *":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "opencascade::handle< MeshVS_MeshEntityOwner > const *":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "opencascade::handle< MeshVS_MeshEntityOwner > *":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "opencascade::handle< MeshVS_MeshEntityOwner > &":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_ChangeFind(self, theKey)

    def __call__(self, *args) -> "opencascade::handle< MeshVS_MeshEntityOwner > &":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Clear(self, *args)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerMeshEntityOwner

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Size(self)

    def Keys(self) -> "PyObject *":
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Keys(self)

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

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

    def begin(self) -> "NCollection_DataMap< int,opencascade::handle< SelectMgr_EntityOwner >,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_begin(self)

    def end(self) -> "NCollection_DataMap< int,opencascade::handle< SelectMgr_EntityOwner >,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,opencascade::handle< SelectMgr_EntityOwner >,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,opencascade::handle< SelectMgr_EntityOwner >,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerOwner_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerOwner(*args))

    def Exchange(self, theOther: "MeshVS_DataMapOfIntegerOwner") -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Exchange(self, theOther)

    def Assign(self, theOther: "MeshVS_DataMapOfIntegerOwner") -> "NCollection_DataMap< Standard_Integer,opencascade::handle< SelectMgr_EntityOwner >,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_DataMapOfIntegerOwner") -> "NCollection_DataMap< Standard_Integer,opencascade::handle< SelectMgr_EntityOwner >,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "opencascade::handle< SelectMgr_EntityOwner > const &") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "opencascade::handle< SelectMgr_EntityOwner > const &") -> "opencascade::handle< SelectMgr_EntityOwner > *":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "opencascade::handle< SelectMgr_EntityOwner > const *":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "opencascade::handle< SelectMgr_EntityOwner > *":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "opencascade::handle< SelectMgr_EntityOwner > &":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_ChangeFind(self, theKey)

    def __call__(self, *args) -> "opencascade::handle< SelectMgr_EntityOwner > &":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Clear(self, *args)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerOwner

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Size(self)

    def Keys(self) -> "PyObject *":
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Keys(self)

# 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

    def begin(self) -> "NCollection_DataMap< int,MeshVS_TwoColors,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_begin(self)

    def end(self) -> "NCollection_DataMap< int,MeshVS_TwoColors,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,MeshVS_TwoColors,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,MeshVS_TwoColors,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerTwoColors_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerTwoColors(*args))

    def Exchange(self, theOther: "MeshVS_DataMapOfIntegerTwoColors") -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Exchange(self, theOther)

    def Assign(self, theOther: "MeshVS_DataMapOfIntegerTwoColors") -> "NCollection_DataMap< Standard_Integer,MeshVS_TwoColors,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_DataMapOfIntegerTwoColors") -> "NCollection_DataMap< Standard_Integer,MeshVS_TwoColors,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "MeshVS_TwoColors") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "MeshVS_TwoColors") -> "MeshVS_TwoColors *":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "MeshVS_TwoColors const *":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "MeshVS_TwoColors *":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "MeshVS_TwoColors &":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_ChangeFind(self, theKey)

    def __call__(self, *args) -> "MeshVS_TwoColors &":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Clear(self, *args)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerTwoColors

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Size(self)

    def Keys(self) -> "PyObject *":
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Keys(self)

# 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

    def begin(self) -> "NCollection_DataMap< int,gp_Vec,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_begin(self)

    def end(self) -> "NCollection_DataMap< int,gp_Vec,NCollection_DefaultHasher< int > >::iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_end(self)

    def cbegin(self) -> "NCollection_DataMap< int,gp_Vec,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_cbegin(self)

    def cend(self) -> "NCollection_DataMap< int,gp_Vec,NCollection_DefaultHasher< int > >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfIntegerVector_swiginit(self, _MeshVS.new_MeshVS_DataMapOfIntegerVector(*args))

    def Exchange(self, theOther: "MeshVS_DataMapOfIntegerVector") -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Exchange(self, theOther)

    def Assign(self, theOther: "MeshVS_DataMapOfIntegerVector") -> "NCollection_DataMap< Standard_Integer,gp_Vec,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_DataMapOfIntegerVector") -> "NCollection_DataMap< Standard_Integer,gp_Vec,TColStd_MapIntegerHasher > &":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Set(self, theOther)

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

    def Bind(self, theKey: "int const &", theItem: "gp_Vec") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Bind(self, theKey, theItem)

    def Bound(self, theKey: "int const &", theItem: "gp_Vec") -> "gp_Vec *":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Bound(self, theKey, theItem)

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

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

    def Seek(self, theKey: "int const &") -> "gp_Vec const *":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Find(self, *args)

    def ChangeSeek(self, theKey: "int const &") -> "gp_Vec *":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "int const &") -> "gp_Vec &":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_ChangeFind(self, theKey)

    def __call__(self, *args) -> "gp_Vec &":
        return _MeshVS.MeshVS_DataMapOfIntegerVector___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Clear(self, *args)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfIntegerVector

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Size(self)

    def Keys(self) -> "PyObject *":
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Keys(self)

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

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

    def begin(self) -> "NCollection_DataMap< MeshVS_TwoColors,NCollection_Map< int,TColStd_MapIntegerHasher >,MeshVS_TwoColorsHasher >::iterator":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_begin(self)

    def end(self) -> "NCollection_DataMap< MeshVS_TwoColors,NCollection_Map< int,TColStd_MapIntegerHasher >,MeshVS_TwoColorsHasher >::iterator":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_end(self)

    def cbegin(self) -> "NCollection_DataMap< MeshVS_TwoColors,NCollection_Map< int,TColStd_MapIntegerHasher >,MeshVS_TwoColorsHasher >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_cbegin(self)

    def cend(self) -> "NCollection_DataMap< MeshVS_TwoColors,NCollection_Map< int,TColStd_MapIntegerHasher >,MeshVS_TwoColorsHasher >::const_iterator":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_swiginit(self, _MeshVS.new_MeshVS_DataMapOfTwoColorsMapOfInteger(*args))

    def Exchange(self, theOther: "MeshVS_DataMapOfTwoColorsMapOfInteger") -> "void":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Exchange(self, theOther)

    def Assign(self, theOther: "MeshVS_DataMapOfTwoColorsMapOfInteger") -> "NCollection_DataMap< MeshVS_TwoColors,TColStd_MapOfInteger,MeshVS_TwoColorsHasher > &":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_DataMapOfTwoColorsMapOfInteger") -> "NCollection_DataMap< MeshVS_TwoColors,TColStd_MapOfInteger,MeshVS_TwoColorsHasher > &":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Set(self, theOther)

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

    def Bind(self, theKey: "MeshVS_TwoColors", theItem: "NCollection_Map< int,NCollection_DefaultHasher< int > > const &") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey: "MeshVS_TwoColors", theItem: "NCollection_Map< int,NCollection_DefaultHasher< int > > const &") -> "NCollection_Map< int,NCollection_DefaultHasher< int > > *":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey: "MeshVS_TwoColors") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_IsBound(self, theKey)

    def UnBind(self, theKey: "MeshVS_TwoColors") -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_UnBind(self, theKey)

    def Seek(self, theKey: "MeshVS_TwoColors") -> "NCollection_Map< int,NCollection_DefaultHasher< int > > const *":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Seek(self, theKey)

    def Find(self, *args) -> "Standard_Boolean":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Find(self, *args)

    def ChangeSeek(self, theKey: "MeshVS_TwoColors") -> "NCollection_Map< int,NCollection_DefaultHasher< int > > *":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey: "MeshVS_TwoColors") -> "NCollection_Map< int,NCollection_DefaultHasher< int > > &":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_ChangeFind(self, theKey)

    def __call__(self, *args) -> "NCollection_Map< int,NCollection_DefaultHasher< int > > &":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger___call__(self, *args)

    def Clear(self, *args) -> "void":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Clear(self, *args)
    __swig_destroy__ = _MeshVS.delete_MeshVS_DataMapOfTwoColorsMapOfInteger

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Size(self)

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

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

    def cbegin(self) -> "NCollection_Map< MeshVS_TwoNodes,MeshVS_TwoNodesHasher >::const_iterator":
        return _MeshVS.MeshVS_MapOfTwoNodes_cbegin(self)

    def cend(self) -> "NCollection_Map< MeshVS_TwoNodes,MeshVS_TwoNodesHasher >::const_iterator":
        return _MeshVS.MeshVS_MapOfTwoNodes_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_MapOfTwoNodes_swiginit(self, _MeshVS.new_MeshVS_MapOfTwoNodes(*args))

    def Exchange(self, theOther: "MeshVS_MapOfTwoNodes") -> "void":
        return _MeshVS.MeshVS_MapOfTwoNodes_Exchange(self, theOther)

    def Assign(self, theOther: "MeshVS_MapOfTwoNodes") -> "NCollection_Map< MeshVS_TwoNodes,MeshVS_TwoNodesHasher > &":
        return _MeshVS.MeshVS_MapOfTwoNodes_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_MapOfTwoNodes") -> "NCollection_Map< MeshVS_TwoNodes,MeshVS_TwoNodesHasher > &":
        return _MeshVS.MeshVS_MapOfTwoNodes_Set(self, theOther)

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

    def Add(self, K: "MeshVS_TwoNodes") -> "Standard_Boolean":
        return _MeshVS.MeshVS_MapOfTwoNodes_Add(self, K)

    def Added(self, K: "MeshVS_TwoNodes") -> "MeshVS_TwoNodes const &":
        return _MeshVS.MeshVS_MapOfTwoNodes_Added(self, K)

    def Remove(self, K: "MeshVS_TwoNodes") -> "Standard_Boolean":
        return _MeshVS.MeshVS_MapOfTwoNodes_Remove(self, K)

    def Clear(self, *args) -> "void":
        return _MeshVS.MeshVS_MapOfTwoNodes_Clear(self, *args)
    __swig_destroy__ = _MeshVS.delete_MeshVS_MapOfTwoNodes

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_MapOfTwoNodes_Size(self)

    def IsEqual(self, theOther: "MeshVS_MapOfTwoNodes") -> "Standard_Boolean":
        return _MeshVS.MeshVS_MapOfTwoNodes_IsEqual(self, theOther)

    def Contains(self, *args) -> "Standard_Boolean":
        return _MeshVS.MeshVS_MapOfTwoNodes_Contains(self, *args)

    def Union(self, theLeft: "MeshVS_MapOfTwoNodes", theRight: "MeshVS_MapOfTwoNodes") -> "void":
        return _MeshVS.MeshVS_MapOfTwoNodes_Union(self, theLeft, theRight)

    def Unite(self, theOther: "MeshVS_MapOfTwoNodes") -> "Standard_Boolean":
        return _MeshVS.MeshVS_MapOfTwoNodes_Unite(self, theOther)

    def HasIntersection(self, theMap: "MeshVS_MapOfTwoNodes") -> "Standard_Boolean":
        return _MeshVS.MeshVS_MapOfTwoNodes_HasIntersection(self, theMap)

    def Intersection(self, theLeft: "MeshVS_MapOfTwoNodes", theRight: "MeshVS_MapOfTwoNodes") -> "void":
        return _MeshVS.MeshVS_MapOfTwoNodes_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther: "MeshVS_MapOfTwoNodes") -> "Standard_Boolean":
        return _MeshVS.MeshVS_MapOfTwoNodes_Intersect(self, theOther)

    def Subtraction(self, theLeft: "MeshVS_MapOfTwoNodes", theRight: "MeshVS_MapOfTwoNodes") -> "void":
        return _MeshVS.MeshVS_MapOfTwoNodes_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther: "MeshVS_MapOfTwoNodes") -> "Standard_Boolean":
        return _MeshVS.MeshVS_MapOfTwoNodes_Subtract(self, theOther)

    def Difference(self, theLeft: "MeshVS_MapOfTwoNodes", theRight: "MeshVS_MapOfTwoNodes") -> "void":
        return _MeshVS.MeshVS_MapOfTwoNodes_Difference(self, theLeft, theRight)

    def Differ(self, theOther: "MeshVS_MapOfTwoNodes") -> "Standard_Boolean":
        return _MeshVS.MeshVS_MapOfTwoNodes_Differ(self, theOther)

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

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

    def begin(self) -> "NCollection_List< opencascade::handle< TColgp_HArray1OfPnt > >::iterator":
        return _MeshVS.MeshVS_PolyhedronVerts_begin(self)

    def end(self) -> "NCollection_List< opencascade::handle< TColgp_HArray1OfPnt > >::iterator":
        return _MeshVS.MeshVS_PolyhedronVerts_end(self)

    def cbegin(self) -> "NCollection_List< opencascade::handle< TColgp_HArray1OfPnt > >::const_iterator":
        return _MeshVS.MeshVS_PolyhedronVerts_cbegin(self)

    def cend(self) -> "NCollection_List< opencascade::handle< TColgp_HArray1OfPnt > >::const_iterator":
        return _MeshVS.MeshVS_PolyhedronVerts_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_PolyhedronVerts_swiginit(self, _MeshVS.new_MeshVS_PolyhedronVerts(*args))

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_PolyhedronVerts_Size(self)

    def Assign(self, theOther: "MeshVS_PolyhedronVerts") -> "NCollection_List< opencascade::handle< TColgp_HArray1OfPnt > > &":
        return _MeshVS.MeshVS_PolyhedronVerts_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_PolyhedronVerts") -> "NCollection_List< opencascade::handle< TColgp_HArray1OfPnt > > &":
        return _MeshVS.MeshVS_PolyhedronVerts_Set(self, theOther)

    def Clear(self, theAllocator: "opencascade::handle< NCollection_BaseAllocator > const &"=0) -> "void":
        return _MeshVS.MeshVS_PolyhedronVerts_Clear(self, theAllocator)

    def First(self) -> "opencascade::handle< TColgp_HArray1OfPnt > const &":
        return _MeshVS.MeshVS_PolyhedronVerts_First(self)

    def Last(self) -> "opencascade::handle< TColgp_HArray1OfPnt > const &":
        return _MeshVS.MeshVS_PolyhedronVerts_Last(self)

    def Append(self, *args) -> "void":
        return _MeshVS.MeshVS_PolyhedronVerts_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _MeshVS.MeshVS_PolyhedronVerts_Prepend(self, *args)

    def RemoveFirst(self) -> "void":
        return _MeshVS.MeshVS_PolyhedronVerts_RemoveFirst(self)

    def Remove(self, theIter: "NCollection_List< opencascade::handle< TColgp_HArray1OfPnt > >::Iterator &") -> "void":
        return _MeshVS.MeshVS_PolyhedronVerts_Remove(self, theIter)

    def InsertBefore(self, *args) -> "void":
        return _MeshVS.MeshVS_PolyhedronVerts_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _MeshVS.MeshVS_PolyhedronVerts_InsertAfter(self, *args)

    def Reverse(self) -> "void":
        return _MeshVS.MeshVS_PolyhedronVerts_Reverse(self)
    __swig_destroy__ = _MeshVS.delete_MeshVS_PolyhedronVerts

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


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

    def More(self) -> "Standard_Boolean":
        return _MeshVS.MeshVS_PolyhedronVertsIter_More(self)

    def Next(self) -> "void":
        return _MeshVS.MeshVS_PolyhedronVertsIter_Next(self)

    def Value(self) -> "MeshVS_PolyhedronVerts const &":
        return _MeshVS.MeshVS_PolyhedronVertsIter_Value(self)

    def ChangeValue(self) -> "MeshVS_PolyhedronVerts &":
        return _MeshVS.MeshVS_PolyhedronVertsIter_ChangeValue(self)
    __swig_destroy__ = _MeshVS.delete_MeshVS_PolyhedronVertsIter

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

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

    def begin(self) -> "NCollection_Sequence< opencascade::handle< MeshVS_PrsBuilder > >::iterator":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_begin(self)

    def end(self) -> "NCollection_Sequence< opencascade::handle< MeshVS_PrsBuilder > >::iterator":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_end(self)

    def cbegin(self) -> "NCollection_Sequence< opencascade::handle< MeshVS_PrsBuilder > >::const_iterator":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_cbegin(self)

    def cend(self) -> "NCollection_Sequence< opencascade::handle< MeshVS_PrsBuilder > >::const_iterator":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_cend(self)

    def __init__(self, *args):
        _MeshVS.MeshVS_SequenceOfPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_SequenceOfPrsBuilder(*args))

    def Size(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Size(self)

    def Length(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Length(self)

    def Lower(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Lower(self)

    def Upper(self) -> "Standard_Integer":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Upper(self)

    def IsEmpty(self) -> "Standard_Boolean":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_IsEmpty(self)

    def Reverse(self) -> "void":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Reverse(self)

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

    @staticmethod
    def delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_delNode(theNode, theAl)

    def Clear(self, theAllocator: "opencascade::handle< NCollection_BaseAllocator > const &"=0) -> "void":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Clear(self, theAllocator)

    def Assign(self, theOther: "MeshVS_SequenceOfPrsBuilder") -> "NCollection_Sequence< opencascade::handle< MeshVS_PrsBuilder > > &":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Assign(self, theOther)

    def Set(self, theOther: "MeshVS_SequenceOfPrsBuilder") -> "NCollection_Sequence< opencascade::handle< MeshVS_PrsBuilder > > &":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Set(self, theOther)

    def Remove(self, *args) -> "void":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Remove(self, *args)

    def Append(self, *args) -> "void":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Append(self, *args)

    def Prepend(self, *args) -> "void":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Prepend(self, *args)

    def InsertBefore(self, *args) -> "void":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_InsertBefore(self, *args)

    def InsertAfter(self, *args) -> "void":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_InsertAfter(self, *args)

    def Split(self, theIndex: "Standard_Integer const", theSeq: "MeshVS_SequenceOfPrsBuilder") -> "void":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Split(self, theIndex, theSeq)

    def First(self) -> "opencascade::handle< MeshVS_PrsBuilder > const &":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_First(self)

    def ChangeFirst(self) -> "opencascade::handle< MeshVS_PrsBuilder > &":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_ChangeFirst(self)

    def Last(self) -> "opencascade::handle< MeshVS_PrsBuilder > const &":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Last(self)

    def ChangeLast(self) -> "opencascade::handle< MeshVS_PrsBuilder > &":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_ChangeLast(self)

    def Value(self, theIndex: "Standard_Integer const") -> "opencascade::handle< MeshVS_PrsBuilder > const &":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Value(self, theIndex)

    def ChangeValue(self, theIndex: "Standard_Integer const") -> "opencascade::handle< MeshVS_PrsBuilder > &":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_ChangeValue(self, theIndex)

    def __call__(self, *args) -> "opencascade::handle< MeshVS_PrsBuilder > &":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder___call__(self, *args)

    def SetValue(self, theIndex: "Standard_Integer const", theItem: "opencascade::handle< MeshVS_PrsBuilder > const &") -> "void":
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_SetValue(self, theIndex, theItem)
    __swig_destroy__ = _MeshVS.delete_MeshVS_SequenceOfPrsBuilder

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


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

def MeshVS_SequenceOfPrsBuilder_delNode(theNode: "NCollection_SeqNode *", theAl: "opencascade::handle< NCollection_BaseAllocator > &") -> "void":
    return _MeshVS.MeshVS_SequenceOfPrsBuilder_delNode(theNode, theAl)

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

    @staticmethod
    def HashCode(theKey: "MeshVS_TwoColors", theUpperBound: "Standard_Integer const") -> "Standard_Integer":
        return _MeshVS.MeshVS_TwoColorsHasher_HashCode(theKey, theUpperBound)

    @staticmethod
    def IsEqual(theKey1: "MeshVS_TwoColors", theKey2: "MeshVS_TwoColors") -> "Standard_Boolean":
        return _MeshVS.MeshVS_TwoColorsHasher_IsEqual(theKey1, theKey2)

    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)

def MeshVS_TwoColorsHasher_HashCode(theKey: "MeshVS_TwoColors", theUpperBound: "Standard_Integer const") -> "Standard_Integer":
    return _MeshVS.MeshVS_TwoColorsHasher_HashCode(theKey, theUpperBound)

def MeshVS_TwoColorsHasher_IsEqual(theKey1: "MeshVS_TwoColors", theKey2: "MeshVS_TwoColors") -> "Standard_Boolean":
    return _MeshVS.MeshVS_TwoColorsHasher_IsEqual(theKey1, theKey2)

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

    @staticmethod
    def HashCode(theKey: "MeshVS_TwoNodes", theUpperBound: "Standard_Integer const") -> "Standard_Integer":
        return _MeshVS.MeshVS_TwoNodesHasher_HashCode(theKey, theUpperBound)

    @staticmethod
    def IsEqual(theKey1: "MeshVS_TwoNodes", theKey2: "MeshVS_TwoNodes") -> "Standard_Boolean":
        return _MeshVS.MeshVS_TwoNodesHasher_IsEqual(theKey1, theKey2)

    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)

def MeshVS_TwoNodesHasher_HashCode(theKey: "MeshVS_TwoNodes", theUpperBound: "Standard_Integer const") -> "Standard_Integer":
    return _MeshVS.MeshVS_TwoNodesHasher_HashCode(theKey, theUpperBound)

def MeshVS_TwoNodesHasher_IsEqual(theKey1: "MeshVS_TwoNodes", theKey2: "MeshVS_TwoNodes") -> "Standard_Boolean":
    return _MeshVS.MeshVS_TwoNodesHasher_IsEqual(theKey1, theKey2)

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.

        Parameters
        ----------
        theSize: Standard_Size

        Returns
        -------
        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

    def __init__(self, *args):
        r"""
        Default constructor.

        Parameters
        ----------
        theOwner: SelectMgr_EntityOwner
        theParentMesh: MeshVS_Mesh
        theSelMethod: MeshVS_MeshSelectionMethod

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_CommonSensitiveEntity_swiginit(self, _MeshVS.new_MeshVS_CommonSensitiveEntity(*args))

    def BoundingBox(self, *args) -> "Select3D_BndBox3d":
        r"""
        Returns bounding box of the triangulation. if location transformation is set, it will be applied.

        Returns
        -------
        Select3D_BndBox3d

        """
        return _MeshVS.MeshVS_CommonSensitiveEntity_BoundingBox(self, *args)

    def Box(self, *args) -> "Select3D_BndBox3d":
        r"""
        Returns bounding box of sub-entity with index theidx in sub-entity list.

        Parameters
        ----------
        theIdx: int

        Returns
        -------
        Select3D_BndBox3d

        """
        return _MeshVS.MeshVS_CommonSensitiveEntity_Box(self, *args)

    def Center(self, *args) -> "Standard_Real":
        r"""
        Returns geometry center of sensitive entity index theidx along the given axis theaxis.

        Parameters
        ----------
        theIdx: int
        theAxis: int

        Returns
        -------
        float

        """
        return _MeshVS.MeshVS_CommonSensitiveEntity_Center(self, *args)

    def CenterOfGeometry(self, *args) -> "gp_Pnt":
        r"""
        Returns center of a mesh.

        Returns
        -------
        gp_Pnt

        """
        return _MeshVS.MeshVS_CommonSensitiveEntity_CenterOfGeometry(self, *args)

    def GetConnected(self, *args) -> "opencascade::handle< Select3D_SensitiveEntity >":
        r"""
        Create a copy.

        Returns
        -------
        opencascade::handle<Select3D_SensitiveEntity>

        """
        return _MeshVS.MeshVS_CommonSensitiveEntity_GetConnected(self, *args)

    def NbSubElements(self, *args) -> "Standard_Integer":
        r"""
        Number of elements.

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_CommonSensitiveEntity_NbSubElements(self, *args)

    def Size(self, *args) -> "Standard_Integer":
        r"""
        Returns the amount of sub-entities of the complex entity.

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_CommonSensitiveEntity_Size(self, *args)

    def Swap(self, *args) -> "void":
        r"""
        Swaps items with indexes theidx1 and theidx2.

        Parameters
        ----------
        theIdx1: int
        theIdx2: int

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_CommonSensitiveEntity_Swap(self, *args)


    @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

    def Get3DGeom(self, *args) -> "Standard_Boolean":
        r"""
        This method returns topology information about 3d-element returns false if element with id isn't 3d or because other troubles.

        Parameters
        ----------
        ID: int
        Data: MeshVS_HArray1OfSequenceOfInteger

        Returns
        -------
        NbNodes: int

        """
        return _MeshVS.MeshVS_DataSource_Get3DGeom(self, *args)

    def GetAddr(self, *args) -> "Standard_Address":
        r"""
        This method returns pointer which represents element or node data structure. this address will be saved in meshvs_meshentityowner, so that you can access to data structure fast by the method owner(). in the redefined method you can return null. id is the numerical identificator of node or element iselement indicates this id describe node ( if standard_false ) or element ( if standard_true ).

        Parameters
        ----------
        ID: int
        IsElement: bool

        Returns
        -------
        Standard_Address

        """
        return _MeshVS.MeshVS_DataSource_GetAddr(self, *args)

    def GetAllElements(self, *args) -> "TColStd_PackedMapOfInteger const &":
        r"""
        This method returns map of all elements the object consist of.

        Returns
        -------
        TColStd_PackedMapOfInteger

        """
        return _MeshVS.MeshVS_DataSource_GetAllElements(self, *args)

    def GetAllGroups(self, *args) -> "void":
        r"""
        This method returns map of all groups the object contains.

        Parameters
        ----------
        Ids: TColStd_PackedMapOfInteger

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_DataSource_GetAllGroups(self, *args)

    def GetAllNodes(self, *args) -> "TColStd_PackedMapOfInteger const &":
        r"""
        This method returns map of all nodes the object consist of.

        Returns
        -------
        TColStd_PackedMapOfInteger

        """
        return _MeshVS.MeshVS_DataSource_GetAllNodes(self, *args)

    def GetBoundingBox(self, *args) -> "Bnd_Box":
        r"""
        Returns the bounding box of the whole mesh. it is used in advanced selection mode to define roughly the sensitive area of the mesh. it can be redefined to get access to a box computed in advance.

        Returns
        -------
        Bnd_Box

        """
        return _MeshVS.MeshVS_DataSource_GetBoundingBox(self, *args)

    def GetDetectedEntities(self, *args) -> "Standard_Boolean":
        r"""
        Returns maps of entities (nodes and elements) detected by mouse click at the point (x,y) on the current view plane, with the tolerance atol. dmin - is out argument should return actual detection tolerance. returns true if something is detected. it should be redefined if the advanced mesh selection is activated. default implementation returns false.

        Parameters
        ----------
        Prs: MeshVS_Mesh
        X: float
        Y: float
        aTol: float
        Nodes: TColStd_HPackedMapOfInteger
        Elements: TColStd_HPackedMapOfInteger

        Returns
        -------
        DMin: float
        Returns maps of entities (nodes and elements) detected by mouse selection with rectangular box (xmin, ymin, xmax, ymax) on the current veiw plane, with the tolerance atol. returns true if something is detected. it should be redefined if the advanced mesh selection is activated. default implementation returns false.

        Parameters
        ----------
        Prs: MeshVS_Mesh
        XMin: float
        YMin: float
        XMax: float
        YMax: float
        aTol: float
        Nodes: TColStd_HPackedMapOfInteger
        Elements: TColStd_HPackedMapOfInteger

        Returns
        -------
        bool
        Returns maps of entities (nodes and elements) detected by mouse selection with the polyline <polyline> on the current veiw plane, with the tolerance atol. returns true if something is detected. it should be redefined if the advanced mesh selection is activated. default implementation returns false.

        Parameters
        ----------
        Prs: MeshVS_Mesh
        Polyline: TColgp_Array1OfPnt2d
        aBox: Bnd_Box2d
        aTol: float
        Nodes: TColStd_HPackedMapOfInteger
        Elements: TColStd_HPackedMapOfInteger

        Returns
        -------
        bool
        Filter out the maps of mesh entities so as to keep only the entities that are allowed to be selected according to the current context. returns true if any of the maps has been changed. it should be redefined if the advanced mesh selection is activated. default implementation returns false.

        Parameters
        ----------
        Prs: MeshVS_Mesh
        Nodes: TColStd_HPackedMapOfInteger
        Elements: TColStd_HPackedMapOfInteger

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_DataSource_GetDetectedEntities(self, *args)

    def GetGeom(self, *args) -> "Standard_Boolean":
        r"""
        Returns geometry information about node or element id is the numerical identificator of node or element iselement indicates this id describe node ( if standard_false ) or element ( if standard_true ) coords is an array of co-ordinates of node(s). for node it is only 3 numbers: x, y, z in the strict order for element it is 3*n numbers, where n is number of this element vertices the order is strict also: x1, y1, z1, x2,...., where xi, yi, zi are co-ordinates of vertices nbnodes is number of nodes. it is recommended this parameter to be set to 1 for node. type is type of node or element (from enumeration). it is recommended this parameter to be set to meshvs_et_node for node.

        Parameters
        ----------
        ID: int
        IsElement: bool
        Coords: TColStd_Array1OfReal
        Type: MeshVS_EntityType

        Returns
        -------
        NbNodes: int

        """
        return _MeshVS.MeshVS_DataSource_GetGeom(self, *args)

    def GetGeomType(self, *args) -> "Standard_Boolean":
        r"""
        This method is similar to getgeom, but returns only element or node type.

        Parameters
        ----------
        ID: int
        IsElement: bool
        Type: MeshVS_EntityType

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_DataSource_GetGeomType(self, *args)

    def GetGroup(self, *args) -> "Standard_Boolean":
        r"""
        This method returns map of all group elements.

        Parameters
        ----------
        Id: int
        Type: MeshVS_EntityType
        Ids: TColStd_PackedMapOfInteger

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_DataSource_GetGroup(self, *args)

    def GetGroupAddr(self, *args) -> "Standard_Address":
        r"""
        This method returns pointer which represents group data structure. this address will be saved in meshvs_meshowner, so that you can access to data structure fast by the method owner(). in the redefined method you can return null. id is the numerical identificator of group.

        Parameters
        ----------
        ID: int

        Returns
        -------
        Standard_Address

        """
        return _MeshVS.MeshVS_DataSource_GetGroupAddr(self, *args)

    def GetNodeNormal(self, *args) -> "Standard_Boolean":
        r"""
        This method return normal of node ranknode of face id, which is using for smooth shading presentation. returns false if normal isn't defined.

        Parameters
        ----------
        ranknode: int
        ElementId: int

        Returns
        -------
        nx: float
        ny: float
        nz: float

        """
        return _MeshVS.MeshVS_DataSource_GetNodeNormal(self, *args)

    def GetNodesByElement(self, *args) -> "Standard_Boolean":
        r"""
        This method returns information about nodes this element consist of. id is the numerical identificator of element. nodeids is the output array of nodes ids in correct order, the same as coordinates returned by getgeom(). nbnodes is number of nodes (number of items set in nodeids). returns false if element does not exist.

        Parameters
        ----------
        ID: int
        NodeIDs: TColStd_Array1OfInteger

        Returns
        -------
        NbNodes: int

        """
        return _MeshVS.MeshVS_DataSource_GetNodesByElement(self, *args)

    def GetNormal(self, *args) -> "Standard_Boolean":
        r"""
        This method calculates normal of face, which is using for correct reflection presentation. there is default method, for advance reflection this method can be redefined. id is the numerical identificator of only element! max is maximal number of nodes an element can consist of nx, ny, nz are values whose represent co-ordinates of normal (will be returned) in the redefined method you can return normal with length more then 1, but in this case the appearance of element will be more bright than usual. for ordinary brightness you must return normal with length 1.

        Parameters
        ----------
        Id: int
        Max: int

        Returns
        -------
        nx: float
        ny: float
        nz: float

        """
        return _MeshVS.MeshVS_DataSource_GetNormal(self, *args)

    def GetNormalsByElement(self, *args) -> "Standard_Boolean":
        r"""
        This method puts components of normal vectors at each node of a mesh face (at each face of a mesh volume) into the output array. returns false if some problem was detected during calculation of normals. id is an identifier of the mesh element. isnodal, when true, means that normals at mesh element nodes are needed. if nodal normals are not available, or isnodal is false, or the mesh element is a volume, then the output array contents depend on the element type: face: a normal calculated by getnormal() is duplicated for each node of the face; volume: normals to all faces of the volume are computed (not for each node!). maxnodes is maximal number of nodes an element can consist of. normals contains the result.

        Parameters
        ----------
        Id: int
        IsNodal: bool
        MaxNodes: int
        Normals: TColStd_HArray1OfReal

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_DataSource_GetNormalsByElement(self, *args)

    def IsAdvancedSelectionEnabled(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if advanced mesh selection is enabled. default implementation returns false. it should be redefined to return true for advanced mesh selection activation.

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_DataSource_IsAdvancedSelectionEnabled(self, *args)


    @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

    def Assign(self, *args) -> "void":
        r"""
        This method copies other drawer contents to this.

        Parameters
        ----------
        aDrawer: MeshVS_Drawer

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Drawer_Assign(self, *args)

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

        Parameters
        ----------
        Key: int
        Value: TCollection_AsciiString

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Drawer_GetAsciiString(self, *args)

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

        Parameters
        ----------
        Key: int

        Returns
        -------
        Value: bool

        """
        return _MeshVS.MeshVS_Drawer_GetBoolean(self, *args)

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

        Parameters
        ----------
        Key: int
        Value: Quantity_Color

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Drawer_GetColor(self, *args)

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

        Parameters
        ----------
        Key: int

        Returns
        -------
        Value: float

        """
        return _MeshVS.MeshVS_Drawer_GetDouble(self, *args)

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

        Parameters
        ----------
        Key: int

        Returns
        -------
        Value: int

        """
        return _MeshVS.MeshVS_Drawer_GetInteger(self, *args)

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

        Parameters
        ----------
        Key: int
        Value: Graphic3d_MaterialAspect

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Drawer_GetMaterial(self, *args)

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

        Parameters
        ----------
        Key: int

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Drawer_RemoveAsciiString(self, *args)

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

        Parameters
        ----------
        Key: int

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Drawer_RemoveBoolean(self, *args)

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

        Parameters
        ----------
        Key: int

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Drawer_RemoveColor(self, *args)

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

        Parameters
        ----------
        Key: int

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Drawer_RemoveDouble(self, *args)

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

        Parameters
        ----------
        Key: int

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Drawer_RemoveInteger(self, *args)

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

        Parameters
        ----------
        Key: int

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Drawer_RemoveMaterial(self, *args)

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

        Parameters
        ----------
        Key: int
        Value: TCollection_AsciiString

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Drawer_SetAsciiString(self, *args)

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

        Parameters
        ----------
        Key: int
        Value: bool

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Drawer_SetBoolean(self, *args)

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

        Parameters
        ----------
        Key: int
        Value: Quantity_Color

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Drawer_SetColor(self, *args)

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

        Parameters
        ----------
        Key: int
        Value: float

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Drawer_SetDouble(self, *args)

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

        Parameters
        ----------
        Key: int
        Value: int

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Drawer_SetInteger(self, *args)

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

        Parameters
        ----------
        Key: int
        Value: Graphic3d_MaterialAspect

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Drawer_SetMaterial(self, *args)


    @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

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        theOwnerId: SelectMgr_EntityOwner

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_DummySensitiveEntity_swiginit(self, _MeshVS.new_MeshVS_DummySensitiveEntity(*args))

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

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_DummySensitiveEntity_BVH(self, *args)

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

        Returns
        -------
        Select3D_BndBox3d

        """
        return _MeshVS.MeshVS_DummySensitiveEntity_BoundingBox(self, *args)

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

        Returns
        -------
        gp_Pnt

        """
        return _MeshVS.MeshVS_DummySensitiveEntity_CenterOfGeometry(self, *args)

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

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_DummySensitiveEntity_Clear(self, *args)

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

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_DummySensitiveEntity_HasInitLocation(self, *args)

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

        Returns
        -------
        gp_GTrsf

        """
        return _MeshVS.MeshVS_DummySensitiveEntity_InvInitLocation(self, *args)

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

        Parameters
        ----------
        theMgr: SelectBasics_SelectingVolumeManager
        thePickResult: SelectBasics_PickResult

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_DummySensitiveEntity_Matches(self, *args)

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

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_DummySensitiveEntity_NbSubElements(self, *args)

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

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_DummySensitiveEntity_ToBuildBVH(self, *args)


    @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

    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.

        Parameters
        ----------
        theIsAllowOverlapped: bool,optional
        	default value is Standard_False

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_Mesh_swiginit(self, _MeshVS.new_MeshVS_Mesh(*args))

    def AddBuilder(self, *args) -> "void":
        r"""
        Adds builder to tale of sequence. prsbuilder is builder to be added if treatashilighter is true, meshvs_mesh will use this builder to create presentation of hilighted and selected owners. only one builder can be hilighter, so that if you call this method with treatashilighter = standard_true some times, only last builder will be hilighter warning: as minimum one builder must be added as hilighter, otherwise selection cannot be computed.

        Parameters
        ----------
        Builder: MeshVS_PrsBuilder
        TreatAsHilighter: bool,optional
        	default value is Standard_False

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Mesh_AddBuilder(self, *args)

    def Compute(self, *args) -> "void":
        r"""
        Computes presentation using builders added to sequence. each builder computes own part of mesh presentation according to its type.

        Parameters
        ----------
        PM: PrsMgr_PresentationManager3d
        Prs: Prs3d_Presentation
        DisplayMode: int

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Mesh_Compute(self, *args)

    def FindBuilder(self, *args) -> "opencascade::handle< MeshVS_PrsBuilder >":
        r"""
        Finds builder by its type the string represents.

        Parameters
        ----------
        TypeString: char *

        Returns
        -------
        opencascade::handle<MeshVS_PrsBuilder>

        """
        return _MeshVS.MeshVS_Mesh_FindBuilder(self, *args)

    def GetBuilder(self, *args) -> "opencascade::handle< MeshVS_PrsBuilder >":
        r"""
        Returns builder by its index in sequence.

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

        Returns
        -------
        opencascade::handle<MeshVS_PrsBuilder>

        """
        return _MeshVS.MeshVS_Mesh_GetBuilder(self, *args)

    def GetBuilderById(self, *args) -> "opencascade::handle< MeshVS_PrsBuilder >":
        r"""
        Returns builder by its id.

        Parameters
        ----------
        Id: int

        Returns
        -------
        opencascade::handle<MeshVS_PrsBuilder>

        """
        return _MeshVS.MeshVS_Mesh_GetBuilderById(self, *args)

    def GetBuildersCount(self, *args) -> "Standard_Integer":
        r"""
        How many builders there are in sequence.

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_Mesh_GetBuildersCount(self, *args)

    def GetDataSource(self, *args) -> "opencascade::handle< MeshVS_DataSource >":
        r"""
        Returns default builders' data source.

        Returns
        -------
        opencascade::handle<MeshVS_DataSource>

        """
        return _MeshVS.MeshVS_Mesh_GetDataSource(self, *args)

    def GetDrawer(self, *args) -> "opencascade::handle< MeshVS_Drawer >":
        r"""
        Returns default builders' drawer.

        Returns
        -------
        opencascade::handle<MeshVS_Drawer>

        """
        return _MeshVS.MeshVS_Mesh_GetDrawer(self, *args)

    def GetFreeId(self, *args) -> "Standard_Integer":
        r"""
        Returns the smallest positive id, not occupied by any builder. this method using when builder is created with id = -1.

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_Mesh_GetFreeId(self, *args)

    def GetHiddenElems(self, *args) -> "opencascade::handle< TColStd_HPackedMapOfInteger > const &":
        r"""
        Returns map of hidden elements (may be null handle).

        Returns
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        """
        return _MeshVS.MeshVS_Mesh_GetHiddenElems(self, *args)

    def GetHiddenNodes(self, *args) -> "opencascade::handle< TColStd_HPackedMapOfInteger > const &":
        r"""
        Returns map of hidden nodes (may be null handle).

        Returns
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        """
        return _MeshVS.MeshVS_Mesh_GetHiddenNodes(self, *args)

    def GetHilighter(self, *args) -> "opencascade::handle< MeshVS_PrsBuilder >":
        r"""
        Returns hilighter.

        Returns
        -------
        opencascade::handle<MeshVS_PrsBuilder>

        """
        return _MeshVS.MeshVS_Mesh_GetHilighter(self, *args)

    def GetMeshSelMethod(self, *args) -> "MeshVS_MeshSelectionMethod":
        r"""
        Returns set mesh selection method (see meshvs.cdl).

        Returns
        -------
        MeshVS_MeshSelectionMethod

        """
        return _MeshVS.MeshVS_Mesh_GetMeshSelMethod(self, *args)

    def GetOwnerMaps(self, *args) -> "MeshVS_DataMapOfIntegerOwner const &":
        r"""
        Returns map of owners.

        Parameters
        ----------
        IsElement: bool

        Returns
        -------
        MeshVS_DataMapOfIntegerOwner

        """
        return _MeshVS.MeshVS_Mesh_GetOwnerMaps(self, *args)

    def GetSelectableNodes(self, *args) -> "opencascade::handle< TColStd_HPackedMapOfInteger > const &":
        r"""
        Returns map of selectable elements (may be null handle).

        Returns
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        """
        return _MeshVS.MeshVS_Mesh_GetSelectableNodes(self, *args)

    def IsHiddenElem(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if specified element is hidden by default no elements are hidden.

        Parameters
        ----------
        ID: int

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Mesh_IsHiddenElem(self, *args)

    def IsHiddenNode(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if specified node is hidden. by default all nodes are hidden.

        Parameters
        ----------
        ID: int

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Mesh_IsHiddenNode(self, *args)

    def IsSelectableElem(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if specified element is not hidden.

        Parameters
        ----------
        ID: int

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Mesh_IsSelectableElem(self, *args)

    def IsSelectableNode(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if specified node is specified as selectable.

        Parameters
        ----------
        ID: int

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Mesh_IsSelectableNode(self, *args)

    def IsWholeMeshOwner(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if the given owner represents a whole mesh.

        Parameters
        ----------
        theOwner: SelectMgr_EntityOwner

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Mesh_IsWholeMeshOwner(self, *args)

    def RemoveBuilder(self, *args) -> "void":
        r"""
        Removes builder from sequence. if it is hilighter, hilighter will be null ( don't remember to set it to other after!!! ).

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

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Mesh_RemoveBuilder(self, *args)

    def RemoveBuilderById(self, *args) -> "void":
        r"""
        Removes builder with identificator id.

        Parameters
        ----------
        Id: int

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Mesh_RemoveBuilderById(self, *args)

    def SetDataSource(self, *args) -> "void":
        r"""
        Sets default builders' data source.

        Parameters
        ----------
        aDataSource: MeshVS_DataSource

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Mesh_SetDataSource(self, *args)

    def SetDrawer(self, *args) -> "void":
        r"""
        Sets default builders' drawer.

        Parameters
        ----------
        aDrawer: MeshVS_Drawer

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Mesh_SetDrawer(self, *args)

    def SetHiddenElems(self, *args) -> "void":
        r"""
        Sets map of hidden elements.

        Parameters
        ----------
        Ids: TColStd_HPackedMapOfInteger

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Mesh_SetHiddenElems(self, *args)

    def SetHiddenNodes(self, *args) -> "void":
        r"""
        Sets map of hidden nodes, which shall not be displayed individually. if nodes shared by some elements shall not be drawn, they should be included into that map.

        Parameters
        ----------
        Ids: TColStd_HPackedMapOfInteger

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Mesh_SetHiddenNodes(self, *args)

    def SetHilighter(self, *args) -> "Standard_Boolean":
        r"""
        Changes hilighter ( see above ).

        Parameters
        ----------
        Builder: MeshVS_PrsBuilder

        Returns
        -------
        None
        Sets builder with sequence index 'index' as hilighter.

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

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Mesh_SetHilighter(self, *args)

    def SetHilighterById(self, *args) -> "Standard_Boolean":
        r"""
        Sets builder with identificator 'id' as hilighter.

        Parameters
        ----------
        Id: int

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Mesh_SetHilighterById(self, *args)

    def SetMeshSelMethod(self, *args) -> "void":
        r"""
        Sets mesh selection method (see meshvs.cdl).

        Parameters
        ----------
        M: MeshVS_MeshSelectionMethod

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Mesh_SetMeshSelMethod(self, *args)

    def SetSelectableNodes(self, *args) -> "void":
        r"""
        Sets map of selectable nodes.

        Parameters
        ----------
        Ids: TColStd_HPackedMapOfInteger

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Mesh_SetSelectableNodes(self, *args)

    def UpdateSelectableNodes(self, *args) -> "void":
        r"""
        Automatically computes selectable nodes; the node is considered as being selectable if it is either not hidden, or is hidden but referred by at least one non-hidden element. thus all nodes that are visible (either individually, or as ends or corners of elements) are selectable by default.

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_Mesh_UpdateSelectableNodes(self, *args)


    @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

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        SelObj: SelectMgr_SelectableObject *
        ID: int
        MeshEntity: Standard_Address
        Type: MeshVS_EntityType
        Priority: int,optional
        	default value is 0
        IsGroup: bool,optional
        	default value is Standard_False

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_MeshEntityOwner_swiginit(self, _MeshVS.new_MeshVS_MeshEntityOwner(*args))

    def ID(self, *args) -> "Standard_Integer":
        r"""
        Returns id of element or node data structure.

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_MeshEntityOwner_ID(self, *args)

    def IsGroup(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if owner represents group of nodes or elements.

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_MeshEntityOwner_IsGroup(self, *args)

    def Owner(self, *args) -> "Standard_Address":
        r"""
        Returns an address of element or node data structure.

        Returns
        -------
        Standard_Address

        """
        return _MeshVS.MeshVS_MeshEntityOwner_Owner(self, *args)

    def Type(self, *args) -> "MeshVS_EntityType":
        r"""
        Returns type of element or node data structure.

        Returns
        -------
        MeshVS_EntityType

        """
        return _MeshVS.MeshVS_MeshEntityOwner_Type(self, *args)


    @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

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        theSelObj: SelectMgr_SelectableObject *
        theDS: MeshVS_DataSource
        thePriority: int,optional
        	default value is 0

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_MeshOwner_swiginit(self, _MeshVS.new_MeshVS_MeshOwner(*args))

    def AddSelectedEntities(self, *args) -> "void":
        r"""
        Saves ids of selected mesh entities.

        Parameters
        ----------
        Nodes: TColStd_HPackedMapOfInteger
        Elems: TColStd_HPackedMapOfInteger

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_MeshOwner_AddSelectedEntities(self, *args)

    def ClearSelectedEntities(self, *args) -> "void":
        r"""
        Clears ids of selected mesh entities.

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_MeshOwner_ClearSelectedEntities(self, *args)

    def GetDataSource(self, *args) -> "opencascade::handle< MeshVS_DataSource > const &":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<MeshVS_DataSource>

        """
        return _MeshVS.MeshVS_MeshOwner_GetDataSource(self, *args)

    def GetDetectedElements(self, *args) -> "opencascade::handle< TColStd_HPackedMapOfInteger > const &":
        r"""
        Returns ids of hilighted mesh elements.

        Returns
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        """
        return _MeshVS.MeshVS_MeshOwner_GetDetectedElements(self, *args)

    def GetDetectedNodes(self, *args) -> "opencascade::handle< TColStd_HPackedMapOfInteger > const &":
        r"""
        Returns ids of hilighted mesh nodes.

        Returns
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        """
        return _MeshVS.MeshVS_MeshOwner_GetDetectedNodes(self, *args)

    def GetSelectedElements(self, *args) -> "opencascade::handle< TColStd_HPackedMapOfInteger > const &":
        r"""
        Returns ids of selected mesh elements.

        Returns
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        """
        return _MeshVS.MeshVS_MeshOwner_GetSelectedElements(self, *args)

    def GetSelectedNodes(self, *args) -> "opencascade::handle< TColStd_HPackedMapOfInteger > const &":
        r"""
        Returns ids of selected mesh nodes.

        Returns
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        """
        return _MeshVS.MeshVS_MeshOwner_GetSelectedNodes(self, *args)

    def SetDetectedEntities(self, *args) -> "void":
        r"""
        Saves ids of hilighted mesh entities.

        Parameters
        ----------
        Nodes: TColStd_HPackedMapOfInteger
        Elems: TColStd_HPackedMapOfInteger

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_MeshOwner_SetDetectedEntities(self, *args)


    @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

    def Build(self, *args) -> "void":
        r"""
        Builds presentation of certain type of data. prs is presentation object which this method constructs. ids is set of numeric identificators forming object appearance. idstoexclude is set of ids to exclude from processing. if some entity has been excluded, it is not processed by other builders. iselement indicates, ids is identificators of nodes or elements. displaymode is numeric constant describing display mode (see meshvs_displaymodeflags.hxx).

        Parameters
        ----------
        Prs: Prs3d_Presentation
        IDs: TColStd_PackedMapOfInteger
        IDsToExclude: TColStd_PackedMapOfInteger
        IsElement: bool
        DisplayMode: int

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_PrsBuilder_Build(self, *args)

    def CustomBuild(self, *args) -> "void":
        r"""
        This method is called to build presentation of custom elements (they have meshvs_et_0d type). ids is set of numeric identificators of elements for custom building. idstoexclude is set of ids to exclude from processing. if some entity has been excluded, it is not processed by other builders. displaymode is numeric constant describing display mode (see meshvs_displaymodeflags.hxx).

        Parameters
        ----------
        Prs: Prs3d_Presentation
        IDs: TColStd_PackedMapOfInteger
        IDsToExclude: TColStd_PackedMapOfInteger
        DisplayMode: int

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_PrsBuilder_CustomBuild(self, *args)

    def CustomSensitiveEntity(self, *args) -> "opencascade::handle< Select3D_SensitiveEntity >":
        r"""
        This method is called to build sensitive of custom elements ( they have meshvs_et_0d type ).

        Parameters
        ----------
        Owner: SelectMgr_EntityOwner
        SelectMode: int

        Returns
        -------
        opencascade::handle<Select3D_SensitiveEntity>

        """
        return _MeshVS.MeshVS_PrsBuilder_CustomSensitiveEntity(self, *args)

    def GetDataSource(self, *args) -> "opencascade::handle< MeshVS_DataSource >":
        r"""
        Returns custom data source or default ( from meshvs_mesh ) if custom is null.

        Returns
        -------
        opencascade::handle<MeshVS_DataSource>

        """
        return _MeshVS.MeshVS_PrsBuilder_GetDataSource(self, *args)

    def GetDrawer(self, *args) -> "opencascade::handle< MeshVS_Drawer >":
        r"""
        Returns custom drawer or default ( from meshvs_mesh ) if custom is null.

        Returns
        -------
        opencascade::handle<MeshVS_Drawer>

        """
        return _MeshVS.MeshVS_PrsBuilder_GetDrawer(self, *args)

    def GetFlags(self, *args) -> "Standard_Integer":
        r"""
        Returns flags, assigned with builder during creation.

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_PrsBuilder_GetFlags(self, *args)

    def GetId(self, *args) -> "Standard_Integer":
        r"""
        Returns builder id.

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_PrsBuilder_GetId(self, *args)

    def GetPresentationManager(self, *args) -> "opencascade::handle< PrsMgr_PresentationManager3d >":
        r"""
        Get presentation manager of builder.

        Returns
        -------
        opencascade::handle<PrsMgr_PresentationManager3d>

        """
        return _MeshVS.MeshVS_PrsBuilder_GetPresentationManager(self, *args)

    def GetPriority(self, *args) -> "Standard_Integer":
        r"""
        Returns priority; as priority bigger, as soon builder will be called.

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_PrsBuilder_GetPriority(self, *args)

    def IsExcludingOn(self, *args) -> "Standard_Boolean":
        r"""
        Read excluding state.

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_PrsBuilder_IsExcludingOn(self, *args)

    def SetDataSource(self, *args) -> "void":
        r"""
        Change custom data source.

        Parameters
        ----------
        newDS: MeshVS_DataSource

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_PrsBuilder_SetDataSource(self, *args)

    def SetDrawer(self, *args) -> "void":
        r"""
        Change custom drawer.

        Parameters
        ----------
        newDr: MeshVS_Drawer

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_PrsBuilder_SetDrawer(self, *args)

    def SetExcluding(self, *args) -> "void":
        r"""
        Set excluding state. if it is standard_true, the nodes or elements, processed by current builder will be noted and next builder won't process its.

        Parameters
        ----------
        state: bool

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_PrsBuilder_SetExcluding(self, *args)

    def SetPresentationManager(self, *args) -> "void":
        r"""
        Set presentation manager for builder.

        Parameters
        ----------
        thePrsMgr: PrsMgr_PresentationManager3d

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_PrsBuilder_SetPresentationManager(self, *args)

    def TestFlags(self, *args) -> "Standard_Boolean":
        r"""
        Test whether display mode has flags assigned with this builder. this method has default implementation and can be redefined for advance behavior returns standard_true only if display mode is appropriate for this builder.

        Parameters
        ----------
        DisplayMode: int

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_PrsBuilder_TestFlags(self, *args)


    @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"""
        No available documentation.

        Parameters
        ----------
        theOwner: SelectMgr_EntityOwner
        thePoints: TColgp_Array1OfPnt
        theSensType: Select3D_TypeOfSensitivity,optional
        	default value is Select3D_TOS_INTERIOR

        Returns
        -------
        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

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        theOwner: SelectMgr_EntityOwner
        theMode: int,optional
        	default value is 0

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_SensitiveMesh_swiginit(self, _MeshVS.new_MeshVS_SensitiveMesh(*args))

    def BoundingBox(self, *args) -> "Select3D_BndBox3d":
        r"""
        Returns bounding box of mesh.

        Returns
        -------
        Select3D_BndBox3d

        """
        return _MeshVS.MeshVS_SensitiveMesh_BoundingBox(self, *args)

    def CenterOfGeometry(self, *args) -> "gp_Pnt":
        r"""
        Returns center of mesh.

        Returns
        -------
        gp_Pnt

        """
        return _MeshVS.MeshVS_SensitiveMesh_CenterOfGeometry(self, *args)

    def GetConnected(self, *args) -> "opencascade::handle< Select3D_SensitiveEntity >":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<Select3D_SensitiveEntity>

        """
        return _MeshVS.MeshVS_SensitiveMesh_GetConnected(self, *args)

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

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_SensitiveMesh_GetMode(self, *args)

    def Matches(self, *args) -> "Standard_Boolean":
        r"""
        Checks whether sensitive overlaps current selecting volume.

        Parameters
        ----------
        theMgr: SelectBasics_SelectingVolumeManager
        thePickResult: SelectBasics_PickResult

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_SensitiveMesh_Matches(self, *args)

    def NbSubElements(self, *args) -> "Standard_Integer":
        r"""
        Returns the amount of mesh nodes.

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_SensitiveMesh_NbSubElements(self, *args)


    @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

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        theOwner: SelectMgr_EntityOwner
        theNodes: TColgp_Array1OfPnt
        theTopo: MeshVS_HArray1OfSequenceOfInteger

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_SensitivePolyhedron_swiginit(self, _MeshVS.new_MeshVS_SensitivePolyhedron(*args))

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

        Returns
        -------
        Select3D_BndBox3d

        """
        return _MeshVS.MeshVS_SensitivePolyhedron_BoundingBox(self, *args)

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

        Returns
        -------
        gp_Pnt

        """
        return _MeshVS.MeshVS_SensitivePolyhedron_CenterOfGeometry(self, *args)

    def GetConnected(self, *args) -> "opencascade::handle< Select3D_SensitiveEntity >":
        r"""
        No available documentation.

        Returns
        -------
        opencascade::handle<Select3D_SensitiveEntity>

        """
        return _MeshVS.MeshVS_SensitivePolyhedron_GetConnected(self, *args)

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

        Parameters
        ----------
        theMgr: SelectBasics_SelectingVolumeManager
        thePickResult: SelectBasics_PickResult

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_SensitivePolyhedron_Matches(self, *args)

    def NbSubElements(self, *args) -> "Standard_Integer":
        r"""
        Returns the amount of nodes of polyhedron.

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_SensitivePolyhedron_NbSubElements(self, *args)


    @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

    def __init__(self, *args):
        r"""
        Creates a new instance and initializes quadrangle vertices with the given points.

        Parameters
        ----------
        theOwner: SelectMgr_EntityOwner
        theQuadVerts: TColgp_Array1OfPnt

        Returns
        -------
        None
        Creates a new instance and initializes quadrangle vertices with the given points.

        Parameters
        ----------
        theOwner: SelectMgr_EntityOwner
        thePnt1: gp_Pnt
        thePnt2: gp_Pnt
        thePnt3: gp_Pnt
        thePnt4: gp_Pnt

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_SensitiveQuad_swiginit(self, _MeshVS.new_MeshVS_SensitiveQuad(*args))

    def BoundingBox(self, *args) -> "Select3D_BndBox3d":
        r"""
        Returns coordinates of the box.

        Returns
        -------
        Select3D_BndBox3d

        """
        return _MeshVS.MeshVS_SensitiveQuad_BoundingBox(self, *args)

    def CenterOfGeometry(self, *args) -> "gp_Pnt":
        r"""
        Returns center of the box.

        Returns
        -------
        gp_Pnt

        """
        return _MeshVS.MeshVS_SensitiveQuad_CenterOfGeometry(self, *args)

    def GetConnected(self, *args) -> "opencascade::handle< Select3D_SensitiveEntity >":
        r"""
        Returns a copy of this sensitive quadrangle.

        Returns
        -------
        opencascade::handle<Select3D_SensitiveEntity>

        """
        return _MeshVS.MeshVS_SensitiveQuad_GetConnected(self, *args)

    def Matches(self, *args) -> "Standard_Boolean":
        r"""
        Checks whether the box overlaps current selecting volume.

        Parameters
        ----------
        theMgr: SelectBasics_SelectingVolumeManager
        thePickResult: SelectBasics_PickResult

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_SensitiveQuad_Matches(self, *args)

    def NbSubElements(self, *args) -> "Standard_Integer":
        r"""
        Returns the amount of sub-entities in sensitive.

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_SensitiveQuad_NbSubElements(self, *args)


    @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"""
        No available documentation.

        Parameters
        ----------
        theOwner: SelectMgr_EntityOwner
        theFirstPnt: gp_Pnt
        theLastPnt: gp_Pnt

        Returns
        -------
        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

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

        Parameters
        ----------
        theNodePair: MeshVS_NodePair
        theUpperBound: int

        Returns
        -------
        int

        """
        return _MeshVS.MeshVS_SymmetricPairHasher_HashCode(*args)

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

        Parameters
        ----------
        thePair1: MeshVS_NodePair
        thePair2: MeshVS_NodePair

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_SymmetricPairHasher_IsEqual(*args)

    __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)

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

    Parameters
    ----------
    theNodePair: MeshVS_NodePair
    theUpperBound: int

    Returns
    -------
    int

    """
    return _MeshVS.MeshVS_SymmetricPairHasher_HashCode(*args)

def MeshVS_SymmetricPairHasher_IsEqual(*args) -> "Standard_Boolean":
    r"""
    No available documentation.

    Parameters
    ----------
    thePair1: MeshVS_NodePair
    thePair2: MeshVS_NodePair

    Returns
    -------
    bool

    """
    return _MeshVS.MeshVS_SymmetricPairHasher_IsEqual(*args)

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

    @staticmethod
    def CreateAspectFillArea3d(*args) -> "opencascade::handle< Graphic3d_AspectFillArea3d >":
        r"""
        Creates fill area aspect with values from drawer according to keys from drawerattribute.

        Parameters
        ----------
        theDr: MeshVS_Drawer
        UseDefaults: bool,optional
        	default value is Standard_True

        Returns
        -------
        opencascade::handle<Graphic3d_AspectFillArea3d>
        Creates fill aspect with values from drawer according to keys from drawerattribute and specific material aspect.

        Parameters
        ----------
        theDr: MeshVS_Drawer
        Mat: Graphic3d_MaterialAspect
        UseDefaults: bool,optional
        	default value is Standard_True

        Returns
        -------
        opencascade::handle<Graphic3d_AspectFillArea3d>

        """
        return _MeshVS.MeshVS_Tool_CreateAspectFillArea3d(*args)

    @staticmethod
    def CreateAspectLine3d(*args) -> "opencascade::handle< Graphic3d_AspectLine3d >":
        r"""
        Creates line aspect with values from drawer according to keys from drawerattribute.

        Parameters
        ----------
        theDr: MeshVS_Drawer
        UseDefaults: bool,optional
        	default value is Standard_True

        Returns
        -------
        opencascade::handle<Graphic3d_AspectLine3d>

        """
        return _MeshVS.MeshVS_Tool_CreateAspectLine3d(*args)

    @staticmethod
    def CreateAspectMarker3d(*args) -> "opencascade::handle< Graphic3d_AspectMarker3d >":
        r"""
        Creates marker aspect with values from drawer according to keys from drawerattribute.

        Parameters
        ----------
        theDr: MeshVS_Drawer
        UseDefaults: bool,optional
        	default value is Standard_True

        Returns
        -------
        opencascade::handle<Graphic3d_AspectMarker3d>

        """
        return _MeshVS.MeshVS_Tool_CreateAspectMarker3d(*args)

    @staticmethod
    def CreateAspectText3d(*args) -> "opencascade::handle< Graphic3d_AspectText3d >":
        r"""
        Creates text aspect with values from drawer according to keys from drawerattribute.

        Parameters
        ----------
        theDr: MeshVS_Drawer
        UseDefaults: bool,optional
        	default value is Standard_True

        Returns
        -------
        opencascade::handle<Graphic3d_AspectText3d>

        """
        return _MeshVS.MeshVS_Tool_CreateAspectText3d(*args)

    @staticmethod
    def GetAverageNormal(*args) -> "Standard_Boolean":
        r"""
        Get an average of normals to non-planar polygon described by these points or compute normal of planar polygon. if the polygon isn't planar, function returns false.

        Parameters
        ----------
        Nodes: TColStd_Array1OfReal
        Norm: gp_Vec

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Tool_GetAverageNormal(*args)

    @staticmethod
    def GetNormal(*args) -> "Standard_Boolean":
        r"""
        Get one of normals to polygon described by these points. if the polygon isn't planar, function returns false.

        Parameters
        ----------
        Nodes: TColStd_Array1OfReal
        Norm: gp_Vec

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_Tool_GetNormal(*args)

    __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)

def MeshVS_Tool_CreateAspectFillArea3d(*args) -> "opencascade::handle< Graphic3d_AspectFillArea3d >":
    r"""
    Creates fill area aspect with values from drawer according to keys from drawerattribute.

    Parameters
    ----------
    theDr: MeshVS_Drawer
    UseDefaults: bool,optional
    	default value is Standard_True

    Returns
    -------
    opencascade::handle<Graphic3d_AspectFillArea3d>
    Creates fill aspect with values from drawer according to keys from drawerattribute and specific material aspect.

    Parameters
    ----------
    theDr: MeshVS_Drawer
    Mat: Graphic3d_MaterialAspect
    UseDefaults: bool,optional
    	default value is Standard_True

    Returns
    -------
    opencascade::handle<Graphic3d_AspectFillArea3d>

    """
    return _MeshVS.MeshVS_Tool_CreateAspectFillArea3d(*args)

def MeshVS_Tool_CreateAspectLine3d(*args) -> "opencascade::handle< Graphic3d_AspectLine3d >":
    r"""
    Creates line aspect with values from drawer according to keys from drawerattribute.

    Parameters
    ----------
    theDr: MeshVS_Drawer
    UseDefaults: bool,optional
    	default value is Standard_True

    Returns
    -------
    opencascade::handle<Graphic3d_AspectLine3d>

    """
    return _MeshVS.MeshVS_Tool_CreateAspectLine3d(*args)

def MeshVS_Tool_CreateAspectMarker3d(*args) -> "opencascade::handle< Graphic3d_AspectMarker3d >":
    r"""
    Creates marker aspect with values from drawer according to keys from drawerattribute.

    Parameters
    ----------
    theDr: MeshVS_Drawer
    UseDefaults: bool,optional
    	default value is Standard_True

    Returns
    -------
    opencascade::handle<Graphic3d_AspectMarker3d>

    """
    return _MeshVS.MeshVS_Tool_CreateAspectMarker3d(*args)

def MeshVS_Tool_CreateAspectText3d(*args) -> "opencascade::handle< Graphic3d_AspectText3d >":
    r"""
    Creates text aspect with values from drawer according to keys from drawerattribute.

    Parameters
    ----------
    theDr: MeshVS_Drawer
    UseDefaults: bool,optional
    	default value is Standard_True

    Returns
    -------
    opencascade::handle<Graphic3d_AspectText3d>

    """
    return _MeshVS.MeshVS_Tool_CreateAspectText3d(*args)

def MeshVS_Tool_GetAverageNormal(*args) -> "Standard_Boolean":
    r"""
    Get an average of normals to non-planar polygon described by these points or compute normal of planar polygon. if the polygon isn't planar, function returns false.

    Parameters
    ----------
    Nodes: TColStd_Array1OfReal
    Norm: gp_Vec

    Returns
    -------
    bool

    """
    return _MeshVS.MeshVS_Tool_GetAverageNormal(*args)

def MeshVS_Tool_GetNormal(*args) -> "Standard_Boolean":
    r"""
    Get one of normals to polygon described by these points. if the polygon isn't planar, function returns false.

    Parameters
    ----------
    Nodes: TColStd_Array1OfReal
    Norm: gp_Vec

    Returns
    -------
    bool

    """
    return _MeshVS.MeshVS_Tool_GetNormal(*args)

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

        Parameters
        ----------
        aFirst: int,optional
        	default value is 0
        aSecond: int,optional
        	default value is 0

        Returns
        -------
        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

    @staticmethod
    def CreatePrismTopology(*args) -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >":
        r"""
        No available documentation.

        Parameters
        ----------
        BasePoints: int

        Returns
        -------
        opencascade::handle<MeshVS_HArray1OfSequenceOfInteger>

        """
        return _MeshVS.MeshVS_DataSource3D_CreatePrismTopology(*args)

    @staticmethod
    def CreatePyramidTopology(*args) -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >":
        r"""
        No available documentation.

        Parameters
        ----------
        BasePoints: int

        Returns
        -------
        opencascade::handle<MeshVS_HArray1OfSequenceOfInteger>

        """
        return _MeshVS.MeshVS_DataSource3D_CreatePyramidTopology(*args)

    def GetPrismTopology(self, *args) -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >":
        r"""
        No available documentation.

        Parameters
        ----------
        BasePoints: int

        Returns
        -------
        opencascade::handle<MeshVS_HArray1OfSequenceOfInteger>

        """
        return _MeshVS.MeshVS_DataSource3D_GetPrismTopology(self, *args)

    def GetPyramidTopology(self, *args) -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >":
        r"""
        No available documentation.

        Parameters
        ----------
        BasePoints: int

        Returns
        -------
        opencascade::handle<MeshVS_HArray1OfSequenceOfInteger>

        """
        return _MeshVS.MeshVS_DataSource3D_GetPyramidTopology(self, *args)


    @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)

def MeshVS_DataSource3D_CreatePrismTopology(*args) -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >":
    r"""
    No available documentation.

    Parameters
    ----------
    BasePoints: int

    Returns
    -------
    opencascade::handle<MeshVS_HArray1OfSequenceOfInteger>

    """
    return _MeshVS.MeshVS_DataSource3D_CreatePrismTopology(*args)

def MeshVS_DataSource3D_CreatePyramidTopology(*args) -> "opencascade::handle< MeshVS_HArray1OfSequenceOfInteger >":
    r"""
    No available documentation.

    Parameters
    ----------
    BasePoints: int

    Returns
    -------
    opencascade::handle<MeshVS_HArray1OfSequenceOfInteger>

    """
    return _MeshVS.MeshVS_DataSource3D_CreatePyramidTopology(*args)

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

    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.

        Parameters
        ----------
        theNonDeformDS: MeshVS_DataSource
        theMagnify: float

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_DeformedDataSource_swiginit(self, _MeshVS.new_MeshVS_DeformedDataSource(*args))

    def GetMagnify(self, *args) -> "Standard_Real":
        r"""
        With this methods you can read and change magnify coefficient of nodal displacements.

        Returns
        -------
        float

        """
        return _MeshVS.MeshVS_DeformedDataSource_GetMagnify(self, *args)

    def GetNonDeformedDataSource(self, *args) -> "opencascade::handle< MeshVS_DataSource >":
        r"""
        With this methods you can read and change internal canonical data source.

        Returns
        -------
        opencascade::handle<MeshVS_DataSource>

        """
        return _MeshVS.MeshVS_DeformedDataSource_GetNonDeformedDataSource(self, *args)

    def GetVector(self, *args) -> "Standard_Boolean":
        r"""
        This method returns vector ( vect ) assigned to node number id.

        Parameters
        ----------
        ID: int
        Vect: gp_Vec

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_DeformedDataSource_GetVector(self, *args)

    def GetVectors(self, *args) -> "MeshVS_DataMapOfIntegerVector const &":
        r"""
        This method returns map of nodal displacement vectors.

        Returns
        -------
        MeshVS_DataMapOfIntegerVector

        """
        return _MeshVS.MeshVS_DeformedDataSource_GetVectors(self, *args)

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

        Parameters
        ----------
        theMagnify: float

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_DeformedDataSource_SetMagnify(self, *args)

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

        Parameters
        ----------
        theDS: MeshVS_DataSource

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_DeformedDataSource_SetNonDeformedDataSource(self, *args)

    def SetVector(self, *args) -> "void":
        r"""
        This method sets vector ( vect ) assigned to node number id.

        Parameters
        ----------
        ID: int
        Vect: gp_Vec

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_DeformedDataSource_SetVector(self, *args)

    def SetVectors(self, *args) -> "void":
        r"""
        This method sets map of nodal displacement vectors (map).

        Parameters
        ----------
        Map: MeshVS_DataMapOfIntegerVector

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_DeformedDataSource_SetVectors(self, *args)


    @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

    def __init__(self, *args):
        r"""
        Constructor.

        Parameters
        ----------
        Parent: MeshVS_Mesh
        Flags: int,optional
        	default value is MeshVS_DMF_ElementalColorDataPrs
        DS: MeshVS_DataSource,optional
        	default value is 0
        Id: int,optional
        	default value is -1
        Priority: int,optional
        	default value is MeshVS_BP_ElemColor

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_ElementalColorPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_ElementalColorPrsBuilder(*args))

    def GetColor1(self, *args) -> "Standard_Boolean":
        r"""
        Returns color assigned with element number id.

        Parameters
        ----------
        ID: int
        theColor: Quantity_Color

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_ElementalColorPrsBuilder_GetColor1(self, *args)

    def GetColor2(self, *args) -> "Standard_Boolean":
        r"""
        Returns colors assigned with element number id.

        Parameters
        ----------
        ID: int
        theColor: MeshVS_TwoColors

        Returns
        -------
        bool
        Returns colors assigned with element number id thecolor1 is the front element color thecolor2 is the back element color.

        Parameters
        ----------
        ID: int
        theColor1: Quantity_Color
        theColor2: Quantity_Color

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_ElementalColorPrsBuilder_GetColor2(self, *args)

    def GetColors1(self, *args) -> "MeshVS_DataMapOfIntegerColor const &":
        r"""
        Returns map of colors same for front and back side of face.

        Returns
        -------
        MeshVS_DataMapOfIntegerColor

        """
        return _MeshVS.MeshVS_ElementalColorPrsBuilder_GetColors1(self, *args)

    def GetColors2(self, *args) -> "MeshVS_DataMapOfIntegerTwoColors const &":
        r"""
        Returns map of different colors for front and back side of face.

        Returns
        -------
        MeshVS_DataMapOfIntegerTwoColors

        """
        return _MeshVS.MeshVS_ElementalColorPrsBuilder_GetColors2(self, *args)

    def HasColors1(self, *args) -> "Standard_Boolean":
        r"""
        Returns true, if map of colors isn't empty.

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_ElementalColorPrsBuilder_HasColors1(self, *args)

    def HasColors2(self, *args) -> "Standard_Boolean":
        r"""
        Returns true, if map isn't empty.

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_ElementalColorPrsBuilder_HasColors2(self, *args)

    def SetColor1(self, *args) -> "void":
        r"""
        Sets color assigned with element number id.

        Parameters
        ----------
        ID: int
        theColor: Quantity_Color

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_ElementalColorPrsBuilder_SetColor1(self, *args)

    def SetColor2(self, *args) -> "void":
        r"""
        Sets colors assigned with element number id.

        Parameters
        ----------
        ID: int
        theTwoColors: MeshVS_TwoColors

        Returns
        -------
        None
        Sets color assigned with element number id thecolor1 is the front element color thecolor2 is the back element color.

        Parameters
        ----------
        ID: int
        theColor1: Quantity_Color
        theColor2: Quantity_Color

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_ElementalColorPrsBuilder_SetColor2(self, *args)

    def SetColors1(self, *args) -> "void":
        r"""
        Sets map of colors same for front and back side of face.

        Parameters
        ----------
        Map: MeshVS_DataMapOfIntegerColor

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_ElementalColorPrsBuilder_SetColors1(self, *args)

    def SetColors2(self, *args) -> "void":
        r"""
        Sets map of different colors for front and back side of face.

        Parameters
        ----------
        Map: MeshVS_DataMapOfIntegerTwoColors

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_ElementalColorPrsBuilder_SetColors2(self, *args)


    @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

    def __init__(self, *args):
        r"""
        Creates builder with certain display mode flags, data source, id and priority.

        Parameters
        ----------
        Parent: MeshVS_Mesh
        Flags: int,optional
        	default value is MeshVS_DMF_OCCMask
        DS: MeshVS_DataSource,optional
        	default value is 0
        Id: int,optional
        	default value is -1
        Priority: int,optional
        	default value is MeshVS_BP_Mesh

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_MeshPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_MeshPrsBuilder(*args))

    @staticmethod
    def AddVolumePrs(*args) -> "void":
        r"""
        Add to array polygons or polylines representing volume.

        Parameters
        ----------
        Topo: MeshVS_HArray1OfSequenceOfInteger
        Nodes: TColStd_Array1OfReal
        NbNodes: int
        Array: Graphic3d_ArrayOfPrimitives
        IsReflected: bool
        IsShrinked: bool
        IsSelect: bool
        ShrinkCoef: float

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_MeshPrsBuilder_AddVolumePrs(*args)

    def BuildElements(self, *args) -> "void":
        r"""
        Builds elements presentation.

        Parameters
        ----------
        Prs: Prs3d_Presentation
        IDs: TColStd_PackedMapOfInteger
        IDsToExclude: TColStd_PackedMapOfInteger
        DisplayMode: int

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_MeshPrsBuilder_BuildElements(self, *args)

    def BuildHilightPrs(self, *args) -> "void":
        r"""
        Builds presentation of hilighted entity.

        Parameters
        ----------
        Prs: Prs3d_Presentation
        IDs: TColStd_PackedMapOfInteger
        IsElement: bool

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_MeshPrsBuilder_BuildHilightPrs(self, *args)

    def BuildNodes(self, *args) -> "void":
        r"""
        Builds nodes presentation.

        Parameters
        ----------
        Prs: Prs3d_Presentation
        IDs: TColStd_PackedMapOfInteger
        IDsToExclude: TColStd_PackedMapOfInteger
        DisplayMode: int

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_MeshPrsBuilder_BuildNodes(self, *args)

    @staticmethod
    def HowManyPrimitives(*args) -> "Standard_Integer &, Standard_Integer &":
        r"""
        Calculate how many polygons or polylines are necessary to draw passed topology.

        Parameters
        ----------
        Topo: MeshVS_HArray1OfSequenceOfInteger
        AsPolygons: bool
        IsSelect: bool
        NbNodes: int

        Returns
        -------
        Vertices: int
        Bounds: int

        """
        return _MeshVS.MeshVS_MeshPrsBuilder_HowManyPrimitives(*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)

def MeshVS_MeshPrsBuilder_AddVolumePrs(*args) -> "void":
    r"""
    Add to array polygons or polylines representing volume.

    Parameters
    ----------
    Topo: MeshVS_HArray1OfSequenceOfInteger
    Nodes: TColStd_Array1OfReal
    NbNodes: int
    Array: Graphic3d_ArrayOfPrimitives
    IsReflected: bool
    IsShrinked: bool
    IsSelect: bool
    ShrinkCoef: float

    Returns
    -------
    None

    """
    return _MeshVS.MeshVS_MeshPrsBuilder_AddVolumePrs(*args)

def MeshVS_MeshPrsBuilder_HowManyPrimitives(*args) -> "Standard_Integer &, Standard_Integer &":
    r"""
    Calculate how many polygons or polylines are necessary to draw passed topology.

    Parameters
    ----------
    Topo: MeshVS_HArray1OfSequenceOfInteger
    AsPolygons: bool
    IsSelect: bool
    NbNodes: int

    Returns
    -------
    Vertices: int
    Bounds: int

    """
    return _MeshVS.MeshVS_MeshPrsBuilder_HowManyPrimitives(*args)

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

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        Parent: MeshVS_Mesh
        Flags: int,optional
        	default value is MeshVS_DMF_NodalColorDataPrs
        DS: MeshVS_DataSource,optional
        	default value is 0
        Id: int,optional
        	default value is -1
        Priority: int,optional
        	default value is MeshVS_BP_NodalColor

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_NodalColorPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_NodalColorPrsBuilder(*args))

    def AddVolumePrs(self, *args) -> "void":
        r"""
        Add to array polygons or polylines representing volume.

        Parameters
        ----------
        theTopo: MeshVS_HArray1OfSequenceOfInteger
        theNodes: TColStd_Array1OfInteger
        theCoords: TColStd_Array1OfReal
        theArray: Graphic3d_ArrayOfPrimitives
        theIsShaded: bool
        theNbColors: int
        theNbTexColors: int
        theColorRatio: float

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_AddVolumePrs(self, *args)

    def GetColor(self, *args) -> "Standard_Boolean":
        r"""
        Returns color assigned to single node.

        Parameters
        ----------
        ID: int
        theColor: Quantity_Color

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_GetColor(self, *args)

    def GetColorMap(self, *args) -> "Aspect_SequenceOfColor const &":
        r"""
        Return colors used for texrture presentation.

        Returns
        -------
        Aspect_SequenceOfColor

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_GetColorMap(self, *args)

    def GetColors(self, *args) -> "MeshVS_DataMapOfIntegerColor const &":
        r"""
        Returns map of colors assigned to nodes.

        Returns
        -------
        MeshVS_DataMapOfIntegerColor

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_GetColors(self, *args)

    def GetInvalidColor(self, *args) -> "Quantity_Color":
        r"""
        Return color representing invalid texture coordinate (laying outside range [0, 1]).

        Returns
        -------
        Quantity_Color

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_GetInvalidColor(self, *args)

    def GetTextureCoord(self, *args) -> "Standard_Real":
        r"""
        Return correspondence between node ids and texture coordinate (range [0, 1]).

        Parameters
        ----------
        theID: int

        Returns
        -------
        float

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_GetTextureCoord(self, *args)

    def GetTextureCoords(self, *args) -> "TColStd_DataMapOfIntegerReal const &":
        r"""
        Get correspondence between node ids and texture coordinates (range [0, 1]).

        Returns
        -------
        TColStd_DataMapOfIntegerReal

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_GetTextureCoords(self, *args)

    def HasColors(self, *args) -> "Standard_Boolean":
        r"""
        Returns true, if map isn't empty.

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_HasColors(self, *args)

    def IsUseTexture(self, *args) -> "Standard_Boolean":
        r"""
        Verify whether texture is used to build presentation.

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_IsUseTexture(self, *args)

    def SetColor(self, *args) -> "void":
        r"""
        Sets color assigned to single node.

        Parameters
        ----------
        ID: int
        theColor: Quantity_Color

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_SetColor(self, *args)

    def SetColorMap(self, *args) -> "void":
        r"""
        Set colors to be used for texrture presentation thecolors - colors for valid coordinates (laying in range [0, 1]).

        Parameters
        ----------
        theColors: Aspect_SequenceOfColor

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_SetColorMap(self, *args)

    def SetColors(self, *args) -> "void":
        r"""
        Sets map of colors assigned to nodes.

        Parameters
        ----------
        Map: MeshVS_DataMapOfIntegerColor

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_SetColors(self, *args)

    def SetInvalidColor(self, *args) -> "void":
        r"""
        Set color representing invalid texture coordinate (laying outside range [0, 1]).

        Parameters
        ----------
        theInvalidColor: Quantity_Color

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_SetInvalidColor(self, *args)

    def SetTextureCoord(self, *args) -> "void":
        r"""
        Specify correspondence between node id and texture coordinate (range [0, 1]).

        Parameters
        ----------
        theID: int
        theCoord: float

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_SetTextureCoord(self, *args)

    def SetTextureCoords(self, *args) -> "void":
        r"""
        Specify correspondence between node ids and texture coordinates (range [0, 1]).

        Parameters
        ----------
        theMap: TColStd_DataMapOfIntegerReal

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_SetTextureCoords(self, *args)

    def UseTexture(self, *args) -> "void":
        r"""
        Specify whether texture must be used to build presentation.

        Parameters
        ----------
        theToUse: bool

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_NodalColorPrsBuilder_UseTexture(self, *args)


    @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

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        Parent: MeshVS_Mesh
        Height: float
        Color: Quantity_Color
        Flags: int,optional
        	default value is MeshVS_DMF_TextDataPrs
        DS: MeshVS_DataSource,optional
        	default value is 0
        Id: int,optional
        	default value is -1
        Priority: int,optional
        	default value is MeshVS_BP_Text

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_TextPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_TextPrsBuilder(*args))

    def GetText(self, *args) -> "Standard_Boolean":
        r"""
        Returns text assigned with single node or element.

        Parameters
        ----------
        IsElement: bool
        ID: int
        Text: TCollection_AsciiString

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_TextPrsBuilder_GetText(self, *args)

    def GetTexts(self, *args) -> "MeshVS_DataMapOfIntegerAsciiString const &":
        r"""
        Returns map of text assigned with nodes ( iselement = false ) or elements ( iselement = true ).

        Parameters
        ----------
        IsElement: bool

        Returns
        -------
        MeshVS_DataMapOfIntegerAsciiString

        """
        return _MeshVS.MeshVS_TextPrsBuilder_GetTexts(self, *args)

    def HasTexts(self, *args) -> "Standard_Boolean":
        r"""
        Returns true if map isn't empty.

        Parameters
        ----------
        IsElement: bool

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_TextPrsBuilder_HasTexts(self, *args)

    def SetText(self, *args) -> "void":
        r"""
        Sets text assigned with single node or element.

        Parameters
        ----------
        IsElement: bool
        ID: int
        Text: TCollection_AsciiString

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_TextPrsBuilder_SetText(self, *args)

    def SetTexts(self, *args) -> "void":
        r"""
        Sets map of text assigned with nodes or elements.

        Parameters
        ----------
        IsElement: bool
        Map: MeshVS_DataMapOfIntegerAsciiString

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_TextPrsBuilder_SetTexts(self, *args)


    @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

    def __init__(self, *args):
        r"""
        No available documentation.

        Parameters
        ----------
        Parent: MeshVS_Mesh
        MaxLength: float
        VectorColor: Quantity_Color
        Flags: int,optional
        	default value is MeshVS_DMF_VectorDataPrs
        DS: MeshVS_DataSource,optional
        	default value is 0
        Id: int,optional
        	default value is -1
        Priority: int,optional
        	default value is MeshVS_BP_Vector
        IsSimplePrs: bool,optional
        	default value is Standard_False

        Returns
        -------
        None

        """
        _MeshVS.MeshVS_VectorPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_VectorPrsBuilder(*args))

    def DrawVector(self, *args) -> "void":
        r"""
        Adds to array of polygons and polylines some primitive representing single vector.

        Parameters
        ----------
        theTrsf: gp_Trsf
        Length: float
        MaxLength: float
        ArrowPoints: TColgp_Array1OfPnt
        Lines: Graphic3d_ArrayOfPrimitives
        ArrowLines: Graphic3d_ArrayOfPrimitives
        Triangles: Graphic3d_ArrayOfPrimitives

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_VectorPrsBuilder_DrawVector(self, *args)

    def GetMinMaxVectorValue(self, *args) -> "void":
        r"""
        Calculates minimal and maximal length of vectors in map ( nodal, if iselement = false or elemental, if iselement = true ).

        Parameters
        ----------
        IsElement: bool

        Returns
        -------
        MinValue: float
        MaxValue: float

        """
        return _MeshVS.MeshVS_VectorPrsBuilder_GetMinMaxVectorValue(self, *args)

    def GetVector(self, *args) -> "Standard_Boolean":
        r"""
        Returns vector assigned with certain node or element.

        Parameters
        ----------
        IsElement: bool
        ID: int
        Vect: gp_Vec

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_VectorPrsBuilder_GetVector(self, *args)

    def GetVectors(self, *args) -> "MeshVS_DataMapOfIntegerVector const &":
        r"""
        Returns map of vectors assigned with nodes or elements.

        Parameters
        ----------
        IsElement: bool

        Returns
        -------
        MeshVS_DataMapOfIntegerVector

        """
        return _MeshVS.MeshVS_VectorPrsBuilder_GetVectors(self, *args)

    def HasVectors(self, *args) -> "Standard_Boolean":
        r"""
        Returns true, if map isn't empty.

        Parameters
        ----------
        IsElement: bool

        Returns
        -------
        bool

        """
        return _MeshVS.MeshVS_VectorPrsBuilder_HasVectors(self, *args)

    def SetSimplePrsMode(self, *args) -> "void":
        r"""
        Sets flag that indicates is simple vector arrow mode uses or not default value is false.

        Parameters
        ----------
        IsSimpleArrow: bool

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_VectorPrsBuilder_SetSimplePrsMode(self, *args)

    def SetSimplePrsParams(self, *args) -> "void":
        r"""
        Sets parameters of simple vector arrwo presentation thelinewidthparam - coefficient of vector line width (to draw line instead of arrow) thestartparam and theendparam parameters of start and end of thickened ends position of thickening calculates according to parameters and maximum vector length default values are: thelinewidthparam = 2.5 thestartparam = 0.85 theendparam = 0.95.

        Parameters
        ----------
        theLineWidthParam: float
        theStartParam: float
        theEndParam: float

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_VectorPrsBuilder_SetSimplePrsParams(self, *args)

    def SetVector(self, *args) -> "void":
        r"""
        Sets vector assigned with certain node or element.

        Parameters
        ----------
        IsElement: bool
        ID: int
        Vect: gp_Vec

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_VectorPrsBuilder_SetVector(self, *args)

    def SetVectors(self, *args) -> "void":
        r"""
        Sets map of vectors assigned with nodes or elements.

        Parameters
        ----------
        IsElement: bool
        Map: MeshVS_DataMapOfIntegerVector

        Returns
        -------
        None

        """
        return _MeshVS.MeshVS_VectorPrsBuilder_SetVectors(self, *args)

    @staticmethod
    def calculateArrow(*args) -> "Standard_Real":
        r"""
        Calculates points of arrow presentation.

        Parameters
        ----------
        Points: TColgp_Array1OfPnt
        Length: float
        ArrowPart: float

        Returns
        -------
        float

        """
        return _MeshVS.MeshVS_VectorPrsBuilder_calculateArrow(*args)


    @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)

def MeshVS_VectorPrsBuilder_calculateArrow(*args) -> "Standard_Real":
    r"""
    Calculates points of arrow presentation.

    Parameters
    ----------
    Points: TColgp_Array1OfPnt
    Length: float
    ArrowPart: float

    Returns
    -------
    float

    """
    return _MeshVS.MeshVS_VectorPrsBuilder_calculateArrow(*args)

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))

    def Array1(self) -> "MeshVS_Array1OfSequenceOfInteger const &":
        return _MeshVS.MeshVS_HArray1OfSequenceOfInteger_Array1(self)

    def ChangeArray1(self) -> "MeshVS_Array1OfSequenceOfInteger &":
        return _MeshVS.MeshVS_HArray1OfSequenceOfInteger_ChangeArray1(self)


    @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)


MeshVS_ColorHasher=OCC.Core.Quantity.Quantity_ColorHasher



