# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# 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
if _swig_python_version_info >= (2, 7, 0):
    def swig_import_helper():
        import importlib
        pkg = __name__.rpartition('.')[0]
        mname = '.'.join((pkg, '_CGAL_Polygon_mesh_processing')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_CGAL_Polygon_mesh_processing')
    _CGAL_Polygon_mesh_processing = swig_import_helper()
    del swig_import_helper
elif _swig_python_version_info >= (2, 6, 0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_CGAL_Polygon_mesh_processing', [dirname(__file__)])
        except ImportError:
            import _CGAL_Polygon_mesh_processing
            return _CGAL_Polygon_mesh_processing
        try:
            _mod = imp.load_module('_CGAL_Polygon_mesh_processing', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _CGAL_Polygon_mesh_processing = swig_import_helper()
    del swig_import_helper
else:
    import _CGAL_Polygon_mesh_processing
del _swig_python_version_info

try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.

try:
    import builtins as __builtin__
except ImportError:
    import __builtin__

def _swig_setattr_nondynamic(self, class_type, name, value, static=1):
    if (name == "thisown"):
        return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name, None)
    if method:
        return method(self, value)
    if (not static):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)


def _swig_setattr(self, class_type, name, value):
    return _swig_setattr_nondynamic(self, class_type, name, value, 0)


def _swig_getattr(self, class_type, name):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    raise AttributeError("'%s' object has no attribute '%s'" % (class_type.__name__, name))


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

try:
    _object = object
    _newclass = 1
except __builtin__.Exception:
    class _object:
        pass
    _newclass = 0

import CGAL.CGAL_Kernel
import CGAL.CGAL_Polyhedron_3
class Polygon_mesh_slicer(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Polygon_mesh_slicer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Polygon_mesh_slicer, name)
    __repr__ = _swig_repr

    def __init__(self, poly):
        this = _CGAL_Polygon_mesh_processing.new_Polygon_mesh_slicer(poly)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def slice(self, plane, out):
        return _CGAL_Polygon_mesh_processing.Polygon_mesh_slicer_slice(self, plane, out)
    __swig_destroy__ = _CGAL_Polygon_mesh_processing.delete_Polygon_mesh_slicer
    __del__ = lambda self: None
Polygon_mesh_slicer_swigregister = _CGAL_Polygon_mesh_processing.Polygon_mesh_slicer_swigregister
Polygon_mesh_slicer_swigregister(Polygon_mesh_slicer)

class Side_of_triangle_mesh(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Side_of_triangle_mesh, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Side_of_triangle_mesh, name)
    __repr__ = _swig_repr

    def __init__(self, poly):
        this = _CGAL_Polygon_mesh_processing.new_Side_of_triangle_mesh(poly)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def bounded_side(self, p):
        return _CGAL_Polygon_mesh_processing.Side_of_triangle_mesh_bounded_side(self, p)
    __swig_destroy__ = _CGAL_Polygon_mesh_processing.delete_Side_of_triangle_mesh
    __del__ = lambda self: None
Side_of_triangle_mesh_swigregister = _CGAL_Polygon_mesh_processing.Side_of_triangle_mesh_swigregister
Side_of_triangle_mesh_swigregister(Side_of_triangle_mesh)

class Integer_triple(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Integer_triple, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Integer_triple, name)
    __repr__ = _swig_repr
    __swig_setmethods__["first"] = _CGAL_Polygon_mesh_processing.Integer_triple_first_set
    __swig_getmethods__["first"] = _CGAL_Polygon_mesh_processing.Integer_triple_first_get
    if _newclass:
        first = _swig_property(_CGAL_Polygon_mesh_processing.Integer_triple_first_get, _CGAL_Polygon_mesh_processing.Integer_triple_first_set)
    __swig_setmethods__["second"] = _CGAL_Polygon_mesh_processing.Integer_triple_second_set
    __swig_getmethods__["second"] = _CGAL_Polygon_mesh_processing.Integer_triple_second_get
    if _newclass:
        second = _swig_property(_CGAL_Polygon_mesh_processing.Integer_triple_second_get, _CGAL_Polygon_mesh_processing.Integer_triple_second_set)
    __swig_setmethods__["third"] = _CGAL_Polygon_mesh_processing.Integer_triple_third_set
    __swig_getmethods__["third"] = _CGAL_Polygon_mesh_processing.Integer_triple_third_get
    if _newclass:
        third = _swig_property(_CGAL_Polygon_mesh_processing.Integer_triple_third_get, _CGAL_Polygon_mesh_processing.Integer_triple_third_set)

    def __init__(self, *args):
        this = _CGAL_Polygon_mesh_processing.new_Integer_triple(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def deepcopy(self, *args):
        return _CGAL_Polygon_mesh_processing.Integer_triple_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Polygon_mesh_processing.delete_Integer_triple
    __del__ = lambda self: None
Integer_triple_swigregister = _CGAL_Polygon_mesh_processing.Integer_triple_swigregister
Integer_triple_swigregister(Integer_triple)

class Facet_pair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Facet_pair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Facet_pair, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CGAL_Polygon_mesh_processing.new_Facet_pair(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["first"] = _CGAL_Polygon_mesh_processing.Facet_pair_first_set
    __swig_getmethods__["first"] = _CGAL_Polygon_mesh_processing.Facet_pair_first_get
    if _newclass:
        first = _swig_property(_CGAL_Polygon_mesh_processing.Facet_pair_first_get, _CGAL_Polygon_mesh_processing.Facet_pair_first_set)
    __swig_setmethods__["second"] = _CGAL_Polygon_mesh_processing.Facet_pair_second_set
    __swig_getmethods__["second"] = _CGAL_Polygon_mesh_processing.Facet_pair_second_get
    if _newclass:
        second = _swig_property(_CGAL_Polygon_mesh_processing.Facet_pair_second_get, _CGAL_Polygon_mesh_processing.Facet_pair_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _CGAL_Polygon_mesh_processing.delete_Facet_pair
    __del__ = lambda self: None
Facet_pair_swigregister = _CGAL_Polygon_mesh_processing.Facet_pair_swigregister
Facet_pair_swigregister(Facet_pair)

class Halfedge_pair(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Halfedge_pair, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Halfedge_pair, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        this = _CGAL_Polygon_mesh_processing.new_Halfedge_pair(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_setmethods__["first"] = _CGAL_Polygon_mesh_processing.Halfedge_pair_first_set
    __swig_getmethods__["first"] = _CGAL_Polygon_mesh_processing.Halfedge_pair_first_get
    if _newclass:
        first = _swig_property(_CGAL_Polygon_mesh_processing.Halfedge_pair_first_get, _CGAL_Polygon_mesh_processing.Halfedge_pair_first_set)
    __swig_setmethods__["second"] = _CGAL_Polygon_mesh_processing.Halfedge_pair_second_set
    __swig_getmethods__["second"] = _CGAL_Polygon_mesh_processing.Halfedge_pair_second_get
    if _newclass:
        second = _swig_property(_CGAL_Polygon_mesh_processing.Halfedge_pair_second_get, _CGAL_Polygon_mesh_processing.Halfedge_pair_second_set)
    def __len__(self):
        return 2
    def __repr__(self):
        return str((self.first, self.second))
    def __getitem__(self, index): 
        if not (index % 2):
            return self.first
        else:
            return self.second
    def __setitem__(self, index, val):
        if not (index % 2):
            self.first = val
        else:
            self.second = val
    __swig_destroy__ = _CGAL_Polygon_mesh_processing.delete_Halfedge_pair
    __del__ = lambda self: None
Halfedge_pair_swigregister = _CGAL_Polygon_mesh_processing.Halfedge_pair_swigregister
Halfedge_pair_swigregister(Halfedge_pair)

class SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _CGAL_Polygon_mesh_processing.delete_SwigPyIterator
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def __sub__(self, *args):
        return _CGAL_Polygon_mesh_processing.SwigPyIterator___sub__(self, *args)
    def __iter__(self):
        return self
SwigPyIterator_swigregister = _CGAL_Polygon_mesh_processing.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class Point_3_Vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Point_3_Vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Point_3_Vector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector___nonzero__(self)

    def __bool__(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector___bool__(self)

    def __len__(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector___len__(self)

    def __getslice__(self, i, j):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector___setitem__(self, *args)

    def pop(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_pop(self)

    def append(self, x):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_append(self, x)

    def empty(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_empty(self)

    def size(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_size(self)

    def swap(self, v):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_swap(self, v)

    def begin(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_begin(self)

    def end(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_end(self)

    def rbegin(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_rbegin(self)

    def rend(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_rend(self)

    def clear(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_clear(self)

    def get_allocator(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_get_allocator(self)

    def pop_back(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_pop_back(self)

    def erase(self, *args):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_erase(self, *args)

    def __init__(self, *args):
        this = _CGAL_Polygon_mesh_processing.new_Point_3_Vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_push_back(self, x)

    def front(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_front(self)

    def back(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_back(self)

    def assign(self, n, x):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_assign(self, n, x)

    def resize(self, *args):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_resize(self, *args)

    def insert(self, *args):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_insert(self, *args)

    def reserve(self, n):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_reserve(self, n)

    def capacity(self):
        return _CGAL_Polygon_mesh_processing.Point_3_Vector_capacity(self)
    __swig_destroy__ = _CGAL_Polygon_mesh_processing.delete_Point_3_Vector
    __del__ = lambda self: None
Point_3_Vector_swigregister = _CGAL_Polygon_mesh_processing.Point_3_Vector_swigregister
Point_3_Vector_swigregister(Point_3_Vector)

class Int_Vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Int_Vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Int_Vector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector___nonzero__(self)

    def __bool__(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector___bool__(self)

    def __len__(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector___len__(self)

    def __getslice__(self, i, j):
        return _CGAL_Polygon_mesh_processing.Int_Vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CGAL_Polygon_mesh_processing.Int_Vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CGAL_Polygon_mesh_processing.Int_Vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CGAL_Polygon_mesh_processing.Int_Vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CGAL_Polygon_mesh_processing.Int_Vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CGAL_Polygon_mesh_processing.Int_Vector___setitem__(self, *args)

    def pop(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_pop(self)

    def append(self, x):
        return _CGAL_Polygon_mesh_processing.Int_Vector_append(self, x)

    def empty(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_empty(self)

    def size(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_size(self)

    def swap(self, v):
        return _CGAL_Polygon_mesh_processing.Int_Vector_swap(self, v)

    def begin(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_begin(self)

    def end(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_end(self)

    def rbegin(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_rbegin(self)

    def rend(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_rend(self)

    def clear(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_clear(self)

    def get_allocator(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_get_allocator(self)

    def pop_back(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_pop_back(self)

    def erase(self, *args):
        return _CGAL_Polygon_mesh_processing.Int_Vector_erase(self, *args)

    def __init__(self, *args):
        this = _CGAL_Polygon_mesh_processing.new_Int_Vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _CGAL_Polygon_mesh_processing.Int_Vector_push_back(self, x)

    def front(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_front(self)

    def back(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_back(self)

    def assign(self, n, x):
        return _CGAL_Polygon_mesh_processing.Int_Vector_assign(self, n, x)

    def resize(self, *args):
        return _CGAL_Polygon_mesh_processing.Int_Vector_resize(self, *args)

    def insert(self, *args):
        return _CGAL_Polygon_mesh_processing.Int_Vector_insert(self, *args)

    def reserve(self, n):
        return _CGAL_Polygon_mesh_processing.Int_Vector_reserve(self, n)

    def capacity(self):
        return _CGAL_Polygon_mesh_processing.Int_Vector_capacity(self)
    __swig_destroy__ = _CGAL_Polygon_mesh_processing.delete_Int_Vector
    __del__ = lambda self: None
Int_Vector_swigregister = _CGAL_Polygon_mesh_processing.Int_Vector_swigregister
Int_Vector_swigregister(Int_Vector)

class Polygon_Vector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Polygon_Vector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Polygon_Vector, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector___nonzero__(self)

    def __bool__(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector___bool__(self)

    def __len__(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector___len__(self)

    def __getslice__(self, i, j):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector___setitem__(self, *args)

    def pop(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_pop(self)

    def append(self, x):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_append(self, x)

    def empty(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_empty(self)

    def size(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_size(self)

    def swap(self, v):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_swap(self, v)

    def begin(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_begin(self)

    def end(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_end(self)

    def rbegin(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_rbegin(self)

    def rend(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_rend(self)

    def clear(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_clear(self)

    def get_allocator(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_get_allocator(self)

    def pop_back(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_pop_back(self)

    def erase(self, *args):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_erase(self, *args)

    def __init__(self, *args):
        this = _CGAL_Polygon_mesh_processing.new_Polygon_Vector(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_push_back(self, x)

    def front(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_front(self)

    def back(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_back(self)

    def assign(self, n, x):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_assign(self, n, x)

    def resize(self, *args):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_resize(self, *args)

    def insert(self, *args):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_insert(self, *args)

    def reserve(self, n):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_reserve(self, n)

    def capacity(self):
        return _CGAL_Polygon_mesh_processing.Polygon_Vector_capacity(self)
    __swig_destroy__ = _CGAL_Polygon_mesh_processing.delete_Polygon_Vector
    __del__ = lambda self: None
Polygon_Vector_swigregister = _CGAL_Polygon_mesh_processing.Polygon_Vector_swigregister
Polygon_Vector_swigregister(Polygon_Vector)

class Polylines(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Polylines, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Polylines, name)
    __repr__ = _swig_repr

    def iterator(self):
        return _CGAL_Polygon_mesh_processing.Polylines_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _CGAL_Polygon_mesh_processing.Polylines___nonzero__(self)

    def __bool__(self):
        return _CGAL_Polygon_mesh_processing.Polylines___bool__(self)

    def __len__(self):
        return _CGAL_Polygon_mesh_processing.Polylines___len__(self)

    def __getslice__(self, i, j):
        return _CGAL_Polygon_mesh_processing.Polylines___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _CGAL_Polygon_mesh_processing.Polylines___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _CGAL_Polygon_mesh_processing.Polylines___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _CGAL_Polygon_mesh_processing.Polylines___delitem__(self, *args)

    def __getitem__(self, *args):
        return _CGAL_Polygon_mesh_processing.Polylines___getitem__(self, *args)

    def __setitem__(self, *args):
        return _CGAL_Polygon_mesh_processing.Polylines___setitem__(self, *args)

    def pop(self):
        return _CGAL_Polygon_mesh_processing.Polylines_pop(self)

    def append(self, x):
        return _CGAL_Polygon_mesh_processing.Polylines_append(self, x)

    def empty(self):
        return _CGAL_Polygon_mesh_processing.Polylines_empty(self)

    def size(self):
        return _CGAL_Polygon_mesh_processing.Polylines_size(self)

    def swap(self, v):
        return _CGAL_Polygon_mesh_processing.Polylines_swap(self, v)

    def begin(self):
        return _CGAL_Polygon_mesh_processing.Polylines_begin(self)

    def end(self):
        return _CGAL_Polygon_mesh_processing.Polylines_end(self)

    def rbegin(self):
        return _CGAL_Polygon_mesh_processing.Polylines_rbegin(self)

    def rend(self):
        return _CGAL_Polygon_mesh_processing.Polylines_rend(self)

    def clear(self):
        return _CGAL_Polygon_mesh_processing.Polylines_clear(self)

    def get_allocator(self):
        return _CGAL_Polygon_mesh_processing.Polylines_get_allocator(self)

    def pop_back(self):
        return _CGAL_Polygon_mesh_processing.Polylines_pop_back(self)

    def erase(self, *args):
        return _CGAL_Polygon_mesh_processing.Polylines_erase(self, *args)

    def __init__(self, *args):
        this = _CGAL_Polygon_mesh_processing.new_Polylines(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        return _CGAL_Polygon_mesh_processing.Polylines_push_back(self, x)

    def front(self):
        return _CGAL_Polygon_mesh_processing.Polylines_front(self)

    def back(self):
        return _CGAL_Polygon_mesh_processing.Polylines_back(self)

    def assign(self, n, x):
        return _CGAL_Polygon_mesh_processing.Polylines_assign(self, n, x)

    def resize(self, *args):
        return _CGAL_Polygon_mesh_processing.Polylines_resize(self, *args)

    def insert(self, *args):
        return _CGAL_Polygon_mesh_processing.Polylines_insert(self, *args)

    def reserve(self, n):
        return _CGAL_Polygon_mesh_processing.Polylines_reserve(self, n)

    def capacity(self):
        return _CGAL_Polygon_mesh_processing.Polylines_capacity(self)
    __swig_destroy__ = _CGAL_Polygon_mesh_processing.delete_Polylines
    __del__ = lambda self: None
Polylines_swigregister = _CGAL_Polygon_mesh_processing.Polylines_swigregister
Polylines_swigregister(Polylines)

CGAL_VERSION = _CGAL_Polygon_mesh_processing.CGAL_VERSION
CGAL_VERSION_NR = _CGAL_Polygon_mesh_processing.CGAL_VERSION_NR
CGAL_SVN_REVISION = _CGAL_Polygon_mesh_processing.CGAL_SVN_REVISION
CGAL_RELEASE_DATE = _CGAL_Polygon_mesh_processing.CGAL_RELEASE_DATE
CGAL_VERSION_STR = _CGAL_Polygon_mesh_processing.CGAL_VERSION_STR

def fair(*args):
    return _CGAL_Polygon_mesh_processing.fair(*args)
fair = _CGAL_Polygon_mesh_processing.fair

def refine(*args):
    return _CGAL_Polygon_mesh_processing.refine(*args)
refine = _CGAL_Polygon_mesh_processing.refine

def triangulate_face(face, P):
    return _CGAL_Polygon_mesh_processing.triangulate_face(face, P)
triangulate_face = _CGAL_Polygon_mesh_processing.triangulate_face

def triangulate_faces(*args):
    return _CGAL_Polygon_mesh_processing.triangulate_faces(*args)
triangulate_faces = _CGAL_Polygon_mesh_processing.triangulate_faces

def isotropic_remeshing(*args):
    return _CGAL_Polygon_mesh_processing.isotropic_remeshing(*args)
isotropic_remeshing = _CGAL_Polygon_mesh_processing.isotropic_remeshing

def split_long_edges(halfedge_range, max_length, P):
    return _CGAL_Polygon_mesh_processing.split_long_edges(halfedge_range, max_length, P)
split_long_edges = _CGAL_Polygon_mesh_processing.split_long_edges

def triangulate_hole(P, h, output):
    return _CGAL_Polygon_mesh_processing.triangulate_hole(P, h, output)
triangulate_hole = _CGAL_Polygon_mesh_processing.triangulate_hole

def triangulate_and_refine_hole(*args):
    return _CGAL_Polygon_mesh_processing.triangulate_and_refine_hole(*args)
triangulate_and_refine_hole = _CGAL_Polygon_mesh_processing.triangulate_and_refine_hole

def triangulate_refine_and_fair_hole(*args):
    return _CGAL_Polygon_mesh_processing.triangulate_refine_and_fair_hole(*args)
triangulate_refine_and_fair_hole = _CGAL_Polygon_mesh_processing.triangulate_refine_and_fair_hole

def triangulate_hole_polyline(*args):
    return _CGAL_Polygon_mesh_processing.triangulate_hole_polyline(*args)
triangulate_hole_polyline = _CGAL_Polygon_mesh_processing.triangulate_hole_polyline

def does_self_intersect(P):
    return _CGAL_Polygon_mesh_processing.does_self_intersect(P)
does_self_intersect = _CGAL_Polygon_mesh_processing.does_self_intersect

def self_intersections(P, out):
    return _CGAL_Polygon_mesh_processing.self_intersections(P, out)
self_intersections = _CGAL_Polygon_mesh_processing.self_intersections

def is_outward_oriented(P):
    return _CGAL_Polygon_mesh_processing.is_outward_oriented(P)
is_outward_oriented = _CGAL_Polygon_mesh_processing.is_outward_oriented

def reverse_face_orientations(*args):
    return _CGAL_Polygon_mesh_processing.reverse_face_orientations(*args)
reverse_face_orientations = _CGAL_Polygon_mesh_processing.reverse_face_orientations

def orient_polygon_soup(points, polygons):
    return _CGAL_Polygon_mesh_processing.orient_polygon_soup(points, polygons)
orient_polygon_soup = _CGAL_Polygon_mesh_processing.orient_polygon_soup

def stitch_borders(*args):
    return _CGAL_Polygon_mesh_processing.stitch_borders(*args)
stitch_borders = _CGAL_Polygon_mesh_processing.stitch_borders

def polygon_soup_to_polygon_mesh(points, polygons, P):
    return _CGAL_Polygon_mesh_processing.polygon_soup_to_polygon_mesh(points, polygons, P)
polygon_soup_to_polygon_mesh = _CGAL_Polygon_mesh_processing.polygon_soup_to_polygon_mesh

def remove_isolated_vertices(P):
    return _CGAL_Polygon_mesh_processing.remove_isolated_vertices(P)
remove_isolated_vertices = _CGAL_Polygon_mesh_processing.remove_isolated_vertices

def compute_face_normal(*args):
    return _CGAL_Polygon_mesh_processing.compute_face_normal(*args)
compute_face_normal = _CGAL_Polygon_mesh_processing.compute_face_normal

def compute_face_normals(P, out):
    return _CGAL_Polygon_mesh_processing.compute_face_normals(P, out)
compute_face_normals = _CGAL_Polygon_mesh_processing.compute_face_normals

def compute_vertex_normal(*args):
    return _CGAL_Polygon_mesh_processing.compute_vertex_normal(*args)
compute_vertex_normal = _CGAL_Polygon_mesh_processing.compute_vertex_normal

def compute_vertex_normals(P, out):
    return _CGAL_Polygon_mesh_processing.compute_vertex_normals(P, out)
compute_vertex_normals = _CGAL_Polygon_mesh_processing.compute_vertex_normals

def connected_component(seed_face, P, out):
    return _CGAL_Polygon_mesh_processing.connected_component(seed_face, P, out)
connected_component = _CGAL_Polygon_mesh_processing.connected_component

def connected_components(P):
    return _CGAL_Polygon_mesh_processing.connected_components(P)
connected_components = _CGAL_Polygon_mesh_processing.connected_components

def keep_large_connected_components(P, threshold_components_to_keep):
    return _CGAL_Polygon_mesh_processing.keep_large_connected_components(P, threshold_components_to_keep)
keep_large_connected_components = _CGAL_Polygon_mesh_processing.keep_large_connected_components

def keep_largest_connected_components(P, nb_components_to_keep):
    return _CGAL_Polygon_mesh_processing.keep_largest_connected_components(P, nb_components_to_keep)
keep_largest_connected_components = _CGAL_Polygon_mesh_processing.keep_largest_connected_components

def keep_connected_components(*args):
    return _CGAL_Polygon_mesh_processing.keep_connected_components(*args)
keep_connected_components = _CGAL_Polygon_mesh_processing.keep_connected_components

def remove_connected_components(*args):
    return _CGAL_Polygon_mesh_processing.remove_connected_components(*args)
remove_connected_components = _CGAL_Polygon_mesh_processing.remove_connected_components

def face_area(face, P):
    return _CGAL_Polygon_mesh_processing.face_area(face, P)
face_area = _CGAL_Polygon_mesh_processing.face_area

def area(*args):
    return _CGAL_Polygon_mesh_processing.area(*args)
area = _CGAL_Polygon_mesh_processing.area

def volume(P):
    return _CGAL_Polygon_mesh_processing.volume(P)
volume = _CGAL_Polygon_mesh_processing.volume

def edge_length(hedge, P):
    return _CGAL_Polygon_mesh_processing.edge_length(hedge, P)
edge_length = _CGAL_Polygon_mesh_processing.edge_length

def face_border_length(hedge, P):
    return _CGAL_Polygon_mesh_processing.face_border_length(hedge, P)
face_border_length = _CGAL_Polygon_mesh_processing.face_border_length

def bbox_3(P):
    return _CGAL_Polygon_mesh_processing.bbox_3(P)
bbox_3 = _CGAL_Polygon_mesh_processing.bbox_3

def border_halfedges(facet_range, P, out):
    return _CGAL_Polygon_mesh_processing.border_halfedges(facet_range, P, out)
border_halfedges = _CGAL_Polygon_mesh_processing.border_halfedges
# This file is compatible with both classic and new-style classes.


