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

from sys import version_info as _swig_python_version_info
# Import the low-level C/C++ module
if __package__ or "." in __name__:
    from . import _MeshDS
else:
    import _MeshDS

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

    def value(self):
        return _MeshDS.SwigPyIterator_value(self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        return _MeshDS.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self

# Register SwigPyIterator in _MeshDS:
_MeshDS.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 _MeshDS.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.MeshVS
import OCC.Core.TColgp
import OCC.Core.SelectMgr
import OCC.Core.Graphic3d
import OCC.Core.BVH
import OCC.Core.Quantity
import OCC.Core.TCollection
import OCC.Core.gp
import OCC.Core.TColStd
import OCC.Core.Aspect
import OCC.Core.Image
import OCC.Core.TopLoc
import OCC.Core.Bnd
import OCC.Core.OSD
import OCC.Core.Media
import OCC.Core.Select3D
import OCC.Core.SelectBasics
import OCC.Core.Geom
import OCC.Core.GeomAbs
import OCC.Core.PrsMgr
import OCC.Core.Prs3d
import OCC.Core.Poly
import OCC.Core.TShort
import OCC.Core.V3d
import OCC.Core.TopAbs
import OCC.Core.AIS
import OCC.Core.TopoDS
import OCC.Core.Message
import OCC.Core.StdSelect

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

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

    def iterator(self):
        return _MeshDS.vector_float_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _MeshDS.vector_float___nonzero__(self)

    def __bool__(self):
        return _MeshDS.vector_float___bool__(self)

    def __len__(self):
        return _MeshDS.vector_float___len__(self)

    def __getslice__(self, i, j):
        return _MeshDS.vector_float___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _MeshDS.vector_float___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _MeshDS.vector_float___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _MeshDS.vector_float___delitem__(self, *args)

    def __getitem__(self, *args):
        return _MeshDS.vector_float___getitem__(self, *args)

    def __setitem__(self, *args):
        return _MeshDS.vector_float___setitem__(self, *args)

    def pop(self):
        return _MeshDS.vector_float_pop(self)

    def append(self, x):
        return _MeshDS.vector_float_append(self, x)

    def empty(self):
        return _MeshDS.vector_float_empty(self)

    def size(self):
        return _MeshDS.vector_float_size(self)

    def swap(self, v):
        return _MeshDS.vector_float_swap(self, v)

    def begin(self):
        return _MeshDS.vector_float_begin(self)

    def end(self):
        return _MeshDS.vector_float_end(self)

    def rbegin(self):
        return _MeshDS.vector_float_rbegin(self)

    def rend(self):
        return _MeshDS.vector_float_rend(self)

    def clear(self):
        return _MeshDS.vector_float_clear(self)

    def get_allocator(self):
        return _MeshDS.vector_float_get_allocator(self)

    def pop_back(self):
        return _MeshDS.vector_float_pop_back(self)

    def erase(self, *args):
        return _MeshDS.vector_float_erase(self, *args)

    def __init__(self, *args):
        _MeshDS.vector_float_swiginit(self, _MeshDS.new_vector_float(*args))

    def push_back(self, x):
        return _MeshDS.vector_float_push_back(self, x)

    def front(self):
        return _MeshDS.vector_float_front(self)

    def back(self):
        return _MeshDS.vector_float_back(self)

    def assign(self, n, x):
        return _MeshDS.vector_float_assign(self, n, x)

    def resize(self, *args):
        return _MeshDS.vector_float_resize(self, *args)

    def insert(self, *args):
        return _MeshDS.vector_float_insert(self, *args)

    def reserve(self, n):
        return _MeshDS.vector_float_reserve(self, n)

    def capacity(self):
        return _MeshDS.vector_float_capacity(self)
    __swig_destroy__ = _MeshDS.delete_vector_float

# Register vector_float in _MeshDS:
_MeshDS.vector_float_swigregister(vector_float)
class vector_gp_Pnt(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _MeshDS.vector_gp_Pnt_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _MeshDS.vector_gp_Pnt___nonzero__(self)

    def __bool__(self):
        return _MeshDS.vector_gp_Pnt___bool__(self)

    def __len__(self):
        return _MeshDS.vector_gp_Pnt___len__(self)

    def __getslice__(self, i, j):
        return _MeshDS.vector_gp_Pnt___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _MeshDS.vector_gp_Pnt___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _MeshDS.vector_gp_Pnt___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _MeshDS.vector_gp_Pnt___delitem__(self, *args)

    def __getitem__(self, *args):
        return _MeshDS.vector_gp_Pnt___getitem__(self, *args)

    def __setitem__(self, *args):
        return _MeshDS.vector_gp_Pnt___setitem__(self, *args)

    def pop(self):
        return _MeshDS.vector_gp_Pnt_pop(self)

    def append(self, x):
        return _MeshDS.vector_gp_Pnt_append(self, x)

    def empty(self):
        return _MeshDS.vector_gp_Pnt_empty(self)

    def size(self):
        return _MeshDS.vector_gp_Pnt_size(self)

    def swap(self, v):
        return _MeshDS.vector_gp_Pnt_swap(self, v)

    def begin(self):
        return _MeshDS.vector_gp_Pnt_begin(self)

    def end(self):
        return _MeshDS.vector_gp_Pnt_end(self)

    def rbegin(self):
        return _MeshDS.vector_gp_Pnt_rbegin(self)

    def rend(self):
        return _MeshDS.vector_gp_Pnt_rend(self)

    def clear(self):
        return _MeshDS.vector_gp_Pnt_clear(self)

    def get_allocator(self):
        return _MeshDS.vector_gp_Pnt_get_allocator(self)

    def pop_back(self):
        return _MeshDS.vector_gp_Pnt_pop_back(self)

    def erase(self, *args):
        return _MeshDS.vector_gp_Pnt_erase(self, *args)

    def __init__(self, *args):
        _MeshDS.vector_gp_Pnt_swiginit(self, _MeshDS.new_vector_gp_Pnt(*args))

    def push_back(self, x):
        return _MeshDS.vector_gp_Pnt_push_back(self, x)

    def front(self):
        return _MeshDS.vector_gp_Pnt_front(self)

    def back(self):
        return _MeshDS.vector_gp_Pnt_back(self)

    def assign(self, n, x):
        return _MeshDS.vector_gp_Pnt_assign(self, n, x)

    def resize(self, *args):
        return _MeshDS.vector_gp_Pnt_resize(self, *args)

    def insert(self, *args):
        return _MeshDS.vector_gp_Pnt_insert(self, *args)

    def reserve(self, n):
        return _MeshDS.vector_gp_Pnt_reserve(self, n)

    def capacity(self):
        return _MeshDS.vector_gp_Pnt_capacity(self)
    __swig_destroy__ = _MeshDS.delete_vector_gp_Pnt

# Register vector_gp_Pnt in _MeshDS:
_MeshDS.vector_gp_Pnt_swigregister(vector_gp_Pnt)
class vector_int(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _MeshDS.vector_int_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _MeshDS.vector_int___nonzero__(self)

    def __bool__(self):
        return _MeshDS.vector_int___bool__(self)

    def __len__(self):
        return _MeshDS.vector_int___len__(self)

    def __getslice__(self, i, j):
        return _MeshDS.vector_int___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _MeshDS.vector_int___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _MeshDS.vector_int___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _MeshDS.vector_int___delitem__(self, *args)

    def __getitem__(self, *args):
        return _MeshDS.vector_int___getitem__(self, *args)

    def __setitem__(self, *args):
        return _MeshDS.vector_int___setitem__(self, *args)

    def pop(self):
        return _MeshDS.vector_int_pop(self)

    def append(self, x):
        return _MeshDS.vector_int_append(self, x)

    def empty(self):
        return _MeshDS.vector_int_empty(self)

    def size(self):
        return _MeshDS.vector_int_size(self)

    def swap(self, v):
        return _MeshDS.vector_int_swap(self, v)

    def begin(self):
        return _MeshDS.vector_int_begin(self)

    def end(self):
        return _MeshDS.vector_int_end(self)

    def rbegin(self):
        return _MeshDS.vector_int_rbegin(self)

    def rend(self):
        return _MeshDS.vector_int_rend(self)

    def clear(self):
        return _MeshDS.vector_int_clear(self)

    def get_allocator(self):
        return _MeshDS.vector_int_get_allocator(self)

    def pop_back(self):
        return _MeshDS.vector_int_pop_back(self)

    def erase(self, *args):
        return _MeshDS.vector_int_erase(self, *args)

    def __init__(self, *args):
        _MeshDS.vector_int_swiginit(self, _MeshDS.new_vector_int(*args))

    def push_back(self, x):
        return _MeshDS.vector_int_push_back(self, x)

    def front(self):
        return _MeshDS.vector_int_front(self)

    def back(self):
        return _MeshDS.vector_int_back(self)

    def assign(self, n, x):
        return _MeshDS.vector_int_assign(self, n, x)

    def resize(self, *args):
        return _MeshDS.vector_int_resize(self, *args)

    def insert(self, *args):
        return _MeshDS.vector_int_insert(self, *args)

    def reserve(self, n):
        return _MeshDS.vector_int_reserve(self, n)

    def capacity(self):
        return _MeshDS.vector_int_capacity(self)
    __swig_destroy__ = _MeshDS.delete_vector_int

# Register vector_int in _MeshDS:
_MeshDS.vector_int_swigregister(vector_int)
class vector_vector_int(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _MeshDS.vector_vector_int_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _MeshDS.vector_vector_int___nonzero__(self)

    def __bool__(self):
        return _MeshDS.vector_vector_int___bool__(self)

    def __len__(self):
        return _MeshDS.vector_vector_int___len__(self)

    def __getslice__(self, i, j):
        return _MeshDS.vector_vector_int___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _MeshDS.vector_vector_int___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _MeshDS.vector_vector_int___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _MeshDS.vector_vector_int___delitem__(self, *args)

    def __getitem__(self, *args):
        return _MeshDS.vector_vector_int___getitem__(self, *args)

    def __setitem__(self, *args):
        return _MeshDS.vector_vector_int___setitem__(self, *args)

    def pop(self):
        return _MeshDS.vector_vector_int_pop(self)

    def append(self, x):
        return _MeshDS.vector_vector_int_append(self, x)

    def empty(self):
        return _MeshDS.vector_vector_int_empty(self)

    def size(self):
        return _MeshDS.vector_vector_int_size(self)

    def swap(self, v):
        return _MeshDS.vector_vector_int_swap(self, v)

    def begin(self):
        return _MeshDS.vector_vector_int_begin(self)

    def end(self):
        return _MeshDS.vector_vector_int_end(self)

    def rbegin(self):
        return _MeshDS.vector_vector_int_rbegin(self)

    def rend(self):
        return _MeshDS.vector_vector_int_rend(self)

    def clear(self):
        return _MeshDS.vector_vector_int_clear(self)

    def get_allocator(self):
        return _MeshDS.vector_vector_int_get_allocator(self)

    def pop_back(self):
        return _MeshDS.vector_vector_int_pop_back(self)

    def erase(self, *args):
        return _MeshDS.vector_vector_int_erase(self, *args)

    def __init__(self, *args):
        _MeshDS.vector_vector_int_swiginit(self, _MeshDS.new_vector_vector_int(*args))

    def push_back(self, x):
        return _MeshDS.vector_vector_int_push_back(self, x)

    def front(self):
        return _MeshDS.vector_vector_int_front(self)

    def back(self):
        return _MeshDS.vector_vector_int_back(self)

    def assign(self, n, x):
        return _MeshDS.vector_vector_int_assign(self, n, x)

    def resize(self, *args):
        return _MeshDS.vector_vector_int_resize(self, *args)

    def insert(self, *args):
        return _MeshDS.vector_vector_int_insert(self, *args)

    def reserve(self, n):
        return _MeshDS.vector_vector_int_reserve(self, n)

    def capacity(self):
        return _MeshDS.vector_vector_int_capacity(self)
    __swig_destroy__ = _MeshDS.delete_vector_vector_int

# Register vector_vector_int in _MeshDS:
_MeshDS.vector_vector_int_swigregister(vector_vector_int)
class vector_vec(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _MeshDS.vector_vec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _MeshDS.vector_vec___nonzero__(self)

    def __bool__(self):
        return _MeshDS.vector_vec___bool__(self)

    def __len__(self):
        return _MeshDS.vector_vec___len__(self)

    def __getslice__(self, i, j):
        return _MeshDS.vector_vec___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _MeshDS.vector_vec___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _MeshDS.vector_vec___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _MeshDS.vector_vec___delitem__(self, *args)

    def __getitem__(self, *args):
        return _MeshDS.vector_vec___getitem__(self, *args)

    def __setitem__(self, *args):
        return _MeshDS.vector_vec___setitem__(self, *args)

    def pop(self):
        return _MeshDS.vector_vec_pop(self)

    def append(self, x):
        return _MeshDS.vector_vec_append(self, x)

    def empty(self):
        return _MeshDS.vector_vec_empty(self)

    def size(self):
        return _MeshDS.vector_vec_size(self)

    def swap(self, v):
        return _MeshDS.vector_vec_swap(self, v)

    def begin(self):
        return _MeshDS.vector_vec_begin(self)

    def end(self):
        return _MeshDS.vector_vec_end(self)

    def rbegin(self):
        return _MeshDS.vector_vec_rbegin(self)

    def rend(self):
        return _MeshDS.vector_vec_rend(self)

    def clear(self):
        return _MeshDS.vector_vec_clear(self)

    def get_allocator(self):
        return _MeshDS.vector_vec_get_allocator(self)

    def pop_back(self):
        return _MeshDS.vector_vec_pop_back(self)

    def erase(self, *args):
        return _MeshDS.vector_vec_erase(self, *args)

    def __init__(self, *args):
        _MeshDS.vector_vec_swiginit(self, _MeshDS.new_vector_vec(*args))

    def push_back(self, x):
        return _MeshDS.vector_vec_push_back(self, x)

    def front(self):
        return _MeshDS.vector_vec_front(self)

    def back(self):
        return _MeshDS.vector_vec_back(self)

    def assign(self, n, x):
        return _MeshDS.vector_vec_assign(self, n, x)

    def resize(self, *args):
        return _MeshDS.vector_vec_resize(self, *args)

    def insert(self, *args):
        return _MeshDS.vector_vec_insert(self, *args)

    def reserve(self, n):
        return _MeshDS.vector_vec_reserve(self, n)

    def capacity(self):
        return _MeshDS.vector_vec_capacity(self)
    __swig_destroy__ = _MeshDS.delete_vector_vec

# Register vector_vec in _MeshDS:
_MeshDS.vector_vec_swigregister(vector_vec)
class vector_vector_vec(object):
    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
    __repr__ = _swig_repr

    def iterator(self):
        return _MeshDS.vector_vector_vec_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _MeshDS.vector_vector_vec___nonzero__(self)

    def __bool__(self):
        return _MeshDS.vector_vector_vec___bool__(self)

    def __len__(self):
        return _MeshDS.vector_vector_vec___len__(self)

    def __getslice__(self, i, j):
        return _MeshDS.vector_vector_vec___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _MeshDS.vector_vector_vec___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _MeshDS.vector_vector_vec___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _MeshDS.vector_vector_vec___delitem__(self, *args)

    def __getitem__(self, *args):
        return _MeshDS.vector_vector_vec___getitem__(self, *args)

    def __setitem__(self, *args):
        return _MeshDS.vector_vector_vec___setitem__(self, *args)

    def pop(self):
        return _MeshDS.vector_vector_vec_pop(self)

    def append(self, x):
        return _MeshDS.vector_vector_vec_append(self, x)

    def empty(self):
        return _MeshDS.vector_vector_vec_empty(self)

    def size(self):
        return _MeshDS.vector_vector_vec_size(self)

    def swap(self, v):
        return _MeshDS.vector_vector_vec_swap(self, v)

    def begin(self):
        return _MeshDS.vector_vector_vec_begin(self)

    def end(self):
        return _MeshDS.vector_vector_vec_end(self)

    def rbegin(self):
        return _MeshDS.vector_vector_vec_rbegin(self)

    def rend(self):
        return _MeshDS.vector_vector_vec_rend(self)

    def clear(self):
        return _MeshDS.vector_vector_vec_clear(self)

    def get_allocator(self):
        return _MeshDS.vector_vector_vec_get_allocator(self)

    def pop_back(self):
        return _MeshDS.vector_vector_vec_pop_back(self)

    def erase(self, *args):
        return _MeshDS.vector_vector_vec_erase(self, *args)

    def __init__(self, *args):
        _MeshDS.vector_vector_vec_swiginit(self, _MeshDS.new_vector_vector_vec(*args))

    def push_back(self, x):
        return _MeshDS.vector_vector_vec_push_back(self, x)

    def front(self):
        return _MeshDS.vector_vector_vec_front(self)

    def back(self):
        return _MeshDS.vector_vector_vec_back(self)

    def assign(self, n, x):
        return _MeshDS.vector_vector_vec_assign(self, n, x)

    def resize(self, *args):
        return _MeshDS.vector_vector_vec_resize(self, *args)

    def insert(self, *args):
        return _MeshDS.vector_vector_vec_insert(self, *args)

    def reserve(self, n):
        return _MeshDS.vector_vector_vec_reserve(self, n)

    def capacity(self):
        return _MeshDS.vector_vector_vec_capacity(self)
    __swig_destroy__ = _MeshDS.delete_vector_vector_vec

# Register vector_vector_vec in _MeshDS:
_MeshDS.vector_vector_vec_swigregister(vector_vector_vec)

def Handle_MeshDS_DataSource_Create():
    return _MeshDS.Handle_MeshDS_DataSource_Create()

def Handle_MeshDS_DataSource_DownCast(t):
    return _MeshDS.Handle_MeshDS_DataSource_DownCast(t)

def Handle_MeshDS_DataSource_IsNull(t):
    return _MeshDS.Handle_MeshDS_DataSource_IsNull(t)
class MeshDS_DataSource(OCC.Core.MeshVS.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):
        _MeshDS.MeshDS_DataSource_swiginit(self, _MeshDS.new_MeshDS_DataSource(*args))

    def SetElemNormals(self, ElemNormalsData):
        return _MeshDS.MeshDS_DataSource_SetElemNormals(self, ElemNormalsData)

    def SetNodeNormals(self, NodeNormalsData):
        return _MeshDS.MeshDS_DataSource_SetNodeNormals(self, NodeNormalsData)

    def GetGeom(self, *args):
        r"""
        Returns geometry information about node or element id is the numerical identificator of node or element iselement indicates this id describe node ( if standard_false ) or element ( if standard_true ) coords is an array of 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.

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

        Returns
        -------
        NbNodes: int
        Type: MeshVS_EntityType

        """
        return _MeshDS.MeshDS_DataSource_GetGeom(self, *args)

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

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

        Returns
        -------
        Type: MeshVS_EntityType

        """
        return _MeshDS.MeshDS_DataSource_GetGeomType(self, *args)

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

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

        Returns
        -------
        Standard_Address

        """
        return _MeshDS.MeshDS_DataSource_GetAddr(self, *args)

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

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

        Returns
        -------
        NbNodes: int

        """
        return _MeshDS.MeshDS_DataSource_GetNodesByElement(self, *args)

    def GetNormal(self, *args):
        r"""
        This method calculates normal of face, which is using for correct reflection presentation. there is default method, for advance reflection this method can be redefined. id is the numerical identificator of only element! max is maximal number of nodes an element can consist of nx, ny, nz are values whose represent 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.

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

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

        """
        return _MeshDS.MeshDS_DataSource_GetNormal(self, *args)

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

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

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

        """
        return _MeshDS.MeshDS_DataSource_GetNodeNormal(self, *args)


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


    __repr__ = _dumps_object

    __swig_destroy__ = _MeshDS.delete_MeshDS_DataSource

# Register MeshDS_DataSource in _MeshDS:
_MeshDS.MeshDS_DataSource_swigregister(MeshDS_DataSource)

