# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.8
#
# 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
if 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_Kernel', [dirname(__file__)])
        except ImportError:
            import _CGAL_Kernel
            return _CGAL_Kernel
        if fp is not None:
            try:
                _mod = imp.load_module('_CGAL_Kernel', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _CGAL_Kernel = swig_import_helper()
    del swig_import_helper
else:
    import _CGAL_Kernel
del version_info
try:
    _swig_property = property
except NameError:
    pass  # Python < 2.2 doesn't have 'property'.


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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


def _swig_repr(self):
    try:
        strthis = "proxy of " + self.this.__repr__()
    except Exception:
        strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object:
        pass
    _newclass = 0


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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Point_2(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def x(self):
        return _CGAL_Kernel.Point_2_x(self)

    def y(self):
        return _CGAL_Kernel.Point_2_y(self)

    def bbox(self, *args):
        return _CGAL_Kernel.Point_2_bbox(self, *args)

    def set_coordinates(self, x, y):
        return _CGAL_Kernel.Point_2_set_coordinates(self, x, y)

    def __str__(self):
        return _CGAL_Kernel.Point_2___str__(self)

    def __add__(self, arg2):
        return _CGAL_Kernel.Point_2___add__(self, arg2)

    def __sub__(self, *args):
        return _CGAL_Kernel.Point_2___sub__(self, *args)

    def __lt__(self, p):
        return _CGAL_Kernel.Point_2___lt__(self, p)

    def __gt__(self, p):
        return _CGAL_Kernel.Point_2___gt__(self, p)

    def __le__(self, p):
        return _CGAL_Kernel.Point_2___le__(self, p)

    def __ge__(self, p):
        return _CGAL_Kernel.Point_2___ge__(self, p)

    def __eq__(self, *args):
        return _CGAL_Kernel.Point_2___eq__(self, *args)

    def __ne__(self, p):
        return _CGAL_Kernel.Point_2___ne__(self, p)

    def __iadd__(self, arg2):
        return _CGAL_Kernel.Point_2___iadd__(self, arg2)

    def __isub__(self, arg2):
        return _CGAL_Kernel.Point_2___isub__(self, arg2)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Point_2_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Point_2
    __del__ = lambda self: None
Point_2_swigregister = _CGAL_Kernel.Point_2_swigregister
Point_2_swigregister(Point_2)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Weighted_point_2(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def weight(self):
        return _CGAL_Kernel.Weighted_point_2_weight(self)

    def x(self):
        return _CGAL_Kernel.Weighted_point_2_x(self)

    def y(self):
        return _CGAL_Kernel.Weighted_point_2_y(self)

    def point(self):
        return _CGAL_Kernel.Weighted_point_2_point(self)

    def __eq__(self, p):
        return _CGAL_Kernel.Weighted_point_2___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Weighted_point_2___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Weighted_point_2___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Weighted_point_2_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Weighted_point_2
    __del__ = lambda self: None
Weighted_point_2_swigregister = _CGAL_Kernel.Weighted_point_2_swigregister
Weighted_point_2_swigregister(Weighted_point_2)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Segment_2(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def source(self, *args):
        return _CGAL_Kernel.Segment_2_source(self, *args)

    def target(self, *args):
        return _CGAL_Kernel.Segment_2_target(self, *args)

    def min(self, *args):
        return _CGAL_Kernel.Segment_2_min(self, *args)

    def max(self, *args):
        return _CGAL_Kernel.Segment_2_max(self, *args)

    def vertex(self, *args):
        return _CGAL_Kernel.Segment_2_vertex(self, *args)

    def point(self, *args):
        return _CGAL_Kernel.Segment_2_point(self, *args)

    def squared_length(self):
        return _CGAL_Kernel.Segment_2_squared_length(self)

    def opposite(self, *args):
        return _CGAL_Kernel.Segment_2_opposite(self, *args)

    def direction(self, *args):
        return _CGAL_Kernel.Segment_2_direction(self, *args)

    def to_vector(self, *args):
        return _CGAL_Kernel.Segment_2_to_vector(self, *args)

    def supporting_line(self, *args):
        return _CGAL_Kernel.Segment_2_supporting_line(self, *args)

    def bbox(self, *args):
        return _CGAL_Kernel.Segment_2_bbox(self, *args)

    def is_degenerate(self):
        return _CGAL_Kernel.Segment_2_is_degenerate(self)

    def is_horizontal(self):
        return _CGAL_Kernel.Segment_2_is_horizontal(self)

    def is_vertical(self):
        return _CGAL_Kernel.Segment_2_is_vertical(self)

    def has_on(self, c):
        return _CGAL_Kernel.Segment_2_has_on(self, c)

    def collinear_has_on(self, c):
        return _CGAL_Kernel.Segment_2_collinear_has_on(self, c)

    def __eq__(self, p):
        return _CGAL_Kernel.Segment_2___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Segment_2___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Segment_2___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Segment_2_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Segment_2
    __del__ = lambda self: None
Segment_2_swigregister = _CGAL_Kernel.Segment_2_swigregister
Segment_2_swigregister(Segment_2)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Triangle_2(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def vertex(self, *args):
        return _CGAL_Kernel.Triangle_2_vertex(self, *args)

    def is_degenerate(self):
        return _CGAL_Kernel.Triangle_2_is_degenerate(self)

    def has_on_positive_side(self, c):
        return _CGAL_Kernel.Triangle_2_has_on_positive_side(self, c)

    def has_on_negative_side(self, c):
        return _CGAL_Kernel.Triangle_2_has_on_negative_side(self, c)

    def has_on_boundary(self, c):
        return _CGAL_Kernel.Triangle_2_has_on_boundary(self, c)

    def has_on_bounded_side(self, c):
        return _CGAL_Kernel.Triangle_2_has_on_bounded_side(self, c)

    def has_on_unbounded_side(self, c):
        return _CGAL_Kernel.Triangle_2_has_on_unbounded_side(self, c)

    def orientation(self):
        return _CGAL_Kernel.Triangle_2_orientation(self)

    def oriented_side(self, c):
        return _CGAL_Kernel.Triangle_2_oriented_side(self, c)

    def bounded_side(self, c):
        return _CGAL_Kernel.Triangle_2_bounded_side(self, c)

    def opposite(self, *args):
        return _CGAL_Kernel.Triangle_2_opposite(self, *args)

    def area(self):
        return _CGAL_Kernel.Triangle_2_area(self)

    def bbox(self, *args):
        return _CGAL_Kernel.Triangle_2_bbox(self, *args)

    def __eq__(self, p):
        return _CGAL_Kernel.Triangle_2___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Triangle_2___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Triangle_2___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Triangle_2_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Triangle_2
    __del__ = lambda self: None
Triangle_2_swigregister = _CGAL_Kernel.Triangle_2_swigregister
Triangle_2_swigregister(Triangle_2)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Ray_2(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def source(self, *args):
        return _CGAL_Kernel.Ray_2_source(self, *args)

    def point(self, *args):
        return _CGAL_Kernel.Ray_2_point(self, *args)

    def direction(self, *args):
        return _CGAL_Kernel.Ray_2_direction(self, *args)

    def to_vector(self, *args):
        return _CGAL_Kernel.Ray_2_to_vector(self, *args)

    def supporting_line(self, *args):
        return _CGAL_Kernel.Ray_2_supporting_line(self, *args)

    def opposite(self, *args):
        return _CGAL_Kernel.Ray_2_opposite(self, *args)

    def is_degenerate(self):
        return _CGAL_Kernel.Ray_2_is_degenerate(self)

    def is_horizontal(self):
        return _CGAL_Kernel.Ray_2_is_horizontal(self)

    def is_vertical(self):
        return _CGAL_Kernel.Ray_2_is_vertical(self)

    def has_on(self, c):
        return _CGAL_Kernel.Ray_2_has_on(self, c)

    def collinear_has_on(self, c):
        return _CGAL_Kernel.Ray_2_collinear_has_on(self, c)

    def __eq__(self, p):
        return _CGAL_Kernel.Ray_2___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Ray_2___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Ray_2___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Ray_2_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Ray_2
    __del__ = lambda self: None
Ray_2_swigregister = _CGAL_Kernel.Ray_2_swigregister
Ray_2_swigregister(Ray_2)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Direction_2(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def delta(self, c):
        return _CGAL_Kernel.Direction_2_delta(self, c)

    def dx(self):
        return _CGAL_Kernel.Direction_2_dx(self)

    def dy(self):
        return _CGAL_Kernel.Direction_2_dy(self)

    def counterclockwise_in_between(self, c1, c2):
        return _CGAL_Kernel.Direction_2_counterclockwise_in_between(self, c1, c2)

    def vector(self, *args):
        return _CGAL_Kernel.Direction_2_vector(self, *args)

    def __lt__(self, p):
        return _CGAL_Kernel.Direction_2___lt__(self, p)

    def __gt__(self, p):
        return _CGAL_Kernel.Direction_2___gt__(self, p)

    def __le__(self, p):
        return _CGAL_Kernel.Direction_2___le__(self, p)

    def __ge__(self, p):
        return _CGAL_Kernel.Direction_2___ge__(self, p)

    def __eq__(self, p):
        return _CGAL_Kernel.Direction_2___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Direction_2___ne__(self, p)

    def __neg__(self):
        return _CGAL_Kernel.Direction_2___neg__(self)

    def __sub__(self, ref):
        return _CGAL_Kernel.Direction_2___sub__(self, ref)

    def __str__(self):
        return _CGAL_Kernel.Direction_2___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Direction_2_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Direction_2
    __del__ = lambda self: None
Direction_2_swigregister = _CGAL_Kernel.Direction_2_swigregister
Direction_2_swigregister(Direction_2)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Line_2(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def a(self):
        return _CGAL_Kernel.Line_2_a(self)

    def b(self):
        return _CGAL_Kernel.Line_2_b(self)

    def c(self):
        return _CGAL_Kernel.Line_2_c(self)

    def point(self, *args):
        return _CGAL_Kernel.Line_2_point(self, *args)

    def projection(self, *args):
        return _CGAL_Kernel.Line_2_projection(self, *args)

    def x_at_y(self, c):
        return _CGAL_Kernel.Line_2_x_at_y(self, c)

    def y_at_x(self, c):
        return _CGAL_Kernel.Line_2_y_at_x(self, c)

    def is_degenerate(self):
        return _CGAL_Kernel.Line_2_is_degenerate(self)

    def is_horizontal(self):
        return _CGAL_Kernel.Line_2_is_horizontal(self)

    def is_vertical(self):
        return _CGAL_Kernel.Line_2_is_vertical(self)

    def oriented_side(self, c):
        return _CGAL_Kernel.Line_2_oriented_side(self, c)

    def has_on(self, c):
        return _CGAL_Kernel.Line_2_has_on(self, c)

    def has_on_positive_side(self, c):
        return _CGAL_Kernel.Line_2_has_on_positive_side(self, c)

    def has_on_negative_side(self, c):
        return _CGAL_Kernel.Line_2_has_on_negative_side(self, c)

    def to_vector(self, *args):
        return _CGAL_Kernel.Line_2_to_vector(self, *args)

    def direction(self, *args):
        return _CGAL_Kernel.Line_2_direction(self, *args)

    def opposite(self, *args):
        return _CGAL_Kernel.Line_2_opposite(self, *args)

    def perpendicular(self, *args):
        return _CGAL_Kernel.Line_2_perpendicular(self, *args)

    def __eq__(self, p):
        return _CGAL_Kernel.Line_2___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Line_2___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Line_2___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Line_2_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Line_2
    __del__ = lambda self: None
Line_2_swigregister = _CGAL_Kernel.Line_2_swigregister
Line_2_swigregister(Line_2)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Vector_2(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def x(self):
        return _CGAL_Kernel.Vector_2_x(self)

    def y(self):
        return _CGAL_Kernel.Vector_2_y(self)

    def cartesian(self, c):
        return _CGAL_Kernel.Vector_2_cartesian(self, c)

    def dimension(self):
        return _CGAL_Kernel.Vector_2_dimension(self)

    def direction(self, *args):
        return _CGAL_Kernel.Vector_2_direction(self, *args)

    def perpendicular(self, *args):
        return _CGAL_Kernel.Vector_2_perpendicular(self, *args)

    def squared_length(self):
        return _CGAL_Kernel.Vector_2_squared_length(self)

    def __add__(self, c):
        return _CGAL_Kernel.Vector_2___add__(self, c)

    def __sub__(self, c):
        return _CGAL_Kernel.Vector_2___sub__(self, c)

    def __neg__(self):
        return _CGAL_Kernel.Vector_2___neg__(self)

    def __mul__(self, *args):
        return _CGAL_Kernel.Vector_2___mul__(self, *args)

    def __div__(self, c):
        return _CGAL_Kernel.Vector_2___div__(self, c)

    def __eq__(self, *args):
        return _CGAL_Kernel.Vector_2___eq__(self, *args)

    def __ne__(self, p):
        return _CGAL_Kernel.Vector_2___ne__(self, p)

    def __iadd__(self, v):
        return _CGAL_Kernel.Vector_2___iadd__(self, v)

    def __isub__(self, v):
        return _CGAL_Kernel.Vector_2___isub__(self, v)

    def __imul__(self, d):
        return _CGAL_Kernel.Vector_2___imul__(self, d)

    def __idiv__(self, d):
        return _CGAL_Kernel.Vector_2___idiv__(self, d)

    def __str__(self):
        return _CGAL_Kernel.Vector_2___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Vector_2_deepcopy(self, *args)

    def normalize(self):
        return _CGAL_Kernel.Vector_2_normalize(self)
    __swig_destroy__ = _CGAL_Kernel.delete_Vector_2
    __del__ = lambda self: None
Vector_2_swigregister = _CGAL_Kernel.Vector_2_swigregister
Vector_2_swigregister(Vector_2)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Point_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def x(self):
        return _CGAL_Kernel.Point_3_x(self)

    def y(self):
        return _CGAL_Kernel.Point_3_y(self)

    def z(self):
        return _CGAL_Kernel.Point_3_z(self)

    def bbox(self, *args):
        return _CGAL_Kernel.Point_3_bbox(self, *args)

    def set_coordinates(self, x, y, z):
        return _CGAL_Kernel.Point_3_set_coordinates(self, x, y, z)

    def __str__(self):
        return _CGAL_Kernel.Point_3___str__(self)

    def __add__(self, arg2):
        return _CGAL_Kernel.Point_3___add__(self, arg2)

    def __sub__(self, *args):
        return _CGAL_Kernel.Point_3___sub__(self, *args)

    def __lt__(self, p):
        return _CGAL_Kernel.Point_3___lt__(self, p)

    def __gt__(self, p):
        return _CGAL_Kernel.Point_3___gt__(self, p)

    def __le__(self, p):
        return _CGAL_Kernel.Point_3___le__(self, p)

    def __ge__(self, p):
        return _CGAL_Kernel.Point_3___ge__(self, p)

    def __eq__(self, *args):
        return _CGAL_Kernel.Point_3___eq__(self, *args)

    def __ne__(self, p):
        return _CGAL_Kernel.Point_3___ne__(self, p)

    def __iadd__(self, arg2):
        return _CGAL_Kernel.Point_3___iadd__(self, arg2)

    def __isub__(self, arg2):
        return _CGAL_Kernel.Point_3___isub__(self, arg2)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Point_3_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Point_3
    __del__ = lambda self: None
Point_3_swigregister = _CGAL_Kernel.Point_3_swigregister
Point_3_swigregister(Point_3)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Weighted_point_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def weight(self):
        return _CGAL_Kernel.Weighted_point_3_weight(self)

    def x(self):
        return _CGAL_Kernel.Weighted_point_3_x(self)

    def y(self):
        return _CGAL_Kernel.Weighted_point_3_y(self)

    def z(self):
        return _CGAL_Kernel.Weighted_point_3_z(self)

    def point(self):
        return _CGAL_Kernel.Weighted_point_3_point(self)

    def __eq__(self, p):
        return _CGAL_Kernel.Weighted_point_3___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Weighted_point_3___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Weighted_point_3___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Weighted_point_3_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Weighted_point_3
    __del__ = lambda self: None
Weighted_point_3_swigregister = _CGAL_Kernel.Weighted_point_3_swigregister
Weighted_point_3_swigregister(Weighted_point_3)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Plane_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def a(self):
        return _CGAL_Kernel.Plane_3_a(self)

    def b(self):
        return _CGAL_Kernel.Plane_3_b(self)

    def c(self):
        return _CGAL_Kernel.Plane_3_c(self)

    def d(self):
        return _CGAL_Kernel.Plane_3_d(self)

    def projection(self, *args):
        return _CGAL_Kernel.Plane_3_projection(self, *args)

    def opposite(self, *args):
        return _CGAL_Kernel.Plane_3_opposite(self, *args)

    def point(self, *args):
        return _CGAL_Kernel.Plane_3_point(self, *args)

    def orthogonal_vector(self, *args):
        return _CGAL_Kernel.Plane_3_orthogonal_vector(self, *args)

    def perpendicular_line(self, *args):
        return _CGAL_Kernel.Plane_3_perpendicular_line(self, *args)

    def orthogonal_direction(self, *args):
        return _CGAL_Kernel.Plane_3_orthogonal_direction(self, *args)

    def base1(self, *args):
        return _CGAL_Kernel.Plane_3_base1(self, *args)

    def base2(self, *args):
        return _CGAL_Kernel.Plane_3_base2(self, *args)

    def to_2d(self, *args):
        return _CGAL_Kernel.Plane_3_to_2d(self, *args)

    def to_3d(self, *args):
        return _CGAL_Kernel.Plane_3_to_3d(self, *args)

    def oriented_side(self, c):
        return _CGAL_Kernel.Plane_3_oriented_side(self, c)

    def has_on_positive_side(self, c):
        return _CGAL_Kernel.Plane_3_has_on_positive_side(self, c)

    def has_on_negative_side(self, c):
        return _CGAL_Kernel.Plane_3_has_on_negative_side(self, c)

    def has_on(self, *args):
        return _CGAL_Kernel.Plane_3_has_on(self, *args)

    def is_degenerate(self):
        return _CGAL_Kernel.Plane_3_is_degenerate(self)

    def __eq__(self, p):
        return _CGAL_Kernel.Plane_3___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Plane_3___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Plane_3___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Plane_3_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Plane_3
    __del__ = lambda self: None
Plane_3_swigregister = _CGAL_Kernel.Plane_3_swigregister
Plane_3_swigregister(Plane_3)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Segment_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def source(self, *args):
        return _CGAL_Kernel.Segment_3_source(self, *args)

    def target(self, *args):
        return _CGAL_Kernel.Segment_3_target(self, *args)

    def min(self, *args):
        return _CGAL_Kernel.Segment_3_min(self, *args)

    def max(self, *args):
        return _CGAL_Kernel.Segment_3_max(self, *args)

    def vertex(self, *args):
        return _CGAL_Kernel.Segment_3_vertex(self, *args)

    def point(self, *args):
        return _CGAL_Kernel.Segment_3_point(self, *args)

    def squared_length(self):
        return _CGAL_Kernel.Segment_3_squared_length(self)

    def opposite(self, *args):
        return _CGAL_Kernel.Segment_3_opposite(self, *args)

    def is_degenerate(self):
        return _CGAL_Kernel.Segment_3_is_degenerate(self)

    def has_on(self, c):
        return _CGAL_Kernel.Segment_3_has_on(self, c)

    def to_vector(self, *args):
        return _CGAL_Kernel.Segment_3_to_vector(self, *args)

    def direction(self, *args):
        return _CGAL_Kernel.Segment_3_direction(self, *args)

    def supporting_line(self, *args):
        return _CGAL_Kernel.Segment_3_supporting_line(self, *args)

    def bbox(self, *args):
        return _CGAL_Kernel.Segment_3_bbox(self, *args)

    def __eq__(self, p):
        return _CGAL_Kernel.Segment_3___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Segment_3___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Segment_3___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Segment_3_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Segment_3
    __del__ = lambda self: None
Segment_3_swigregister = _CGAL_Kernel.Segment_3_swigregister
Segment_3_swigregister(Segment_3)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Line_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def projection(self, *args):
        return _CGAL_Kernel.Line_3_projection(self, *args)

    def point(self, *args):
        return _CGAL_Kernel.Line_3_point(self, *args)

    def is_degenerate(self):
        return _CGAL_Kernel.Line_3_is_degenerate(self)

    def has_on(self, c):
        return _CGAL_Kernel.Line_3_has_on(self, c)

    def perpendicular_plane(self, *args):
        return _CGAL_Kernel.Line_3_perpendicular_plane(self, *args)

    def opposite(self, *args):
        return _CGAL_Kernel.Line_3_opposite(self, *args)

    def to_vector(self, *args):
        return _CGAL_Kernel.Line_3_to_vector(self, *args)

    def direction(self, *args):
        return _CGAL_Kernel.Line_3_direction(self, *args)

    def __eq__(self, p):
        return _CGAL_Kernel.Line_3___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Line_3___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Line_3___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Line_3_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Line_3
    __del__ = lambda self: None
Line_3_swigregister = _CGAL_Kernel.Line_3_swigregister
Line_3_swigregister(Line_3)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Sphere_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def center(self, *args):
        return _CGAL_Kernel.Sphere_3_center(self, *args)

    def squared_radius(self):
        return _CGAL_Kernel.Sphere_3_squared_radius(self)

    def orientation(self):
        return _CGAL_Kernel.Sphere_3_orientation(self)

    def is_degenerate(self):
        return _CGAL_Kernel.Sphere_3_is_degenerate(self)

    def oriented_side(self, c):
        return _CGAL_Kernel.Sphere_3_oriented_side(self, c)

    def bounded_side(self, c):
        return _CGAL_Kernel.Sphere_3_bounded_side(self, c)

    def has_on_positive_side(self, c):
        return _CGAL_Kernel.Sphere_3_has_on_positive_side(self, c)

    def has_on_negative_side(self, c):
        return _CGAL_Kernel.Sphere_3_has_on_negative_side(self, c)

    def has_on_boundary(self, c):
        return _CGAL_Kernel.Sphere_3_has_on_boundary(self, c)

    def has_on_bounded_side(self, c):
        return _CGAL_Kernel.Sphere_3_has_on_bounded_side(self, c)

    def has_on_unbounded_side(self, c):
        return _CGAL_Kernel.Sphere_3_has_on_unbounded_side(self, c)

    def has_on(self, c):
        return _CGAL_Kernel.Sphere_3_has_on(self, c)

    def opposite(self, *args):
        return _CGAL_Kernel.Sphere_3_opposite(self, *args)

    def bbox(self, *args):
        return _CGAL_Kernel.Sphere_3_bbox(self, *args)

    def __eq__(self, p):
        return _CGAL_Kernel.Sphere_3___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Sphere_3___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Sphere_3___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Sphere_3_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Sphere_3
    __del__ = lambda self: None
Sphere_3_swigregister = _CGAL_Kernel.Sphere_3_swigregister
Sphere_3_swigregister(Sphere_3)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Triangle_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def vertex(self, *args):
        return _CGAL_Kernel.Triangle_3_vertex(self, *args)

    def supporting_plane(self):
        return _CGAL_Kernel.Triangle_3_supporting_plane(self)

    def is_degenerate(self):
        return _CGAL_Kernel.Triangle_3_is_degenerate(self)

    def has_on(self, c):
        return _CGAL_Kernel.Triangle_3_has_on(self, c)

    def squared_area(self):
        return _CGAL_Kernel.Triangle_3_squared_area(self)

    def bbox(self, *args):
        return _CGAL_Kernel.Triangle_3_bbox(self, *args)

    def __eq__(self, p):
        return _CGAL_Kernel.Triangle_3___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Triangle_3___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Triangle_3___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Triangle_3_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Triangle_3
    __del__ = lambda self: None
Triangle_3_swigregister = _CGAL_Kernel.Triangle_3_swigregister
Triangle_3_swigregister(Triangle_3)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Ray_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def source(self, *args):
        return _CGAL_Kernel.Ray_3_source(self, *args)

    def point(self, *args):
        return _CGAL_Kernel.Ray_3_point(self, *args)

    def direction(self, *args):
        return _CGAL_Kernel.Ray_3_direction(self, *args)

    def to_vector(self, *args):
        return _CGAL_Kernel.Ray_3_to_vector(self, *args)

    def supporting_line(self, *args):
        return _CGAL_Kernel.Ray_3_supporting_line(self, *args)

    def opposite(self, *args):
        return _CGAL_Kernel.Ray_3_opposite(self, *args)

    def is_degenerate(self):
        return _CGAL_Kernel.Ray_3_is_degenerate(self)

    def has_on(self, c):
        return _CGAL_Kernel.Ray_3_has_on(self, c)

    def __eq__(self, p):
        return _CGAL_Kernel.Ray_3___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Ray_3___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Ray_3___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Ray_3_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Ray_3
    __del__ = lambda self: None
Ray_3_swigregister = _CGAL_Kernel.Ray_3_swigregister
Ray_3_swigregister(Ray_3)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Direction_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def delta(self, c):
        return _CGAL_Kernel.Direction_3_delta(self, c)

    def dx(self):
        return _CGAL_Kernel.Direction_3_dx(self)

    def dy(self):
        return _CGAL_Kernel.Direction_3_dy(self)

    def dz(self):
        return _CGAL_Kernel.Direction_3_dz(self)

    def vector(self, *args):
        return _CGAL_Kernel.Direction_3_vector(self, *args)

    def __eq__(self, p):
        return _CGAL_Kernel.Direction_3___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Direction_3___ne__(self, p)

    def __neg__(self):
        return _CGAL_Kernel.Direction_3___neg__(self)

    def __sub__(self, ref):
        return _CGAL_Kernel.Direction_3___sub__(self, ref)

    def __str__(self):
        return _CGAL_Kernel.Direction_3___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Direction_3_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Direction_3
    __del__ = lambda self: None
Direction_3_swigregister = _CGAL_Kernel.Direction_3_swigregister
Direction_3_swigregister(Direction_3)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Tetrahedron_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def vertex(self, *args):
        return _CGAL_Kernel.Tetrahedron_3_vertex(self, *args)

    def is_degenerate(self):
        return _CGAL_Kernel.Tetrahedron_3_is_degenerate(self)

    def has_on_positive_side(self, c):
        return _CGAL_Kernel.Tetrahedron_3_has_on_positive_side(self, c)

    def has_on_negative_side(self, c):
        return _CGAL_Kernel.Tetrahedron_3_has_on_negative_side(self, c)

    def has_on_boundary(self, c):
        return _CGAL_Kernel.Tetrahedron_3_has_on_boundary(self, c)

    def has_on_bounded_side(self, c):
        return _CGAL_Kernel.Tetrahedron_3_has_on_bounded_side(self, c)

    def has_on_unbounded_side(self, c):
        return _CGAL_Kernel.Tetrahedron_3_has_on_unbounded_side(self, c)

    def orientation(self):
        return _CGAL_Kernel.Tetrahedron_3_orientation(self)

    def oriented_side(self, c):
        return _CGAL_Kernel.Tetrahedron_3_oriented_side(self, c)

    def bounded_side(self, c):
        return _CGAL_Kernel.Tetrahedron_3_bounded_side(self, c)

    def volume(self):
        return _CGAL_Kernel.Tetrahedron_3_volume(self)

    def bbox(self, *args):
        return _CGAL_Kernel.Tetrahedron_3_bbox(self, *args)

    def __eq__(self, p):
        return _CGAL_Kernel.Tetrahedron_3___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Tetrahedron_3___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Tetrahedron_3___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Tetrahedron_3_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Tetrahedron_3
    __del__ = lambda self: None
Tetrahedron_3_swigregister = _CGAL_Kernel.Tetrahedron_3_swigregister
Tetrahedron_3_swigregister(Tetrahedron_3)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Vector_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def x(self):
        return _CGAL_Kernel.Vector_3_x(self)

    def y(self):
        return _CGAL_Kernel.Vector_3_y(self)

    def z(self):
        return _CGAL_Kernel.Vector_3_z(self)

    def cartesian(self, c):
        return _CGAL_Kernel.Vector_3_cartesian(self, c)

    def direction(self, *args):
        return _CGAL_Kernel.Vector_3_direction(self, *args)

    def squared_length(self):
        return _CGAL_Kernel.Vector_3_squared_length(self)

    def dimension(self):
        return _CGAL_Kernel.Vector_3_dimension(self)

    def __add__(self, c):
        return _CGAL_Kernel.Vector_3___add__(self, c)

    def __sub__(self, c):
        return _CGAL_Kernel.Vector_3___sub__(self, c)

    def __neg__(self):
        return _CGAL_Kernel.Vector_3___neg__(self)

    def __mul__(self, *args):
        return _CGAL_Kernel.Vector_3___mul__(self, *args)

    def __div__(self, c):
        return _CGAL_Kernel.Vector_3___div__(self, c)

    def __eq__(self, *args):
        return _CGAL_Kernel.Vector_3___eq__(self, *args)

    def __ne__(self, p):
        return _CGAL_Kernel.Vector_3___ne__(self, p)

    def __iadd__(self, v):
        return _CGAL_Kernel.Vector_3___iadd__(self, v)

    def __isub__(self, v):
        return _CGAL_Kernel.Vector_3___isub__(self, v)

    def __imul__(self, d):
        return _CGAL_Kernel.Vector_3___imul__(self, d)

    def __idiv__(self, d):
        return _CGAL_Kernel.Vector_3___idiv__(self, d)

    def set_coordinates(self, x, y, z):
        return _CGAL_Kernel.Vector_3_set_coordinates(self, x, y, z)

    def __str__(self):
        return _CGAL_Kernel.Vector_3___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Vector_3_deepcopy(self, *args)

    def normalize(self):
        return _CGAL_Kernel.Vector_3_normalize(self)
    __swig_destroy__ = _CGAL_Kernel.delete_Vector_3
    __del__ = lambda self: None
Vector_3_swigregister = _CGAL_Kernel.Vector_3_swigregister
Vector_3_swigregister(Vector_3)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Bbox_2(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def dimension(self):
        return _CGAL_Kernel.Bbox_2_dimension(self)

    def xmin(self):
        return _CGAL_Kernel.Bbox_2_xmin(self)

    def ymin(self):
        return _CGAL_Kernel.Bbox_2_ymin(self)

    def xmax(self):
        return _CGAL_Kernel.Bbox_2_xmax(self)

    def ymax(self):
        return _CGAL_Kernel.Bbox_2_ymax(self)

    def min(self, i):
        return _CGAL_Kernel.Bbox_2_min(self, i)

    def max(self, i):
        return _CGAL_Kernel.Bbox_2_max(self, i)

    def __add__(self, c):
        return _CGAL_Kernel.Bbox_2___add__(self, c)

    def __iadd__(self, c):
        return _CGAL_Kernel.Bbox_2___iadd__(self, c)

    def __eq__(self, p):
        return _CGAL_Kernel.Bbox_2___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Bbox_2___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Bbox_2___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Bbox_2_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Bbox_2
    __del__ = lambda self: None
Bbox_2_swigregister = _CGAL_Kernel.Bbox_2_swigregister
Bbox_2_swigregister(Bbox_2)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Bbox_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def dimension(self):
        return _CGAL_Kernel.Bbox_3_dimension(self)

    def xmin(self):
        return _CGAL_Kernel.Bbox_3_xmin(self)

    def ymin(self):
        return _CGAL_Kernel.Bbox_3_ymin(self)

    def zmin(self):
        return _CGAL_Kernel.Bbox_3_zmin(self)

    def xmax(self):
        return _CGAL_Kernel.Bbox_3_xmax(self)

    def ymax(self):
        return _CGAL_Kernel.Bbox_3_ymax(self)

    def zmax(self):
        return _CGAL_Kernel.Bbox_3_zmax(self)

    def min(self, i):
        return _CGAL_Kernel.Bbox_3_min(self, i)

    def max(self, i):
        return _CGAL_Kernel.Bbox_3_max(self, i)

    def __add__(self, c):
        return _CGAL_Kernel.Bbox_3___add__(self, c)

    def __iadd__(self, c):
        return _CGAL_Kernel.Bbox_3___iadd__(self, c)

    def __eq__(self, p):
        return _CGAL_Kernel.Bbox_3___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Bbox_3___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Bbox_3___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Bbox_3_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Bbox_3
    __del__ = lambda self: None
Bbox_3_swigregister = _CGAL_Kernel.Bbox_3_swigregister
Bbox_3_swigregister(Bbox_3)

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

    def __init__(self):
        this = _CGAL_Kernel.new_Object()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def is_Point_2(self):
        return _CGAL_Kernel.Object_is_Point_2(self)

    def get_Point_2(self):
        return _CGAL_Kernel.Object_get_Point_2(self)

    def is_Point_3(self):
        return _CGAL_Kernel.Object_is_Point_3(self)

    def get_Point_3(self):
        return _CGAL_Kernel.Object_get_Point_3(self)

    def is_Triangle_2(self):
        return _CGAL_Kernel.Object_is_Triangle_2(self)

    def get_Triangle_2(self):
        return _CGAL_Kernel.Object_get_Triangle_2(self)

    def is_Triangle_3(self):
        return _CGAL_Kernel.Object_is_Triangle_3(self)

    def get_Triangle_3(self):
        return _CGAL_Kernel.Object_get_Triangle_3(self)

    def is_Segment_3(self):
        return _CGAL_Kernel.Object_is_Segment_3(self)

    def get_Segment_3(self):
        return _CGAL_Kernel.Object_get_Segment_3(self)

    def is_Segment_2(self):
        return _CGAL_Kernel.Object_is_Segment_2(self)

    def get_Segment_2(self):
        return _CGAL_Kernel.Object_get_Segment_2(self)

    def is_Line_3(self):
        return _CGAL_Kernel.Object_is_Line_3(self)

    def get_Line_3(self):
        return _CGAL_Kernel.Object_get_Line_3(self)

    def is_Line_2(self):
        return _CGAL_Kernel.Object_is_Line_2(self)

    def get_Line_2(self):
        return _CGAL_Kernel.Object_get_Line_2(self)

    def is_Plane_3(self):
        return _CGAL_Kernel.Object_is_Plane_3(self)

    def get_Plane_3(self):
        return _CGAL_Kernel.Object_get_Plane_3(self)

    def is_Ray_2(self):
        return _CGAL_Kernel.Object_is_Ray_2(self)

    def get_Ray_2(self):
        return _CGAL_Kernel.Object_get_Ray_2(self)

    def is_Ray_3(self):
        return _CGAL_Kernel.Object_is_Ray_3(self)

    def get_Ray_3(self):
        return _CGAL_Kernel.Object_get_Ray_3(self)

    def empty(self):
        return _CGAL_Kernel.Object_empty(self)
    __swig_destroy__ = _CGAL_Kernel.delete_Object
    __del__ = lambda self: None
Object_swigregister = _CGAL_Kernel.Object_swigregister
Object_swigregister(Object)


_CGAL_Kernel.ON_NEGATIVE_SIDE_swigconstant(_CGAL_Kernel)
ON_NEGATIVE_SIDE = _CGAL_Kernel.ON_NEGATIVE_SIDE

_CGAL_Kernel.ON_ORIENTED_BOUNDARY_swigconstant(_CGAL_Kernel)
ON_ORIENTED_BOUNDARY = _CGAL_Kernel.ON_ORIENTED_BOUNDARY

_CGAL_Kernel.ON_POSITIVE_SIDE_swigconstant(_CGAL_Kernel)
ON_POSITIVE_SIDE = _CGAL_Kernel.ON_POSITIVE_SIDE

_CGAL_Kernel.ON_UNBOUNDED_SIDE_swigconstant(_CGAL_Kernel)
ON_UNBOUNDED_SIDE = _CGAL_Kernel.ON_UNBOUNDED_SIDE

_CGAL_Kernel.ON_BOUNDARY_swigconstant(_CGAL_Kernel)
ON_BOUNDARY = _CGAL_Kernel.ON_BOUNDARY

_CGAL_Kernel.ON_BOUNDED_SIDE_swigconstant(_CGAL_Kernel)
ON_BOUNDED_SIDE = _CGAL_Kernel.ON_BOUNDED_SIDE

_CGAL_Kernel.NEGATIVE_swigconstant(_CGAL_Kernel)
NEGATIVE = _CGAL_Kernel.NEGATIVE

_CGAL_Kernel.RIGHT_TURN_swigconstant(_CGAL_Kernel)
RIGHT_TURN = _CGAL_Kernel.RIGHT_TURN

_CGAL_Kernel.CLOCKWISE_swigconstant(_CGAL_Kernel)
CLOCKWISE = _CGAL_Kernel.CLOCKWISE

_CGAL_Kernel.ZERO_swigconstant(_CGAL_Kernel)
ZERO = _CGAL_Kernel.ZERO

_CGAL_Kernel.COPLANAR_swigconstant(_CGAL_Kernel)
COPLANAR = _CGAL_Kernel.COPLANAR

_CGAL_Kernel.COLLINEAR_swigconstant(_CGAL_Kernel)
COLLINEAR = _CGAL_Kernel.COLLINEAR

_CGAL_Kernel.LEFT_TURN_swigconstant(_CGAL_Kernel)
LEFT_TURN = _CGAL_Kernel.LEFT_TURN

_CGAL_Kernel.COUNTERCLOCKWISE_swigconstant(_CGAL_Kernel)
COUNTERCLOCKWISE = _CGAL_Kernel.COUNTERCLOCKWISE

_CGAL_Kernel.POSITIVE_swigconstant(_CGAL_Kernel)
POSITIVE = _CGAL_Kernel.POSITIVE
class Polygon_2(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Polygon_2, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Polygon_2, name)
    __repr__ = _swig_repr

    def set(self, pos, x):
        return _CGAL_Kernel.Polygon_2_set(self, pos, x)

    def push_back(self, c):
        return _CGAL_Kernel.Polygon_2_push_back(self, c)

    def clear(self):
        return _CGAL_Kernel.Polygon_2_clear(self)

    def reverse_orientation(self):
        return _CGAL_Kernel.Polygon_2_reverse_orientation(self)

    def erase(self, *args):
        return _CGAL_Kernel.Polygon_2_erase(self, *args)

    def is_simple(self):
        return _CGAL_Kernel.Polygon_2_is_simple(self)

    def is_convex(self):
        return _CGAL_Kernel.Polygon_2_is_convex(self)

    def orientation(self):
        return _CGAL_Kernel.Polygon_2_orientation(self)

    def oriented_side(self, c):
        return _CGAL_Kernel.Polygon_2_oriented_side(self, c)

    def bounded_side(self, c):
        return _CGAL_Kernel.Polygon_2_bounded_side(self, c)

    def area(self):
        return _CGAL_Kernel.Polygon_2_area(self)

    def left_vertex(self):
        return _CGAL_Kernel.Polygon_2_left_vertex(self)

    def right_vertex(self):
        return _CGAL_Kernel.Polygon_2_right_vertex(self)

    def top_vertex(self):
        return _CGAL_Kernel.Polygon_2_top_vertex(self)

    def bottom_vertex(self):
        return _CGAL_Kernel.Polygon_2_bottom_vertex(self)

    def is_counterclockwise_oriented(self):
        return _CGAL_Kernel.Polygon_2_is_counterclockwise_oriented(self)

    def is_clockwise_oriented(self):
        return _CGAL_Kernel.Polygon_2_is_clockwise_oriented(self)

    def is_collinear_oriented(self):
        return _CGAL_Kernel.Polygon_2_is_collinear_oriented(self)

    def has_on_positive_side(self, c):
        return _CGAL_Kernel.Polygon_2_has_on_positive_side(self, c)

    def has_on_negative_side(self, c):
        return _CGAL_Kernel.Polygon_2_has_on_negative_side(self, c)

    def has_on_boundary(self, c):
        return _CGAL_Kernel.Polygon_2_has_on_boundary(self, c)

    def has_on_bounded_side(self, c):
        return _CGAL_Kernel.Polygon_2_has_on_bounded_side(self, c)

    def has_on_unbounded_side(self, c):
        return _CGAL_Kernel.Polygon_2_has_on_unbounded_side(self, c)

    def vertex(self, *args):
        return _CGAL_Kernel.Polygon_2_vertex(self, *args)

    def edge(self, *args):
        return _CGAL_Kernel.Polygon_2_edge(self, *args)

    def size(self):
        return _CGAL_Kernel.Polygon_2_size(self)

    def is_empty(self):
        return _CGAL_Kernel.Polygon_2_is_empty(self)

    def bbox(self, *args):
        return _CGAL_Kernel.Polygon_2_bbox(self, *args)

    def __eq__(self, p):
        return _CGAL_Kernel.Polygon_2___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Polygon_2___ne__(self, p)

    def __str__(self):
        return _CGAL_Kernel.Polygon_2___str__(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Polygon_2_deepcopy(self, *args)

    def insert(self, *args):
        return _CGAL_Kernel.Polygon_2_insert(self, *args)

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Polygon_2(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def vertices(self):
        return _CGAL_Kernel.Polygon_2_vertices(self)

    def edges(self):
        return _CGAL_Kernel.Polygon_2_edges(self)

    def vertices_circulator(self):
        return _CGAL_Kernel.Polygon_2_vertices_circulator(self)

    def edges_circulator(self):
        return _CGAL_Kernel.Polygon_2_edges_circulator(self)
    __swig_destroy__ = _CGAL_Kernel.delete_Polygon_2
    __del__ = lambda self: None
Polygon_2_swigregister = _CGAL_Kernel.Polygon_2_swigregister
Polygon_2_swigregister(Polygon_2)


def squared_distance(*args):
    return _CGAL_Kernel.squared_distance(*args)
squared_distance = _CGAL_Kernel.squared_distance

def do_intersect(*args):
    return _CGAL_Kernel.do_intersect(*args)
do_intersect = _CGAL_Kernel.do_intersect

def intersection(*args):
    return _CGAL_Kernel.intersection(*args)
intersection = _CGAL_Kernel.intersection

def area(arg1, arg2, arg3):
    return _CGAL_Kernel.area(arg1, arg2, arg3)
area = _CGAL_Kernel.area

def centroid(*args):
    return _CGAL_Kernel.centroid(*args)
centroid = _CGAL_Kernel.centroid

def cross_product(arg1, arg2):
    return _CGAL_Kernel.cross_product(arg1, arg2)
cross_product = _CGAL_Kernel.cross_product

def determinant(*args):
    return _CGAL_Kernel.determinant(*args)
determinant = _CGAL_Kernel.determinant
class Origin(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Origin, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Origin, name)
    __repr__ = _swig_repr

    def __add__(self, *args):
        return _CGAL_Kernel.Origin___add__(self, *args)

    def __sub__(self, *args):
        return _CGAL_Kernel.Origin___sub__(self, *args)

    def __init__(self):
        this = _CGAL_Kernel.new_Origin()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _CGAL_Kernel.delete_Origin
    __del__ = lambda self: None
Origin_swigregister = _CGAL_Kernel.Origin_swigregister
Origin_swigregister(Origin)

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

    def __init__(self):
        this = _CGAL_Kernel.new_Null_vector()
        try:
            self.this.append(this)
        except Exception:
            self.this = this
    __swig_destroy__ = _CGAL_Kernel.delete_Null_vector
    __del__ = lambda self: None
Null_vector_swigregister = _CGAL_Kernel.Null_vector_swigregister
Null_vector_swigregister(Null_vector)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Iso_rectangle_2(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __eq__(self, p):
        return _CGAL_Kernel.Iso_rectangle_2___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Iso_rectangle_2___ne__(self, p)

    def vertex(self, *args):
        return _CGAL_Kernel.Iso_rectangle_2_vertex(self, *args)

    def min(self, *args):
        return _CGAL_Kernel.Iso_rectangle_2_min(self, *args)

    def max(self, *args):
        return _CGAL_Kernel.Iso_rectangle_2_max(self, *args)

    def xmin(self):
        return _CGAL_Kernel.Iso_rectangle_2_xmin(self)

    def ymin(self):
        return _CGAL_Kernel.Iso_rectangle_2_ymin(self)

    def xmax(self):
        return _CGAL_Kernel.Iso_rectangle_2_xmax(self)

    def ymax(self):
        return _CGAL_Kernel.Iso_rectangle_2_ymax(self)

    def min_coord(self, c):
        return _CGAL_Kernel.Iso_rectangle_2_min_coord(self, c)

    def max_coord(self, c):
        return _CGAL_Kernel.Iso_rectangle_2_max_coord(self, c)

    def bbox(self, *args):
        return _CGAL_Kernel.Iso_rectangle_2_bbox(self, *args)

    def is_degenerate(self):
        return _CGAL_Kernel.Iso_rectangle_2_is_degenerate(self)

    def bounded_side(self, c):
        return _CGAL_Kernel.Iso_rectangle_2_bounded_side(self, c)

    def has_on_boundary(self, c):
        return _CGAL_Kernel.Iso_rectangle_2_has_on_boundary(self, c)

    def has_on_bounded_side(self, c):
        return _CGAL_Kernel.Iso_rectangle_2_has_on_bounded_side(self, c)

    def has_on_unbounded_side(self, c):
        return _CGAL_Kernel.Iso_rectangle_2_has_on_unbounded_side(self, c)

    def area(self):
        return _CGAL_Kernel.Iso_rectangle_2_area(self)
    __swig_destroy__ = _CGAL_Kernel.delete_Iso_rectangle_2
    __del__ = lambda self: None
Iso_rectangle_2_swigregister = _CGAL_Kernel.Iso_rectangle_2_swigregister
Iso_rectangle_2_swigregister(Iso_rectangle_2)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Iso_cuboid_3(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __eq__(self, p):
        return _CGAL_Kernel.Iso_cuboid_3___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Iso_cuboid_3___ne__(self, p)

    def vertex(self, *args):
        return _CGAL_Kernel.Iso_cuboid_3_vertex(self, *args)

    def min(self, *args):
        return _CGAL_Kernel.Iso_cuboid_3_min(self, *args)

    def max(self, *args):
        return _CGAL_Kernel.Iso_cuboid_3_max(self, *args)

    def xmin(self):
        return _CGAL_Kernel.Iso_cuboid_3_xmin(self)

    def ymin(self):
        return _CGAL_Kernel.Iso_cuboid_3_ymin(self)

    def zmin(self):
        return _CGAL_Kernel.Iso_cuboid_3_zmin(self)

    def xmax(self):
        return _CGAL_Kernel.Iso_cuboid_3_xmax(self)

    def ymax(self):
        return _CGAL_Kernel.Iso_cuboid_3_ymax(self)

    def zmax(self):
        return _CGAL_Kernel.Iso_cuboid_3_zmax(self)

    def min_coord(self, c):
        return _CGAL_Kernel.Iso_cuboid_3_min_coord(self, c)

    def max_coord(self, c):
        return _CGAL_Kernel.Iso_cuboid_3_max_coord(self, c)

    def bbox(self, *args):
        return _CGAL_Kernel.Iso_cuboid_3_bbox(self, *args)

    def is_degenerate(self):
        return _CGAL_Kernel.Iso_cuboid_3_is_degenerate(self)

    def bounded_side(self, c):
        return _CGAL_Kernel.Iso_cuboid_3_bounded_side(self, c)

    def has_on_boundary(self, c):
        return _CGAL_Kernel.Iso_cuboid_3_has_on_boundary(self, c)

    def has_on_bounded_side(self, c):
        return _CGAL_Kernel.Iso_cuboid_3_has_on_bounded_side(self, c)

    def has_on_unbounded_side(self, c):
        return _CGAL_Kernel.Iso_cuboid_3_has_on_unbounded_side(self, c)

    def volume(self):
        return _CGAL_Kernel.Iso_cuboid_3_volume(self)
    __swig_destroy__ = _CGAL_Kernel.delete_Iso_cuboid_3
    __del__ = lambda self: None
Iso_cuboid_3_swigregister = _CGAL_Kernel.Iso_cuboid_3_swigregister
Iso_cuboid_3_swigregister(Iso_cuboid_3)

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

    def __init__(self, *args):
        this = _CGAL_Kernel.new_Ref_int(*args)
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def set(self, t):
        return _CGAL_Kernel.Ref_int_set(self, t)

    def object(self):
        return _CGAL_Kernel.Ref_int_object(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Ref_int_deepcopy(self, *args)
    __swig_destroy__ = _CGAL_Kernel.delete_Ref_int
    __del__ = lambda self: None
Ref_int_swigregister = _CGAL_Kernel.Ref_int_swigregister
Ref_int_swigregister(Ref_int)
cvar = _CGAL_Kernel.cvar
ORIGIN = cvar.ORIGIN
NULL_VECTOR = cvar.NULL_VECTOR


Vector_2.__rmul__ = Vector_2.__mul__
Vector_3.__rmul__ = Vector_3.__mul__
Vector_2.__idiv__ = Vector_2.__div__
Vector_3.__idiv__ = Vector_3.__div__
Vector_2.__truediv__ = Vector_2.__div__
Vector_3.__truediv__ = Vector_3.__div__

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

    def __init__(self):
        this = _CGAL_Kernel.new_Polygon_2_Vertex_iterator()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __iter__(self):
        return _CGAL_Kernel.Polygon_2_Vertex_iterator___iter__(self)

    def __next__(self):
        return _CGAL_Kernel.Polygon_2_Vertex_iterator___next__(self)

    def next(self, *args):
        return _CGAL_Kernel.Polygon_2_Vertex_iterator_next(self, *args)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Polygon_2_Vertex_iterator_deepcopy(self, *args)

    def hasNext(self):
        return _CGAL_Kernel.Polygon_2_Vertex_iterator_hasNext(self)

    def __eq__(self, p):
        return _CGAL_Kernel.Polygon_2_Vertex_iterator___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Polygon_2_Vertex_iterator___ne__(self, p)
    __swig_destroy__ = _CGAL_Kernel.delete_Polygon_2_Vertex_iterator
    __del__ = lambda self: None
Polygon_2_Vertex_iterator_swigregister = _CGAL_Kernel.Polygon_2_Vertex_iterator_swigregister
Polygon_2_Vertex_iterator_swigregister(Polygon_2_Vertex_iterator)

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

    def __init__(self):
        this = _CGAL_Kernel.new_Polygon_2_Edge_const_iterator()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __iter__(self):
        return _CGAL_Kernel.Polygon_2_Edge_const_iterator___iter__(self)

    def __next__(self):
        return _CGAL_Kernel.Polygon_2_Edge_const_iterator___next__(self)

    def next(self, *args):
        return _CGAL_Kernel.Polygon_2_Edge_const_iterator_next(self, *args)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Polygon_2_Edge_const_iterator_deepcopy(self, *args)

    def hasNext(self):
        return _CGAL_Kernel.Polygon_2_Edge_const_iterator_hasNext(self)

    def __eq__(self, p):
        return _CGAL_Kernel.Polygon_2_Edge_const_iterator___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Polygon_2_Edge_const_iterator___ne__(self, p)
    __swig_destroy__ = _CGAL_Kernel.delete_Polygon_2_Edge_const_iterator
    __del__ = lambda self: None
Polygon_2_Edge_const_iterator_swigregister = _CGAL_Kernel.Polygon_2_Edge_const_iterator_swigregister
Polygon_2_Edge_const_iterator_swigregister(Polygon_2_Edge_const_iterator)

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

    def __init__(self):
        this = _CGAL_Kernel.new_Polygon_2_Vertex_circulator()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __iter__(self):
        return _CGAL_Kernel.Polygon_2_Vertex_circulator___iter__(self)

    def next(self):
        return _CGAL_Kernel.Polygon_2_Vertex_circulator_next(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Polygon_2_Vertex_circulator_deepcopy(self, *args)

    def prev(self):
        return _CGAL_Kernel.Polygon_2_Vertex_circulator_prev(self)

    def hasNext(self):
        return _CGAL_Kernel.Polygon_2_Vertex_circulator_hasNext(self)

    def __eq__(self, p):
        return _CGAL_Kernel.Polygon_2_Vertex_circulator___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Polygon_2_Vertex_circulator___ne__(self, p)
    __swig_destroy__ = _CGAL_Kernel.delete_Polygon_2_Vertex_circulator
    __del__ = lambda self: None
Polygon_2_Vertex_circulator_swigregister = _CGAL_Kernel.Polygon_2_Vertex_circulator_swigregister
Polygon_2_Vertex_circulator_swigregister(Polygon_2_Vertex_circulator)

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

    def __init__(self):
        this = _CGAL_Kernel.new_Polygon_2_Edge_const_circulator()
        try:
            self.this.append(this)
        except Exception:
            self.this = this

    def __iter__(self):
        return _CGAL_Kernel.Polygon_2_Edge_const_circulator___iter__(self)

    def next(self):
        return _CGAL_Kernel.Polygon_2_Edge_const_circulator_next(self)

    def deepcopy(self, *args):
        return _CGAL_Kernel.Polygon_2_Edge_const_circulator_deepcopy(self, *args)

    def prev(self):
        return _CGAL_Kernel.Polygon_2_Edge_const_circulator_prev(self)

    def hasNext(self):
        return _CGAL_Kernel.Polygon_2_Edge_const_circulator_hasNext(self)

    def __eq__(self, p):
        return _CGAL_Kernel.Polygon_2_Edge_const_circulator___eq__(self, p)

    def __ne__(self, p):
        return _CGAL_Kernel.Polygon_2_Edge_const_circulator___ne__(self, p)
    __swig_destroy__ = _CGAL_Kernel.delete_Polygon_2_Edge_const_circulator
    __del__ = lambda self: None
Polygon_2_Edge_const_circulator_swigregister = _CGAL_Kernel.Polygon_2_Edge_const_circulator_swigregister
Polygon_2_Edge_const_circulator_swigregister(Polygon_2_Edge_const_circulator)


def bounded_side_2(range, p):
    return _CGAL_Kernel.bounded_side_2(range, p)
bounded_side_2 = _CGAL_Kernel.bounded_side_2
# This file is compatible with both classic and new-style classes.


