# 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, '_ifcopenshell_wrapper')).lstrip('.')
        try:
            return importlib.import_module(mname)
        except ImportError:
            return importlib.import_module('_ifcopenshell_wrapper')
    _ifcopenshell_wrapper = 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('_ifcopenshell_wrapper', [dirname(__file__)])
        except ImportError:
            import _ifcopenshell_wrapper
            return _ifcopenshell_wrapper
        try:
            _mod = imp.load_module('_ifcopenshell_wrapper', fp, pathname, description)
        finally:
            if fp is not None:
                fp.close()
        return _mod
    _ifcopenshell_wrapper = swig_import_helper()
    del swig_import_helper
else:
    import _ifcopenshell_wrapper
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

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__ = _ifcopenshell_wrapper.delete_SwigPyIterator
    __del__ = lambda self: None

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    def iterator(self):
        return _ifcopenshell_wrapper.DoubleArray3_iterator(self)
    def __iter__(self):
        return self.iterator()

    def __nonzero__(self):
        return _ifcopenshell_wrapper.DoubleArray3___nonzero__(self)

    def __bool__(self):
        return _ifcopenshell_wrapper.DoubleArray3___bool__(self)

    def __len__(self):
        return _ifcopenshell_wrapper.DoubleArray3___len__(self)

    def __getslice__(self, i, j):
        return _ifcopenshell_wrapper.DoubleArray3___getslice__(self, i, j)

    def __setslice__(self, *args):
        return _ifcopenshell_wrapper.DoubleArray3___setslice__(self, *args)

    def __delslice__(self, i, j):
        return _ifcopenshell_wrapper.DoubleArray3___delslice__(self, i, j)

    def __delitem__(self, *args):
        return _ifcopenshell_wrapper.DoubleArray3___delitem__(self, *args)

    def __getitem__(self, *args):
        return _ifcopenshell_wrapper.DoubleArray3___getitem__(self, *args)

    def __setitem__(self, *args):
        return _ifcopenshell_wrapper.DoubleArray3___setitem__(self, *args)

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

    def empty(self):
        return _ifcopenshell_wrapper.DoubleArray3_empty(self)

    def size(self):
        return _ifcopenshell_wrapper.DoubleArray3_size(self)

    def swap(self, v):
        return _ifcopenshell_wrapper.DoubleArray3_swap(self, v)

    def begin(self):
        return _ifcopenshell_wrapper.DoubleArray3_begin(self)

    def end(self):
        return _ifcopenshell_wrapper.DoubleArray3_end(self)

    def rbegin(self):
        return _ifcopenshell_wrapper.DoubleArray3_rbegin(self)

    def rend(self):
        return _ifcopenshell_wrapper.DoubleArray3_rend(self)

    def front(self):
        return _ifcopenshell_wrapper.DoubleArray3_front(self)

    def back(self):
        return _ifcopenshell_wrapper.DoubleArray3_back(self)

    def fill(self, u):
        return _ifcopenshell_wrapper.DoubleArray3_fill(self, u)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_DoubleArray3
    __del__ = lambda self: None
DoubleArray3_swigregister = _ifcopenshell_wrapper.DoubleArray3_swigregister
DoubleArray3_swigregister(DoubleArray3)


def taxonomy_item_repr(i):
    """taxonomy_item_repr(ifcopenshell::geometry::taxonomy::item::ptr i) -> std::string"""
    return _ifcopenshell_wrapper.taxonomy_item_repr(i)
class OpaqueNumber(_object):
    """Proxy of C++ IfcGeom::OpaqueNumber class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def to_double(self):
        """to_double(OpaqueNumber self) -> double"""
        return _ifcopenshell_wrapper.OpaqueNumber_to_double(self)


    def to_string(self):
        """to_string(OpaqueNumber self) -> std::string"""
        return _ifcopenshell_wrapper.OpaqueNumber_to_string(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_OpaqueNumber
    __del__ = lambda self: None

    def __add__(self, other):
        """__add__(OpaqueNumber self, OpaqueNumber other) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueNumber___add__(self, other)


    def __sub__(self, other):
        """__sub__(OpaqueNumber self, OpaqueNumber other) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueNumber___sub__(self, other)


    def __mul__(self, other):
        """__mul__(OpaqueNumber self, OpaqueNumber other) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueNumber___mul__(self, other)


    def __truediv__(self, *args):
        return _ifcopenshell_wrapper.OpaqueNumber___truediv__(self, *args)
    __div__ = __truediv__



    def __eq__(self, other):
        """__eq__(OpaqueNumber self, OpaqueNumber other) -> bool"""
        return _ifcopenshell_wrapper.OpaqueNumber___eq__(self, other)


    def __lt__(self, other):
        """__lt__(OpaqueNumber self, OpaqueNumber other) -> bool"""
        return _ifcopenshell_wrapper.OpaqueNumber___lt__(self, other)


    def __neg__(self):
        """__neg__(OpaqueNumber self) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueNumber___neg__(self)


    def clone(self):
        """clone(OpaqueNumber self) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueNumber_clone(self)

OpaqueNumber_swigregister = _ifcopenshell_wrapper.OpaqueNumber_swigregister
OpaqueNumber_swigregister(OpaqueNumber)

class ConversionResultShape(_object):
    """Proxy of C++ IfcGeom::ConversionResultShape class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def Triangulate(self, *args):
        """
        Triangulate(ConversionResultShape self, Settings settings, matrix4 place, Triangulation t, int item_id, int surface_style_id)
        Triangulate(ConversionResultShape self, Settings settings) -> Triangulation
        """
        return _ifcopenshell_wrapper.ConversionResultShape_Triangulate(self, *args)


    def Serialize(self, place, arg3):
        """Serialize(ConversionResultShape self, matrix4 place, std::string & arg3)"""
        return _ifcopenshell_wrapper.ConversionResultShape_Serialize(self, place, arg3)


    def surface_genus(self):
        """surface_genus(ConversionResultShape self) -> int"""
        return _ifcopenshell_wrapper.ConversionResultShape_surface_genus(self)


    def is_manifold(self):
        """is_manifold(ConversionResultShape self) -> bool"""
        return _ifcopenshell_wrapper.ConversionResultShape_is_manifold(self)


    def num_vertices(self):
        """num_vertices(ConversionResultShape self) -> int"""
        return _ifcopenshell_wrapper.ConversionResultShape_num_vertices(self)


    def num_edges(self):
        """num_edges(ConversionResultShape self) -> int"""
        return _ifcopenshell_wrapper.ConversionResultShape_num_edges(self)


    def num_faces(self):
        """num_faces(ConversionResultShape self) -> int"""
        return _ifcopenshell_wrapper.ConversionResultShape_num_faces(self)


    def bounding_box(self, *args):
        """
        bounding_box(ConversionResultShape self, void *& arg2) -> double
        bounding_box(ConversionResultShape self) -> std::pair< IfcGeom::OpaqueCoordinate< 3 >,IfcGeom::OpaqueCoordinate< 3 > >
        """
        return _ifcopenshell_wrapper.ConversionResultShape_bounding_box(self, *args)


    def set_box(self, b):
        """set_box(ConversionResultShape self, void * b)"""
        return _ifcopenshell_wrapper.ConversionResultShape_set_box(self, b)


    def length(self):
        """length(ConversionResultShape self) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.ConversionResultShape_length(self)


    def area(self):
        """area(ConversionResultShape self) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.ConversionResultShape_area(self)


    def volume(self):
        """volume(ConversionResultShape self) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.ConversionResultShape_volume(self)


    def position(self):
        """position(ConversionResultShape self) -> OpaqueCoordinate_3"""
        return _ifcopenshell_wrapper.ConversionResultShape_position(self)


    def axis(self):
        """axis(ConversionResultShape self) -> OpaqueCoordinate_3"""
        return _ifcopenshell_wrapper.ConversionResultShape_axis(self)


    def plane_equation(self):
        """plane_equation(ConversionResultShape self) -> OpaqueCoordinate_4"""
        return _ifcopenshell_wrapper.ConversionResultShape_plane_equation(self)


    def convex_decomposition(self):
        """convex_decomposition(ConversionResultShape self) -> std::vector< IfcGeom::ConversionResultShape *,std::allocator< IfcGeom::ConversionResultShape * > >"""
        return _ifcopenshell_wrapper.ConversionResultShape_convex_decomposition(self)


    def halfspaces(self):
        """halfspaces(ConversionResultShape self) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_halfspaces(self)


    def box(self):
        """box(ConversionResultShape self) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_box(self)


    def solid(self):
        """solid(ConversionResultShape self) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_solid(self)


    def wrap_in_compound(self):
        """wrap_in_compound(ConversionResultShape self) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_wrap_in_compound(self)


    def vertices(self):
        """vertices(ConversionResultShape self) -> std::vector< IfcGeom::ConversionResultShape *,std::allocator< IfcGeom::ConversionResultShape * > >"""
        return _ifcopenshell_wrapper.ConversionResultShape_vertices(self)


    def edges(self):
        """edges(ConversionResultShape self) -> std::vector< IfcGeom::ConversionResultShape *,std::allocator< IfcGeom::ConversionResultShape * > >"""
        return _ifcopenshell_wrapper.ConversionResultShape_edges(self)


    def facets(self):
        """facets(ConversionResultShape self) -> std::vector< IfcGeom::ConversionResultShape *,std::allocator< IfcGeom::ConversionResultShape * > >"""
        return _ifcopenshell_wrapper.ConversionResultShape_facets(self)


    def add(self, arg2):
        """add(ConversionResultShape self, ConversionResultShape arg2) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_add(self, arg2)


    def subtract(self, arg2):
        """subtract(ConversionResultShape self, ConversionResultShape arg2) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_subtract(self, arg2)


    def intersect(self, arg2):
        """intersect(ConversionResultShape self, ConversionResultShape arg2) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_intersect(self, arg2)


    def concat(self, arg2):
        """concat(ConversionResultShape self, ConversionResultShape arg2) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_concat(self, arg2)


    def map(self, *args):
        """
        map(ConversionResultShape self, OpaqueCoordinate_4 arg2, OpaqueCoordinate_4 to)
        map(ConversionResultShape self, std::vector< IfcGeom::OpaqueCoordinate< 4 >,std::allocator< IfcGeom::OpaqueCoordinate< 4 > > > const & arg2, std::vector< IfcGeom::OpaqueCoordinate< 4 >,std::allocator< IfcGeom::OpaqueCoordinate< 4 > > > const & to)
        """
        return _ifcopenshell_wrapper.ConversionResultShape_map(self, *args)


    def moved(self, arg2):
        """moved(ConversionResultShape self, ifcopenshell::geometry::taxonomy::matrix4::ptr arg2) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_moved(self, arg2)


    def surface_area_along_direction(self, tol, arg3, along_x, along_y, along_z):
        """surface_area_along_direction(ConversionResultShape self, double tol, ifcopenshell::geometry::taxonomy::matrix4::ptr const & arg3, double & along_x, double & along_y, double & along_z) -> bool"""
        return _ifcopenshell_wrapper.ConversionResultShape_surface_area_along_direction(self, tol, arg3, along_x, along_y, along_z)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_ConversionResultShape
    __del__ = lambda self: None

    def serialize_obj(self):
        """serialize_obj(ConversionResultShape self) -> std::string"""
        return _ifcopenshell_wrapper.ConversionResultShape_serialize_obj(self)


    def convex_tag(self, b):
        """convex_tag(ConversionResultShape self, bool b)"""
        return _ifcopenshell_wrapper.ConversionResultShape_convex_tag(self, b)


    def serialize(self):
        """serialize(ConversionResultShape self) -> std::string"""
        return _ifcopenshell_wrapper.ConversionResultShape_serialize(self)


    def solid_mt(self):
        """solid_mt(ConversionResultShape self) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.ConversionResultShape_solid_mt(self)

ConversionResultShape_swigregister = _ifcopenshell_wrapper.ConversionResultShape_swigregister
ConversionResultShape_swigregister(ConversionResultShape)

