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

"""
MeshVS module, see official documentation at
https://www.opencascade.com/doc/occt-7.7.0/refman/html/package_meshvs.html
"""

from sys import version_info as _swig_python_version_info
# 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 == "this":
            set(self, name, value)
        elif name == "thisown":
            self.this.own(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):
        return _MeshVS.SwigPyIterator_value(self)

    def incr(self, n=1):
        return _MeshVS.SwigPyIterator_incr(self, n)

    def decr(self, n=1):
        return _MeshVS.SwigPyIterator_decr(self, n)

    def distance(self, x):
        return _MeshVS.SwigPyIterator_distance(self, x)

    def equal(self, x):
        return _MeshVS.SwigPyIterator_equal(self, x)

    def copy(self):
        return _MeshVS.SwigPyIterator_copy(self)

    def next(self):
        return _MeshVS.SwigPyIterator_next(self)

    def __next__(self):
        return _MeshVS.SwigPyIterator___next__(self)

    def previous(self):
        return _MeshVS.SwigPyIterator_previous(self)

    def advance(self, n):
        return _MeshVS.SwigPyIterator_advance(self, n)

    def __eq__(self, x):
        return _MeshVS.SwigPyIterator___eq__(self, x)

    def __ne__(self, x):
        return _MeshVS.SwigPyIterator___ne__(self, x)

    def __iadd__(self, n):
        return _MeshVS.SwigPyIterator___iadd__(self, n)

    def __isub__(self, n):
        return _MeshVS.SwigPyIterator___isub__(self, n)

    def __add__(self, n):
        return _MeshVS.SwigPyIterator___add__(self, n)

    def __sub__(self, *args):
        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, method_name, class_name):
    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
import OCC.Core.TopTools

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

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


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

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


def Handle_MeshVS_CommonSensitiveEntity_Create():
    return _MeshVS.Handle_MeshVS_CommonSensitiveEntity_Create()

def Handle_MeshVS_CommonSensitiveEntity_DownCast(t):
    return _MeshVS.Handle_MeshVS_CommonSensitiveEntity_DownCast(t)

def Handle_MeshVS_CommonSensitiveEntity_IsNull(t):
    return _MeshVS.Handle_MeshVS_CommonSensitiveEntity_IsNull(t)

def Handle_MeshVS_DataSource_Create():
    return _MeshVS.Handle_MeshVS_DataSource_Create()

def Handle_MeshVS_DataSource_DownCast(t):
    return _MeshVS.Handle_MeshVS_DataSource_DownCast(t)

def Handle_MeshVS_DataSource_IsNull(t):
    return _MeshVS.Handle_MeshVS_DataSource_IsNull(t)

def Handle_MeshVS_Drawer_Create():
    return _MeshVS.Handle_MeshVS_Drawer_Create()

def Handle_MeshVS_Drawer_DownCast(t):
    return _MeshVS.Handle_MeshVS_Drawer_DownCast(t)

def Handle_MeshVS_Drawer_IsNull(t):
    return _MeshVS.Handle_MeshVS_Drawer_IsNull(t)

def Handle_MeshVS_DummySensitiveEntity_Create():
    return _MeshVS.Handle_MeshVS_DummySensitiveEntity_Create()

def Handle_MeshVS_DummySensitiveEntity_DownCast(t):
    return _MeshVS.Handle_MeshVS_DummySensitiveEntity_DownCast(t)

def Handle_MeshVS_DummySensitiveEntity_IsNull(t):
    return _MeshVS.Handle_MeshVS_DummySensitiveEntity_IsNull(t)

def Handle_MeshVS_Mesh_Create():
    return _MeshVS.Handle_MeshVS_Mesh_Create()

def Handle_MeshVS_Mesh_DownCast(t):
    return _MeshVS.Handle_MeshVS_Mesh_DownCast(t)

def Handle_MeshVS_Mesh_IsNull(t):
    return _MeshVS.Handle_MeshVS_Mesh_IsNull(t)

def Handle_MeshVS_MeshEntityOwner_Create():
    return _MeshVS.Handle_MeshVS_MeshEntityOwner_Create()

def Handle_MeshVS_MeshEntityOwner_DownCast(t):
    return _MeshVS.Handle_MeshVS_MeshEntityOwner_DownCast(t)

def Handle_MeshVS_MeshEntityOwner_IsNull(t):
    return _MeshVS.Handle_MeshVS_MeshEntityOwner_IsNull(t)

def Handle_MeshVS_MeshOwner_Create():
    return _MeshVS.Handle_MeshVS_MeshOwner_Create()

def Handle_MeshVS_MeshOwner_DownCast(t):
    return _MeshVS.Handle_MeshVS_MeshOwner_DownCast(t)

def Handle_MeshVS_MeshOwner_IsNull(t):
    return _MeshVS.Handle_MeshVS_MeshOwner_IsNull(t)

def Handle_MeshVS_PrsBuilder_Create():
    return _MeshVS.Handle_MeshVS_PrsBuilder_Create()

def Handle_MeshVS_PrsBuilder_DownCast(t):
    return _MeshVS.Handle_MeshVS_PrsBuilder_DownCast(t)

def Handle_MeshVS_PrsBuilder_IsNull(t):
    return _MeshVS.Handle_MeshVS_PrsBuilder_IsNull(t)

def Handle_MeshVS_SensitiveFace_Create():
    return _MeshVS.Handle_MeshVS_SensitiveFace_Create()

def Handle_MeshVS_SensitiveFace_DownCast(t):
    return _MeshVS.Handle_MeshVS_SensitiveFace_DownCast(t)

def Handle_MeshVS_SensitiveFace_IsNull(t):
    return _MeshVS.Handle_MeshVS_SensitiveFace_IsNull(t)

def Handle_MeshVS_SensitiveMesh_Create():
    return _MeshVS.Handle_MeshVS_SensitiveMesh_Create()

def Handle_MeshVS_SensitiveMesh_DownCast(t):
    return _MeshVS.Handle_MeshVS_SensitiveMesh_DownCast(t)

def Handle_MeshVS_SensitiveMesh_IsNull(t):
    return _MeshVS.Handle_MeshVS_SensitiveMesh_IsNull(t)

def Handle_MeshVS_SensitivePolyhedron_Create():
    return _MeshVS.Handle_MeshVS_SensitivePolyhedron_Create()

def Handle_MeshVS_SensitivePolyhedron_DownCast(t):
    return _MeshVS.Handle_MeshVS_SensitivePolyhedron_DownCast(t)

def Handle_MeshVS_SensitivePolyhedron_IsNull(t):
    return _MeshVS.Handle_MeshVS_SensitivePolyhedron_IsNull(t)

def Handle_MeshVS_SensitiveQuad_Create():
    return _MeshVS.Handle_MeshVS_SensitiveQuad_Create()

def Handle_MeshVS_SensitiveQuad_DownCast(t):
    return _MeshVS.Handle_MeshVS_SensitiveQuad_DownCast(t)

def Handle_MeshVS_SensitiveQuad_IsNull(t):
    return _MeshVS.Handle_MeshVS_SensitiveQuad_IsNull(t)

def Handle_MeshVS_SensitiveSegment_Create():
    return _MeshVS.Handle_MeshVS_SensitiveSegment_Create()

def Handle_MeshVS_SensitiveSegment_DownCast(t):
    return _MeshVS.Handle_MeshVS_SensitiveSegment_DownCast(t)

def Handle_MeshVS_SensitiveSegment_IsNull(t):
    return _MeshVS.Handle_MeshVS_SensitiveSegment_IsNull(t)

def Handle_MeshVS_DataSource3D_Create():
    return _MeshVS.Handle_MeshVS_DataSource3D_Create()

def Handle_MeshVS_DataSource3D_DownCast(t):
    return _MeshVS.Handle_MeshVS_DataSource3D_DownCast(t)

def Handle_MeshVS_DataSource3D_IsNull(t):
    return _MeshVS.Handle_MeshVS_DataSource3D_IsNull(t)

def Handle_MeshVS_DeformedDataSource_Create():
    return _MeshVS.Handle_MeshVS_DeformedDataSource_Create()

def Handle_MeshVS_DeformedDataSource_DownCast(t):
    return _MeshVS.Handle_MeshVS_DeformedDataSource_DownCast(t)

def Handle_MeshVS_DeformedDataSource_IsNull(t):
    return _MeshVS.Handle_MeshVS_DeformedDataSource_IsNull(t)

def Handle_MeshVS_ElementalColorPrsBuilder_Create():
    return _MeshVS.Handle_MeshVS_ElementalColorPrsBuilder_Create()

def Handle_MeshVS_ElementalColorPrsBuilder_DownCast(t):
    return _MeshVS.Handle_MeshVS_ElementalColorPrsBuilder_DownCast(t)

def Handle_MeshVS_ElementalColorPrsBuilder_IsNull(t):
    return _MeshVS.Handle_MeshVS_ElementalColorPrsBuilder_IsNull(t)

def Handle_MeshVS_MeshPrsBuilder_Create():
    return _MeshVS.Handle_MeshVS_MeshPrsBuilder_Create()

def Handle_MeshVS_MeshPrsBuilder_DownCast(t):
    return _MeshVS.Handle_MeshVS_MeshPrsBuilder_DownCast(t)

def Handle_MeshVS_MeshPrsBuilder_IsNull(t):
    return _MeshVS.Handle_MeshVS_MeshPrsBuilder_IsNull(t)

def Handle_MeshVS_NodalColorPrsBuilder_Create():
    return _MeshVS.Handle_MeshVS_NodalColorPrsBuilder_Create()

def Handle_MeshVS_NodalColorPrsBuilder_DownCast(t):
    return _MeshVS.Handle_MeshVS_NodalColorPrsBuilder_DownCast(t)

def Handle_MeshVS_NodalColorPrsBuilder_IsNull(t):
    return _MeshVS.Handle_MeshVS_NodalColorPrsBuilder_IsNull(t)

def Handle_MeshVS_TextPrsBuilder_Create():
    return _MeshVS.Handle_MeshVS_TextPrsBuilder_Create()

def Handle_MeshVS_TextPrsBuilder_DownCast(t):
    return _MeshVS.Handle_MeshVS_TextPrsBuilder_DownCast(t)

def Handle_MeshVS_TextPrsBuilder_IsNull(t):
    return _MeshVS.Handle_MeshVS_TextPrsBuilder_IsNull(t)

def Handle_MeshVS_VectorPrsBuilder_Create():
    return _MeshVS.Handle_MeshVS_VectorPrsBuilder_Create()

def Handle_MeshVS_VectorPrsBuilder_DownCast(t):
    return _MeshVS.Handle_MeshVS_VectorPrsBuilder_DownCast(t)

def Handle_MeshVS_VectorPrsBuilder_IsNull(t):
    return _MeshVS.Handle_MeshVS_VectorPrsBuilder_IsNull(t)

def Handle_MeshVS_HArray1OfSequenceOfInteger_Create():
    return _MeshVS.Handle_MeshVS_HArray1OfSequenceOfInteger_Create()

def Handle_MeshVS_HArray1OfSequenceOfInteger_DownCast(t):
    return _MeshVS.Handle_MeshVS_HArray1OfSequenceOfInteger_DownCast(t)