class ConversionResult(_object):
    """Proxy of C++ IfcGeom::ConversionResult class."""

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

    def __init__(self, *args):
        """
        __init__(IfcGeom::ConversionResult self, int id, ifcopenshell::geometry::taxonomy::matrix4::ptr placement, ConversionResultShape shape, ifcopenshell::geometry::taxonomy::style::ptr style) -> ConversionResult
        __init__(IfcGeom::ConversionResult self, int id, ifcopenshell::geometry::taxonomy::matrix4::ptr placement, ConversionResultShape shape) -> ConversionResult
        __init__(IfcGeom::ConversionResult self, int id, ConversionResultShape shape, ifcopenshell::geometry::taxonomy::style::ptr style) -> ConversionResult
        __init__(IfcGeom::ConversionResult self, int id, ConversionResultShape shape) -> ConversionResult
        """
        this = _ifcopenshell_wrapper.new_ConversionResult(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def append(self, trsf):
        """append(ConversionResult self, ifcopenshell::geometry::taxonomy::matrix4::ptr trsf)"""
        return _ifcopenshell_wrapper.ConversionResult_append(self, trsf)


    def prepend(self, trsf):
        """prepend(ConversionResult self, ifcopenshell::geometry::taxonomy::matrix4::ptr trsf)"""
        return _ifcopenshell_wrapper.ConversionResult_prepend(self, trsf)


    def Shape(self):
        """Shape(ConversionResult self) -> std::shared_ptr< IfcGeom::ConversionResultShape >"""
        return _ifcopenshell_wrapper.ConversionResult_Shape(self)


    def Placement(self):
        """Placement(ConversionResult self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr"""
        return _ifcopenshell_wrapper.ConversionResult_Placement(self)


    def hasStyle(self):
        """hasStyle(ConversionResult self) -> bool"""
        return _ifcopenshell_wrapper.ConversionResult_hasStyle(self)


    def Style(self):
        """Style(ConversionResult self) -> style"""
        return _ifcopenshell_wrapper.ConversionResult_Style(self)


    def StylePtr(self):
        """StylePtr(ConversionResult self) -> ifcopenshell::geometry::taxonomy::style::ptr"""
        return _ifcopenshell_wrapper.ConversionResult_StylePtr(self)


    def setStyle(self, newStyle):
        """setStyle(ConversionResult self, ifcopenshell::geometry::taxonomy::style::ptr newStyle)"""
        return _ifcopenshell_wrapper.ConversionResult_setStyle(self, newStyle)


    def ItemId(self):
        """ItemId(ConversionResult self) -> int"""
        return _ifcopenshell_wrapper.ConversionResult_ItemId(self)


    def apply_transform(self, unit_scale=1.):
        """
        apply_transform(ConversionResult self, double unit_scale=1.) -> ConversionResultShape
        apply_transform(ConversionResult self) -> ConversionResultShape
        """
        return _ifcopenshell_wrapper.ConversionResult_apply_transform(self, unit_scale)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_ConversionResult
    __del__ = lambda self: None
ConversionResult_swigregister = _ifcopenshell_wrapper.ConversionResult_swigregister
ConversionResult_swigregister(ConversionResult)

CURVES = _ifcopenshell_wrapper.CURVES
SURFACES_AND_SOLIDS = _ifcopenshell_wrapper.SURFACES_AND_SOLIDS
CURVES_SURFACES_AND_SOLIDS = _ifcopenshell_wrapper.CURVES_SURFACES_AND_SOLIDS
TRIANGULATED = _ifcopenshell_wrapper.TRIANGULATED
NATIVE = _ifcopenshell_wrapper.NATIVE
SERIALIZED = _ifcopenshell_wrapper.SERIALIZED
MAXSTEPSIZE = _ifcopenshell_wrapper.MAXSTEPSIZE
MINSTEPS = _ifcopenshell_wrapper.MINSTEPS
TRIANGLE_MESH = _ifcopenshell_wrapper.TRIANGLE_MESH
POLYHEDRON_WITHOUT_HOLES = _ifcopenshell_wrapper.POLYHEDRON_WITHOUT_HOLES
POLYHEDRON_WITH_HOLES = _ifcopenshell_wrapper.POLYHEDRON_WITH_HOLES

def __rshift__(*args):
    """
    __rshift__(std::istream & arg1, ifcopenshell::geometry::settings::OutputDimensionalityTypes & ioo) -> std::istream
    __rshift__(std::istream & arg1, ifcopenshell::geometry::settings::IteratorOutputOptions & ioo) -> std::istream
    __rshift__(std::istream & arg1, ifcopenshell::geometry::settings::FunctionStepMethod & ioo) -> std::istream
    __rshift__(std::istream & arg1, ifcopenshell::geometry::settings::TriangulationMethod & ioo) -> std::istream &
    """
    return _ifcopenshell_wrapper.__rshift__(*args)
class Settings(_object):
    """Proxy of C++ ifcopenshell::geometry::Settings class."""

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

    def set_(self, *args):
        """
        set_(Settings self, std::string const & name, bool val)
        set_(Settings self, std::string const & name, int val)
        set_(Settings self, std::string const & name, ifcopenshell::geometry::settings::IteratorOutputOptions val)
        set_(Settings self, std::string const & name, ifcopenshell::geometry::settings::FunctionStepMethod val)
        set_(Settings self, std::string const & name, ifcopenshell::geometry::settings::OutputDimensionalityTypes val)
        set_(Settings self, std::string const & name, double val)
        set_(Settings self, std::string const & name, std::string const & val)
        set_(Settings self, std::string const & name, std::set< int > const & val)
        set_(Settings self, std::string const & name, std::set< std::string > const & val)
        set_(Settings self, std::string const & name, std::vector< double,std::allocator< double > > const & val)
        """
        return _ifcopenshell_wrapper.Settings_set_(self, *args)


    def get_(self, name):
        """get_(Settings self, std::string const & name) -> ifcopenshell::geometry::Settings::value_variant_t"""
        return _ifcopenshell_wrapper.Settings_get_(self, name)


    def setting_names(self):
        """setting_names(Settings self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.Settings_setting_names(self)


    def get_type(self, name):
        """get_type(Settings self, std::string const & name) -> std::string"""
        return _ifcopenshell_wrapper.Settings_get_type(self, name)


    def __init__(self):
        """__init__(ifcopenshell::geometry::Settings self) -> Settings"""
        this = _ifcopenshell_wrapper.new_Settings()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Settings
    __del__ = lambda self: None
Settings_swigregister = _ifcopenshell_wrapper.Settings_swigregister
Settings_swigregister(Settings)

class geometry_exception(_object):
    """Proxy of C++ IfcGeom::geometry_exception class."""

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

    def __init__(self, m):
        """__init__(IfcGeom::geometry_exception self, std::string const & m) -> geometry_exception"""
        this = _ifcopenshell_wrapper.new_geometry_exception(m)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_geometry_exception
    __del__ = lambda self: None
geometry_exception_swigregister = _ifcopenshell_wrapper.geometry_exception_swigregister
geometry_exception_swigregister(geometry_exception)

class too_many_faces_exception(geometry_exception):
    """Proxy of C++ IfcGeom::too_many_faces_exception class."""

    __swig_setmethods__ = {}
    for _s in [geometry_exception]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, too_many_faces_exception, name, value)
    __swig_getmethods__ = {}
    for _s in [geometry_exception]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, too_many_faces_exception, name)
    __repr__ = _swig_repr

    def __init__(self):
        """__init__(IfcGeom::too_many_faces_exception self) -> too_many_faces_exception"""
        this = _ifcopenshell_wrapper.new_too_many_faces_exception()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_too_many_faces_exception
    __del__ = lambda self: None
too_many_faces_exception_swigregister = _ifcopenshell_wrapper.too_many_faces_exception_swigregister
too_many_faces_exception_swigregister(too_many_faces_exception)

class Transformation(_object):
    """Proxy of C++ IfcGeom::Transformation class."""

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

    def __init__(self, settings, matrix):
        """__init__(IfcGeom::Transformation self, Settings settings, ifcopenshell::geometry::taxonomy::matrix4::ptr const & matrix) -> Transformation"""
        this = _ifcopenshell_wrapper.new_Transformation(settings, matrix)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def data(self):
        """data(Transformation self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.Transformation_data(self)


    def matrix_(self):
        """matrix_(Transformation self) -> PyObject *"""
        return _ifcopenshell_wrapper.Transformation_matrix_(self)


            # Hide the getters with read-only property implementations
    matrix = property(matrix_)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_Transformation
    __del__ = lambda self: None
Transformation_swigregister = _ifcopenshell_wrapper.Transformation_swigregister
Transformation_swigregister(Transformation)

class Element(_object):
    """Proxy of C++ IfcGeom::Element class."""

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

    def id(self):
        """id(Element self) -> int"""
        return _ifcopenshell_wrapper.Element_id(self)


    def parent_id(self):
        """parent_id(Element self) -> int"""
        return _ifcopenshell_wrapper.Element_parent_id(self)


    def name(self):
        """name(Element self) -> std::string const &"""
        return _ifcopenshell_wrapper.Element_name(self)


    def type(self):
        """type(Element self) -> std::string const &"""
        return _ifcopenshell_wrapper.Element_type(self)


    def guid(self):
        """guid(Element self) -> std::string const &"""
        return _ifcopenshell_wrapper.Element_guid(self)


    def context(self):
        """context(Element self) -> std::string const &"""
        return _ifcopenshell_wrapper.Element_context(self)


    def unique_id(self):
        """unique_id(Element self) -> std::string const &"""
        return _ifcopenshell_wrapper.Element_unique_id(self)


    def transformation(self):
        """transformation(Element self) -> Transformation"""
        return _ifcopenshell_wrapper.Element_transformation(self)


    def product(self):
        """product(Element self) -> IfcBaseEntity"""
        return _ifcopenshell_wrapper.Element_product(self)


    def parents(self):
        """parents(Element self) -> std::vector< IfcGeom::Element const *,std::allocator< IfcGeom::Element const * > > const &"""
        return _ifcopenshell_wrapper.Element_parents(self)


    def SetParents(self, newparents):
        """SetParents(Element self, std::vector< IfcGeom::Element const *,std::allocator< IfcGeom::Element const * > > & newparents)"""
        return _ifcopenshell_wrapper.Element_SetParents(self, newparents)


    def __init__(self, settings, id, parent_id, name, type, guid, context, trsf, product):
        """__init__(IfcGeom::Element self, Settings settings, int id, int parent_id, std::string const & name, std::string const & type, std::string const & guid, std::string const & context, ifcopenshell::geometry::taxonomy::matrix4::ptr const & trsf, IfcBaseEntity product) -> Element"""
        this = _ifcopenshell_wrapper.new_Element(settings, id, parent_id, name, type, guid, context, trsf, product)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Element
    __del__ = lambda self: None

    def transformation_buffer(self):
        """transformation_buffer(Element self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Element_transformation_buffer(self)


    def product_(self):
        """product_(Element self) -> entity_instance"""
        return _ifcopenshell_wrapper.Element_product_(self)


            # Hide the getters with read-only property implementations
    id = property(id)
    parent_id = property(parent_id)
    name = property(name)
    type = property(type)
    guid = property(guid)
    context = property(context)
    unique_id = property(unique_id)
    transformation = property(transformation)
    product = property(product_)

    transformation_buffer = property(transformation_buffer)

Element_swigregister = _ifcopenshell_wrapper.Element_swigregister
Element_swigregister(Element)

def __eq__(element1, element2):
    """__eq__(Element element1, Element element2) -> bool"""
    return _ifcopenshell_wrapper.__eq__(element1, element2)

def __lt__(element1, element2):
    """__lt__(Element element1, Element element2) -> bool"""
    return _ifcopenshell_wrapper.__lt__(element1, element2)

class BRepElement(Element):
    """Proxy of C++ IfcGeom::BRepElement class."""

    __swig_setmethods__ = {}
    for _s in [Element]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BRepElement, name, value)
    __swig_getmethods__ = {}
    for _s in [Element]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BRepElement, name)
    __repr__ = _swig_repr

    def geometry_pointer(self):
        """geometry_pointer(BRepElement self) -> boost::shared_ptr< IfcGeom::Representation::BRep > const &"""
        return _ifcopenshell_wrapper.BRepElement_geometry_pointer(self)


    def geometry(self):
        """geometry(BRepElement self) -> BRep"""
        return _ifcopenshell_wrapper.BRepElement_geometry(self)


    def __init__(self, id, parent_id, name, type, guid, context, trsf, geometry, product):
        """__init__(IfcGeom::BRepElement self, int id, int parent_id, std::string const & name, std::string const & type, std::string const & guid, std::string const & context, ifcopenshell::geometry::taxonomy::matrix4::ptr const & trsf, boost::shared_ptr< IfcGeom::Representation::BRep > const & geometry, IfcBaseEntity product) -> BRepElement"""
        this = _ifcopenshell_wrapper.new_BRepElement(id, parent_id, name, type, guid, context, trsf, geometry, product)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calculate_projected_surface_area(self, along_x, along_y, along_z):
        """calculate_projected_surface_area(BRepElement self, double & along_x, double & along_y, double & along_z) -> bool"""
        return _ifcopenshell_wrapper.BRepElement_calculate_projected_surface_area(self, along_x, along_y, along_z)


    def calc_volume_(self):
        """calc_volume_(BRepElement self) -> double"""
        return _ifcopenshell_wrapper.BRepElement_calc_volume_(self)


    def calc_surface_area_(self):
        """calc_surface_area_(BRepElement self) -> double"""
        return _ifcopenshell_wrapper.BRepElement_calc_surface_area_(self)


            # Hide the getters with read-only property implementations
    geometry = property(geometry)
    volume = property(calc_volume_)
    surface_area = property(calc_surface_area_)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_BRepElement
    __del__ = lambda self: None
BRepElement_swigregister = _ifcopenshell_wrapper.BRepElement_swigregister
BRepElement_swigregister(BRepElement)

class TriangulationElement(Element):
    """Proxy of C++ IfcGeom::TriangulationElement class."""

    __swig_setmethods__ = {}
    for _s in [Element]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TriangulationElement, name, value)
    __swig_getmethods__ = {}
    for _s in [Element]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TriangulationElement, name)
    __repr__ = _swig_repr

    def geometry(self):
        """geometry(TriangulationElement self) -> Triangulation"""
        return _ifcopenshell_wrapper.TriangulationElement_geometry(self)


    def geometry_pointer(self):
        """geometry_pointer(TriangulationElement self) -> boost::shared_ptr< IfcGeom::Representation::Triangulation > const &"""
        return _ifcopenshell_wrapper.TriangulationElement_geometry_pointer(self)


    def __init__(self, *args):
        """
        __init__(IfcGeom::TriangulationElement self, BRepElement shape_model) -> TriangulationElement
        __init__(IfcGeom::TriangulationElement self, Element element, boost::shared_ptr< IfcGeom::Representation::Triangulation > const & geometry) -> TriangulationElement
        """
        this = _ifcopenshell_wrapper.new_TriangulationElement(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

            # Hide the getters with read-only property implementations
    geometry = property(geometry)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_TriangulationElement
    __del__ = lambda self: None
TriangulationElement_swigregister = _ifcopenshell_wrapper.TriangulationElement_swigregister
TriangulationElement_swigregister(TriangulationElement)

class SerializedElement(Element):
    """Proxy of C++ IfcGeom::SerializedElement class."""

    __swig_setmethods__ = {}
    for _s in [Element]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SerializedElement, name, value)
    __swig_getmethods__ = {}
    for _s in [Element]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SerializedElement, name)
    __repr__ = _swig_repr

    def geometry(self):
        """geometry(SerializedElement self) -> Serialization"""
        return _ifcopenshell_wrapper.SerializedElement_geometry(self)


    def __init__(self, shape_model):
        """__init__(IfcGeom::SerializedElement self, BRepElement shape_model) -> SerializedElement"""
        this = _ifcopenshell_wrapper.new_SerializedElement(shape_model)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_SerializedElement
    __del__ = lambda self: None

            # Hide the getters with read-only property implementations
    geometry = property(geometry)

SerializedElement_swigregister = _ifcopenshell_wrapper.SerializedElement_swigregister
SerializedElement_swigregister(SerializedElement)

class Representation(_object):
    """Proxy of C++ IfcGeom::Representation::Representation class."""

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

    def __init__(self, settings, entity, id):
        """__init__(IfcGeom::Representation::Representation self, Settings settings, std::string const & entity, std::string const & id) -> Representation"""
        this = _ifcopenshell_wrapper.new_Representation(settings, entity, id)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def settings(self):
        """settings(Representation self) -> Settings"""
        return _ifcopenshell_wrapper.Representation_settings(self)


    def entity(self):
        """entity(Representation self) -> std::string const &"""
        return _ifcopenshell_wrapper.Representation_entity(self)


    def id(self):
        """id(Representation self) -> std::string const &"""
        return _ifcopenshell_wrapper.Representation_id(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_Representation
    __del__ = lambda self: None

            # Hide the getters with read-only property implementations
    id = property(id)

Representation_swigregister = _ifcopenshell_wrapper.Representation_swigregister
Representation_swigregister(Representation)

class BRep(Representation):
    """Proxy of C++ IfcGeom::Representation::BRep class."""

    __swig_setmethods__ = {}
    for _s in [Representation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, BRep, name, value)
    __swig_getmethods__ = {}
    for _s in [Representation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, BRep, name)
    __repr__ = _swig_repr

    def __init__(self, settings, entity, id, shapes):
        """__init__(IfcGeom::Representation::BRep self, Settings settings, std::string const & entity, std::string const & id, IfcGeom::ConversionResults const & shapes) -> BRep"""
        this = _ifcopenshell_wrapper.new_BRep(settings, entity, id, shapes)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_BRep
    __del__ = lambda self: None

    def begin(self):
        """begin(BRep self) -> IfcGeom::ConversionResults::const_iterator"""
        return _ifcopenshell_wrapper.BRep_begin(self)


    def end(self):
        """end(BRep self) -> IfcGeom::ConversionResults::const_iterator"""
        return _ifcopenshell_wrapper.BRep_end(self)


    def shapes(self):
        """shapes(BRep self) -> IfcGeom::ConversionResults const &"""
        return _ifcopenshell_wrapper.BRep_shapes(self)


    def as_compound(self, force_meters=False):
        """
        as_compound(BRep self, bool force_meters=False) -> ConversionResultShape
        as_compound(BRep self) -> ConversionResultShape
        """
        return _ifcopenshell_wrapper.BRep_as_compound(self, force_meters)


    def calculate_volume(self, arg2):
        """calculate_volume(BRep self, double & arg2) -> bool"""
        return _ifcopenshell_wrapper.BRep_calculate_volume(self, arg2)


    def calculate_surface_area(self, arg2):
        """calculate_surface_area(BRep self, double & arg2) -> bool"""
        return _ifcopenshell_wrapper.BRep_calculate_surface_area(self, arg2)


    def calculate_projected_surface_area(self, ax, along_x, along_y, along_z):
        """calculate_projected_surface_area(BRep self, ifcopenshell::geometry::taxonomy::matrix4::ptr const & ax, double & along_x, double & along_y, double & along_z) -> bool"""
        return _ifcopenshell_wrapper.BRep_calculate_projected_surface_area(self, ax, along_x, along_y, along_z)


    def size(self):
        """size(BRep self) -> int"""
        return _ifcopenshell_wrapper.BRep_size(self)


    def item(self, i):
        """item(BRep self, int i) -> ConversionResultShape"""
        return _ifcopenshell_wrapper.BRep_item(self, i)


    def item_id(self, i):
        """item_id(BRep self, int i) -> int"""
        return _ifcopenshell_wrapper.BRep_item_id(self, i)

BRep_swigregister = _ifcopenshell_wrapper.BRep_swigregister
BRep_swigregister(BRep)

class Serialization(Representation):
    """Proxy of C++ IfcGeom::Representation::Serialization class."""

    __swig_setmethods__ = {}
    for _s in [Representation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Serialization, name, value)
    __swig_getmethods__ = {}
    for _s in [Representation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Serialization, name)
    __repr__ = _swig_repr

    def brep_data(self):
        """brep_data(Serialization self) -> std::string const &"""
        return _ifcopenshell_wrapper.Serialization_brep_data(self)


    def surface_styles(self):
        """surface_styles(Serialization self) -> std::vector< double,std::allocator< double > > const &"""
        return _ifcopenshell_wrapper.Serialization_surface_styles(self)


    def surface_style_ids(self):
        """surface_style_ids(Serialization self) -> std::vector< int,std::allocator< int > > const &"""
        return _ifcopenshell_wrapper.Serialization_surface_style_ids(self)


    def __init__(self, brep):
        """__init__(IfcGeom::Representation::Serialization self, BRep brep) -> Serialization"""
        this = _ifcopenshell_wrapper.new_Serialization(brep)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Serialization
    __del__ = lambda self: None

            # Hide the getters with read-only property implementations
    brep_data = property(brep_data)
    surface_styles = property(surface_styles)
    surface_style_ids = property(surface_style_ids)

Serialization_swigregister = _ifcopenshell_wrapper.Serialization_swigregister
Serialization_swigregister(Serialization)

class Triangulation(Representation):
    """Proxy of C++ IfcGeom::Representation::Triangulation class."""

    __swig_setmethods__ = {}
    for _s in [Representation]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Triangulation, name, value)
    __swig_getmethods__ = {}
    for _s in [Representation]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, Triangulation, name)
    __repr__ = _swig_repr

    def verts(self):
        """verts(Triangulation self) -> std::vector< double,std::allocator< double > > const &"""
        return _ifcopenshell_wrapper.Triangulation_verts(self)


    def faces(self):
        """faces(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
        return _ifcopenshell_wrapper.Triangulation_faces(self)


    def polyhedral_faces_without_holes(self):
        """polyhedral_faces_without_holes(Triangulation self) -> std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const &"""
        return _ifcopenshell_wrapper.Triangulation_polyhedral_faces_without_holes(self)


    def polyhedral_faces_with_holes(self):
        """polyhedral_faces_with_holes(Triangulation self) -> std::vector< std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > >,std::allocator< std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > > > const &"""
        return _ifcopenshell_wrapper.Triangulation_polyhedral_faces_with_holes(self)


    def edges(self):
        """edges(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
        return _ifcopenshell_wrapper.Triangulation_edges(self)


    def normals(self):
        """normals(Triangulation self) -> std::vector< double,std::allocator< double > > const &"""
        return _ifcopenshell_wrapper.Triangulation_normals(self)


    def uvs(self):
        """uvs(Triangulation self) -> std::vector< double,std::allocator< double > > const &"""
        return _ifcopenshell_wrapper.Triangulation_uvs(self)


    def uvs_ref(self):
        """uvs_ref(Triangulation self) -> std::vector< double,std::allocator< double > > &"""
        return _ifcopenshell_wrapper.Triangulation_uvs_ref(self)


    def material_ids(self):
        """material_ids(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
        return _ifcopenshell_wrapper.Triangulation_material_ids(self)


    def materials(self):
        """materials(Triangulation self) -> std::vector< ifcopenshell::geometry::taxonomy::style::ptr,std::allocator< ifcopenshell::geometry::taxonomy::style::ptr > > const &"""
        return _ifcopenshell_wrapper.Triangulation_materials(self)


    def item_ids(self):
        """item_ids(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
        return _ifcopenshell_wrapper.Triangulation_item_ids(self)


    def edges_item_ids(self):
        """edges_item_ids(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
        return _ifcopenshell_wrapper.Triangulation_edges_item_ids(self)


    def __init__(self, *args):
        """
        __init__(IfcGeom::Representation::Triangulation self, BRep shape_model) -> Triangulation
        __init__(IfcGeom::Representation::Triangulation self, Settings settings, std::string const & entity, std::string const & id, std::vector< double,std::allocator< double > > const & verts, std::vector< int,std::allocator< int > > const & faces, std::vector< int,std::allocator< int > > const & edges, std::vector< double,std::allocator< double > > const & normals, std::vector< double,std::allocator< double > > const & uvs, std::vector< int,std::allocator< int > > const & material_ids, std::vector< ifcopenshell::geometry::taxonomy::style::ptr,std::allocator< ifcopenshell::geometry::taxonomy::style::ptr > > const & materials, std::vector< int,std::allocator< int > > const & item_ids, std::vector< int,std::allocator< int > > const & edges_item_ids) -> Triangulation
        """
        this = _ifcopenshell_wrapper.new_Triangulation(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Triangulation
    __del__ = lambda self: None

    def box_project_uvs(vertices, normals):
        """box_project_uvs(std::vector< double,std::allocator< double > > const & vertices, std::vector< double,std::allocator< double > > const & normals) -> std::vector< double,std::allocator< double > >"""
        return _ifcopenshell_wrapper.Triangulation_box_project_uvs(vertices, normals)

    box_project_uvs = staticmethod(box_project_uvs)

    def empty(settings):
        """empty(Settings settings) -> Triangulation"""
        return _ifcopenshell_wrapper.Triangulation_empty(settings)

    empty = staticmethod(empty)

    def addVertex(self, item_index, material_index, X, Y, Z):
        """addVertex(Triangulation self, int item_index, int material_index, double X, double Y, double Z) -> int"""
        return _ifcopenshell_wrapper.Triangulation_addVertex(self, item_index, material_index, X, Y, Z)


    def addNormal(self, X, Y, Z):
        """addNormal(Triangulation self, double X, double Y, double Z)"""
        return _ifcopenshell_wrapper.Triangulation_addNormal(self, X, Y, Z)


    def addFace(self, *args):
        """
        addFace(Triangulation self, int item_id, int style, int i0, int i1, int i2)
        addFace(Triangulation self, int item_id, int style, std::vector< int,std::allocator< int > > const & outer_bound)
        addFace(Triangulation self, int item_id, int style, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & bounds)
        """
        return _ifcopenshell_wrapper.Triangulation_addFace(self, *args)


    def addEdge(self, item_id, style, i0, i1):
        """addEdge(Triangulation self, int item_id, int style, int i0, int i1)"""
        return _ifcopenshell_wrapper.Triangulation_addEdge(self, item_id, style, i0, i1)


    def registerEdge(self, item_id, i0, i1):
        """registerEdge(Triangulation self, int item_id, int i0, int i1)"""
        return _ifcopenshell_wrapper.Triangulation_registerEdge(self, item_id, i0, i1)


    def registerEdgeCount(self, n1, n2, edgecount):
        """registerEdgeCount(Triangulation self, int n1, int n2, std::map< std::pair< int,int >,int > & edgecount)"""
        return _ifcopenshell_wrapper.Triangulation_registerEdgeCount(self, n1, n2, edgecount)


    def resetWelds(self):
        """resetWelds(Triangulation self)"""
        return _ifcopenshell_wrapper.Triangulation_resetWelds(self)


    def faces_buffer(self):
        """faces_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_faces_buffer(self)


    def edges_buffer(self):
        """edges_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_edges_buffer(self)


    def material_ids_buffer(self):
        """material_ids_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_material_ids_buffer(self)


    def item_ids_buffer(self):
        """item_ids_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_item_ids_buffer(self)


    def edges_item_ids_buffer(self):
        """edges_item_ids_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_edges_item_ids_buffer(self)


    def verts_buffer(self):
        """verts_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_verts_buffer(self)


    def normals_buffer(self):
        """normals_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
        return _ifcopenshell_wrapper.Triangulation_normals_buffer(self)


    def colors_buffer(self):
        """colors_buffer(Triangulation self) -> PyObject *"""
        return _ifcopenshell_wrapper.Triangulation_colors_buffer(self)


            # Hide the getters with read-only property implementations
    faces_tri = property(faces)
    polyhedral_faces_without_holes = property(polyhedral_faces_without_holes)
    polyhedral_faces_with_holes = property(polyhedral_faces_with_holes)
    def get_faces(self):
        if self.faces_tri: 
            return self.faces_tri
        elif self.polyhedral_faces_without_holes:
            return self.polyhedral_faces_without_holes
        else:
            return self.polyhedral_faces_with_holes
    faces = property(get_faces)
    edges = property(edges)
    material_ids = property(material_ids)
    materials = property(materials)
    verts = property(verts)
    normals = property(normals)
    item_ids = property(item_ids)
    uvs = property(uvs)
    edges_item_ids = property(edges_item_ids)

    faces_buffer = property(faces_buffer)
    edges_buffer = property(edges_buffer)
    material_ids_buffer = property(material_ids_buffer)
    item_ids_buffer = property(item_ids_buffer)
    edges_item_ids_buffer = property(edges_item_ids_buffer)
    verts_buffer = property(verts_buffer)
    normals_buffer = property(normals_buffer)
    colors_buffer = property(colors_buffer)

Triangulation_swigregister = _ifcopenshell_wrapper.Triangulation_swigregister
Triangulation_swigregister(Triangulation)

def Triangulation_box_project_uvs(vertices, normals):
    """Triangulation_box_project_uvs(std::vector< double,std::allocator< double > > const & vertices, std::vector< double,std::allocator< double > > const & normals) -> std::vector< double,std::allocator< double > >"""
    return _ifcopenshell_wrapper.Triangulation_box_project_uvs(vertices, normals)

def Triangulation_empty(settings):
    """Triangulation_empty(Settings settings) -> Triangulation"""
    return _ifcopenshell_wrapper.Triangulation_empty(settings)

class geometry_conversion_result(_object):
    """Proxy of C++ IfcGeom::geometry_conversion_result class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, geometry_conversion_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, geometry_conversion_result, name)
    __repr__ = _swig_repr
    __swig_setmethods__["index"] = _ifcopenshell_wrapper.geometry_conversion_result_index_set
    __swig_getmethods__["index"] = _ifcopenshell_wrapper.geometry_conversion_result_index_get
    if _newclass:
        index = _swig_property(_ifcopenshell_wrapper.geometry_conversion_result_index_get, _ifcopenshell_wrapper.geometry_conversion_result_index_set)
    __swig_setmethods__["item"] = _ifcopenshell_wrapper.geometry_conversion_result_item_set
    __swig_getmethods__["item"] = _ifcopenshell_wrapper.geometry_conversion_result_item_get
    if _newclass:
        item = _swig_property(_ifcopenshell_wrapper.geometry_conversion_result_item_get, _ifcopenshell_wrapper.geometry_conversion_result_item_set)
    __swig_setmethods__["products"] = _ifcopenshell_wrapper.geometry_conversion_result_products_set
    __swig_getmethods__["products"] = _ifcopenshell_wrapper.geometry_conversion_result_products_get
    if _newclass:
        products = _swig_property(_ifcopenshell_wrapper.geometry_conversion_result_products_get, _ifcopenshell_wrapper.geometry_conversion_result_products_set)
    __swig_setmethods__["representation"] = _ifcopenshell_wrapper.geometry_conversion_result_representation_set
    __swig_getmethods__["representation"] = _ifcopenshell_wrapper.geometry_conversion_result_representation_get
    if _newclass:
        representation = _swig_property(_ifcopenshell_wrapper.geometry_conversion_result_representation_get, _ifcopenshell_wrapper.geometry_conversion_result_representation_set)
    __swig_setmethods__["products_2"] = _ifcopenshell_wrapper.geometry_conversion_result_products_2_set
    __swig_getmethods__["products_2"] = _ifcopenshell_wrapper.geometry_conversion_result_products_2_get
    if _newclass:
        products_2 = _swig_property(_ifcopenshell_wrapper.geometry_conversion_result_products_2_get, _ifcopenshell_wrapper.geometry_conversion_result_products_2_set)
    __swig_setmethods__["breps"] = _ifcopenshell_wrapper.geometry_conversion_result_breps_set
    __swig_getmethods__["breps"] = _ifcopenshell_wrapper.geometry_conversion_result_breps_get
    if _newclass:
        breps = _swig_property(_ifcopenshell_wrapper.geometry_conversion_result_breps_get, _ifcopenshell_wrapper.geometry_conversion_result_breps_set)
    __swig_setmethods__["elements"] = _ifcopenshell_wrapper.geometry_conversion_result_elements_set
    __swig_getmethods__["elements"] = _ifcopenshell_wrapper.geometry_conversion_result_elements_get
    if _newclass:
        elements = _swig_property(_ifcopenshell_wrapper.geometry_conversion_result_elements_get, _ifcopenshell_wrapper.geometry_conversion_result_elements_set)

    def __init__(self):
        """__init__(IfcGeom::geometry_conversion_result self) -> geometry_conversion_result"""
        this = _ifcopenshell_wrapper.new_geometry_conversion_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_geometry_conversion_result
    __del__ = lambda self: None
geometry_conversion_result_swigregister = _ifcopenshell_wrapper.geometry_conversion_result_swigregister
geometry_conversion_result_swigregister(geometry_conversion_result)

class Iterator(_object):
    """Proxy of C++ IfcGeom::Iterator class."""

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

    def __init__(self, *args):
        """
        __init__(IfcGeom::Iterator self, std::unique_ptr< ifcopenshell::geometry::kernels::AbstractKernel > && geometry_library, Settings settings, file file, std::vector< IfcGeom::filter_t,std::allocator< IfcGeom::filter_t > > const & filters, int num_threads) -> Iterator
        __init__(IfcGeom::Iterator self, std::unique_ptr< ifcopenshell::geometry::kernels::AbstractKernel > && geometry_library, Settings settings, file file) -> Iterator
        __init__(IfcGeom::Iterator self, std::unique_ptr< ifcopenshell::geometry::kernels::AbstractKernel > && geometry_library, Settings settings, file file, int num_threads) -> Iterator
        """
        this = _ifcopenshell_wrapper.new_Iterator(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_Iterator
    __del__ = lambda self: None

    def set_cache(self, cache):
        """set_cache(Iterator self, GeometrySerializer cache)"""
        return _ifcopenshell_wrapper.Iterator_set_cache(self, cache)


    def get_task_items(self):
        """get_task_items(Iterator self) -> std::vector< ifcopenshell::geometry::taxonomy::item::ptr,std::allocator< ifcopenshell::geometry::taxonomy::item::ptr > >"""
        return _ifcopenshell_wrapper.Iterator_get_task_items(self)


    def get_task_products(self):
        """get_task_products(Iterator self) -> aggregate_of_aggregate_of_instance::ptr"""
        return _ifcopenshell_wrapper.Iterator_get_task_products(self)


    def unit_name(self):
        """unit_name(Iterator self) -> std::string const &"""
        return _ifcopenshell_wrapper.Iterator_unit_name(self)


    def unit_magnitude(self):
        """unit_magnitude(Iterator self) -> double"""
        return _ifcopenshell_wrapper.Iterator_unit_magnitude(self)


    def had_error_processing_elements(self):
        """had_error_processing_elements(Iterator self) -> bool"""
        return _ifcopenshell_wrapper.Iterator_had_error_processing_elements(self)

    __swig_setmethods__["initialization_outcome_"] = _ifcopenshell_wrapper.Iterator_initialization_outcome__set
    __swig_getmethods__["initialization_outcome_"] = _ifcopenshell_wrapper.Iterator_initialization_outcome__get
    if _newclass:
        initialization_outcome_ = _swig_property(_ifcopenshell_wrapper.Iterator_initialization_outcome__get, _ifcopenshell_wrapper.Iterator_initialization_outcome__set)

    def initialize(self):
        """initialize(Iterator self) -> bool"""
        return _ifcopenshell_wrapper.Iterator_initialize(self)

    __swig_setmethods__["processed_"] = _ifcopenshell_wrapper.Iterator_processed__set
    __swig_getmethods__["processed_"] = _ifcopenshell_wrapper.Iterator_processed__get
    if _newclass:
        processed_ = _swig_property(_ifcopenshell_wrapper.Iterator_processed__get, _ifcopenshell_wrapper.Iterator_processed__set)

    def process_finished_rep(self, rep):
        """process_finished_rep(Iterator self, geometry_conversion_result rep)"""
        return _ifcopenshell_wrapper.Iterator_process_finished_rep(self, rep)


    def process_concurrently(self):
        """process_concurrently(Iterator self)"""
        return _ifcopenshell_wrapper.Iterator_process_concurrently(self)


    def compute_bounds(self, with_geometry):
        """compute_bounds(Iterator self, bool with_geometry)"""
        return _ifcopenshell_wrapper.Iterator_compute_bounds(self, with_geometry)


    def progress(self):
        """progress(Iterator self) -> int"""
        return _ifcopenshell_wrapper.Iterator_progress(self)


    def getLog(self):
        """getLog(Iterator self) -> std::string"""
        return _ifcopenshell_wrapper.Iterator_getLog(self)


    def file(self):
        """file(Iterator self) -> file"""
        return _ifcopenshell_wrapper.Iterator_file(self)


    def filters(self, *args):
        """
        filters(Iterator self) -> std::vector< IfcGeom::filter_t,std::allocator< IfcGeom::filter_t > > const
        filters(Iterator self) -> std::vector< IfcGeom::filter_t,std::allocator< IfcGeom::filter_t > > &
        """
        return _ifcopenshell_wrapper.Iterator_filters(self, *args)


    def bounds_min(self):
        """bounds_min(Iterator self) -> point3"""
        return _ifcopenshell_wrapper.Iterator_bounds_min(self)


    def bounds_max(self):
        """bounds_max(Iterator self) -> point3"""
        return _ifcopenshell_wrapper.Iterator_bounds_max(self)


    def next(self):
        """next(Iterator self) -> entity_instance"""
        return _ifcopenshell_wrapper.Iterator_next(self)


    def get(self):
        """get(Iterator self) -> Element"""
        return _ifcopenshell_wrapper.Iterator_get(self)


    def get_native(self):
        """get_native(Iterator self) -> BRepElement"""
        return _ifcopenshell_wrapper.Iterator_get_native(self)


    def get_object(self, id):
        """get_object(Iterator self, int id) -> Element"""
        return _ifcopenshell_wrapper.Iterator_get_object(self, id)


    def create(self):
        """create(Iterator self) -> entity_instance"""
        return _ifcopenshell_wrapper.Iterator_create(self)

Iterator_swigregister = _ifcopenshell_wrapper.Iterator_swigregister
Iterator_swigregister(Iterator)

class SerializerSettings(_object):
    """Proxy of C++ ifcopenshell::geometry::SerializerSettings class."""

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

    def set_(self, *args):
        """
        set_(SerializerSettings self, std::string const & name, bool val)
        set_(SerializerSettings self, std::string const & name, int val)
        set_(SerializerSettings self, std::string const & name, double val)
        set_(SerializerSettings self, std::string const & name, std::string const & val)
        set_(SerializerSettings self, std::string const & name, std::set< int > const & val)
        """
        return _ifcopenshell_wrapper.SerializerSettings_set_(self, *args)


    def get_(self, name):
        """get_(SerializerSettings self, std::string const & name) -> ifcopenshell::geometry::SerializerSettings::value_variant_t"""
        return _ifcopenshell_wrapper.SerializerSettings_get_(self, name)


    def setting_names(self):
        """setting_names(SerializerSettings self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.SerializerSettings_setting_names(self)


    def get_type(self, name):
        """get_type(SerializerSettings self, std::string const & name) -> std::string"""
        return _ifcopenshell_wrapper.SerializerSettings_get_type(self, name)


    def __init__(self):
        """__init__(ifcopenshell::geometry::SerializerSettings self) -> SerializerSettings"""
        this = _ifcopenshell_wrapper.new_SerializerSettings()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_SerializerSettings
    __del__ = lambda self: None
SerializerSettings_swigregister = _ifcopenshell_wrapper.SerializerSettings_swigregister
SerializerSettings_swigregister(SerializerSettings)

class buffer(_object):
    """Proxy of C++ stream_or_filename class."""

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

    def __init__(self, *args):
        """
        __init__(stream_or_filename self, std::string const & fn) -> buffer
        __init__(stream_or_filename self) -> buffer
        """
        this = _ifcopenshell_wrapper.new_buffer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get_value(self):
        """get_value(buffer self) -> std::string"""
        return _ifcopenshell_wrapper.buffer_get_value(self)


    def filename(self):
        """filename(buffer self) -> boost::optional< std::string >"""
        return _ifcopenshell_wrapper.buffer_filename(self)


    def is_ready(self):
        """is_ready(buffer self) -> bool"""
        return _ifcopenshell_wrapper.buffer_is_ready(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_buffer
    __del__ = lambda self: None
buffer_swigregister = _ifcopenshell_wrapper.buffer_swigregister
buffer_swigregister(buffer)

class GeometrySerializer(_object):
    """Proxy of C++ GeometrySerializer class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    READ_BREP = _ifcopenshell_wrapper.GeometrySerializer_READ_BREP
    READ_TRIANGULATION = _ifcopenshell_wrapper.GeometrySerializer_READ_TRIANGULATION
    __swig_destroy__ = _ifcopenshell_wrapper.delete_GeometrySerializer
    __del__ = lambda self: None

    def isTesselated(self):
        """isTesselated(GeometrySerializer self) -> bool"""
        return _ifcopenshell_wrapper.GeometrySerializer_isTesselated(self)


    def write(self, *args):
        """
        write(GeometrySerializer self, TriangulationElement o)
        write(GeometrySerializer self, BRepElement o)
        """
        return _ifcopenshell_wrapper.GeometrySerializer_write(self, *args)


    def setUnitNameAndMagnitude(self, name, magnitude):
        """setUnitNameAndMagnitude(GeometrySerializer self, std::string const & name, float magnitude)"""
        return _ifcopenshell_wrapper.GeometrySerializer_setUnitNameAndMagnitude(self, name, magnitude)


    def read(self, *args):
        """
        read(GeometrySerializer self, file f, std::string const & guid, std::string const & representation_id, GeometrySerializer::read_type rt) -> Element
        read(GeometrySerializer self, file f, std::string const & guid, std::string const & representation_id) -> Element
        """
        return _ifcopenshell_wrapper.GeometrySerializer_read(self, *args)


    def settings(self, *args):
        """
        settings(GeometrySerializer self) -> SerializerSettings
        settings(GeometrySerializer self) -> SerializerSettings
        """
        return _ifcopenshell_wrapper.GeometrySerializer_settings(self, *args)


    def geometry_settings(self, *args):
        """
        geometry_settings(GeometrySerializer self) -> Settings
        geometry_settings(GeometrySerializer self) -> Settings
        """
        return _ifcopenshell_wrapper.GeometrySerializer_geometry_settings(self, *args)


    def object_id(self, o):
        """object_id(GeometrySerializer self, Element o) -> std::string"""
        return _ifcopenshell_wrapper.GeometrySerializer_object_id(self, o)

GeometrySerializer_swigregister = _ifcopenshell_wrapper.GeometrySerializer_swigregister
GeometrySerializer_swigregister(GeometrySerializer)

class WriteOnlyGeometrySerializer(GeometrySerializer):
    """Proxy of C++ WriteOnlyGeometrySerializer class."""

    __swig_setmethods__ = {}
    for _s in [GeometrySerializer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WriteOnlyGeometrySerializer, name, value)
    __swig_getmethods__ = {}
    for _s in [GeometrySerializer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, WriteOnlyGeometrySerializer, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def read(self, *args):
        """
        read(WriteOnlyGeometrySerializer self, file arg2, std::string const & arg3, std::string const & arg4, GeometrySerializer::read_type arg5) -> Element
        read(WriteOnlyGeometrySerializer self, file arg2, std::string const & arg3, std::string const & arg4) -> Element
        """
        return _ifcopenshell_wrapper.WriteOnlyGeometrySerializer_read(self, *args)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_WriteOnlyGeometrySerializer
    __del__ = lambda self: None
WriteOnlyGeometrySerializer_swigregister = _ifcopenshell_wrapper.WriteOnlyGeometrySerializer_swigregister
WriteOnlyGeometrySerializer_swigregister(WriteOnlyGeometrySerializer)

class topology_error(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::topology_error class."""

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

    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::topology_error self) -> topology_error
        __init__(ifcopenshell::geometry::taxonomy::topology_error self, char const *const s) -> topology_error
        """
        this = _ifcopenshell_wrapper.new_topology_error(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_topology_error
    __del__ = lambda self: None
topology_error_swigregister = _ifcopenshell_wrapper.topology_error_swigregister
topology_error_swigregister(topology_error)

MATRIX4 = _ifcopenshell_wrapper.MATRIX4
POINT3 = _ifcopenshell_wrapper.POINT3
DIRECTION3 = _ifcopenshell_wrapper.DIRECTION3
LINE = _ifcopenshell_wrapper.LINE
CIRCLE = _ifcopenshell_wrapper.CIRCLE
ELLIPSE = _ifcopenshell_wrapper.ELLIPSE
BSPLINE_CURVE = _ifcopenshell_wrapper.BSPLINE_CURVE
OFFSET_CURVE = _ifcopenshell_wrapper.OFFSET_CURVE
PLANE = _ifcopenshell_wrapper.PLANE
CYLINDER = _ifcopenshell_wrapper.CYLINDER
SPHERE = _ifcopenshell_wrapper.SPHERE
TORUS = _ifcopenshell_wrapper.TORUS
BSPLINE_SURFACE = _ifcopenshell_wrapper.BSPLINE_SURFACE
EDGE = _ifcopenshell_wrapper.EDGE
LOOP = _ifcopenshell_wrapper.LOOP
FACE = _ifcopenshell_wrapper.FACE
SHELL = _ifcopenshell_wrapper.SHELL
SOLID = _ifcopenshell_wrapper.SOLID
LOFT = _ifcopenshell_wrapper.LOFT
EXTRUSION = _ifcopenshell_wrapper.EXTRUSION
REVOLVE = _ifcopenshell_wrapper.REVOLVE
SWEEP_ALONG_CURVE = _ifcopenshell_wrapper.SWEEP_ALONG_CURVE
NODE = _ifcopenshell_wrapper.NODE
COLLECTION = _ifcopenshell_wrapper.COLLECTION
BOOLEAN_RESULT = _ifcopenshell_wrapper.BOOLEAN_RESULT
FUNCTION_ITEM = _ifcopenshell_wrapper.FUNCTION_ITEM
FUNCTOR_ITEM = _ifcopenshell_wrapper.FUNCTOR_ITEM
PIECEWISE_FUNCTION = _ifcopenshell_wrapper.PIECEWISE_FUNCTION
GRADIENT_FUNCTION = _ifcopenshell_wrapper.GRADIENT_FUNCTION
CANT_FUNCTION = _ifcopenshell_wrapper.CANT_FUNCTION
OFFSET_FUNCTION = _ifcopenshell_wrapper.OFFSET_FUNCTION
COLOUR = _ifcopenshell_wrapper.COLOUR
STYLE = _ifcopenshell_wrapper.STYLE

def kind_to_string(k):
    """kind_to_string(ifcopenshell::geometry::taxonomy::kinds k) -> std::string const &"""
    return _ifcopenshell_wrapper.kind_to_string(k)
class item(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::item class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["instance"] = _ifcopenshell_wrapper.item_instance_set
    __swig_getmethods__["instance"] = _ifcopenshell_wrapper.item_instance_get
    if _newclass:
        instance = _swig_property(_ifcopenshell_wrapper.item_instance_get, _ifcopenshell_wrapper.item_instance_set)
    __swig_setmethods__["orientation"] = _ifcopenshell_wrapper.item_orientation_set
    __swig_getmethods__["orientation"] = _ifcopenshell_wrapper.item_orientation_get
    if _newclass:
        orientation = _swig_property(_ifcopenshell_wrapper.item_orientation_get, _ifcopenshell_wrapper.item_orientation_set)

    def clone_(self):
        """clone_(item self) -> item"""
        return _ifcopenshell_wrapper.item_clone_(self)


    def kind(self):
        """kind(item self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.item_kind(self)


    def reverse(self):
        """reverse(item self)"""
        return _ifcopenshell_wrapper.item_reverse(self)


    def calc_hash(self):
        """calc_hash(item self) -> size_t"""
        return _ifcopenshell_wrapper.item_calc_hash(self)


    def hash(self):
        """hash(item self) -> size_t"""
        return _ifcopenshell_wrapper.item_hash(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_item
    __del__ = lambda self: None

    def identity(self):
        """identity(item self) -> uint32_t"""
        return _ifcopenshell_wrapper.item_identity(self)

item_swigregister = _ifcopenshell_wrapper.item_swigregister
item_swigregister(item)

class matrix4(item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::matrix4 class."""

    __swig_setmethods__ = {}
    for _s in [item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, matrix4, name, value)
    __swig_getmethods__ = {}
    for _s in [item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, matrix4, name)
    __repr__ = _swig_repr
    IDENTITY = _ifcopenshell_wrapper.matrix4_IDENTITY
    AFFINE_WO_SCALE = _ifcopenshell_wrapper.matrix4_AFFINE_WO_SCALE
    AFFINE_W_UNIFORM_SCALE = _ifcopenshell_wrapper.matrix4_AFFINE_W_UNIFORM_SCALE
    AFFINE_W_NONUNIFORM_SCALE = _ifcopenshell_wrapper.matrix4_AFFINE_W_NONUNIFORM_SCALE
    OTHER = _ifcopenshell_wrapper.matrix4_OTHER
    __swig_setmethods__["tag"] = _ifcopenshell_wrapper.matrix4_tag_set
    __swig_getmethods__["tag"] = _ifcopenshell_wrapper.matrix4_tag_get
    if _newclass:
        tag = _swig_property(_ifcopenshell_wrapper.matrix4_tag_get, _ifcopenshell_wrapper.matrix4_tag_set)

    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::matrix4 self) -> matrix4
        __init__(ifcopenshell::geometry::taxonomy::matrix4 self, Eigen::Matrix4d const & c) -> matrix4
        __init__(ifcopenshell::geometry::taxonomy::matrix4 self, Eigen::Vector3d const & o, Eigen::Vector3d const & z, Eigen::Vector3d const & x) -> matrix4
        __init__(ifcopenshell::geometry::taxonomy::matrix4 self, Eigen::Vector3d const & o, Eigen::Vector3d const & z) -> matrix4
        """
        this = _ifcopenshell_wrapper.new_matrix4(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def is_identity(self):
        """is_identity(matrix4 self) -> bool"""
        return _ifcopenshell_wrapper.matrix4_is_identity(self)


    def clone_(self):
        """clone_(matrix4 self) -> matrix4"""
        return _ifcopenshell_wrapper.matrix4_clone_(self)


    def kind(self):
        """kind(matrix4 self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.matrix4_kind(self)


    def calc_hash(self):
        """calc_hash(matrix4 self) -> size_t"""
        return _ifcopenshell_wrapper.matrix4_calc_hash(self)


    def pre_multiply_scale(self, s):
        """pre_multiply_scale(matrix4 self, double s)"""
        return _ifcopenshell_wrapper.matrix4_pre_multiply_scale(self, s)


    def post_multiply_scale(self, s):
        """post_multiply_scale(matrix4 self, double s)"""
        return _ifcopenshell_wrapper.matrix4_post_multiply_scale(self, s)


    def translation_part(self):
        """translation_part(matrix4 self) -> Eigen::Vector3d"""
        return _ifcopenshell_wrapper.matrix4_translation_part(self)


    def components_(self):
        """components_(matrix4 self) -> PyObject *"""
        return _ifcopenshell_wrapper.matrix4_components_(self)


    components = property(components_)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_matrix4
    __del__ = lambda self: None
matrix4_swigregister = _ifcopenshell_wrapper.matrix4_swigregister
matrix4_swigregister(matrix4)

class colour(item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::colour class."""

    __swig_setmethods__ = {}
    for _s in [item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, colour, name, value)
    __swig_getmethods__ = {}
    for _s in [item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, colour, name)
    __repr__ = _swig_repr

    def clone_(self):
        """clone_(colour self) -> colour"""
        return _ifcopenshell_wrapper.colour_clone_(self)


    def kind(self):
        """kind(colour self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.colour_kind(self)


    def calc_hash(self):
        """calc_hash(colour self) -> size_t"""
        return _ifcopenshell_wrapper.colour_calc_hash(self)


    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::colour self) -> colour
        __init__(ifcopenshell::geometry::taxonomy::colour self, double r, double g, double b) -> colour
        """
        this = _ifcopenshell_wrapper.new_colour(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def r(self):
        """r(colour self) -> double const &"""
        return _ifcopenshell_wrapper.colour_r(self)


    def g(self):
        """g(colour self) -> double const &"""
        return _ifcopenshell_wrapper.colour_g(self)


    def b(self):
        """b(colour self) -> double const &"""
        return _ifcopenshell_wrapper.colour_b(self)


    def components_(self):
        """components_(colour self) -> PyObject *"""
        return _ifcopenshell_wrapper.colour_components_(self)


    components = property(components_)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_colour
    __del__ = lambda self: None
colour_swigregister = _ifcopenshell_wrapper.colour_swigregister
colour_swigregister(colour)

class style(item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::style class."""

    __swig_setmethods__ = {}
    for _s in [item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, style, name, value)
    __swig_getmethods__ = {}
    for _s in [item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, style, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _ifcopenshell_wrapper.style_name_set
    __swig_getmethods__["name"] = _ifcopenshell_wrapper.style_name_get
    if _newclass:
        name = _swig_property(_ifcopenshell_wrapper.style_name_get, _ifcopenshell_wrapper.style_name_set)
    __swig_setmethods__["diffuse"] = _ifcopenshell_wrapper.style_diffuse_set
    __swig_getmethods__["diffuse"] = _ifcopenshell_wrapper.style_diffuse_get
    if _newclass:
        diffuse = _swig_property(_ifcopenshell_wrapper.style_diffuse_get, _ifcopenshell_wrapper.style_diffuse_set)
    __swig_setmethods__["surface"] = _ifcopenshell_wrapper.style_surface_set
    __swig_getmethods__["surface"] = _ifcopenshell_wrapper.style_surface_get
    if _newclass:
        surface = _swig_property(_ifcopenshell_wrapper.style_surface_get, _ifcopenshell_wrapper.style_surface_set)
    __swig_setmethods__["specular"] = _ifcopenshell_wrapper.style_specular_set
    __swig_getmethods__["specular"] = _ifcopenshell_wrapper.style_specular_get
    if _newclass:
        specular = _swig_property(_ifcopenshell_wrapper.style_specular_get, _ifcopenshell_wrapper.style_specular_set)
    __swig_setmethods__["specularity"] = _ifcopenshell_wrapper.style_specularity_set
    __swig_getmethods__["specularity"] = _ifcopenshell_wrapper.style_specularity_get
    if _newclass:
        specularity = _swig_property(_ifcopenshell_wrapper.style_specularity_get, _ifcopenshell_wrapper.style_specularity_set)
    __swig_setmethods__["transparency"] = _ifcopenshell_wrapper.style_transparency_set
    __swig_getmethods__["transparency"] = _ifcopenshell_wrapper.style_transparency_get
    if _newclass:
        transparency = _swig_property(_ifcopenshell_wrapper.style_transparency_get, _ifcopenshell_wrapper.style_transparency_set)
    __swig_setmethods__["use_surface_color"] = _ifcopenshell_wrapper.style_use_surface_color_set
    __swig_getmethods__["use_surface_color"] = _ifcopenshell_wrapper.style_use_surface_color_get
    if _newclass:
        use_surface_color = _swig_property(_ifcopenshell_wrapper.style_use_surface_color_get, _ifcopenshell_wrapper.style_use_surface_color_set)

    def clone_(self):
        """clone_(style self) -> style"""
        return _ifcopenshell_wrapper.style_clone_(self)


    def kind(self):
        """kind(style self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.style_kind(self)


    def calc_hash(self):
        """calc_hash(style self) -> size_t"""
        return _ifcopenshell_wrapper.style_calc_hash(self)


    def __eq__(self, other):
        """__eq__(style self, style other) -> bool"""
        return _ifcopenshell_wrapper.style___eq__(self, other)


    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::style self) -> style
        __init__(ifcopenshell::geometry::taxonomy::style self, std::string const & name) -> style
        """
        this = _ifcopenshell_wrapper.new_style(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def get_color(self):
        """get_color(style self) -> colour"""
        return _ifcopenshell_wrapper.style_get_color(self)


    def has_specularity(self):
        """has_specularity(style self) -> bool"""
        return _ifcopenshell_wrapper.style_has_specularity(self)


    def has_transparency(self):
        """has_transparency(style self) -> bool"""
        return _ifcopenshell_wrapper.style_has_transparency(self)


    def instance_id(self):
        """instance_id(style self) -> size_t"""
        return _ifcopenshell_wrapper.style_instance_id(self)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_style
    __del__ = lambda self: None
style_swigregister = _ifcopenshell_wrapper.style_swigregister
style_swigregister(style)

class geom_item(item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::geom_item class."""

    __swig_setmethods__ = {}
    for _s in [item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, geom_item, name, value)
    __swig_getmethods__ = {}
    for _s in [item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, geom_item, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["surface_style"] = _ifcopenshell_wrapper.geom_item_surface_style_set
    __swig_getmethods__["surface_style"] = _ifcopenshell_wrapper.geom_item_surface_style_get
    if _newclass:
        surface_style = _swig_property(_ifcopenshell_wrapper.geom_item_surface_style_get, _ifcopenshell_wrapper.geom_item_surface_style_set)
    __swig_setmethods__["matrix"] = _ifcopenshell_wrapper.geom_item_matrix_set
    __swig_getmethods__["matrix"] = _ifcopenshell_wrapper.geom_item_matrix_get
    if _newclass:
        matrix = _swig_property(_ifcopenshell_wrapper.geom_item_matrix_get, _ifcopenshell_wrapper.geom_item_matrix_set)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_geom_item
    __del__ = lambda self: None
geom_item_swigregister = _ifcopenshell_wrapper.geom_item_swigregister
geom_item_swigregister(geom_item)

class implicit_item(geom_item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::implicit_item class."""

    __swig_setmethods__ = {}
    for _s in [geom_item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, implicit_item, name, value)
    __swig_getmethods__ = {}
    for _s in [geom_item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, implicit_item, name)

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

class function_item(implicit_item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::function_item class."""

    __swig_setmethods__ = {}
    for _s in [implicit_item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, function_item, name, value)
    __swig_getmethods__ = {}
    for _s in [implicit_item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, function_item, name)

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

    def start(self):
        """start(function_item self) -> double"""
        return _ifcopenshell_wrapper.function_item_start(self)


    def end(self):
        """end(function_item self) -> double"""
        return _ifcopenshell_wrapper.function_item_end(self)


    def length(self):
        """length(function_item self) -> double"""
        return _ifcopenshell_wrapper.function_item_length(self)


    def kind(self):
        """kind(function_item self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.function_item_kind(self)


    def calc_hash(self):
        """calc_hash(function_item self) -> size_t"""
        return _ifcopenshell_wrapper.function_item_calc_hash(self)


    __repr__ = taxonomy_item_repr

function_item_swigregister = _ifcopenshell_wrapper.function_item_swigregister
function_item_swigregister(function_item)

class functor_item(function_item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::functor_item class."""

    __swig_setmethods__ = {}
    for _s in [function_item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, functor_item, name, value)
    __swig_getmethods__ = {}
    for _s in [function_item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, functor_item, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::functor_item self, double length, std::function< Eigen::Matrix4d (double) > fn, IfcUtil::IfcBaseInterface const * instance=None) -> functor_item
        __init__(ifcopenshell::geometry::taxonomy::functor_item self, double length, std::function< Eigen::Matrix4d (double) > fn) -> functor_item
        __init__(ifcopenshell::geometry::taxonomy::functor_item self, functor_item arg2) -> functor_item
        __init__(ifcopenshell::geometry::taxonomy::functor_item self, functor_item arg2) -> functor_item
        """
        this = _ifcopenshell_wrapper.new_functor_item(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_functor_item
    __del__ = lambda self: None

    def start(self):
        """start(functor_item self) -> double"""
        return _ifcopenshell_wrapper.functor_item_start(self)


    def end(self):
        """end(functor_item self) -> double"""
        return _ifcopenshell_wrapper.functor_item_end(self)


    def __call__(self, u):
        """__call__(functor_item self, double u) -> Eigen::Matrix4d"""
        return _ifcopenshell_wrapper.functor_item___call__(self, u)


    def clone_(self):
        """clone_(functor_item self) -> functor_item"""
        return _ifcopenshell_wrapper.functor_item_clone_(self)


    def kind(self):
        """kind(functor_item self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.functor_item_kind(self)


    def calc_hash(self):
        """calc_hash(functor_item self) -> size_t"""
        return _ifcopenshell_wrapper.functor_item_calc_hash(self)


    __repr__ = taxonomy_item_repr

functor_item_swigregister = _ifcopenshell_wrapper.functor_item_swigregister
functor_item_swigregister(functor_item)

class piecewise_function(function_item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::piecewise_function class."""

    __swig_setmethods__ = {}
    for _s in [function_item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, piecewise_function, name, value)
    __swig_getmethods__ = {}
    for _s in [function_item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, piecewise_function, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::piecewise_function self, double start, ifcopenshell::geometry::taxonomy::piecewise_function::spans_t const & s, IfcUtil::IfcBaseInterface const * instance=None) -> piecewise_function
        __init__(ifcopenshell::geometry::taxonomy::piecewise_function self, double start, ifcopenshell::geometry::taxonomy::piecewise_function::spans_t const & s) -> piecewise_function
        __init__(ifcopenshell::geometry::taxonomy::piecewise_function self, double start, std::vector< ifcopenshell::geometry::taxonomy::piecewise_function::ptr,std::allocator< ifcopenshell::geometry::taxonomy::piecewise_function::ptr > > const & pwfs, IfcUtil::IfcBaseInterface const * instance=None) -> piecewise_function
        __init__(ifcopenshell::geometry::taxonomy::piecewise_function self, double start, std::vector< ifcopenshell::geometry::taxonomy::piecewise_function::ptr,std::allocator< ifcopenshell::geometry::taxonomy::piecewise_function::ptr > > const & pwfs) -> piecewise_function
        __init__(ifcopenshell::geometry::taxonomy::piecewise_function self, piecewise_function arg2) -> piecewise_function
        __init__(ifcopenshell::geometry::taxonomy::piecewise_function self, piecewise_function arg2) -> piecewise_function
        """
        this = _ifcopenshell_wrapper.new_piecewise_function(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_piecewise_function
    __del__ = lambda self: None

    def spans(self):
        """spans(piecewise_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::spans_t const &"""
        return _ifcopenshell_wrapper.piecewise_function_spans(self)


    def span_count(self):
        """span_count(piecewise_function self) -> size_t"""
        return _ifcopenshell_wrapper.piecewise_function_span_count(self)


    def span_fn(self, i):
        """span_fn(piecewise_function self, size_t i) -> ifcopenshell::geometry::taxonomy::function_item::const_ptr"""
        return _ifcopenshell_wrapper.piecewise_function_span_fn(self, i)


    def is_empty(self):
        """is_empty(piecewise_function self) -> bool"""
        return _ifcopenshell_wrapper.piecewise_function_is_empty(self)


    def start(self):
        """start(piecewise_function self) -> double"""
        return _ifcopenshell_wrapper.piecewise_function_start(self)


    def end(self):
        """end(piecewise_function self) -> double"""
        return _ifcopenshell_wrapper.piecewise_function_end(self)


    def length(self):
        """length(piecewise_function self) -> double"""
        return _ifcopenshell_wrapper.piecewise_function_length(self)


    def clone_(self):
        """clone_(piecewise_function self) -> piecewise_function"""
        return _ifcopenshell_wrapper.piecewise_function_clone_(self)


    def kind(self):
        """kind(piecewise_function self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.piecewise_function_kind(self)


    def calc_hash(self):
        """calc_hash(piecewise_function self) -> size_t"""
        return _ifcopenshell_wrapper.piecewise_function_calc_hash(self)


    __repr__ = taxonomy_item_repr

piecewise_function_swigregister = _ifcopenshell_wrapper.piecewise_function_swigregister
piecewise_function_swigregister(piecewise_function)

class gradient_function(function_item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::gradient_function class."""

    __swig_setmethods__ = {}
    for _s in [function_item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, gradient_function, name, value)
    __swig_getmethods__ = {}
    for _s in [function_item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, gradient_function, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::gradient_function self, ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr horizontal, ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr vertical, IfcUtil::IfcBaseInterface const * instance=None) -> gradient_function
        __init__(ifcopenshell::geometry::taxonomy::gradient_function self, ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr horizontal, ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr vertical) -> gradient_function
        __init__(ifcopenshell::geometry::taxonomy::gradient_function self, gradient_function arg2) -> gradient_function
        __init__(ifcopenshell::geometry::taxonomy::gradient_function self, gradient_function arg2) -> gradient_function
        """
        this = _ifcopenshell_wrapper.new_gradient_function(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_gradient_function
    __del__ = lambda self: None

    def start(self):
        """start(gradient_function self) -> double"""
        return _ifcopenshell_wrapper.gradient_function_start(self)


    def end(self):
        """end(gradient_function self) -> double"""
        return _ifcopenshell_wrapper.gradient_function_end(self)


    def get_horizontal(self):
        """get_horizontal(gradient_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr"""
        return _ifcopenshell_wrapper.gradient_function_get_horizontal(self)


    def get_vertical(self):
        """get_vertical(gradient_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr"""
        return _ifcopenshell_wrapper.gradient_function_get_vertical(self)


    def clone_(self):
        """clone_(gradient_function self) -> gradient_function"""
        return _ifcopenshell_wrapper.gradient_function_clone_(self)


    def kind(self):
        """kind(gradient_function self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.gradient_function_kind(self)


    def calc_hash(self):
        """calc_hash(gradient_function self) -> size_t"""
        return _ifcopenshell_wrapper.gradient_function_calc_hash(self)


    __repr__ = taxonomy_item_repr

gradient_function_swigregister = _ifcopenshell_wrapper.gradient_function_swigregister
gradient_function_swigregister(gradient_function)

class cant_function(function_item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::cant_function class."""

    __swig_setmethods__ = {}
    for _s in [function_item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, cant_function, name, value)
    __swig_getmethods__ = {}
    for _s in [function_item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, cant_function, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::cant_function self, ifcopenshell::geometry::taxonomy::gradient_function::const_ptr gradient, ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr cant, IfcUtil::IfcBaseInterface const * instance=None) -> cant_function
        __init__(ifcopenshell::geometry::taxonomy::cant_function self, ifcopenshell::geometry::taxonomy::gradient_function::const_ptr gradient, ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr cant) -> cant_function
        __init__(ifcopenshell::geometry::taxonomy::cant_function self, cant_function arg2) -> cant_function
        __init__(ifcopenshell::geometry::taxonomy::cant_function self, cant_function arg2) -> cant_function
        """
        this = _ifcopenshell_wrapper.new_cant_function(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_cant_function
    __del__ = lambda self: None

    def start(self):
        """start(cant_function self) -> double"""
        return _ifcopenshell_wrapper.cant_function_start(self)


    def end(self):
        """end(cant_function self) -> double"""
        return _ifcopenshell_wrapper.cant_function_end(self)


    def get_gradient(self):
        """get_gradient(cant_function self) -> ifcopenshell::geometry::taxonomy::gradient_function::const_ptr"""
        return _ifcopenshell_wrapper.cant_function_get_gradient(self)


    def get_cant(self):
        """get_cant(cant_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr"""
        return _ifcopenshell_wrapper.cant_function_get_cant(self)


    def clone_(self):
        """clone_(cant_function self) -> cant_function"""
        return _ifcopenshell_wrapper.cant_function_clone_(self)


    def kind(self):
        """kind(cant_function self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.cant_function_kind(self)


    def calc_hash(self):
        """calc_hash(cant_function self) -> size_t"""
        return _ifcopenshell_wrapper.cant_function_calc_hash(self)


    __repr__ = taxonomy_item_repr

cant_function_swigregister = _ifcopenshell_wrapper.cant_function_swigregister
cant_function_swigregister(cant_function)

class offset_function(function_item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::offset_function class."""

    __swig_setmethods__ = {}
    for _s in [function_item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, offset_function, name, value)
    __swig_getmethods__ = {}
    for _s in [function_item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, offset_function, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::offset_function self, ifcopenshell::geometry::taxonomy::function_item::const_ptr basis, ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr offset, IfcUtil::IfcBaseInterface const * instance=None) -> offset_function
        __init__(ifcopenshell::geometry::taxonomy::offset_function self, ifcopenshell::geometry::taxonomy::function_item::const_ptr basis, ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr offset) -> offset_function
        __init__(ifcopenshell::geometry::taxonomy::offset_function self, offset_function arg2) -> offset_function
        __init__(ifcopenshell::geometry::taxonomy::offset_function self, offset_function arg2) -> offset_function
        """
        this = _ifcopenshell_wrapper.new_offset_function(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_offset_function
    __del__ = lambda self: None

    def start(self):
        """start(offset_function self) -> double"""
        return _ifcopenshell_wrapper.offset_function_start(self)


    def end(self):
        """end(offset_function self) -> double"""
        return _ifcopenshell_wrapper.offset_function_end(self)


    def get_basis(self):
        """get_basis(offset_function self) -> ifcopenshell::geometry::taxonomy::function_item::const_ptr"""
        return _ifcopenshell_wrapper.offset_function_get_basis(self)


    def get_offset(self):
        """get_offset(offset_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr"""
        return _ifcopenshell_wrapper.offset_function_get_offset(self)


    def clone_(self):
        """clone_(offset_function self) -> offset_function"""
        return _ifcopenshell_wrapper.offset_function_clone_(self)


    def kind(self):
        """kind(offset_function self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.offset_function_kind(self)


    def calc_hash(self):
        """calc_hash(offset_function self) -> size_t"""
        return _ifcopenshell_wrapper.offset_function_calc_hash(self)


    __repr__ = taxonomy_item_repr

offset_function_swigregister = _ifcopenshell_wrapper.offset_function_swigregister
offset_function_swigregister(offset_function)


def less(arg1, arg2):
    """less(ifcopenshell::geometry::taxonomy::item::const_ptr arg1, ifcopenshell::geometry::taxonomy::item::const_ptr arg2) -> bool"""
    return _ifcopenshell_wrapper.less(arg1, arg2)
class less_functor(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::less_functor class."""

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

    def __call__(self, a, b):
        """__call__(less_functor self, ifcopenshell::geometry::taxonomy::item::const_ptr a, ifcopenshell::geometry::taxonomy::item::const_ptr b) -> bool"""
        return _ifcopenshell_wrapper.less_functor___call__(self, a, b)


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::less_functor self) -> less_functor"""
        this = _ifcopenshell_wrapper.new_less_functor()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_less_functor
    __del__ = lambda self: None
less_functor_swigregister = _ifcopenshell_wrapper.less_functor_swigregister
less_functor_swigregister(less_functor)

class equal_functor(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::equal_functor class."""

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

    def __call__(self, a, b):
        """__call__(equal_functor self, ifcopenshell::geometry::taxonomy::item::ptr const & a, ifcopenshell::geometry::taxonomy::item::ptr const & b) -> bool"""
        return _ifcopenshell_wrapper.equal_functor___call__(self, a, b)


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::equal_functor self) -> equal_functor"""
        this = _ifcopenshell_wrapper.new_equal_functor()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_equal_functor
    __del__ = lambda self: None
equal_functor_swigregister = _ifcopenshell_wrapper.equal_functor_swigregister
equal_functor_swigregister(equal_functor)

class hash_functor(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::hash_functor class."""

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

    def __call__(self, a):
        """__call__(hash_functor self, ifcopenshell::geometry::taxonomy::item::ptr const & a) -> size_t"""
        return _ifcopenshell_wrapper.hash_functor___call__(self, a)


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::hash_functor self) -> hash_functor"""
        this = _ifcopenshell_wrapper.new_hash_functor()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_hash_functor
    __del__ = lambda self: None
hash_functor_swigregister = _ifcopenshell_wrapper.hash_functor_swigregister
hash_functor_swigregister(hash_functor)

class point3(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::point3 class."""

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

    def clone_(self):
        """clone_(point3 self) -> point3"""
        return _ifcopenshell_wrapper.point3_clone_(self)


    def kind(self):
        """kind(point3 self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.point3_kind(self)


    def calc_hash(self):
        """calc_hash(point3 self) -> size_t"""
        return _ifcopenshell_wrapper.point3_calc_hash(self)


    def _print(self, o, indent=0):
        """
        _print(point3 self, std::ostream & o, int indent=0)
        _print(point3 self, std::ostream & o)
        """
        return _ifcopenshell_wrapper.point3__print(self, o, indent)


    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::point3 self) -> point3
        __init__(ifcopenshell::geometry::taxonomy::point3 self, Eigen::Vector3d const & c) -> point3
        __init__(ifcopenshell::geometry::taxonomy::point3 self, double x, double y, double z=0.) -> point3
        __init__(ifcopenshell::geometry::taxonomy::point3 self, double x, double y) -> point3
        """
        this = _ifcopenshell_wrapper.new_point3(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def components_(self):
        """components_(point3 self) -> PyObject *"""
        return _ifcopenshell_wrapper.point3_components_(self)


    components = property(components_)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_point3
    __del__ = lambda self: None
point3_swigregister = _ifcopenshell_wrapper.point3_swigregister
point3_swigregister(point3)

class direction3(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::direction3 class."""

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

    def clone_(self):
        """clone_(direction3 self) -> direction3"""
        return _ifcopenshell_wrapper.direction3_clone_(self)


    def kind(self):
        """kind(direction3 self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.direction3_kind(self)


    def calc_hash(self):
        """calc_hash(direction3 self) -> size_t"""
        return _ifcopenshell_wrapper.direction3_calc_hash(self)


    def _print(self, o, indent=0):
        """
        _print(direction3 self, std::ostream & o, int indent=0)
        _print(direction3 self, std::ostream & o)
        """
        return _ifcopenshell_wrapper.direction3__print(self, o, indent)


    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::direction3 self) -> direction3
        __init__(ifcopenshell::geometry::taxonomy::direction3 self, Eigen::Vector3d const & c) -> direction3
        __init__(ifcopenshell::geometry::taxonomy::direction3 self, double x, double y, double z=0.) -> direction3
        __init__(ifcopenshell::geometry::taxonomy::direction3 self, double x, double y) -> direction3
        """
        this = _ifcopenshell_wrapper.new_direction3(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def components_(self):
        """components_(direction3 self) -> PyObject *"""
        return _ifcopenshell_wrapper.direction3_components_(self)


    components = property(components_)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_direction3
    __del__ = lambda self: None
direction3_swigregister = _ifcopenshell_wrapper.direction3_swigregister
direction3_swigregister(direction3)

class curve(geom_item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::curve class."""

    __swig_setmethods__ = {}
    for _s in [geom_item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, curve, name, value)
    __swig_getmethods__ = {}
    for _s in [geom_item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, curve, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def print_impl(self, o, classname, indent=0):
        """
        print_impl(curve self, std::ostream & o, std::string const & classname, int indent=0)
        print_impl(curve self, std::ostream & o, std::string const & classname)
        """
        return _ifcopenshell_wrapper.curve_print_impl(self, o, classname, indent)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_curve
    __del__ = lambda self: None
curve_swigregister = _ifcopenshell_wrapper.curve_swigregister
curve_swigregister(curve)

class line(curve):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::line class."""

    __swig_setmethods__ = {}
    for _s in [curve]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, line, name, value)
    __swig_getmethods__ = {}
    for _s in [curve]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, line, name)
    __repr__ = _swig_repr

    def clone_(self):
        """clone_(line self) -> line"""
        return _ifcopenshell_wrapper.line_clone_(self)


    def kind(self):
        """kind(line self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.line_kind(self)


    def calc_hash(self):
        """calc_hash(line self) -> size_t"""
        return _ifcopenshell_wrapper.line_calc_hash(self)


    def matrix_(self):
        """matrix_(line self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.line_matrix_(self)


    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::line self) -> line"""
        this = _ifcopenshell_wrapper.new_line()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_line
    __del__ = lambda self: None
line_swigregister = _ifcopenshell_wrapper.line_swigregister
line_swigregister(line)

class circle(curve):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::circle class."""

    __swig_setmethods__ = {}
    for _s in [curve]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, circle, name, value)
    __swig_getmethods__ = {}
    for _s in [curve]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, circle, name)
    __repr__ = _swig_repr
    __swig_setmethods__["radius"] = _ifcopenshell_wrapper.circle_radius_set
    __swig_getmethods__["radius"] = _ifcopenshell_wrapper.circle_radius_get
    if _newclass:
        radius = _swig_property(_ifcopenshell_wrapper.circle_radius_get, _ifcopenshell_wrapper.circle_radius_set)

    def clone_(self):
        """clone_(circle self) -> circle"""
        return _ifcopenshell_wrapper.circle_clone_(self)


    def kind(self):
        """kind(circle self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.circle_kind(self)


    def calc_hash(self):
        """calc_hash(circle self) -> size_t"""
        return _ifcopenshell_wrapper.circle_calc_hash(self)


    def from_3_points(p1, p2, p3):
        """from_3_points(Eigen::Vector3d const & p1, Eigen::Vector3d const & p2, Eigen::Vector3d const & p3) -> ifcopenshell::geometry::taxonomy::circle::ptr"""
        return _ifcopenshell_wrapper.circle_from_3_points(p1, p2, p3)

    from_3_points = staticmethod(from_3_points)

    def matrix_(self):
        """matrix_(circle self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.circle_matrix_(self)


    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::circle self) -> circle"""
        this = _ifcopenshell_wrapper.new_circle()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_circle
    __del__ = lambda self: None
circle_swigregister = _ifcopenshell_wrapper.circle_swigregister
circle_swigregister(circle)

def circle_from_3_points(p1, p2, p3):
    """circle_from_3_points(Eigen::Vector3d const & p1, Eigen::Vector3d const & p2, Eigen::Vector3d const & p3) -> ifcopenshell::geometry::taxonomy::circle::ptr"""
    return _ifcopenshell_wrapper.circle_from_3_points(p1, p2, p3)

class ellipse(curve):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::ellipse class."""

    __swig_setmethods__ = {}
    for _s in [curve]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ellipse, name, value)
    __swig_getmethods__ = {}
    for _s in [curve]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ellipse, name)
    __repr__ = _swig_repr
    __swig_setmethods__["radius"] = _ifcopenshell_wrapper.ellipse_radius_set
    __swig_getmethods__["radius"] = _ifcopenshell_wrapper.ellipse_radius_get
    if _newclass:
        radius = _swig_property(_ifcopenshell_wrapper.ellipse_radius_get, _ifcopenshell_wrapper.ellipse_radius_set)
    __swig_setmethods__["radius2"] = _ifcopenshell_wrapper.ellipse_radius2_set
    __swig_getmethods__["radius2"] = _ifcopenshell_wrapper.ellipse_radius2_get
    if _newclass:
        radius2 = _swig_property(_ifcopenshell_wrapper.ellipse_radius2_get, _ifcopenshell_wrapper.ellipse_radius2_set)

    def clone_(self):
        """clone_(ellipse self) -> ellipse"""
        return _ifcopenshell_wrapper.ellipse_clone_(self)


    def kind(self):
        """kind(ellipse self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.ellipse_kind(self)


    def calc_hash(self):
        """calc_hash(ellipse self) -> size_t"""
        return _ifcopenshell_wrapper.ellipse_calc_hash(self)


    def matrix_(self):
        """matrix_(ellipse self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.ellipse_matrix_(self)


    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::ellipse self) -> ellipse"""
        this = _ifcopenshell_wrapper.new_ellipse()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_ellipse
    __del__ = lambda self: None
ellipse_swigregister = _ifcopenshell_wrapper.ellipse_swigregister
ellipse_swigregister(ellipse)

class bspline_curve(curve):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::bspline_curve class."""

    __swig_setmethods__ = {}
    for _s in [curve]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, bspline_curve, name, value)
    __swig_getmethods__ = {}
    for _s in [curve]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, bspline_curve, name)
    __repr__ = _swig_repr

    def clone_(self):
        """clone_(bspline_curve self) -> bspline_curve"""
        return _ifcopenshell_wrapper.bspline_curve_clone_(self)


    def kind(self):
        """kind(bspline_curve self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.bspline_curve_kind(self)


    def calc_hash(self):
        """calc_hash(bspline_curve self) -> size_t"""
        return _ifcopenshell_wrapper.bspline_curve_calc_hash(self)

    __swig_setmethods__["control_points"] = _ifcopenshell_wrapper.bspline_curve_control_points_set
    __swig_getmethods__["control_points"] = _ifcopenshell_wrapper.bspline_curve_control_points_get
    if _newclass:
        control_points = _swig_property(_ifcopenshell_wrapper.bspline_curve_control_points_get, _ifcopenshell_wrapper.bspline_curve_control_points_set)
    __swig_setmethods__["multiplicities"] = _ifcopenshell_wrapper.bspline_curve_multiplicities_set
    __swig_getmethods__["multiplicities"] = _ifcopenshell_wrapper.bspline_curve_multiplicities_get
    if _newclass:
        multiplicities = _swig_property(_ifcopenshell_wrapper.bspline_curve_multiplicities_get, _ifcopenshell_wrapper.bspline_curve_multiplicities_set)
    __swig_setmethods__["knots"] = _ifcopenshell_wrapper.bspline_curve_knots_set
    __swig_getmethods__["knots"] = _ifcopenshell_wrapper.bspline_curve_knots_get
    if _newclass:
        knots = _swig_property(_ifcopenshell_wrapper.bspline_curve_knots_get, _ifcopenshell_wrapper.bspline_curve_knots_set)
    __swig_setmethods__["weights"] = _ifcopenshell_wrapper.bspline_curve_weights_set
    __swig_getmethods__["weights"] = _ifcopenshell_wrapper.bspline_curve_weights_get
    if _newclass:
        weights = _swig_property(_ifcopenshell_wrapper.bspline_curve_weights_get, _ifcopenshell_wrapper.bspline_curve_weights_set)
    __swig_setmethods__["degree"] = _ifcopenshell_wrapper.bspline_curve_degree_set
    __swig_getmethods__["degree"] = _ifcopenshell_wrapper.bspline_curve_degree_get
    if _newclass:
        degree = _swig_property(_ifcopenshell_wrapper.bspline_curve_degree_get, _ifcopenshell_wrapper.bspline_curve_degree_set)

    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::bspline_curve self) -> bspline_curve"""
        this = _ifcopenshell_wrapper.new_bspline_curve()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_bspline_curve
    __del__ = lambda self: None
bspline_curve_swigregister = _ifcopenshell_wrapper.bspline_curve_swigregister
bspline_curve_swigregister(bspline_curve)

class offset_curve(curve):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::offset_curve class."""

    __swig_setmethods__ = {}
    for _s in [curve]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, offset_curve, name, value)
    __swig_getmethods__ = {}
    for _s in [curve]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, offset_curve, name)
    __repr__ = _swig_repr
    __swig_setmethods__["reference"] = _ifcopenshell_wrapper.offset_curve_reference_set
    __swig_getmethods__["reference"] = _ifcopenshell_wrapper.offset_curve_reference_get
    if _newclass:
        reference = _swig_property(_ifcopenshell_wrapper.offset_curve_reference_get, _ifcopenshell_wrapper.offset_curve_reference_set)
    __swig_setmethods__["offset"] = _ifcopenshell_wrapper.offset_curve_offset_set
    __swig_getmethods__["offset"] = _ifcopenshell_wrapper.offset_curve_offset_get
    if _newclass:
        offset = _swig_property(_ifcopenshell_wrapper.offset_curve_offset_get, _ifcopenshell_wrapper.offset_curve_offset_set)
    __swig_setmethods__["basis"] = _ifcopenshell_wrapper.offset_curve_basis_set
    __swig_getmethods__["basis"] = _ifcopenshell_wrapper.offset_curve_basis_get
    if _newclass:
        basis = _swig_property(_ifcopenshell_wrapper.offset_curve_basis_get, _ifcopenshell_wrapper.offset_curve_basis_set)

    def clone_(self):
        """clone_(offset_curve self) -> offset_curve"""
        return _ifcopenshell_wrapper.offset_curve_clone_(self)


    def kind(self):
        """kind(offset_curve self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.offset_curve_kind(self)


    def calc_hash(self):
        """calc_hash(offset_curve self) -> size_t"""
        return _ifcopenshell_wrapper.offset_curve_calc_hash(self)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::offset_curve self) -> offset_curve"""
        this = _ifcopenshell_wrapper.new_offset_curve()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_offset_curve
    __del__ = lambda self: None
offset_curve_swigregister = _ifcopenshell_wrapper.offset_curve_swigregister
offset_curve_swigregister(offset_curve)

class trimmed_curve(geom_item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::trimmed_curve class."""

    __swig_setmethods__ = {}
    for _s in [geom_item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, trimmed_curve, name, value)
    __swig_getmethods__ = {}
    for _s in [geom_item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, trimmed_curve, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["start"] = _ifcopenshell_wrapper.trimmed_curve_start_set
    __swig_getmethods__["start"] = _ifcopenshell_wrapper.trimmed_curve_start_get
    if _newclass:
        start = _swig_property(_ifcopenshell_wrapper.trimmed_curve_start_get, _ifcopenshell_wrapper.trimmed_curve_start_set)
    __swig_setmethods__["end"] = _ifcopenshell_wrapper.trimmed_curve_end_set
    __swig_getmethods__["end"] = _ifcopenshell_wrapper.trimmed_curve_end_get
    if _newclass:
        end = _swig_property(_ifcopenshell_wrapper.trimmed_curve_end_get, _ifcopenshell_wrapper.trimmed_curve_end_set)
    __swig_setmethods__["basis"] = _ifcopenshell_wrapper.trimmed_curve_basis_set
    __swig_getmethods__["basis"] = _ifcopenshell_wrapper.trimmed_curve_basis_get
    if _newclass:
        basis = _swig_property(_ifcopenshell_wrapper.trimmed_curve_basis_get, _ifcopenshell_wrapper.trimmed_curve_basis_set)
    __swig_setmethods__["curve_sense"] = _ifcopenshell_wrapper.trimmed_curve_curve_sense_set
    __swig_getmethods__["curve_sense"] = _ifcopenshell_wrapper.trimmed_curve_curve_sense_get
    if _newclass:
        curve_sense = _swig_property(_ifcopenshell_wrapper.trimmed_curve_curve_sense_get, _ifcopenshell_wrapper.trimmed_curve_curve_sense_set)

    def reverse(self):
        """reverse(trimmed_curve self)"""
        return _ifcopenshell_wrapper.trimmed_curve_reverse(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_trimmed_curve
    __del__ = lambda self: None
trimmed_curve_swigregister = _ifcopenshell_wrapper.trimmed_curve_swigregister
trimmed_curve_swigregister(trimmed_curve)

class edge(trimmed_curve):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::edge class."""

    __swig_setmethods__ = {}
    for _s in [trimmed_curve]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, edge, name, value)
    __swig_getmethods__ = {}
    for _s in [trimmed_curve]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, edge, name)
    __repr__ = _swig_repr

    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::edge self) -> edge
        __init__(ifcopenshell::geometry::taxonomy::edge self, ifcopenshell::geometry::taxonomy::point3::ptr const & a, ifcopenshell::geometry::taxonomy::point3::ptr const & b) -> edge
        """
        this = _ifcopenshell_wrapper.new_edge(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def clone_(self):
        """clone_(edge self) -> edge"""
        return _ifcopenshell_wrapper.edge_clone_(self)


    def kind(self):
        """kind(edge self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.edge_kind(self)


    def calc_hash(self):
        """calc_hash(edge self) -> size_t"""
        return _ifcopenshell_wrapper.edge_calc_hash(self)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_edge
    __del__ = lambda self: None
edge_swigregister = _ifcopenshell_wrapper.edge_swigregister
edge_swigregister(edge)

class collection(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::collection class."""

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

    def clone_(self):
        """clone_(collection self) -> collection"""
        return _ifcopenshell_wrapper.collection_clone_(self)


    def kind(self):
        """kind(collection self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.collection_kind(self)


    def calc_hash(self):
        """calc_hash(collection self) -> size_t"""
        return _ifcopenshell_wrapper.collection_calc_hash(self)


    def children_(self):
        """children_(collection self) -> std::vector< ifcopenshell::geometry::taxonomy::geom_item::ptr,std::allocator< ifcopenshell::geometry::taxonomy::geom_item::ptr > > const &"""
        return _ifcopenshell_wrapper.collection_children_(self)


    def __getitem__(self, index):
        """__getitem__(collection self, int index) -> ifcopenshell::geometry::taxonomy::geom_item::ptr const &"""
        return _ifcopenshell_wrapper.collection___getitem__(self, index)


    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    def matrix_(self):
        """matrix_(collection self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.collection_matrix_(self)


    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::collection self) -> collection"""
        this = _ifcopenshell_wrapper.new_collection()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_collection
    __del__ = lambda self: None
collection_swigregister = _ifcopenshell_wrapper.collection_swigregister
collection_swigregister(collection)

class loop(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::loop class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, loop, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, loop, name)
    __repr__ = _swig_repr
    __swig_setmethods__["external"] = _ifcopenshell_wrapper.loop_external_set
    __swig_getmethods__["external"] = _ifcopenshell_wrapper.loop_external_get
    if _newclass:
        external = _swig_property(_ifcopenshell_wrapper.loop_external_get, _ifcopenshell_wrapper.loop_external_set)
    __swig_setmethods__["closed"] = _ifcopenshell_wrapper.loop_closed_set
    __swig_getmethods__["closed"] = _ifcopenshell_wrapper.loop_closed_get
    if _newclass:
        closed = _swig_property(_ifcopenshell_wrapper.loop_closed_get, _ifcopenshell_wrapper.loop_closed_set)
    __swig_setmethods__["fi"] = _ifcopenshell_wrapper.loop_fi_set
    __swig_getmethods__["fi"] = _ifcopenshell_wrapper.loop_fi_get
    if _newclass:
        fi = _swig_property(_ifcopenshell_wrapper.loop_fi_get, _ifcopenshell_wrapper.loop_fi_set)

    def is_polyhedron(self):
        """is_polyhedron(loop self) -> bool"""
        return _ifcopenshell_wrapper.loop_is_polyhedron(self)


    def calculate_linear_edge_curves(self):
        """calculate_linear_edge_curves(loop self)"""
        return _ifcopenshell_wrapper.loop_calculate_linear_edge_curves(self)


    def remove_linear_edge_curves(self):
        """remove_linear_edge_curves(loop self)"""
        return _ifcopenshell_wrapper.loop_remove_linear_edge_curves(self)


    def clone_(self):
        """clone_(loop self) -> loop"""
        return _ifcopenshell_wrapper.loop_clone_(self)


    def kind(self):
        """kind(loop self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.loop_kind(self)


    def calc_hash(self):
        """calc_hash(loop self) -> size_t"""
        return _ifcopenshell_wrapper.loop_calc_hash(self)


    def centroid(self):
        """centroid(loop self) -> ifcopenshell::geometry::taxonomy::point3::ptr"""
        return _ifcopenshell_wrapper.loop_centroid(self)


    def children_(self):
        """children_(loop self) -> std::vector< ifcopenshell::geometry::taxonomy::edge::ptr,std::allocator< ifcopenshell::geometry::taxonomy::edge::ptr > > const &"""
        return _ifcopenshell_wrapper.loop_children_(self)


    def __getitem__(self, index):
        """__getitem__(loop self, int index) -> ifcopenshell::geometry::taxonomy::edge::ptr const &"""
        return _ifcopenshell_wrapper.loop___getitem__(self, index)


    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::loop self) -> loop"""
        this = _ifcopenshell_wrapper.new_loop()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_loop
    __del__ = lambda self: None
loop_swigregister = _ifcopenshell_wrapper.loop_swigregister
loop_swigregister(loop)

class face(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::face class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, face, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, face, name)
    __repr__ = _swig_repr
    __swig_setmethods__["basis"] = _ifcopenshell_wrapper.face_basis_set
    __swig_getmethods__["basis"] = _ifcopenshell_wrapper.face_basis_get
    if _newclass:
        basis = _swig_property(_ifcopenshell_wrapper.face_basis_get, _ifcopenshell_wrapper.face_basis_set)

    def clone_(self):
        """clone_(face self) -> face"""
        return _ifcopenshell_wrapper.face_clone_(self)


    def kind(self):
        """kind(face self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.face_kind(self)


    def print_impl(self, o, indent):
        """print_impl(face self, std::ostream & o, int indent)"""
        return _ifcopenshell_wrapper.face_print_impl(self, o, indent)


    def calc_hash(self):
        """calc_hash(face self) -> size_t"""
        return _ifcopenshell_wrapper.face_calc_hash(self)


    def children_(self):
        """children_(face self) -> std::vector< ifcopenshell::geometry::taxonomy::loop::ptr,std::allocator< ifcopenshell::geometry::taxonomy::loop::ptr > > const &"""
        return _ifcopenshell_wrapper.face_children_(self)


    def __getitem__(self, index):
        """__getitem__(face self, int index) -> ifcopenshell::geometry::taxonomy::loop::ptr const &"""
        return _ifcopenshell_wrapper.face___getitem__(self, index)


    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    def matrix_(self):
        """matrix_(face self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.face_matrix_(self)


    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::face self) -> face"""
        this = _ifcopenshell_wrapper.new_face()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_face
    __del__ = lambda self: None
face_swigregister = _ifcopenshell_wrapper.face_swigregister
face_swigregister(face)

class shell(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::shell class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, shell, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, shell, name)
    __repr__ = _swig_repr
    __swig_setmethods__["closed"] = _ifcopenshell_wrapper.shell_closed_set
    __swig_getmethods__["closed"] = _ifcopenshell_wrapper.shell_closed_get
    if _newclass:
        closed = _swig_property(_ifcopenshell_wrapper.shell_closed_get, _ifcopenshell_wrapper.shell_closed_set)

    def print_impl(self, o, indent):
        """print_impl(shell self, std::ostream & o, int indent)"""
        return _ifcopenshell_wrapper.shell_print_impl(self, o, indent)


    def clone_(self):
        """clone_(shell self) -> shell"""
        return _ifcopenshell_wrapper.shell_clone_(self)


    def kind(self):
        """kind(shell self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.shell_kind(self)


    def calc_hash(self):
        """calc_hash(shell self) -> size_t"""
        return _ifcopenshell_wrapper.shell_calc_hash(self)


    def centroid(self):
        """centroid(shell self) -> ifcopenshell::geometry::taxonomy::point3::ptr"""
        return _ifcopenshell_wrapper.shell_centroid(self)


    def children_(self):
        """children_(shell self) -> std::vector< ifcopenshell::geometry::taxonomy::face::ptr,std::allocator< ifcopenshell::geometry::taxonomy::face::ptr > > const &"""
        return _ifcopenshell_wrapper.shell_children_(self)


    def __getitem__(self, index):
        """__getitem__(shell self, int index) -> ifcopenshell::geometry::taxonomy::face::ptr const &"""
        return _ifcopenshell_wrapper.shell___getitem__(self, index)


    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::shell self) -> shell"""
        this = _ifcopenshell_wrapper.new_shell()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_shell
    __del__ = lambda self: None
shell_swigregister = _ifcopenshell_wrapper.shell_swigregister
shell_swigregister(shell)

class solid(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::solid class."""

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

    def clone_(self):
        """clone_(solid self) -> solid"""
        return _ifcopenshell_wrapper.solid_clone_(self)


    def kind(self):
        """kind(solid self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.solid_kind(self)


    def calc_hash(self):
        """calc_hash(solid self) -> size_t"""
        return _ifcopenshell_wrapper.solid_calc_hash(self)


    def children_(self):
        """children_(solid self) -> std::vector< ifcopenshell::geometry::taxonomy::shell::ptr,std::allocator< ifcopenshell::geometry::taxonomy::shell::ptr > > const &"""
        return _ifcopenshell_wrapper.solid_children_(self)


    def __getitem__(self, index):
        """__getitem__(solid self, int index) -> ifcopenshell::geometry::taxonomy::shell::ptr const &"""
        return _ifcopenshell_wrapper.solid___getitem__(self, index)


    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    def matrix_(self):
        """matrix_(solid self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.solid_matrix_(self)


    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::solid self) -> solid"""
        this = _ifcopenshell_wrapper.new_solid()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_solid
    __del__ = lambda self: None
solid_swigregister = _ifcopenshell_wrapper.solid_swigregister
solid_swigregister(solid)

class loft(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::loft class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, loft, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, loft, name)
    __repr__ = _swig_repr
    __swig_setmethods__["axis"] = _ifcopenshell_wrapper.loft_axis_set
    __swig_getmethods__["axis"] = _ifcopenshell_wrapper.loft_axis_get
    if _newclass:
        axis = _swig_property(_ifcopenshell_wrapper.loft_axis_get, _ifcopenshell_wrapper.loft_axis_set)

    def clone_(self):
        """clone_(loft self) -> loft"""
        return _ifcopenshell_wrapper.loft_clone_(self)


    def kind(self):
        """kind(loft self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.loft_kind(self)


    def print_impl(self, o, indent):
        """print_impl(loft self, std::ostream & o, int indent)"""
        return _ifcopenshell_wrapper.loft_print_impl(self, o, indent)


    def calc_hash(self):
        """calc_hash(loft self) -> size_t"""
        return _ifcopenshell_wrapper.loft_calc_hash(self)


    def children_(self):
        """children_(loft self) -> std::vector< ifcopenshell::geometry::taxonomy::geom_item::ptr,std::allocator< ifcopenshell::geometry::taxonomy::geom_item::ptr > > const &"""
        return _ifcopenshell_wrapper.loft_children_(self)


    def __getitem__(self, index):
        """__getitem__(loft self, int index) -> ifcopenshell::geometry::taxonomy::geom_item::ptr const &"""
        return _ifcopenshell_wrapper.loft___getitem__(self, index)


    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::loft self) -> loft"""
        this = _ifcopenshell_wrapper.new_loft()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_loft
    __del__ = lambda self: None
loft_swigregister = _ifcopenshell_wrapper.loft_swigregister
loft_swigregister(loft)

class surface(geom_item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::surface class."""

    __swig_setmethods__ = {}
    for _s in [geom_item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, surface, name, value)
    __swig_getmethods__ = {}
    for _s in [geom_item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, surface, name)

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

class plane(surface):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::plane class."""

    __swig_setmethods__ = {}
    for _s in [surface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, plane, name, value)
    __swig_getmethods__ = {}
    for _s in [surface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, plane, name)
    __repr__ = _swig_repr

    def clone_(self):
        """clone_(plane self) -> plane"""
        return _ifcopenshell_wrapper.plane_clone_(self)


    def kind(self):
        """kind(plane self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.plane_kind(self)


    def calc_hash(self):
        """calc_hash(plane self) -> size_t"""
        return _ifcopenshell_wrapper.plane_calc_hash(self)


    def matrix_(self):
        """matrix_(plane self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.plane_matrix_(self)


    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::plane self) -> plane"""
        this = _ifcopenshell_wrapper.new_plane()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_plane
    __del__ = lambda self: None
plane_swigregister = _ifcopenshell_wrapper.plane_swigregister
plane_swigregister(plane)

class cylinder(surface):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::cylinder class."""

    __swig_setmethods__ = {}
    for _s in [surface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, cylinder, name, value)
    __swig_getmethods__ = {}
    for _s in [surface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, cylinder, name)
    __repr__ = _swig_repr
    __swig_setmethods__["radius"] = _ifcopenshell_wrapper.cylinder_radius_set
    __swig_getmethods__["radius"] = _ifcopenshell_wrapper.cylinder_radius_get
    if _newclass:
        radius = _swig_property(_ifcopenshell_wrapper.cylinder_radius_get, _ifcopenshell_wrapper.cylinder_radius_set)

    def clone_(self):
        """clone_(cylinder self) -> cylinder"""
        return _ifcopenshell_wrapper.cylinder_clone_(self)


    def kind(self):
        """kind(cylinder self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.cylinder_kind(self)


    def calc_hash(self):
        """calc_hash(cylinder self) -> size_t"""
        return _ifcopenshell_wrapper.cylinder_calc_hash(self)


    def matrix_(self):
        """matrix_(cylinder self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.cylinder_matrix_(self)


    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::cylinder self) -> cylinder"""
        this = _ifcopenshell_wrapper.new_cylinder()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_cylinder
    __del__ = lambda self: None
cylinder_swigregister = _ifcopenshell_wrapper.cylinder_swigregister
cylinder_swigregister(cylinder)

class sphere(surface):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::sphere class."""

    __swig_setmethods__ = {}
    for _s in [surface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, sphere, name, value)
    __swig_getmethods__ = {}
    for _s in [surface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, sphere, name)
    __repr__ = _swig_repr
    __swig_setmethods__["radius"] = _ifcopenshell_wrapper.sphere_radius_set
    __swig_getmethods__["radius"] = _ifcopenshell_wrapper.sphere_radius_get
    if _newclass:
        radius = _swig_property(_ifcopenshell_wrapper.sphere_radius_get, _ifcopenshell_wrapper.sphere_radius_set)

    def clone_(self):
        """clone_(sphere self) -> sphere"""
        return _ifcopenshell_wrapper.sphere_clone_(self)


    def kind(self):
        """kind(sphere self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.sphere_kind(self)


    def calc_hash(self):
        """calc_hash(sphere self) -> size_t"""
        return _ifcopenshell_wrapper.sphere_calc_hash(self)


    def matrix_(self):
        """matrix_(sphere self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.sphere_matrix_(self)


    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::sphere self) -> sphere"""
        this = _ifcopenshell_wrapper.new_sphere()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_sphere
    __del__ = lambda self: None
sphere_swigregister = _ifcopenshell_wrapper.sphere_swigregister
sphere_swigregister(sphere)

class torus(surface):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::torus class."""

    __swig_setmethods__ = {}
    for _s in [surface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, torus, name, value)
    __swig_getmethods__ = {}
    for _s in [surface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, torus, name)
    __repr__ = _swig_repr
    __swig_setmethods__["radius1"] = _ifcopenshell_wrapper.torus_radius1_set
    __swig_getmethods__["radius1"] = _ifcopenshell_wrapper.torus_radius1_get
    if _newclass:
        radius1 = _swig_property(_ifcopenshell_wrapper.torus_radius1_get, _ifcopenshell_wrapper.torus_radius1_set)
    __swig_setmethods__["radius2"] = _ifcopenshell_wrapper.torus_radius2_set
    __swig_getmethods__["radius2"] = _ifcopenshell_wrapper.torus_radius2_get
    if _newclass:
        radius2 = _swig_property(_ifcopenshell_wrapper.torus_radius2_get, _ifcopenshell_wrapper.torus_radius2_set)

    def clone_(self):
        """clone_(torus self) -> torus"""
        return _ifcopenshell_wrapper.torus_clone_(self)


    def kind(self):
        """kind(torus self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.torus_kind(self)


    def calc_hash(self):
        """calc_hash(torus self) -> size_t"""
        return _ifcopenshell_wrapper.torus_calc_hash(self)


    def matrix_(self):
        """matrix_(torus self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.torus_matrix_(self)


    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::torus self) -> torus"""
        this = _ifcopenshell_wrapper.new_torus()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_torus
    __del__ = lambda self: None
torus_swigregister = _ifcopenshell_wrapper.torus_swigregister
torus_swigregister(torus)

class bspline_surface(surface):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::bspline_surface class."""

    __swig_setmethods__ = {}
    for _s in [surface]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, bspline_surface, name, value)
    __swig_getmethods__ = {}
    for _s in [surface]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, bspline_surface, name)
    __repr__ = _swig_repr

    def clone_(self):
        """clone_(bspline_surface self) -> bspline_surface"""
        return _ifcopenshell_wrapper.bspline_surface_clone_(self)


    def kind(self):
        """kind(bspline_surface self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.bspline_surface_kind(self)


    def calc_hash(self):
        """calc_hash(bspline_surface self) -> size_t"""
        return _ifcopenshell_wrapper.bspline_surface_calc_hash(self)

    __swig_setmethods__["control_points"] = _ifcopenshell_wrapper.bspline_surface_control_points_set
    __swig_getmethods__["control_points"] = _ifcopenshell_wrapper.bspline_surface_control_points_get
    if _newclass:
        control_points = _swig_property(_ifcopenshell_wrapper.bspline_surface_control_points_get, _ifcopenshell_wrapper.bspline_surface_control_points_set)
    __swig_setmethods__["multiplicities"] = _ifcopenshell_wrapper.bspline_surface_multiplicities_set
    __swig_getmethods__["multiplicities"] = _ifcopenshell_wrapper.bspline_surface_multiplicities_get
    if _newclass:
        multiplicities = _swig_property(_ifcopenshell_wrapper.bspline_surface_multiplicities_get, _ifcopenshell_wrapper.bspline_surface_multiplicities_set)
    __swig_setmethods__["knots"] = _ifcopenshell_wrapper.bspline_surface_knots_set
    __swig_getmethods__["knots"] = _ifcopenshell_wrapper.bspline_surface_knots_get
    if _newclass:
        knots = _swig_property(_ifcopenshell_wrapper.bspline_surface_knots_get, _ifcopenshell_wrapper.bspline_surface_knots_set)
    __swig_setmethods__["weights"] = _ifcopenshell_wrapper.bspline_surface_weights_set
    __swig_getmethods__["weights"] = _ifcopenshell_wrapper.bspline_surface_weights_get
    if _newclass:
        weights = _swig_property(_ifcopenshell_wrapper.bspline_surface_weights_get, _ifcopenshell_wrapper.bspline_surface_weights_set)
    __swig_setmethods__["degree"] = _ifcopenshell_wrapper.bspline_surface_degree_set
    __swig_getmethods__["degree"] = _ifcopenshell_wrapper.bspline_surface_degree_get
    if _newclass:
        degree = _swig_property(_ifcopenshell_wrapper.bspline_surface_degree_get, _ifcopenshell_wrapper.bspline_surface_degree_set)

    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::bspline_surface self) -> bspline_surface"""
        this = _ifcopenshell_wrapper.new_bspline_surface()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_bspline_surface
    __del__ = lambda self: None
bspline_surface_swigregister = _ifcopenshell_wrapper.bspline_surface_swigregister
bspline_surface_swigregister(bspline_surface)

class sweep(geom_item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::sweep class."""

    __swig_setmethods__ = {}
    for _s in [geom_item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, sweep, name, value)
    __swig_getmethods__ = {}
    for _s in [geom_item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, sweep, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_setmethods__["basis"] = _ifcopenshell_wrapper.sweep_basis_set
    __swig_getmethods__["basis"] = _ifcopenshell_wrapper.sweep_basis_get
    if _newclass:
        basis = _swig_property(_ifcopenshell_wrapper.sweep_basis_get, _ifcopenshell_wrapper.sweep_basis_set)
    __swig_destroy__ = _ifcopenshell_wrapper.delete_sweep
    __del__ = lambda self: None
sweep_swigregister = _ifcopenshell_wrapper.sweep_swigregister
sweep_swigregister(sweep)

class extrusion(sweep):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::extrusion class."""

    __swig_setmethods__ = {}
    for _s in [sweep]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, extrusion, name, value)
    __swig_getmethods__ = {}
    for _s in [sweep]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, extrusion, name)
    __repr__ = _swig_repr
    __swig_setmethods__["direction"] = _ifcopenshell_wrapper.extrusion_direction_set
    __swig_getmethods__["direction"] = _ifcopenshell_wrapper.extrusion_direction_get
    if _newclass:
        direction = _swig_property(_ifcopenshell_wrapper.extrusion_direction_get, _ifcopenshell_wrapper.extrusion_direction_set)
    __swig_setmethods__["depth"] = _ifcopenshell_wrapper.extrusion_depth_set
    __swig_getmethods__["depth"] = _ifcopenshell_wrapper.extrusion_depth_get
    if _newclass:
        depth = _swig_property(_ifcopenshell_wrapper.extrusion_depth_get, _ifcopenshell_wrapper.extrusion_depth_set)

    def clone_(self):
        """clone_(extrusion self) -> extrusion"""
        return _ifcopenshell_wrapper.extrusion_clone_(self)


    def kind(self):
        """kind(extrusion self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.extrusion_kind(self)


    def __init__(self, m, basis, dir, d):
        """__init__(ifcopenshell::geometry::taxonomy::extrusion self, ifcopenshell::geometry::taxonomy::matrix4::ptr m, ifcopenshell::geometry::taxonomy::item::ptr basis, ifcopenshell::geometry::taxonomy::direction3::ptr dir, double d) -> extrusion"""
        this = _ifcopenshell_wrapper.new_extrusion(m, basis, dir, d)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calc_hash(self):
        """calc_hash(extrusion self) -> size_t"""
        return _ifcopenshell_wrapper.extrusion_calc_hash(self)


    def matrix_(self):
        """matrix_(extrusion self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.extrusion_matrix_(self)


    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_extrusion
    __del__ = lambda self: None
extrusion_swigregister = _ifcopenshell_wrapper.extrusion_swigregister
extrusion_swigregister(extrusion)

class revolve(sweep):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::revolve class."""

    __swig_setmethods__ = {}
    for _s in [sweep]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, revolve, name, value)
    __swig_getmethods__ = {}
    for _s in [sweep]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, revolve, name)
    __repr__ = _swig_repr
    __swig_setmethods__["axis_origin"] = _ifcopenshell_wrapper.revolve_axis_origin_set
    __swig_getmethods__["axis_origin"] = _ifcopenshell_wrapper.revolve_axis_origin_get
    if _newclass:
        axis_origin = _swig_property(_ifcopenshell_wrapper.revolve_axis_origin_get, _ifcopenshell_wrapper.revolve_axis_origin_set)
    __swig_setmethods__["direction"] = _ifcopenshell_wrapper.revolve_direction_set
    __swig_getmethods__["direction"] = _ifcopenshell_wrapper.revolve_direction_get
    if _newclass:
        direction = _swig_property(_ifcopenshell_wrapper.revolve_direction_get, _ifcopenshell_wrapper.revolve_direction_set)
    __swig_setmethods__["angle"] = _ifcopenshell_wrapper.revolve_angle_set
    __swig_getmethods__["angle"] = _ifcopenshell_wrapper.revolve_angle_get
    if _newclass:
        angle = _swig_property(_ifcopenshell_wrapper.revolve_angle_get, _ifcopenshell_wrapper.revolve_angle_set)

    def clone_(self):
        """clone_(revolve self) -> revolve"""
        return _ifcopenshell_wrapper.revolve_clone_(self)


    def kind(self):
        """kind(revolve self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.revolve_kind(self)


    def __init__(self, m, basis, pnt, dir, a):
        """__init__(ifcopenshell::geometry::taxonomy::revolve self, ifcopenshell::geometry::taxonomy::matrix4::ptr m, ifcopenshell::geometry::taxonomy::item::ptr basis, ifcopenshell::geometry::taxonomy::point3::ptr pnt, ifcopenshell::geometry::taxonomy::direction3::ptr dir, boost::optional< double > const & a) -> revolve"""
        this = _ifcopenshell_wrapper.new_revolve(m, basis, pnt, dir, a)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calc_hash(self):
        """calc_hash(revolve self) -> size_t"""
        return _ifcopenshell_wrapper.revolve_calc_hash(self)


    def matrix_(self):
        """matrix_(revolve self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
        return _ifcopenshell_wrapper.revolve_matrix_(self)


    matrix = property(matrix_)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_revolve
    __del__ = lambda self: None
revolve_swigregister = _ifcopenshell_wrapper.revolve_swigregister
revolve_swigregister(revolve)

class sweep_along_curve(sweep):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::sweep_along_curve class."""

    __swig_setmethods__ = {}
    for _s in [sweep]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, sweep_along_curve, name, value)
    __swig_getmethods__ = {}
    for _s in [sweep]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, sweep_along_curve, name)
    __repr__ = _swig_repr
    __swig_setmethods__["surface"] = _ifcopenshell_wrapper.sweep_along_curve_surface_set
    __swig_getmethods__["surface"] = _ifcopenshell_wrapper.sweep_along_curve_surface_get
    if _newclass:
        surface = _swig_property(_ifcopenshell_wrapper.sweep_along_curve_surface_get, _ifcopenshell_wrapper.sweep_along_curve_surface_set)
    __swig_setmethods__["curve"] = _ifcopenshell_wrapper.sweep_along_curve_curve_set
    __swig_getmethods__["curve"] = _ifcopenshell_wrapper.sweep_along_curve_curve_get
    if _newclass:
        curve = _swig_property(_ifcopenshell_wrapper.sweep_along_curve_curve_get, _ifcopenshell_wrapper.sweep_along_curve_curve_set)
    __swig_setmethods__["direction"] = _ifcopenshell_wrapper.sweep_along_curve_direction_set
    __swig_getmethods__["direction"] = _ifcopenshell_wrapper.sweep_along_curve_direction_get
    if _newclass:
        direction = _swig_property(_ifcopenshell_wrapper.sweep_along_curve_direction_get, _ifcopenshell_wrapper.sweep_along_curve_direction_set)

    def clone_(self):
        """clone_(sweep_along_curve self) -> sweep_along_curve"""
        return _ifcopenshell_wrapper.sweep_along_curve_clone_(self)


    def kind(self):
        """kind(sweep_along_curve self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.sweep_along_curve_kind(self)


    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::taxonomy::sweep_along_curve self, ifcopenshell::geometry::taxonomy::matrix4::ptr m, ifcopenshell::geometry::taxonomy::face::ptr basis, ifcopenshell::geometry::taxonomy::item::ptr surf, ifcopenshell::geometry::taxonomy::item::ptr crv) -> sweep_along_curve
        __init__(ifcopenshell::geometry::taxonomy::sweep_along_curve self, ifcopenshell::geometry::taxonomy::matrix4::ptr m, ifcopenshell::geometry::taxonomy::face::ptr profile, ifcopenshell::geometry::taxonomy::item::ptr directrix, ifcopenshell::geometry::taxonomy::direction3::ptr ref) -> sweep_along_curve
        """
        this = _ifcopenshell_wrapper.new_sweep_along_curve(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def calc_hash(self):
        """calc_hash(sweep_along_curve self) -> size_t"""
        return _ifcopenshell_wrapper.sweep_along_curve_calc_hash(self)


    __repr__ = taxonomy_item_repr

    __swig_destroy__ = _ifcopenshell_wrapper.delete_sweep_along_curve
    __del__ = lambda self: None
sweep_along_curve_swigregister = _ifcopenshell_wrapper.sweep_along_curve_swigregister
sweep_along_curve_swigregister(sweep_along_curve)

class node(item):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::node class."""

    __swig_setmethods__ = {}
    for _s in [item]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, node, name, value)
    __swig_getmethods__ = {}
    for _s in [item]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, node, name)
    __repr__ = _swig_repr

    def clone_(self):
        """clone_(node self) -> node"""
        return _ifcopenshell_wrapper.node_clone_(self)


    def kind(self):
        """kind(node self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.node_kind(self)


    def calc_hash(self):
        """calc_hash(node self) -> size_t"""
        return _ifcopenshell_wrapper.node_calc_hash(self)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::node self) -> node"""
        this = _ifcopenshell_wrapper.new_node()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_node
    __del__ = lambda self: None
node_swigregister = _ifcopenshell_wrapper.node_swigregister
node_swigregister(node)

class boolean_result(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::boolean_result class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, boolean_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, boolean_result, name)
    __repr__ = _swig_repr
    UNION = _ifcopenshell_wrapper.boolean_result_UNION
    SUBTRACTION = _ifcopenshell_wrapper.boolean_result_SUBTRACTION
    INTERSECTION = _ifcopenshell_wrapper.boolean_result_INTERSECTION

    def clone_(self):
        """clone_(boolean_result self) -> boolean_result"""
        return _ifcopenshell_wrapper.boolean_result_clone_(self)


    def kind(self):
        """kind(boolean_result self) -> ifcopenshell::geometry::taxonomy::kinds"""
        return _ifcopenshell_wrapper.boolean_result_kind(self)

    __swig_setmethods__["operation"] = _ifcopenshell_wrapper.boolean_result_operation_set
    __swig_getmethods__["operation"] = _ifcopenshell_wrapper.boolean_result_operation_get
    if _newclass:
        operation = _swig_property(_ifcopenshell_wrapper.boolean_result_operation_get, _ifcopenshell_wrapper.boolean_result_operation_set)

    def operation_str(op):
        """operation_str(ifcopenshell::geometry::taxonomy::boolean_result::operation_t op) -> std::string const &"""
        return _ifcopenshell_wrapper.boolean_result_operation_str(op)

    operation_str = staticmethod(operation_str)

    def calc_hash(self):
        """calc_hash(boolean_result self) -> size_t"""
        return _ifcopenshell_wrapper.boolean_result_calc_hash(self)


    def children_(self):
        """children_(boolean_result self) -> std::vector< ifcopenshell::geometry::taxonomy::geom_item::ptr,std::allocator< ifcopenshell::geometry::taxonomy::geom_item::ptr > > const &"""
        return _ifcopenshell_wrapper.boolean_result_children_(self)


    def __getitem__(self, index):
        """__getitem__(boolean_result self, int index) -> ifcopenshell::geometry::taxonomy::geom_item::ptr const &"""
        return _ifcopenshell_wrapper.boolean_result___getitem__(self, index)


    children = property(children_)
    def __iter__(self):
    	return iter(self.children)


    __repr__ = taxonomy_item_repr


    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::boolean_result self) -> boolean_result"""
        this = _ifcopenshell_wrapper.new_boolean_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_boolean_result
    __del__ = lambda self: None
boolean_result_swigregister = _ifcopenshell_wrapper.boolean_result_swigregister
boolean_result_swigregister(boolean_result)

def boolean_result_operation_str(op):
    """boolean_result_operation_str(ifcopenshell::geometry::taxonomy::boolean_result::operation_t op) -> std::string const &"""
    return _ifcopenshell_wrapper.boolean_result_operation_str(op)

class type_by_kind(_object):
    """Proxy of C++ ifcopenshell::geometry::taxonomy::type_by_kind class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, type_by_kind, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, type_by_kind, name)
    __repr__ = _swig_repr
    max = _ifcopenshell_wrapper.type_by_kind_max

    def __init__(self):
        """__init__(ifcopenshell::geometry::taxonomy::type_by_kind self) -> type_by_kind"""
        this = _ifcopenshell_wrapper.new_type_by_kind()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_type_by_kind
    __del__ = lambda self: None
type_by_kind_swigregister = _ifcopenshell_wrapper.type_by_kind_swigregister
type_by_kind_swigregister(type_by_kind)


def flatten(deep):
    """flatten(ifcopenshell::geometry::taxonomy::collection::ptr const & deep) -> ifcopenshell::geometry::taxonomy::collection::ptr"""
    return _ifcopenshell_wrapper.flatten(deep)

def create_box(*args):
    """
    create_box(double dx, double dy, double dz) -> ifcopenshell::geometry::taxonomy::solid::ptr
    create_box(double x, double y, double z, double dx, double dy, double dz) -> ifcopenshell::geometry::taxonomy::solid::ptr
    """
    return _ifcopenshell_wrapper.create_box(*args)
ATPATH = _ifcopenshell_wrapper.ATPATH
ATSTART = _ifcopenshell_wrapper.ATSTART
ATEND = _ifcopenshell_wrapper.ATEND
NOTDEFINED = _ifcopenshell_wrapper.NOTDEFINED

def helmert_curve_point(A0, A1, A2, s):
    """helmert_curve_point(double A0, double A1, double A2, double s) -> std::vector< double,std::allocator< double > >"""
    return _ifcopenshell_wrapper.helmert_curve_point(A0, A1, A2, s)

def convert_loop_to_function_item(loop):
    """convert_loop_to_function_item(ifcopenshell::geometry::taxonomy::loop::ptr loop) -> ifcopenshell::geometry::taxonomy::function_item::ptr"""
    return _ifcopenshell_wrapper.convert_loop_to_function_item(loop)
class fn_evaluator(_object):
    """Proxy of C++ ifcopenshell::geometry::fn_evaluator class."""

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

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

    def clone(self):
        """clone(fn_evaluator self) -> fn_evaluator"""
        return _ifcopenshell_wrapper.fn_evaluator_clone(self)


    def evaluate(self, u):
        """evaluate(fn_evaluator self, double u) -> Eigen::Matrix4d"""
        return _ifcopenshell_wrapper.fn_evaluator_evaluate(self, u)


    def start(self):
        """start(fn_evaluator self) -> double"""
        return _ifcopenshell_wrapper.fn_evaluator_start(self)


    def end(self):
        """end(fn_evaluator self) -> double"""
        return _ifcopenshell_wrapper.fn_evaluator_end(self)


    def length(self):
        """length(fn_evaluator self) -> double"""
        return _ifcopenshell_wrapper.fn_evaluator_length(self)

    __swig_setmethods__["settings_"] = _ifcopenshell_wrapper.fn_evaluator_settings__set
    __swig_getmethods__["settings_"] = _ifcopenshell_wrapper.fn_evaluator_settings__get
    if _newclass:
        settings_ = _swig_property(_ifcopenshell_wrapper.fn_evaluator_settings__get, _ifcopenshell_wrapper.fn_evaluator_settings__set)
fn_evaluator_swigregister = _ifcopenshell_wrapper.fn_evaluator_swigregister
fn_evaluator_swigregister(fn_evaluator)

class function_item_evaluator(_object):
    """Proxy of C++ ifcopenshell::geometry::function_item_evaluator class."""

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

    def __init__(self, *args):
        """
        __init__(ifcopenshell::geometry::function_item_evaluator self, Settings settings, ifcopenshell::geometry::taxonomy::function_item::const_ptr fn) -> function_item_evaluator
        __init__(ifcopenshell::geometry::function_item_evaluator self, function_item_evaluator other) -> function_item_evaluator
        """
        this = _ifcopenshell_wrapper.new_function_item_evaluator(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_function_item_evaluator
    __del__ = lambda self: None

    def evaluation_points(self, *args):
        """
        evaluation_points(function_item_evaluator self) -> std::vector< double,std::allocator< double > >
        evaluation_points(function_item_evaluator self, double ustart, double uend, unsigned int nsteps) -> std::vector< double,std::allocator< double > >
        """
        return _ifcopenshell_wrapper.function_item_evaluator_evaluation_points(self, *args)


    def evaluate(self, *args):
        """
        evaluate(function_item_evaluator self) -> ifcopenshell::geometry::taxonomy::item::ptr
        evaluate(function_item_evaluator self, double ustart, double uend, unsigned int nsteps) -> ifcopenshell::geometry::taxonomy::item::ptr
        evaluate(function_item_evaluator self, double u) -> Eigen::Matrix4d
        """
        return _ifcopenshell_wrapper.function_item_evaluator_evaluate(self, *args)

function_item_evaluator_swigregister = _ifcopenshell_wrapper.function_item_evaluator_swigregister
function_item_evaluator_swigregister(function_item_evaluator)

class horizontal_plan_at_element(_object):
    """Proxy of C++ horizontal_plan_at_element class."""

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

    def __init__(self):
        """__init__(horizontal_plan_at_element self) -> horizontal_plan_at_element"""
        this = _ifcopenshell_wrapper.new_horizontal_plan_at_element()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_horizontal_plan_at_element
    __del__ = lambda self: None
horizontal_plan_at_element_swigregister = _ifcopenshell_wrapper.horizontal_plan_at_element_swigregister
horizontal_plan_at_element_swigregister(horizontal_plan_at_element)

class drawing_meta(_object):
    """Proxy of C++ drawing_meta class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, drawing_meta, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, drawing_meta, name)
    __repr__ = _swig_repr
    __swig_setmethods__["pln_3d"] = _ifcopenshell_wrapper.drawing_meta_pln_3d_set
    __swig_getmethods__["pln_3d"] = _ifcopenshell_wrapper.drawing_meta_pln_3d_get
    if _newclass:
        pln_3d = _swig_property(_ifcopenshell_wrapper.drawing_meta_pln_3d_get, _ifcopenshell_wrapper.drawing_meta_pln_3d_set)
    __swig_setmethods__["matrix_3"] = _ifcopenshell_wrapper.drawing_meta_matrix_3_set
    __swig_getmethods__["matrix_3"] = _ifcopenshell_wrapper.drawing_meta_matrix_3_get
    if _newclass:
        matrix_3 = _swig_property(_ifcopenshell_wrapper.drawing_meta_matrix_3_get, _ifcopenshell_wrapper.drawing_meta_matrix_3_set)

    def __init__(self):
        """__init__(drawing_meta self) -> drawing_meta"""
        this = _ifcopenshell_wrapper.new_drawing_meta()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_drawing_meta
    __del__ = lambda self: None
drawing_meta_swigregister = _ifcopenshell_wrapper.drawing_meta_swigregister
drawing_meta_swigregister(drawing_meta)

ON_SLABS_AT_FLOORPLANS = _ifcopenshell_wrapper.ON_SLABS_AT_FLOORPLANS
ON_SLABS_AND_WALLS = _ifcopenshell_wrapper.ON_SLABS_AND_WALLS
ALWAYS = _ifcopenshell_wrapper.ALWAYS
class SvgSerializer(WriteOnlyGeometrySerializer):
    """Proxy of C++ SvgSerializer class."""

    __swig_setmethods__ = {}
    for _s in [WriteOnlyGeometrySerializer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SvgSerializer, name, value)
    __swig_getmethods__ = {}
    for _s in [WriteOnlyGeometrySerializer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, SvgSerializer, name)
    __repr__ = _swig_repr
    SH_NONE = _ifcopenshell_wrapper.SvgSerializer_SH_NONE
    SH_FULL = _ifcopenshell_wrapper.SvgSerializer_SH_FULL
    SH_LEFT = _ifcopenshell_wrapper.SvgSerializer_SH_LEFT

    def __init__(self, out_filename, geometry_settings, settings):
        """__init__(SvgSerializer self, buffer out_filename, Settings geometry_settings, SerializerSettings settings) -> SvgSerializer"""
        this = _ifcopenshell_wrapper.new_SvgSerializer(out_filename, geometry_settings, settings)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def addXCoordinate(self, fi):
        """addXCoordinate(SvgSerializer self, boost::shared_ptr< util::string_buffer::float_item > const & fi)"""
        return _ifcopenshell_wrapper.SvgSerializer_addXCoordinate(self, fi)


    def addYCoordinate(self, fi):
        """addYCoordinate(SvgSerializer self, boost::shared_ptr< util::string_buffer::float_item > const & fi)"""
        return _ifcopenshell_wrapper.SvgSerializer_addYCoordinate(self, fi)


    def addSizeComponent(self, fi):
        """addSizeComponent(SvgSerializer self, boost::shared_ptr< util::string_buffer::float_item > const & fi)"""
        return _ifcopenshell_wrapper.SvgSerializer_addSizeComponent(self, fi)


    def growBoundingBox(self, x, y):
        """growBoundingBox(SvgSerializer self, double x, double y)"""
        return _ifcopenshell_wrapper.SvgSerializer_growBoundingBox(self, x, y)


    def writeHeader(self):
        """writeHeader(SvgSerializer self)"""
        return _ifcopenshell_wrapper.SvgSerializer_writeHeader(self)


    def doWriteHeader(self):
        """doWriteHeader(SvgSerializer self)"""
        return _ifcopenshell_wrapper.SvgSerializer_doWriteHeader(self)


    def ready(self):
        """ready(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_ready(self)


    def write(self, *args):
        """
        write(SvgSerializer self, TriangulationElement arg2)
        write(SvgSerializer self, BRepElement o)
        write(SvgSerializer self, SvgSerializer::path_object & p, TopoDS_Shape const & wire, boost::optional< std::vector< double,std::allocator< double > > > dash_array)
        write(SvgSerializer self, SvgSerializer::path_object & p, TopoDS_Shape const & wire)
        write(SvgSerializer self, geometry_data const & data)
        """
        return _ifcopenshell_wrapper.SvgSerializer_write(self, *args)


    def start_path(self, *args):
        """
        start_path(SvgSerializer self, gp_Pln const & p, IfcBaseEntity storey, std::string const & id) -> SvgSerializer::path_object
        start_path(SvgSerializer self, gp_Pln const & p, std::string const & drawing_name, std::string const & id) -> SvgSerializer::path_object &
        """
        return _ifcopenshell_wrapper.SvgSerializer_start_path(self, *args)


    def isTesselated(self):
        """isTesselated(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_isTesselated(self)


    def finalize(self):
        """finalize(SvgSerializer self)"""
        return _ifcopenshell_wrapper.SvgSerializer_finalize(self)


    def setUnitNameAndMagnitude(self, arg2, arg3):
        """setUnitNameAndMagnitude(SvgSerializer self, std::string const & arg2, float arg3)"""
        return _ifcopenshell_wrapper.SvgSerializer_setUnitNameAndMagnitude(self, arg2, arg3)


    def setFile(self, f):
        """setFile(SvgSerializer self, file f)"""
        return _ifcopenshell_wrapper.SvgSerializer_setFile(self, f)


    def setBoundingRectangle(self, width, height):
        """setBoundingRectangle(SvgSerializer self, double width, double height)"""
        return _ifcopenshell_wrapper.SvgSerializer_setBoundingRectangle(self, width, height)


    def setSectionHeight(self, h, storey=None):
        """
        setSectionHeight(SvgSerializer self, double h, IfcBaseEntity storey=None)
        setSectionHeight(SvgSerializer self, double h)
        """
        return _ifcopenshell_wrapper.SvgSerializer_setSectionHeight(self, h, storey)


    def setSectionHeightsFromStoreys(self, offset=1.2):
        """
        setSectionHeightsFromStoreys(SvgSerializer self, double offset=1.2)
        setSectionHeightsFromStoreys(SvgSerializer self)
        """
        return _ifcopenshell_wrapper.SvgSerializer_setSectionHeightsFromStoreys(self, offset)


    def setPrintSpaceNames(self, b):
        """setPrintSpaceNames(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setPrintSpaceNames(self, b)


    def setPrintSpaceAreas(self, b):
        """setPrintSpaceAreas(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setPrintSpaceAreas(self, b)


    def setDrawStoreyHeights(self, sh):
        """setDrawStoreyHeights(SvgSerializer self, SvgSerializer::storey_height_display_types sh)"""
        return _ifcopenshell_wrapper.SvgSerializer_setDrawStoreyHeights(self, sh)


    def setDrawDoorArcs(self, b):
        """setDrawDoorArcs(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setDrawDoorArcs(self, b)


    def setStoreyHeightLineLength(self, d):
        """setStoreyHeightLineLength(SvgSerializer self, double d)"""
        return _ifcopenshell_wrapper.SvgSerializer_setStoreyHeightLineLength(self, d)


    def setSpaceNameTransform(self, v):
        """setSpaceNameTransform(SvgSerializer self, std::string const & v)"""
        return _ifcopenshell_wrapper.SvgSerializer_setSpaceNameTransform(self, v)


    def addTextAnnotations(self, k):
        """addTextAnnotations(SvgSerializer self, drawing_key const & k)"""
        return _ifcopenshell_wrapper.SvgSerializer_addTextAnnotations(self, k)


    def resize(self):
        """resize(SvgSerializer self) -> std::array< std::array< double,3 >,3 >"""
        return _ifcopenshell_wrapper.SvgSerializer_resize(self)


    def resetScale(self):
        """resetScale(SvgSerializer self)"""
        return _ifcopenshell_wrapper.SvgSerializer_resetScale(self)


    def setSectionRef(self, s):
        """setSectionRef(SvgSerializer self, boost::optional< std::string > const & s)"""
        return _ifcopenshell_wrapper.SvgSerializer_setSectionRef(self, s)


    def setElevationRef(self, s):
        """setElevationRef(SvgSerializer self, boost::optional< std::string > const & s)"""
        return _ifcopenshell_wrapper.SvgSerializer_setElevationRef(self, s)


    def setElevationRefGuid(self, s):
        """setElevationRefGuid(SvgSerializer self, boost::optional< std::string > const & s)"""
        return _ifcopenshell_wrapper.SvgSerializer_setElevationRefGuid(self, s)


    def setAutoSection(self, b):
        """setAutoSection(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setAutoSection(self, b)


    def setAutoElevation(self, b):
        """setAutoElevation(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setAutoElevation(self, b)


    def setUseNamespace(self, b):
        """setUseNamespace(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setUseNamespace(self, b)


    def setUseHlrPoly(self, b):
        """setUseHlrPoly(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setUseHlrPoly(self, b)


    def setUsePrefiltering(self, b):
        """setUsePrefiltering(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setUsePrefiltering(self, b)


    def getUsePrefiltering(self):
        """getUsePrefiltering(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_getUsePrefiltering(self)


    def setSegmentProjection(self, b):
        """setSegmentProjection(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setSegmentProjection(self, b)


    def getSegmentProjection(self):
        """getSegmentProjection(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_getSegmentProjection(self)


    def setPolygonal(self, b):
        """setPolygonal(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setPolygonal(self, b)


    def setAlwaysProject(self, b):
        """setAlwaysProject(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setAlwaysProject(self, b)


    def setWithoutStoreys(self, b):
        """setWithoutStoreys(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setWithoutStoreys(self, b)


    def setNoCSS(self, b):
        """setNoCSS(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setNoCSS(self, b)


    def setUnifyInputs(self, b):
        """setUnifyInputs(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setUnifyInputs(self, b)


    def getUnifyInputs(self):
        """getUnifyInputs(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_getUnifyInputs(self)


    def setOnlyValid(self, b):
        """setOnlyValid(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setOnlyValid(self, b)


    def getOnlyValid(self, b):
        """getOnlyValid(SvgSerializer self, bool b) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_getOnlyValid(self, b)


    def setScale(self, s):
        """setScale(SvgSerializer self, double s)"""
        return _ifcopenshell_wrapper.SvgSerializer_setScale(self, s)


    def setDrawingCenter(self, x, y):
        """setDrawingCenter(SvgSerializer self, double x, double y)"""
        return _ifcopenshell_wrapper.SvgSerializer_setDrawingCenter(self, x, y)


    def nameElement(self, *args):
        """
        nameElement(SvgSerializer self, IfcBaseEntity storey, Element elem) -> std::string
        nameElement(SvgSerializer self, IfcBaseEntity elem) -> std::string
        """
        return _ifcopenshell_wrapper.SvgSerializer_nameElement(self, *args)


    def idElement(self, elem):
        """idElement(SvgSerializer self, IfcBaseEntity elem) -> std::string"""
        return _ifcopenshell_wrapper.SvgSerializer_idElement(self, elem)


    def object_id(self, storey, o):
        """object_id(SvgSerializer self, IfcBaseEntity storey, Element o) -> std::string"""
        return _ifcopenshell_wrapper.SvgSerializer_object_id(self, storey, o)


    def addDrawing(self, pos, dir, ref, name, include_projection):
        """addDrawing(SvgSerializer self, gp_Pnt const & pos, gp_Dir const & dir, gp_Dir const & ref, std::string const & name, bool include_projection)"""
        return _ifcopenshell_wrapper.SvgSerializer_addDrawing(self, pos, dir, ref, name, include_projection)


    def setSubtractionSettings(self, sbp):
        """setSubtractionSettings(SvgSerializer self, subtract_before_project sbp)"""
        return _ifcopenshell_wrapper.SvgSerializer_setSubtractionSettings(self, sbp)


    def getSubtractionSettings(self):
        """getSubtractionSettings(SvgSerializer self) -> subtract_before_project"""
        return _ifcopenshell_wrapper.SvgSerializer_getSubtractionSettings(self)


    def setProfileThreshold(self, i):
        """setProfileThreshold(SvgSerializer self, int i)"""
        return _ifcopenshell_wrapper.SvgSerializer_setProfileThreshold(self, i)


    def getProfileThreshold(self):
        """getProfileThreshold(SvgSerializer self) -> int"""
        return _ifcopenshell_wrapper.SvgSerializer_getProfileThreshold(self)


    def setMirrorY(self, b):
        """setMirrorY(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setMirrorY(self, b)


    def getMirrorY(self):
        """getMirrorY(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_getMirrorY(self)


    def setMirrorX(self, b):
        """setMirrorX(SvgSerializer self, bool b)"""
        return _ifcopenshell_wrapper.SvgSerializer_setMirrorX(self, b)


    def getMirrorX(self):
        """getMirrorX(SvgSerializer self) -> bool"""
        return _ifcopenshell_wrapper.SvgSerializer_getMirrorX(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_SvgSerializer
    __del__ = lambda self: None
SvgSerializer_swigregister = _ifcopenshell_wrapper.SvgSerializer_swigregister
SvgSerializer_swigregister(SvgSerializer)

class HdfSerializer(GeometrySerializer):
    """Proxy of C++ HdfSerializer class."""

    __swig_setmethods__ = {}
    for _s in [GeometrySerializer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HdfSerializer, name, value)
    __swig_getmethods__ = {}
    for _s in [GeometrySerializer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, HdfSerializer, name)
    __repr__ = _swig_repr

    def __init__(self, hdf_filename, geometry_settings, settings, read_only=False):
        """
        __init__(HdfSerializer self, std::string const & hdf_filename, Settings geometry_settings, SerializerSettings settings, bool read_only=False) -> HdfSerializer
        __init__(HdfSerializer self, std::string const & hdf_filename, Settings geometry_settings, SerializerSettings settings) -> HdfSerializer
        """
        this = _ifcopenshell_wrapper.new_HdfSerializer(hdf_filename, geometry_settings, settings, read_only)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_HdfSerializer
    __del__ = lambda self: None

    def ready(self):
        """ready(HdfSerializer self) -> bool"""
        return _ifcopenshell_wrapper.HdfSerializer_ready(self)


    def writeHeader(self):
        """writeHeader(HdfSerializer self)"""
        return _ifcopenshell_wrapper.HdfSerializer_writeHeader(self)


    def write(self, *args):
        """
        write(HdfSerializer self, Element o) -> H5::Group
        write(HdfSerializer self, BRepElement o)
        write(HdfSerializer self, TriangulationElement o)
        """
        return _ifcopenshell_wrapper.HdfSerializer_write(self, *args)


    def remove(self, guid):
        """remove(HdfSerializer self, std::string const & guid)"""
        return _ifcopenshell_wrapper.HdfSerializer_remove(self, guid)


    def read(self, *args):
        """
        read(HdfSerializer self, file f, std::string const & guid, std::string const & arg4, GeometrySerializer::read_type rt) -> Element
        read(HdfSerializer self, file f, std::string const & guid, std::string const & arg4) -> Element
        """
        return _ifcopenshell_wrapper.HdfSerializer_read(self, *args)


    def finalize(self):
        """finalize(HdfSerializer self)"""
        return _ifcopenshell_wrapper.HdfSerializer_finalize(self)


    def isTesselated(self):
        """isTesselated(HdfSerializer self) -> bool"""
        return _ifcopenshell_wrapper.HdfSerializer_isTesselated(self)


    def setUnitNameAndMagnitude(self, arg2, arg3):
        """setUnitNameAndMagnitude(HdfSerializer self, std::string const & arg2, float arg3)"""
        return _ifcopenshell_wrapper.HdfSerializer_setUnitNameAndMagnitude(self, arg2, arg3)


    def setFile(self, arg2):
        """setFile(HdfSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.HdfSerializer_setFile(self, arg2)

HdfSerializer_swigregister = _ifcopenshell_wrapper.HdfSerializer_swigregister
HdfSerializer_swigregister(HdfSerializer)

class WaveFrontOBJSerializer(WriteOnlyGeometrySerializer):
    """Proxy of C++ WaveFrontOBJSerializer class."""

    __swig_setmethods__ = {}
    for _s in [WriteOnlyGeometrySerializer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WaveFrontOBJSerializer, name, value)
    __swig_getmethods__ = {}
    for _s in [WriteOnlyGeometrySerializer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, WaveFrontOBJSerializer, name)
    __repr__ = _swig_repr

    def __init__(self, obj_filename, mtl_filename, geometry_settings, settings):
        """__init__(WaveFrontOBJSerializer self, buffer obj_filename, buffer mtl_filename, Settings geometry_settings, SerializerSettings settings) -> WaveFrontOBJSerializer"""
        this = _ifcopenshell_wrapper.new_WaveFrontOBJSerializer(obj_filename, mtl_filename, geometry_settings, settings)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_WaveFrontOBJSerializer
    __del__ = lambda self: None

    def ready(self):
        """ready(WaveFrontOBJSerializer self) -> bool"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_ready(self)


    def writeHeader(self):
        """writeHeader(WaveFrontOBJSerializer self)"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_writeHeader(self)


    def writeMaterial(self, style):
        """writeMaterial(WaveFrontOBJSerializer self, ifcopenshell::geometry::taxonomy::style::ptr const style)"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_writeMaterial(self, style)


    def write(self, *args):
        """
        write(WaveFrontOBJSerializer self, TriangulationElement o)
        write(WaveFrontOBJSerializer self, BRepElement arg2)
        """
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_write(self, *args)


    def finalize(self):
        """finalize(WaveFrontOBJSerializer self)"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_finalize(self)


    def isTesselated(self):
        """isTesselated(WaveFrontOBJSerializer self) -> bool"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_isTesselated(self)


    def setUnitNameAndMagnitude(self, arg2, arg3):
        """setUnitNameAndMagnitude(WaveFrontOBJSerializer self, std::string const & arg2, float arg3)"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_setUnitNameAndMagnitude(self, arg2, arg3)


    def setFile(self, arg2):
        """setFile(WaveFrontOBJSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.WaveFrontOBJSerializer_setFile(self, arg2)

WaveFrontOBJSerializer_swigregister = _ifcopenshell_wrapper.WaveFrontOBJSerializer_swigregister
WaveFrontOBJSerializer_swigregister(WaveFrontOBJSerializer)

class ColladaSerializer(WriteOnlyGeometrySerializer):
    """Proxy of C++ ColladaSerializer class."""

    __swig_setmethods__ = {}
    for _s in [WriteOnlyGeometrySerializer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ColladaSerializer, name, value)
    __swig_getmethods__ = {}
    for _s in [WriteOnlyGeometrySerializer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, ColladaSerializer, name)
    __repr__ = _swig_repr

    def __init__(self, dae_filename, geometry_settings, settings):
        """__init__(ColladaSerializer self, std::string const & dae_filename, Settings geometry_settings, SerializerSettings settings) -> ColladaSerializer"""
        this = _ifcopenshell_wrapper.new_ColladaSerializer(dae_filename, geometry_settings, settings)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def ready(self):
        """ready(ColladaSerializer self) -> bool"""
        return _ifcopenshell_wrapper.ColladaSerializer_ready(self)


    def writeHeader(self):
        """writeHeader(ColladaSerializer self)"""
        return _ifcopenshell_wrapper.ColladaSerializer_writeHeader(self)


    def write(self, *args):
        """
        write(ColladaSerializer self, TriangulationElement o)
        write(ColladaSerializer self, BRepElement arg2)
        """
        return _ifcopenshell_wrapper.ColladaSerializer_write(self, *args)


    def finalize(self):
        """finalize(ColladaSerializer self)"""
        return _ifcopenshell_wrapper.ColladaSerializer_finalize(self)


    def isTesselated(self):
        """isTesselated(ColladaSerializer self) -> bool"""
        return _ifcopenshell_wrapper.ColladaSerializer_isTesselated(self)


    def setUnitNameAndMagnitude(self, name, magnitude):
        """setUnitNameAndMagnitude(ColladaSerializer self, std::string const & name, float magnitude)"""
        return _ifcopenshell_wrapper.ColladaSerializer_setUnitNameAndMagnitude(self, name, magnitude)


    def setFile(self, arg2):
        """setFile(ColladaSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.ColladaSerializer_setFile(self, arg2)


    def object_id(self, o):
        """object_id(ColladaSerializer self, Element o) -> std::string"""
        return _ifcopenshell_wrapper.ColladaSerializer_object_id(self, o)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_ColladaSerializer
    __del__ = lambda self: None
ColladaSerializer_swigregister = _ifcopenshell_wrapper.ColladaSerializer_swigregister
ColladaSerializer_swigregister(ColladaSerializer)

class XmlSerializer(_object):
    """Proxy of C++ XmlSerializer class."""

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

    def __init__(self, file, xml_filename):
        """__init__(XmlSerializer self, file file, std::string const & xml_filename) -> XmlSerializer"""
        this = _ifcopenshell_wrapper.new_XmlSerializer(file, xml_filename)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_XmlSerializer
    __del__ = lambda self: None

    def ready(self):
        """ready(XmlSerializer self) -> bool"""
        return _ifcopenshell_wrapper.XmlSerializer_ready(self)


    def writeHeader(self):
        """writeHeader(XmlSerializer self)"""
        return _ifcopenshell_wrapper.XmlSerializer_writeHeader(self)


    def finalize(self):
        """finalize(XmlSerializer self)"""
        return _ifcopenshell_wrapper.XmlSerializer_finalize(self)


    def setFile(self, arg2):
        """setFile(XmlSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.XmlSerializer_setFile(self, arg2)

XmlSerializer_swigregister = _ifcopenshell_wrapper.XmlSerializer_swigregister
XmlSerializer_swigregister(XmlSerializer)

class XmlSerializerFactory(_object):
    """Proxy of C++ XmlSerializerFactory class."""

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

    def implementations():
        """implementations() -> XmlSerializerFactory::Factory &"""
        return _ifcopenshell_wrapper.XmlSerializerFactory_implementations()

    implementations = staticmethod(implementations)

    def __init__(self):
        """__init__(XmlSerializerFactory self) -> XmlSerializerFactory"""
        this = _ifcopenshell_wrapper.new_XmlSerializerFactory()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_XmlSerializerFactory
    __del__ = lambda self: None
XmlSerializerFactory_swigregister = _ifcopenshell_wrapper.XmlSerializerFactory_swigregister
XmlSerializerFactory_swigregister(XmlSerializerFactory)

def XmlSerializerFactory_implementations():
    """XmlSerializerFactory_implementations() -> XmlSerializerFactory::Factory &"""
    return _ifcopenshell_wrapper.XmlSerializerFactory_implementations()

class GltfSerializer(WriteOnlyGeometrySerializer):
    """Proxy of C++ GltfSerializer class."""

    __swig_setmethods__ = {}
    for _s in [WriteOnlyGeometrySerializer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GltfSerializer, name, value)
    __swig_getmethods__ = {}
    for _s in [WriteOnlyGeometrySerializer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, GltfSerializer, name)
    __repr__ = _swig_repr

    def __init__(self, filename, geometry_settings, settings):
        """__init__(GltfSerializer self, std::string const & filename, Settings geometry_settings, SerializerSettings settings) -> GltfSerializer"""
        this = _ifcopenshell_wrapper.new_GltfSerializer(filename, geometry_settings, settings)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_GltfSerializer
    __del__ = lambda self: None

    def ready(self):
        """ready(GltfSerializer self) -> bool"""
        return _ifcopenshell_wrapper.GltfSerializer_ready(self)


    def writeHeader(self):
        """writeHeader(GltfSerializer self)"""
        return _ifcopenshell_wrapper.GltfSerializer_writeHeader(self)


    def write(self, *args):
        """
        write(GltfSerializer self, TriangulationElement o)
        write(GltfSerializer self, BRepElement arg2)
        """
        return _ifcopenshell_wrapper.GltfSerializer_write(self, *args)


    def finalize(self):
        """finalize(GltfSerializer self)"""
        return _ifcopenshell_wrapper.GltfSerializer_finalize(self)


    def isTesselated(self):
        """isTesselated(GltfSerializer self) -> bool"""
        return _ifcopenshell_wrapper.GltfSerializer_isTesselated(self)


    def setUnitNameAndMagnitude(self, arg2, arg3):
        """setUnitNameAndMagnitude(GltfSerializer self, std::string const & arg2, float arg3)"""
        return _ifcopenshell_wrapper.GltfSerializer_setUnitNameAndMagnitude(self, arg2, arg3)


    def setFile(self, arg2):
        """setFile(GltfSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.GltfSerializer_setFile(self, arg2)

GltfSerializer_swigregister = _ifcopenshell_wrapper.GltfSerializer_swigregister
GltfSerializer_swigregister(GltfSerializer)

class TtlWktSerializer(WriteOnlyGeometrySerializer):
    """Proxy of C++ TtlWktSerializer class."""

    __swig_setmethods__ = {}
    for _s in [WriteOnlyGeometrySerializer]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TtlWktSerializer, name, value)
    __swig_getmethods__ = {}
    for _s in [WriteOnlyGeometrySerializer]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, TtlWktSerializer, name)
    __repr__ = _swig_repr

    def __init__(self, filename, geometry_settings, settings):
        """__init__(TtlWktSerializer self, buffer filename, Settings geometry_settings, SerializerSettings settings) -> TtlWktSerializer"""
        this = _ifcopenshell_wrapper.new_TtlWktSerializer(filename, geometry_settings, settings)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_TtlWktSerializer
    __del__ = lambda self: None

    def ready(self):
        """ready(TtlWktSerializer self) -> bool"""
        return _ifcopenshell_wrapper.TtlWktSerializer_ready(self)


    def writeHeader(self):
        """writeHeader(TtlWktSerializer self)"""
        return _ifcopenshell_wrapper.TtlWktSerializer_writeHeader(self)


    def write(self, *args):
        """
        write(TtlWktSerializer self, TriangulationElement o)
        write(TtlWktSerializer self, BRepElement arg2)
        """
        return _ifcopenshell_wrapper.TtlWktSerializer_write(self, *args)


    def finalize(self):
        """finalize(TtlWktSerializer self)"""
        return _ifcopenshell_wrapper.TtlWktSerializer_finalize(self)


    def isTesselated(self):
        """isTesselated(TtlWktSerializer self) -> bool"""
        return _ifcopenshell_wrapper.TtlWktSerializer_isTesselated(self)


    def setUnitNameAndMagnitude(self, arg2, arg3):
        """setUnitNameAndMagnitude(TtlWktSerializer self, std::string const & arg2, float arg3)"""
        return _ifcopenshell_wrapper.TtlWktSerializer_setUnitNameAndMagnitude(self, arg2, arg3)


    def setFile(self, arg2):
        """setFile(TtlWktSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.TtlWktSerializer_setFile(self, arg2)


    def ttl_object_id(self, o, postfix=None):
        """
        ttl_object_id(TtlWktSerializer self, Element o, char const *const postfix=None) -> std::string
        ttl_object_id(TtlWktSerializer self, Element o) -> std::string
        """
        return _ifcopenshell_wrapper.TtlWktSerializer_ttl_object_id(self, o, postfix)

TtlWktSerializer_swigregister = _ifcopenshell_wrapper.TtlWktSerializer_swigregister
TtlWktSerializer_swigregister(TtlWktSerializer)

class ray_intersection_results(_object):
    """Proxy of C++ std::vector<(IfcGeom::ray_intersection_result)> class."""

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

    def iterator(self):
        """iterator(ray_intersection_results self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.ray_intersection_results_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(ray_intersection_results self) -> bool"""
        return _ifcopenshell_wrapper.ray_intersection_results___nonzero__(self)


    def __bool__(self):
        """__bool__(ray_intersection_results self) -> bool"""
        return _ifcopenshell_wrapper.ray_intersection_results___bool__(self)


    def __len__(self):
        """__len__(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::size_type"""
        return _ifcopenshell_wrapper.ray_intersection_results___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, std::vector< IfcGeom::ray_intersection_result >::difference_type j) -> ray_intersection_results"""
        return _ifcopenshell_wrapper.ray_intersection_results___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, std::vector< IfcGeom::ray_intersection_result >::difference_type j)
        __setslice__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, std::vector< IfcGeom::ray_intersection_result >::difference_type j, ray_intersection_results v)
        """
        return _ifcopenshell_wrapper.ray_intersection_results___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, std::vector< IfcGeom::ray_intersection_result >::difference_type j)"""
        return _ifcopenshell_wrapper.ray_intersection_results___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i)
        __delitem__(ray_intersection_results self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.ray_intersection_results___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(ray_intersection_results self, PySliceObject * slice) -> ray_intersection_results
        __getitem__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i) -> ray_intersection_result
        """
        return _ifcopenshell_wrapper.ray_intersection_results___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(ray_intersection_results self, PySliceObject * slice, ray_intersection_results v)
        __setitem__(ray_intersection_results self, PySliceObject * slice)
        __setitem__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i, ray_intersection_result x)
        """
        return _ifcopenshell_wrapper.ray_intersection_results___setitem__(self, *args)


    def pop(self):
        """pop(ray_intersection_results self) -> ray_intersection_result"""
        return _ifcopenshell_wrapper.ray_intersection_results_pop(self)


    def append(self, x):
        """append(ray_intersection_results self, ray_intersection_result x)"""
        return _ifcopenshell_wrapper.ray_intersection_results_append(self, x)


    def empty(self):
        """empty(ray_intersection_results self) -> bool"""
        return _ifcopenshell_wrapper.ray_intersection_results_empty(self)


    def size(self):
        """size(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::size_type"""
        return _ifcopenshell_wrapper.ray_intersection_results_size(self)


    def swap(self, v):
        """swap(ray_intersection_results self, ray_intersection_results v)"""
        return _ifcopenshell_wrapper.ray_intersection_results_swap(self, v)


    def begin(self):
        """begin(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::iterator"""
        return _ifcopenshell_wrapper.ray_intersection_results_begin(self)


    def end(self):
        """end(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::iterator"""
        return _ifcopenshell_wrapper.ray_intersection_results_end(self)


    def rbegin(self):
        """rbegin(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::reverse_iterator"""
        return _ifcopenshell_wrapper.ray_intersection_results_rbegin(self)


    def rend(self):
        """rend(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::reverse_iterator"""
        return _ifcopenshell_wrapper.ray_intersection_results_rend(self)


    def clear(self):
        """clear(ray_intersection_results self)"""
        return _ifcopenshell_wrapper.ray_intersection_results_clear(self)


    def get_allocator(self):
        """get_allocator(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::allocator_type"""
        return _ifcopenshell_wrapper.ray_intersection_results_get_allocator(self)


    def pop_back(self):
        """pop_back(ray_intersection_results self)"""
        return _ifcopenshell_wrapper.ray_intersection_results_pop_back(self)


    def erase(self, *args):
        """
        erase(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::iterator pos) -> std::vector< IfcGeom::ray_intersection_result >::iterator
        erase(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::iterator first, std::vector< IfcGeom::ray_intersection_result >::iterator last) -> std::vector< IfcGeom::ray_intersection_result >::iterator
        """
        return _ifcopenshell_wrapper.ray_intersection_results_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(IfcGeom::ray_intersection_result)> self) -> ray_intersection_results
        __init__(std::vector<(IfcGeom::ray_intersection_result)> self, ray_intersection_results arg2) -> ray_intersection_results
        __init__(std::vector<(IfcGeom::ray_intersection_result)> self, std::vector< IfcGeom::ray_intersection_result >::size_type size) -> ray_intersection_results
        __init__(std::vector<(IfcGeom::ray_intersection_result)> self, std::vector< IfcGeom::ray_intersection_result >::size_type size, ray_intersection_result value) -> ray_intersection_results
        """
        this = _ifcopenshell_wrapper.new_ray_intersection_results(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(ray_intersection_results self, ray_intersection_result x)"""
        return _ifcopenshell_wrapper.ray_intersection_results_push_back(self, x)


    def front(self):
        """front(ray_intersection_results self) -> ray_intersection_result"""
        return _ifcopenshell_wrapper.ray_intersection_results_front(self)


    def back(self):
        """back(ray_intersection_results self) -> ray_intersection_result"""
        return _ifcopenshell_wrapper.ray_intersection_results_back(self)


    def assign(self, n, x):
        """assign(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type n, ray_intersection_result x)"""
        return _ifcopenshell_wrapper.ray_intersection_results_assign(self, n, x)


    def resize(self, *args):
        """
        resize(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type new_size)
        resize(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type new_size, ray_intersection_result x)
        """
        return _ifcopenshell_wrapper.ray_intersection_results_resize(self, *args)


    def insert(self, *args):
        """
        insert(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::iterator pos, ray_intersection_result x) -> std::vector< IfcGeom::ray_intersection_result >::iterator
        insert(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::iterator pos, std::vector< IfcGeom::ray_intersection_result >::size_type n, ray_intersection_result x)
        """
        return _ifcopenshell_wrapper.ray_intersection_results_insert(self, *args)


    def reserve(self, n):
        """reserve(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type n)"""
        return _ifcopenshell_wrapper.ray_intersection_results_reserve(self, n)


    def capacity(self):
        """capacity(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::size_type"""
        return _ifcopenshell_wrapper.ray_intersection_results_capacity(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_ray_intersection_results
    __del__ = lambda self: None
ray_intersection_results_swigregister = _ifcopenshell_wrapper.ray_intersection_results_swigregister
ray_intersection_results_swigregister(ray_intersection_results)

class clashes(_object):
    """Proxy of C++ std::vector<(IfcGeom::clash)> class."""

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

    def iterator(self):
        """iterator(clashes self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.clashes_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(clashes self) -> bool"""
        return _ifcopenshell_wrapper.clashes___nonzero__(self)


    def __bool__(self):
        """__bool__(clashes self) -> bool"""
        return _ifcopenshell_wrapper.clashes___bool__(self)


    def __len__(self):
        """__len__(clashes self) -> std::vector< IfcGeom::clash >::size_type"""
        return _ifcopenshell_wrapper.clashes___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(clashes self, std::vector< IfcGeom::clash >::difference_type i, std::vector< IfcGeom::clash >::difference_type j) -> clashes"""
        return _ifcopenshell_wrapper.clashes___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(clashes self, std::vector< IfcGeom::clash >::difference_type i, std::vector< IfcGeom::clash >::difference_type j)
        __setslice__(clashes self, std::vector< IfcGeom::clash >::difference_type i, std::vector< IfcGeom::clash >::difference_type j, clashes v)
        """
        return _ifcopenshell_wrapper.clashes___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(clashes self, std::vector< IfcGeom::clash >::difference_type i, std::vector< IfcGeom::clash >::difference_type j)"""
        return _ifcopenshell_wrapper.clashes___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(clashes self, std::vector< IfcGeom::clash >::difference_type i)
        __delitem__(clashes self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.clashes___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(clashes self, PySliceObject * slice) -> clashes
        __getitem__(clashes self, std::vector< IfcGeom::clash >::difference_type i) -> clash
        """
        return _ifcopenshell_wrapper.clashes___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(clashes self, PySliceObject * slice, clashes v)
        __setitem__(clashes self, PySliceObject * slice)
        __setitem__(clashes self, std::vector< IfcGeom::clash >::difference_type i, clash x)
        """
        return _ifcopenshell_wrapper.clashes___setitem__(self, *args)


    def pop(self):
        """pop(clashes self) -> clash"""
        return _ifcopenshell_wrapper.clashes_pop(self)


    def append(self, x):
        """append(clashes self, clash x)"""
        return _ifcopenshell_wrapper.clashes_append(self, x)


    def empty(self):
        """empty(clashes self) -> bool"""
        return _ifcopenshell_wrapper.clashes_empty(self)


    def size(self):
        """size(clashes self) -> std::vector< IfcGeom::clash >::size_type"""
        return _ifcopenshell_wrapper.clashes_size(self)


    def swap(self, v):
        """swap(clashes self, clashes v)"""
        return _ifcopenshell_wrapper.clashes_swap(self, v)


    def begin(self):
        """begin(clashes self) -> std::vector< IfcGeom::clash >::iterator"""
        return _ifcopenshell_wrapper.clashes_begin(self)


    def end(self):
        """end(clashes self) -> std::vector< IfcGeom::clash >::iterator"""
        return _ifcopenshell_wrapper.clashes_end(self)


    def rbegin(self):
        """rbegin(clashes self) -> std::vector< IfcGeom::clash >::reverse_iterator"""
        return _ifcopenshell_wrapper.clashes_rbegin(self)


    def rend(self):
        """rend(clashes self) -> std::vector< IfcGeom::clash >::reverse_iterator"""
        return _ifcopenshell_wrapper.clashes_rend(self)


    def clear(self):
        """clear(clashes self)"""
        return _ifcopenshell_wrapper.clashes_clear(self)


    def get_allocator(self):
        """get_allocator(clashes self) -> std::vector< IfcGeom::clash >::allocator_type"""
        return _ifcopenshell_wrapper.clashes_get_allocator(self)


    def pop_back(self):
        """pop_back(clashes self)"""
        return _ifcopenshell_wrapper.clashes_pop_back(self)


    def erase(self, *args):
        """
        erase(clashes self, std::vector< IfcGeom::clash >::iterator pos) -> std::vector< IfcGeom::clash >::iterator
        erase(clashes self, std::vector< IfcGeom::clash >::iterator first, std::vector< IfcGeom::clash >::iterator last) -> std::vector< IfcGeom::clash >::iterator
        """
        return _ifcopenshell_wrapper.clashes_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(IfcGeom::clash)> self) -> clashes
        __init__(std::vector<(IfcGeom::clash)> self, clashes arg2) -> clashes
        __init__(std::vector<(IfcGeom::clash)> self, std::vector< IfcGeom::clash >::size_type size) -> clashes
        __init__(std::vector<(IfcGeom::clash)> self, std::vector< IfcGeom::clash >::size_type size, clash value) -> clashes
        """
        this = _ifcopenshell_wrapper.new_clashes(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(clashes self, clash x)"""
        return _ifcopenshell_wrapper.clashes_push_back(self, x)


    def front(self):
        """front(clashes self) -> clash"""
        return _ifcopenshell_wrapper.clashes_front(self)


    def back(self):
        """back(clashes self) -> clash"""
        return _ifcopenshell_wrapper.clashes_back(self)


    def assign(self, n, x):
        """assign(clashes self, std::vector< IfcGeom::clash >::size_type n, clash x)"""
        return _ifcopenshell_wrapper.clashes_assign(self, n, x)


    def resize(self, *args):
        """
        resize(clashes self, std::vector< IfcGeom::clash >::size_type new_size)
        resize(clashes self, std::vector< IfcGeom::clash >::size_type new_size, clash x)
        """
        return _ifcopenshell_wrapper.clashes_resize(self, *args)


    def insert(self, *args):
        """
        insert(clashes self, std::vector< IfcGeom::clash >::iterator pos, clash x) -> std::vector< IfcGeom::clash >::iterator
        insert(clashes self, std::vector< IfcGeom::clash >::iterator pos, std::vector< IfcGeom::clash >::size_type n, clash x)
        """
        return _ifcopenshell_wrapper.clashes_insert(self, *args)


    def reserve(self, n):
        """reserve(clashes self, std::vector< IfcGeom::clash >::size_type n)"""
        return _ifcopenshell_wrapper.clashes_reserve(self, n)


    def capacity(self):
        """capacity(clashes self) -> std::vector< IfcGeom::clash >::size_type"""
        return _ifcopenshell_wrapper.clashes_capacity(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_clashes
    __del__ = lambda self: None
clashes_swigregister = _ifcopenshell_wrapper.clashes_swigregister
clashes_swigregister(clashes)

class ray_intersection_result(_object):
    """Proxy of C++ IfcGeom::ray_intersection_result class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ray_intersection_result, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ray_intersection_result, name)
    __repr__ = _swig_repr
    __swig_setmethods__["distance"] = _ifcopenshell_wrapper.ray_intersection_result_distance_set
    __swig_getmethods__["distance"] = _ifcopenshell_wrapper.ray_intersection_result_distance_get
    if _newclass:
        distance = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_distance_get, _ifcopenshell_wrapper.ray_intersection_result_distance_set)
    __swig_setmethods__["style_index"] = _ifcopenshell_wrapper.ray_intersection_result_style_index_set
    __swig_getmethods__["style_index"] = _ifcopenshell_wrapper.ray_intersection_result_style_index_get
    if _newclass:
        style_index = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_style_index_get, _ifcopenshell_wrapper.ray_intersection_result_style_index_set)
    __swig_setmethods__["instance"] = _ifcopenshell_wrapper.ray_intersection_result_instance_set
    __swig_getmethods__["instance"] = _ifcopenshell_wrapper.ray_intersection_result_instance_get
    if _newclass:
        instance = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_instance_get, _ifcopenshell_wrapper.ray_intersection_result_instance_set)
    __swig_setmethods__["position"] = _ifcopenshell_wrapper.ray_intersection_result_position_set
    __swig_getmethods__["position"] = _ifcopenshell_wrapper.ray_intersection_result_position_get
    if _newclass:
        position = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_position_get, _ifcopenshell_wrapper.ray_intersection_result_position_set)
    __swig_setmethods__["normal"] = _ifcopenshell_wrapper.ray_intersection_result_normal_set
    __swig_getmethods__["normal"] = _ifcopenshell_wrapper.ray_intersection_result_normal_get
    if _newclass:
        normal = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_normal_get, _ifcopenshell_wrapper.ray_intersection_result_normal_set)
    __swig_setmethods__["ray_distance"] = _ifcopenshell_wrapper.ray_intersection_result_ray_distance_set
    __swig_getmethods__["ray_distance"] = _ifcopenshell_wrapper.ray_intersection_result_ray_distance_get
    if _newclass:
        ray_distance = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_ray_distance_get, _ifcopenshell_wrapper.ray_intersection_result_ray_distance_set)
    __swig_setmethods__["dot_product"] = _ifcopenshell_wrapper.ray_intersection_result_dot_product_set
    __swig_getmethods__["dot_product"] = _ifcopenshell_wrapper.ray_intersection_result_dot_product_get
    if _newclass:
        dot_product = _swig_property(_ifcopenshell_wrapper.ray_intersection_result_dot_product_get, _ifcopenshell_wrapper.ray_intersection_result_dot_product_set)

    def __init__(self):
        """__init__(IfcGeom::ray_intersection_result self) -> ray_intersection_result"""
        this = _ifcopenshell_wrapper.new_ray_intersection_result()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_ray_intersection_result
    __del__ = lambda self: None
ray_intersection_result_swigregister = _ifcopenshell_wrapper.ray_intersection_result_swigregister
ray_intersection_result_swigregister(ray_intersection_result)

class clash(_object):
    """Proxy of C++ IfcGeom::clash class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, clash, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, clash, name)
    __repr__ = _swig_repr
    __swig_setmethods__["clash_type"] = _ifcopenshell_wrapper.clash_clash_type_set
    __swig_getmethods__["clash_type"] = _ifcopenshell_wrapper.clash_clash_type_get
    if _newclass:
        clash_type = _swig_property(_ifcopenshell_wrapper.clash_clash_type_get, _ifcopenshell_wrapper.clash_clash_type_set)
    __swig_setmethods__["a"] = _ifcopenshell_wrapper.clash_a_set
    __swig_getmethods__["a"] = _ifcopenshell_wrapper.clash_a_get
    if _newclass:
        a = _swig_property(_ifcopenshell_wrapper.clash_a_get, _ifcopenshell_wrapper.clash_a_set)
    __swig_setmethods__["b"] = _ifcopenshell_wrapper.clash_b_set
    __swig_getmethods__["b"] = _ifcopenshell_wrapper.clash_b_get
    if _newclass:
        b = _swig_property(_ifcopenshell_wrapper.clash_b_get, _ifcopenshell_wrapper.clash_b_set)
    __swig_setmethods__["distance"] = _ifcopenshell_wrapper.clash_distance_set
    __swig_getmethods__["distance"] = _ifcopenshell_wrapper.clash_distance_get
    if _newclass:
        distance = _swig_property(_ifcopenshell_wrapper.clash_distance_get, _ifcopenshell_wrapper.clash_distance_set)
    __swig_setmethods__["p1"] = _ifcopenshell_wrapper.clash_p1_set
    __swig_getmethods__["p1"] = _ifcopenshell_wrapper.clash_p1_get
    if _newclass:
        p1 = _swig_property(_ifcopenshell_wrapper.clash_p1_get, _ifcopenshell_wrapper.clash_p1_set)
    __swig_setmethods__["p2"] = _ifcopenshell_wrapper.clash_p2_set
    __swig_getmethods__["p2"] = _ifcopenshell_wrapper.clash_p2_get
    if _newclass:
        p2 = _swig_property(_ifcopenshell_wrapper.clash_p2_get, _ifcopenshell_wrapper.clash_p2_set)

    def __init__(self):
        """__init__(IfcGeom::clash self) -> clash"""
        this = _ifcopenshell_wrapper.new_clash()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_clash
    __del__ = lambda self: None
clash_swigregister = _ifcopenshell_wrapper.clash_swigregister
clash_swigregister(clash)

class tree(_object):
    """Proxy of C++ IfcGeom::tree class."""

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

    def __init__(self, *args):
        """
        __init__(IfcGeom::tree self) -> tree
        __init__(IfcGeom::tree self, file f) -> tree
        __init__(IfcGeom::tree self, file f, Settings settings) -> tree
        __init__(IfcGeom::tree self, Iterator it) -> tree
        """
        this = _ifcopenshell_wrapper.new_tree(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def add_file(self, *args):
        """
        add_file(tree self, file f, Settings settings)
        add_file(tree self, Iterator it)
        """
        return _ifcopenshell_wrapper.tree_add_file(self, *args)


    def write_h5(self):
        """write_h5(tree self)"""
        return _ifcopenshell_wrapper.tree_write_h5(self)


    def uint8_to_b64(self, uuids_array):
        """uint8_to_b64(tree self, std::vector< uint8_t,std::allocator< uint8_t > > const & uuids_array) -> std::string"""
        return _ifcopenshell_wrapper.tree_uint8_to_b64(self, uuids_array)


    def is_manifold(fs):
        """is_manifold(std::vector< int,std::allocator< int > > const & fs) -> bool"""
        return _ifcopenshell_wrapper.tree_is_manifold(fs)

    is_manifold = staticmethod(is_manifold)

    def add_element(self, *args):
        """
        add_element(tree self, TriangulationElement elem)
        add_element(tree self, BRepElement elem)
        """
        return _ifcopenshell_wrapper.tree_add_element(self, *args)


    def distances(self):
        """distances(tree self) -> std::vector< double,std::allocator< double > > const &"""
        return _ifcopenshell_wrapper.tree_distances(self)


    def protrusion_distances(self):
        """protrusion_distances(tree self) -> std::vector< double,std::allocator< double > > const &"""
        return _ifcopenshell_wrapper.tree_protrusion_distances(self)


    def select_ray(self, p0, d, length=1000.):
        """
        select_ray(tree self, gp_Pnt const & p0, gp_Dir const & d, double length=1000.) -> ray_intersection_results
        select_ray(tree self, gp_Pnt const & p0, gp_Dir const & d) -> ray_intersection_results
        """
        return _ifcopenshell_wrapper.tree_select_ray(self, p0, d, length)


    def enable_face_styles(self, *args):
        """
        enable_face_styles(tree self) -> bool
        enable_face_styles(tree self, bool b)
        """
        return _ifcopenshell_wrapper.tree_enable_face_styles(self, *args)


    def styles(self):
        """styles(tree self) -> std::vector< ifcopenshell::geometry::taxonomy::style::ptr,std::allocator< ifcopenshell::geometry::taxonomy::style::ptr > > const &"""
        return _ifcopenshell_wrapper.tree_styles(self)


    def vector_to_list(ps):
        """vector_to_list(std::vector< IfcUtil::IfcBaseEntity const *,std::allocator< IfcUtil::IfcBaseEntity const * > > const & ps) -> aggregate_of_instance::ptr"""
        return _ifcopenshell_wrapper.tree_vector_to_list(ps)

    vector_to_list = staticmethod(vector_to_list)

    def select_box(self, *args):
        """
        select_box(tree self, entity_instance e, bool completely_within=False, double extend=-1.e-5) -> aggregate_of_instance::ptr
        select_box(tree self, entity_instance e, bool completely_within=False) -> aggregate_of_instance::ptr
        select_box(tree self, entity_instance e) -> aggregate_of_instance::ptr
        select_box(tree self, gp_Pnt const & p) -> aggregate_of_instance::ptr
        select_box(tree self, Bnd_Box const & b, bool completely_within=False) -> aggregate_of_instance::ptr
        select_box(tree self, Bnd_Box const & b) -> aggregate_of_instance::ptr
        """
        return _ifcopenshell_wrapper.tree_select_box(self, *args)


    def select(self, *args):
        """
        select(tree self, entity_instance e, bool completely_within=False, double extend=0.0) -> aggregate_of_instance::ptr
        select(tree self, entity_instance e, bool completely_within=False) -> aggregate_of_instance::ptr
        select(tree self, entity_instance e) -> aggregate_of_instance::ptr
        select(tree self, gp_Pnt const & p, double extend=0.0) -> aggregate_of_instance::ptr
        select(tree self, gp_Pnt const & p) -> aggregate_of_instance::ptr
        select(tree self, std::string const & shape_serialization, bool completely_within=False, double extend=-1.e-5) -> aggregate_of_instance::ptr
        select(tree self, std::string const & shape_serialization, bool completely_within=False) -> aggregate_of_instance::ptr
        select(tree self, std::string const & shape_serialization) -> aggregate_of_instance::ptr
        select(tree self, BRepElement elem, bool completely_within=False, double extend=-1.e-5) -> aggregate_of_instance::ptr
        select(tree self, BRepElement elem, bool completely_within=False) -> aggregate_of_instance::ptr
        select(tree self, BRepElement elem) -> aggregate_of_instance::ptr
        """
        return _ifcopenshell_wrapper.tree_select(self, *args)


    def clash_intersection_many(self, set_a, set_b, tolerance, check_all):
        """clash_intersection_many(tree self, std::vector< IfcUtil::IfcBaseClass *,std::allocator< IfcUtil::IfcBaseClass * > > const & set_a, std::vector< IfcUtil::IfcBaseClass *,std::allocator< IfcUtil::IfcBaseClass * > > const & set_b, double tolerance, bool check_all) -> clashes"""
        return _ifcopenshell_wrapper.tree_clash_intersection_many(self, set_a, set_b, tolerance, check_all)


    def clash_collision_many(self, set_a, set_b, allow_touching):
        """clash_collision_many(tree self, std::vector< IfcUtil::IfcBaseClass *,std::allocator< IfcUtil::IfcBaseClass * > > const & set_a, std::vector< IfcUtil::IfcBaseClass *,std::allocator< IfcUtil::IfcBaseClass * > > const & set_b, bool allow_touching) -> clashes"""
        return _ifcopenshell_wrapper.tree_clash_collision_many(self, set_a, set_b, allow_touching)


    def clash_clearance_many(self, set_a, set_b, clearance, check_all):
        """clash_clearance_many(tree self, std::vector< IfcUtil::IfcBaseClass *,std::allocator< IfcUtil::IfcBaseClass * > > const & set_a, std::vector< IfcUtil::IfcBaseClass *,std::allocator< IfcUtil::IfcBaseClass * > > const & set_b, double clearance, bool check_all) -> clashes"""
        return _ifcopenshell_wrapper.tree_clash_clearance_many(self, set_a, set_b, clearance, check_all)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_tree
    __del__ = lambda self: None
tree_swigregister = _ifcopenshell_wrapper.tree_swigregister
tree_swigregister(tree)

def tree_is_manifold(fs):
    """tree_is_manifold(std::vector< int,std::allocator< int > > const & fs) -> bool"""
    return _ifcopenshell_wrapper.tree_is_manifold(fs)

def tree_vector_to_list(ps):
    """tree_vector_to_list(std::vector< IfcUtil::IfcBaseEntity const *,std::allocator< IfcUtil::IfcBaseEntity const * > > const & ps) -> aggregate_of_instance::ptr"""
    return _ifcopenshell_wrapper.tree_vector_to_list(ps)


def construct_iterator_with_include_exclude(geometry_library, settings, file, elems, include, num_threads):
    """construct_iterator_with_include_exclude(std::string const & geometry_library, Settings settings, file file, std::vector< std::string,std::allocator< std::string > > elems, bool include, int num_threads) -> Iterator"""
    return _ifcopenshell_wrapper.construct_iterator_with_include_exclude(geometry_library, settings, file, elems, include, num_threads)

def construct_iterator_with_include_exclude_globalid(geometry_library, settings, file, elems, include, num_threads):
    """construct_iterator_with_include_exclude_globalid(std::string const & geometry_library, Settings settings, file file, std::vector< std::string,std::allocator< std::string > > elems, bool include, int num_threads) -> Iterator"""
    return _ifcopenshell_wrapper.construct_iterator_with_include_exclude_globalid(geometry_library, settings, file, elems, include, num_threads)

def construct_iterator_with_include_exclude_id(geometry_library, settings, file, elems, include, num_threads):
    """construct_iterator_with_include_exclude_id(std::string const & geometry_library, Settings settings, file file, std::vector< int,std::allocator< int > > elems, bool include, int num_threads) -> Iterator"""
    return _ifcopenshell_wrapper.construct_iterator_with_include_exclude_id(geometry_library, settings, file, elems, include, num_threads)

def map_shape(settings, instance):
    """map_shape(Settings settings, entity_instance instance) -> ifcopenshell::geometry::taxonomy::item::ptr"""
    return _ifcopenshell_wrapper.map_shape(settings, instance)

def create_shape(*args):
    """
    create_shape(Settings settings, entity_instance instance, entity_instance representation=None, char const *const geometry_library) -> boost::variant< IfcGeom::Element *,IfcGeom::Representation::Representation *,IfcGeom::Transformation * >
    create_shape(Settings settings, entity_instance instance, entity_instance representation=None) -> boost::variant< IfcGeom::Element *,IfcGeom::Representation::Representation *,IfcGeom::Transformation * >
    create_shape(Settings settings, entity_instance instance) -> boost::variant< IfcGeom::Element *,IfcGeom::Representation::Representation *,IfcGeom::Transformation * >
    """
    return _ifcopenshell_wrapper.create_shape(*args)

def serialise(schema_name, shape_str, advanced=True):
    """
    serialise(std::string const & schema_name, std::string const & shape_str, bool advanced=True) -> entity_instance
    serialise(std::string const & schema_name, std::string const & shape_str) -> entity_instance
    """
    return _ifcopenshell_wrapper.serialise(schema_name, shape_str, advanced)

def tesselate(schema_name, shape_str, d):
    """tesselate(std::string const & schema_name, std::string const & shape_str, double d) -> entity_instance"""
    return _ifcopenshell_wrapper.tesselate(schema_name, shape_str, d)
class svg_line_segments(_object):
    """Proxy of C++ std::vector<(std::array<(svgfill::point_2,2)>)> class."""

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

    def iterator(self):
        """iterator(svg_line_segments self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_line_segments_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(svg_line_segments self) -> bool"""
        return _ifcopenshell_wrapper.svg_line_segments___nonzero__(self)


    def __bool__(self):
        """__bool__(svg_line_segments self) -> bool"""
        return _ifcopenshell_wrapper.svg_line_segments___bool__(self)


    def __len__(self):
        """__len__(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_line_segments___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, std::vector< std::array< svgfill::point_2,2 > >::difference_type j) -> svg_line_segments"""
        return _ifcopenshell_wrapper.svg_line_segments___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, std::vector< std::array< svgfill::point_2,2 > >::difference_type j)
        __setslice__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, std::vector< std::array< svgfill::point_2,2 > >::difference_type j, svg_line_segments v)
        """
        return _ifcopenshell_wrapper.svg_line_segments___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, std::vector< std::array< svgfill::point_2,2 > >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_line_segments___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i)
        __delitem__(svg_line_segments self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_line_segments___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(svg_line_segments self, PySliceObject * slice) -> svg_line_segments
        __getitem__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i) -> line_segment
        """
        return _ifcopenshell_wrapper.svg_line_segments___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(svg_line_segments self, PySliceObject * slice, svg_line_segments v)
        __setitem__(svg_line_segments self, PySliceObject * slice)
        __setitem__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i, line_segment x)
        """
        return _ifcopenshell_wrapper.svg_line_segments___setitem__(self, *args)


    def pop(self):
        """pop(svg_line_segments self) -> line_segment"""
        return _ifcopenshell_wrapper.svg_line_segments_pop(self)


    def append(self, x):
        """append(svg_line_segments self, line_segment x)"""
        return _ifcopenshell_wrapper.svg_line_segments_append(self, x)


    def empty(self):
        """empty(svg_line_segments self) -> bool"""
        return _ifcopenshell_wrapper.svg_line_segments_empty(self)


    def size(self):
        """size(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_line_segments_size(self)


    def swap(self, v):
        """swap(svg_line_segments self, svg_line_segments v)"""
        return _ifcopenshell_wrapper.svg_line_segments_swap(self, v)


    def begin(self):
        """begin(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::iterator"""
        return _ifcopenshell_wrapper.svg_line_segments_begin(self)


    def end(self):
        """end(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::iterator"""
        return _ifcopenshell_wrapper.svg_line_segments_end(self)


    def rbegin(self):
        """rbegin(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_line_segments_rbegin(self)


    def rend(self):
        """rend(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_line_segments_rend(self)


    def clear(self):
        """clear(svg_line_segments self)"""
        return _ifcopenshell_wrapper.svg_line_segments_clear(self)


    def get_allocator(self):
        """get_allocator(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::allocator_type"""
        return _ifcopenshell_wrapper.svg_line_segments_get_allocator(self)


    def pop_back(self):
        """pop_back(svg_line_segments self)"""
        return _ifcopenshell_wrapper.svg_line_segments_pop_back(self)


    def erase(self, *args):
        """
        erase(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::iterator pos) -> std::vector< std::array< svgfill::point_2,2 > >::iterator
        erase(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::iterator first, std::vector< std::array< svgfill::point_2,2 > >::iterator last) -> std::vector< std::array< svgfill::point_2,2 > >::iterator
        """
        return _ifcopenshell_wrapper.svg_line_segments_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::array<(svgfill::point_2,2)>)> self) -> svg_line_segments
        __init__(std::vector<(std::array<(svgfill::point_2,2)>)> self, svg_line_segments arg2) -> svg_line_segments
        __init__(std::vector<(std::array<(svgfill::point_2,2)>)> self, std::vector< std::array< svgfill::point_2,2 > >::size_type size) -> svg_line_segments
        __init__(std::vector<(std::array<(svgfill::point_2,2)>)> self, std::vector< std::array< svgfill::point_2,2 > >::size_type size, line_segment value) -> svg_line_segments
        """
        this = _ifcopenshell_wrapper.new_svg_line_segments(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(svg_line_segments self, line_segment x)"""
        return _ifcopenshell_wrapper.svg_line_segments_push_back(self, x)


    def front(self):
        """front(svg_line_segments self) -> line_segment"""
        return _ifcopenshell_wrapper.svg_line_segments_front(self)


    def back(self):
        """back(svg_line_segments self) -> line_segment"""
        return _ifcopenshell_wrapper.svg_line_segments_back(self)


    def assign(self, n, x):
        """assign(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type n, line_segment x)"""
        return _ifcopenshell_wrapper.svg_line_segments_assign(self, n, x)


    def resize(self, *args):
        """
        resize(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type new_size)
        resize(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type new_size, line_segment x)
        """
        return _ifcopenshell_wrapper.svg_line_segments_resize(self, *args)


    def insert(self, *args):
        """
        insert(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::iterator pos, line_segment x) -> std::vector< std::array< svgfill::point_2,2 > >::iterator
        insert(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::iterator pos, std::vector< std::array< svgfill::point_2,2 > >::size_type n, line_segment x)
        """
        return _ifcopenshell_wrapper.svg_line_segments_insert(self, *args)


    def reserve(self, n):
        """reserve(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type n)"""
        return _ifcopenshell_wrapper.svg_line_segments_reserve(self, n)


    def capacity(self):
        """capacity(svg_line_segments self) -> std::vector< std::array< svgfill::point_2,2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_line_segments_capacity(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_line_segments
    __del__ = lambda self: None
svg_line_segments_swigregister = _ifcopenshell_wrapper.svg_line_segments_swigregister
svg_line_segments_swigregister(svg_line_segments)

class svg_groups_of_line_segments(_object):
    """Proxy of C++ std::vector<(std::vector<(std::array<(svgfill::point_2,2)>)>)> class."""

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

    def iterator(self):
        """iterator(svg_groups_of_line_segments self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(svg_groups_of_line_segments self) -> bool"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___nonzero__(self)


    def __bool__(self):
        """__bool__(svg_groups_of_line_segments self) -> bool"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___bool__(self)


    def __len__(self):
        """__len__(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type j) -> svg_groups_of_line_segments"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type j)
        __setslice__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type j, svg_groups_of_line_segments v)
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i)
        __delitem__(svg_groups_of_line_segments self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(svg_groups_of_line_segments self, PySliceObject * slice) -> svg_groups_of_line_segments
        __getitem__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i) -> svg_line_segments
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(svg_groups_of_line_segments self, PySliceObject * slice, svg_groups_of_line_segments v)
        __setitem__(svg_groups_of_line_segments self, PySliceObject * slice)
        __setitem__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::difference_type i, svg_line_segments x)
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments___setitem__(self, *args)


    def pop(self):
        """pop(svg_groups_of_line_segments self) -> svg_line_segments"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_pop(self)


    def append(self, x):
        """append(svg_groups_of_line_segments self, svg_line_segments x)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_append(self, x)


    def empty(self):
        """empty(svg_groups_of_line_segments self) -> bool"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_empty(self)


    def size(self):
        """size(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_size(self)


    def swap(self, v):
        """swap(svg_groups_of_line_segments self, svg_groups_of_line_segments v)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_swap(self, v)


    def begin(self):
        """begin(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_begin(self)


    def end(self):
        """end(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_end(self)


    def rbegin(self):
        """rbegin(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_rbegin(self)


    def rend(self):
        """rend(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_rend(self)


    def clear(self):
        """clear(svg_groups_of_line_segments self)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_clear(self)


    def get_allocator(self):
        """get_allocator(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::allocator_type"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_get_allocator(self)


    def pop_back(self):
        """pop_back(svg_groups_of_line_segments self)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_pop_back(self)


    def erase(self, *args):
        """
        erase(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator pos) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator
        erase(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator first, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator last) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::vector<(std::array<(svgfill::point_2,2)>)>)> self) -> svg_groups_of_line_segments
        __init__(std::vector<(std::vector<(std::array<(svgfill::point_2,2)>)>)> self, svg_groups_of_line_segments arg2) -> svg_groups_of_line_segments
        __init__(std::vector<(std::vector<(std::array<(svgfill::point_2,2)>)>)> self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type size) -> svg_groups_of_line_segments
        __init__(std::vector<(std::vector<(std::array<(svgfill::point_2,2)>)>)> self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type size, svg_line_segments value) -> svg_groups_of_line_segments
        """
        this = _ifcopenshell_wrapper.new_svg_groups_of_line_segments(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(svg_groups_of_line_segments self, svg_line_segments x)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_push_back(self, x)


    def front(self):
        """front(svg_groups_of_line_segments self) -> svg_line_segments"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_front(self)


    def back(self):
        """back(svg_groups_of_line_segments self) -> svg_line_segments"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_back(self)


    def assign(self, n, x):
        """assign(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type n, svg_line_segments x)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_assign(self, n, x)


    def resize(self, *args):
        """
        resize(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type new_size)
        resize(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type new_size, svg_line_segments x)
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_resize(self, *args)


    def insert(self, *args):
        """
        insert(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator pos, svg_line_segments x) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator
        insert(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::iterator pos, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type n, svg_line_segments x)
        """
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_insert(self, *args)


    def reserve(self, n):
        """reserve(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type n)"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_reserve(self, n)


    def capacity(self):
        """capacity(svg_groups_of_line_segments self) -> std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type"""
        return _ifcopenshell_wrapper.svg_groups_of_line_segments_capacity(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_groups_of_line_segments
    __del__ = lambda self: None
svg_groups_of_line_segments_swigregister = _ifcopenshell_wrapper.svg_groups_of_line_segments_swigregister
svg_groups_of_line_segments_swigregister(svg_groups_of_line_segments)

class svg_point(_object):
    """Proxy of C++ std::array<(double,2)> class."""

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

    def iterator(self):
        """iterator(svg_point self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_point_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(svg_point self) -> bool"""
        return _ifcopenshell_wrapper.svg_point___nonzero__(self)


    def __bool__(self):
        """__bool__(svg_point self) -> bool"""
        return _ifcopenshell_wrapper.svg_point___bool__(self)


    def __len__(self):
        """__len__(svg_point self) -> std::array< double,2 >::size_type"""
        return _ifcopenshell_wrapper.svg_point___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::difference_type j) -> svg_point"""
        return _ifcopenshell_wrapper.svg_point___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::difference_type j)
        __setslice__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::difference_type j, svg_point v)
        """
        return _ifcopenshell_wrapper.svg_point___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_point___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(svg_point self, std::array< double,2 >::difference_type i)
        __delitem__(svg_point self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_point___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(svg_point self, PySliceObject * slice) -> svg_point
        __getitem__(svg_point self, std::array< double,2 >::difference_type i) -> std::array< double,2 >::value_type const &
        """
        return _ifcopenshell_wrapper.svg_point___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(svg_point self, PySliceObject * slice, svg_point v)
        __setitem__(svg_point self, PySliceObject * slice)
        __setitem__(svg_point self, std::array< double,2 >::difference_type i, std::array< double,2 >::value_type const & x)
        """
        return _ifcopenshell_wrapper.svg_point___setitem__(self, *args)


    def __init__(self, *args):
        """
        __init__(std::array<(double,2)> self) -> svg_point
        __init__(std::array<(double,2)> self, svg_point arg2) -> svg_point
        """
        this = _ifcopenshell_wrapper.new_svg_point(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        """empty(svg_point self) -> bool"""
        return _ifcopenshell_wrapper.svg_point_empty(self)


    def size(self):
        """size(svg_point self) -> std::array< double,2 >::size_type"""
        return _ifcopenshell_wrapper.svg_point_size(self)


    def swap(self, v):
        """swap(svg_point self, svg_point v)"""
        return _ifcopenshell_wrapper.svg_point_swap(self, v)


    def begin(self):
        """begin(svg_point self) -> std::array< double,2 >::iterator"""
        return _ifcopenshell_wrapper.svg_point_begin(self)


    def end(self):
        """end(svg_point self) -> std::array< double,2 >::iterator"""
        return _ifcopenshell_wrapper.svg_point_end(self)


    def rbegin(self):
        """rbegin(svg_point self) -> std::array< double,2 >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_point_rbegin(self)


    def rend(self):
        """rend(svg_point self) -> std::array< double,2 >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_point_rend(self)


    def front(self):
        """front(svg_point self) -> std::array< double,2 >::value_type const &"""
        return _ifcopenshell_wrapper.svg_point_front(self)


    def back(self):
        """back(svg_point self) -> std::array< double,2 >::value_type const &"""
        return _ifcopenshell_wrapper.svg_point_back(self)


    def fill(self, u):
        """fill(svg_point self, std::array< double,2 >::value_type const & u)"""
        return _ifcopenshell_wrapper.svg_point_fill(self, u)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_point
    __del__ = lambda self: None
svg_point_swigregister = _ifcopenshell_wrapper.svg_point_swigregister
svg_point_swigregister(svg_point)

class line_segment(_object):
    """Proxy of C++ std::array<(svgfill::point_2,2)> class."""

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

    def iterator(self):
        """iterator(line_segment self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.line_segment_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(line_segment self) -> bool"""
        return _ifcopenshell_wrapper.line_segment___nonzero__(self)


    def __bool__(self):
        """__bool__(line_segment self) -> bool"""
        return _ifcopenshell_wrapper.line_segment___bool__(self)


    def __len__(self):
        """__len__(line_segment self) -> std::array< svgfill::point_2,2 >::size_type"""
        return _ifcopenshell_wrapper.line_segment___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::difference_type j) -> line_segment"""
        return _ifcopenshell_wrapper.line_segment___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::difference_type j)
        __setslice__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::difference_type j, line_segment v)
        """
        return _ifcopenshell_wrapper.line_segment___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::difference_type j)"""
        return _ifcopenshell_wrapper.line_segment___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i)
        __delitem__(line_segment self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.line_segment___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(line_segment self, PySliceObject * slice) -> line_segment
        __getitem__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i) -> std::array< svgfill::point_2,2 >::value_type const &
        """
        return _ifcopenshell_wrapper.line_segment___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(line_segment self, PySliceObject * slice, line_segment v)
        __setitem__(line_segment self, PySliceObject * slice)
        __setitem__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i, std::array< svgfill::point_2,2 >::value_type const & x)
        """
        return _ifcopenshell_wrapper.line_segment___setitem__(self, *args)


    def __init__(self, *args):
        """
        __init__(std::array<(svgfill::point_2,2)> self) -> line_segment
        __init__(std::array<(svgfill::point_2,2)> self, line_segment arg2) -> line_segment
        """
        this = _ifcopenshell_wrapper.new_line_segment(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def empty(self):
        """empty(line_segment self) -> bool"""
        return _ifcopenshell_wrapper.line_segment_empty(self)


    def size(self):
        """size(line_segment self) -> std::array< svgfill::point_2,2 >::size_type"""
        return _ifcopenshell_wrapper.line_segment_size(self)


    def swap(self, v):
        """swap(line_segment self, line_segment v)"""
        return _ifcopenshell_wrapper.line_segment_swap(self, v)


    def begin(self):
        """begin(line_segment self) -> std::array< svgfill::point_2,2 >::iterator"""
        return _ifcopenshell_wrapper.line_segment_begin(self)


    def end(self):
        """end(line_segment self) -> std::array< svgfill::point_2,2 >::iterator"""
        return _ifcopenshell_wrapper.line_segment_end(self)


    def rbegin(self):
        """rbegin(line_segment self) -> std::array< svgfill::point_2,2 >::reverse_iterator"""
        return _ifcopenshell_wrapper.line_segment_rbegin(self)


    def rend(self):
        """rend(line_segment self) -> std::array< svgfill::point_2,2 >::reverse_iterator"""
        return _ifcopenshell_wrapper.line_segment_rend(self)


    def front(self):
        """front(line_segment self) -> std::array< svgfill::point_2,2 >::value_type const &"""
        return _ifcopenshell_wrapper.line_segment_front(self)


    def back(self):
        """back(line_segment self) -> std::array< svgfill::point_2,2 >::value_type const &"""
        return _ifcopenshell_wrapper.line_segment_back(self)


    def fill(self, u):
        """fill(line_segment self, std::array< svgfill::point_2,2 >::value_type const & u)"""
        return _ifcopenshell_wrapper.line_segment_fill(self, u)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_line_segment
    __del__ = lambda self: None
line_segment_swigregister = _ifcopenshell_wrapper.line_segment_swigregister
line_segment_swigregister(line_segment)

class svg_polygons(_object):
    """Proxy of C++ std::vector<(svgfill::polygon_2)> class."""

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

    def iterator(self):
        """iterator(svg_polygons self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_polygons_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(svg_polygons self) -> bool"""
        return _ifcopenshell_wrapper.svg_polygons___nonzero__(self)


    def __bool__(self):
        """__bool__(svg_polygons self) -> bool"""
        return _ifcopenshell_wrapper.svg_polygons___bool__(self)


    def __len__(self):
        """__len__(svg_polygons self) -> std::vector< svgfill::polygon_2 >::size_type"""
        return _ifcopenshell_wrapper.svg_polygons___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, std::vector< svgfill::polygon_2 >::difference_type j) -> svg_polygons"""
        return _ifcopenshell_wrapper.svg_polygons___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, std::vector< svgfill::polygon_2 >::difference_type j)
        __setslice__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, std::vector< svgfill::polygon_2 >::difference_type j, svg_polygons v)
        """
        return _ifcopenshell_wrapper.svg_polygons___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, std::vector< svgfill::polygon_2 >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_polygons___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i)
        __delitem__(svg_polygons self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_polygons___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(svg_polygons self, PySliceObject * slice) -> svg_polygons
        __getitem__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i) -> polygon_2
        """
        return _ifcopenshell_wrapper.svg_polygons___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(svg_polygons self, PySliceObject * slice, svg_polygons v)
        __setitem__(svg_polygons self, PySliceObject * slice)
        __setitem__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i, polygon_2 x)
        """
        return _ifcopenshell_wrapper.svg_polygons___setitem__(self, *args)


    def pop(self):
        """pop(svg_polygons self) -> polygon_2"""
        return _ifcopenshell_wrapper.svg_polygons_pop(self)


    def append(self, x):
        """append(svg_polygons self, polygon_2 x)"""
        return _ifcopenshell_wrapper.svg_polygons_append(self, x)


    def empty(self):
        """empty(svg_polygons self) -> bool"""
        return _ifcopenshell_wrapper.svg_polygons_empty(self)


    def size(self):
        """size(svg_polygons self) -> std::vector< svgfill::polygon_2 >::size_type"""
        return _ifcopenshell_wrapper.svg_polygons_size(self)


    def swap(self, v):
        """swap(svg_polygons self, svg_polygons v)"""
        return _ifcopenshell_wrapper.svg_polygons_swap(self, v)


    def begin(self):
        """begin(svg_polygons self) -> std::vector< svgfill::polygon_2 >::iterator"""
        return _ifcopenshell_wrapper.svg_polygons_begin(self)


    def end(self):
        """end(svg_polygons self) -> std::vector< svgfill::polygon_2 >::iterator"""
        return _ifcopenshell_wrapper.svg_polygons_end(self)


    def rbegin(self):
        """rbegin(svg_polygons self) -> std::vector< svgfill::polygon_2 >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_polygons_rbegin(self)


    def rend(self):
        """rend(svg_polygons self) -> std::vector< svgfill::polygon_2 >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_polygons_rend(self)


    def clear(self):
        """clear(svg_polygons self)"""
        return _ifcopenshell_wrapper.svg_polygons_clear(self)


    def get_allocator(self):
        """get_allocator(svg_polygons self) -> std::vector< svgfill::polygon_2 >::allocator_type"""
        return _ifcopenshell_wrapper.svg_polygons_get_allocator(self)


    def pop_back(self):
        """pop_back(svg_polygons self)"""
        return _ifcopenshell_wrapper.svg_polygons_pop_back(self)


    def erase(self, *args):
        """
        erase(svg_polygons self, std::vector< svgfill::polygon_2 >::iterator pos) -> std::vector< svgfill::polygon_2 >::iterator
        erase(svg_polygons self, std::vector< svgfill::polygon_2 >::iterator first, std::vector< svgfill::polygon_2 >::iterator last) -> std::vector< svgfill::polygon_2 >::iterator
        """
        return _ifcopenshell_wrapper.svg_polygons_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(svgfill::polygon_2)> self) -> svg_polygons
        __init__(std::vector<(svgfill::polygon_2)> self, svg_polygons arg2) -> svg_polygons
        __init__(std::vector<(svgfill::polygon_2)> self, std::vector< svgfill::polygon_2 >::size_type size) -> svg_polygons
        __init__(std::vector<(svgfill::polygon_2)> self, std::vector< svgfill::polygon_2 >::size_type size, polygon_2 value) -> svg_polygons
        """
        this = _ifcopenshell_wrapper.new_svg_polygons(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(svg_polygons self, polygon_2 x)"""
        return _ifcopenshell_wrapper.svg_polygons_push_back(self, x)


    def front(self):
        """front(svg_polygons self) -> polygon_2"""
        return _ifcopenshell_wrapper.svg_polygons_front(self)


    def back(self):
        """back(svg_polygons self) -> polygon_2"""
        return _ifcopenshell_wrapper.svg_polygons_back(self)


    def assign(self, n, x):
        """assign(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type n, polygon_2 x)"""
        return _ifcopenshell_wrapper.svg_polygons_assign(self, n, x)


    def resize(self, *args):
        """
        resize(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type new_size)
        resize(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type new_size, polygon_2 x)
        """
        return _ifcopenshell_wrapper.svg_polygons_resize(self, *args)


    def insert(self, *args):
        """
        insert(svg_polygons self, std::vector< svgfill::polygon_2 >::iterator pos, polygon_2 x) -> std::vector< svgfill::polygon_2 >::iterator
        insert(svg_polygons self, std::vector< svgfill::polygon_2 >::iterator pos, std::vector< svgfill::polygon_2 >::size_type n, polygon_2 x)
        """
        return _ifcopenshell_wrapper.svg_polygons_insert(self, *args)


    def reserve(self, n):
        """reserve(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type n)"""
        return _ifcopenshell_wrapper.svg_polygons_reserve(self, n)


    def capacity(self):
        """capacity(svg_polygons self) -> std::vector< svgfill::polygon_2 >::size_type"""
        return _ifcopenshell_wrapper.svg_polygons_capacity(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_polygons
    __del__ = lambda self: None
svg_polygons_swigregister = _ifcopenshell_wrapper.svg_polygons_swigregister
svg_polygons_swigregister(svg_polygons)

class svg_groups_of_polygons(_object):
    """Proxy of C++ std::vector<(std::vector<(svgfill::polygon_2)>)> class."""

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

    def iterator(self):
        """iterator(svg_groups_of_polygons self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(svg_groups_of_polygons self) -> bool"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons___nonzero__(self)


    def __bool__(self):
        """__bool__(svg_groups_of_polygons self) -> bool"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons___bool__(self)


    def __len__(self):
        """__len__(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, std::vector< std::vector< svgfill::polygon_2 > >::difference_type j) -> svg_groups_of_polygons"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, std::vector< std::vector< svgfill::polygon_2 > >::difference_type j)
        __setslice__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, std::vector< std::vector< svgfill::polygon_2 > >::difference_type j, svg_groups_of_polygons v)
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, std::vector< std::vector< svgfill::polygon_2 > >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i)
        __delitem__(svg_groups_of_polygons self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(svg_groups_of_polygons self, PySliceObject * slice) -> svg_groups_of_polygons
        __getitem__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i) -> svg_polygons
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(svg_groups_of_polygons self, PySliceObject * slice, svg_groups_of_polygons v)
        __setitem__(svg_groups_of_polygons self, PySliceObject * slice)
        __setitem__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i, svg_polygons x)
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons___setitem__(self, *args)


    def pop(self):
        """pop(svg_groups_of_polygons self) -> svg_polygons"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_pop(self)


    def append(self, x):
        """append(svg_groups_of_polygons self, svg_polygons x)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_append(self, x)


    def empty(self):
        """empty(svg_groups_of_polygons self) -> bool"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_empty(self)


    def size(self):
        """size(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_size(self)


    def swap(self, v):
        """swap(svg_groups_of_polygons self, svg_groups_of_polygons v)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_swap(self, v)


    def begin(self):
        """begin(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_begin(self)


    def end(self):
        """end(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_end(self)


    def rbegin(self):
        """rbegin(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_rbegin(self)


    def rend(self):
        """rend(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_rend(self)


    def clear(self):
        """clear(svg_groups_of_polygons self)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_clear(self)


    def get_allocator(self):
        """get_allocator(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::allocator_type"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_get_allocator(self)


    def pop_back(self):
        """pop_back(svg_groups_of_polygons self)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_pop_back(self)


    def erase(self, *args):
        """
        erase(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::iterator pos) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator
        erase(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::iterator first, std::vector< std::vector< svgfill::polygon_2 > >::iterator last) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::vector<(svgfill::polygon_2)>)> self) -> svg_groups_of_polygons
        __init__(std::vector<(std::vector<(svgfill::polygon_2)>)> self, svg_groups_of_polygons arg2) -> svg_groups_of_polygons
        __init__(std::vector<(std::vector<(svgfill::polygon_2)>)> self, std::vector< std::vector< svgfill::polygon_2 > >::size_type size) -> svg_groups_of_polygons
        __init__(std::vector<(std::vector<(svgfill::polygon_2)>)> self, std::vector< std::vector< svgfill::polygon_2 > >::size_type size, svg_polygons value) -> svg_groups_of_polygons
        """
        this = _ifcopenshell_wrapper.new_svg_groups_of_polygons(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(svg_groups_of_polygons self, svg_polygons x)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_push_back(self, x)


    def front(self):
        """front(svg_groups_of_polygons self) -> svg_polygons"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_front(self)


    def back(self):
        """back(svg_groups_of_polygons self) -> svg_polygons"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_back(self)


    def assign(self, n, x):
        """assign(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type n, svg_polygons x)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_assign(self, n, x)


    def resize(self, *args):
        """
        resize(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type new_size)
        resize(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type new_size, svg_polygons x)
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons_resize(self, *args)


    def insert(self, *args):
        """
        insert(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::iterator pos, svg_polygons x) -> std::vector< std::vector< svgfill::polygon_2 > >::iterator
        insert(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::iterator pos, std::vector< std::vector< svgfill::polygon_2 > >::size_type n, svg_polygons x)
        """
        return _ifcopenshell_wrapper.svg_groups_of_polygons_insert(self, *args)


    def reserve(self, n):
        """reserve(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type n)"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_reserve(self, n)


    def capacity(self):
        """capacity(svg_groups_of_polygons self) -> std::vector< std::vector< svgfill::polygon_2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_groups_of_polygons_capacity(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_groups_of_polygons
    __del__ = lambda self: None
svg_groups_of_polygons_swigregister = _ifcopenshell_wrapper.svg_groups_of_polygons_swigregister
svg_groups_of_polygons_swigregister(svg_groups_of_polygons)

class svg_loop(_object):
    """Proxy of C++ std::vector<(std::array<(double,2)>)> class."""

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

    def iterator(self):
        """iterator(svg_loop self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_loop_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(svg_loop self) -> bool"""
        return _ifcopenshell_wrapper.svg_loop___nonzero__(self)


    def __bool__(self):
        """__bool__(svg_loop self) -> bool"""
        return _ifcopenshell_wrapper.svg_loop___bool__(self)


    def __len__(self):
        """__len__(svg_loop self) -> std::vector< std::array< double,2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_loop___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, std::vector< std::array< double,2 > >::difference_type j) -> svg_loop"""
        return _ifcopenshell_wrapper.svg_loop___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, std::vector< std::array< double,2 > >::difference_type j)
        __setslice__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, std::vector< std::array< double,2 > >::difference_type j, svg_loop v)
        """
        return _ifcopenshell_wrapper.svg_loop___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, std::vector< std::array< double,2 > >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_loop___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i)
        __delitem__(svg_loop self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_loop___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(svg_loop self, PySliceObject * slice) -> svg_loop
        __getitem__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i) -> svg_point
        """
        return _ifcopenshell_wrapper.svg_loop___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(svg_loop self, PySliceObject * slice, svg_loop v)
        __setitem__(svg_loop self, PySliceObject * slice)
        __setitem__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i, svg_point x)
        """
        return _ifcopenshell_wrapper.svg_loop___setitem__(self, *args)


    def pop(self):
        """pop(svg_loop self) -> svg_point"""
        return _ifcopenshell_wrapper.svg_loop_pop(self)


    def append(self, x):
        """append(svg_loop self, svg_point x)"""
        return _ifcopenshell_wrapper.svg_loop_append(self, x)


    def empty(self):
        """empty(svg_loop self) -> bool"""
        return _ifcopenshell_wrapper.svg_loop_empty(self)


    def size(self):
        """size(svg_loop self) -> std::vector< std::array< double,2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_loop_size(self)


    def swap(self, v):
        """swap(svg_loop self, svg_loop v)"""
        return _ifcopenshell_wrapper.svg_loop_swap(self, v)


    def begin(self):
        """begin(svg_loop self) -> std::vector< std::array< double,2 > >::iterator"""
        return _ifcopenshell_wrapper.svg_loop_begin(self)


    def end(self):
        """end(svg_loop self) -> std::vector< std::array< double,2 > >::iterator"""
        return _ifcopenshell_wrapper.svg_loop_end(self)


    def rbegin(self):
        """rbegin(svg_loop self) -> std::vector< std::array< double,2 > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_loop_rbegin(self)


    def rend(self):
        """rend(svg_loop self) -> std::vector< std::array< double,2 > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_loop_rend(self)


    def clear(self):
        """clear(svg_loop self)"""
        return _ifcopenshell_wrapper.svg_loop_clear(self)


    def get_allocator(self):
        """get_allocator(svg_loop self) -> std::vector< std::array< double,2 > >::allocator_type"""
        return _ifcopenshell_wrapper.svg_loop_get_allocator(self)


    def pop_back(self):
        """pop_back(svg_loop self)"""
        return _ifcopenshell_wrapper.svg_loop_pop_back(self)


    def erase(self, *args):
        """
        erase(svg_loop self, std::vector< std::array< double,2 > >::iterator pos) -> std::vector< std::array< double,2 > >::iterator
        erase(svg_loop self, std::vector< std::array< double,2 > >::iterator first, std::vector< std::array< double,2 > >::iterator last) -> std::vector< std::array< double,2 > >::iterator
        """
        return _ifcopenshell_wrapper.svg_loop_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::array<(double,2)>)> self) -> svg_loop
        __init__(std::vector<(std::array<(double,2)>)> self, svg_loop arg2) -> svg_loop
        __init__(std::vector<(std::array<(double,2)>)> self, std::vector< std::array< double,2 > >::size_type size) -> svg_loop
        __init__(std::vector<(std::array<(double,2)>)> self, std::vector< std::array< double,2 > >::size_type size, svg_point value) -> svg_loop
        """
        this = _ifcopenshell_wrapper.new_svg_loop(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(svg_loop self, svg_point x)"""
        return _ifcopenshell_wrapper.svg_loop_push_back(self, x)


    def front(self):
        """front(svg_loop self) -> svg_point"""
        return _ifcopenshell_wrapper.svg_loop_front(self)


    def back(self):
        """back(svg_loop self) -> svg_point"""
        return _ifcopenshell_wrapper.svg_loop_back(self)


    def assign(self, n, x):
        """assign(svg_loop self, std::vector< std::array< double,2 > >::size_type n, svg_point x)"""
        return _ifcopenshell_wrapper.svg_loop_assign(self, n, x)


    def resize(self, *args):
        """
        resize(svg_loop self, std::vector< std::array< double,2 > >::size_type new_size)
        resize(svg_loop self, std::vector< std::array< double,2 > >::size_type new_size, svg_point x)
        """
        return _ifcopenshell_wrapper.svg_loop_resize(self, *args)


    def insert(self, *args):
        """
        insert(svg_loop self, std::vector< std::array< double,2 > >::iterator pos, svg_point x) -> std::vector< std::array< double,2 > >::iterator
        insert(svg_loop self, std::vector< std::array< double,2 > >::iterator pos, std::vector< std::array< double,2 > >::size_type n, svg_point x)
        """
        return _ifcopenshell_wrapper.svg_loop_insert(self, *args)


    def reserve(self, n):
        """reserve(svg_loop self, std::vector< std::array< double,2 > >::size_type n)"""
        return _ifcopenshell_wrapper.svg_loop_reserve(self, n)


    def capacity(self):
        """capacity(svg_loop self) -> std::vector< std::array< double,2 > >::size_type"""
        return _ifcopenshell_wrapper.svg_loop_capacity(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_loop
    __del__ = lambda self: None
svg_loop_swigregister = _ifcopenshell_wrapper.svg_loop_swigregister
svg_loop_swigregister(svg_loop)

class svg_loops(_object):
    """Proxy of C++ std::vector<(std::vector<(std::array<(double,2)>)>)> class."""

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

    def iterator(self):
        """iterator(svg_loops self) -> SwigPyIterator"""
        return _ifcopenshell_wrapper.svg_loops_iterator(self)

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

    def __nonzero__(self):
        """__nonzero__(svg_loops self) -> bool"""
        return _ifcopenshell_wrapper.svg_loops___nonzero__(self)


    def __bool__(self):
        """__bool__(svg_loops self) -> bool"""
        return _ifcopenshell_wrapper.svg_loops___bool__(self)


    def __len__(self):
        """__len__(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::size_type"""
        return _ifcopenshell_wrapper.svg_loops___len__(self)


    def __getslice__(self, i, j):
        """__getslice__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, std::vector< std::vector< std::array< double,2 > > >::difference_type j) -> svg_loops"""
        return _ifcopenshell_wrapper.svg_loops___getslice__(self, i, j)


    def __setslice__(self, *args):
        """
        __setslice__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, std::vector< std::vector< std::array< double,2 > > >::difference_type j)
        __setslice__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, std::vector< std::vector< std::array< double,2 > > >::difference_type j, svg_loops v)
        """
        return _ifcopenshell_wrapper.svg_loops___setslice__(self, *args)


    def __delslice__(self, i, j):
        """__delslice__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, std::vector< std::vector< std::array< double,2 > > >::difference_type j)"""
        return _ifcopenshell_wrapper.svg_loops___delslice__(self, i, j)


    def __delitem__(self, *args):
        """
        __delitem__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i)
        __delitem__(svg_loops self, PySliceObject * slice)
        """
        return _ifcopenshell_wrapper.svg_loops___delitem__(self, *args)


    def __getitem__(self, *args):
        """
        __getitem__(svg_loops self, PySliceObject * slice) -> svg_loops
        __getitem__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i) -> svg_loop
        """
        return _ifcopenshell_wrapper.svg_loops___getitem__(self, *args)


    def __setitem__(self, *args):
        """
        __setitem__(svg_loops self, PySliceObject * slice, svg_loops v)
        __setitem__(svg_loops self, PySliceObject * slice)
        __setitem__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i, svg_loop x)
        """
        return _ifcopenshell_wrapper.svg_loops___setitem__(self, *args)


    def pop(self):
        """pop(svg_loops self) -> svg_loop"""
        return _ifcopenshell_wrapper.svg_loops_pop(self)


    def append(self, x):
        """append(svg_loops self, svg_loop x)"""
        return _ifcopenshell_wrapper.svg_loops_append(self, x)


    def empty(self):
        """empty(svg_loops self) -> bool"""
        return _ifcopenshell_wrapper.svg_loops_empty(self)


    def size(self):
        """size(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::size_type"""
        return _ifcopenshell_wrapper.svg_loops_size(self)


    def swap(self, v):
        """swap(svg_loops self, svg_loops v)"""
        return _ifcopenshell_wrapper.svg_loops_swap(self, v)


    def begin(self):
        """begin(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::iterator"""
        return _ifcopenshell_wrapper.svg_loops_begin(self)


    def end(self):
        """end(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::iterator"""
        return _ifcopenshell_wrapper.svg_loops_end(self)


    def rbegin(self):
        """rbegin(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_loops_rbegin(self)


    def rend(self):
        """rend(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::reverse_iterator"""
        return _ifcopenshell_wrapper.svg_loops_rend(self)


    def clear(self):
        """clear(svg_loops self)"""
        return _ifcopenshell_wrapper.svg_loops_clear(self)


    def get_allocator(self):
        """get_allocator(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::allocator_type"""
        return _ifcopenshell_wrapper.svg_loops_get_allocator(self)


    def pop_back(self):
        """pop_back(svg_loops self)"""
        return _ifcopenshell_wrapper.svg_loops_pop_back(self)


    def erase(self, *args):
        """
        erase(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::iterator pos) -> std::vector< std::vector< std::array< double,2 > > >::iterator
        erase(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::iterator first, std::vector< std::vector< std::array< double,2 > > >::iterator last) -> std::vector< std::vector< std::array< double,2 > > >::iterator
        """
        return _ifcopenshell_wrapper.svg_loops_erase(self, *args)


    def __init__(self, *args):
        """
        __init__(std::vector<(std::vector<(std::array<(double,2)>)>)> self) -> svg_loops
        __init__(std::vector<(std::vector<(std::array<(double,2)>)>)> self, svg_loops arg2) -> svg_loops
        __init__(std::vector<(std::vector<(std::array<(double,2)>)>)> self, std::vector< std::vector< std::array< double,2 > > >::size_type size) -> svg_loops
        __init__(std::vector<(std::vector<(std::array<(double,2)>)>)> self, std::vector< std::vector< std::array< double,2 > > >::size_type size, svg_loop value) -> svg_loops
        """
        this = _ifcopenshell_wrapper.new_svg_loops(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def push_back(self, x):
        """push_back(svg_loops self, svg_loop x)"""
        return _ifcopenshell_wrapper.svg_loops_push_back(self, x)


    def front(self):
        """front(svg_loops self) -> svg_loop"""
        return _ifcopenshell_wrapper.svg_loops_front(self)


    def back(self):
        """back(svg_loops self) -> svg_loop"""
        return _ifcopenshell_wrapper.svg_loops_back(self)


    def assign(self, n, x):
        """assign(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type n, svg_loop x)"""
        return _ifcopenshell_wrapper.svg_loops_assign(self, n, x)


    def resize(self, *args):
        """
        resize(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type new_size)
        resize(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type new_size, svg_loop x)
        """
        return _ifcopenshell_wrapper.svg_loops_resize(self, *args)


    def insert(self, *args):
        """
        insert(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::iterator pos, svg_loop x) -> std::vector< std::vector< std::array< double,2 > > >::iterator
        insert(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::iterator pos, std::vector< std::vector< std::array< double,2 > > >::size_type n, svg_loop x)
        """
        return _ifcopenshell_wrapper.svg_loops_insert(self, *args)


    def reserve(self, n):
        """reserve(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type n)"""
        return _ifcopenshell_wrapper.svg_loops_reserve(self, n)


    def capacity(self):
        """capacity(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::size_type"""
        return _ifcopenshell_wrapper.svg_loops_capacity(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_svg_loops
    __del__ = lambda self: None
svg_loops_swigregister = _ifcopenshell_wrapper.svg_loops_swigregister
svg_loops_swigregister(svg_loops)

class OpaqueCoordinate_3(_object):
    """Proxy of C++ IfcGeom::OpaqueCoordinate<(3)> class."""

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

    def __init__(self, *args):
        """
        __init__(IfcGeom::OpaqueCoordinate<(3)> self) -> OpaqueCoordinate_3
        __init__(IfcGeom::OpaqueCoordinate<(3)> self, OpaqueCoordinate_3 other) -> OpaqueCoordinate_3
        """
        this = _ifcopenshell_wrapper.new_OpaqueCoordinate_3(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_OpaqueCoordinate_3
    __del__ = lambda self: None

    def get(self, i):
        """get(OpaqueCoordinate_3 self, size_t i) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueCoordinate_3_get(self, i)


    def set(self, i, n):
        """set(OpaqueCoordinate_3 self, size_t i, OpaqueNumber n)"""
        return _ifcopenshell_wrapper.OpaqueCoordinate_3_set(self, i, n)

OpaqueCoordinate_3_swigregister = _ifcopenshell_wrapper.OpaqueCoordinate_3_swigregister
OpaqueCoordinate_3_swigregister(OpaqueCoordinate_3)

class OpaqueCoordinate_4(_object):
    """Proxy of C++ IfcGeom::OpaqueCoordinate<(4)> class."""

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

    def __init__(self, *args):
        """
        __init__(IfcGeom::OpaqueCoordinate<(4)> self) -> OpaqueCoordinate_4
        __init__(IfcGeom::OpaqueCoordinate<(4)> self, OpaqueCoordinate_4 other) -> OpaqueCoordinate_4
        """
        this = _ifcopenshell_wrapper.new_OpaqueCoordinate_4(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_OpaqueCoordinate_4
    __del__ = lambda self: None

    def get(self, i):
        """get(OpaqueCoordinate_4 self, size_t i) -> OpaqueNumber"""
        return _ifcopenshell_wrapper.OpaqueCoordinate_4_get(self, i)


    def set(self, i, n):
        """set(OpaqueCoordinate_4 self, size_t i, OpaqueNumber n)"""
        return _ifcopenshell_wrapper.OpaqueCoordinate_4_set(self, i, n)

OpaqueCoordinate_4_swigregister = _ifcopenshell_wrapper.OpaqueCoordinate_4_swigregister
OpaqueCoordinate_4_swigregister(OpaqueCoordinate_4)


def create_epeck(*args):
    """
    create_epeck(int i) -> OpaqueNumber
    create_epeck(double d) -> OpaqueNumber
    create_epeck(std::string const & s) -> OpaqueNumber
    """
    return _ifcopenshell_wrapper.create_epeck(*args)

def nary_union(sequence):
    """nary_union(PyObject * sequence) -> ConversionResultShape"""
    return _ifcopenshell_wrapper.nary_union(sequence)
class polygon_2(_object):
    """Proxy of C++ svgfill::polygon_2 class."""

    __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
    __swig_setmethods__["boundary"] = _ifcopenshell_wrapper.polygon_2_boundary_set
    __swig_getmethods__["boundary"] = _ifcopenshell_wrapper.polygon_2_boundary_get
    if _newclass:
        boundary = _swig_property(_ifcopenshell_wrapper.polygon_2_boundary_get, _ifcopenshell_wrapper.polygon_2_boundary_set)
    __swig_setmethods__["inner_boundaries"] = _ifcopenshell_wrapper.polygon_2_inner_boundaries_set
    __swig_getmethods__["inner_boundaries"] = _ifcopenshell_wrapper.polygon_2_inner_boundaries_get
    if _newclass:
        inner_boundaries = _swig_property(_ifcopenshell_wrapper.polygon_2_inner_boundaries_get, _ifcopenshell_wrapper.polygon_2_inner_boundaries_set)
    __swig_setmethods__["point_inside"] = _ifcopenshell_wrapper.polygon_2_point_inside_set
    __swig_getmethods__["point_inside"] = _ifcopenshell_wrapper.polygon_2_point_inside_get
    if _newclass:
        point_inside = _swig_property(_ifcopenshell_wrapper.polygon_2_point_inside_get, _ifcopenshell_wrapper.polygon_2_point_inside_set)

    def __init__(self):
        """__init__(svgfill::polygon_2 self) -> polygon_2"""
        this = _ifcopenshell_wrapper.new_polygon_2()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_polygon_2
    __del__ = lambda self: None
polygon_2_swigregister = _ifcopenshell_wrapper.polygon_2_swigregister
polygon_2_swigregister(polygon_2)

CARTESIAN_DOUBLE = _ifcopenshell_wrapper.CARTESIAN_DOUBLE
CARTESIAN_QUOTIENT = _ifcopenshell_wrapper.CARTESIAN_QUOTIENT
FILTERED_CARTESIAN_QUOTIENT = _ifcopenshell_wrapper.FILTERED_CARTESIAN_QUOTIENT
EXACT_PREDICATES = _ifcopenshell_wrapper.EXACT_PREDICATES
EXACT_CONSTRUCTIONS = _ifcopenshell_wrapper.EXACT_CONSTRUCTIONS
class abstract_arrangement(_object):
    """Proxy of C++ svgfill::abstract_arrangement class."""

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

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

    def __call__(self, eps, segments, progress):
        """__call__(abstract_arrangement self, double eps, svg_line_segments segments, std::function< void (float) > & progress) -> bool"""
        return _ifcopenshell_wrapper.abstract_arrangement___call__(self, eps, segments, progress)


    def write(self, polygons, progress):
        """write(abstract_arrangement self, svg_polygons polygons, std::function< void (float) > & progress) -> bool"""
        return _ifcopenshell_wrapper.abstract_arrangement_write(self, polygons, progress)


    def merge(self, edge_indices):
        """merge(abstract_arrangement self, std::vector< int,std::allocator< int > > const & edge_indices)"""
        return _ifcopenshell_wrapper.abstract_arrangement_merge(self, edge_indices)


    def get_face_pairs(self):
        """get_face_pairs(abstract_arrangement self) -> std::vector< int,std::allocator< int > >"""
        return _ifcopenshell_wrapper.abstract_arrangement_get_face_pairs(self)


    def num_edges(self):
        """num_edges(abstract_arrangement self) -> size_t"""
        return _ifcopenshell_wrapper.abstract_arrangement_num_edges(self)


    def num_faces(self):
        """num_faces(abstract_arrangement self) -> size_t"""
        return _ifcopenshell_wrapper.abstract_arrangement_num_faces(self)

abstract_arrangement_swigregister = _ifcopenshell_wrapper.abstract_arrangement_swigregister
abstract_arrangement_swigregister(abstract_arrangement)

class context(_object):
    """Proxy of C++ svgfill::context class."""

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

    def __init__(self, *args):
        """
        __init__(svgfill::context self, svgfill::solver s, double eps) -> context
        __init__(svgfill::context self, svgfill::solver s, double eps, std::function< void (float) > & progress) -> context
        """
        this = _ifcopenshell_wrapper.new_context(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def add(self, segments):
        """add(context self, svg_line_segments segments)"""
        return _ifcopenshell_wrapper.context_add(self, segments)


    def build(self):
        """build(context self) -> bool"""
        return _ifcopenshell_wrapper.context_build(self)


    def get_face_pairs(self):
        """get_face_pairs(context self) -> std::vector< int,std::allocator< int > >"""
        return _ifcopenshell_wrapper.context_get_face_pairs(self)


    def merge(self, edge_indices):
        """merge(context self, std::vector< int,std::allocator< int > > const & edge_indices)"""
        return _ifcopenshell_wrapper.context_merge(self, edge_indices)


    def write(self, arg2):
        """write(context self, svg_groups_of_polygons arg2)"""
        return _ifcopenshell_wrapper.context_write(self, arg2)


    def num_edges(self):
        """num_edges(context self) -> size_t"""
        return _ifcopenshell_wrapper.context_num_edges(self)


    def num_faces(self):
        """num_faces(context self) -> size_t"""
        return _ifcopenshell_wrapper.context_num_faces(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_context
    __del__ = lambda self: None
context_swigregister = _ifcopenshell_wrapper.context_swigregister
context_swigregister(context)


def polygons_to_svg(*args):
    """
    polygons_to_svg(svg_groups_of_polygons polygons, bool random_color=False) -> std::string
    polygons_to_svg(svg_groups_of_polygons polygons) -> std::string
    polygons_to_svg(svg_polygons polygons, bool random_color=False) -> std::string
    polygons_to_svg(svg_polygons polygons) -> std::string
    """
    return _ifcopenshell_wrapper.polygons_to_svg(*args)

def svg_to_line_segments(data, class_name):
    """svg_to_line_segments(std::string const & data, boost::optional< std::string > const & class_name) -> svg_groups_of_line_segments"""
    return _ifcopenshell_wrapper.svg_to_line_segments(data, class_name)

def line_segments_to_polygons(s, eps, segments):
    """line_segments_to_polygons(svgfill::solver s, double eps, svg_groups_of_line_segments segments) -> svg_groups_of_polygons"""
    return _ifcopenshell_wrapper.line_segments_to_polygons(s, eps, segments)

def svg_to_polygons(data, class_name):
    """svg_to_polygons(std::string const & data, boost::optional< std::string > const & class_name) -> svg_polygons"""
    return _ifcopenshell_wrapper.svg_to_polygons(data, class_name)

def arrange_polygons(polygons):
    """arrange_polygons(svg_polygons polygons) -> svg_polygons"""
    return _ifcopenshell_wrapper.arrange_polygons(polygons)
class IfcEntityInstanceData(_object):
    """Proxy of C++ IfcEntityInstanceData class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcEntityInstanceData
    __del__ = lambda self: None
IfcEntityInstanceData_swigregister = _ifcopenshell_wrapper.IfcEntityInstanceData_swigregister
IfcEntityInstanceData_swigregister(IfcEntityInstanceData)

class attribute_value_derived(_object):
    """Proxy of C++ attribute_value_derived class."""

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

    def __bool__(self): return False
    def __repr__(self): return '*'


    def __init__(self):
        """__init__(attribute_value_derived self) -> attribute_value_derived"""
        this = _ifcopenshell_wrapper.new_attribute_value_derived()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_attribute_value_derived
    __del__ = lambda self: None
attribute_value_derived_swigregister = _ifcopenshell_wrapper.attribute_value_derived_swigregister
attribute_value_derived_swigregister(attribute_value_derived)


def set_feature(x, v):
    """set_feature(std::string const & x, PyObject * v)"""
    return _ifcopenshell_wrapper.set_feature(x, v)

def get_feature(x):
    """get_feature(std::string const & x) -> PyObject *"""
    return _ifcopenshell_wrapper.get_feature(x)
class RocksDBPrefixIterator(_object):
    """Proxy of C++ RocksDBPrefixIterator class."""

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

    def __init__(self, storage, prefix):
        """__init__(RocksDBPrefixIterator self, IfcParse::impl::rocks_db_file_storage const * storage, std::string const & prefix) -> RocksDBPrefixIterator"""
        this = _ifcopenshell_wrapper.new_RocksDBPrefixIterator(storage, prefix)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def valid(self):
        """valid(RocksDBPrefixIterator self) -> bool"""
        return _ifcopenshell_wrapper.RocksDBPrefixIterator_valid(self)


    def next(self):
        """next(RocksDBPrefixIterator self)"""
        return _ifcopenshell_wrapper.RocksDBPrefixIterator_next(self)


    def key(self):
        """key(RocksDBPrefixIterator self) -> PyObject *"""
        return _ifcopenshell_wrapper.RocksDBPrefixIterator_key(self)


    def value(self):
        """value(RocksDBPrefixIterator self) -> PyObject *"""
        return _ifcopenshell_wrapper.RocksDBPrefixIterator_value(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_RocksDBPrefixIterator
    __del__ = lambda self: None
RocksDBPrefixIterator_swigregister = _ifcopenshell_wrapper.RocksDBPrefixIterator_swigregister
RocksDBPrefixIterator_swigregister(RocksDBPrefixIterator)
cvar = _ifcopenshell_wrapper.cvar

class IfcSpfHeader(_object):
    """Proxy of C++ IfcParse::IfcSpfHeader class."""

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

    def __init__(self, *args):
        """
        __init__(IfcParse::IfcSpfHeader self, file file=None) -> IfcSpfHeader
        __init__(IfcParse::IfcSpfHeader self) -> IfcSpfHeader
        __init__(IfcParse::IfcSpfHeader self, IfcParse::IfcSpfLexer * lexer) -> IfcSpfHeader
        """
        this = _ifcopenshell_wrapper.new_IfcSpfHeader(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcSpfHeader
    __del__ = lambda self: None

    def file(self, *args):
        """
        file(IfcSpfHeader self) -> file
        file(IfcSpfHeader self, file file)
        """
        return _ifcopenshell_wrapper.IfcSpfHeader_file(self, *args)


    def read(self):
        """read(IfcSpfHeader self)"""
        return _ifcopenshell_wrapper.IfcSpfHeader_read(self)


    def tryRead(self):
        """tryRead(IfcSpfHeader self) -> bool"""
        return _ifcopenshell_wrapper.IfcSpfHeader_tryRead(self)


    def write(self, out):
        """write(IfcSpfHeader self, std::ostream & out)"""
        return _ifcopenshell_wrapper.IfcSpfHeader_write(self, out)


    def file_description_py(self):
        """file_description_py(IfcSpfHeader self) -> entity_instance"""
        return _ifcopenshell_wrapper.IfcSpfHeader_file_description_py(self)


    def file_name_py(self):
        """file_name_py(IfcSpfHeader self) -> entity_instance"""
        return _ifcopenshell_wrapper.IfcSpfHeader_file_name_py(self)


    def file_schema_py(self):
        """file_schema_py(IfcSpfHeader self) -> entity_instance"""
        return _ifcopenshell_wrapper.IfcSpfHeader_file_schema_py(self)


            # Hide the getters with read-only property implementations
    		# self.file_ref is set in ifcopenshell.file.header()
    file_description = property(lambda self: self.file_ref(self.file_description_py()))
    file_name = property(lambda self: self.file_ref(self.file_name_py()))
    file_schema = property(lambda self: self.file_ref(self.file_schema_py()))

IfcSpfHeader_swigregister = _ifcopenshell_wrapper.IfcSpfHeader_swigregister
IfcSpfHeader_swigregister(IfcSpfHeader)

FT_IFCSPF = _ifcopenshell_wrapper.FT_IFCSPF
FT_IFCXML = _ifcopenshell_wrapper.FT_IFCXML
FT_IFCZIP = _ifcopenshell_wrapper.FT_IFCZIP
FT_ROCKSDB = _ifcopenshell_wrapper.FT_ROCKSDB
FT_UNKNOWN = _ifcopenshell_wrapper.FT_UNKNOWN
FT_AUTODETECT = _ifcopenshell_wrapper.FT_AUTODETECT

def guess_file_type(fn):
    """guess_file_type(std::string const & fn) -> IfcParse::filetype"""
    return _ifcopenshell_wrapper.guess_file_type(fn)
class InstanceStreamer(_object):
    """Proxy of C++ IfcParse::InstanceStreamer class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, InstanceStreamer, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, InstanceStreamer, name)
    __repr__ = _swig_repr
    __swig_setmethods__["coerce_attribute_count"] = _ifcopenshell_wrapper.InstanceStreamer_coerce_attribute_count_set
    __swig_getmethods__["coerce_attribute_count"] = _ifcopenshell_wrapper.InstanceStreamer_coerce_attribute_count_get
    if _newclass:
        coerce_attribute_count = _swig_property(_ifcopenshell_wrapper.InstanceStreamer_coerce_attribute_count_get, _ifcopenshell_wrapper.InstanceStreamer_coerce_attribute_count_set)

    def __nonzero__(self):
        return _ifcopenshell_wrapper.InstanceStreamer___nonzero__(self)
    __bool__ = __nonzero__



    def status(self):
        """status(InstanceStreamer self) -> file_open_status"""
        return _ifcopenshell_wrapper.InstanceStreamer_status(self)


    def references(self, *args):
        """
        references(InstanceStreamer self) -> IfcParse::unresolved_references const
        references(InstanceStreamer self) -> IfcParse::unresolved_references &
        """
        return _ifcopenshell_wrapper.InstanceStreamer_references(self, *args)


    def inverses(self, *args):
        """
        inverses(InstanceStreamer self) -> IfcParse::impl::in_memory_file_storage::entities_by_ref_t const
        inverses(InstanceStreamer self) -> IfcParse::impl::in_memory_file_storage::entities_by_ref_t &
        """
        return _ifcopenshell_wrapper.InstanceStreamer_inverses(self, *args)


    def __init__(self, *args):
        """
        __init__(IfcParse::InstanceStreamer self, std::string const & fn) -> InstanceStreamer
        __init__(IfcParse::InstanceStreamer self, void * data, int length) -> InstanceStreamer
        """
        this = _ifcopenshell_wrapper.new_InstanceStreamer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_InstanceStreamer
    __del__ = lambda self: None

    def read_instance_py(self):
        """read_instance_py(InstanceStreamer self) -> PyObject *"""
        return _ifcopenshell_wrapper.InstanceStreamer_read_instance_py(self)

InstanceStreamer_swigregister = _ifcopenshell_wrapper.InstanceStreamer_swigregister
InstanceStreamer_swigregister(InstanceStreamer)

class file(_object):
    """Proxy of C++ IfcParse::IfcFile class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, file, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, file, name)
    __repr__ = _swig_repr
    __swig_setmethods__["byguid_"] = _ifcopenshell_wrapper.file_byguid__set
    __swig_getmethods__["byguid_"] = _ifcopenshell_wrapper.file_byguid__get
    if _newclass:
        byguid_ = _swig_property(_ifcopenshell_wrapper.file_byguid__get, _ifcopenshell_wrapper.file_byguid__set)
    __swig_setmethods__["byid_"] = _ifcopenshell_wrapper.file_byid__set
    __swig_getmethods__["byid_"] = _ifcopenshell_wrapper.file_byid__get
    if _newclass:
        byid_ = _swig_property(_ifcopenshell_wrapper.file_byid__get, _ifcopenshell_wrapper.file_byid__set)
    __swig_setmethods__["byref_excl_"] = _ifcopenshell_wrapper.file_byref_excl__set
    __swig_getmethods__["byref_excl_"] = _ifcopenshell_wrapper.file_byref_excl__get
    if _newclass:
        byref_excl_ = _swig_property(_ifcopenshell_wrapper.file_byref_excl__get, _ifcopenshell_wrapper.file_byref_excl__set)
    __swig_setmethods__["check_existance_before_adding"] = _ifcopenshell_wrapper.file_check_existance_before_adding_set
    __swig_getmethods__["check_existance_before_adding"] = _ifcopenshell_wrapper.file_check_existance_before_adding_get
    if _newclass:
        check_existance_before_adding = _swig_property(_ifcopenshell_wrapper.file_check_existance_before_adding_get, _ifcopenshell_wrapper.file_check_existance_before_adding_set)
    __swig_setmethods__["calculate_unit_factors"] = _ifcopenshell_wrapper.file_calculate_unit_factors_set
    __swig_getmethods__["calculate_unit_factors"] = _ifcopenshell_wrapper.file_calculate_unit_factors_get
    if _newclass:
        calculate_unit_factors = _swig_property(_ifcopenshell_wrapper.file_calculate_unit_factors_get, _ifcopenshell_wrapper.file_calculate_unit_factors_set)
    __swig_setmethods__["instantiate_typed_instances"] = _ifcopenshell_wrapper.file_instantiate_typed_instances_set
    __swig_getmethods__["instantiate_typed_instances"] = _ifcopenshell_wrapper.file_instantiate_typed_instances_get
    if _newclass:
        instantiate_typed_instances = _swig_property(_ifcopenshell_wrapper.file_instantiate_typed_instances_get, _ifcopenshell_wrapper.file_instantiate_typed_instances_set)

    def __init__(self, *args):
        """
        __init__(IfcParse::IfcFile self, std::string const & path, IfcParse::filetype ty, bool readonly=False) -> file
        __init__(IfcParse::IfcFile self, std::string const & path, IfcParse::filetype ty) -> file
        __init__(IfcParse::IfcFile self, std::string const & path) -> file
        __init__(IfcParse::IfcFile self, std::istream & stream, int length) -> file
        __init__(IfcParse::IfcFile self, void * data, int length) -> file
        __init__(IfcParse::IfcFile self, IfcParse::IfcSpfStream * stream) -> file
        __init__(IfcParse::IfcFile self, schema_definition schema, IfcParse::filetype ty, std::string const & path) -> file
        __init__(IfcParse::IfcFile self, schema_definition schema, IfcParse::filetype ty) -> file
        __init__(IfcParse::IfcFile self, schema_definition schema) -> file
        __init__(IfcParse::IfcFile self) -> file
        """
        this = _ifcopenshell_wrapper.new_file(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_file
    __del__ = lambda self: None

    def good(self):
        """good(file self) -> file_open_status"""
        return _ifcopenshell_wrapper.file_good(self)


    def by_type(self, *args):
        """
        by_type(file self, declaration arg2) -> aggregate_of_instance::ptr
        by_type(file self, std::string const & type) -> aggregate_of_instance::ptr
        """
        return _ifcopenshell_wrapper.file_by_type(self, *args)


    def by_type_excl_subtypes(self, *args):
        """
        by_type_excl_subtypes(file self, declaration arg2) -> aggregate_of_instance::ptr
        by_type_excl_subtypes(file self, std::string const & type) -> aggregate_of_instance::ptr
        """
        return _ifcopenshell_wrapper.file_by_type_excl_subtypes(self, *args)


    def by_id(self, id):
        """by_id(file self, int id) -> entity_instance"""
        return _ifcopenshell_wrapper.file_by_id(self, id)


    def by_guid(self, guid):
        """by_guid(file self, std::string const & guid) -> entity_instance"""
        return _ifcopenshell_wrapper.file_by_guid(self, guid)


    def traverse(instance, max_level=-1):
        """
        traverse(entity_instance instance, int max_level=-1) -> aggregate_of_instance::ptr
        traverse(entity_instance instance) -> aggregate_of_instance::ptr
        """
        return _ifcopenshell_wrapper.file_traverse(instance, max_level)

    traverse = staticmethod(traverse)

    def traverse_breadth_first(instance, max_level=-1):
        """
        traverse_breadth_first(entity_instance instance, int max_level=-1) -> aggregate_of_instance::ptr
        traverse_breadth_first(entity_instance instance) -> aggregate_of_instance::ptr
        """
        return _ifcopenshell_wrapper.file_traverse_breadth_first(instance, max_level)

    traverse_breadth_first = staticmethod(traverse_breadth_first)

    def get_inverses_by_declaration(self, instance_id, type, attribute_index):
        """get_inverses_by_declaration(file self, int instance_id, declaration type, int attribute_index) -> aggregate_of_instance::ptr"""
        return _ifcopenshell_wrapper.file_get_inverses_by_declaration(self, instance_id, type, attribute_index)


    def get_total_inverses_by_id(self, instance_id):
        """get_total_inverses_by_id(file self, int instance_id) -> size_t"""
        return _ifcopenshell_wrapper.file_get_total_inverses_by_id(self, instance_id)


    def FreshId(self):
        """FreshId(file self) -> unsigned int"""
        return _ifcopenshell_wrapper.file_FreshId(self)


    def getMaxId(self):
        """getMaxId(file self) -> unsigned int"""
        return _ifcopenshell_wrapper.file_getMaxId(self)


    def ifcroot_type(self):
        """ifcroot_type(file self) -> declaration"""
        return _ifcopenshell_wrapper.file_ifcroot_type(self)


    def recalculate_id_counter(self):
        """recalculate_id_counter(file self)"""
        return _ifcopenshell_wrapper.file_recalculate_id_counter(self)


    def add(self, entity, id=-1):
        """
        add(file self, entity_instance entity, int id=-1) -> entity_instance
        add(file self, entity_instance entity) -> entity_instance
        """
        return _ifcopenshell_wrapper.file_add(self, entity, id)


    def addEntities(self, entities):
        """addEntities(file self, aggregate_of_instance::ptr entities)"""
        return _ifcopenshell_wrapper.file_addEntities(self, entities)


    def remove(self, entity):
        """remove(file self, entity_instance entity)"""
        return _ifcopenshell_wrapper.file_remove(self, entity)


    def header(self, *args):
        """
        header(file self) -> IfcSpfHeader
        header(file self) -> IfcSpfHeader
        """
        return _ifcopenshell_wrapper.file_header(self, *args)


    def createTimestamp():
        """createTimestamp() -> std::string"""
        return _ifcopenshell_wrapper.file_createTimestamp()

    createTimestamp = staticmethod(createTimestamp)

    def getUnit(self, unit_type):
        """getUnit(file self, std::string const & unit_type) -> std::pair< IfcUtil::IfcBaseClass *,double >"""
        return _ifcopenshell_wrapper.file_getUnit(self, unit_type)


    def build_inverses(self):
        """build_inverses(file self)"""
        return _ifcopenshell_wrapper.file_build_inverses(self)


    def add_type_ref(self, new_entity):
        """add_type_ref(file self, entity_instance new_entity)"""
        return _ifcopenshell_wrapper.file_add_type_ref(self, new_entity)


    def remove_type_ref(self, new_entity):
        """remove_type_ref(file self, entity_instance new_entity)"""
        return _ifcopenshell_wrapper.file_remove_type_ref(self, new_entity)


    def process_deletion_inverse(self, inst):
        """process_deletion_inverse(file self, entity_instance inst)"""
        return _ifcopenshell_wrapper.file_process_deletion_inverse(self, inst)


    def build_inverses_(self, arg2):
        """build_inverses_(file self, entity_instance arg2)"""
        return _ifcopenshell_wrapper.file_build_inverses_(self, arg2)


    def create(self, decl):
        """create(file self, declaration decl) -> entity_instance"""
        return _ifcopenshell_wrapper.file_create(self, decl)


    def batch(self):
        """batch(file self)"""
        return _ifcopenshell_wrapper.file_batch(self)


    def unbatch(self):
        """unbatch(file self)"""
        return _ifcopenshell_wrapper.file_unbatch(self)


    def reset_identity_cache(self):
        """reset_identity_cache(file self)"""
        return _ifcopenshell_wrapper.file_reset_identity_cache(self)


    def file_pointer(self):
        """file_pointer(file self) -> size_t"""
        return _ifcopenshell_wrapper.file_file_pointer(self)


    def get_inverse(self, e):
        """get_inverse(file self, entity_instance e) -> aggregate_of_instance::ptr"""
        return _ifcopenshell_wrapper.file_get_inverse(self, e)


    def get_inverse_indices(self, *args):
        """
        get_inverse_indices(file self, int instance_id) -> std::vector< int,std::allocator< int > >
        get_inverse_indices(file self, entity_instance e) -> std::vector< int,std::allocator< int > >
        """
        return _ifcopenshell_wrapper.file_get_inverse_indices(self, *args)


    def get_total_inverses(self, e):
        """get_total_inverses(file self, entity_instance e) -> int"""
        return _ifcopenshell_wrapper.file_get_total_inverses(self, e)


    def write(self, fn):
        """write(file self, std::string const & fn)"""
        return _ifcopenshell_wrapper.file_write(self, fn)


    def to_string(self):
        """to_string(file self) -> std::string"""
        return _ifcopenshell_wrapper.file_to_string(self)


    def entity_names(self):
        """entity_names(file self) -> std::vector< unsigned int,std::allocator< unsigned int > >"""
        return _ifcopenshell_wrapper.file_entity_names(self)


    def types(self):
        """types(file self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.file_types(self)


    def schema_name(self):
        """schema_name(file self) -> std::string"""
        return _ifcopenshell_wrapper.file_schema_name(self)


    def storage_mode(self):
        """storage_mode(file self) -> int"""
        return _ifcopenshell_wrapper.file_storage_mode(self)


    def key_value_store_iter(self, prefix):
        """key_value_store_iter(file self, std::string const & prefix) -> RocksDBPrefixIterator"""
        return _ifcopenshell_wrapper.file_key_value_store_iter(self, prefix)


    def key_value_store_query(self, key):
        """key_value_store_query(file self, std::string const & key) -> PyObject *"""
        return _ifcopenshell_wrapper.file_key_value_store_query(self, key)


    schema = property(schema_name)

file_swigregister = _ifcopenshell_wrapper.file_swigregister
file_swigregister(file)

def file_traverse(instance, max_level=-1):
    """
    traverse(entity_instance instance, int max_level=-1) -> aggregate_of_instance::ptr
    file_traverse(entity_instance instance) -> aggregate_of_instance::ptr
    """
    return _ifcopenshell_wrapper.file_traverse(instance, max_level)

def file_traverse_breadth_first(instance, max_level=-1):
    """
    traverse_breadth_first(entity_instance instance, int max_level=-1) -> aggregate_of_instance::ptr
    file_traverse_breadth_first(entity_instance instance) -> aggregate_of_instance::ptr
    """
    return _ifcopenshell_wrapper.file_traverse_breadth_first(instance, max_level)

def file_createTimestamp():
    """file_createTimestamp() -> std::string"""
    return _ifcopenshell_wrapper.file_createTimestamp()


def parse_ifcxml(filename):
    """parse_ifcxml(std::string const & filename) -> file"""
    return _ifcopenshell_wrapper.parse_ifcxml(filename)
class file_open_status(_object):
    """Proxy of C++ IfcParse::file_open_status class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, file_open_status, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, file_open_status, name)
    __repr__ = _swig_repr
    SUCCESS = _ifcopenshell_wrapper.file_open_status_SUCCESS
    READ_ERROR = _ifcopenshell_wrapper.file_open_status_READ_ERROR
    NO_HEADER = _ifcopenshell_wrapper.file_open_status_NO_HEADER
    UNSUPPORTED_SCHEMA = _ifcopenshell_wrapper.file_open_status_UNSUPPORTED_SCHEMA
    INVALID_SYNTAX = _ifcopenshell_wrapper.file_open_status_INVALID_SYNTAX
    UNKNOWN = _ifcopenshell_wrapper.file_open_status_UNKNOWN

    def __init__(self, *args):
        """
        __init__(IfcParse::file_open_status self, IfcParse::file_open_status::file_open_enum error) -> file_open_status
        __init__(IfcParse::file_open_status self) -> file_open_status
        """
        this = _ifcopenshell_wrapper.new_file_open_status(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def value(self):
        """value(file_open_status self) -> IfcParse::file_open_status::file_open_enum"""
        return _ifcopenshell_wrapper.file_open_status_value(self)


    def __nonzero__(self):
        return _ifcopenshell_wrapper.file_open_status___nonzero__(self)
    __bool__ = __nonzero__


    __swig_destroy__ = _ifcopenshell_wrapper.delete_file_open_status
    __del__ = lambda self: None
file_open_status_swigregister = _ifcopenshell_wrapper.file_open_status_swigregister
file_open_status_swigregister(file_open_status)

class entity_instance(_object):
    """Proxy of C++ IfcUtil::IfcBaseClass class."""

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

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __swig_setmethods__["id_"] = _ifcopenshell_wrapper.entity_instance_id__set
    __swig_getmethods__["id_"] = _ifcopenshell_wrapper.entity_instance_id__get
    if _newclass:
        id_ = _swig_property(_ifcopenshell_wrapper.entity_instance_id__get, _ifcopenshell_wrapper.entity_instance_id__set)
    __swig_setmethods__["file_"] = _ifcopenshell_wrapper.entity_instance_file__set
    __swig_getmethods__["file_"] = _ifcopenshell_wrapper.entity_instance_file__get
    if _newclass:
        file_ = _swig_property(_ifcopenshell_wrapper.entity_instance_file__get, _ifcopenshell_wrapper.entity_instance_file__set)

    def data(self, *args):
        """
        data(entity_instance self) -> IfcEntityInstanceData
        data(entity_instance self) -> IfcEntityInstanceData
        """
        return _ifcopenshell_wrapper.entity_instance_data(self, *args)


    def declaration(self):
        """declaration(entity_instance self) -> declaration"""
        return _ifcopenshell_wrapper.entity_instance_declaration(self)


    def set_attribute_value(self, *args):
        """
        set_attribute_value(entity_instance self, size_t i, entity_instance p)
        set_attribute_value(entity_instance self, std::string const & name, entity_instance p)
        """
        return _ifcopenshell_wrapper.entity_instance_set_attribute_value(self, *args)


    def unset_attribute_value(self, i):
        """unset_attribute_value(entity_instance self, size_t i)"""
        return _ifcopenshell_wrapper.entity_instance_unset_attribute_value(self, i)


    def get_attribute_value(self, index):
        """get_attribute_value(entity_instance self, size_t index) -> AttributeValue"""
        return _ifcopenshell_wrapper.entity_instance_get_attribute_value(self, index)


    def identity(self):
        """identity(entity_instance self) -> uint32_t"""
        return _ifcopenshell_wrapper.entity_instance_identity(self)


    def toString(self, arg2, upper=False):
        """
        toString(entity_instance self, std::ostream & arg2, bool upper=False)
        toString(entity_instance self, std::ostream & arg2)
        """
        return _ifcopenshell_wrapper.entity_instance_toString(self, arg2, upper)


    		# Will be assigned when `ifcopenshell.entity_instance` is created.
    file = None


    def get_attribute_category(self, name):
        """get_attribute_category(entity_instance self, std::string const & name) -> int"""
        return _ifcopenshell_wrapper.entity_instance_get_attribute_category(self, name)


    def id(self):
        """id(entity_instance self) -> int"""
        return _ifcopenshell_wrapper.entity_instance_id(self)


    def __len__(self):
        """__len__(entity_instance self) -> int"""
        return _ifcopenshell_wrapper.entity_instance___len__(self)


    def get_attribute_names(self):
        """get_attribute_names(entity_instance self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.entity_instance_get_attribute_names(self)


    def get_inverse_attribute_names(self):
        """get_inverse_attribute_names(entity_instance self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.entity_instance_get_inverse_attribute_names(self)


    def is_a(self, *args):
        """
        is_a(entity_instance self, std::string const & s) -> bool
        is_a(entity_instance self, bool with_schema=False) -> std::string
        is_a(entity_instance self) -> std::string
        """
        return _ifcopenshell_wrapper.entity_instance_is_a(self, *args)


    def get_argument(self, *args):
        """
        get_argument(entity_instance self, unsigned int i) -> AttributeValue
        get_argument(entity_instance self, std::string const & a) -> AttributeValue
        """
        return _ifcopenshell_wrapper.entity_instance_get_argument(self, *args)


    def __eq__(self, other):
        """__eq__(entity_instance self, entity_instance other) -> bool"""
        return _ifcopenshell_wrapper.entity_instance___eq__(self, other)


    def __repr__(self):
        """__repr__(entity_instance self) -> std::string"""
        return _ifcopenshell_wrapper.entity_instance___repr__(self)


    def to_string(self, valid_spf=True):
        """
        to_string(entity_instance self, bool valid_spf=True) -> std::string
        to_string(entity_instance self) -> std::string
        """
        return _ifcopenshell_wrapper.entity_instance_to_string(self, valid_spf)


    def file_pointer(self):
        """file_pointer(entity_instance self) -> size_t"""
        return _ifcopenshell_wrapper.entity_instance_file_pointer(self)


    def get_argument_index(self, a):
        """get_argument_index(entity_instance self, std::string const & a) -> unsigned int"""
        return _ifcopenshell_wrapper.entity_instance_get_argument_index(self, a)


    def get_inverse(self, a):
        """get_inverse(entity_instance self, std::string const & a) -> aggregate_of_instance::ptr"""
        return _ifcopenshell_wrapper.entity_instance_get_inverse(self, a)


    def get_argument_type(self, i):
        """get_argument_type(entity_instance self, unsigned int i) -> char const *const"""
        return _ifcopenshell_wrapper.entity_instance_get_argument_type(self, i)


    def get_argument_name(self, i):
        """get_argument_name(entity_instance self, unsigned int i) -> std::string const &"""
        return _ifcopenshell_wrapper.entity_instance_get_argument_name(self, i)


    def setArgumentAsNull(self, i):
        """setArgumentAsNull(entity_instance self, unsigned int i)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsNull(self, i)


    def setArgumentAsInt(self, i, v):
        """setArgumentAsInt(entity_instance self, unsigned int i, int v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsInt(self, i, v)


    def setArgumentAsBool(self, i, v):
        """setArgumentAsBool(entity_instance self, unsigned int i, bool v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsBool(self, i, v)


    def setArgumentAsLogical(self, i, v):
        """setArgumentAsLogical(entity_instance self, unsigned int i, boost::logic::tribool v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsLogical(self, i, v)


    def setArgumentAsDouble(self, i, v):
        """setArgumentAsDouble(entity_instance self, unsigned int i, double v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsDouble(self, i, v)


    def setArgumentAsString(self, i, a):
        """setArgumentAsString(entity_instance self, unsigned int i, std::string const & a)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsString(self, i, a)


    def setArgumentAsAggregateOfInt(self, i, v):
        """setArgumentAsAggregateOfInt(entity_instance self, unsigned int i, std::vector< int,std::allocator< int > > const & v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfInt(self, i, v)


    def setArgumentAsAggregateOfDouble(self, i, v):
        """setArgumentAsAggregateOfDouble(entity_instance self, unsigned int i, std::vector< double,std::allocator< double > > const & v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfDouble(self, i, v)


    def setArgumentAsAggregateOfString(self, i, v):
        """setArgumentAsAggregateOfString(entity_instance self, unsigned int i, std::vector< std::string,std::allocator< std::string > > const & v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfString(self, i, v)


    def setArgumentAsEntityInstance(self, i, v):
        """setArgumentAsEntityInstance(entity_instance self, unsigned int i, entity_instance v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsEntityInstance(self, i, v)


    def setArgumentAsAggregateOfEntityInstance(self, i, v):
        """setArgumentAsAggregateOfEntityInstance(entity_instance self, unsigned int i, aggregate_of_instance::ptr v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfEntityInstance(self, i, v)


    def setArgumentAsAggregateOfAggregateOfInt(self, i, v):
        """setArgumentAsAggregateOfAggregateOfInt(entity_instance self, unsigned int i, std::vector< std::vector< int,std::allocator< int > >,std::allocator< std::vector< int,std::allocator< int > > > > const & v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfAggregateOfInt(self, i, v)


    def setArgumentAsAggregateOfAggregateOfDouble(self, i, v):
        """setArgumentAsAggregateOfAggregateOfDouble(entity_instance self, unsigned int i, std::vector< std::vector< double,std::allocator< double > >,std::allocator< std::vector< double,std::allocator< double > > > > const & v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfAggregateOfDouble(self, i, v)


    def setArgumentAsAggregateOfAggregateOfEntityInstance(self, i, v):
        """setArgumentAsAggregateOfAggregateOfEntityInstance(entity_instance self, unsigned int i, aggregate_of_aggregate_of_instance::ptr v)"""
        return _ifcopenshell_wrapper.entity_instance_setArgumentAsAggregateOfAggregateOfEntityInstance(self, i, v)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_entity_instance
    __del__ = lambda self: None
entity_instance_swigregister = _ifcopenshell_wrapper.entity_instance_swigregister
entity_instance_swigregister(entity_instance)

class IfcBaseEntity(entity_instance):
    """Proxy of C++ IfcUtil::IfcBaseEntity class."""

    __swig_setmethods__ = {}
    for _s in [entity_instance]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IfcBaseEntity, name, value)
    __swig_getmethods__ = {}
    for _s in [entity_instance]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, IfcBaseEntity, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def declaration(self):
        """declaration(IfcBaseEntity self) -> declaration"""
        return _ifcopenshell_wrapper.IfcBaseEntity_declaration(self)


    def get(self, name):
        """get(IfcBaseEntity self, std::string const & name) -> AttributeValue"""
        return _ifcopenshell_wrapper.IfcBaseEntity_get(self, name)


    def get_inverse(self, name):
        """get_inverse(IfcBaseEntity self, std::string const & name) -> boost::shared_ptr< aggregate_of_instance >"""
        return _ifcopenshell_wrapper.IfcBaseEntity_get_inverse(self, name)


    def set_id(self, i):
        """set_id(IfcBaseEntity self, boost::optional< unsigned int > const & i) -> unsigned int"""
        return _ifcopenshell_wrapper.IfcBaseEntity_set_id(self, i)


    def populate_derived(self):
        """populate_derived(IfcBaseEntity self)"""
        return _ifcopenshell_wrapper.IfcBaseEntity_populate_derived(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcBaseEntity
    __del__ = lambda self: None
IfcBaseEntity_swigregister = _ifcopenshell_wrapper.IfcBaseEntity_swigregister
IfcBaseEntity_swigregister(IfcBaseEntity)

class IfcLateBoundEntity(IfcBaseEntity):
    """Proxy of C++ IfcUtil::IfcLateBoundEntity class."""

    __swig_setmethods__ = {}
    for _s in [IfcBaseEntity]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IfcLateBoundEntity, name, value)
    __swig_getmethods__ = {}
    for _s in [IfcBaseEntity]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, IfcLateBoundEntity, name)
    __repr__ = _swig_repr

    def __init__(self, decl, data):
        """__init__(IfcUtil::IfcLateBoundEntity self, declaration decl, IfcEntityInstanceData data) -> IfcLateBoundEntity"""
        this = _ifcopenshell_wrapper.new_IfcLateBoundEntity(decl, data)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def declaration(self):
        """declaration(IfcLateBoundEntity self) -> declaration"""
        return _ifcopenshell_wrapper.IfcLateBoundEntity_declaration(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcLateBoundEntity
    __del__ = lambda self: None
IfcLateBoundEntity_swigregister = _ifcopenshell_wrapper.IfcLateBoundEntity_swigregister
IfcLateBoundEntity_swigregister(IfcLateBoundEntity)

class IfcBaseType(entity_instance):
    """Proxy of C++ IfcUtil::IfcBaseType class."""

    __swig_setmethods__ = {}
    for _s in [entity_instance]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IfcBaseType, name, value)
    __swig_getmethods__ = {}
    for _s in [entity_instance]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, IfcBaseType, name)

    def __init__(self, *args, **kwargs):
        raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr

    def declaration(self):
        """declaration(IfcBaseType self) -> declaration"""
        return _ifcopenshell_wrapper.IfcBaseType_declaration(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_IfcBaseType
    __del__ = lambda self: None
IfcBaseType_swigregister = _ifcopenshell_wrapper.IfcBaseType_swigregister
IfcBaseType_swigregister(IfcBaseType)

class parameter_type(_object):
    """Proxy of C++ IfcParse::parameter_type class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, parameter_type, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, parameter_type, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _ifcopenshell_wrapper.delete_parameter_type
    __del__ = lambda self: None

    def as_named_type(self):
        """as_named_type(parameter_type self) -> named_type"""
        return _ifcopenshell_wrapper.parameter_type_as_named_type(self)


    def as_simple_type(self):
        """as_simple_type(parameter_type self) -> simple_type"""
        return _ifcopenshell_wrapper.parameter_type_as_simple_type(self)


    def as_aggregation_type(self):
        """as_aggregation_type(parameter_type self) -> aggregation_type"""
        return _ifcopenshell_wrapper.parameter_type_as_aggregation_type(self)


    def _is(self, *args):
        """
        _is(parameter_type self, std::string const & arg2) -> bool
        _is(parameter_type self, declaration arg2) -> bool
        """
        return _ifcopenshell_wrapper.parameter_type__is(self, *args)


    def __init__(self):
        """__init__(IfcParse::parameter_type self) -> parameter_type"""
        this = _ifcopenshell_wrapper.new_parameter_type()
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
parameter_type_swigregister = _ifcopenshell_wrapper.parameter_type_swigregister
parameter_type_swigregister(parameter_type)

class named_type(parameter_type):
    """Proxy of C++ IfcParse::named_type class."""

    __swig_setmethods__ = {}
    for _s in [parameter_type]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, named_type, name, value)
    __swig_getmethods__ = {}
    for _s in [parameter_type]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, named_type, name)
    __repr__ = _swig_repr

    def __init__(self, declared_type):
        """__init__(IfcParse::named_type self, declaration declared_type) -> named_type"""
        this = _ifcopenshell_wrapper.new_named_type(declared_type)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def declared_type(self):
        """declared_type(named_type self) -> declaration"""
        return _ifcopenshell_wrapper.named_type_declared_type(self)


    def as_named_type(self):
        """as_named_type(named_type self) -> named_type"""
        return _ifcopenshell_wrapper.named_type_as_named_type(self)


    def _is(self, *args):
        """
        _is(named_type self, std::string const & name) -> bool
        _is(named_type self, declaration decl) -> bool
        """
        return _ifcopenshell_wrapper.named_type__is(self, *args)


    def __repr__(self):
    	return repr(self.declared_type())

    __swig_destroy__ = _ifcopenshell_wrapper.delete_named_type
    __del__ = lambda self: None
named_type_swigregister = _ifcopenshell_wrapper.named_type_swigregister
named_type_swigregister(named_type)

class simple_type(parameter_type):
    """Proxy of C++ IfcParse::simple_type class."""

    __swig_setmethods__ = {}
    for _s in [parameter_type]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, simple_type, name, value)
    __swig_getmethods__ = {}
    for _s in [parameter_type]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, simple_type, name)
    __repr__ = _swig_repr
    binary_type = _ifcopenshell_wrapper.simple_type_binary_type
    boolean_type = _ifcopenshell_wrapper.simple_type_boolean_type
    integer_type = _ifcopenshell_wrapper.simple_type_integer_type
    logical_type = _ifcopenshell_wrapper.simple_type_logical_type
    number_type = _ifcopenshell_wrapper.simple_type_number_type
    real_type = _ifcopenshell_wrapper.simple_type_real_type
    string_type = _ifcopenshell_wrapper.simple_type_string_type
    datatype_COUNT = _ifcopenshell_wrapper.simple_type_datatype_COUNT

    def __init__(self, declared_type):
        """__init__(IfcParse::simple_type self, IfcParse::simple_type::data_type declared_type) -> simple_type"""
        this = _ifcopenshell_wrapper.new_simple_type(declared_type)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def declared_type(self):
        """declared_type(simple_type self) -> IfcParse::simple_type::data_type"""
        return _ifcopenshell_wrapper.simple_type_declared_type(self)


    def as_simple_type(self):
        """as_simple_type(simple_type self) -> simple_type"""
        return _ifcopenshell_wrapper.simple_type_as_simple_type(self)


    def __repr__(self):
    	return "<%s>" % self.declared_type()

    __swig_destroy__ = _ifcopenshell_wrapper.delete_simple_type
    __del__ = lambda self: None
simple_type_swigregister = _ifcopenshell_wrapper.simple_type_swigregister
simple_type_swigregister(simple_type)

class aggregation_type(parameter_type):
    """Proxy of C++ IfcParse::aggregation_type class."""

    __swig_setmethods__ = {}
    for _s in [parameter_type]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, aggregation_type, name, value)
    __swig_getmethods__ = {}
    for _s in [parameter_type]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, aggregation_type, name)
    __repr__ = _swig_repr
    array_type = _ifcopenshell_wrapper.aggregation_type_array_type
    bag_type = _ifcopenshell_wrapper.aggregation_type_bag_type
    list_type = _ifcopenshell_wrapper.aggregation_type_list_type
    set_type = _ifcopenshell_wrapper.aggregation_type_set_type

    def __init__(self, type_of_aggregation, bound1, bound2, type_of_element):
        """__init__(IfcParse::aggregation_type self, IfcParse::aggregation_type::aggregate_type type_of_aggregation, int bound1, int bound2, parameter_type type_of_element) -> aggregation_type"""
        this = _ifcopenshell_wrapper.new_aggregation_type(type_of_aggregation, bound1, bound2, type_of_element)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_aggregation_type
    __del__ = lambda self: None

    def type_of_aggregation(self):
        """type_of_aggregation(aggregation_type self) -> IfcParse::aggregation_type::aggregate_type"""
        return _ifcopenshell_wrapper.aggregation_type_type_of_aggregation(self)


    def bound1(self):
        """bound1(aggregation_type self) -> int"""
        return _ifcopenshell_wrapper.aggregation_type_bound1(self)


    def bound2(self):
        """bound2(aggregation_type self) -> int"""
        return _ifcopenshell_wrapper.aggregation_type_bound2(self)


    def type_of_element(self):
        """type_of_element(aggregation_type self) -> parameter_type"""
        return _ifcopenshell_wrapper.aggregation_type_type_of_element(self)


    def as_aggregation_type(self):
        """as_aggregation_type(aggregation_type self) -> aggregation_type"""
        return _ifcopenshell_wrapper.aggregation_type_as_aggregation_type(self)


    def type_of_aggregation_string(self):
        """type_of_aggregation_string(aggregation_type self) -> std::string"""
        return _ifcopenshell_wrapper.aggregation_type_type_of_aggregation_string(self)


    def __repr__(self):
    	format_bound = lambda i: "?" if i == -1 else str(i)
    	return "<%s [%s:%s] of %r>" % (
    		self.type_of_aggregation_string(),
    		format_bound(self.bound1()),
    		format_bound(self.bound2()),
    		self.type_of_element()
    	)

aggregation_type_swigregister = _ifcopenshell_wrapper.aggregation_type_swigregister
aggregation_type_swigregister(aggregation_type)

class declaration(_object):
    """Proxy of C++ IfcParse::declaration class."""

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

    def __init__(self, name, index_in_schema):
        """__init__(IfcParse::declaration self, std::string const & name, int index_in_schema) -> declaration"""
        this = _ifcopenshell_wrapper.new_declaration(name, index_in_schema)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_declaration
    __del__ = lambda self: None

    def name(self):
        """name(declaration self) -> std::string const &"""
        return _ifcopenshell_wrapper.declaration_name(self)


    def name_uc(self):
        """name_uc(declaration self) -> std::string const &"""
        return _ifcopenshell_wrapper.declaration_name_uc(self)


    def as_type_declaration(self):
        """as_type_declaration(declaration self) -> type_declaration"""
        return _ifcopenshell_wrapper.declaration_as_type_declaration(self)


    def as_select_type(self):
        """as_select_type(declaration self) -> select_type"""
        return _ifcopenshell_wrapper.declaration_as_select_type(self)


    def as_enumeration_type(self):
        """as_enumeration_type(declaration self) -> enumeration_type"""
        return _ifcopenshell_wrapper.declaration_as_enumeration_type(self)


    def as_entity(self):
        """as_entity(declaration self) -> entity"""
        return _ifcopenshell_wrapper.declaration_as_entity(self)


    def _is(self, *args):
        """
        _is(declaration self, std::string const & name) -> bool
        _is(declaration self, declaration decl) -> bool
        """
        return _ifcopenshell_wrapper.declaration__is(self, *args)


    def index_in_schema(self):
        """index_in_schema(declaration self) -> int"""
        return _ifcopenshell_wrapper.declaration_index_in_schema(self)


    def type(self):
        """type(declaration self) -> int"""
        return _ifcopenshell_wrapper.declaration_type(self)


    def schema(self):
        """schema(declaration self) -> schema_definition"""
        return _ifcopenshell_wrapper.declaration_schema(self)

declaration_swigregister = _ifcopenshell_wrapper.declaration_swigregister
declaration_swigregister(declaration)

class type_declaration(declaration):
    """Proxy of C++ IfcParse::type_declaration class."""

    __swig_setmethods__ = {}
    for _s in [declaration]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, type_declaration, name, value)
    __swig_getmethods__ = {}
    for _s in [declaration]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, type_declaration, name)
    __repr__ = _swig_repr

    def __init__(self, name, index_in_schema, declared_type):
        """__init__(IfcParse::type_declaration self, std::string const & name, int index_in_schema, parameter_type declared_type) -> type_declaration"""
        this = _ifcopenshell_wrapper.new_type_declaration(name, index_in_schema, declared_type)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_type_declaration
    __del__ = lambda self: None

    def declared_type(self):
        """declared_type(type_declaration self) -> parameter_type"""
        return _ifcopenshell_wrapper.type_declaration_declared_type(self)


    def as_type_declaration(self):
        """as_type_declaration(type_declaration self) -> type_declaration"""
        return _ifcopenshell_wrapper.type_declaration_as_type_declaration(self)


    def __repr__(self):
    	return "<type %s: %r>" % (self.name(), self.declared_type())


    def argument_types(self):
        """argument_types(type_declaration self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.type_declaration_argument_types(self)

type_declaration_swigregister = _ifcopenshell_wrapper.type_declaration_swigregister
type_declaration_swigregister(type_declaration)

class select_type(declaration):
    """Proxy of C++ IfcParse::select_type class."""

    __swig_setmethods__ = {}
    for _s in [declaration]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, select_type, name, value)
    __swig_getmethods__ = {}
    for _s in [declaration]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, select_type, name)
    __repr__ = _swig_repr

    def __init__(self, name, index_in_schema, select_list):
        """__init__(IfcParse::select_type self, std::string const & name, int index_in_schema, std::vector< IfcParse::declaration const *,std::allocator< IfcParse::declaration const * > > const & select_list) -> select_type"""
        this = _ifcopenshell_wrapper.new_select_type(name, index_in_schema, select_list)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def select_list(self):
        """select_list(select_type self) -> std::vector< IfcParse::declaration const *,std::allocator< IfcParse::declaration const * > > const &"""
        return _ifcopenshell_wrapper.select_type_select_list(self)


    def as_select_type(self):
        """as_select_type(select_type self) -> select_type"""
        return _ifcopenshell_wrapper.select_type_as_select_type(self)


    def __repr__(self):
    	return "<select %s: (%s)>" % (self.name(), " | ".join(map(repr, self.select_list())))

    __swig_destroy__ = _ifcopenshell_wrapper.delete_select_type
    __del__ = lambda self: None
select_type_swigregister = _ifcopenshell_wrapper.select_type_swigregister
select_type_swigregister(select_type)

class enumeration_type(declaration):
    """Proxy of C++ IfcParse::enumeration_type class."""

    __swig_setmethods__ = {}
    for _s in [declaration]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, enumeration_type, name, value)
    __swig_getmethods__ = {}
    for _s in [declaration]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, enumeration_type, name)
    __repr__ = _swig_repr

    def __init__(self, name, index_in_schema, enumeration_items):
        """__init__(IfcParse::enumeration_type self, std::string const & name, int index_in_schema, std::vector< std::string,std::allocator< std::string > > const & enumeration_items) -> enumeration_type"""
        this = _ifcopenshell_wrapper.new_enumeration_type(name, index_in_schema, enumeration_items)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def enumeration_items(self):
        """enumeration_items(enumeration_type self) -> std::vector< std::string,std::allocator< std::string > > const &"""
        return _ifcopenshell_wrapper.enumeration_type_enumeration_items(self)


    def lookup_enum_value(self, i):
        """lookup_enum_value(enumeration_type self, size_t i) -> char const *"""
        return _ifcopenshell_wrapper.enumeration_type_lookup_enum_value(self, i)


    def lookup_enum_offset(self, string):
        """lookup_enum_offset(enumeration_type self, std::string const & string) -> size_t"""
        return _ifcopenshell_wrapper.enumeration_type_lookup_enum_offset(self, string)


    def as_enumeration_type(self):
        """as_enumeration_type(enumeration_type self) -> enumeration_type"""
        return _ifcopenshell_wrapper.enumeration_type_as_enumeration_type(self)


    def __repr__(self):
    	return "<enumeration %s: (%s)>" % (self.name(), ", ".join(self.enumeration_items()))


    def argument_types(self):
        """argument_types(enumeration_type self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.enumeration_type_argument_types(self)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_enumeration_type
    __del__ = lambda self: None
enumeration_type_swigregister = _ifcopenshell_wrapper.enumeration_type_swigregister
enumeration_type_swigregister(enumeration_type)

class attribute(_object):
    """Proxy of C++ IfcParse::attribute class."""

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

    def __init__(self, name, type_of_attribute, optional):
        """__init__(IfcParse::attribute self, std::string const & name, parameter_type type_of_attribute, bool optional) -> attribute"""
        this = _ifcopenshell_wrapper.new_attribute(name, type_of_attribute, optional)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_attribute
    __del__ = lambda self: None

    def name(self):
        """name(attribute self) -> std::string const &"""
        return _ifcopenshell_wrapper.attribute_name(self)


    def type_of_attribute(self):
        """type_of_attribute(attribute self) -> parameter_type"""
        return _ifcopenshell_wrapper.attribute_type_of_attribute(self)


    def optional(self):
        """optional(attribute self) -> bool"""
        return _ifcopenshell_wrapper.attribute_optional(self)


    def __repr__(self):
    	return "<attribute %s%s: %s>" % (self.name(), "?" if self.optional() else "", self.type_of_attribute())

attribute_swigregister = _ifcopenshell_wrapper.attribute_swigregister
attribute_swigregister(attribute)

class inverse_attribute(_object):
    """Proxy of C++ IfcParse::inverse_attribute class."""

    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, inverse_attribute, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, inverse_attribute, name)
    __repr__ = _swig_repr
    bag_type = _ifcopenshell_wrapper.inverse_attribute_bag_type
    set_type = _ifcopenshell_wrapper.inverse_attribute_set_type
    unspecified_type = _ifcopenshell_wrapper.inverse_attribute_unspecified_type

    def __init__(self, name, type_of_aggregation, bound1, bound2, entity_reference, attribute_reference):
        """__init__(IfcParse::inverse_attribute self, std::string const & name, IfcParse::inverse_attribute::aggregate_type type_of_aggregation, int bound1, int bound2, entity entity_reference, attribute attribute_reference) -> inverse_attribute"""
        this = _ifcopenshell_wrapper.new_inverse_attribute(name, type_of_aggregation, bound1, bound2, entity_reference, attribute_reference)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this

    def name(self):
        """name(inverse_attribute self) -> std::string const &"""
        return _ifcopenshell_wrapper.inverse_attribute_name(self)


    def type_of_aggregation(self):
        """type_of_aggregation(inverse_attribute self) -> IfcParse::inverse_attribute::aggregate_type"""
        return _ifcopenshell_wrapper.inverse_attribute_type_of_aggregation(self)


    def bound1(self):
        """bound1(inverse_attribute self) -> int"""
        return _ifcopenshell_wrapper.inverse_attribute_bound1(self)


    def bound2(self):
        """bound2(inverse_attribute self) -> int"""
        return _ifcopenshell_wrapper.inverse_attribute_bound2(self)


    def entity_reference(self):
        """entity_reference(inverse_attribute self) -> entity"""
        return _ifcopenshell_wrapper.inverse_attribute_entity_reference(self)


    def attribute_reference(self):
        """attribute_reference(inverse_attribute self) -> attribute"""
        return _ifcopenshell_wrapper.inverse_attribute_attribute_reference(self)


    def type_of_aggregation_string(self):
        """type_of_aggregation_string(inverse_attribute self) -> std::string"""
        return _ifcopenshell_wrapper.inverse_attribute_type_of_aggregation_string(self)


    def __repr__(self):
    	format_bound = lambda i: "?" if i == -1 else str(i)
    	return "<inverse %s: %s [%s:%s] of %r for %r>" % (
    		self.name(),
    		self.type_of_aggregation_string(),
    		format_bound(self.bound1()),
    		format_bound(self.bound2()),
    		self.entity_reference(),
    		self.attribute_reference()
    	)

    __swig_destroy__ = _ifcopenshell_wrapper.delete_inverse_attribute
    __del__ = lambda self: None
inverse_attribute_swigregister = _ifcopenshell_wrapper.inverse_attribute_swigregister
inverse_attribute_swigregister(inverse_attribute)

class entity(declaration):
    """Proxy of C++ IfcParse::entity class."""

    __swig_setmethods__ = {}
    for _s in [declaration]:
        __swig_setmethods__.update(getattr(_s, '__swig_setmethods__', {}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, entity, name, value)
    __swig_getmethods__ = {}
    for _s in [declaration]:
        __swig_getmethods__.update(getattr(_s, '__swig_getmethods__', {}))
    __getattr__ = lambda self, name: _swig_getattr(self, entity, name)
    __repr__ = _swig_repr

    def __init__(self, name, is_abstract, index_in_schema, supertype):
        """__init__(IfcParse::entity self, std::string const & name, bool is_abstract, int index_in_schema, entity supertype) -> entity"""
        this = _ifcopenshell_wrapper.new_entity(name, is_abstract, index_in_schema, supertype)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_entity
    __del__ = lambda self: None

    def is_abstract(self):
        """is_abstract(entity self) -> bool"""
        return _ifcopenshell_wrapper.entity_is_abstract(self)


    def set_subtypes(self, subtypes):
        """set_subtypes(entity self, std::vector< IfcParse::entity const *,std::allocator< IfcParse::entity const * > > const & subtypes)"""
        return _ifcopenshell_wrapper.entity_set_subtypes(self, subtypes)


    def set_attributes(self, attributes, derived):
        """set_attributes(entity self, std::vector< IfcParse::attribute const *,std::allocator< IfcParse::attribute const * > > const & attributes, std::vector< bool,std::allocator< bool > > const & derived)"""
        return _ifcopenshell_wrapper.entity_set_attributes(self, attributes, derived)


    def set_inverse_attributes(self, inverse_attributes):
        """set_inverse_attributes(entity self, std::vector< IfcParse::inverse_attribute const *,std::allocator< IfcParse::inverse_attribute const * > > const & inverse_attributes)"""
        return _ifcopenshell_wrapper.entity_set_inverse_attributes(self, inverse_attributes)


    def subtypes(self):
        """subtypes(entity self) -> std::vector< IfcParse::entity const *,std::allocator< IfcParse::entity const * > > const &"""
        return _ifcopenshell_wrapper.entity_subtypes(self)


    def attributes(self):
        """attributes(entity self) -> std::vector< IfcParse::attribute const *,std::allocator< IfcParse::attribute const * > > const &"""
        return _ifcopenshell_wrapper.entity_attributes(self)


    def derived(self):
        """derived(entity self) -> std::vector< bool,std::allocator< bool > > const &"""
        return _ifcopenshell_wrapper.entity_derived(self)


    def all_attributes(self):
        """all_attributes(entity self) -> std::vector< IfcParse::attribute const *,std::allocator< IfcParse::attribute const * > > const"""
        return _ifcopenshell_wrapper.entity_all_attributes(self)


    def all_inverse_attributes(self):
        """all_inverse_attributes(entity self) -> std::vector< IfcParse::inverse_attribute const *,std::allocator< IfcParse::inverse_attribute const * > > const"""
        return _ifcopenshell_wrapper.entity_all_inverse_attributes(self)


    def attribute_by_index(self, index):
        """attribute_by_index(entity self, size_t index) -> attribute"""
        return _ifcopenshell_wrapper.entity_attribute_by_index(self, index)


    def attribute_count(self):
        """attribute_count(entity self) -> size_t"""
        return _ifcopenshell_wrapper.entity_attribute_count(self)


    def attribute_index(self, *args):
        """
        attribute_index(entity self, attribute attr) -> ptrdiff_t
        attribute_index(entity self, std::string const & attr_name) -> ptrdiff_t
        """
        return _ifcopenshell_wrapper.entity_attribute_index(self, *args)


    def supertype(self):
        """supertype(entity self) -> entity"""
        return _ifcopenshell_wrapper.entity_supertype(self)


    def as_entity(self):
        """as_entity(entity self) -> entity"""
        return _ifcopenshell_wrapper.entity_as_entity(self)


    def __repr__(self):
    	return "<entity %s>" % (self.name())


    def argument_types(self):
        """argument_types(entity self) -> std::vector< std::string,std::allocator< std::string > >"""
        return _ifcopenshell_wrapper.entity_argument_types(self)

entity_swigregister = _ifcopenshell_wrapper.entity_swigregister
entity_swigregister(entity)

class schema_definition(_object):
    """Proxy of C++ IfcParse::schema_definition class."""

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

    def __init__(self, name, declarations, factory):
        """__init__(IfcParse::schema_definition self, std::string const & name, std::vector< IfcParse::declaration const *,std::allocator< IfcParse::declaration const * > > const & declarations, IfcParse::instance_factory * factory) -> schema_definition"""
        this = _ifcopenshell_wrapper.new_schema_definition(name, declarations, factory)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_schema_definition
    __del__ = lambda self: None

    def declaration_by_name(self, *args):
        """
        declaration_by_name(schema_definition self, std::string const & name) -> declaration
        declaration_by_name(schema_definition self, size_t name) -> declaration
        """
        return _ifcopenshell_wrapper.schema_definition_declaration_by_name(self, *args)


    def declarations(self):
        """declarations(schema_definition self) -> std::vector< IfcParse::declaration const *,std::allocator< IfcParse::declaration const * > > const &"""
        return _ifcopenshell_wrapper.schema_definition_declarations(self)


    def type_declarations(self):
        """type_declarations(schema_definition self) -> std::vector< IfcParse::type_declaration const *,std::allocator< IfcParse::type_declaration const * > > const &"""
        return _ifcopenshell_wrapper.schema_definition_type_declarations(self)


    def select_types(self):
        """select_types(schema_definition self) -> std::vector< IfcParse::select_type const *,std::allocator< IfcParse::select_type const * > > const &"""
        return _ifcopenshell_wrapper.schema_definition_select_types(self)


    def enumeration_types(self):
        """enumeration_types(schema_definition self) -> std::vector< IfcParse::enumeration_type const *,std::allocator< IfcParse::enumeration_type const * > > const &"""
        return _ifcopenshell_wrapper.schema_definition_enumeration_types(self)


    def entities(self):
        """entities(schema_definition self) -> std::vector< IfcParse::entity const *,std::allocator< IfcParse::entity const * > > const &"""
        return _ifcopenshell_wrapper.schema_definition_entities(self)


    def name(self):
        """name(schema_definition self) -> std::string const &"""
        return _ifcopenshell_wrapper.schema_definition_name(self)


    def instantiate(self, decl, data):
        """instantiate(schema_definition self, declaration decl, IfcEntityInstanceData data) -> entity_instance"""
        return _ifcopenshell_wrapper.schema_definition_instantiate(self, decl, data)


    def __repr__(self):
    	return "<schema %s>" % (self.name())

schema_definition_swigregister = _ifcopenshell_wrapper.schema_definition_swigregister
schema_definition_swigregister(schema_definition)


def schema_by_name(arg1):
    """schema_by_name(std::string const & arg1) -> schema_definition"""
    return _ifcopenshell_wrapper.schema_by_name(arg1)

def schema_names():
    """schema_names() -> std::vector< std::string,std::allocator< std::string > >"""
    return _ifcopenshell_wrapper.schema_names()

def register_schema(arg1):
    """register_schema(schema_definition arg1)"""
    return _ifcopenshell_wrapper.register_schema(arg1)

def clear_schemas():
    """clear_schemas()"""
    return _ifcopenshell_wrapper.clear_schemas()
class RocksDbSerializer(_object):
    """Proxy of C++ RocksDbSerializer class."""

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

    def __init__(self, *args):
        """
        __init__(RocksDbSerializer self, file file, std::string const & rocksdb_filename) -> RocksDbSerializer
        __init__(RocksDbSerializer self, std::string const & input_filename, std::string const & rocksdb_filename, bool stream) -> RocksDbSerializer
        """
        this = _ifcopenshell_wrapper.new_RocksDbSerializer(*args)
        try:
            self.this.append(this)
        except __builtin__.Exception:
            self.this = this
    __swig_destroy__ = _ifcopenshell_wrapper.delete_RocksDbSerializer
    __del__ = lambda self: None

    def ready(self):
        """ready(RocksDbSerializer self) -> bool"""
        return _ifcopenshell_wrapper.RocksDbSerializer_ready(self)


    def writeHeader(self):
        """writeHeader(RocksDbSerializer self)"""
        return _ifcopenshell_wrapper.RocksDbSerializer_writeHeader(self)


    def finalize(self):
        """finalize(RocksDbSerializer self)"""
        return _ifcopenshell_wrapper.RocksDbSerializer_finalize(self)


    def setFile(self, arg2):
        """setFile(RocksDbSerializer self, file arg2)"""
        return _ifcopenshell_wrapper.RocksDbSerializer_setFile(self, arg2)

RocksDbSerializer_swigregister = _ifcopenshell_wrapper.RocksDbSerializer_swigregister
RocksDbSerializer_swigregister(RocksDbSerializer)


def open(fn, readonly=False):
    """
    open(std::string const & fn, bool readonly=False) -> file
    open(std::string const & fn) -> file
    """
    return _ifcopenshell_wrapper.open(fn, readonly)

def read(data):
    """read(std::string const & data) -> file"""
    return _ifcopenshell_wrapper.read(data)

def stream_from_string(data):
    """stream_from_string(std::string const & data) -> InstanceStreamer"""
    return _ifcopenshell_wrapper.stream_from_string(data)

def version():
    """version() -> char const *"""
    return _ifcopenshell_wrapper.version()

def new_IfcBaseClass(schema_identifier, name):
    """new_IfcBaseClass(std::string const & schema_identifier, std::string const & name) -> entity_instance"""
    return _ifcopenshell_wrapper.new_IfcBaseClass(schema_identifier, name)

def get_log():
    """get_log() -> std::string"""
    return _ifcopenshell_wrapper.get_log()

def turn_on_detailed_logging():
    """turn_on_detailed_logging()"""
    return _ifcopenshell_wrapper.turn_on_detailed_logging()

def turn_off_detailed_logging():
    """turn_off_detailed_logging()"""
    return _ifcopenshell_wrapper.turn_off_detailed_logging()

def set_log_format_json():
    """set_log_format_json()"""
    return _ifcopenshell_wrapper.set_log_format_json()

def set_log_format_text():
    """set_log_format_text()"""
    return _ifcopenshell_wrapper.set_log_format_text()

def get_info_cpp(v, include_identifier=True):
    """
    get_info_cpp(entity_instance v, bool include_identifier=True) -> PyObject
    get_info_cpp(entity_instance v) -> PyObject *
    """
    return _ifcopenshell_wrapper.get_info_cpp(v, include_identifier)
# This file is compatible with both classic and new-style classes.