def Handle_MeshVS_HArray1OfSequenceOfInteger_IsNull(t):
    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):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_begin(self)

    def end(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_cend(self)

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

    def Init(self, theValue):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Init(self, theValue)

    def Size(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Size(self)

    def Length(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Length(self)

    def IsEmpty(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_IsEmpty(self)

    def Lower(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Lower(self)

    def Upper(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Upper(self)

    def IsDeletable(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_IsDeletable(self)

    def IsAllocated(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_IsAllocated(self)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Assign(self, theOther)

    def Move(self, theOther):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Move(self, theOther)

    def Set(self, *args):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Set(self, *args)

    def First(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_First(self)

    def ChangeFirst(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_ChangeFirst(self)

    def Last(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Last(self)

    def ChangeLast(self):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_ChangeLast(self)

    def Value(self, theIndex):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        return _MeshVS.MeshVS_Array1OfSequenceOfInteger_SetValue(self, theIndex, theItem)

    def Resize(self, theLower, theUpper, theToCopyData):
        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):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_begin(self)

    def end(self):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_cend(self)

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

    def Exchange(self, theOther):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Set(self, theOther)

    def ReSize(self, N):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Seek(self, theKey)

    def Find(self, *args):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MeshVS.MeshVS_DataMapOfColorMapOfInteger___call__(self, *args)

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

    def Size(self):
        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):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_begin(self)

    def end(self):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_cend(self)

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

    def Exchange(self, theOther):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Set(self, theOther)

    def ReSize(self, N):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Seek(self, theKey)

    def Find(self, *args):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger___call__(self, *args)

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

    def Size(self):
        return _MeshVS.MeshVS_DataMapOfHArray1OfSequenceOfInteger_Size(self)

    def Keys(self):
        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):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_begin(self)

    def end(self):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_cend(self)

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

    def Exchange(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Set(self, theOther)

    def ReSize(self, N):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Seek(self, theKey)

    def Find(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString___call__(self, *args)

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

    def Size(self):
        return _MeshVS.MeshVS_DataMapOfIntegerAsciiString_Size(self)

    def Keys(self):
        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):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_begin(self)

    def end(self):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_cend(self)

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

    def Exchange(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Set(self, theOther)

    def ReSize(self, N):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Seek(self, theKey)

    def Find(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean___call__(self, *args)

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

    def Size(self):
        return _MeshVS.MeshVS_DataMapOfIntegerBoolean_Size(self)

    def Keys(self):
        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):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_begin(self)

    def end(self):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_cend(self)

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

    def Exchange(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Set(self, theOther)

    def ReSize(self, N):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Seek(self, theKey)

    def Find(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerColor___call__(self, *args)

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

    def Size(self):
        return _MeshVS.MeshVS_DataMapOfIntegerColor_Size(self)

    def Keys(self):
        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):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_begin(self)

    def end(self):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_cend(self)

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

    def Exchange(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Set(self, theOther)

    def ReSize(self, N):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Seek(self, theKey)

    def Find(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial___call__(self, *args)

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

    def Size(self):
        return _MeshVS.MeshVS_DataMapOfIntegerMaterial_Size(self)

    def Keys(self):
        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):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_begin(self)

    def end(self):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_cend(self)

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

    def Exchange(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Set(self, theOther)

    def ReSize(self, N):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Seek(self, theKey)

    def Find(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner___call__(self, *args)

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

    def Size(self):
        return _MeshVS.MeshVS_DataMapOfIntegerMeshEntityOwner_Size(self)

    def Keys(self):
        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):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_begin(self)

    def end(self):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_cend(self)

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

    def Exchange(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Set(self, theOther)

    def ReSize(self, N):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Seek(self, theKey)

    def Find(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner___call__(self, *args)

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

    def Size(self):
        return _MeshVS.MeshVS_DataMapOfIntegerOwner_Size(self)

    def Keys(self):
        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):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_begin(self)

    def end(self):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_cend(self)

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

    def Exchange(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Set(self, theOther)

    def ReSize(self, N):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Seek(self, theKey)

    def Find(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors___call__(self, *args)

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

    def Size(self):
        return _MeshVS.MeshVS_DataMapOfIntegerTwoColors_Size(self)

    def Keys(self):
        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):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_begin(self)

    def end(self):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_cend(self)

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

    def Exchange(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Set(self, theOther)

    def ReSize(self, N):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Seek(self, theKey)

    def Find(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MeshVS.MeshVS_DataMapOfIntegerVector___call__(self, *args)

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

    def Size(self):
        return _MeshVS.MeshVS_DataMapOfIntegerVector_Size(self)

    def Keys(self):
        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):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_begin(self)

    def end(self):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_cend(self)

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

    def Exchange(self, theOther):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Set(self, theOther)

    def ReSize(self, N):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_ReSize(self, N)

    def Bind(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Bind(self, theKey, theItem)

    def Bound(self, theKey, theItem):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Bound(self, theKey, theItem)

    def IsBound(self, theKey):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_IsBound(self, theKey)

    def UnBind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_UnBind(self, theKey)

    def Seek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Seek(self, theKey)

    def Find(self, *args):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_Find(self, *args)

    def ChangeSeek(self, theKey):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_ChangeSeek(self, theKey)

    def ChangeFind(self, theKey):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger_ChangeFind(self, theKey)

    def __call__(self, *args):
        return _MeshVS.MeshVS_DataMapOfTwoColorsMapOfInteger___call__(self, *args)

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

    def Size(self):
        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):
        return _MeshVS.MeshVS_MapOfTwoNodes_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_MapOfTwoNodes_cend(self)

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

    def Exchange(self, theOther):
        return _MeshVS.MeshVS_MapOfTwoNodes_Exchange(self, theOther)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_MapOfTwoNodes_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_MapOfTwoNodes_Set(self, theOther)

    def ReSize(self, N):
        return _MeshVS.MeshVS_MapOfTwoNodes_ReSize(self, N)

    def Add(self, K):
        return _MeshVS.MeshVS_MapOfTwoNodes_Add(self, K)

    def Added(self, K):
        return _MeshVS.MeshVS_MapOfTwoNodes_Added(self, K)

    def Remove(self, K):
        return _MeshVS.MeshVS_MapOfTwoNodes_Remove(self, K)

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

    def Size(self):
        return _MeshVS.MeshVS_MapOfTwoNodes_Size(self)

    def IsEqual(self, theOther):
        return _MeshVS.MeshVS_MapOfTwoNodes_IsEqual(self, theOther)

    def Contains(self, *args):
        return _MeshVS.MeshVS_MapOfTwoNodes_Contains(self, *args)

    def Union(self, theLeft, theRight):
        return _MeshVS.MeshVS_MapOfTwoNodes_Union(self, theLeft, theRight)

    def Unite(self, theOther):
        return _MeshVS.MeshVS_MapOfTwoNodes_Unite(self, theOther)

    def HasIntersection(self, theMap):
        return _MeshVS.MeshVS_MapOfTwoNodes_HasIntersection(self, theMap)

    def Intersection(self, theLeft, theRight):
        return _MeshVS.MeshVS_MapOfTwoNodes_Intersection(self, theLeft, theRight)

    def Intersect(self, theOther):
        return _MeshVS.MeshVS_MapOfTwoNodes_Intersect(self, theOther)

    def Subtraction(self, theLeft, theRight):
        return _MeshVS.MeshVS_MapOfTwoNodes_Subtraction(self, theLeft, theRight)

    def Subtract(self, theOther):
        return _MeshVS.MeshVS_MapOfTwoNodes_Subtract(self, theOther)

    def Difference(self, theLeft, theRight):
        return _MeshVS.MeshVS_MapOfTwoNodes_Difference(self, theLeft, theRight)

    def Differ(self, theOther):
        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):
        return _MeshVS.MeshVS_PolyhedronVerts_begin(self)

    def end(self):
        return _MeshVS.MeshVS_PolyhedronVerts_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_PolyhedronVerts_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_PolyhedronVerts_cend(self)

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

    def Size(self):
        return _MeshVS.MeshVS_PolyhedronVerts_Size(self)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_PolyhedronVerts_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_PolyhedronVerts_Set(self, theOther)

    def Clear(self, theAllocator=0):
        return _MeshVS.MeshVS_PolyhedronVerts_Clear(self, theAllocator)

    def First(self):
        return _MeshVS.MeshVS_PolyhedronVerts_First(self)

    def Last(self):
        return _MeshVS.MeshVS_PolyhedronVerts_Last(self)

    def Append(self, *args):
        return _MeshVS.MeshVS_PolyhedronVerts_Append(self, *args)

    def Prepend(self, *args):
        return _MeshVS.MeshVS_PolyhedronVerts_Prepend(self, *args)

    def RemoveFirst(self):
        return _MeshVS.MeshVS_PolyhedronVerts_RemoveFirst(self)

    def Remove(self, theIter):
        return _MeshVS.MeshVS_PolyhedronVerts_Remove(self, theIter)

    def InsertBefore(self, *args):
        return _MeshVS.MeshVS_PolyhedronVerts_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _MeshVS.MeshVS_PolyhedronVerts_InsertAfter(self, *args)

    def Reverse(self):
        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):
        return _MeshVS.MeshVS_PolyhedronVertsIter_More(self)

    def Next(self):
        return _MeshVS.MeshVS_PolyhedronVertsIter_Next(self)

    def Value(self):
        return _MeshVS.MeshVS_PolyhedronVertsIter_Value(self)

    def ChangeValue(self):
        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):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_begin(self)

    def end(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_end(self)

    def cbegin(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_cbegin(self)

    def cend(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_cend(self)

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

    def Size(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Size(self)

    def Length(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Length(self)

    def Lower(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Lower(self)

    def Upper(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Upper(self)

    def IsEmpty(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_IsEmpty(self)

    def Reverse(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Reverse(self)

    def Exchange(self, I, J):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Exchange(self, I, J)

    @staticmethod
    def delNode(theNode, theAl):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_delNode(theNode, theAl)

    def Clear(self, theAllocator=0):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Clear(self, theAllocator)

    def Assign(self, theOther):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Assign(self, theOther)

    def Set(self, theOther):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Set(self, theOther)

    def Remove(self, *args):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Remove(self, *args)

    def Append(self, *args):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Append(self, *args)

    def Prepend(self, *args):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Prepend(self, *args)

    def InsertBefore(self, *args):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_InsertBefore(self, *args)

    def InsertAfter(self, *args):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_InsertAfter(self, *args)

    def Split(self, theIndex, theSeq):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Split(self, theIndex, theSeq)

    def First(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_First(self)

    def ChangeFirst(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_ChangeFirst(self)

    def Last(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Last(self)

    def ChangeLast(self):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_ChangeLast(self)

    def Value(self, theIndex):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_Value(self, theIndex)

    def ChangeValue(self, theIndex):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder_ChangeValue(self, theIndex)

    def __call__(self, *args):
        return _MeshVS.MeshVS_SequenceOfPrsBuilder___call__(self, *args)

    def SetValue(self, theIndex, theItem):
        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)
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, theUpperBound):
        return _MeshVS.MeshVS_TwoColorsHasher_HashCode(theKey, theUpperBound)

    @staticmethod
    def IsEqual(theKey1, theKey2):
        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)
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, theUpperBound):
        return _MeshVS.MeshVS_TwoNodesHasher_HashCode(theKey, theUpperBound)

    @staticmethod
    def IsEqual(theKey1, theKey2):
        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)
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"""

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

        Return
        -------
        None

        Description
        -----------
        Constructor of the buffer of the requested size.

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

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

        Return
        -------
        None

        Description
        -----------
        Default constructor.

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

    def BoundingBox(self, *args):
        r"""
        Return
        -------
        Select3D_BndBox3d

        Description
        -----------
        Returns bounding box of the triangulation. if location transformation is set, it will be applied.

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

    def Box(self, *args):
        r"""

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

        Return
        -------
        Select3D_BndBox3d

        Description
        -----------
        Returns bounding box of sub-entity with index theidx in sub-entity list.

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

    def Center(self, *args):
        r"""

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

        Return
        -------
        float

        Description
        -----------
        Returns geometry center of sensitive entity index theidx along the given axis theaxis.

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

    def CenterOfGeometry(self, *args):
        r"""
        Return
        -------
        gp_Pnt

        Description
        -----------
        Returns center of a mesh.

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

    def GetConnected(self, *args):
        r"""
        Return
        -------
        opencascade::handle<Select3D_SensitiveEntity>

        Description
        -----------
        Create a copy.

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

    def NbSubElements(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Number of elements.

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

    def Size(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the amount of sub-entities of the complex entity.

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

    def Swap(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Swaps items with indexes theidx1 and theidx2.

        """
        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):
        r"""

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

        Return
        -------
        NbNodes: int

        Description
        -----------
        This method returns topology information about 3d-element returns false if element with id isn't 3d or because other troubles.

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

    def GetAddr(self, *args):
        r"""

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

        Return
        -------
        Standard_Address

        Description
        -----------
        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 ).

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

    def GetAllElements(self, *args):
        r"""
        Return
        -------
        TColStd_PackedMapOfInteger

        Description
        -----------
        This method returns map of all elements the object consist of.

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

    def GetAllGroups(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        This method returns map of all groups the object contains.

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

    def GetAllNodes(self, *args):
        r"""
        Return
        -------
        TColStd_PackedMapOfInteger

        Description
        -----------
        This method returns map of all nodes the object consist of.

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

    def GetBoundingBox(self, *args):
        r"""
        Return
        -------
        Bnd_Box

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

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

    def GetDetectedEntities(self, *args):
        r"""

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

        Return
        -------
        DMin: float

        Description
        -----------
        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
        XMin: float
        YMin: float
        XMax: float
        YMax: float
        aTol: float
        Nodes: TColStd_HPackedMapOfInteger
        Elements: TColStd_HPackedMapOfInteger

        Return
        -------
        bool

        Description
        -----------
        Returns maps of entities (nodes and elements) detected by mouse selection with rectangular box (xmin, ymin, xmax, ymax) on the current view 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

        Return
        -------
        bool

        Description
        -----------
        Returns maps of entities (nodes and elements) detected by mouse selection with the polyline <polyline> on the current view 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
        Nodes: TColStd_HPackedMapOfInteger
        Elements: TColStd_HPackedMapOfInteger

        Return
        -------
        bool

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

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

    def GetGeom(self, *args):
        r"""

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

        Return
        -------
        NbNodes: int
        Type: MeshVS_EntityType

        Description
        -----------
        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 coordinates 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 coordinates 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.

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

    def GetGeomType(self, *args):
        r"""

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

        Return
        -------
        Type: MeshVS_EntityType

        Description
        -----------
        This method is similar to getgeom, but returns only element or node type.

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

    def GetGroup(self, *args):
        r"""

        Parameters
        ----------
        Id: int
        Ids: TColStd_PackedMapOfInteger

        Return
        -------
        Type: MeshVS_EntityType

        Description
        -----------
        This method returns map of all group elements.

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

    def GetGroupAddr(self, *args):
        r"""

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

        Return
        -------
        Standard_Address

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

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

    def GetNodeNormal(self, *args):
        r"""

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

        Return
        -------
        nx: float
        ny: float
        nz: float

        Description
        -----------
        This method return normal of node ranknode of face id, which is using for smooth shading presentation. returns false if normal isn't defined.

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

    def GetNodesByElement(self, *args):
        r"""

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

        Return
        -------
        NbNodes: int

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

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

    def GetNormal(self, *args):
        r"""

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

        Return
        -------
        nx: float
        ny: float
        nz: float

        Description
        -----------
        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 coordinates 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.

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

    def GetNormalsByElement(self, *args):
        r"""

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

        Return
        -------
        bool

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

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

    def IsAdvancedSelectionEnabled(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true if advanced mesh selection is enabled. default implementation returns false. it should be redefined to return true for advanced mesh selection activation.

        """
        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):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        This method copies other drawer contents to this.

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

    def GetAsciiString(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

    def GetBoolean(self, *args):
        r"""

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

        Return
        -------
        Value: bool

        Description
        -----------
        No available documentation.

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

    def GetColor(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

    def GetDouble(self, *args):
        r"""

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

        Return
        -------
        Value: float

        Description
        -----------
        No available documentation.

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

    def GetInteger(self, *args):
        r"""

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

        Return
        -------
        Value: int

        Description
        -----------
        No available documentation.

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

    def GetMaterial(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

    def RemoveAsciiString(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

    def RemoveBoolean(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

    def RemoveColor(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

    def RemoveDouble(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

    def RemoveInteger(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

    def RemoveMaterial(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

    def SetAsciiString(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def SetBoolean(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def SetColor(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def SetDouble(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def SetInteger(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def SetMaterial(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

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

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def BVH(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def BoundingBox(self, *args):
        r"""
        Return
        -------
        Select3D_BndBox3d

        Description
        -----------
        No available documentation.

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

    def CenterOfGeometry(self, *args):
        r"""
        Return
        -------
        gp_Pnt

        Description
        -----------
        No available documentation.

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

    def Clear(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def HasInitLocation(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

    def InvInitLocation(self, *args):
        r"""
        Return
        -------
        gp_GTrsf

        Description
        -----------
        No available documentation.

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

    def Matches(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

    def NbSubElements(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        No available documentation.

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

    def ToBuildBVH(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

        Parameters
        ----------
        theIsAllowOverlapped: bool (optional, default to Standard_False)

        Return
        -------
        None

        Description
        -----------
        Constructor. theisallowoverlapped is standard_true, if it is allowed to draw edges overlapped with beams its value is stored in drawer.

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

    def AddBuilder(self, *args):
        r"""

        Parameters
        ----------
        Builder: MeshVS_PrsBuilder
        TreatAsHilighter: bool (optional, default to Standard_False)

        Return
        -------
        None

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

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

    def Compute(self, *args):
        r"""

        Parameters
        ----------
        thePrsMgr: PrsMgr_PresentationManager
        thePrs: Prs3d_Presentation
        theDispMode: int

        Return
        -------
        None

        Description
        -----------
        Computes presentation using builders added to sequence. each builder computes own part of mesh presentation according to its type.

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

    def FindBuilder(self, *args):
        r"""

        Parameters
        ----------
        TypeString: str

        Return
        -------
        opencascade::handle<MeshVS_PrsBuilder>

        Description
        -----------
        Finds builder by its type the string represents.

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

    def GetBuilder(self, *args):
        r"""

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

        Return
        -------
        opencascade::handle<MeshVS_PrsBuilder>

        Description
        -----------
        Returns builder by its index in sequence.

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

    def GetBuilderById(self, *args):
        r"""

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

        Return
        -------
        opencascade::handle<MeshVS_PrsBuilder>

        Description
        -----------
        Returns builder by its id.

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

    def GetBuildersCount(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        How many builders there are in sequence.

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

    def GetDataSource(self, *args):
        r"""
        Return
        -------
        opencascade::handle<MeshVS_DataSource>

        Description
        -----------
        Returns default builders' data source.

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

    def GetDrawer(self, *args):
        r"""
        Return
        -------
        opencascade::handle<MeshVS_Drawer>

        Description
        -----------
        Returns default builders' drawer.

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

    def GetFreeId(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the smallest positive id, not occupied by any builder. this method using when builder is created with id = -1.

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

    def GetHiddenElems(self, *args):
        r"""
        Return
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        Description
        -----------
        Returns map of hidden elements (may be null handle).

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

    def GetHiddenNodes(self, *args):
        r"""
        Return
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        Description
        -----------
        Returns map of hidden nodes (may be null handle).

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

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

        Description
        -----------
        Returns hilighter.

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

    def GetMeshSelMethod(self, *args):
        r"""
        Return
        -------
        MeshVS_MeshSelectionMethod

        Description
        -----------
        Returns set mesh selection method (see meshvs.cdl).

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

    def GetOwnerMaps(self, *args):
        r"""

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

        Return
        -------
        MeshVS_DataMapOfIntegerOwner

        Description
        -----------
        Returns map of owners.

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

    def GetSelectableNodes(self, *args):
        r"""
        Return
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        Description
        -----------
        Returns map of selectable elements (may be null handle).

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

    def IsHiddenElem(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        Returns true if specified element is hidden by default no elements are hidden.

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

    def IsHiddenNode(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        Returns true if specified node is hidden. by default all nodes are hidden.

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

    def IsSelectableElem(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        Returns true if specified element is not hidden.

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

    def IsSelectableNode(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        Returns true if specified node is specified as selectable.

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

    def IsWholeMeshOwner(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        Returns true if the given owner represents a whole mesh.

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

    def RemoveBuilder(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Removes builder from sequence. if it is hilighter, hilighter will be null ( don't remember to set it to other after!!! ).

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

    def RemoveBuilderById(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Removes builder with identificator id.

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

    def SetDataSource(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Sets default builders' data source.

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

    def SetDrawer(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Sets default builders' drawer.

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

    def SetHiddenElems(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Sets map of hidden elements.

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

    def SetHiddenNodes(self, *args):
        r"""

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

        Return
        -------
        None

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

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

    def SetHilighter(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Changes hilighter ( see above ).

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

        Return
        -------
        bool

        Description
        -----------
        Sets builder with sequence index 'index' as hilighter.

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

    def SetHilighterById(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        Sets builder with identificator 'id' as hilighter.

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

    def SetMeshSelMethod(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Sets mesh selection method (see meshvs.cdl).

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

    def SetSelectableNodes(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Sets map of selectable nodes.

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

    def UpdateSelectableNodes(self, *args):
        r"""
        Return
        -------
        None

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

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

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

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def ID(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns id of element or node data structure.

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

    def IsGroup(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true if owner represents group of nodes or elements.

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

    def Owner(self, *args):
        r"""
        Return
        -------
        Standard_Address

        Description
        -----------
        Returns an address of element or node data structure.

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

    def Type(self, *args):
        r"""
        Return
        -------
        MeshVS_EntityType

        Description
        -----------
        Returns type of element or node data structure.

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

        Parameters
        ----------
        theSelObj: SelectMgr_SelectableObject *
        theDS: MeshVS_DataSource
        thePriority: int (optional, default to 0)

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def AddSelectedEntities(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Saves ids of selected mesh entities.

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

    def ClearSelectedEntities(self, *args):
        r"""
        Return
        -------
        None

        Description
        -----------
        Clears ids of selected mesh entities.

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

    def GetDataSource(self, *args):
        r"""
        Return
        -------
        opencascade::handle<MeshVS_DataSource>

        Description
        -----------
        No available documentation.

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

    def GetDetectedElements(self, *args):
        r"""
        Return
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        Description
        -----------
        Returns ids of hilighted mesh elements.

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

    def GetDetectedNodes(self, *args):
        r"""
        Return
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        Description
        -----------
        Returns ids of hilighted mesh nodes.

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

    def GetSelectedElements(self, *args):
        r"""
        Return
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        Description
        -----------
        Returns ids of selected mesh elements.

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

    def GetSelectedNodes(self, *args):
        r"""
        Return
        -------
        opencascade::handle<TColStd_HPackedMapOfInteger>

        Description
        -----------
        Returns ids of selected mesh nodes.

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

    def SetDetectedEntities(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Saves ids of hilighted mesh entities.

        """
        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):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        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).

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

    def CustomBuild(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        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).

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

    def CustomSensitiveEntity(self, *args):
        r"""

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

        Return
        -------
        opencascade::handle<Select3D_SensitiveEntity>

        Description
        -----------
        This method is called to build sensitive of custom elements ( they have meshvs_et_0d type ).

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

    def GetDataSource(self, *args):
        r"""
        Return
        -------
        opencascade::handle<MeshVS_DataSource>

        Description
        -----------
        Returns custom data source or default ( from meshvs_mesh ) if custom is null.

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

    def GetDrawer(self, *args):
        r"""
        Return
        -------
        opencascade::handle<MeshVS_Drawer>

        Description
        -----------
        Returns custom drawer or default ( from meshvs_mesh ) if custom is null.

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

    def GetFlags(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns flags, assigned with builder during creation.

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

    def GetId(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns builder id.

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

    def GetPresentationManager(self, *args):
        r"""
        Return
        -------
        opencascade::handle<PrsMgr_PresentationManager>

        Description
        -----------
        Get presentation manager of builder.

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

    def GetPriority(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns priority; as priority bigger, as soon builder will be called.

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

    def IsExcludingOn(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Read excluding state.

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

    def SetDataSource(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Change custom data source.

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

    def SetDrawer(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Change custom drawer.

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

    def SetExcluding(self, *args):
        r"""

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

        Return
        -------
        None

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

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

    def SetPresentationManager(self, *args):
        r"""

        Parameters
        ----------
        thePrsMgr: PrsMgr_PresentationManager

        Return
        -------
        None

        Description
        -----------
        Set presentation manager for builder.

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

    def TestFlags(self, *args):
        r"""

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

        Return
        -------
        bool

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

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

        Parameters
        ----------
        theOwner: SelectMgr_EntityOwner
        thePoints: TColgp_Array1OfPnt
        theSensType: Select3D_TypeOfSensitivity (optional, default to Select3D_TOS_INTERIOR)

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

        Parameters
        ----------
        theOwner: SelectMgr_EntityOwner
        theMode: int (optional, default to 0)

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def BoundingBox(self, *args):
        r"""
        Return
        -------
        Select3D_BndBox3d

        Description
        -----------
        Returns bounding box of mesh.

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

    def CenterOfGeometry(self, *args):
        r"""
        Return
        -------
        gp_Pnt

        Description
        -----------
        Returns center of mesh.

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

    def GetConnected(self, *args):
        r"""
        Return
        -------
        opencascade::handle<Select3D_SensitiveEntity>

        Description
        -----------
        No available documentation.

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

    def GetMode(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        No available documentation.

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

    def Matches(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        Checks whether sensitive overlaps current selecting volume.

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

    def NbSubElements(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the amount of mesh nodes.

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

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

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def BoundingBox(self, *args):
        r"""
        Return
        -------
        Select3D_BndBox3d

        Description
        -----------
        No available documentation.

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

    def CenterOfGeometry(self, *args):
        r"""
        Return
        -------
        gp_Pnt

        Description
        -----------
        No available documentation.

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

    def GetConnected(self, *args):
        r"""
        Return
        -------
        opencascade::handle<Select3D_SensitiveEntity>

        Description
        -----------
        No available documentation.

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

    def Matches(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

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

    def NbSubElements(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the amount of nodes of polyhedron.

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

        Parameters
        ----------
        theOwner: SelectMgr_EntityOwner
        theQuadVerts: TColgp_Array1OfPnt

        Return
        -------
        None

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

        Return
        -------
        None

        Description
        -----------
        Creates a new instance and initializes quadrangle vertices with the given points.

        """
        _MeshVS.MeshVS_SensitiveQuad_swiginit(self, _MeshVS.new_MeshVS_SensitiveQuad(*args))

    def BoundingBox(self, *args):
        r"""
        Return
        -------
        Select3D_BndBox3d

        Description
        -----------
        Returns coordinates of the box.

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

    def CenterOfGeometry(self, *args):
        r"""
        Return
        -------
        gp_Pnt

        Description
        -----------
        Returns center of the box.

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

    def GetConnected(self, *args):
        r"""
        Return
        -------
        opencascade::handle<Select3D_SensitiveEntity>

        Description
        -----------
        Returns a copy of this sensitive quadrangle.

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

    def Matches(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        Checks whether the box overlaps current selecting volume.

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

    def NbSubElements(self, *args):
        r"""
        Return
        -------
        int

        Description
        -----------
        Returns the amount of sub-entities in sensitive.

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

        Parameters
        ----------
        theOwner: SelectMgr_EntityOwner
        theFirstPnt: gp_Pnt
        theLastPnt: gp_Pnt

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _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):
        r"""

        Parameters
        ----------
        theNodePair: MeshVS_NodePair
        theUpperBound: int

        Return
        -------
        int

        Description
        -----------
        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 return a computed hash code, in the range [1, theupperbound].

        """
        return _MeshVS.MeshVS_SymmetricPairHasher_HashCode(*args)

    @staticmethod
    def IsEqual(*args):
        r"""

        Parameters
        ----------
        thePair1: MeshVS_NodePair
        thePair2: MeshVS_NodePair

        Return
        -------
        bool

        Description
        -----------
        No available documentation.

        """
        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)
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):
        r"""

        Parameters
        ----------
        theDr: MeshVS_Drawer
        UseDefaults: bool (optional, default to Standard_True)

        Return
        -------
        opencascade::handle<Graphic3d_AspectFillArea3d>

        Description
        -----------
        Creates fill area aspect with values from drawer according to keys from drawerattribute.

        Parameters
        ----------
        theDr: MeshVS_Drawer
        Mat: Graphic3d_MaterialAspect
        UseDefaults: bool (optional, default to Standard_True)

        Return
        -------
        opencascade::handle<Graphic3d_AspectFillArea3d>

        Description
        -----------
        Creates fill aspect with values from drawer according to keys from drawerattribute and specific material aspect.

        """
        return _MeshVS.MeshVS_Tool_CreateAspectFillArea3d(*args)

    @staticmethod
    def CreateAspectLine3d(*args):
        r"""

        Parameters
        ----------
        theDr: MeshVS_Drawer
        UseDefaults: bool (optional, default to Standard_True)

        Return
        -------
        opencascade::handle<Graphic3d_AspectLine3d>

        Description
        -----------
        Creates line aspect with values from drawer according to keys from drawerattribute.

        """
        return _MeshVS.MeshVS_Tool_CreateAspectLine3d(*args)

    @staticmethod
    def CreateAspectMarker3d(*args):
        r"""

        Parameters
        ----------
        theDr: MeshVS_Drawer
        UseDefaults: bool (optional, default to Standard_True)

        Return
        -------
        opencascade::handle<Graphic3d_AspectMarker3d>

        Description
        -----------
        Creates marker aspect with values from drawer according to keys from drawerattribute.

        """
        return _MeshVS.MeshVS_Tool_CreateAspectMarker3d(*args)

    @staticmethod
    def CreateAspectText3d(*args):
        r"""

        Parameters
        ----------
        theDr: MeshVS_Drawer
        UseDefaults: bool (optional, default to Standard_True)

        Return
        -------
        opencascade::handle<Graphic3d_AspectText3d>

        Description
        -----------
        Creates text aspect with values from drawer according to keys from drawerattribute.

        """
        return _MeshVS.MeshVS_Tool_CreateAspectText3d(*args)

    @staticmethod
    def GetAverageNormal(*args):
        r"""

        Parameters
        ----------
        Nodes: TColStd_Array1OfReal
        Norm: gp_Vec

        Return
        -------
        bool

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

        """
        return _MeshVS.MeshVS_Tool_GetAverageNormal(*args)

    @staticmethod
    def GetNormal(*args):
        r"""

        Parameters
        ----------
        Nodes: TColStd_Array1OfReal
        Norm: gp_Vec

        Return
        -------
        bool

        Description
        -----------
        Get one of normals to polygon described by these points. if the polygon isn't planar, function returns false.

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

        Parameters
        ----------
        aFirst: int (optional, default to 0)
        aSecond: int (optional, default to 0)

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _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):
        r"""

        Parameters
        ----------
        BasePoints: int

        Return
        -------
        opencascade::handle<MeshVS_HArray1OfSequenceOfInteger>

        Description
        -----------
        No available documentation.

        """
        return _MeshVS.MeshVS_DataSource3D_CreatePrismTopology(*args)

    @staticmethod
    def CreatePyramidTopology(*args):
        r"""

        Parameters
        ----------
        BasePoints: int

        Return
        -------
        opencascade::handle<MeshVS_HArray1OfSequenceOfInteger>

        Description
        -----------
        No available documentation.

        """
        return _MeshVS.MeshVS_DataSource3D_CreatePyramidTopology(*args)

    def GetPrismTopology(self, *args):
        r"""

        Parameters
        ----------
        BasePoints: int

        Return
        -------
        opencascade::handle<MeshVS_HArray1OfSequenceOfInteger>

        Description
        -----------
        No available documentation.

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

    def GetPyramidTopology(self, *args):
        r"""

        Parameters
        ----------
        BasePoints: int

        Return
        -------
        opencascade::handle<MeshVS_HArray1OfSequenceOfInteger>

        Description
        -----------
        No available documentation.

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

        Parameters
        ----------
        theNonDeformDS: MeshVS_DataSource
        theMagnify: float

        Return
        -------
        None

        Description
        -----------
        Constructor thenondeformds is canonical non-deformed data source, by which we are able to calculate deformed mesh geometry themagnify is coefficient of displacement magnify.

        """
        _MeshVS.MeshVS_DeformedDataSource_swiginit(self, _MeshVS.new_MeshVS_DeformedDataSource(*args))

    def GetMagnify(self, *args):
        r"""
        Return
        -------
        float

        Description
        -----------
        With this methods you can read and change magnify coefficient of nodal displacements.

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

    def GetNonDeformedDataSource(self, *args):
        r"""
        Return
        -------
        opencascade::handle<MeshVS_DataSource>

        Description
        -----------
        With this methods you can read and change internal canonical data source.

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

    def GetVector(self, *args):
        r"""

        Parameters
        ----------
        ID: int
        Vect: gp_Vec

        Return
        -------
        bool

        Description
        -----------
        This method returns vector ( vect ) assigned to node number id.

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

    def GetVectors(self, *args):
        r"""
        Return
        -------
        MeshVS_DataMapOfIntegerVector

        Description
        -----------
        This method returns map of nodal displacement vectors.

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

    def SetMagnify(self, *args):
        r"""

        Parameters
        ----------
        theMagnify: float

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def SetNonDeformedDataSource(self, *args):
        r"""

        Parameters
        ----------
        theDS: MeshVS_DataSource

        Return
        -------
        None

        Description
        -----------
        No available documentation.

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

    def SetVector(self, *args):
        r"""

        Parameters
        ----------
        ID: int
        Vect: gp_Vec

        Return
        -------
        None

        Description
        -----------
        This method sets vector ( vect ) assigned to node number id.

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

    def SetVectors(self, *args):
        r"""

        Parameters
        ----------
        Map: MeshVS_DataMapOfIntegerVector

        Return
        -------
        None

        Description
        -----------
        This method sets map of nodal displacement vectors (map).

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

        Parameters
        ----------
        Parent: MeshVS_Mesh
        Flags: int (optional, default to MeshVS_DMF_ElementalColorDataPrs)
        DS: MeshVS_DataSource (optional, default to 0)
        Id: int (optional, default to -1)
        Priority: int (optional, default to MeshVS_BP_ElemColor)

        Return
        -------
        None

        Description
        -----------
        Constructor.

        """
        _MeshVS.MeshVS_ElementalColorPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_ElementalColorPrsBuilder(*args))

    def GetColor1(self, *args):
        r"""

        Parameters
        ----------
        ID: int
        theColor: Quantity_Color

        Return
        -------
        bool

        Description
        -----------
        Returns color assigned with element number id.

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

    def GetColor2(self, *args):
        r"""

        Parameters
        ----------
        ID: int
        theColor: MeshVS_TwoColors

        Return
        -------
        bool

        Description
        -----------
        Returns colors assigned with element number id.

        Parameters
        ----------
        ID: int
        theColor1: Quantity_Color
        theColor2: Quantity_Color

        Return
        -------
        bool

        Description
        -----------
        Returns colors assigned with element number id thecolor1 is the front element color thecolor2 is the back element color.

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

    def GetColors1(self, *args):
        r"""
        Return
        -------
        MeshVS_DataMapOfIntegerColor

        Description
        -----------
        Returns map of colors same for front and back side of face.

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

    def GetColors2(self, *args):
        r"""
        Return
        -------
        MeshVS_DataMapOfIntegerTwoColors

        Description
        -----------
        Returns map of different colors for front and back side of face.

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

    def HasColors1(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true, if map of colors isn't empty.

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

    def HasColors2(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true, if map isn't empty.

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

    def SetColor1(self, *args):
        r"""

        Parameters
        ----------
        ID: int
        theColor: Quantity_Color

        Return
        -------
        None

        Description
        -----------
        Sets color assigned with element number id.

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

    def SetColor2(self, *args):
        r"""

        Parameters
        ----------
        ID: int
        theTwoColors: MeshVS_TwoColors

        Return
        -------
        None

        Description
        -----------
        Sets colors assigned with element number id.

        Parameters
        ----------
        ID: int
        theColor1: Quantity_Color
        theColor2: Quantity_Color

        Return
        -------
        None

        Description
        -----------
        Sets color assigned with element number id thecolor1 is the front element color thecolor2 is the back element color.

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

    def SetColors1(self, *args):
        r"""

        Parameters
        ----------
        Map: MeshVS_DataMapOfIntegerColor

        Return
        -------
        None

        Description
        -----------
        Sets map of colors same for front and back side of face.

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

    def SetColors2(self, *args):
        r"""

        Parameters
        ----------
        Map: MeshVS_DataMapOfIntegerTwoColors

        Return
        -------
        None

        Description
        -----------
        Sets map of different colors for front and back side of face.

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

        Parameters
        ----------
        Parent: MeshVS_Mesh
        Flags: int (optional, default to MeshVS_DMF_OCCMask)
        DS: MeshVS_DataSource (optional, default to 0)
        Id: int (optional, default to -1)
        Priority: int (optional, default to MeshVS_BP_Mesh)

        Return
        -------
        None

        Description
        -----------
        Creates builder with certain display mode flags, data source, id and priority.

        """
        _MeshVS.MeshVS_MeshPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_MeshPrsBuilder(*args))

    @staticmethod
    def AddVolumePrs(*args):
        r"""

        Parameters
        ----------
        Topo: MeshVS_HArray1OfSequenceOfInteger
        Nodes: TColStd_Array1OfReal
        NbNodes: int
        Array: Graphic3d_ArrayOfPrimitives
        IsReflected: bool
        IsShrinked: bool
        IsSelect: bool
        ShrinkCoef: float

        Return
        -------
        None

        Description
        -----------
        Add to array polygons or polylines representing volume.

        """
        return _MeshVS.MeshVS_MeshPrsBuilder_AddVolumePrs(*args)

    def BuildElements(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Builds elements presentation.

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

    def BuildHilightPrs(self, *args):
        r"""

        Parameters
        ----------
        Prs: Prs3d_Presentation
        IDs: TColStd_PackedMapOfInteger
        IsElement: bool

        Return
        -------
        None

        Description
        -----------
        Builds presentation of hilighted entity.

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

    def BuildNodes(self, *args):
        r"""

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

        Return
        -------
        None

        Description
        -----------
        Builds nodes presentation.

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

    @staticmethod
    def HowManyPrimitives(*args):
        r"""

        Parameters
        ----------
        Topo: MeshVS_HArray1OfSequenceOfInteger
        AsPolygons: bool
        IsSelect: bool
        NbNodes: int

        Return
        -------
        Vertices: int
        Bounds: int

        Description
        -----------
        Calculate how many polygons or polylines are necessary to draw passed topology.

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

        Parameters
        ----------
        Parent: MeshVS_Mesh
        Flags: int (optional, default to MeshVS_DMF_NodalColorDataPrs)
        DS: MeshVS_DataSource (optional, default to 0)
        Id: int (optional, default to -1)
        Priority: int (optional, default to MeshVS_BP_NodalColor)

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _MeshVS.MeshVS_NodalColorPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_NodalColorPrsBuilder(*args))

    def AddVolumePrs(self, *args):
        r"""

        Parameters
        ----------
        theTopo: MeshVS_HArray1OfSequenceOfInteger
        theNodes: TColStd_Array1OfInteger
        theCoords: TColStd_Array1OfReal
        theArray: Graphic3d_ArrayOfPrimitives
        theIsShaded: bool
        theNbColors: int
        theNbTexColors: int
        theColorRatio: float

        Return
        -------
        None

        Description
        -----------
        Add to array polygons or polylines representing volume.

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

    def GetColor(self, *args):
        r"""

        Parameters
        ----------
        ID: int
        theColor: Quantity_Color

        Return
        -------
        bool

        Description
        -----------
        Returns color assigned to single node.

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

    def GetColorMap(self, *args):
        r"""
        Return
        -------
        Aspect_SequenceOfColor

        Description
        -----------
        Return colors used for texrture presentation.

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

    def GetColors(self, *args):
        r"""
        Return
        -------
        MeshVS_DataMapOfIntegerColor

        Description
        -----------
        Returns map of colors assigned to nodes.

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

    def GetInvalidColor(self, *args):
        r"""
        Return
        -------
        Quantity_Color

        Description
        -----------
        Return color representing invalid texture coordinate (laying outside range [0, 1]).

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

    def GetTextureCoord(self, *args):
        r"""

        Parameters
        ----------
        theID: int

        Return
        -------
        float

        Description
        -----------
        Return correspondence between node ids and texture coordinate (range [0, 1]).

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

    def GetTextureCoords(self, *args):
        r"""
        Return
        -------
        TColStd_DataMapOfIntegerReal

        Description
        -----------
        Get correspondence between node ids and texture coordinates (range [0, 1]).

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

    def HasColors(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Returns true, if map isn't empty.

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

    def IsUseTexture(self, *args):
        r"""
        Return
        -------
        bool

        Description
        -----------
        Verify whether texture is used to build presentation.

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

    def SetColor(self, *args):
        r"""

        Parameters
        ----------
        ID: int
        theColor: Quantity_Color

        Return
        -------
        None

        Description
        -----------
        Sets color assigned to single node.

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

    def SetColorMap(self, *args):
        r"""

        Parameters
        ----------
        theColors: Aspect_SequenceOfColor

        Return
        -------
        None

        Description
        -----------
        Set colors to be used for texrture presentation thecolors - colors for valid coordinates (laying in range [0, 1]).

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

    def SetColors(self, *args):
        r"""

        Parameters
        ----------
        Map: MeshVS_DataMapOfIntegerColor

        Return
        -------
        None

        Description
        -----------
        Sets map of colors assigned to nodes.

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

    def SetInvalidColor(self, *args):
        r"""

        Parameters
        ----------
        theInvalidColor: Quantity_Color

        Return
        -------
        None

        Description
        -----------
        Set color representing invalid texture coordinate (laying outside range [0, 1]).

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

    def SetTextureCoord(self, *args):
        r"""

        Parameters
        ----------
        theID: int
        theCoord: float

        Return
        -------
        None

        Description
        -----------
        Specify correspondence between node id and texture coordinate (range [0, 1]).

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

    def SetTextureCoords(self, *args):
        r"""

        Parameters
        ----------
        theMap: TColStd_DataMapOfIntegerReal

        Return
        -------
        None

        Description
        -----------
        Specify correspondence between node ids and texture coordinates (range [0, 1]).

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

    def UseTexture(self, *args):
        r"""

        Parameters
        ----------
        theToUse: bool

        Return
        -------
        None

        Description
        -----------
        Specify whether texture must be used to build presentation.

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

        Parameters
        ----------
        Parent: MeshVS_Mesh
        Height: float
        Color: Quantity_Color
        Flags: int (optional, default to MeshVS_DMF_TextDataPrs)
        DS: MeshVS_DataSource (optional, default to 0)
        Id: int (optional, default to -1)
        Priority: int (optional, default to MeshVS_BP_Text)

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _MeshVS.MeshVS_TextPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_TextPrsBuilder(*args))

    def GetText(self, *args):
        r"""

        Parameters
        ----------
        IsElement: bool
        ID: int
        Text: str

        Return
        -------
        bool

        Description
        -----------
        Returns text assigned with single node or element.

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

    def GetTexts(self, *args):
        r"""

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

        Return
        -------
        MeshVS_DataMapOfIntegerAsciiString

        Description
        -----------
        Returns map of text assigned with nodes ( iselement = false ) or elements ( iselement = true ).

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

    def HasTexts(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        Returns true if map isn't empty.

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

    def SetText(self, *args):
        r"""

        Parameters
        ----------
        IsElement: bool
        ID: int
        Text: str

        Return
        -------
        None

        Description
        -----------
        Sets text assigned with single node or element.

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

    def SetTexts(self, *args):
        r"""

        Parameters
        ----------
        IsElement: bool
        Map: MeshVS_DataMapOfIntegerAsciiString

        Return
        -------
        None

        Description
        -----------
        Sets map of text assigned with nodes or elements.

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

        Parameters
        ----------
        Parent: MeshVS_Mesh
        MaxLength: float
        VectorColor: Quantity_Color
        Flags: int (optional, default to MeshVS_DMF_VectorDataPrs)
        DS: MeshVS_DataSource (optional, default to 0)
        Id: int (optional, default to -1)
        Priority: int (optional, default to MeshVS_BP_Vector)
        IsSimplePrs: bool (optional, default to Standard_False)

        Return
        -------
        None

        Description
        -----------
        No available documentation.

        """
        _MeshVS.MeshVS_VectorPrsBuilder_swiginit(self, _MeshVS.new_MeshVS_VectorPrsBuilder(*args))

    def DrawVector(self, *args):
        r"""

        Parameters
        ----------
        theTrsf: gp_Trsf
        Length: float
        MaxLength: float
        ArrowPoints: TColgp_Array1OfPnt
        Lines: Graphic3d_ArrayOfPrimitives
        ArrowLines: Graphic3d_ArrayOfPrimitives
        Triangles: Graphic3d_ArrayOfPrimitives

        Return
        -------
        None

        Description
        -----------
        Adds to array of polygons and polylines some primitive representing single vector.

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

    def GetMinMaxVectorValue(self, *args):
        r"""

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

        Return
        -------
        MinValue: float
        MaxValue: float

        Description
        -----------
        Calculates minimal and maximal length of vectors in map ( nodal, if iselement = false or elemental, if iselement = true ).

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

    def GetVector(self, *args):
        r"""

        Parameters
        ----------
        IsElement: bool
        ID: int
        Vect: gp_Vec

        Return
        -------
        bool

        Description
        -----------
        Returns vector assigned with certain node or element.

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

    def GetVectors(self, *args):
        r"""

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

        Return
        -------
        MeshVS_DataMapOfIntegerVector

        Description
        -----------
        Returns map of vectors assigned with nodes or elements.

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

    def HasVectors(self, *args):
        r"""

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

        Return
        -------
        bool

        Description
        -----------
        Returns true, if map isn't empty.

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

    def SetSimplePrsMode(self, *args):
        r"""

        Parameters
        ----------
        IsSimpleArrow: bool

        Return
        -------
        None

        Description
        -----------
        Sets flag that indicates is simple vector arrow mode uses or not default value is false.

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

    def SetSimplePrsParams(self, *args):
        r"""

        Parameters
        ----------
        theLineWidthParam: float
        theStartParam: float
        theEndParam: float

        Return
        -------
        None

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

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

    def SetVector(self, *args):
        r"""

        Parameters
        ----------
        IsElement: bool
        ID: int
        Vect: gp_Vec

        Return
        -------
        None

        Description
        -----------
        Sets vector assigned with certain node or element.

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

    def SetVectors(self, *args):
        r"""

        Parameters
        ----------
        IsElement: bool
        Map: MeshVS_DataMapOfIntegerVector

        Return
        -------
        None

        Description
        -----------
        Sets map of vectors assigned with nodes or elements.

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

    @staticmethod
    def calculateArrow(*args):
        r"""

        Parameters
        ----------
        Points: TColgp_Array1OfPnt
        Length: float
        ArrowPart: float

        Return
        -------
        float

        Description
        -----------
        Calculates points of arrow presentation.

        """
        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)
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):
        return _MeshVS.MeshVS_HArray1OfSequenceOfInteger_Array1(self)

    def ChangeArray1(self):
        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)



@deprecated
def MeshVS_SymmetricPairHasher_HashCode(*args):
	return MeshVS_SymmetricPairHasher.HashCode(*args)

@deprecated
def MeshVS_SymmetricPairHasher_IsEqual(*args):
	return MeshVS_SymmetricPairHasher.IsEqual(*args)

@deprecated
def MeshVS_Tool_CreateAspectFillArea3d(*args):
	return MeshVS_Tool.CreateAspectFillArea3d(*args)

@deprecated
def MeshVS_Tool_CreateAspectFillArea3d(*args):
	return MeshVS_Tool.CreateAspectFillArea3d(*args)

@deprecated
def MeshVS_Tool_CreateAspectLine3d(*args):
	return MeshVS_Tool.CreateAspectLine3d(*args)

@deprecated
def MeshVS_Tool_CreateAspectMarker3d(*args):
	return MeshVS_Tool.CreateAspectMarker3d(*args)

@deprecated
def MeshVS_Tool_CreateAspectText3d(*args):
	return MeshVS_Tool.CreateAspectText3d(*args)

@deprecated
def MeshVS_Tool_GetAverageNormal(*args):
	return MeshVS_Tool.GetAverageNormal(*args)

@deprecated
def MeshVS_Tool_GetNormal(*args):
	return MeshVS_Tool.GetNormal(*args)

@deprecated
def MeshVS_DataSource3D_CreatePrismTopology(*args):
	return MeshVS_DataSource3D.CreatePrismTopology(*args)

@deprecated
def MeshVS_DataSource3D_CreatePyramidTopology(*args):
	return MeshVS_DataSource3D.CreatePyramidTopology(*args)

@deprecated
def MeshVS_MeshPrsBuilder_AddVolumePrs(*args):
	return MeshVS_MeshPrsBuilder.AddVolumePrs(*args)

@deprecated
def MeshVS_MeshPrsBuilder_HowManyPrimitives(*args):
	return MeshVS_MeshPrsBuilder.HowManyPrimitives(*args)

@deprecated
def MeshVS_VectorPrsBuilder_calculateArrow(*args):
	return MeshVS_VectorPrsBuilder.calculateArrow(*args)



