6905 lines
317 KiB
Python
6905 lines
317 KiB
Python
# This file was automatically generated by SWIG (https://www.swig.org).
|
|
# Version 4.2.1
|
|
#
|
|
# Do not make changes to this file unless you know what you are doing - modify
|
|
# the SWIG interface file instead.
|
|
|
|
from sys import version_info as _swig_python_version_info
|
|
# Import the low-level C/C++ module
|
|
if __package__ or "." in __name__:
|
|
from . import _ifcopenshell_wrapper
|
|
else:
|
|
import _ifcopenshell_wrapper
|
|
|
|
try:
|
|
import builtins as __builtin__
|
|
except ImportError:
|
|
import __builtin__
|
|
|
|
def _swig_repr(self):
|
|
try:
|
|
strthis = "proxy of " + self.this.__repr__()
|
|
except __builtin__.Exception:
|
|
strthis = ""
|
|
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
|
|
|
|
|
|
def _swig_setattr_nondynamic_instance_variable(set):
|
|
def set_instance_attr(self, name, value):
|
|
if name == "this":
|
|
set(self, name, value)
|
|
elif name == "thisown":
|
|
self.this.own(value)
|
|
elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
|
|
set(self, name, value)
|
|
else:
|
|
raise AttributeError("You cannot add instance attributes to %s" % self)
|
|
return set_instance_attr
|
|
|
|
|
|
def _swig_setattr_nondynamic_class_variable(set):
|
|
def set_class_attr(cls, name, value):
|
|
if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
|
|
set(cls, name, value)
|
|
else:
|
|
raise AttributeError("You cannot add class attributes to %s" % cls)
|
|
return set_class_attr
|
|
|
|
|
|
def _swig_add_metaclass(metaclass):
|
|
"""Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
|
|
def wrapper(cls):
|
|
return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
|
|
return wrapper
|
|
|
|
|
|
class _SwigNonDynamicMeta(type):
|
|
"""Meta class to enforce nondynamic attributes (no new attributes) for a class"""
|
|
__setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
|
|
|
|
|
|
class SwigPyIterator(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_SwigPyIterator
|
|
|
|
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
|
|
|
|
# Register SwigPyIterator in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.SwigPyIterator_swigregister(SwigPyIterator)
|
|
SHARED_PTR_DISOWN = _ifcopenshell_wrapper.SHARED_PTR_DISOWN
|
|
class DoubleArray3(object):
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
return _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):
|
|
_ifcopenshell_wrapper.DoubleArray3_swiginit(self, _ifcopenshell_wrapper.new_DoubleArray3(*args))
|
|
|
|
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
|
|
|
|
# Register DoubleArray3 in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.DoubleArray3_swigregister(DoubleArray3)
|
|
|
|
def taxonomy_item_repr(i):
|
|
r"""taxonomy_item_repr(ifcopenshell::geometry::taxonomy::item::ptr i) -> std::string"""
|
|
return _ifcopenshell_wrapper.taxonomy_item_repr(i)
|
|
class OpaqueNumber(object):
|
|
r"""Proxy of C++ IfcGeom::OpaqueNumber class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def to_double(self):
|
|
r"""to_double(OpaqueNumber self) -> double"""
|
|
return _ifcopenshell_wrapper.OpaqueNumber_to_double(self)
|
|
|
|
def to_string(self):
|
|
r"""to_string(OpaqueNumber self) -> std::string"""
|
|
return _ifcopenshell_wrapper.OpaqueNumber_to_string(self)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_OpaqueNumber
|
|
|
|
def __add__(self, other):
|
|
r"""__add__(OpaqueNumber self, OpaqueNumber other) -> OpaqueNumber"""
|
|
return _ifcopenshell_wrapper.OpaqueNumber___add__(self, other)
|
|
|
|
def __sub__(self, other):
|
|
r"""__sub__(OpaqueNumber self, OpaqueNumber other) -> OpaqueNumber"""
|
|
return _ifcopenshell_wrapper.OpaqueNumber___sub__(self, other)
|
|
|
|
def __mul__(self, other):
|
|
r"""__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):
|
|
r"""__eq__(OpaqueNumber self, OpaqueNumber other) -> bool"""
|
|
return _ifcopenshell_wrapper.OpaqueNumber___eq__(self, other)
|
|
|
|
def __lt__(self, other):
|
|
r"""__lt__(OpaqueNumber self, OpaqueNumber other) -> bool"""
|
|
return _ifcopenshell_wrapper.OpaqueNumber___lt__(self, other)
|
|
|
|
def __neg__(self):
|
|
r"""__neg__(OpaqueNumber self) -> OpaqueNumber"""
|
|
return _ifcopenshell_wrapper.OpaqueNumber___neg__(self)
|
|
|
|
def clone(self):
|
|
r"""clone(OpaqueNumber self) -> OpaqueNumber"""
|
|
return _ifcopenshell_wrapper.OpaqueNumber_clone(self)
|
|
|
|
# Register OpaqueNumber in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.OpaqueNumber_swigregister(OpaqueNumber)
|
|
class ConversionResultShape(object):
|
|
r"""Proxy of C++ IfcGeom::ConversionResultShape class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def Triangulate(self, *args):
|
|
r"""
|
|
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):
|
|
r"""Serialize(ConversionResultShape self, matrix4 place, std::string & arg3)"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_Serialize(self, place, arg3)
|
|
|
|
def surface_genus(self):
|
|
r"""surface_genus(ConversionResultShape self) -> int"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_surface_genus(self)
|
|
|
|
def is_manifold(self):
|
|
r"""is_manifold(ConversionResultShape self) -> bool"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_is_manifold(self)
|
|
|
|
def num_vertices(self):
|
|
r"""num_vertices(ConversionResultShape self) -> int"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_num_vertices(self)
|
|
|
|
def num_edges(self):
|
|
r"""num_edges(ConversionResultShape self) -> int"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_num_edges(self)
|
|
|
|
def num_faces(self):
|
|
r"""num_faces(ConversionResultShape self) -> int"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_num_faces(self)
|
|
|
|
def bounding_box(self, *args):
|
|
r"""
|
|
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):
|
|
r"""set_box(ConversionResultShape self, void * b)"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_set_box(self, b)
|
|
|
|
def length(self):
|
|
r"""length(ConversionResultShape self) -> OpaqueNumber"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_length(self)
|
|
|
|
def area(self):
|
|
r"""area(ConversionResultShape self) -> OpaqueNumber"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_area(self)
|
|
|
|
def volume(self):
|
|
r"""volume(ConversionResultShape self) -> OpaqueNumber"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_volume(self)
|
|
|
|
def position(self):
|
|
r"""position(ConversionResultShape self) -> OpaqueCoordinate_3"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_position(self)
|
|
|
|
def axis(self):
|
|
r"""axis(ConversionResultShape self) -> OpaqueCoordinate_3"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_axis(self)
|
|
|
|
def plane_equation(self):
|
|
r"""plane_equation(ConversionResultShape self) -> OpaqueCoordinate_4"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_plane_equation(self)
|
|
|
|
def convex_decomposition(self):
|
|
r"""convex_decomposition(ConversionResultShape self) -> std::vector< IfcGeom::ConversionResultShape *,std::allocator< IfcGeom::ConversionResultShape * > >"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_convex_decomposition(self)
|
|
|
|
def halfspaces(self):
|
|
r"""halfspaces(ConversionResultShape self) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_halfspaces(self)
|
|
|
|
def box(self):
|
|
r"""box(ConversionResultShape self) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_box(self)
|
|
|
|
def solid(self):
|
|
r"""solid(ConversionResultShape self) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_solid(self)
|
|
|
|
def wrap_in_compound(self):
|
|
r"""wrap_in_compound(ConversionResultShape self) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_wrap_in_compound(self)
|
|
|
|
def vertices(self):
|
|
r"""vertices(ConversionResultShape self) -> std::vector< IfcGeom::ConversionResultShape *,std::allocator< IfcGeom::ConversionResultShape * > >"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_vertices(self)
|
|
|
|
def edges(self):
|
|
r"""edges(ConversionResultShape self) -> std::vector< IfcGeom::ConversionResultShape *,std::allocator< IfcGeom::ConversionResultShape * > >"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_edges(self)
|
|
|
|
def facets(self):
|
|
r"""facets(ConversionResultShape self) -> std::vector< IfcGeom::ConversionResultShape *,std::allocator< IfcGeom::ConversionResultShape * > >"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_facets(self)
|
|
|
|
def add(self, arg2):
|
|
r"""add(ConversionResultShape self, ConversionResultShape arg2) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_add(self, arg2)
|
|
|
|
def subtract(self, arg2):
|
|
r"""subtract(ConversionResultShape self, ConversionResultShape arg2) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_subtract(self, arg2)
|
|
|
|
def intersect(self, arg2):
|
|
r"""intersect(ConversionResultShape self, ConversionResultShape arg2) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_intersect(self, arg2)
|
|
|
|
def concat(self, arg2):
|
|
r"""concat(ConversionResultShape self, ConversionResultShape arg2) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_concat(self, arg2)
|
|
|
|
def map(self, *args):
|
|
r"""
|
|
map(ConversionResultShape self, OpaqueCoordinate_4 _from, OpaqueCoordinate_4 to)
|
|
map(ConversionResultShape self, std::vector< IfcGeom::OpaqueCoordinate< 4 >,std::allocator< IfcGeom::OpaqueCoordinate< 4 > > > const & _from, std::vector< IfcGeom::OpaqueCoordinate< 4 >,std::allocator< IfcGeom::OpaqueCoordinate< 4 > > > const & to)
|
|
"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_map(self, *args)
|
|
|
|
def moved(self, arg2):
|
|
r"""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):
|
|
r"""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
|
|
|
|
def serialize_obj(self):
|
|
r"""serialize_obj(ConversionResultShape self) -> std::string"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_serialize_obj(self)
|
|
|
|
def convex_tag(self, b):
|
|
r"""convex_tag(ConversionResultShape self, bool b)"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_convex_tag(self, b)
|
|
|
|
def serialize(self):
|
|
r"""serialize(ConversionResultShape self) -> std::string"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_serialize(self)
|
|
|
|
def solid_mt(self):
|
|
r"""solid_mt(ConversionResultShape self) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.ConversionResultShape_solid_mt(self)
|
|
|
|
# Register ConversionResultShape in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.ConversionResultShape_swigregister(ConversionResultShape)
|
|
class ConversionResult(object):
|
|
r"""Proxy of C++ IfcGeom::ConversionResult class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(ConversionResult self, int id, ifcopenshell::geometry::taxonomy::matrix4::ptr placement, ConversionResultShape shape, ifcopenshell::geometry::taxonomy::style::ptr style) -> ConversionResult
|
|
__init__(ConversionResult self, int id, ifcopenshell::geometry::taxonomy::matrix4::ptr placement, ConversionResultShape shape) -> ConversionResult
|
|
__init__(ConversionResult self, int id, ConversionResultShape shape, ifcopenshell::geometry::taxonomy::style::ptr style) -> ConversionResult
|
|
__init__(ConversionResult self, int id, ConversionResultShape shape) -> ConversionResult
|
|
"""
|
|
_ifcopenshell_wrapper.ConversionResult_swiginit(self, _ifcopenshell_wrapper.new_ConversionResult(*args))
|
|
|
|
def append(self, trsf):
|
|
r"""append(ConversionResult self, ifcopenshell::geometry::taxonomy::matrix4::ptr trsf)"""
|
|
return _ifcopenshell_wrapper.ConversionResult_append(self, trsf)
|
|
|
|
def prepend(self, trsf):
|
|
r"""prepend(ConversionResult self, ifcopenshell::geometry::taxonomy::matrix4::ptr trsf)"""
|
|
return _ifcopenshell_wrapper.ConversionResult_prepend(self, trsf)
|
|
|
|
def Shape(self):
|
|
r"""Shape(ConversionResult self) -> std::shared_ptr< IfcGeom::ConversionResultShape >"""
|
|
return _ifcopenshell_wrapper.ConversionResult_Shape(self)
|
|
|
|
def Placement(self):
|
|
r"""Placement(ConversionResult self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr"""
|
|
return _ifcopenshell_wrapper.ConversionResult_Placement(self)
|
|
|
|
def hasStyle(self):
|
|
r"""hasStyle(ConversionResult self) -> bool"""
|
|
return _ifcopenshell_wrapper.ConversionResult_hasStyle(self)
|
|
|
|
def Style(self):
|
|
r"""Style(ConversionResult self) -> style"""
|
|
return _ifcopenshell_wrapper.ConversionResult_Style(self)
|
|
|
|
def StylePtr(self):
|
|
r"""StylePtr(ConversionResult self) -> ifcopenshell::geometry::taxonomy::style::ptr"""
|
|
return _ifcopenshell_wrapper.ConversionResult_StylePtr(self)
|
|
|
|
def setStyle(self, newStyle):
|
|
r"""setStyle(ConversionResult self, ifcopenshell::geometry::taxonomy::style::ptr newStyle)"""
|
|
return _ifcopenshell_wrapper.ConversionResult_setStyle(self, newStyle)
|
|
|
|
def ItemId(self):
|
|
r"""ItemId(ConversionResult self) -> int"""
|
|
return _ifcopenshell_wrapper.ConversionResult_ItemId(self)
|
|
|
|
def apply_transform(self, unit_scale=1.):
|
|
r"""apply_transform(ConversionResult self, double unit_scale=1.) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.ConversionResult_apply_transform(self, unit_scale)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_ConversionResult
|
|
|
|
# Register ConversionResult in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.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):
|
|
r"""
|
|
__rshift__(std::istream & _in, ifcopenshell::geometry::settings::OutputDimensionalityTypes & ioo) -> std::istream
|
|
__rshift__(std::istream & _in, ifcopenshell::geometry::settings::IteratorOutputOptions & ioo) -> std::istream
|
|
__rshift__(std::istream & _in, ifcopenshell::geometry::settings::FunctionStepMethod & ioo) -> std::istream
|
|
__rshift__(std::istream & _in, ifcopenshell::geometry::settings::TriangulationMethod & ioo) -> std::istream &
|
|
"""
|
|
return _ifcopenshell_wrapper.__rshift__(*args)
|
|
class MakeVolume(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::settings::MakeVolume class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
name = _ifcopenshell_wrapper.MakeVolume_name
|
|
|
|
description = _ifcopenshell_wrapper.MakeVolume_description
|
|
|
|
defaultvalue = _ifcopenshell_wrapper.MakeVolume_defaultvalue
|
|
|
|
|
|
def __init__(self):
|
|
r"""__init__(MakeVolume self) -> MakeVolume"""
|
|
_ifcopenshell_wrapper.MakeVolume_swiginit(self, _ifcopenshell_wrapper.new_MakeVolume())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_MakeVolume
|
|
|
|
# Register MakeVolume in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.MakeVolume_swigregister(MakeVolume)
|
|
class Settings(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::Settings class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def set_(self, *args):
|
|
r"""
|
|
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):
|
|
r"""get_(Settings self, std::string const & name) -> ifcopenshell::geometry::Settings::value_variant_t"""
|
|
return _ifcopenshell_wrapper.Settings_get_(self, name)
|
|
|
|
def setting_names(self):
|
|
r"""setting_names(Settings self) -> std::vector< std::string,std::allocator< std::string > >"""
|
|
return _ifcopenshell_wrapper.Settings_setting_names(self)
|
|
|
|
def get_type(self, name):
|
|
r"""get_type(Settings self, std::string const & name) -> std::string"""
|
|
return _ifcopenshell_wrapper.Settings_get_type(self, name)
|
|
|
|
def __init__(self):
|
|
r"""__init__(Settings self) -> Settings"""
|
|
_ifcopenshell_wrapper.Settings_swiginit(self, _ifcopenshell_wrapper.new_Settings())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_Settings
|
|
|
|
# Register Settings in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.Settings_swigregister(Settings)
|
|
class Transformation(object):
|
|
r"""Proxy of C++ IfcGeom::Transformation class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, settings, matrix):
|
|
r"""__init__(Transformation self, Settings settings, ifcopenshell::geometry::taxonomy::matrix4::ptr const & matrix) -> Transformation"""
|
|
_ifcopenshell_wrapper.Transformation_swiginit(self, _ifcopenshell_wrapper.new_Transformation(settings, matrix))
|
|
|
|
def data(self):
|
|
r"""data(Transformation self) -> ifcopenshell::geometry::taxonomy::matrix4::ptr const &"""
|
|
return _ifcopenshell_wrapper.Transformation_data(self)
|
|
|
|
def matrix_(self):
|
|
r"""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
|
|
|
|
# Register Transformation in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.Transformation_swigregister(Transformation)
|
|
class Element(object):
|
|
r"""Proxy of C++ IfcGeom::Element class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def id(self):
|
|
r"""id(Element self) -> int"""
|
|
return _ifcopenshell_wrapper.Element_id(self)
|
|
|
|
def parent_id(self):
|
|
r"""parent_id(Element self) -> int"""
|
|
return _ifcopenshell_wrapper.Element_parent_id(self)
|
|
|
|
def name(self):
|
|
r"""name(Element self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.Element_name(self)
|
|
|
|
def type(self):
|
|
r"""type(Element self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.Element_type(self)
|
|
|
|
def guid(self):
|
|
r"""guid(Element self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.Element_guid(self)
|
|
|
|
def context(self):
|
|
r"""context(Element self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.Element_context(self)
|
|
|
|
def unique_id(self):
|
|
r"""unique_id(Element self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.Element_unique_id(self)
|
|
|
|
def transformation(self):
|
|
r"""transformation(Element self) -> Transformation"""
|
|
return _ifcopenshell_wrapper.Element_transformation(self)
|
|
|
|
def product(self):
|
|
r"""product(Element self) -> IfcBaseEntity"""
|
|
return _ifcopenshell_wrapper.Element_product(self)
|
|
|
|
def parents(self):
|
|
r"""parents(Element self) -> std::vector< IfcGeom::Element const *,std::allocator< IfcGeom::Element const * > > const &"""
|
|
return _ifcopenshell_wrapper.Element_parents(self)
|
|
|
|
def SetParents(self, newparents):
|
|
r"""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):
|
|
r"""__init__(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"""
|
|
_ifcopenshell_wrapper.Element_swiginit(self, _ifcopenshell_wrapper.new_Element(settings, id, parent_id, name, type, guid, context, trsf, product))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_Element
|
|
|
|
def transformation_buffer(self):
|
|
r"""transformation_buffer(Element self) -> std::pair< char const *,size_t >"""
|
|
return _ifcopenshell_wrapper.Element_transformation_buffer(self)
|
|
|
|
def product_(self):
|
|
r"""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)
|
|
|
|
|
|
# Register Element in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.Element_swigregister(Element)
|
|
|
|
def __eq__(element1, element2):
|
|
r"""__eq__(Element element1, Element element2) -> bool"""
|
|
return _ifcopenshell_wrapper.__eq__(element1, element2)
|
|
|
|
def __lt__(element1, element2):
|
|
r"""__lt__(Element element1, Element element2) -> bool"""
|
|
return _ifcopenshell_wrapper.__lt__(element1, element2)
|
|
|
|
class BRepElement(Element):
|
|
r"""Proxy of C++ IfcGeom::BRepElement class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def geometry_pointer(self):
|
|
r"""geometry_pointer(BRepElement self) -> boost::shared_ptr< IfcGeom::Representation::BRep > const &"""
|
|
return _ifcopenshell_wrapper.BRepElement_geometry_pointer(self)
|
|
|
|
def geometry(self):
|
|
r"""geometry(BRepElement self) -> BRep"""
|
|
return _ifcopenshell_wrapper.BRepElement_geometry(self)
|
|
|
|
def __init__(self, id, parent_id, name, type, guid, context, trsf, geometry, product):
|
|
r"""__init__(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"""
|
|
_ifcopenshell_wrapper.BRepElement_swiginit(self, _ifcopenshell_wrapper.new_BRepElement(id, parent_id, name, type, guid, context, trsf, geometry, product))
|
|
|
|
def calculate_projected_surface_area(self, along_x, along_y, along_z):
|
|
r"""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):
|
|
r"""calc_volume_(BRepElement self) -> double"""
|
|
return _ifcopenshell_wrapper.BRepElement_calc_volume_(self)
|
|
|
|
def calc_surface_area_(self):
|
|
r"""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
|
|
|
|
# Register BRepElement in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.BRepElement_swigregister(BRepElement)
|
|
class TriangulationElement(Element):
|
|
r"""Proxy of C++ IfcGeom::TriangulationElement class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def geometry(self):
|
|
r"""geometry(TriangulationElement self) -> Triangulation"""
|
|
return _ifcopenshell_wrapper.TriangulationElement_geometry(self)
|
|
|
|
def geometry_pointer(self):
|
|
r"""geometry_pointer(TriangulationElement self) -> boost::shared_ptr< IfcGeom::Representation::Triangulation > const &"""
|
|
return _ifcopenshell_wrapper.TriangulationElement_geometry_pointer(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(TriangulationElement self, BRepElement shape_model) -> TriangulationElement
|
|
__init__(TriangulationElement self, Element element, boost::shared_ptr< IfcGeom::Representation::Triangulation > const & geometry) -> TriangulationElement
|
|
"""
|
|
_ifcopenshell_wrapper.TriangulationElement_swiginit(self, _ifcopenshell_wrapper.new_TriangulationElement(*args))
|
|
|
|
# Hide the getters with read-only property implementations
|
|
geometry = property(geometry)
|
|
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_TriangulationElement
|
|
|
|
# Register TriangulationElement in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.TriangulationElement_swigregister(TriangulationElement)
|
|
class SerializedElement(Element):
|
|
r"""Proxy of C++ IfcGeom::SerializedElement class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def geometry(self):
|
|
r"""geometry(SerializedElement self) -> Serialization"""
|
|
return _ifcopenshell_wrapper.SerializedElement_geometry(self)
|
|
|
|
def __init__(self, shape_model):
|
|
r"""__init__(SerializedElement self, BRepElement shape_model) -> SerializedElement"""
|
|
_ifcopenshell_wrapper.SerializedElement_swiginit(self, _ifcopenshell_wrapper.new_SerializedElement(shape_model))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_SerializedElement
|
|
|
|
# Hide the getters with read-only property implementations
|
|
geometry = property(geometry)
|
|
|
|
|
|
# Register SerializedElement in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.SerializedElement_swigregister(SerializedElement)
|
|
class Representation(object):
|
|
r"""Proxy of C++ IfcGeom::Representation::Representation class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, settings, entity, id):
|
|
r"""__init__(Representation self, Settings settings, std::string const & entity, std::string const & id) -> Representation"""
|
|
_ifcopenshell_wrapper.Representation_swiginit(self, _ifcopenshell_wrapper.new_Representation(settings, entity, id))
|
|
|
|
def settings(self):
|
|
r"""settings(Representation self) -> Settings"""
|
|
return _ifcopenshell_wrapper.Representation_settings(self)
|
|
|
|
def entity(self):
|
|
r"""entity(Representation self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.Representation_entity(self)
|
|
|
|
def id(self):
|
|
r"""id(Representation self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.Representation_id(self)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_Representation
|
|
|
|
# Hide the getters with read-only property implementations
|
|
id = property(id)
|
|
|
|
|
|
# Register Representation in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.Representation_swigregister(Representation)
|
|
class BRep(Representation):
|
|
r"""Proxy of C++ IfcGeom::Representation::BRep class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, settings, entity, id, shapes):
|
|
r"""__init__(BRep self, Settings settings, std::string const & entity, std::string const & id, IfcGeom::ConversionResults const & shapes) -> BRep"""
|
|
_ifcopenshell_wrapper.BRep_swiginit(self, _ifcopenshell_wrapper.new_BRep(settings, entity, id, shapes))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_BRep
|
|
|
|
def begin(self):
|
|
r"""begin(BRep self) -> IfcGeom::ConversionResults::const_iterator"""
|
|
return _ifcopenshell_wrapper.BRep_begin(self)
|
|
|
|
def end(self):
|
|
r"""end(BRep self) -> IfcGeom::ConversionResults::const_iterator"""
|
|
return _ifcopenshell_wrapper.BRep_end(self)
|
|
|
|
def shapes(self):
|
|
r"""shapes(BRep self) -> IfcGeom::ConversionResults const &"""
|
|
return _ifcopenshell_wrapper.BRep_shapes(self)
|
|
|
|
def as_compound(self, force_meters=False):
|
|
r"""as_compound(BRep self, bool force_meters=False) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.BRep_as_compound(self, force_meters)
|
|
|
|
def calculate_volume(self, arg2):
|
|
r"""calculate_volume(BRep self, double & arg2) -> bool"""
|
|
return _ifcopenshell_wrapper.BRep_calculate_volume(self, arg2)
|
|
|
|
def calculate_surface_area(self, arg2):
|
|
r"""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):
|
|
r"""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):
|
|
r"""size(BRep self) -> int"""
|
|
return _ifcopenshell_wrapper.BRep_size(self)
|
|
|
|
def item(self, i):
|
|
r"""item(BRep self, int i) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.BRep_item(self, i)
|
|
|
|
def item_id(self, i):
|
|
r"""item_id(BRep self, int i) -> int"""
|
|
return _ifcopenshell_wrapper.BRep_item_id(self, i)
|
|
|
|
# Register BRep in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.BRep_swigregister(BRep)
|
|
class Serialization(Representation):
|
|
r"""Proxy of C++ IfcGeom::Representation::Serialization class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def brep_data(self):
|
|
r"""brep_data(Serialization self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.Serialization_brep_data(self)
|
|
|
|
def surface_styles(self):
|
|
r"""surface_styles(Serialization self) -> std::vector< double,std::allocator< double > > const &"""
|
|
return _ifcopenshell_wrapper.Serialization_surface_styles(self)
|
|
|
|
def surface_style_ids(self):
|
|
r"""surface_style_ids(Serialization self) -> std::vector< int,std::allocator< int > > const &"""
|
|
return _ifcopenshell_wrapper.Serialization_surface_style_ids(self)
|
|
|
|
def __init__(self, brep):
|
|
r"""__init__(Serialization self, BRep brep) -> Serialization"""
|
|
_ifcopenshell_wrapper.Serialization_swiginit(self, _ifcopenshell_wrapper.new_Serialization(brep))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_Serialization
|
|
|
|
# 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)
|
|
|
|
|
|
# Register Serialization in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.Serialization_swigregister(Serialization)
|
|
class Triangulation(Representation):
|
|
r"""Proxy of C++ IfcGeom::Representation::Triangulation class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def verts(self):
|
|
r"""verts(Triangulation self) -> std::vector< double,std::allocator< double > > const &"""
|
|
return _ifcopenshell_wrapper.Triangulation_verts(self)
|
|
|
|
def faces(self):
|
|
r"""faces(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
|
|
return _ifcopenshell_wrapper.Triangulation_faces(self)
|
|
|
|
def polyhedral_faces_without_holes(self):
|
|
r"""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):
|
|
r"""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):
|
|
r"""edges(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
|
|
return _ifcopenshell_wrapper.Triangulation_edges(self)
|
|
|
|
def normals(self):
|
|
r"""normals(Triangulation self) -> std::vector< double,std::allocator< double > > const &"""
|
|
return _ifcopenshell_wrapper.Triangulation_normals(self)
|
|
|
|
def uvs(self):
|
|
r"""uvs(Triangulation self) -> std::vector< double,std::allocator< double > > const &"""
|
|
return _ifcopenshell_wrapper.Triangulation_uvs(self)
|
|
|
|
def uvs_ref(self):
|
|
r"""uvs_ref(Triangulation self) -> std::vector< double,std::allocator< double > > &"""
|
|
return _ifcopenshell_wrapper.Triangulation_uvs_ref(self)
|
|
|
|
def material_ids(self):
|
|
r"""material_ids(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
|
|
return _ifcopenshell_wrapper.Triangulation_material_ids(self)
|
|
|
|
def materials(self):
|
|
r"""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):
|
|
r"""item_ids(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
|
|
return _ifcopenshell_wrapper.Triangulation_item_ids(self)
|
|
|
|
def edges_item_ids(self):
|
|
r"""edges_item_ids(Triangulation self) -> std::vector< int,std::allocator< int > > const &"""
|
|
return _ifcopenshell_wrapper.Triangulation_edges_item_ids(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(Triangulation self, BRep shape_model) -> Triangulation
|
|
__init__(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
|
|
"""
|
|
_ifcopenshell_wrapper.Triangulation_swiginit(self, _ifcopenshell_wrapper.new_Triangulation(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_Triangulation
|
|
|
|
@staticmethod
|
|
def box_project_uvs(vertices, normals):
|
|
r"""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)
|
|
|
|
@staticmethod
|
|
def empty(settings):
|
|
r"""empty(Settings settings) -> Triangulation"""
|
|
return _ifcopenshell_wrapper.Triangulation_empty(settings)
|
|
|
|
def addVertex(self, item_index, material_index, X, Y, Z):
|
|
r"""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):
|
|
r"""addNormal(Triangulation self, double X, double Y, double Z)"""
|
|
return _ifcopenshell_wrapper.Triangulation_addNormal(self, X, Y, Z)
|
|
|
|
def addFace(self, *args):
|
|
r"""
|
|
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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""resetWelds(Triangulation self)"""
|
|
return _ifcopenshell_wrapper.Triangulation_resetWelds(self)
|
|
|
|
def faces_buffer(self):
|
|
r"""faces_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
|
|
return _ifcopenshell_wrapper.Triangulation_faces_buffer(self)
|
|
|
|
def edges_buffer(self):
|
|
r"""edges_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
|
|
return _ifcopenshell_wrapper.Triangulation_edges_buffer(self)
|
|
|
|
def material_ids_buffer(self):
|
|
r"""material_ids_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
|
|
return _ifcopenshell_wrapper.Triangulation_material_ids_buffer(self)
|
|
|
|
def item_ids_buffer(self):
|
|
r"""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):
|
|
r"""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):
|
|
r"""verts_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
|
|
return _ifcopenshell_wrapper.Triangulation_verts_buffer(self)
|
|
|
|
def normals_buffer(self):
|
|
r"""normals_buffer(Triangulation self) -> std::pair< char const *,size_t >"""
|
|
return _ifcopenshell_wrapper.Triangulation_normals_buffer(self)
|
|
|
|
def colors_buffer(self):
|
|
r"""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)
|
|
|
|
|
|
# Register Triangulation in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.Triangulation_swigregister(Triangulation)
|
|
class geometry_conversion_result(object):
|
|
r"""Proxy of C++ IfcGeom::geometry_conversion_result class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
index = property(_ifcopenshell_wrapper.geometry_conversion_result_index_get, _ifcopenshell_wrapper.geometry_conversion_result_index_set, doc=r"""index : int""")
|
|
item = property(_ifcopenshell_wrapper.geometry_conversion_result_item_get, _ifcopenshell_wrapper.geometry_conversion_result_item_set, doc=r"""item : ifcopenshell::geometry::taxonomy::ptr""")
|
|
products = property(_ifcopenshell_wrapper.geometry_conversion_result_products_get, _ifcopenshell_wrapper.geometry_conversion_result_products_set, doc=r"""products : std::vector<(std::pair<(p.IfcUtil::IfcBaseEntity,ifcopenshell::geometry::taxonomy::matrix4::ptr)>,std::allocator<(std::pair<(p.IfcUtil::IfcBaseEntity,ifcopenshell::geometry::taxonomy::matrix4::ptr)>)>)>""")
|
|
representation = property(_ifcopenshell_wrapper.geometry_conversion_result_representation_get, _ifcopenshell_wrapper.geometry_conversion_result_representation_set, doc=r"""representation : p.IfcUtil::IfcBaseEntity""")
|
|
products_2 = property(_ifcopenshell_wrapper.geometry_conversion_result_products_2_get, _ifcopenshell_wrapper.geometry_conversion_result_products_2_set, doc=r"""products_2 : aggregate_of_instance::ptr""")
|
|
breps = property(_ifcopenshell_wrapper.geometry_conversion_result_breps_get, _ifcopenshell_wrapper.geometry_conversion_result_breps_set, doc=r"""breps : std::vector<(p.IfcGeom::BRepElement,std::allocator<(p.IfcGeom::BRepElement)>)>""")
|
|
elements = property(_ifcopenshell_wrapper.geometry_conversion_result_elements_get, _ifcopenshell_wrapper.geometry_conversion_result_elements_set, doc=r"""elements : std::vector<(p.IfcGeom::Element,std::allocator<(p.IfcGeom::Element)>)>""")
|
|
|
|
def __init__(self):
|
|
r"""__init__(geometry_conversion_result self) -> geometry_conversion_result"""
|
|
_ifcopenshell_wrapper.geometry_conversion_result_swiginit(self, _ifcopenshell_wrapper.new_geometry_conversion_result())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_geometry_conversion_result
|
|
|
|
# Register geometry_conversion_result in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.geometry_conversion_result_swigregister(geometry_conversion_result)
|
|
class Iterator(object):
|
|
r"""Proxy of C++ IfcGeom::Iterator class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(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__(Iterator self, std::unique_ptr< ifcopenshell::geometry::kernels::AbstractKernel > && geometry_library, Settings settings, file file) -> Iterator
|
|
__init__(Iterator self, std::unique_ptr< ifcopenshell::geometry::kernels::AbstractKernel > && geometry_library, Settings settings, file file, int num_threads) -> Iterator
|
|
"""
|
|
_ifcopenshell_wrapper.Iterator_swiginit(self, _ifcopenshell_wrapper.new_Iterator(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_Iterator
|
|
|
|
def set_cache(self, cache):
|
|
r"""set_cache(Iterator self, GeometrySerializer cache)"""
|
|
return _ifcopenshell_wrapper.Iterator_set_cache(self, cache)
|
|
|
|
def get_task_items(self):
|
|
r"""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):
|
|
r"""get_task_products(Iterator self) -> aggregate_of_aggregate_of_instance::ptr"""
|
|
return _ifcopenshell_wrapper.Iterator_get_task_products(self)
|
|
|
|
def unit_name(self):
|
|
r"""unit_name(Iterator self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.Iterator_unit_name(self)
|
|
|
|
def unit_magnitude(self):
|
|
r"""unit_magnitude(Iterator self) -> double"""
|
|
return _ifcopenshell_wrapper.Iterator_unit_magnitude(self)
|
|
|
|
def had_error_processing_elements(self):
|
|
r"""had_error_processing_elements(Iterator self) -> bool"""
|
|
return _ifcopenshell_wrapper.Iterator_had_error_processing_elements(self)
|
|
initialization_outcome_ = property(_ifcopenshell_wrapper.Iterator_initialization_outcome__get, _ifcopenshell_wrapper.Iterator_initialization_outcome__set, doc=r"""initialization_outcome_ : boost::optional<(bool)>""")
|
|
|
|
def initialize(self):
|
|
r"""initialize(Iterator self) -> bool"""
|
|
return _ifcopenshell_wrapper.Iterator_initialize(self)
|
|
processed_ = property(_ifcopenshell_wrapper.Iterator_processed__get, _ifcopenshell_wrapper.Iterator_processed__set, doc=r"""processed_ : size_t""")
|
|
|
|
def process_finished_rep(self, rep):
|
|
r"""process_finished_rep(Iterator self, geometry_conversion_result rep)"""
|
|
return _ifcopenshell_wrapper.Iterator_process_finished_rep(self, rep)
|
|
|
|
def process_concurrently(self):
|
|
r"""process_concurrently(Iterator self)"""
|
|
return _ifcopenshell_wrapper.Iterator_process_concurrently(self)
|
|
|
|
def compute_bounds(self, with_geometry):
|
|
r"""compute_bounds(Iterator self, bool with_geometry)"""
|
|
return _ifcopenshell_wrapper.Iterator_compute_bounds(self, with_geometry)
|
|
|
|
def progress(self):
|
|
r"""progress(Iterator self) -> int"""
|
|
return _ifcopenshell_wrapper.Iterator_progress(self)
|
|
|
|
def getLog(self):
|
|
r"""getLog(Iterator self) -> std::string"""
|
|
return _ifcopenshell_wrapper.Iterator_getLog(self)
|
|
|
|
def file(self):
|
|
r"""file(Iterator self) -> file"""
|
|
return _ifcopenshell_wrapper.Iterator_file(self)
|
|
|
|
def filters(self, *args):
|
|
r"""
|
|
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):
|
|
r"""bounds_min(Iterator self) -> point3"""
|
|
return _ifcopenshell_wrapper.Iterator_bounds_min(self)
|
|
|
|
def bounds_max(self):
|
|
r"""bounds_max(Iterator self) -> point3"""
|
|
return _ifcopenshell_wrapper.Iterator_bounds_max(self)
|
|
|
|
def next(self):
|
|
r"""next(Iterator self) -> entity_instance"""
|
|
return _ifcopenshell_wrapper.Iterator_next(self)
|
|
|
|
def get(self):
|
|
r"""get(Iterator self) -> Element"""
|
|
return _ifcopenshell_wrapper.Iterator_get(self)
|
|
|
|
def get_native(self):
|
|
r"""get_native(Iterator self) -> BRepElement"""
|
|
return _ifcopenshell_wrapper.Iterator_get_native(self)
|
|
|
|
def get_object(self, id):
|
|
r"""get_object(Iterator self, int id) -> Element"""
|
|
return _ifcopenshell_wrapper.Iterator_get_object(self, id)
|
|
|
|
def create(self):
|
|
r"""create(Iterator self) -> entity_instance"""
|
|
return _ifcopenshell_wrapper.Iterator_create(self)
|
|
|
|
# Register Iterator in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.Iterator_swigregister(Iterator)
|
|
class SerializerSettings(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::SerializerSettings class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def set_(self, *args):
|
|
r"""
|
|
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):
|
|
r"""get_(SerializerSettings self, std::string const & name) -> ifcopenshell::geometry::SerializerSettings::value_variant_t"""
|
|
return _ifcopenshell_wrapper.SerializerSettings_get_(self, name)
|
|
|
|
def setting_names(self):
|
|
r"""setting_names(SerializerSettings self) -> std::vector< std::string,std::allocator< std::string > >"""
|
|
return _ifcopenshell_wrapper.SerializerSettings_setting_names(self)
|
|
|
|
def get_type(self, name):
|
|
r"""get_type(SerializerSettings self, std::string const & name) -> std::string"""
|
|
return _ifcopenshell_wrapper.SerializerSettings_get_type(self, name)
|
|
|
|
def __init__(self):
|
|
r"""__init__(SerializerSettings self) -> SerializerSettings"""
|
|
_ifcopenshell_wrapper.SerializerSettings_swiginit(self, _ifcopenshell_wrapper.new_SerializerSettings())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_SerializerSettings
|
|
|
|
# Register SerializerSettings in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.SerializerSettings_swigregister(SerializerSettings)
|
|
class buffer(object):
|
|
r"""Proxy of C++ stream_or_filename class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(buffer self, std::string const & fn) -> buffer
|
|
__init__(buffer self) -> buffer
|
|
"""
|
|
_ifcopenshell_wrapper.buffer_swiginit(self, _ifcopenshell_wrapper.new_buffer(*args))
|
|
|
|
def get_value(self):
|
|
r"""get_value(buffer self) -> std::string"""
|
|
return _ifcopenshell_wrapper.buffer_get_value(self)
|
|
|
|
def filename(self):
|
|
r"""filename(buffer self) -> boost::optional< std::string >"""
|
|
return _ifcopenshell_wrapper.buffer_filename(self)
|
|
|
|
def is_ready(self):
|
|
r"""is_ready(buffer self) -> bool"""
|
|
return _ifcopenshell_wrapper.buffer_is_ready(self)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_buffer
|
|
|
|
# Register buffer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.buffer_swigregister(buffer)
|
|
class GeometrySerializer(object):
|
|
r"""Proxy of C++ GeometrySerializer class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
READ_BREP = _ifcopenshell_wrapper.GeometrySerializer_READ_BREP
|
|
|
|
READ_TRIANGULATION = _ifcopenshell_wrapper.GeometrySerializer_READ_TRIANGULATION
|
|
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_GeometrySerializer
|
|
|
|
def isTesselated(self):
|
|
r"""isTesselated(GeometrySerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.GeometrySerializer_isTesselated(self)
|
|
|
|
def write(self, *args):
|
|
r"""
|
|
write(GeometrySerializer self, TriangulationElement o)
|
|
write(GeometrySerializer self, BRepElement o)
|
|
"""
|
|
return _ifcopenshell_wrapper.GeometrySerializer_write(self, *args)
|
|
|
|
def setUnitNameAndMagnitude(self, name, magnitude):
|
|
r"""setUnitNameAndMagnitude(GeometrySerializer self, std::string const & name, float magnitude)"""
|
|
return _ifcopenshell_wrapper.GeometrySerializer_setUnitNameAndMagnitude(self, name, magnitude)
|
|
|
|
def read(self, *args):
|
|
r"""read(GeometrySerializer self, file f, std::string const & guid, std::string const & representation_id, GeometrySerializer::read_type rt=READ_BREP) -> Element"""
|
|
return _ifcopenshell_wrapper.GeometrySerializer_read(self, *args)
|
|
|
|
def settings(self, *args):
|
|
r"""
|
|
settings(GeometrySerializer self) -> SerializerSettings
|
|
settings(GeometrySerializer self) -> SerializerSettings
|
|
"""
|
|
return _ifcopenshell_wrapper.GeometrySerializer_settings(self, *args)
|
|
|
|
def geometry_settings(self, *args):
|
|
r"""
|
|
geometry_settings(GeometrySerializer self) -> Settings
|
|
geometry_settings(GeometrySerializer self) -> Settings
|
|
"""
|
|
return _ifcopenshell_wrapper.GeometrySerializer_geometry_settings(self, *args)
|
|
|
|
def object_id(self, o):
|
|
r"""object_id(GeometrySerializer self, Element o) -> std::string"""
|
|
return _ifcopenshell_wrapper.GeometrySerializer_object_id(self, o)
|
|
|
|
# Register GeometrySerializer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.GeometrySerializer_swigregister(GeometrySerializer)
|
|
class WriteOnlyGeometrySerializer(GeometrySerializer):
|
|
r"""Proxy of C++ WriteOnlyGeometrySerializer class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def read(self, *args):
|
|
r"""read(WriteOnlyGeometrySerializer self, file arg2, std::string const & arg3, std::string const & arg4, GeometrySerializer::read_type arg5=READ_BREP) -> Element"""
|
|
return _ifcopenshell_wrapper.WriteOnlyGeometrySerializer_read(self, *args)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_WriteOnlyGeometrySerializer
|
|
|
|
# Register WriteOnlyGeometrySerializer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.WriteOnlyGeometrySerializer_swigregister(WriteOnlyGeometrySerializer)
|
|
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):
|
|
r"""kind_to_string(ifcopenshell::geometry::taxonomy::kinds k) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.kind_to_string(k)
|
|
class item(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::item class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
instance = property(_ifcopenshell_wrapper.item_instance_get, _ifcopenshell_wrapper.item_instance_set, doc=r"""instance : p.q(const).IfcUtil::IfcBaseInterface""")
|
|
orientation = property(_ifcopenshell_wrapper.item_orientation_get, _ifcopenshell_wrapper.item_orientation_set, doc=r"""orientation : boost::optional<(bool)>""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(item self) -> item"""
|
|
return _ifcopenshell_wrapper.item_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(item self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.item_kind(self)
|
|
|
|
def reverse(self):
|
|
r"""reverse(item self)"""
|
|
return _ifcopenshell_wrapper.item_reverse(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(item self) -> size_t"""
|
|
return _ifcopenshell_wrapper.item_calc_hash(self)
|
|
|
|
def hash(self):
|
|
r"""hash(item self) -> size_t"""
|
|
return _ifcopenshell_wrapper.item_hash(self)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_item
|
|
|
|
def identity(self):
|
|
r"""identity(item self) -> uint32_t"""
|
|
return _ifcopenshell_wrapper.item_identity(self)
|
|
|
|
# Register item in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.item_swigregister(item)
|
|
class matrix4(item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::matrix4 class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__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
|
|
|
|
tag = property(_ifcopenshell_wrapper.matrix4_tag_get, _ifcopenshell_wrapper.matrix4_tag_set, doc=r"""tag : ifcopenshell::geometry::taxonomy::matrix4::tag_t""")
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(matrix4 self) -> matrix4
|
|
__init__(matrix4 self, Eigen::Matrix4d const & c) -> matrix4
|
|
__init__(matrix4 self, Eigen::Vector3d const & o, Eigen::Vector3d const & z, Eigen::Vector3d const & x) -> matrix4
|
|
__init__(matrix4 self, Eigen::Vector3d const & o, Eigen::Vector3d const & z) -> matrix4
|
|
"""
|
|
_ifcopenshell_wrapper.matrix4_swiginit(self, _ifcopenshell_wrapper.new_matrix4(*args))
|
|
|
|
def is_identity(self):
|
|
r"""is_identity(matrix4 self) -> bool"""
|
|
return _ifcopenshell_wrapper.matrix4_is_identity(self)
|
|
|
|
def clone_(self):
|
|
r"""clone_(matrix4 self) -> matrix4"""
|
|
return _ifcopenshell_wrapper.matrix4_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(matrix4 self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.matrix4_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(matrix4 self) -> size_t"""
|
|
return _ifcopenshell_wrapper.matrix4_calc_hash(self)
|
|
|
|
def pre_multiply_scale(self, s):
|
|
r"""pre_multiply_scale(matrix4 self, double s)"""
|
|
return _ifcopenshell_wrapper.matrix4_pre_multiply_scale(self, s)
|
|
|
|
def post_multiply_scale(self, s):
|
|
r"""post_multiply_scale(matrix4 self, double s)"""
|
|
return _ifcopenshell_wrapper.matrix4_post_multiply_scale(self, s)
|
|
|
|
def translation_part(self):
|
|
r"""translation_part(matrix4 self) -> Eigen::Vector3d"""
|
|
return _ifcopenshell_wrapper.matrix4_translation_part(self)
|
|
|
|
def components_(self):
|
|
r"""components_(matrix4 self) -> PyObject *"""
|
|
return _ifcopenshell_wrapper.matrix4_components_(self)
|
|
|
|
components = property(components_)
|
|
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_matrix4
|
|
|
|
# Register matrix4 in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.matrix4_swigregister(matrix4)
|
|
class colour(item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::colour class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def clone_(self):
|
|
r"""clone_(colour self) -> colour"""
|
|
return _ifcopenshell_wrapper.colour_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(colour self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.colour_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(colour self) -> size_t"""
|
|
return _ifcopenshell_wrapper.colour_calc_hash(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(colour self) -> colour
|
|
__init__(colour self, double r, double g, double b) -> colour
|
|
"""
|
|
_ifcopenshell_wrapper.colour_swiginit(self, _ifcopenshell_wrapper.new_colour(*args))
|
|
|
|
def r(self):
|
|
r"""r(colour self) -> double const &"""
|
|
return _ifcopenshell_wrapper.colour_r(self)
|
|
|
|
def g(self):
|
|
r"""g(colour self) -> double const &"""
|
|
return _ifcopenshell_wrapper.colour_g(self)
|
|
|
|
def b(self):
|
|
r"""b(colour self) -> double const &"""
|
|
return _ifcopenshell_wrapper.colour_b(self)
|
|
|
|
def components_(self):
|
|
r"""components_(colour self) -> PyObject *"""
|
|
return _ifcopenshell_wrapper.colour_components_(self)
|
|
|
|
components = property(components_)
|
|
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_colour
|
|
|
|
# Register colour in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.colour_swigregister(colour)
|
|
class style(item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::style class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
name = property(_ifcopenshell_wrapper.style_name_get, _ifcopenshell_wrapper.style_name_set, doc=r"""name : std::string""")
|
|
diffuse = property(_ifcopenshell_wrapper.style_diffuse_get, _ifcopenshell_wrapper.style_diffuse_set, doc=r"""diffuse : ifcopenshell::geometry::taxonomy::colour""")
|
|
surface = property(_ifcopenshell_wrapper.style_surface_get, _ifcopenshell_wrapper.style_surface_set, doc=r"""surface : ifcopenshell::geometry::taxonomy::colour""")
|
|
specular = property(_ifcopenshell_wrapper.style_specular_get, _ifcopenshell_wrapper.style_specular_set, doc=r"""specular : ifcopenshell::geometry::taxonomy::colour""")
|
|
specularity = property(_ifcopenshell_wrapper.style_specularity_get, _ifcopenshell_wrapper.style_specularity_set, doc=r"""specularity : double""")
|
|
transparency = property(_ifcopenshell_wrapper.style_transparency_get, _ifcopenshell_wrapper.style_transparency_set, doc=r"""transparency : double""")
|
|
use_surface_color = property(_ifcopenshell_wrapper.style_use_surface_color_get, _ifcopenshell_wrapper.style_use_surface_color_set, doc=r"""use_surface_color : bool""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(style self) -> style"""
|
|
return _ifcopenshell_wrapper.style_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(style self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.style_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(style self) -> size_t"""
|
|
return _ifcopenshell_wrapper.style_calc_hash(self)
|
|
|
|
def __eq__(self, other):
|
|
r"""__eq__(style self, style other) -> bool"""
|
|
return _ifcopenshell_wrapper.style___eq__(self, other)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(style self) -> style
|
|
__init__(style self, std::string const & name) -> style
|
|
"""
|
|
_ifcopenshell_wrapper.style_swiginit(self, _ifcopenshell_wrapper.new_style(*args))
|
|
|
|
def get_color(self):
|
|
r"""get_color(style self) -> colour"""
|
|
return _ifcopenshell_wrapper.style_get_color(self)
|
|
|
|
def has_specularity(self):
|
|
r"""has_specularity(style self) -> bool"""
|
|
return _ifcopenshell_wrapper.style_has_specularity(self)
|
|
|
|
def has_transparency(self):
|
|
r"""has_transparency(style self) -> bool"""
|
|
return _ifcopenshell_wrapper.style_has_transparency(self)
|
|
|
|
def instance_id(self):
|
|
r"""instance_id(style self) -> size_t"""
|
|
return _ifcopenshell_wrapper.style_instance_id(self)
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_style
|
|
|
|
# Register style in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.style_swigregister(style)
|
|
class geom_item(item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::geom_item class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
surface_style = property(_ifcopenshell_wrapper.geom_item_surface_style_get, _ifcopenshell_wrapper.geom_item_surface_style_set, doc=r"""surface_style : ifcopenshell::geometry::taxonomy::style::ptr""")
|
|
matrix = property(_ifcopenshell_wrapper.geom_item_matrix_get, _ifcopenshell_wrapper.geom_item_matrix_set, doc=r"""matrix : ifcopenshell::geometry::taxonomy::matrix4::ptr""")
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_geom_item
|
|
|
|
# Register geom_item in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.geom_item_swigregister(geom_item)
|
|
class implicit_item(geom_item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::implicit_item class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_implicit_item
|
|
|
|
# Register implicit_item in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.implicit_item_swigregister(implicit_item)
|
|
class function_item(implicit_item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::function_item class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_function_item
|
|
|
|
def start(self):
|
|
r"""start(function_item self) -> double"""
|
|
return _ifcopenshell_wrapper.function_item_start(self)
|
|
|
|
def end(self):
|
|
r"""end(function_item self) -> double"""
|
|
return _ifcopenshell_wrapper.function_item_end(self)
|
|
|
|
def length(self):
|
|
r"""length(function_item self) -> double"""
|
|
return _ifcopenshell_wrapper.function_item_length(self)
|
|
|
|
def kind(self):
|
|
r"""kind(function_item self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.function_item_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(function_item self) -> size_t"""
|
|
return _ifcopenshell_wrapper.function_item_calc_hash(self)
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
|
|
# Register function_item in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.function_item_swigregister(function_item)
|
|
class functor_item(function_item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::functor_item class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(functor_item self, double length, std::function< Eigen::Matrix4d (double) > fn, IfcUtil::IfcBaseInterface const * instance=None) -> functor_item
|
|
__init__(functor_item self, functor_item arg2) -> functor_item
|
|
__init__(functor_item self, functor_item arg2) -> functor_item
|
|
"""
|
|
_ifcopenshell_wrapper.functor_item_swiginit(self, _ifcopenshell_wrapper.new_functor_item(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_functor_item
|
|
|
|
def start(self):
|
|
r"""start(functor_item self) -> double"""
|
|
return _ifcopenshell_wrapper.functor_item_start(self)
|
|
|
|
def end(self):
|
|
r"""end(functor_item self) -> double"""
|
|
return _ifcopenshell_wrapper.functor_item_end(self)
|
|
|
|
def __call__(self, u):
|
|
r"""__call__(functor_item self, double u) -> Eigen::Matrix4d"""
|
|
return _ifcopenshell_wrapper.functor_item___call__(self, u)
|
|
|
|
def clone_(self):
|
|
r"""clone_(functor_item self) -> functor_item"""
|
|
return _ifcopenshell_wrapper.functor_item_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(functor_item self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.functor_item_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(functor_item self) -> size_t"""
|
|
return _ifcopenshell_wrapper.functor_item_calc_hash(self)
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
|
|
# Register functor_item in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.functor_item_swigregister(functor_item)
|
|
class piecewise_function(function_item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::piecewise_function class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(piecewise_function self, double start, ifcopenshell::geometry::taxonomy::piecewise_function::spans_t const & s, IfcUtil::IfcBaseInterface const * instance=None) -> piecewise_function
|
|
__init__(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__(piecewise_function self, piecewise_function arg2) -> piecewise_function
|
|
__init__(piecewise_function self, piecewise_function arg2) -> piecewise_function
|
|
"""
|
|
_ifcopenshell_wrapper.piecewise_function_swiginit(self, _ifcopenshell_wrapper.new_piecewise_function(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_piecewise_function
|
|
|
|
def spans(self):
|
|
r"""spans(piecewise_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::spans_t const &"""
|
|
return _ifcopenshell_wrapper.piecewise_function_spans(self)
|
|
|
|
def span_count(self):
|
|
r"""span_count(piecewise_function self) -> size_t"""
|
|
return _ifcopenshell_wrapper.piecewise_function_span_count(self)
|
|
|
|
def span_fn(self, i):
|
|
r"""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):
|
|
r"""is_empty(piecewise_function self) -> bool"""
|
|
return _ifcopenshell_wrapper.piecewise_function_is_empty(self)
|
|
|
|
def start(self):
|
|
r"""start(piecewise_function self) -> double"""
|
|
return _ifcopenshell_wrapper.piecewise_function_start(self)
|
|
|
|
def end(self):
|
|
r"""end(piecewise_function self) -> double"""
|
|
return _ifcopenshell_wrapper.piecewise_function_end(self)
|
|
|
|
def length(self):
|
|
r"""length(piecewise_function self) -> double"""
|
|
return _ifcopenshell_wrapper.piecewise_function_length(self)
|
|
|
|
def clone_(self):
|
|
r"""clone_(piecewise_function self) -> piecewise_function"""
|
|
return _ifcopenshell_wrapper.piecewise_function_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(piecewise_function self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.piecewise_function_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(piecewise_function self) -> size_t"""
|
|
return _ifcopenshell_wrapper.piecewise_function_calc_hash(self)
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
|
|
# Register piecewise_function in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.piecewise_function_swigregister(piecewise_function)
|
|
class gradient_function(function_item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::gradient_function class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(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__(gradient_function self, gradient_function arg2) -> gradient_function
|
|
__init__(gradient_function self, gradient_function arg2) -> gradient_function
|
|
"""
|
|
_ifcopenshell_wrapper.gradient_function_swiginit(self, _ifcopenshell_wrapper.new_gradient_function(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_gradient_function
|
|
|
|
def start(self):
|
|
r"""start(gradient_function self) -> double"""
|
|
return _ifcopenshell_wrapper.gradient_function_start(self)
|
|
|
|
def end(self):
|
|
r"""end(gradient_function self) -> double"""
|
|
return _ifcopenshell_wrapper.gradient_function_end(self)
|
|
|
|
def get_horizontal(self):
|
|
r"""get_horizontal(gradient_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr"""
|
|
return _ifcopenshell_wrapper.gradient_function_get_horizontal(self)
|
|
|
|
def get_vertical(self):
|
|
r"""get_vertical(gradient_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr"""
|
|
return _ifcopenshell_wrapper.gradient_function_get_vertical(self)
|
|
|
|
def clone_(self):
|
|
r"""clone_(gradient_function self) -> gradient_function"""
|
|
return _ifcopenshell_wrapper.gradient_function_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(gradient_function self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.gradient_function_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(gradient_function self) -> size_t"""
|
|
return _ifcopenshell_wrapper.gradient_function_calc_hash(self)
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
|
|
# Register gradient_function in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.gradient_function_swigregister(gradient_function)
|
|
class cant_function(function_item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::cant_function class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(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__(cant_function self, cant_function arg2) -> cant_function
|
|
__init__(cant_function self, cant_function arg2) -> cant_function
|
|
"""
|
|
_ifcopenshell_wrapper.cant_function_swiginit(self, _ifcopenshell_wrapper.new_cant_function(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_cant_function
|
|
|
|
def start(self):
|
|
r"""start(cant_function self) -> double"""
|
|
return _ifcopenshell_wrapper.cant_function_start(self)
|
|
|
|
def end(self):
|
|
r"""end(cant_function self) -> double"""
|
|
return _ifcopenshell_wrapper.cant_function_end(self)
|
|
|
|
def get_gradient(self):
|
|
r"""get_gradient(cant_function self) -> ifcopenshell::geometry::taxonomy::gradient_function::const_ptr"""
|
|
return _ifcopenshell_wrapper.cant_function_get_gradient(self)
|
|
|
|
def get_cant(self):
|
|
r"""get_cant(cant_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr"""
|
|
return _ifcopenshell_wrapper.cant_function_get_cant(self)
|
|
|
|
def clone_(self):
|
|
r"""clone_(cant_function self) -> cant_function"""
|
|
return _ifcopenshell_wrapper.cant_function_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(cant_function self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.cant_function_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(cant_function self) -> size_t"""
|
|
return _ifcopenshell_wrapper.cant_function_calc_hash(self)
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
|
|
# Register cant_function in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.cant_function_swigregister(cant_function)
|
|
class offset_function(function_item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::offset_function class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(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__(offset_function self, offset_function arg2) -> offset_function
|
|
__init__(offset_function self, offset_function arg2) -> offset_function
|
|
"""
|
|
_ifcopenshell_wrapper.offset_function_swiginit(self, _ifcopenshell_wrapper.new_offset_function(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_offset_function
|
|
|
|
def start(self):
|
|
r"""start(offset_function self) -> double"""
|
|
return _ifcopenshell_wrapper.offset_function_start(self)
|
|
|
|
def end(self):
|
|
r"""end(offset_function self) -> double"""
|
|
return _ifcopenshell_wrapper.offset_function_end(self)
|
|
|
|
def get_basis(self):
|
|
r"""get_basis(offset_function self) -> ifcopenshell::geometry::taxonomy::function_item::const_ptr"""
|
|
return _ifcopenshell_wrapper.offset_function_get_basis(self)
|
|
|
|
def get_offset(self):
|
|
r"""get_offset(offset_function self) -> ifcopenshell::geometry::taxonomy::piecewise_function::const_ptr"""
|
|
return _ifcopenshell_wrapper.offset_function_get_offset(self)
|
|
|
|
def clone_(self):
|
|
r"""clone_(offset_function self) -> offset_function"""
|
|
return _ifcopenshell_wrapper.offset_function_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(offset_function self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.offset_function_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(offset_function self) -> size_t"""
|
|
return _ifcopenshell_wrapper.offset_function_calc_hash(self)
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
|
|
# Register offset_function in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.offset_function_swigregister(offset_function)
|
|
|
|
def less(arg1, arg2):
|
|
r"""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):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::less_functor class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __call__(self, a, b):
|
|
r"""__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):
|
|
r"""__init__(less_functor self) -> less_functor"""
|
|
_ifcopenshell_wrapper.less_functor_swiginit(self, _ifcopenshell_wrapper.new_less_functor())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_less_functor
|
|
|
|
# Register less_functor in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.less_functor_swigregister(less_functor)
|
|
class equal_functor(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::equal_functor class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __call__(self, a, b):
|
|
r"""__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):
|
|
r"""__init__(equal_functor self) -> equal_functor"""
|
|
_ifcopenshell_wrapper.equal_functor_swiginit(self, _ifcopenshell_wrapper.new_equal_functor())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_equal_functor
|
|
|
|
# Register equal_functor in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.equal_functor_swigregister(equal_functor)
|
|
class hash_functor(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::hash_functor class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __call__(self, a):
|
|
r"""__call__(hash_functor self, ifcopenshell::geometry::taxonomy::item::ptr const & a) -> size_t"""
|
|
return _ifcopenshell_wrapper.hash_functor___call__(self, a)
|
|
|
|
def __init__(self):
|
|
r"""__init__(hash_functor self) -> hash_functor"""
|
|
_ifcopenshell_wrapper.hash_functor_swiginit(self, _ifcopenshell_wrapper.new_hash_functor())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_hash_functor
|
|
|
|
# Register hash_functor in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.hash_functor_swigregister(hash_functor)
|
|
class point3(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::point3 class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def clone_(self):
|
|
r"""clone_(point3 self) -> point3"""
|
|
return _ifcopenshell_wrapper.point3_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(point3 self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.point3_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(point3 self) -> size_t"""
|
|
return _ifcopenshell_wrapper.point3_calc_hash(self)
|
|
|
|
def _print(self, o, indent=0):
|
|
r"""_print(point3 self, std::ostream & o, int indent=0)"""
|
|
return _ifcopenshell_wrapper.point3__print(self, o, indent)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(point3 self) -> point3
|
|
__init__(point3 self, Eigen::Vector3d const & c) -> point3
|
|
__init__(point3 self, double x, double y, double z=0.) -> point3
|
|
"""
|
|
_ifcopenshell_wrapper.point3_swiginit(self, _ifcopenshell_wrapper.new_point3(*args))
|
|
|
|
def components_(self):
|
|
r"""components_(point3 self) -> PyObject *"""
|
|
return _ifcopenshell_wrapper.point3_components_(self)
|
|
|
|
components = property(components_)
|
|
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_point3
|
|
|
|
# Register point3 in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.point3_swigregister(point3)
|
|
class direction3(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::direction3 class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def clone_(self):
|
|
r"""clone_(direction3 self) -> direction3"""
|
|
return _ifcopenshell_wrapper.direction3_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(direction3 self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.direction3_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(direction3 self) -> size_t"""
|
|
return _ifcopenshell_wrapper.direction3_calc_hash(self)
|
|
|
|
def _print(self, o, indent=0):
|
|
r"""_print(direction3 self, std::ostream & o, int indent=0)"""
|
|
return _ifcopenshell_wrapper.direction3__print(self, o, indent)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(direction3 self) -> direction3
|
|
__init__(direction3 self, Eigen::Vector3d const & c) -> direction3
|
|
__init__(direction3 self, double x, double y, double z=0.) -> direction3
|
|
"""
|
|
_ifcopenshell_wrapper.direction3_swiginit(self, _ifcopenshell_wrapper.new_direction3(*args))
|
|
|
|
def components_(self):
|
|
r"""components_(direction3 self) -> PyObject *"""
|
|
return _ifcopenshell_wrapper.direction3_components_(self)
|
|
|
|
components = property(components_)
|
|
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_direction3
|
|
|
|
# Register direction3 in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.direction3_swigregister(direction3)
|
|
class curve(geom_item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::curve class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def print_impl(self, o, classname, indent=0):
|
|
r"""print_impl(curve self, std::ostream & o, std::string const & classname, int indent=0)"""
|
|
return _ifcopenshell_wrapper.curve_print_impl(self, o, classname, indent)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_curve
|
|
|
|
# Register curve in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.curve_swigregister(curve)
|
|
class line(curve):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::line class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def clone_(self):
|
|
r"""clone_(line self) -> line"""
|
|
return _ifcopenshell_wrapper.line_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(line self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.line_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(line self) -> size_t"""
|
|
return _ifcopenshell_wrapper.line_calc_hash(self)
|
|
|
|
def matrix_(self):
|
|
r"""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):
|
|
r"""__init__(line self) -> line"""
|
|
_ifcopenshell_wrapper.line_swiginit(self, _ifcopenshell_wrapper.new_line())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_line
|
|
|
|
# Register line in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.line_swigregister(line)
|
|
class circle(curve):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::circle class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
radius = property(_ifcopenshell_wrapper.circle_radius_get, _ifcopenshell_wrapper.circle_radius_set, doc=r"""radius : double""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(circle self) -> circle"""
|
|
return _ifcopenshell_wrapper.circle_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(circle self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.circle_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(circle self) -> size_t"""
|
|
return _ifcopenshell_wrapper.circle_calc_hash(self)
|
|
|
|
@staticmethod
|
|
def from_3_points(p1, p2, p3):
|
|
r"""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)
|
|
|
|
def matrix_(self):
|
|
r"""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):
|
|
r"""__init__(circle self) -> circle"""
|
|
_ifcopenshell_wrapper.circle_swiginit(self, _ifcopenshell_wrapper.new_circle())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_circle
|
|
|
|
# Register circle in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.circle_swigregister(circle)
|
|
class ellipse(curve):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::ellipse class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
radius = property(_ifcopenshell_wrapper.ellipse_radius_get, _ifcopenshell_wrapper.ellipse_radius_set, doc=r"""radius : double""")
|
|
radius2 = property(_ifcopenshell_wrapper.ellipse_radius2_get, _ifcopenshell_wrapper.ellipse_radius2_set, doc=r"""radius2 : double""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(ellipse self) -> ellipse"""
|
|
return _ifcopenshell_wrapper.ellipse_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(ellipse self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.ellipse_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(ellipse self) -> size_t"""
|
|
return _ifcopenshell_wrapper.ellipse_calc_hash(self)
|
|
|
|
def matrix_(self):
|
|
r"""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):
|
|
r"""__init__(ellipse self) -> ellipse"""
|
|
_ifcopenshell_wrapper.ellipse_swiginit(self, _ifcopenshell_wrapper.new_ellipse())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_ellipse
|
|
|
|
# Register ellipse in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.ellipse_swigregister(ellipse)
|
|
class bspline_curve(curve):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::bspline_curve class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def clone_(self):
|
|
r"""clone_(bspline_curve self) -> bspline_curve"""
|
|
return _ifcopenshell_wrapper.bspline_curve_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(bspline_curve self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.bspline_curve_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(bspline_curve self) -> size_t"""
|
|
return _ifcopenshell_wrapper.bspline_curve_calc_hash(self)
|
|
control_points = property(_ifcopenshell_wrapper.bspline_curve_control_points_get, _ifcopenshell_wrapper.bspline_curve_control_points_set, doc=r"""control_points : std::vector<(ifcopenshell::geometry::taxonomy::point3::ptr,std::allocator<(ifcopenshell::geometry::taxonomy::point3::ptr)>)>""")
|
|
multiplicities = property(_ifcopenshell_wrapper.bspline_curve_multiplicities_get, _ifcopenshell_wrapper.bspline_curve_multiplicities_set, doc=r"""multiplicities : std::vector<(int,std::allocator<(int)>)>""")
|
|
knots = property(_ifcopenshell_wrapper.bspline_curve_knots_get, _ifcopenshell_wrapper.bspline_curve_knots_set, doc=r"""knots : std::vector<(double,std::allocator<(double)>)>""")
|
|
weights = property(_ifcopenshell_wrapper.bspline_curve_weights_get, _ifcopenshell_wrapper.bspline_curve_weights_set, doc=r"""weights : boost::optional<(std::vector<(double,std::allocator<(double)>)>)>""")
|
|
degree = property(_ifcopenshell_wrapper.bspline_curve_degree_get, _ifcopenshell_wrapper.bspline_curve_degree_set, doc=r"""degree : int""")
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
|
|
def __init__(self):
|
|
r"""__init__(bspline_curve self) -> bspline_curve"""
|
|
_ifcopenshell_wrapper.bspline_curve_swiginit(self, _ifcopenshell_wrapper.new_bspline_curve())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_bspline_curve
|
|
|
|
# Register bspline_curve in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.bspline_curve_swigregister(bspline_curve)
|
|
class offset_curve(curve):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::offset_curve class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
reference = property(_ifcopenshell_wrapper.offset_curve_reference_get, _ifcopenshell_wrapper.offset_curve_reference_set, doc=r"""reference : ifcopenshell::geometry::taxonomy::direction3::ptr""")
|
|
offset = property(_ifcopenshell_wrapper.offset_curve_offset_get, _ifcopenshell_wrapper.offset_curve_offset_set, doc=r"""offset : double""")
|
|
basis = property(_ifcopenshell_wrapper.offset_curve_basis_get, _ifcopenshell_wrapper.offset_curve_basis_set, doc=r"""basis : ifcopenshell::geometry::taxonomy::item::ptr""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(offset_curve self) -> offset_curve"""
|
|
return _ifcopenshell_wrapper.offset_curve_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(offset_curve self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.offset_curve_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(offset_curve self) -> size_t"""
|
|
return _ifcopenshell_wrapper.offset_curve_calc_hash(self)
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
|
|
def __init__(self):
|
|
r"""__init__(offset_curve self) -> offset_curve"""
|
|
_ifcopenshell_wrapper.offset_curve_swiginit(self, _ifcopenshell_wrapper.new_offset_curve())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_offset_curve
|
|
|
|
# Register offset_curve in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.offset_curve_swigregister(offset_curve)
|
|
class trimmed_curve(geom_item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::trimmed_curve class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
start = property(_ifcopenshell_wrapper.trimmed_curve_start_get, _ifcopenshell_wrapper.trimmed_curve_start_set, doc=r"""start : boost::variant<(boost::blank,ifcopenshell::geometry::taxonomy::point3::ptr,double)>""")
|
|
end = property(_ifcopenshell_wrapper.trimmed_curve_end_get, _ifcopenshell_wrapper.trimmed_curve_end_set, doc=r"""end : boost::variant<(boost::blank,ifcopenshell::geometry::taxonomy::point3::ptr,double)>""")
|
|
basis = property(_ifcopenshell_wrapper.trimmed_curve_basis_get, _ifcopenshell_wrapper.trimmed_curve_basis_set, doc=r"""basis : ifcopenshell::geometry::taxonomy::item::ptr""")
|
|
curve_sense = property(_ifcopenshell_wrapper.trimmed_curve_curve_sense_get, _ifcopenshell_wrapper.trimmed_curve_curve_sense_set, doc=r"""curve_sense : boost::optional<(bool)>""")
|
|
|
|
def reverse(self):
|
|
r"""reverse(trimmed_curve self)"""
|
|
return _ifcopenshell_wrapper.trimmed_curve_reverse(self)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_trimmed_curve
|
|
|
|
# Register trimmed_curve in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.trimmed_curve_swigregister(trimmed_curve)
|
|
class edge(trimmed_curve):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::edge class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(edge self) -> edge
|
|
__init__(edge self, ifcopenshell::geometry::taxonomy::point3::ptr const & a, ifcopenshell::geometry::taxonomy::point3::ptr const & b) -> edge
|
|
"""
|
|
_ifcopenshell_wrapper.edge_swiginit(self, _ifcopenshell_wrapper.new_edge(*args))
|
|
|
|
def clone_(self):
|
|
r"""clone_(edge self) -> edge"""
|
|
return _ifcopenshell_wrapper.edge_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(edge self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.edge_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(edge self) -> size_t"""
|
|
return _ifcopenshell_wrapper.edge_calc_hash(self)
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_edge
|
|
|
|
# Register edge in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.edge_swigregister(edge)
|
|
class collection(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::collection class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def clone_(self):
|
|
r"""clone_(collection self) -> collection"""
|
|
return _ifcopenshell_wrapper.collection_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(collection self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.collection_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(collection self) -> size_t"""
|
|
return _ifcopenshell_wrapper.collection_calc_hash(self)
|
|
|
|
def children_(self):
|
|
r"""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):
|
|
r"""__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):
|
|
r"""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):
|
|
r"""__init__(collection self) -> collection"""
|
|
_ifcopenshell_wrapper.collection_swiginit(self, _ifcopenshell_wrapper.new_collection())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_collection
|
|
|
|
# Register collection in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.collection_swigregister(collection)
|
|
class loop(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::loop class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
external = property(_ifcopenshell_wrapper.loop_external_get, _ifcopenshell_wrapper.loop_external_set, doc=r"""external : boost::optional<(bool)>""")
|
|
closed = property(_ifcopenshell_wrapper.loop_closed_get, _ifcopenshell_wrapper.loop_closed_set, doc=r"""closed : boost::optional<(bool)>""")
|
|
function_item = property(_ifcopenshell_wrapper.loop_function_item_get, _ifcopenshell_wrapper.loop_function_item_set, doc=r"""function_item : boost::optional<(ifcopenshell::geometry::taxonomy::function_item::ptr)>""")
|
|
tags = property(_ifcopenshell_wrapper.loop_tags_get, _ifcopenshell_wrapper.loop_tags_set, doc=r"""tags : boost::optional<(std::vector<(std::string,std::allocator<(std::string)>)>)>""")
|
|
|
|
def is_polyhedron(self):
|
|
r"""is_polyhedron(loop self) -> bool"""
|
|
return _ifcopenshell_wrapper.loop_is_polyhedron(self)
|
|
|
|
def calculate_linear_edge_curves(self):
|
|
r"""calculate_linear_edge_curves(loop self)"""
|
|
return _ifcopenshell_wrapper.loop_calculate_linear_edge_curves(self)
|
|
|
|
def remove_linear_edge_curves(self):
|
|
r"""remove_linear_edge_curves(loop self)"""
|
|
return _ifcopenshell_wrapper.loop_remove_linear_edge_curves(self)
|
|
|
|
def clone_(self):
|
|
r"""clone_(loop self) -> loop"""
|
|
return _ifcopenshell_wrapper.loop_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(loop self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.loop_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(loop self) -> size_t"""
|
|
return _ifcopenshell_wrapper.loop_calc_hash(self)
|
|
|
|
def centroid(self):
|
|
r"""centroid(loop self) -> ifcopenshell::geometry::taxonomy::point3::ptr"""
|
|
return _ifcopenshell_wrapper.loop_centroid(self)
|
|
|
|
def children_(self):
|
|
r"""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):
|
|
r"""__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):
|
|
r"""__init__(loop self) -> loop"""
|
|
_ifcopenshell_wrapper.loop_swiginit(self, _ifcopenshell_wrapper.new_loop())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_loop
|
|
|
|
# Register loop in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.loop_swigregister(loop)
|
|
class face(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::face class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
basis = property(_ifcopenshell_wrapper.face_basis_get, _ifcopenshell_wrapper.face_basis_set, doc=r"""basis : ifcopenshell::geometry::taxonomy::item::ptr""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(face self) -> face"""
|
|
return _ifcopenshell_wrapper.face_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(face self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.face_kind(self)
|
|
|
|
def print_impl(self, o, indent):
|
|
r"""print_impl(face self, std::ostream & o, int indent)"""
|
|
return _ifcopenshell_wrapper.face_print_impl(self, o, indent)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(face self) -> size_t"""
|
|
return _ifcopenshell_wrapper.face_calc_hash(self)
|
|
|
|
def children_(self):
|
|
r"""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):
|
|
r"""__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):
|
|
r"""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):
|
|
r"""__init__(face self) -> face"""
|
|
_ifcopenshell_wrapper.face_swiginit(self, _ifcopenshell_wrapper.new_face())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_face
|
|
|
|
# Register face in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.face_swigregister(face)
|
|
class shell(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::shell class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
closed = property(_ifcopenshell_wrapper.shell_closed_get, _ifcopenshell_wrapper.shell_closed_set, doc=r"""closed : boost::optional<(bool)>""")
|
|
|
|
def print_impl(self, o, indent):
|
|
r"""print_impl(shell self, std::ostream & o, int indent)"""
|
|
return _ifcopenshell_wrapper.shell_print_impl(self, o, indent)
|
|
|
|
def clone_(self):
|
|
r"""clone_(shell self) -> shell"""
|
|
return _ifcopenshell_wrapper.shell_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(shell self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.shell_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(shell self) -> size_t"""
|
|
return _ifcopenshell_wrapper.shell_calc_hash(self)
|
|
|
|
def centroid(self):
|
|
r"""centroid(shell self) -> ifcopenshell::geometry::taxonomy::point3::ptr"""
|
|
return _ifcopenshell_wrapper.shell_centroid(self)
|
|
|
|
def children_(self):
|
|
r"""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):
|
|
r"""__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):
|
|
r"""__init__(shell self) -> shell"""
|
|
_ifcopenshell_wrapper.shell_swiginit(self, _ifcopenshell_wrapper.new_shell())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_shell
|
|
|
|
# Register shell in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.shell_swigregister(shell)
|
|
class solid(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::solid class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def clone_(self):
|
|
r"""clone_(solid self) -> solid"""
|
|
return _ifcopenshell_wrapper.solid_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(solid self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.solid_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(solid self) -> size_t"""
|
|
return _ifcopenshell_wrapper.solid_calc_hash(self)
|
|
|
|
def children_(self):
|
|
r"""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):
|
|
r"""__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):
|
|
r"""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):
|
|
r"""__init__(solid self) -> solid"""
|
|
_ifcopenshell_wrapper.solid_swiginit(self, _ifcopenshell_wrapper.new_solid())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_solid
|
|
|
|
# Register solid in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.solid_swigregister(solid)
|
|
class loft(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::loft class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
axis = property(_ifcopenshell_wrapper.loft_axis_get, _ifcopenshell_wrapper.loft_axis_set, doc=r"""axis : ifcopenshell::geometry::taxonomy::item::ptr""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(loft self) -> loft"""
|
|
return _ifcopenshell_wrapper.loft_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(loft self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.loft_kind(self)
|
|
|
|
def print_impl(self, o, indent):
|
|
r"""print_impl(loft self, std::ostream & o, int indent)"""
|
|
return _ifcopenshell_wrapper.loft_print_impl(self, o, indent)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(loft self) -> size_t"""
|
|
return _ifcopenshell_wrapper.loft_calc_hash(self)
|
|
|
|
def children_(self):
|
|
r"""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):
|
|
r"""__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):
|
|
r"""__init__(loft self) -> loft"""
|
|
_ifcopenshell_wrapper.loft_swiginit(self, _ifcopenshell_wrapper.new_loft())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_loft
|
|
|
|
# Register loft in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.loft_swigregister(loft)
|
|
class surface(geom_item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::surface class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_surface
|
|
|
|
# Register surface in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.surface_swigregister(surface)
|
|
class plane(surface):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::plane class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def clone_(self):
|
|
r"""clone_(plane self) -> plane"""
|
|
return _ifcopenshell_wrapper.plane_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(plane self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.plane_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(plane self) -> size_t"""
|
|
return _ifcopenshell_wrapper.plane_calc_hash(self)
|
|
|
|
def matrix_(self):
|
|
r"""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):
|
|
r"""__init__(plane self) -> plane"""
|
|
_ifcopenshell_wrapper.plane_swiginit(self, _ifcopenshell_wrapper.new_plane())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_plane
|
|
|
|
# Register plane in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.plane_swigregister(plane)
|
|
class cylinder(surface):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::cylinder class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
radius = property(_ifcopenshell_wrapper.cylinder_radius_get, _ifcopenshell_wrapper.cylinder_radius_set, doc=r"""radius : double""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(cylinder self) -> cylinder"""
|
|
return _ifcopenshell_wrapper.cylinder_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(cylinder self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.cylinder_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(cylinder self) -> size_t"""
|
|
return _ifcopenshell_wrapper.cylinder_calc_hash(self)
|
|
|
|
def matrix_(self):
|
|
r"""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):
|
|
r"""__init__(cylinder self) -> cylinder"""
|
|
_ifcopenshell_wrapper.cylinder_swiginit(self, _ifcopenshell_wrapper.new_cylinder())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_cylinder
|
|
|
|
# Register cylinder in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.cylinder_swigregister(cylinder)
|
|
class sphere(surface):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::sphere class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
radius = property(_ifcopenshell_wrapper.sphere_radius_get, _ifcopenshell_wrapper.sphere_radius_set, doc=r"""radius : double""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(sphere self) -> sphere"""
|
|
return _ifcopenshell_wrapper.sphere_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(sphere self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.sphere_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(sphere self) -> size_t"""
|
|
return _ifcopenshell_wrapper.sphere_calc_hash(self)
|
|
|
|
def matrix_(self):
|
|
r"""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):
|
|
r"""__init__(sphere self) -> sphere"""
|
|
_ifcopenshell_wrapper.sphere_swiginit(self, _ifcopenshell_wrapper.new_sphere())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_sphere
|
|
|
|
# Register sphere in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.sphere_swigregister(sphere)
|
|
class torus(surface):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::torus class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
radius1 = property(_ifcopenshell_wrapper.torus_radius1_get, _ifcopenshell_wrapper.torus_radius1_set, doc=r"""radius1 : double""")
|
|
radius2 = property(_ifcopenshell_wrapper.torus_radius2_get, _ifcopenshell_wrapper.torus_radius2_set, doc=r"""radius2 : double""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(torus self) -> torus"""
|
|
return _ifcopenshell_wrapper.torus_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(torus self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.torus_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(torus self) -> size_t"""
|
|
return _ifcopenshell_wrapper.torus_calc_hash(self)
|
|
|
|
def matrix_(self):
|
|
r"""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):
|
|
r"""__init__(torus self) -> torus"""
|
|
_ifcopenshell_wrapper.torus_swiginit(self, _ifcopenshell_wrapper.new_torus())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_torus
|
|
|
|
# Register torus in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.torus_swigregister(torus)
|
|
class bspline_surface(surface):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::bspline_surface class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def clone_(self):
|
|
r"""clone_(bspline_surface self) -> bspline_surface"""
|
|
return _ifcopenshell_wrapper.bspline_surface_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(bspline_surface self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.bspline_surface_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(bspline_surface self) -> size_t"""
|
|
return _ifcopenshell_wrapper.bspline_surface_calc_hash(self)
|
|
control_points = property(_ifcopenshell_wrapper.bspline_surface_control_points_get, _ifcopenshell_wrapper.bspline_surface_control_points_set, doc=r"""control_points : std::vector<(std::vector<(ifcopenshell::geometry::taxonomy::point3::ptr,std::allocator<(ifcopenshell::geometry::taxonomy::point3::ptr)>)>,std::allocator<(std::vector<(ifcopenshell::geometry::taxonomy::point3::ptr,std::allocator<(ifcopenshell::geometry::taxonomy::point3::ptr)>)>)>)>""")
|
|
multiplicities = property(_ifcopenshell_wrapper.bspline_surface_multiplicities_get, _ifcopenshell_wrapper.bspline_surface_multiplicities_set, doc=r"""multiplicities : std::array<(std::vector<(int,std::allocator<(int)>)>,2)>""")
|
|
knots = property(_ifcopenshell_wrapper.bspline_surface_knots_get, _ifcopenshell_wrapper.bspline_surface_knots_set, doc=r"""knots : std::array<(std::vector<(double,std::allocator<(double)>)>,2)>""")
|
|
weights = property(_ifcopenshell_wrapper.bspline_surface_weights_get, _ifcopenshell_wrapper.bspline_surface_weights_set, doc=r"""weights : boost::optional<(std::vector<(std::vector<(double,std::allocator<(double)>)>,std::allocator<(std::vector<(double,std::allocator<(double)>)>)>)>)>""")
|
|
degree = property(_ifcopenshell_wrapper.bspline_surface_degree_get, _ifcopenshell_wrapper.bspline_surface_degree_set, doc=r"""degree : std::array<(int,2)>""")
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
|
|
def __init__(self):
|
|
r"""__init__(bspline_surface self) -> bspline_surface"""
|
|
_ifcopenshell_wrapper.bspline_surface_swiginit(self, _ifcopenshell_wrapper.new_bspline_surface())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_bspline_surface
|
|
|
|
# Register bspline_surface in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.bspline_surface_swigregister(bspline_surface)
|
|
class sweep(geom_item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::sweep class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
basis = property(_ifcopenshell_wrapper.sweep_basis_get, _ifcopenshell_wrapper.sweep_basis_set, doc=r"""basis : ifcopenshell::geometry::taxonomy::item::ptr""")
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_sweep
|
|
|
|
# Register sweep in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.sweep_swigregister(sweep)
|
|
class extrusion(sweep):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::extrusion class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
direction = property(_ifcopenshell_wrapper.extrusion_direction_get, _ifcopenshell_wrapper.extrusion_direction_set, doc=r"""direction : ifcopenshell::geometry::taxonomy::direction3::ptr""")
|
|
depth = property(_ifcopenshell_wrapper.extrusion_depth_get, _ifcopenshell_wrapper.extrusion_depth_set, doc=r"""depth : double""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(extrusion self) -> extrusion"""
|
|
return _ifcopenshell_wrapper.extrusion_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(extrusion self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.extrusion_kind(self)
|
|
|
|
def __init__(self, m, basis, dir, d):
|
|
r"""__init__(extrusion self, ifcopenshell::geometry::taxonomy::matrix4::ptr m, ifcopenshell::geometry::taxonomy::item::ptr basis, ifcopenshell::geometry::taxonomy::direction3::ptr dir, double d) -> extrusion"""
|
|
_ifcopenshell_wrapper.extrusion_swiginit(self, _ifcopenshell_wrapper.new_extrusion(m, basis, dir, d))
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(extrusion self) -> size_t"""
|
|
return _ifcopenshell_wrapper.extrusion_calc_hash(self)
|
|
|
|
def matrix_(self):
|
|
r"""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
|
|
|
|
# Register extrusion in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.extrusion_swigregister(extrusion)
|
|
class revolve(sweep):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::revolve class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
axis_origin = property(_ifcopenshell_wrapper.revolve_axis_origin_get, _ifcopenshell_wrapper.revolve_axis_origin_set, doc=r"""axis_origin : ifcopenshell::geometry::taxonomy::point3::ptr""")
|
|
direction = property(_ifcopenshell_wrapper.revolve_direction_get, _ifcopenshell_wrapper.revolve_direction_set, doc=r"""direction : ifcopenshell::geometry::taxonomy::direction3::ptr""")
|
|
angle = property(_ifcopenshell_wrapper.revolve_angle_get, _ifcopenshell_wrapper.revolve_angle_set, doc=r"""angle : boost::optional<(double)>""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(revolve self) -> revolve"""
|
|
return _ifcopenshell_wrapper.revolve_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(revolve self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.revolve_kind(self)
|
|
|
|
def __init__(self, m, basis, pnt, dir, a):
|
|
r"""__init__(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"""
|
|
_ifcopenshell_wrapper.revolve_swiginit(self, _ifcopenshell_wrapper.new_revolve(m, basis, pnt, dir, a))
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(revolve self) -> size_t"""
|
|
return _ifcopenshell_wrapper.revolve_calc_hash(self)
|
|
|
|
def matrix_(self):
|
|
r"""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
|
|
|
|
# Register revolve in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.revolve_swigregister(revolve)
|
|
class sweep_along_curve(sweep):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::sweep_along_curve class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
surface = property(_ifcopenshell_wrapper.sweep_along_curve_surface_get, _ifcopenshell_wrapper.sweep_along_curve_surface_set, doc=r"""surface : ifcopenshell::geometry::taxonomy::item::ptr""")
|
|
curve = property(_ifcopenshell_wrapper.sweep_along_curve_curve_get, _ifcopenshell_wrapper.sweep_along_curve_curve_set, doc=r"""curve : ifcopenshell::geometry::taxonomy::item::ptr""")
|
|
direction = property(_ifcopenshell_wrapper.sweep_along_curve_direction_get, _ifcopenshell_wrapper.sweep_along_curve_direction_set, doc=r"""direction : ifcopenshell::geometry::taxonomy::direction3::ptr""")
|
|
|
|
def clone_(self):
|
|
r"""clone_(sweep_along_curve self) -> sweep_along_curve"""
|
|
return _ifcopenshell_wrapper.sweep_along_curve_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(sweep_along_curve self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.sweep_along_curve_kind(self)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(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__(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
|
|
"""
|
|
_ifcopenshell_wrapper.sweep_along_curve_swiginit(self, _ifcopenshell_wrapper.new_sweep_along_curve(*args))
|
|
|
|
def calc_hash(self):
|
|
r"""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
|
|
|
|
# Register sweep_along_curve in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.sweep_along_curve_swigregister(sweep_along_curve)
|
|
class node(item):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::node class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def clone_(self):
|
|
r"""clone_(node self) -> node"""
|
|
return _ifcopenshell_wrapper.node_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(node self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.node_kind(self)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(node self) -> size_t"""
|
|
return _ifcopenshell_wrapper.node_calc_hash(self)
|
|
|
|
__repr__ = taxonomy_item_repr
|
|
|
|
|
|
def __init__(self):
|
|
r"""__init__(node self) -> node"""
|
|
_ifcopenshell_wrapper.node_swiginit(self, _ifcopenshell_wrapper.new_node())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_node
|
|
|
|
# Register node in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.node_swigregister(node)
|
|
class boolean_result(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::boolean_result class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
UNION = _ifcopenshell_wrapper.boolean_result_UNION
|
|
|
|
SUBTRACTION = _ifcopenshell_wrapper.boolean_result_SUBTRACTION
|
|
|
|
INTERSECTION = _ifcopenshell_wrapper.boolean_result_INTERSECTION
|
|
|
|
|
|
def clone_(self):
|
|
r"""clone_(boolean_result self) -> boolean_result"""
|
|
return _ifcopenshell_wrapper.boolean_result_clone_(self)
|
|
|
|
def kind(self):
|
|
r"""kind(boolean_result self) -> ifcopenshell::geometry::taxonomy::kinds"""
|
|
return _ifcopenshell_wrapper.boolean_result_kind(self)
|
|
operation = property(_ifcopenshell_wrapper.boolean_result_operation_get, _ifcopenshell_wrapper.boolean_result_operation_set, doc=r"""operation : ifcopenshell::geometry::taxonomy::boolean_result::operation_t""")
|
|
|
|
@staticmethod
|
|
def operation_str(op):
|
|
r"""operation_str(ifcopenshell::geometry::taxonomy::boolean_result::operation_t op) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.boolean_result_operation_str(op)
|
|
|
|
def calc_hash(self):
|
|
r"""calc_hash(boolean_result self) -> size_t"""
|
|
return _ifcopenshell_wrapper.boolean_result_calc_hash(self)
|
|
|
|
def children_(self):
|
|
r"""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):
|
|
r"""__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):
|
|
r"""__init__(boolean_result self) -> boolean_result"""
|
|
_ifcopenshell_wrapper.boolean_result_swiginit(self, _ifcopenshell_wrapper.new_boolean_result())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_boolean_result
|
|
|
|
# Register boolean_result in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.boolean_result_swigregister(boolean_result)
|
|
class type_by_kind(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::taxonomy::type_by_kind class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
max = _ifcopenshell_wrapper.type_by_kind_max
|
|
|
|
|
|
def __init__(self):
|
|
r"""__init__(type_by_kind self) -> type_by_kind"""
|
|
_ifcopenshell_wrapper.type_by_kind_swiginit(self, _ifcopenshell_wrapper.new_type_by_kind())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_type_by_kind
|
|
|
|
# Register type_by_kind in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.type_by_kind_swigregister(type_by_kind)
|
|
|
|
def flatten(deep):
|
|
r"""flatten(ifcopenshell::geometry::taxonomy::collection::ptr const & deep) -> ifcopenshell::geometry::taxonomy::collection::ptr"""
|
|
return _ifcopenshell_wrapper.flatten(deep)
|
|
|
|
def create_box(*args):
|
|
r"""
|
|
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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""Proxy of C++ ifcopenshell::geometry::fn_evaluator class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_fn_evaluator
|
|
|
|
def clone(self):
|
|
r"""clone(fn_evaluator self) -> fn_evaluator"""
|
|
return _ifcopenshell_wrapper.fn_evaluator_clone(self)
|
|
|
|
def evaluate(self, u):
|
|
r"""evaluate(fn_evaluator self, double u) -> Eigen::Matrix4d"""
|
|
return _ifcopenshell_wrapper.fn_evaluator_evaluate(self, u)
|
|
|
|
def start(self):
|
|
r"""start(fn_evaluator self) -> double"""
|
|
return _ifcopenshell_wrapper.fn_evaluator_start(self)
|
|
|
|
def end(self):
|
|
r"""end(fn_evaluator self) -> double"""
|
|
return _ifcopenshell_wrapper.fn_evaluator_end(self)
|
|
|
|
def length(self):
|
|
r"""length(fn_evaluator self) -> double"""
|
|
return _ifcopenshell_wrapper.fn_evaluator_length(self)
|
|
settings_ = property(_ifcopenshell_wrapper.fn_evaluator_settings__get, _ifcopenshell_wrapper.fn_evaluator_settings__set, doc=r"""settings_ : ifcopenshell::geometry::Settings""")
|
|
|
|
# Register fn_evaluator in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.fn_evaluator_swigregister(fn_evaluator)
|
|
class function_item_evaluator(object):
|
|
r"""Proxy of C++ ifcopenshell::geometry::function_item_evaluator class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(function_item_evaluator self, Settings settings, ifcopenshell::geometry::taxonomy::function_item::const_ptr fn) -> function_item_evaluator
|
|
__init__(function_item_evaluator self, function_item_evaluator other) -> function_item_evaluator
|
|
"""
|
|
_ifcopenshell_wrapper.function_item_evaluator_swiginit(self, _ifcopenshell_wrapper.new_function_item_evaluator(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_function_item_evaluator
|
|
|
|
def evaluation_points(self, *args):
|
|
r"""
|
|
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):
|
|
r"""
|
|
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)
|
|
|
|
# Register function_item_evaluator in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.function_item_evaluator_swigregister(function_item_evaluator)
|
|
class horizontal_plan_at_element(object):
|
|
r"""Proxy of C++ horizontal_plan_at_element class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self):
|
|
r"""__init__(horizontal_plan_at_element self) -> horizontal_plan_at_element"""
|
|
_ifcopenshell_wrapper.horizontal_plan_at_element_swiginit(self, _ifcopenshell_wrapper.new_horizontal_plan_at_element())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_horizontal_plan_at_element
|
|
|
|
# Register horizontal_plan_at_element in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.horizontal_plan_at_element_swigregister(horizontal_plan_at_element)
|
|
class drawing_meta(object):
|
|
r"""Proxy of C++ drawing_meta class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
pln_3d = property(_ifcopenshell_wrapper.drawing_meta_pln_3d_get, _ifcopenshell_wrapper.drawing_meta_pln_3d_set, doc=r"""pln_3d : gp_Pln""")
|
|
matrix_3 = property(_ifcopenshell_wrapper.drawing_meta_matrix_3_get, _ifcopenshell_wrapper.drawing_meta_matrix_3_set, doc=r"""matrix_3 : std::array<(std::array<(double,3)>,3)>""")
|
|
|
|
def __init__(self):
|
|
r"""__init__(drawing_meta self) -> drawing_meta"""
|
|
_ifcopenshell_wrapper.drawing_meta_swiginit(self, _ifcopenshell_wrapper.new_drawing_meta())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_drawing_meta
|
|
|
|
# Register drawing_meta in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.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):
|
|
r"""Proxy of C++ SvgSerializer class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__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):
|
|
r"""__init__(SvgSerializer self, buffer out_filename, Settings geometry_settings, SerializerSettings settings) -> SvgSerializer"""
|
|
_ifcopenshell_wrapper.SvgSerializer_swiginit(self, _ifcopenshell_wrapper.new_SvgSerializer(out_filename, geometry_settings, settings))
|
|
|
|
def addXCoordinate(self, fi):
|
|
r"""addXCoordinate(SvgSerializer self, boost::shared_ptr< util::string_buffer::float_item > const & fi)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_addXCoordinate(self, fi)
|
|
|
|
def addYCoordinate(self, fi):
|
|
r"""addYCoordinate(SvgSerializer self, boost::shared_ptr< util::string_buffer::float_item > const & fi)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_addYCoordinate(self, fi)
|
|
|
|
def addSizeComponent(self, fi):
|
|
r"""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):
|
|
r"""growBoundingBox(SvgSerializer self, double x, double y)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_growBoundingBox(self, x, y)
|
|
|
|
def writeHeader(self):
|
|
r"""writeHeader(SvgSerializer self)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_writeHeader(self)
|
|
|
|
def doWriteHeader(self):
|
|
r"""doWriteHeader(SvgSerializer self)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_doWriteHeader(self)
|
|
|
|
def ready(self):
|
|
r"""ready(SvgSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_ready(self)
|
|
|
|
def write(self, *args):
|
|
r"""
|
|
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=boost::none)
|
|
write(SvgSerializer self, geometry_data const & data)
|
|
"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_write(self, *args)
|
|
|
|
def start_path(self, *args):
|
|
r"""
|
|
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):
|
|
r"""isTesselated(SvgSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_isTesselated(self)
|
|
|
|
def finalize(self):
|
|
r"""finalize(SvgSerializer self)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_finalize(self)
|
|
|
|
def setUnitNameAndMagnitude(self, arg2, arg3):
|
|
r"""setUnitNameAndMagnitude(SvgSerializer self, std::string const & arg2, float arg3)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setUnitNameAndMagnitude(self, arg2, arg3)
|
|
|
|
def setFile(self, f):
|
|
r"""setFile(SvgSerializer self, file f)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setFile(self, f)
|
|
|
|
def setBoundingRectangle(self, width, height):
|
|
r"""setBoundingRectangle(SvgSerializer self, double width, double height)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setBoundingRectangle(self, width, height)
|
|
|
|
def setSectionHeight(self, h, storey=None):
|
|
r"""setSectionHeight(SvgSerializer self, double h, IfcBaseEntity storey=None)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setSectionHeight(self, h, storey)
|
|
|
|
def setSectionHeightsFromStoreys(self, offset=1.2):
|
|
r"""setSectionHeightsFromStoreys(SvgSerializer self, double offset=1.2)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setSectionHeightsFromStoreys(self, offset)
|
|
|
|
def setPrintSpaceNames(self, b):
|
|
r"""setPrintSpaceNames(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setPrintSpaceNames(self, b)
|
|
|
|
def setPrintSpaceAreas(self, b):
|
|
r"""setPrintSpaceAreas(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setPrintSpaceAreas(self, b)
|
|
|
|
def setDrawStoreyHeights(self, sh):
|
|
r"""setDrawStoreyHeights(SvgSerializer self, SvgSerializer::storey_height_display_types sh)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setDrawStoreyHeights(self, sh)
|
|
|
|
def setDrawDoorArcs(self, b):
|
|
r"""setDrawDoorArcs(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setDrawDoorArcs(self, b)
|
|
|
|
def setStoreyHeightLineLength(self, d):
|
|
r"""setStoreyHeightLineLength(SvgSerializer self, double d)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setStoreyHeightLineLength(self, d)
|
|
|
|
def setSpaceNameTransform(self, v):
|
|
r"""setSpaceNameTransform(SvgSerializer self, std::string const & v)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setSpaceNameTransform(self, v)
|
|
|
|
def addTextAnnotations(self, k):
|
|
r"""addTextAnnotations(SvgSerializer self, drawing_key const & k)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_addTextAnnotations(self, k)
|
|
|
|
def resize(self):
|
|
r"""resize(SvgSerializer self) -> std::array< std::array< double,3 >,3 >"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_resize(self)
|
|
|
|
def resetScale(self):
|
|
r"""resetScale(SvgSerializer self)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_resetScale(self)
|
|
|
|
def setSectionRef(self, s):
|
|
r"""setSectionRef(SvgSerializer self, boost::optional< std::string > const & s)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setSectionRef(self, s)
|
|
|
|
def setElevationRef(self, s):
|
|
r"""setElevationRef(SvgSerializer self, boost::optional< std::string > const & s)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setElevationRef(self, s)
|
|
|
|
def setElevationRefGuid(self, s):
|
|
r"""setElevationRefGuid(SvgSerializer self, boost::optional< std::string > const & s)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setElevationRefGuid(self, s)
|
|
|
|
def setAutoSection(self, b):
|
|
r"""setAutoSection(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setAutoSection(self, b)
|
|
|
|
def setAutoElevation(self, b):
|
|
r"""setAutoElevation(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setAutoElevation(self, b)
|
|
|
|
def setUseNamespace(self, b):
|
|
r"""setUseNamespace(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setUseNamespace(self, b)
|
|
|
|
def setUseHlrPoly(self, b):
|
|
r"""setUseHlrPoly(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setUseHlrPoly(self, b)
|
|
|
|
def setUsePrefiltering(self, b):
|
|
r"""setUsePrefiltering(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setUsePrefiltering(self, b)
|
|
|
|
def getUsePrefiltering(self):
|
|
r"""getUsePrefiltering(SvgSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_getUsePrefiltering(self)
|
|
|
|
def setSegmentProjection(self, b):
|
|
r"""setSegmentProjection(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setSegmentProjection(self, b)
|
|
|
|
def getSegmentProjection(self):
|
|
r"""getSegmentProjection(SvgSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_getSegmentProjection(self)
|
|
|
|
def setPolygonal(self, b):
|
|
r"""setPolygonal(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setPolygonal(self, b)
|
|
|
|
def setAlwaysProject(self, b):
|
|
r"""setAlwaysProject(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setAlwaysProject(self, b)
|
|
|
|
def setWithoutStoreys(self, b):
|
|
r"""setWithoutStoreys(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setWithoutStoreys(self, b)
|
|
|
|
def setNoCSS(self, b):
|
|
r"""setNoCSS(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setNoCSS(self, b)
|
|
|
|
def setUnifyInputs(self, b):
|
|
r"""setUnifyInputs(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setUnifyInputs(self, b)
|
|
|
|
def getUnifyInputs(self):
|
|
r"""getUnifyInputs(SvgSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_getUnifyInputs(self)
|
|
|
|
def setOnlyValid(self, b):
|
|
r"""setOnlyValid(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setOnlyValid(self, b)
|
|
|
|
def getOnlyValid(self, b):
|
|
r"""getOnlyValid(SvgSerializer self, bool b) -> bool"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_getOnlyValid(self, b)
|
|
|
|
def setScale(self, s):
|
|
r"""setScale(SvgSerializer self, double s)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setScale(self, s)
|
|
|
|
def setDrawingCenter(self, x, y):
|
|
r"""setDrawingCenter(SvgSerializer self, double x, double y)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setDrawingCenter(self, x, y)
|
|
|
|
def nameElement(self, *args):
|
|
r"""
|
|
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):
|
|
r"""idElement(SvgSerializer self, IfcBaseEntity elem) -> std::string"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_idElement(self, elem)
|
|
|
|
def object_id(self, storey, o):
|
|
r"""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):
|
|
r"""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):
|
|
r"""setSubtractionSettings(SvgSerializer self, subtract_before_project sbp)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setSubtractionSettings(self, sbp)
|
|
|
|
def getSubtractionSettings(self):
|
|
r"""getSubtractionSettings(SvgSerializer self) -> subtract_before_project"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_getSubtractionSettings(self)
|
|
|
|
def setProfileThreshold(self, i):
|
|
r"""setProfileThreshold(SvgSerializer self, int i)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setProfileThreshold(self, i)
|
|
|
|
def getProfileThreshold(self):
|
|
r"""getProfileThreshold(SvgSerializer self) -> int"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_getProfileThreshold(self)
|
|
|
|
def setMirrorY(self, b):
|
|
r"""setMirrorY(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setMirrorY(self, b)
|
|
|
|
def getMirrorY(self):
|
|
r"""getMirrorY(SvgSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_getMirrorY(self)
|
|
|
|
def setMirrorX(self, b):
|
|
r"""setMirrorX(SvgSerializer self, bool b)"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_setMirrorX(self, b)
|
|
|
|
def getMirrorX(self):
|
|
r"""getMirrorX(SvgSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.SvgSerializer_getMirrorX(self)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_SvgSerializer
|
|
|
|
# Register SvgSerializer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.SvgSerializer_swigregister(SvgSerializer)
|
|
class HdfSerializer(GeometrySerializer):
|
|
r"""Proxy of C++ HdfSerializer class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, hdf_filename, geometry_settings, settings, read_only=False):
|
|
r"""__init__(HdfSerializer self, std::string const & hdf_filename, Settings geometry_settings, SerializerSettings settings, bool read_only=False) -> HdfSerializer"""
|
|
_ifcopenshell_wrapper.HdfSerializer_swiginit(self, _ifcopenshell_wrapper.new_HdfSerializer(hdf_filename, geometry_settings, settings, read_only))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_HdfSerializer
|
|
|
|
def ready(self):
|
|
r"""ready(HdfSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.HdfSerializer_ready(self)
|
|
|
|
def writeHeader(self):
|
|
r"""writeHeader(HdfSerializer self)"""
|
|
return _ifcopenshell_wrapper.HdfSerializer_writeHeader(self)
|
|
|
|
def write(self, *args):
|
|
r"""
|
|
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):
|
|
r"""remove(HdfSerializer self, std::string const & guid)"""
|
|
return _ifcopenshell_wrapper.HdfSerializer_remove(self, guid)
|
|
|
|
def read(self, *args):
|
|
r"""read(HdfSerializer self, file f, std::string const & guid, std::string const & arg4, GeometrySerializer::read_type rt=READ_BREP) -> Element"""
|
|
return _ifcopenshell_wrapper.HdfSerializer_read(self, *args)
|
|
|
|
def finalize(self):
|
|
r"""finalize(HdfSerializer self)"""
|
|
return _ifcopenshell_wrapper.HdfSerializer_finalize(self)
|
|
|
|
def isTesselated(self):
|
|
r"""isTesselated(HdfSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.HdfSerializer_isTesselated(self)
|
|
|
|
def setUnitNameAndMagnitude(self, arg2, arg3):
|
|
r"""setUnitNameAndMagnitude(HdfSerializer self, std::string const & arg2, float arg3)"""
|
|
return _ifcopenshell_wrapper.HdfSerializer_setUnitNameAndMagnitude(self, arg2, arg3)
|
|
|
|
def setFile(self, arg2):
|
|
r"""setFile(HdfSerializer self, file arg2)"""
|
|
return _ifcopenshell_wrapper.HdfSerializer_setFile(self, arg2)
|
|
|
|
# Register HdfSerializer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.HdfSerializer_swigregister(HdfSerializer)
|
|
class WaveFrontOBJSerializer(WriteOnlyGeometrySerializer):
|
|
r"""Proxy of C++ WaveFrontOBJSerializer class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, obj_filename, mtl_filename, geometry_settings, settings):
|
|
r"""__init__(WaveFrontOBJSerializer self, buffer obj_filename, buffer mtl_filename, Settings geometry_settings, SerializerSettings settings) -> WaveFrontOBJSerializer"""
|
|
_ifcopenshell_wrapper.WaveFrontOBJSerializer_swiginit(self, _ifcopenshell_wrapper.new_WaveFrontOBJSerializer(obj_filename, mtl_filename, geometry_settings, settings))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_WaveFrontOBJSerializer
|
|
|
|
def ready(self):
|
|
r"""ready(WaveFrontOBJSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.WaveFrontOBJSerializer_ready(self)
|
|
|
|
def writeHeader(self):
|
|
r"""writeHeader(WaveFrontOBJSerializer self)"""
|
|
return _ifcopenshell_wrapper.WaveFrontOBJSerializer_writeHeader(self)
|
|
|
|
def writeMaterial(self, style):
|
|
r"""writeMaterial(WaveFrontOBJSerializer self, ifcopenshell::geometry::taxonomy::style::ptr const style)"""
|
|
return _ifcopenshell_wrapper.WaveFrontOBJSerializer_writeMaterial(self, style)
|
|
|
|
def write(self, *args):
|
|
r"""
|
|
write(WaveFrontOBJSerializer self, TriangulationElement o)
|
|
write(WaveFrontOBJSerializer self, BRepElement arg2)
|
|
"""
|
|
return _ifcopenshell_wrapper.WaveFrontOBJSerializer_write(self, *args)
|
|
|
|
def finalize(self):
|
|
r"""finalize(WaveFrontOBJSerializer self)"""
|
|
return _ifcopenshell_wrapper.WaveFrontOBJSerializer_finalize(self)
|
|
|
|
def isTesselated(self):
|
|
r"""isTesselated(WaveFrontOBJSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.WaveFrontOBJSerializer_isTesselated(self)
|
|
|
|
def setUnitNameAndMagnitude(self, arg2, arg3):
|
|
r"""setUnitNameAndMagnitude(WaveFrontOBJSerializer self, std::string const & arg2, float arg3)"""
|
|
return _ifcopenshell_wrapper.WaveFrontOBJSerializer_setUnitNameAndMagnitude(self, arg2, arg3)
|
|
|
|
def setFile(self, arg2):
|
|
r"""setFile(WaveFrontOBJSerializer self, file arg2)"""
|
|
return _ifcopenshell_wrapper.WaveFrontOBJSerializer_setFile(self, arg2)
|
|
|
|
# Register WaveFrontOBJSerializer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.WaveFrontOBJSerializer_swigregister(WaveFrontOBJSerializer)
|
|
class ColladaSerializer(WriteOnlyGeometrySerializer):
|
|
r"""Proxy of C++ ColladaSerializer class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, dae_filename, geometry_settings, settings):
|
|
r"""__init__(ColladaSerializer self, std::string const & dae_filename, Settings geometry_settings, SerializerSettings settings) -> ColladaSerializer"""
|
|
_ifcopenshell_wrapper.ColladaSerializer_swiginit(self, _ifcopenshell_wrapper.new_ColladaSerializer(dae_filename, geometry_settings, settings))
|
|
|
|
def ready(self):
|
|
r"""ready(ColladaSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.ColladaSerializer_ready(self)
|
|
|
|
def writeHeader(self):
|
|
r"""writeHeader(ColladaSerializer self)"""
|
|
return _ifcopenshell_wrapper.ColladaSerializer_writeHeader(self)
|
|
|
|
def write(self, *args):
|
|
r"""
|
|
write(ColladaSerializer self, TriangulationElement o)
|
|
write(ColladaSerializer self, BRepElement arg2)
|
|
"""
|
|
return _ifcopenshell_wrapper.ColladaSerializer_write(self, *args)
|
|
|
|
def finalize(self):
|
|
r"""finalize(ColladaSerializer self)"""
|
|
return _ifcopenshell_wrapper.ColladaSerializer_finalize(self)
|
|
|
|
def isTesselated(self):
|
|
r"""isTesselated(ColladaSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.ColladaSerializer_isTesselated(self)
|
|
|
|
def setUnitNameAndMagnitude(self, name, magnitude):
|
|
r"""setUnitNameAndMagnitude(ColladaSerializer self, std::string const & name, float magnitude)"""
|
|
return _ifcopenshell_wrapper.ColladaSerializer_setUnitNameAndMagnitude(self, name, magnitude)
|
|
|
|
def setFile(self, arg2):
|
|
r"""setFile(ColladaSerializer self, file arg2)"""
|
|
return _ifcopenshell_wrapper.ColladaSerializer_setFile(self, arg2)
|
|
|
|
def object_id(self, o):
|
|
r"""object_id(ColladaSerializer self, Element o) -> std::string"""
|
|
return _ifcopenshell_wrapper.ColladaSerializer_object_id(self, o)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_ColladaSerializer
|
|
|
|
# Register ColladaSerializer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.ColladaSerializer_swigregister(ColladaSerializer)
|
|
class XmlSerializer(object):
|
|
r"""Proxy of C++ XmlSerializer class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, file, xml_filename):
|
|
r"""__init__(XmlSerializer self, file file, std::string const & xml_filename) -> XmlSerializer"""
|
|
_ifcopenshell_wrapper.XmlSerializer_swiginit(self, _ifcopenshell_wrapper.new_XmlSerializer(file, xml_filename))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_XmlSerializer
|
|
|
|
def ready(self):
|
|
r"""ready(XmlSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.XmlSerializer_ready(self)
|
|
|
|
def writeHeader(self):
|
|
r"""writeHeader(XmlSerializer self)"""
|
|
return _ifcopenshell_wrapper.XmlSerializer_writeHeader(self)
|
|
|
|
def finalize(self):
|
|
r"""finalize(XmlSerializer self)"""
|
|
return _ifcopenshell_wrapper.XmlSerializer_finalize(self)
|
|
|
|
def setFile(self, arg2):
|
|
r"""setFile(XmlSerializer self, file arg2)"""
|
|
return _ifcopenshell_wrapper.XmlSerializer_setFile(self, arg2)
|
|
|
|
# Register XmlSerializer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.XmlSerializer_swigregister(XmlSerializer)
|
|
class GltfSerializer(WriteOnlyGeometrySerializer):
|
|
r"""Proxy of C++ GltfSerializer class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, filename, geometry_settings, settings):
|
|
r"""__init__(GltfSerializer self, std::string const & filename, Settings geometry_settings, SerializerSettings settings) -> GltfSerializer"""
|
|
_ifcopenshell_wrapper.GltfSerializer_swiginit(self, _ifcopenshell_wrapper.new_GltfSerializer(filename, geometry_settings, settings))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_GltfSerializer
|
|
|
|
def ready(self):
|
|
r"""ready(GltfSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.GltfSerializer_ready(self)
|
|
|
|
def writeHeader(self):
|
|
r"""writeHeader(GltfSerializer self)"""
|
|
return _ifcopenshell_wrapper.GltfSerializer_writeHeader(self)
|
|
|
|
def write(self, *args):
|
|
r"""
|
|
write(GltfSerializer self, TriangulationElement o)
|
|
write(GltfSerializer self, BRepElement arg2)
|
|
"""
|
|
return _ifcopenshell_wrapper.GltfSerializer_write(self, *args)
|
|
|
|
def finalize(self):
|
|
r"""finalize(GltfSerializer self)"""
|
|
return _ifcopenshell_wrapper.GltfSerializer_finalize(self)
|
|
|
|
def isTesselated(self):
|
|
r"""isTesselated(GltfSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.GltfSerializer_isTesselated(self)
|
|
|
|
def setUnitNameAndMagnitude(self, arg2, arg3):
|
|
r"""setUnitNameAndMagnitude(GltfSerializer self, std::string const & arg2, float arg3)"""
|
|
return _ifcopenshell_wrapper.GltfSerializer_setUnitNameAndMagnitude(self, arg2, arg3)
|
|
|
|
def setFile(self, arg2):
|
|
r"""setFile(GltfSerializer self, file arg2)"""
|
|
return _ifcopenshell_wrapper.GltfSerializer_setFile(self, arg2)
|
|
|
|
# Register GltfSerializer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.GltfSerializer_swigregister(GltfSerializer)
|
|
class TtlWktSerializer(WriteOnlyGeometrySerializer):
|
|
r"""Proxy of C++ TtlWktSerializer class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, filename, geometry_settings, settings):
|
|
r"""__init__(TtlWktSerializer self, buffer filename, Settings geometry_settings, SerializerSettings settings) -> TtlWktSerializer"""
|
|
_ifcopenshell_wrapper.TtlWktSerializer_swiginit(self, _ifcopenshell_wrapper.new_TtlWktSerializer(filename, geometry_settings, settings))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_TtlWktSerializer
|
|
|
|
def ready(self):
|
|
r"""ready(TtlWktSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.TtlWktSerializer_ready(self)
|
|
|
|
def writeHeader(self):
|
|
r"""writeHeader(TtlWktSerializer self)"""
|
|
return _ifcopenshell_wrapper.TtlWktSerializer_writeHeader(self)
|
|
|
|
def write(self, *args):
|
|
r"""
|
|
write(TtlWktSerializer self, TriangulationElement o)
|
|
write(TtlWktSerializer self, BRepElement arg2)
|
|
"""
|
|
return _ifcopenshell_wrapper.TtlWktSerializer_write(self, *args)
|
|
|
|
def finalize(self):
|
|
r"""finalize(TtlWktSerializer self)"""
|
|
return _ifcopenshell_wrapper.TtlWktSerializer_finalize(self)
|
|
|
|
def isTesselated(self):
|
|
r"""isTesselated(TtlWktSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.TtlWktSerializer_isTesselated(self)
|
|
|
|
def setUnitNameAndMagnitude(self, arg2, arg3):
|
|
r"""setUnitNameAndMagnitude(TtlWktSerializer self, std::string const & arg2, float arg3)"""
|
|
return _ifcopenshell_wrapper.TtlWktSerializer_setUnitNameAndMagnitude(self, arg2, arg3)
|
|
|
|
def setFile(self, arg2):
|
|
r"""setFile(TtlWktSerializer self, file arg2)"""
|
|
return _ifcopenshell_wrapper.TtlWktSerializer_setFile(self, arg2)
|
|
|
|
def ttl_object_id(self, o, postfix=None):
|
|
r"""ttl_object_id(TtlWktSerializer self, Element o, char const *const postfix=None) -> std::string"""
|
|
return _ifcopenshell_wrapper.TtlWktSerializer_ttl_object_id(self, o, postfix)
|
|
|
|
# Register TtlWktSerializer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.TtlWktSerializer_swigregister(TtlWktSerializer)
|
|
class JsonSerializer(object):
|
|
r"""Proxy of C++ JsonSerializer class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
JSON_DIALECT_CREOOX = _ifcopenshell_wrapper.JsonSerializer_JSON_DIALECT_CREOOX
|
|
|
|
|
|
def __init__(self, *args):
|
|
r"""__init__(JsonSerializer self, file file, std::string const & json_filename, JsonSerializer::Dialect dialect=Dialect::JSON_DIALECT_CREOOX) -> JsonSerializer"""
|
|
_ifcopenshell_wrapper.JsonSerializer_swiginit(self, _ifcopenshell_wrapper.new_JsonSerializer(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_JsonSerializer
|
|
|
|
def ready(self):
|
|
r"""ready(JsonSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.JsonSerializer_ready(self)
|
|
|
|
def writeHeader(self):
|
|
r"""writeHeader(JsonSerializer self)"""
|
|
return _ifcopenshell_wrapper.JsonSerializer_writeHeader(self)
|
|
|
|
def finalize(self):
|
|
r"""finalize(JsonSerializer self)"""
|
|
return _ifcopenshell_wrapper.JsonSerializer_finalize(self)
|
|
|
|
def setFile(self, arg2):
|
|
r"""setFile(JsonSerializer self, file arg2)"""
|
|
return _ifcopenshell_wrapper.JsonSerializer_setFile(self, arg2)
|
|
|
|
# Register JsonSerializer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.JsonSerializer_swigregister(JsonSerializer)
|
|
class ray_intersection_results(object):
|
|
r"""Proxy of C++ std::vector< IfcGeom::ray_intersection_result > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
r"""iterator(ray_intersection_results self) -> SwigPyIterator"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_iterator(self)
|
|
def __iter__(self):
|
|
return self.iterator()
|
|
|
|
def __nonzero__(self):
|
|
r"""__nonzero__(ray_intersection_results self) -> bool"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
r"""__bool__(ray_intersection_results self) -> bool"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results___bool__(self)
|
|
|
|
def __len__(self):
|
|
r"""__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):
|
|
r"""__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):
|
|
r"""
|
|
__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):
|
|
r"""__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):
|
|
r"""
|
|
__delitem__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::difference_type i)
|
|
__delitem__(ray_intersection_results self, SWIGPY_SLICEOBJECT * slice)
|
|
"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
r"""
|
|
__getitem__(ray_intersection_results self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""
|
|
__setitem__(ray_intersection_results self, SWIGPY_SLICEOBJECT * slice, ray_intersection_results v)
|
|
__setitem__(ray_intersection_results self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""pop(ray_intersection_results self) -> ray_intersection_result"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_pop(self)
|
|
|
|
def append(self, x):
|
|
r"""append(ray_intersection_results self, ray_intersection_result x)"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_append(self, x)
|
|
|
|
def empty(self):
|
|
r"""empty(ray_intersection_results self) -> bool"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_empty(self)
|
|
|
|
def size(self):
|
|
r"""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):
|
|
r"""swap(ray_intersection_results self, ray_intersection_results v)"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_swap(self, v)
|
|
|
|
def begin(self):
|
|
r"""begin(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::iterator"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_begin(self)
|
|
|
|
def end(self):
|
|
r"""end(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::iterator"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_end(self)
|
|
|
|
def rbegin(self):
|
|
r"""rbegin(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_rbegin(self)
|
|
|
|
def rend(self):
|
|
r"""rend(ray_intersection_results self) -> std::vector< IfcGeom::ray_intersection_result >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_rend(self)
|
|
|
|
def clear(self):
|
|
r"""clear(ray_intersection_results self)"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_clear(self)
|
|
|
|
def get_allocator(self):
|
|
r"""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):
|
|
r"""pop_back(ray_intersection_results self)"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_pop_back(self)
|
|
|
|
def erase(self, *args):
|
|
r"""
|
|
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):
|
|
r"""
|
|
__init__(ray_intersection_results self) -> ray_intersection_results
|
|
__init__(ray_intersection_results self, ray_intersection_results other) -> ray_intersection_results
|
|
__init__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type size) -> ray_intersection_results
|
|
__init__(ray_intersection_results self, std::vector< IfcGeom::ray_intersection_result >::size_type size, ray_intersection_result value) -> ray_intersection_results
|
|
"""
|
|
_ifcopenshell_wrapper.ray_intersection_results_swiginit(self, _ifcopenshell_wrapper.new_ray_intersection_results(*args))
|
|
|
|
def push_back(self, x):
|
|
r"""push_back(ray_intersection_results self, ray_intersection_result x)"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_push_back(self, x)
|
|
|
|
def front(self):
|
|
r"""front(ray_intersection_results self) -> ray_intersection_result"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_front(self)
|
|
|
|
def back(self):
|
|
r"""back(ray_intersection_results self) -> ray_intersection_result"""
|
|
return _ifcopenshell_wrapper.ray_intersection_results_back(self)
|
|
|
|
def assign(self, n, x):
|
|
r"""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):
|
|
r"""
|
|
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):
|
|
r"""
|
|
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):
|
|
r"""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):
|
|
r"""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
|
|
|
|
# Register ray_intersection_results in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.ray_intersection_results_swigregister(ray_intersection_results)
|
|
class clashes(object):
|
|
r"""Proxy of C++ std::vector< IfcGeom::clash > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
r"""iterator(clashes self) -> SwigPyIterator"""
|
|
return _ifcopenshell_wrapper.clashes_iterator(self)
|
|
def __iter__(self):
|
|
return self.iterator()
|
|
|
|
def __nonzero__(self):
|
|
r"""__nonzero__(clashes self) -> bool"""
|
|
return _ifcopenshell_wrapper.clashes___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
r"""__bool__(clashes self) -> bool"""
|
|
return _ifcopenshell_wrapper.clashes___bool__(self)
|
|
|
|
def __len__(self):
|
|
r"""__len__(clashes self) -> std::vector< IfcGeom::clash >::size_type"""
|
|
return _ifcopenshell_wrapper.clashes___len__(self)
|
|
|
|
def __getslice__(self, i, j):
|
|
r"""__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):
|
|
r"""
|
|
__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):
|
|
r"""__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):
|
|
r"""
|
|
__delitem__(clashes self, std::vector< IfcGeom::clash >::difference_type i)
|
|
__delitem__(clashes self, SWIGPY_SLICEOBJECT * slice)
|
|
"""
|
|
return _ifcopenshell_wrapper.clashes___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
r"""
|
|
__getitem__(clashes self, SWIGPY_SLICEOBJECT * slice) -> clashes
|
|
__getitem__(clashes self, std::vector< IfcGeom::clash >::difference_type i) -> clash
|
|
"""
|
|
return _ifcopenshell_wrapper.clashes___getitem__(self, *args)
|
|
|
|
def __setitem__(self, *args):
|
|
r"""
|
|
__setitem__(clashes self, SWIGPY_SLICEOBJECT * slice, clashes v)
|
|
__setitem__(clashes self, SWIGPY_SLICEOBJECT * slice)
|
|
__setitem__(clashes self, std::vector< IfcGeom::clash >::difference_type i, clash x)
|
|
"""
|
|
return _ifcopenshell_wrapper.clashes___setitem__(self, *args)
|
|
|
|
def pop(self):
|
|
r"""pop(clashes self) -> clash"""
|
|
return _ifcopenshell_wrapper.clashes_pop(self)
|
|
|
|
def append(self, x):
|
|
r"""append(clashes self, clash x)"""
|
|
return _ifcopenshell_wrapper.clashes_append(self, x)
|
|
|
|
def empty(self):
|
|
r"""empty(clashes self) -> bool"""
|
|
return _ifcopenshell_wrapper.clashes_empty(self)
|
|
|
|
def size(self):
|
|
r"""size(clashes self) -> std::vector< IfcGeom::clash >::size_type"""
|
|
return _ifcopenshell_wrapper.clashes_size(self)
|
|
|
|
def swap(self, v):
|
|
r"""swap(clashes self, clashes v)"""
|
|
return _ifcopenshell_wrapper.clashes_swap(self, v)
|
|
|
|
def begin(self):
|
|
r"""begin(clashes self) -> std::vector< IfcGeom::clash >::iterator"""
|
|
return _ifcopenshell_wrapper.clashes_begin(self)
|
|
|
|
def end(self):
|
|
r"""end(clashes self) -> std::vector< IfcGeom::clash >::iterator"""
|
|
return _ifcopenshell_wrapper.clashes_end(self)
|
|
|
|
def rbegin(self):
|
|
r"""rbegin(clashes self) -> std::vector< IfcGeom::clash >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.clashes_rbegin(self)
|
|
|
|
def rend(self):
|
|
r"""rend(clashes self) -> std::vector< IfcGeom::clash >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.clashes_rend(self)
|
|
|
|
def clear(self):
|
|
r"""clear(clashes self)"""
|
|
return _ifcopenshell_wrapper.clashes_clear(self)
|
|
|
|
def get_allocator(self):
|
|
r"""get_allocator(clashes self) -> std::vector< IfcGeom::clash >::allocator_type"""
|
|
return _ifcopenshell_wrapper.clashes_get_allocator(self)
|
|
|
|
def pop_back(self):
|
|
r"""pop_back(clashes self)"""
|
|
return _ifcopenshell_wrapper.clashes_pop_back(self)
|
|
|
|
def erase(self, *args):
|
|
r"""
|
|
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):
|
|
r"""
|
|
__init__(clashes self) -> clashes
|
|
__init__(clashes self, clashes other) -> clashes
|
|
__init__(clashes self, std::vector< IfcGeom::clash >::size_type size) -> clashes
|
|
__init__(clashes self, std::vector< IfcGeom::clash >::size_type size, clash value) -> clashes
|
|
"""
|
|
_ifcopenshell_wrapper.clashes_swiginit(self, _ifcopenshell_wrapper.new_clashes(*args))
|
|
|
|
def push_back(self, x):
|
|
r"""push_back(clashes self, clash x)"""
|
|
return _ifcopenshell_wrapper.clashes_push_back(self, x)
|
|
|
|
def front(self):
|
|
r"""front(clashes self) -> clash"""
|
|
return _ifcopenshell_wrapper.clashes_front(self)
|
|
|
|
def back(self):
|
|
r"""back(clashes self) -> clash"""
|
|
return _ifcopenshell_wrapper.clashes_back(self)
|
|
|
|
def assign(self, n, x):
|
|
r"""assign(clashes self, std::vector< IfcGeom::clash >::size_type n, clash x)"""
|
|
return _ifcopenshell_wrapper.clashes_assign(self, n, x)
|
|
|
|
def resize(self, *args):
|
|
r"""
|
|
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):
|
|
r"""
|
|
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):
|
|
r"""reserve(clashes self, std::vector< IfcGeom::clash >::size_type n)"""
|
|
return _ifcopenshell_wrapper.clashes_reserve(self, n)
|
|
|
|
def capacity(self):
|
|
r"""capacity(clashes self) -> std::vector< IfcGeom::clash >::size_type"""
|
|
return _ifcopenshell_wrapper.clashes_capacity(self)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_clashes
|
|
|
|
# Register clashes in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.clashes_swigregister(clashes)
|
|
class ray_intersection_result(object):
|
|
r"""Proxy of C++ IfcGeom::ray_intersection_result class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
distance = property(_ifcopenshell_wrapper.ray_intersection_result_distance_get, _ifcopenshell_wrapper.ray_intersection_result_distance_set, doc=r"""distance : double""")
|
|
style_index = property(_ifcopenshell_wrapper.ray_intersection_result_style_index_get, _ifcopenshell_wrapper.ray_intersection_result_style_index_set, doc=r"""style_index : int""")
|
|
instance = property(_ifcopenshell_wrapper.ray_intersection_result_instance_get, _ifcopenshell_wrapper.ray_intersection_result_instance_set, doc=r"""instance : p.q(const).IfcUtil::IfcBaseEntity""")
|
|
position = property(_ifcopenshell_wrapper.ray_intersection_result_position_get, _ifcopenshell_wrapper.ray_intersection_result_position_set, doc=r"""position : std::array<(double,3)>""")
|
|
normal = property(_ifcopenshell_wrapper.ray_intersection_result_normal_get, _ifcopenshell_wrapper.ray_intersection_result_normal_set, doc=r"""normal : std::array<(double,3)>""")
|
|
ray_distance = property(_ifcopenshell_wrapper.ray_intersection_result_ray_distance_get, _ifcopenshell_wrapper.ray_intersection_result_ray_distance_set, doc=r"""ray_distance : double""")
|
|
dot_product = property(_ifcopenshell_wrapper.ray_intersection_result_dot_product_get, _ifcopenshell_wrapper.ray_intersection_result_dot_product_set, doc=r"""dot_product : double""")
|
|
|
|
def __init__(self):
|
|
r"""__init__(ray_intersection_result self) -> ray_intersection_result"""
|
|
_ifcopenshell_wrapper.ray_intersection_result_swiginit(self, _ifcopenshell_wrapper.new_ray_intersection_result())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_ray_intersection_result
|
|
|
|
# Register ray_intersection_result in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.ray_intersection_result_swigregister(ray_intersection_result)
|
|
class clash(object):
|
|
r"""Proxy of C++ IfcGeom::clash class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
clash_type = property(_ifcopenshell_wrapper.clash_clash_type_get, _ifcopenshell_wrapper.clash_clash_type_set, doc=r"""clash_type : int""")
|
|
a = property(_ifcopenshell_wrapper.clash_a_get, _ifcopenshell_wrapper.clash_a_set, doc=r"""a : p.q(const).IfcUtil::IfcBaseClass""")
|
|
b = property(_ifcopenshell_wrapper.clash_b_get, _ifcopenshell_wrapper.clash_b_set, doc=r"""b : p.q(const).IfcUtil::IfcBaseClass""")
|
|
distance = property(_ifcopenshell_wrapper.clash_distance_get, _ifcopenshell_wrapper.clash_distance_set, doc=r"""distance : double""")
|
|
p1 = property(_ifcopenshell_wrapper.clash_p1_get, _ifcopenshell_wrapper.clash_p1_set, doc=r"""p1 : std::array<(double,3)>""")
|
|
p2 = property(_ifcopenshell_wrapper.clash_p2_get, _ifcopenshell_wrapper.clash_p2_set, doc=r"""p2 : std::array<(double,3)>""")
|
|
|
|
def __init__(self):
|
|
r"""__init__(clash self) -> clash"""
|
|
_ifcopenshell_wrapper.clash_swiginit(self, _ifcopenshell_wrapper.new_clash())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_clash
|
|
|
|
# Register clash in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.clash_swigregister(clash)
|
|
class tree(object):
|
|
r"""Proxy of C++ IfcGeom::tree class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(tree self) -> tree
|
|
__init__(tree self, file f) -> tree
|
|
__init__(tree self, file f, Settings settings) -> tree
|
|
__init__(tree self, Iterator it) -> tree
|
|
"""
|
|
_ifcopenshell_wrapper.tree_swiginit(self, _ifcopenshell_wrapper.new_tree(*args))
|
|
|
|
def add_file(self, *args):
|
|
r"""
|
|
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):
|
|
r"""write_h5(tree self)"""
|
|
return _ifcopenshell_wrapper.tree_write_h5(self)
|
|
|
|
def uint8_to_b64(self, uuids_array):
|
|
r"""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)
|
|
|
|
@staticmethod
|
|
def is_manifold(fs):
|
|
r"""is_manifold(std::vector< int,std::allocator< int > > const & fs) -> bool"""
|
|
return _ifcopenshell_wrapper.tree_is_manifold(fs)
|
|
|
|
def add_element(self, *args):
|
|
r"""
|
|
add_element(tree self, TriangulationElement elem)
|
|
add_element(tree self, BRepElement elem)
|
|
"""
|
|
return _ifcopenshell_wrapper.tree_add_element(self, *args)
|
|
|
|
def distances(self):
|
|
r"""distances(tree self) -> std::vector< double,std::allocator< double > > const &"""
|
|
return _ifcopenshell_wrapper.tree_distances(self)
|
|
|
|
def protrusion_distances(self):
|
|
r"""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.):
|
|
r"""select_ray(tree self, gp_Pnt const & p0, gp_Dir const & d, double length=1000.) -> ray_intersection_results"""
|
|
return _ifcopenshell_wrapper.tree_select_ray(self, p0, d, length)
|
|
|
|
def enable_face_styles(self, *args):
|
|
r"""
|
|
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):
|
|
r"""styles(tree self) -> std::vector< ifcopenshell::geometry::taxonomy::style::ptr,std::allocator< ifcopenshell::geometry::taxonomy::style::ptr > > const &"""
|
|
return _ifcopenshell_wrapper.tree_styles(self)
|
|
|
|
@staticmethod
|
|
def vector_to_list(ps):
|
|
r"""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 select_box(self, *args):
|
|
r"""
|
|
select_box(tree self, entity_instance e, bool completely_within=False, double extend=-1.e-5) -> 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
|
|
"""
|
|
return _ifcopenshell_wrapper.tree_select_box(self, *args)
|
|
|
|
def select(self, *args):
|
|
r"""
|
|
select(tree self, entity_instance e, bool completely_within=False, double extend=0.0) -> aggregate_of_instance::ptr
|
|
select(tree self, gp_Pnt const & p, double extend=0.0) -> 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, BRepElement elem, bool completely_within=False, double extend=-1.e-5) -> aggregate_of_instance::ptr
|
|
"""
|
|
return _ifcopenshell_wrapper.tree_select(self, *args)
|
|
|
|
def clash_intersection_many(self, set_a, set_b, tolerance, check_all):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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
|
|
|
|
# Register tree in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.tree_swigregister(tree)
|
|
|
|
def construct_iterator(geometry_library, settings, file, num_threads):
|
|
r"""construct_iterator(std::string const & geometry_library, Settings settings, file file, int num_threads) -> Iterator"""
|
|
return _ifcopenshell_wrapper.construct_iterator(geometry_library, settings, file, num_threads)
|
|
|
|
def construct_iterator_with_include_exclude(geometry_library, settings, file, elems, include, num_threads):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""map_shape(Settings settings, entity_instance instance) -> ifcopenshell::geometry::taxonomy::item::ptr"""
|
|
return _ifcopenshell_wrapper.map_shape(settings, instance)
|
|
|
|
def create_shape(*args):
|
|
r"""create_shape(Settings settings, entity_instance instance, entity_instance representation=None, char const *const geometry_library="opencascade") -> boost::variant< IfcGeom::Element *,IfcGeom::Representation::Representation *,IfcGeom::Transformation * >"""
|
|
return _ifcopenshell_wrapper.create_shape(*args)
|
|
|
|
def serialise(schema_name, shape_str, advanced=True):
|
|
r"""serialise(std::string const & schema_name, std::string const & shape_str, bool advanced=True) -> entity_instance"""
|
|
return _ifcopenshell_wrapper.serialise(schema_name, shape_str, advanced)
|
|
|
|
def tesselate(schema_name, shape_str, d):
|
|
r"""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):
|
|
r"""Proxy of C++ std::vector< std::array< svgfill::point_2,2 > > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
r"""iterator(svg_line_segments self) -> SwigPyIterator"""
|
|
return _ifcopenshell_wrapper.svg_line_segments_iterator(self)
|
|
def __iter__(self):
|
|
return self.iterator()
|
|
|
|
def __nonzero__(self):
|
|
r"""__nonzero__(svg_line_segments self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_line_segments___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
r"""__bool__(svg_line_segments self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_line_segments___bool__(self)
|
|
|
|
def __len__(self):
|
|
r"""__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):
|
|
r"""__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):
|
|
r"""
|
|
__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):
|
|
r"""__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):
|
|
r"""
|
|
__delitem__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::difference_type i)
|
|
__delitem__(svg_line_segments self, SWIGPY_SLICEOBJECT * slice)
|
|
"""
|
|
return _ifcopenshell_wrapper.svg_line_segments___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
r"""
|
|
__getitem__(svg_line_segments self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""
|
|
__setitem__(svg_line_segments self, SWIGPY_SLICEOBJECT * slice, svg_line_segments v)
|
|
__setitem__(svg_line_segments self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""pop(svg_line_segments self) -> line_segment"""
|
|
return _ifcopenshell_wrapper.svg_line_segments_pop(self)
|
|
|
|
def append(self, x):
|
|
r"""append(svg_line_segments self, line_segment x)"""
|
|
return _ifcopenshell_wrapper.svg_line_segments_append(self, x)
|
|
|
|
def empty(self):
|
|
r"""empty(svg_line_segments self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_line_segments_empty(self)
|
|
|
|
def size(self):
|
|
r"""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):
|
|
r"""swap(svg_line_segments self, svg_line_segments v)"""
|
|
return _ifcopenshell_wrapper.svg_line_segments_swap(self, v)
|
|
|
|
def begin(self):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""clear(svg_line_segments self)"""
|
|
return _ifcopenshell_wrapper.svg_line_segments_clear(self)
|
|
|
|
def get_allocator(self):
|
|
r"""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):
|
|
r"""pop_back(svg_line_segments self)"""
|
|
return _ifcopenshell_wrapper.svg_line_segments_pop_back(self)
|
|
|
|
def erase(self, *args):
|
|
r"""
|
|
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):
|
|
r"""
|
|
__init__(svg_line_segments self) -> svg_line_segments
|
|
__init__(svg_line_segments self, svg_line_segments other) -> svg_line_segments
|
|
__init__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type size) -> svg_line_segments
|
|
__init__(svg_line_segments self, std::vector< std::array< svgfill::point_2,2 > >::size_type size, line_segment value) -> svg_line_segments
|
|
"""
|
|
_ifcopenshell_wrapper.svg_line_segments_swiginit(self, _ifcopenshell_wrapper.new_svg_line_segments(*args))
|
|
|
|
def push_back(self, x):
|
|
r"""push_back(svg_line_segments self, line_segment x)"""
|
|
return _ifcopenshell_wrapper.svg_line_segments_push_back(self, x)
|
|
|
|
def front(self):
|
|
r"""front(svg_line_segments self) -> line_segment"""
|
|
return _ifcopenshell_wrapper.svg_line_segments_front(self)
|
|
|
|
def back(self):
|
|
r"""back(svg_line_segments self) -> line_segment"""
|
|
return _ifcopenshell_wrapper.svg_line_segments_back(self)
|
|
|
|
def assign(self, n, x):
|
|
r"""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):
|
|
r"""
|
|
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):
|
|
r"""
|
|
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):
|
|
r"""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):
|
|
r"""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
|
|
|
|
# Register svg_line_segments in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.svg_line_segments_swigregister(svg_line_segments)
|
|
class svg_groups_of_line_segments(object):
|
|
r"""Proxy of C++ std::vector< std::vector< std::array< svgfill::point_2,2 > > > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
r"""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):
|
|
r"""__nonzero__(svg_groups_of_line_segments self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_line_segments___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
r"""__bool__(svg_groups_of_line_segments self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_line_segments___bool__(self)
|
|
|
|
def __len__(self):
|
|
r"""__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):
|
|
r"""__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):
|
|
r"""
|
|
__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):
|
|
r"""__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):
|
|
r"""
|
|
__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, SWIGPY_SLICEOBJECT * slice)
|
|
"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_line_segments___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
r"""
|
|
__getitem__(svg_groups_of_line_segments self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""
|
|
__setitem__(svg_groups_of_line_segments self, SWIGPY_SLICEOBJECT * slice, svg_groups_of_line_segments v)
|
|
__setitem__(svg_groups_of_line_segments self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""pop(svg_groups_of_line_segments self) -> svg_line_segments"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_line_segments_pop(self)
|
|
|
|
def append(self, x):
|
|
r"""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):
|
|
r"""empty(svg_groups_of_line_segments self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_line_segments_empty(self)
|
|
|
|
def size(self):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""clear(svg_groups_of_line_segments self)"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_line_segments_clear(self)
|
|
|
|
def get_allocator(self):
|
|
r"""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):
|
|
r"""pop_back(svg_groups_of_line_segments self)"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_line_segments_pop_back(self)
|
|
|
|
def erase(self, *args):
|
|
r"""
|
|
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):
|
|
r"""
|
|
__init__(svg_groups_of_line_segments self) -> svg_groups_of_line_segments
|
|
__init__(svg_groups_of_line_segments self, svg_groups_of_line_segments other) -> svg_groups_of_line_segments
|
|
__init__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type size) -> svg_groups_of_line_segments
|
|
__init__(svg_groups_of_line_segments self, std::vector< std::vector< std::array< svgfill::point_2,2 > > >::size_type size, svg_line_segments value) -> svg_groups_of_line_segments
|
|
"""
|
|
_ifcopenshell_wrapper.svg_groups_of_line_segments_swiginit(self, _ifcopenshell_wrapper.new_svg_groups_of_line_segments(*args))
|
|
|
|
def push_back(self, x):
|
|
r"""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):
|
|
r"""front(svg_groups_of_line_segments self) -> svg_line_segments"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_line_segments_front(self)
|
|
|
|
def back(self):
|
|
r"""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):
|
|
r"""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):
|
|
r"""
|
|
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):
|
|
r"""
|
|
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):
|
|
r"""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):
|
|
r"""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
|
|
|
|
# Register svg_groups_of_line_segments in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.svg_groups_of_line_segments_swigregister(svg_groups_of_line_segments)
|
|
class svg_point(object):
|
|
r"""Proxy of C++ std::array< double,2 > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
r"""iterator(svg_point self) -> SwigPyIterator"""
|
|
return _ifcopenshell_wrapper.svg_point_iterator(self)
|
|
def __iter__(self):
|
|
return self.iterator()
|
|
|
|
def __nonzero__(self):
|
|
r"""__nonzero__(svg_point self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_point___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
r"""__bool__(svg_point self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_point___bool__(self)
|
|
|
|
def __len__(self):
|
|
r"""__len__(svg_point self) -> std::array< double,2 >::size_type"""
|
|
return _ifcopenshell_wrapper.svg_point___len__(self)
|
|
|
|
def __getslice__(self, i, j):
|
|
r"""__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):
|
|
r"""
|
|
__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):
|
|
r"""__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):
|
|
r"""
|
|
__delitem__(svg_point self, std::array< double,2 >::difference_type i)
|
|
__delitem__(svg_point self, SWIGPY_SLICEOBJECT * slice)
|
|
"""
|
|
return _ifcopenshell_wrapper.svg_point___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
r"""
|
|
__getitem__(svg_point self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""
|
|
__setitem__(svg_point self, SWIGPY_SLICEOBJECT * slice, svg_point v)
|
|
__setitem__(svg_point self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""
|
|
__init__(svg_point self) -> svg_point
|
|
__init__(svg_point self, svg_point other) -> svg_point
|
|
"""
|
|
_ifcopenshell_wrapper.svg_point_swiginit(self, _ifcopenshell_wrapper.new_svg_point(*args))
|
|
|
|
def empty(self):
|
|
r"""empty(svg_point self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_point_empty(self)
|
|
|
|
def size(self):
|
|
r"""size(svg_point self) -> std::array< double,2 >::size_type"""
|
|
return _ifcopenshell_wrapper.svg_point_size(self)
|
|
|
|
def swap(self, v):
|
|
r"""swap(svg_point self, svg_point v)"""
|
|
return _ifcopenshell_wrapper.svg_point_swap(self, v)
|
|
|
|
def begin(self):
|
|
r"""begin(svg_point self) -> std::array< double,2 >::iterator"""
|
|
return _ifcopenshell_wrapper.svg_point_begin(self)
|
|
|
|
def end(self):
|
|
r"""end(svg_point self) -> std::array< double,2 >::iterator"""
|
|
return _ifcopenshell_wrapper.svg_point_end(self)
|
|
|
|
def rbegin(self):
|
|
r"""rbegin(svg_point self) -> std::array< double,2 >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.svg_point_rbegin(self)
|
|
|
|
def rend(self):
|
|
r"""rend(svg_point self) -> std::array< double,2 >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.svg_point_rend(self)
|
|
|
|
def front(self):
|
|
r"""front(svg_point self) -> std::array< double,2 >::value_type const &"""
|
|
return _ifcopenshell_wrapper.svg_point_front(self)
|
|
|
|
def back(self):
|
|
r"""back(svg_point self) -> std::array< double,2 >::value_type const &"""
|
|
return _ifcopenshell_wrapper.svg_point_back(self)
|
|
|
|
def fill(self, u):
|
|
r"""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
|
|
|
|
# Register svg_point in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.svg_point_swigregister(svg_point)
|
|
class line_segment(object):
|
|
r"""Proxy of C++ std::array< svgfill::point_2,2 > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
r"""iterator(line_segment self) -> SwigPyIterator"""
|
|
return _ifcopenshell_wrapper.line_segment_iterator(self)
|
|
def __iter__(self):
|
|
return self.iterator()
|
|
|
|
def __nonzero__(self):
|
|
r"""__nonzero__(line_segment self) -> bool"""
|
|
return _ifcopenshell_wrapper.line_segment___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
r"""__bool__(line_segment self) -> bool"""
|
|
return _ifcopenshell_wrapper.line_segment___bool__(self)
|
|
|
|
def __len__(self):
|
|
r"""__len__(line_segment self) -> std::array< svgfill::point_2,2 >::size_type"""
|
|
return _ifcopenshell_wrapper.line_segment___len__(self)
|
|
|
|
def __getslice__(self, i, j):
|
|
r"""__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):
|
|
r"""
|
|
__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):
|
|
r"""__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):
|
|
r"""
|
|
__delitem__(line_segment self, std::array< svgfill::point_2,2 >::difference_type i)
|
|
__delitem__(line_segment self, SWIGPY_SLICEOBJECT * slice)
|
|
"""
|
|
return _ifcopenshell_wrapper.line_segment___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
r"""
|
|
__getitem__(line_segment self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""
|
|
__setitem__(line_segment self, SWIGPY_SLICEOBJECT * slice, line_segment v)
|
|
__setitem__(line_segment self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""
|
|
__init__(line_segment self) -> line_segment
|
|
__init__(line_segment self, line_segment other) -> line_segment
|
|
"""
|
|
_ifcopenshell_wrapper.line_segment_swiginit(self, _ifcopenshell_wrapper.new_line_segment(*args))
|
|
|
|
def empty(self):
|
|
r"""empty(line_segment self) -> bool"""
|
|
return _ifcopenshell_wrapper.line_segment_empty(self)
|
|
|
|
def size(self):
|
|
r"""size(line_segment self) -> std::array< svgfill::point_2,2 >::size_type"""
|
|
return _ifcopenshell_wrapper.line_segment_size(self)
|
|
|
|
def swap(self, v):
|
|
r"""swap(line_segment self, line_segment v)"""
|
|
return _ifcopenshell_wrapper.line_segment_swap(self, v)
|
|
|
|
def begin(self):
|
|
r"""begin(line_segment self) -> std::array< svgfill::point_2,2 >::iterator"""
|
|
return _ifcopenshell_wrapper.line_segment_begin(self)
|
|
|
|
def end(self):
|
|
r"""end(line_segment self) -> std::array< svgfill::point_2,2 >::iterator"""
|
|
return _ifcopenshell_wrapper.line_segment_end(self)
|
|
|
|
def rbegin(self):
|
|
r"""rbegin(line_segment self) -> std::array< svgfill::point_2,2 >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.line_segment_rbegin(self)
|
|
|
|
def rend(self):
|
|
r"""rend(line_segment self) -> std::array< svgfill::point_2,2 >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.line_segment_rend(self)
|
|
|
|
def front(self):
|
|
r"""front(line_segment self) -> std::array< svgfill::point_2,2 >::value_type const &"""
|
|
return _ifcopenshell_wrapper.line_segment_front(self)
|
|
|
|
def back(self):
|
|
r"""back(line_segment self) -> std::array< svgfill::point_2,2 >::value_type const &"""
|
|
return _ifcopenshell_wrapper.line_segment_back(self)
|
|
|
|
def fill(self, u):
|
|
r"""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
|
|
|
|
# Register line_segment in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.line_segment_swigregister(line_segment)
|
|
class svg_polygons(object):
|
|
r"""Proxy of C++ std::vector< svgfill::polygon_2 > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
r"""iterator(svg_polygons self) -> SwigPyIterator"""
|
|
return _ifcopenshell_wrapper.svg_polygons_iterator(self)
|
|
def __iter__(self):
|
|
return self.iterator()
|
|
|
|
def __nonzero__(self):
|
|
r"""__nonzero__(svg_polygons self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_polygons___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
r"""__bool__(svg_polygons self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_polygons___bool__(self)
|
|
|
|
def __len__(self):
|
|
r"""__len__(svg_polygons self) -> std::vector< svgfill::polygon_2 >::size_type"""
|
|
return _ifcopenshell_wrapper.svg_polygons___len__(self)
|
|
|
|
def __getslice__(self, i, j):
|
|
r"""__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):
|
|
r"""
|
|
__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):
|
|
r"""__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):
|
|
r"""
|
|
__delitem__(svg_polygons self, std::vector< svgfill::polygon_2 >::difference_type i)
|
|
__delitem__(svg_polygons self, SWIGPY_SLICEOBJECT * slice)
|
|
"""
|
|
return _ifcopenshell_wrapper.svg_polygons___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
r"""
|
|
__getitem__(svg_polygons self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""
|
|
__setitem__(svg_polygons self, SWIGPY_SLICEOBJECT * slice, svg_polygons v)
|
|
__setitem__(svg_polygons self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""pop(svg_polygons self) -> polygon_2"""
|
|
return _ifcopenshell_wrapper.svg_polygons_pop(self)
|
|
|
|
def append(self, x):
|
|
r"""append(svg_polygons self, polygon_2 x)"""
|
|
return _ifcopenshell_wrapper.svg_polygons_append(self, x)
|
|
|
|
def empty(self):
|
|
r"""empty(svg_polygons self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_polygons_empty(self)
|
|
|
|
def size(self):
|
|
r"""size(svg_polygons self) -> std::vector< svgfill::polygon_2 >::size_type"""
|
|
return _ifcopenshell_wrapper.svg_polygons_size(self)
|
|
|
|
def swap(self, v):
|
|
r"""swap(svg_polygons self, svg_polygons v)"""
|
|
return _ifcopenshell_wrapper.svg_polygons_swap(self, v)
|
|
|
|
def begin(self):
|
|
r"""begin(svg_polygons self) -> std::vector< svgfill::polygon_2 >::iterator"""
|
|
return _ifcopenshell_wrapper.svg_polygons_begin(self)
|
|
|
|
def end(self):
|
|
r"""end(svg_polygons self) -> std::vector< svgfill::polygon_2 >::iterator"""
|
|
return _ifcopenshell_wrapper.svg_polygons_end(self)
|
|
|
|
def rbegin(self):
|
|
r"""rbegin(svg_polygons self) -> std::vector< svgfill::polygon_2 >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.svg_polygons_rbegin(self)
|
|
|
|
def rend(self):
|
|
r"""rend(svg_polygons self) -> std::vector< svgfill::polygon_2 >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.svg_polygons_rend(self)
|
|
|
|
def clear(self):
|
|
r"""clear(svg_polygons self)"""
|
|
return _ifcopenshell_wrapper.svg_polygons_clear(self)
|
|
|
|
def get_allocator(self):
|
|
r"""get_allocator(svg_polygons self) -> std::vector< svgfill::polygon_2 >::allocator_type"""
|
|
return _ifcopenshell_wrapper.svg_polygons_get_allocator(self)
|
|
|
|
def pop_back(self):
|
|
r"""pop_back(svg_polygons self)"""
|
|
return _ifcopenshell_wrapper.svg_polygons_pop_back(self)
|
|
|
|
def erase(self, *args):
|
|
r"""
|
|
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):
|
|
r"""
|
|
__init__(svg_polygons self) -> svg_polygons
|
|
__init__(svg_polygons self, svg_polygons other) -> svg_polygons
|
|
__init__(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type size) -> svg_polygons
|
|
__init__(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type size, polygon_2 value) -> svg_polygons
|
|
"""
|
|
_ifcopenshell_wrapper.svg_polygons_swiginit(self, _ifcopenshell_wrapper.new_svg_polygons(*args))
|
|
|
|
def push_back(self, x):
|
|
r"""push_back(svg_polygons self, polygon_2 x)"""
|
|
return _ifcopenshell_wrapper.svg_polygons_push_back(self, x)
|
|
|
|
def front(self):
|
|
r"""front(svg_polygons self) -> polygon_2"""
|
|
return _ifcopenshell_wrapper.svg_polygons_front(self)
|
|
|
|
def back(self):
|
|
r"""back(svg_polygons self) -> polygon_2"""
|
|
return _ifcopenshell_wrapper.svg_polygons_back(self)
|
|
|
|
def assign(self, n, x):
|
|
r"""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):
|
|
r"""
|
|
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):
|
|
r"""
|
|
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):
|
|
r"""reserve(svg_polygons self, std::vector< svgfill::polygon_2 >::size_type n)"""
|
|
return _ifcopenshell_wrapper.svg_polygons_reserve(self, n)
|
|
|
|
def capacity(self):
|
|
r"""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
|
|
|
|
# Register svg_polygons in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.svg_polygons_swigregister(svg_polygons)
|
|
class svg_groups_of_polygons(object):
|
|
r"""Proxy of C++ std::vector< std::vector< svgfill::polygon_2 > > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
r"""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):
|
|
r"""__nonzero__(svg_groups_of_polygons self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_polygons___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
r"""__bool__(svg_groups_of_polygons self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_polygons___bool__(self)
|
|
|
|
def __len__(self):
|
|
r"""__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):
|
|
r"""__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):
|
|
r"""
|
|
__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):
|
|
r"""__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):
|
|
r"""
|
|
__delitem__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::difference_type i)
|
|
__delitem__(svg_groups_of_polygons self, SWIGPY_SLICEOBJECT * slice)
|
|
"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_polygons___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
r"""
|
|
__getitem__(svg_groups_of_polygons self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""
|
|
__setitem__(svg_groups_of_polygons self, SWIGPY_SLICEOBJECT * slice, svg_groups_of_polygons v)
|
|
__setitem__(svg_groups_of_polygons self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""pop(svg_groups_of_polygons self) -> svg_polygons"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_polygons_pop(self)
|
|
|
|
def append(self, x):
|
|
r"""append(svg_groups_of_polygons self, svg_polygons x)"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_polygons_append(self, x)
|
|
|
|
def empty(self):
|
|
r"""empty(svg_groups_of_polygons self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_polygons_empty(self)
|
|
|
|
def size(self):
|
|
r"""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):
|
|
r"""swap(svg_groups_of_polygons self, svg_groups_of_polygons v)"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_polygons_swap(self, v)
|
|
|
|
def begin(self):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""clear(svg_groups_of_polygons self)"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_polygons_clear(self)
|
|
|
|
def get_allocator(self):
|
|
r"""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):
|
|
r"""pop_back(svg_groups_of_polygons self)"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_polygons_pop_back(self)
|
|
|
|
def erase(self, *args):
|
|
r"""
|
|
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):
|
|
r"""
|
|
__init__(svg_groups_of_polygons self) -> svg_groups_of_polygons
|
|
__init__(svg_groups_of_polygons self, svg_groups_of_polygons other) -> svg_groups_of_polygons
|
|
__init__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type size) -> svg_groups_of_polygons
|
|
__init__(svg_groups_of_polygons self, std::vector< std::vector< svgfill::polygon_2 > >::size_type size, svg_polygons value) -> svg_groups_of_polygons
|
|
"""
|
|
_ifcopenshell_wrapper.svg_groups_of_polygons_swiginit(self, _ifcopenshell_wrapper.new_svg_groups_of_polygons(*args))
|
|
|
|
def push_back(self, x):
|
|
r"""push_back(svg_groups_of_polygons self, svg_polygons x)"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_polygons_push_back(self, x)
|
|
|
|
def front(self):
|
|
r"""front(svg_groups_of_polygons self) -> svg_polygons"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_polygons_front(self)
|
|
|
|
def back(self):
|
|
r"""back(svg_groups_of_polygons self) -> svg_polygons"""
|
|
return _ifcopenshell_wrapper.svg_groups_of_polygons_back(self)
|
|
|
|
def assign(self, n, x):
|
|
r"""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):
|
|
r"""
|
|
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):
|
|
r"""
|
|
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):
|
|
r"""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):
|
|
r"""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
|
|
|
|
# Register svg_groups_of_polygons in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.svg_groups_of_polygons_swigregister(svg_groups_of_polygons)
|
|
class svg_loop(object):
|
|
r"""Proxy of C++ std::vector< std::array< double,2 > > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
r"""iterator(svg_loop self) -> SwigPyIterator"""
|
|
return _ifcopenshell_wrapper.svg_loop_iterator(self)
|
|
def __iter__(self):
|
|
return self.iterator()
|
|
|
|
def __nonzero__(self):
|
|
r"""__nonzero__(svg_loop self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_loop___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
r"""__bool__(svg_loop self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_loop___bool__(self)
|
|
|
|
def __len__(self):
|
|
r"""__len__(svg_loop self) -> std::vector< std::array< double,2 > >::size_type"""
|
|
return _ifcopenshell_wrapper.svg_loop___len__(self)
|
|
|
|
def __getslice__(self, i, j):
|
|
r"""__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):
|
|
r"""
|
|
__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):
|
|
r"""__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):
|
|
r"""
|
|
__delitem__(svg_loop self, std::vector< std::array< double,2 > >::difference_type i)
|
|
__delitem__(svg_loop self, SWIGPY_SLICEOBJECT * slice)
|
|
"""
|
|
return _ifcopenshell_wrapper.svg_loop___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
r"""
|
|
__getitem__(svg_loop self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""
|
|
__setitem__(svg_loop self, SWIGPY_SLICEOBJECT * slice, svg_loop v)
|
|
__setitem__(svg_loop self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""pop(svg_loop self) -> svg_point"""
|
|
return _ifcopenshell_wrapper.svg_loop_pop(self)
|
|
|
|
def append(self, x):
|
|
r"""append(svg_loop self, svg_point x)"""
|
|
return _ifcopenshell_wrapper.svg_loop_append(self, x)
|
|
|
|
def empty(self):
|
|
r"""empty(svg_loop self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_loop_empty(self)
|
|
|
|
def size(self):
|
|
r"""size(svg_loop self) -> std::vector< std::array< double,2 > >::size_type"""
|
|
return _ifcopenshell_wrapper.svg_loop_size(self)
|
|
|
|
def swap(self, v):
|
|
r"""swap(svg_loop self, svg_loop v)"""
|
|
return _ifcopenshell_wrapper.svg_loop_swap(self, v)
|
|
|
|
def begin(self):
|
|
r"""begin(svg_loop self) -> std::vector< std::array< double,2 > >::iterator"""
|
|
return _ifcopenshell_wrapper.svg_loop_begin(self)
|
|
|
|
def end(self):
|
|
r"""end(svg_loop self) -> std::vector< std::array< double,2 > >::iterator"""
|
|
return _ifcopenshell_wrapper.svg_loop_end(self)
|
|
|
|
def rbegin(self):
|
|
r"""rbegin(svg_loop self) -> std::vector< std::array< double,2 > >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.svg_loop_rbegin(self)
|
|
|
|
def rend(self):
|
|
r"""rend(svg_loop self) -> std::vector< std::array< double,2 > >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.svg_loop_rend(self)
|
|
|
|
def clear(self):
|
|
r"""clear(svg_loop self)"""
|
|
return _ifcopenshell_wrapper.svg_loop_clear(self)
|
|
|
|
def get_allocator(self):
|
|
r"""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):
|
|
r"""pop_back(svg_loop self)"""
|
|
return _ifcopenshell_wrapper.svg_loop_pop_back(self)
|
|
|
|
def erase(self, *args):
|
|
r"""
|
|
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):
|
|
r"""
|
|
__init__(svg_loop self) -> svg_loop
|
|
__init__(svg_loop self, svg_loop other) -> svg_loop
|
|
__init__(svg_loop self, std::vector< std::array< double,2 > >::size_type size) -> svg_loop
|
|
__init__(svg_loop self, std::vector< std::array< double,2 > >::size_type size, svg_point value) -> svg_loop
|
|
"""
|
|
_ifcopenshell_wrapper.svg_loop_swiginit(self, _ifcopenshell_wrapper.new_svg_loop(*args))
|
|
|
|
def push_back(self, x):
|
|
r"""push_back(svg_loop self, svg_point x)"""
|
|
return _ifcopenshell_wrapper.svg_loop_push_back(self, x)
|
|
|
|
def front(self):
|
|
r"""front(svg_loop self) -> svg_point"""
|
|
return _ifcopenshell_wrapper.svg_loop_front(self)
|
|
|
|
def back(self):
|
|
r"""back(svg_loop self) -> svg_point"""
|
|
return _ifcopenshell_wrapper.svg_loop_back(self)
|
|
|
|
def assign(self, n, x):
|
|
r"""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):
|
|
r"""
|
|
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):
|
|
r"""
|
|
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):
|
|
r"""reserve(svg_loop self, std::vector< std::array< double,2 > >::size_type n)"""
|
|
return _ifcopenshell_wrapper.svg_loop_reserve(self, n)
|
|
|
|
def capacity(self):
|
|
r"""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
|
|
|
|
# Register svg_loop in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.svg_loop_swigregister(svg_loop)
|
|
class svg_loops(object):
|
|
r"""Proxy of C++ std::vector< std::vector< std::array< double,2 > > > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def iterator(self):
|
|
r"""iterator(svg_loops self) -> SwigPyIterator"""
|
|
return _ifcopenshell_wrapper.svg_loops_iterator(self)
|
|
def __iter__(self):
|
|
return self.iterator()
|
|
|
|
def __nonzero__(self):
|
|
r"""__nonzero__(svg_loops self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_loops___nonzero__(self)
|
|
|
|
def __bool__(self):
|
|
r"""__bool__(svg_loops self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_loops___bool__(self)
|
|
|
|
def __len__(self):
|
|
r"""__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):
|
|
r"""__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):
|
|
r"""
|
|
__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):
|
|
r"""__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):
|
|
r"""
|
|
__delitem__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::difference_type i)
|
|
__delitem__(svg_loops self, SWIGPY_SLICEOBJECT * slice)
|
|
"""
|
|
return _ifcopenshell_wrapper.svg_loops___delitem__(self, *args)
|
|
|
|
def __getitem__(self, *args):
|
|
r"""
|
|
__getitem__(svg_loops self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""
|
|
__setitem__(svg_loops self, SWIGPY_SLICEOBJECT * slice, svg_loops v)
|
|
__setitem__(svg_loops self, SWIGPY_SLICEOBJECT * 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):
|
|
r"""pop(svg_loops self) -> svg_loop"""
|
|
return _ifcopenshell_wrapper.svg_loops_pop(self)
|
|
|
|
def append(self, x):
|
|
r"""append(svg_loops self, svg_loop x)"""
|
|
return _ifcopenshell_wrapper.svg_loops_append(self, x)
|
|
|
|
def empty(self):
|
|
r"""empty(svg_loops self) -> bool"""
|
|
return _ifcopenshell_wrapper.svg_loops_empty(self)
|
|
|
|
def size(self):
|
|
r"""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):
|
|
r"""swap(svg_loops self, svg_loops v)"""
|
|
return _ifcopenshell_wrapper.svg_loops_swap(self, v)
|
|
|
|
def begin(self):
|
|
r"""begin(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::iterator"""
|
|
return _ifcopenshell_wrapper.svg_loops_begin(self)
|
|
|
|
def end(self):
|
|
r"""end(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::iterator"""
|
|
return _ifcopenshell_wrapper.svg_loops_end(self)
|
|
|
|
def rbegin(self):
|
|
r"""rbegin(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.svg_loops_rbegin(self)
|
|
|
|
def rend(self):
|
|
r"""rend(svg_loops self) -> std::vector< std::vector< std::array< double,2 > > >::reverse_iterator"""
|
|
return _ifcopenshell_wrapper.svg_loops_rend(self)
|
|
|
|
def clear(self):
|
|
r"""clear(svg_loops self)"""
|
|
return _ifcopenshell_wrapper.svg_loops_clear(self)
|
|
|
|
def get_allocator(self):
|
|
r"""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):
|
|
r"""pop_back(svg_loops self)"""
|
|
return _ifcopenshell_wrapper.svg_loops_pop_back(self)
|
|
|
|
def erase(self, *args):
|
|
r"""
|
|
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):
|
|
r"""
|
|
__init__(svg_loops self) -> svg_loops
|
|
__init__(svg_loops self, svg_loops other) -> svg_loops
|
|
__init__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type size) -> svg_loops
|
|
__init__(svg_loops self, std::vector< std::vector< std::array< double,2 > > >::size_type size, svg_loop value) -> svg_loops
|
|
"""
|
|
_ifcopenshell_wrapper.svg_loops_swiginit(self, _ifcopenshell_wrapper.new_svg_loops(*args))
|
|
|
|
def push_back(self, x):
|
|
r"""push_back(svg_loops self, svg_loop x)"""
|
|
return _ifcopenshell_wrapper.svg_loops_push_back(self, x)
|
|
|
|
def front(self):
|
|
r"""front(svg_loops self) -> svg_loop"""
|
|
return _ifcopenshell_wrapper.svg_loops_front(self)
|
|
|
|
def back(self):
|
|
r"""back(svg_loops self) -> svg_loop"""
|
|
return _ifcopenshell_wrapper.svg_loops_back(self)
|
|
|
|
def assign(self, n, x):
|
|
r"""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):
|
|
r"""
|
|
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):
|
|
r"""
|
|
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):
|
|
r"""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):
|
|
r"""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
|
|
|
|
# Register svg_loops in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.svg_loops_swigregister(svg_loops)
|
|
class OpaqueCoordinate_3(object):
|
|
r"""Proxy of C++ IfcGeom::OpaqueCoordinate< 3 > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(OpaqueCoordinate_3 self) -> OpaqueCoordinate_3
|
|
__init__(OpaqueCoordinate_3 self, OpaqueCoordinate_3 other) -> OpaqueCoordinate_3
|
|
"""
|
|
_ifcopenshell_wrapper.OpaqueCoordinate_3_swiginit(self, _ifcopenshell_wrapper.new_OpaqueCoordinate_3(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_OpaqueCoordinate_3
|
|
|
|
def get(self, i):
|
|
r"""get(OpaqueCoordinate_3 self, size_t i) -> OpaqueNumber"""
|
|
return _ifcopenshell_wrapper.OpaqueCoordinate_3_get(self, i)
|
|
|
|
def set(self, i, n):
|
|
r"""set(OpaqueCoordinate_3 self, size_t i, OpaqueNumber n)"""
|
|
return _ifcopenshell_wrapper.OpaqueCoordinate_3_set(self, i, n)
|
|
|
|
# Register OpaqueCoordinate_3 in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.OpaqueCoordinate_3_swigregister(OpaqueCoordinate_3)
|
|
class OpaqueCoordinate_4(object):
|
|
r"""Proxy of C++ IfcGeom::OpaqueCoordinate< 4 > class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(OpaqueCoordinate_4 self) -> OpaqueCoordinate_4
|
|
__init__(OpaqueCoordinate_4 self, OpaqueCoordinate_4 other) -> OpaqueCoordinate_4
|
|
"""
|
|
_ifcopenshell_wrapper.OpaqueCoordinate_4_swiginit(self, _ifcopenshell_wrapper.new_OpaqueCoordinate_4(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_OpaqueCoordinate_4
|
|
|
|
def get(self, i):
|
|
r"""get(OpaqueCoordinate_4 self, size_t i) -> OpaqueNumber"""
|
|
return _ifcopenshell_wrapper.OpaqueCoordinate_4_get(self, i)
|
|
|
|
def set(self, i, n):
|
|
r"""set(OpaqueCoordinate_4 self, size_t i, OpaqueNumber n)"""
|
|
return _ifcopenshell_wrapper.OpaqueCoordinate_4_set(self, i, n)
|
|
|
|
# Register OpaqueCoordinate_4 in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.OpaqueCoordinate_4_swigregister(OpaqueCoordinate_4)
|
|
|
|
def create_epeck(*args):
|
|
r"""
|
|
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):
|
|
r"""nary_union(PyObject * sequence) -> ConversionResultShape"""
|
|
return _ifcopenshell_wrapper.nary_union(sequence)
|
|
class polygon_2(object):
|
|
r"""Proxy of C++ svgfill::polygon_2 class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
boundary = property(_ifcopenshell_wrapper.polygon_2_boundary_get, _ifcopenshell_wrapper.polygon_2_boundary_set, doc=r"""boundary : svgfill::loop_2""")
|
|
inner_boundaries = property(_ifcopenshell_wrapper.polygon_2_inner_boundaries_get, _ifcopenshell_wrapper.polygon_2_inner_boundaries_set, doc=r"""inner_boundaries : std::vector<(svgfill::loop_2,std::allocator<(svgfill::loop_2)>)>""")
|
|
point_inside = property(_ifcopenshell_wrapper.polygon_2_point_inside_get, _ifcopenshell_wrapper.polygon_2_point_inside_set, doc=r"""point_inside : svgfill::point_2""")
|
|
|
|
def __init__(self):
|
|
r"""__init__(polygon_2 self) -> polygon_2"""
|
|
_ifcopenshell_wrapper.polygon_2_swiginit(self, _ifcopenshell_wrapper.new_polygon_2())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_polygon_2
|
|
|
|
# Register polygon_2 in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.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):
|
|
r"""Proxy of C++ svgfill::abstract_arrangement class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_abstract_arrangement
|
|
|
|
def __call__(self, eps, segments, progress):
|
|
r"""__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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""num_edges(abstract_arrangement self) -> size_t"""
|
|
return _ifcopenshell_wrapper.abstract_arrangement_num_edges(self)
|
|
|
|
def num_faces(self):
|
|
r"""num_faces(abstract_arrangement self) -> size_t"""
|
|
return _ifcopenshell_wrapper.abstract_arrangement_num_faces(self)
|
|
|
|
# Register abstract_arrangement in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.abstract_arrangement_swigregister(abstract_arrangement)
|
|
class context(object):
|
|
r"""Proxy of C++ svgfill::context class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(context self, svgfill::solver s, double eps) -> context
|
|
__init__(context self, svgfill::solver s, double eps, std::function< void (float) > & progress) -> context
|
|
"""
|
|
_ifcopenshell_wrapper.context_swiginit(self, _ifcopenshell_wrapper.new_context(*args))
|
|
|
|
def add(self, segments):
|
|
r"""add(context self, svg_line_segments segments)"""
|
|
return _ifcopenshell_wrapper.context_add(self, segments)
|
|
|
|
def build(self):
|
|
r"""build(context self) -> bool"""
|
|
return _ifcopenshell_wrapper.context_build(self)
|
|
|
|
def get_face_pairs(self):
|
|
r"""get_face_pairs(context self) -> std::vector< int,std::allocator< int > >"""
|
|
return _ifcopenshell_wrapper.context_get_face_pairs(self)
|
|
|
|
def merge(self, edge_indices):
|
|
r"""merge(context self, std::vector< int,std::allocator< int > > const & edge_indices)"""
|
|
return _ifcopenshell_wrapper.context_merge(self, edge_indices)
|
|
|
|
def write(self, arg2):
|
|
r"""write(context self, svg_groups_of_polygons arg2)"""
|
|
return _ifcopenshell_wrapper.context_write(self, arg2)
|
|
|
|
def num_edges(self):
|
|
r"""num_edges(context self) -> size_t"""
|
|
return _ifcopenshell_wrapper.context_num_edges(self)
|
|
|
|
def num_faces(self):
|
|
r"""num_faces(context self) -> size_t"""
|
|
return _ifcopenshell_wrapper.context_num_faces(self)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_context
|
|
|
|
# Register context in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.context_swigregister(context)
|
|
|
|
def polygons_to_svg(*args):
|
|
r"""
|
|
polygons_to_svg(svg_groups_of_polygons polygons, bool random_color=False) -> std::string
|
|
polygons_to_svg(svg_polygons polygons, bool random_color=False) -> std::string
|
|
"""
|
|
return _ifcopenshell_wrapper.polygons_to_svg(*args)
|
|
|
|
def svg_to_line_segments(data, class_name):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""arrange_polygons(svg_polygons polygons) -> svg_polygons"""
|
|
return _ifcopenshell_wrapper.arrange_polygons(polygons)
|
|
class IfcEntityInstanceData(object):
|
|
r"""Proxy of C++ IfcEntityInstanceData class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_IfcEntityInstanceData
|
|
|
|
# Register IfcEntityInstanceData in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.IfcEntityInstanceData_swigregister(IfcEntityInstanceData)
|
|
class attribute_value_derived(object):
|
|
r"""Proxy of C++ attribute_value_derived class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __bool__(self): return False
|
|
def __repr__(self): return '*'
|
|
|
|
|
|
def __init__(self):
|
|
r"""__init__(attribute_value_derived self) -> attribute_value_derived"""
|
|
_ifcopenshell_wrapper.attribute_value_derived_swiginit(self, _ifcopenshell_wrapper.new_attribute_value_derived())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_attribute_value_derived
|
|
|
|
# Register attribute_value_derived in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.attribute_value_derived_swigregister(attribute_value_derived)
|
|
|
|
def set_feature(x, v):
|
|
r"""set_feature(std::string const & x, PyObject * v)"""
|
|
return _ifcopenshell_wrapper.set_feature(x, v)
|
|
|
|
def get_feature(x):
|
|
r"""get_feature(std::string const & x) -> PyObject *"""
|
|
return _ifcopenshell_wrapper.get_feature(x)
|
|
class RocksDBPrefixIterator(object):
|
|
r"""Proxy of C++ RocksDBPrefixIterator class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, storage, prefix):
|
|
r"""__init__(RocksDBPrefixIterator self, IfcParse::impl::rocks_db_file_storage const * storage, std::string const & prefix) -> RocksDBPrefixIterator"""
|
|
_ifcopenshell_wrapper.RocksDBPrefixIterator_swiginit(self, _ifcopenshell_wrapper.new_RocksDBPrefixIterator(storage, prefix))
|
|
|
|
def valid(self):
|
|
r"""valid(RocksDBPrefixIterator self) -> bool"""
|
|
return _ifcopenshell_wrapper.RocksDBPrefixIterator_valid(self)
|
|
|
|
def next(self):
|
|
r"""next(RocksDBPrefixIterator self)"""
|
|
return _ifcopenshell_wrapper.RocksDBPrefixIterator_next(self)
|
|
|
|
def key(self):
|
|
r"""key(RocksDBPrefixIterator self) -> PyObject *"""
|
|
return _ifcopenshell_wrapper.RocksDBPrefixIterator_key(self)
|
|
|
|
def value(self):
|
|
r"""value(RocksDBPrefixIterator self) -> PyObject *"""
|
|
return _ifcopenshell_wrapper.RocksDBPrefixIterator_value(self)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_RocksDBPrefixIterator
|
|
|
|
# Register RocksDBPrefixIterator in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.RocksDBPrefixIterator_swigregister(RocksDBPrefixIterator)
|
|
cvar = _ifcopenshell_wrapper.cvar
|
|
|
|
class IfcSpfHeader(object):
|
|
r"""Proxy of C++ IfcParse::IfcSpfHeader class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(IfcSpfHeader self, file file=None) -> IfcSpfHeader
|
|
__init__(IfcSpfHeader self, IfcParse::IfcSpfLexer * lexer) -> IfcSpfHeader
|
|
"""
|
|
_ifcopenshell_wrapper.IfcSpfHeader_swiginit(self, _ifcopenshell_wrapper.new_IfcSpfHeader(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_IfcSpfHeader
|
|
|
|
def file(self, *args):
|
|
r"""
|
|
file(IfcSpfHeader self) -> file
|
|
file(IfcSpfHeader self, file file)
|
|
"""
|
|
return _ifcopenshell_wrapper.IfcSpfHeader_file(self, *args)
|
|
|
|
def read(self):
|
|
r"""read(IfcSpfHeader self)"""
|
|
return _ifcopenshell_wrapper.IfcSpfHeader_read(self)
|
|
|
|
def tryRead(self):
|
|
r"""tryRead(IfcSpfHeader self) -> bool"""
|
|
return _ifcopenshell_wrapper.IfcSpfHeader_tryRead(self)
|
|
|
|
def write(self, out):
|
|
r"""write(IfcSpfHeader self, std::ostream & out)"""
|
|
return _ifcopenshell_wrapper.IfcSpfHeader_write(self, out)
|
|
|
|
def file_description_py(self):
|
|
r"""file_description_py(IfcSpfHeader self) -> entity_instance"""
|
|
return _ifcopenshell_wrapper.IfcSpfHeader_file_description_py(self)
|
|
|
|
def file_name_py(self):
|
|
r"""file_name_py(IfcSpfHeader self) -> entity_instance"""
|
|
return _ifcopenshell_wrapper.IfcSpfHeader_file_name_py(self)
|
|
|
|
def file_schema_py(self):
|
|
r"""file_schema_py(IfcSpfHeader self) -> entity_instance"""
|
|
return _ifcopenshell_wrapper.IfcSpfHeader_file_schema_py(self)
|
|
|
|
# Register IfcSpfHeader in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.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):
|
|
r"""guess_file_type(std::string const & fn) -> IfcParse::filetype"""
|
|
return _ifcopenshell_wrapper.guess_file_type(fn)
|
|
class InstanceStreamer(object):
|
|
r"""Proxy of C++ IfcParse::InstanceStreamer class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
coerce_attribute_count = property(_ifcopenshell_wrapper.InstanceStreamer_coerce_attribute_count_get, _ifcopenshell_wrapper.InstanceStreamer_coerce_attribute_count_set, doc=r"""coerce_attribute_count : bool""")
|
|
|
|
def __nonzero__(self):
|
|
return _ifcopenshell_wrapper.InstanceStreamer___nonzero__(self)
|
|
__bool__ = __nonzero__
|
|
|
|
|
|
|
|
def status(self):
|
|
r"""status(InstanceStreamer self) -> file_open_status"""
|
|
return _ifcopenshell_wrapper.InstanceStreamer_status(self)
|
|
|
|
def references(self, *args):
|
|
r"""
|
|
references(InstanceStreamer self) -> IfcParse::unresolved_references const
|
|
references(InstanceStreamer self) -> IfcParse::unresolved_references &
|
|
"""
|
|
return _ifcopenshell_wrapper.InstanceStreamer_references(self, *args)
|
|
|
|
def bypassed_instances(self):
|
|
r"""bypassed_instances(InstanceStreamer self) -> std::vector< unsigned int,std::allocator< unsigned int > > const &"""
|
|
return _ifcopenshell_wrapper.InstanceStreamer_bypassed_instances(self)
|
|
|
|
def inverses(self, *args):
|
|
r"""
|
|
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 hasSemicolon(self):
|
|
r"""hasSemicolon(InstanceStreamer self) -> bool"""
|
|
return _ifcopenshell_wrapper.InstanceStreamer_hasSemicolon(self)
|
|
|
|
def semicolonCount(self):
|
|
r"""semicolonCount(InstanceStreamer self) -> size_t"""
|
|
return _ifcopenshell_wrapper.InstanceStreamer_semicolonCount(self)
|
|
|
|
def pushPage(self, page):
|
|
r"""pushPage(InstanceStreamer self, std::string const & page)"""
|
|
return _ifcopenshell_wrapper.InstanceStreamer_pushPage(self, page)
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(InstanceStreamer self) -> InstanceStreamer
|
|
__init__(InstanceStreamer self, std::string const & fn, bool mmap=False) -> InstanceStreamer
|
|
__init__(InstanceStreamer self, void * data, int length) -> InstanceStreamer
|
|
"""
|
|
_ifcopenshell_wrapper.InstanceStreamer_swiginit(self, _ifcopenshell_wrapper.new_InstanceStreamer(*args))
|
|
|
|
def bypassTypes(self, type_names):
|
|
r"""bypassTypes(InstanceStreamer self, std::set< std::string > const & type_names)"""
|
|
return _ifcopenshell_wrapper.InstanceStreamer_bypassTypes(self, type_names)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_InstanceStreamer
|
|
|
|
def readInstancePy(self, type_as_declaration_instance=False):
|
|
r"""readInstancePy(InstanceStreamer self, bool type_as_declaration_instance=False) -> PyObject"""
|
|
return _ifcopenshell_wrapper.InstanceStreamer_readInstancePy(self, type_as_declaration_instance)
|
|
|
|
# Register InstanceStreamer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.InstanceStreamer_swigregister(InstanceStreamer)
|
|
class uninitialized_tag(object):
|
|
r"""Proxy of C++ IfcParse::uninitialized_tag class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self):
|
|
r"""__init__(uninitialized_tag self) -> uninitialized_tag"""
|
|
_ifcopenshell_wrapper.uninitialized_tag_swiginit(self, _ifcopenshell_wrapper.new_uninitialized_tag())
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_uninitialized_tag
|
|
|
|
# Register uninitialized_tag in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.uninitialized_tag_swigregister(uninitialized_tag)
|
|
class file(object):
|
|
r"""Proxy of C++ IfcParse::IfcFile class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
check_existance_before_adding = property(_ifcopenshell_wrapper.file_check_existance_before_adding_get, _ifcopenshell_wrapper.file_check_existance_before_adding_set, doc=r"""check_existance_before_adding : bool""")
|
|
calculate_unit_factors = property(_ifcopenshell_wrapper.file_calculate_unit_factors_get, _ifcopenshell_wrapper.file_calculate_unit_factors_set, doc=r"""calculate_unit_factors : bool""")
|
|
instantiate_typed_instances = property(_ifcopenshell_wrapper.file_instantiate_typed_instances_get, _ifcopenshell_wrapper.file_instantiate_typed_instances_set, doc=r"""instantiate_typed_instances : bool""")
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__init__(file self, std::string const & path, IfcParse::filetype ty=FT_AUTODETECT, bool readonly=False) -> file
|
|
__init__(file self, std::istream & stream, int length) -> file
|
|
__init__(file self, void * data, int length) -> file
|
|
__init__(file self, IfcParse::FileReader * stream) -> file
|
|
__init__(file self, schema_definition schema=IfcParse::schema_by_name("IFC4"), IfcParse::filetype ty=FT_AUTODETECT, std::string const & path="") -> file
|
|
__init__(file self, uninitialized_tag arg2) -> file
|
|
"""
|
|
_ifcopenshell_wrapper.file_swiginit(self, _ifcopenshell_wrapper.new_file(*args))
|
|
|
|
def initialize(self, *args):
|
|
r"""initialize(file self, std::string const & path, IfcParse::filetype ty=FT_AUTODETECT, bool readonly=False) -> bool"""
|
|
return _ifcopenshell_wrapper.file_initialize(self, *args)
|
|
|
|
def bypass_type(self, type_name):
|
|
r"""bypass_type(file self, std::string const & type_name)"""
|
|
return _ifcopenshell_wrapper.file_bypass_type(self, type_name)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_file
|
|
|
|
def good(self):
|
|
r"""good(file self) -> file_open_status"""
|
|
return _ifcopenshell_wrapper.file_good(self)
|
|
|
|
def by_type(self, *args):
|
|
r"""
|
|
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):
|
|
r"""
|
|
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):
|
|
r"""by_id(file self, int id) -> entity_instance"""
|
|
return _ifcopenshell_wrapper.file_by_id(self, id)
|
|
|
|
def by_guid(self, guid):
|
|
r"""by_guid(file self, std::string const & guid) -> entity_instance"""
|
|
return _ifcopenshell_wrapper.file_by_guid(self, guid)
|
|
|
|
@staticmethod
|
|
def traverse(instance, max_level=-1):
|
|
r"""traverse(entity_instance instance, int max_level=-1) -> aggregate_of_instance::ptr"""
|
|
return _ifcopenshell_wrapper.file_traverse(instance, max_level)
|
|
|
|
@staticmethod
|
|
def traverse_breadth_first(instance, max_level=-1):
|
|
r"""traverse_breadth_first(entity_instance instance, int max_level=-1) -> aggregate_of_instance::ptr"""
|
|
return _ifcopenshell_wrapper.file_traverse_breadth_first(instance, max_level)
|
|
|
|
def get_inverses_by_declaration(self, instance_id, type, attribute_index):
|
|
r"""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):
|
|
r"""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):
|
|
r"""FreshId(file self) -> unsigned int"""
|
|
return _ifcopenshell_wrapper.file_FreshId(self)
|
|
|
|
def getMaxId(self):
|
|
r"""getMaxId(file self) -> unsigned int"""
|
|
return _ifcopenshell_wrapper.file_getMaxId(self)
|
|
|
|
def ifcroot_type(self):
|
|
r"""ifcroot_type(file self) -> declaration"""
|
|
return _ifcopenshell_wrapper.file_ifcroot_type(self)
|
|
|
|
def recalculate_id_counter(self):
|
|
r"""recalculate_id_counter(file self)"""
|
|
return _ifcopenshell_wrapper.file_recalculate_id_counter(self)
|
|
|
|
def add(self, entity, id=-1):
|
|
r"""add(file self, entity_instance entity, int id=-1) -> entity_instance"""
|
|
return _ifcopenshell_wrapper.file_add(self, entity, id)
|
|
|
|
def addEntities(self, entities):
|
|
r"""addEntities(file self, aggregate_of_instance::ptr entities)"""
|
|
return _ifcopenshell_wrapper.file_addEntities(self, entities)
|
|
|
|
def remove(self, entity):
|
|
r"""remove(file self, entity_instance entity)"""
|
|
return _ifcopenshell_wrapper.file_remove(self, entity)
|
|
|
|
def header(self, *args):
|
|
r"""
|
|
header(file self) -> IfcSpfHeader
|
|
header(file self) -> IfcSpfHeader
|
|
"""
|
|
return _ifcopenshell_wrapper.file_header(self, *args)
|
|
|
|
@staticmethod
|
|
def createTimestamp():
|
|
r"""createTimestamp() -> std::string"""
|
|
return _ifcopenshell_wrapper.file_createTimestamp()
|
|
|
|
def getUnit(self, unit_type):
|
|
r"""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):
|
|
r"""build_inverses(file self)"""
|
|
return _ifcopenshell_wrapper.file_build_inverses(self)
|
|
|
|
def add_type_ref(self, new_entity):
|
|
r"""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):
|
|
r"""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):
|
|
r"""process_deletion_inverse(file self, entity_instance inst)"""
|
|
return _ifcopenshell_wrapper.file_process_deletion_inverse(self, inst)
|
|
|
|
def build_inverses_(self, arg2):
|
|
r"""build_inverses_(file self, entity_instance arg2)"""
|
|
return _ifcopenshell_wrapper.file_build_inverses_(self, arg2)
|
|
|
|
def create(self, decl):
|
|
r"""create(file self, declaration decl) -> entity_instance"""
|
|
return _ifcopenshell_wrapper.file_create(self, decl)
|
|
|
|
def batch(self):
|
|
r"""batch(file self)"""
|
|
return _ifcopenshell_wrapper.file_batch(self)
|
|
|
|
def unbatch(self):
|
|
r"""unbatch(file self)"""
|
|
return _ifcopenshell_wrapper.file_unbatch(self)
|
|
|
|
def reset_identity_cache(self):
|
|
r"""reset_identity_cache(file self)"""
|
|
return _ifcopenshell_wrapper.file_reset_identity_cache(self)
|
|
|
|
def file_pointer(self):
|
|
r"""file_pointer(file self) -> size_t"""
|
|
return _ifcopenshell_wrapper.file_file_pointer(self)
|
|
|
|
def get_inverse(self, e):
|
|
r"""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):
|
|
r"""
|
|
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):
|
|
r"""get_total_inverses(file self, entity_instance e) -> int"""
|
|
return _ifcopenshell_wrapper.file_get_total_inverses(self, e)
|
|
|
|
def write(self, fn):
|
|
r"""write(file self, std::string const & fn)"""
|
|
return _ifcopenshell_wrapper.file_write(self, fn)
|
|
|
|
def to_string(self):
|
|
r"""to_string(file self) -> std::string"""
|
|
return _ifcopenshell_wrapper.file_to_string(self)
|
|
|
|
def entity_names(self):
|
|
r"""entity_names(file self) -> std::vector< unsigned int,std::allocator< unsigned int > >"""
|
|
return _ifcopenshell_wrapper.file_entity_names(self)
|
|
|
|
def types(self):
|
|
r"""types(file self) -> std::vector< std::string,std::allocator< std::string > >"""
|
|
return _ifcopenshell_wrapper.file_types(self)
|
|
|
|
def schema_name(self):
|
|
r"""schema_name(file self) -> std::string"""
|
|
return _ifcopenshell_wrapper.file_schema_name(self)
|
|
|
|
def storage_mode(self):
|
|
r"""storage_mode(file self) -> int"""
|
|
return _ifcopenshell_wrapper.file_storage_mode(self)
|
|
|
|
def key_value_store_iter(self, prefix):
|
|
r"""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):
|
|
r"""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)
|
|
|
|
|
|
# Register file in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.file_swigregister(file)
|
|
|
|
def parse_ifcxml(filename):
|
|
r"""parse_ifcxml(std::string const & filename) -> file"""
|
|
return _ifcopenshell_wrapper.parse_ifcxml(filename)
|
|
class file_open_status(object):
|
|
r"""Proxy of C++ IfcParse::file_open_status class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__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):
|
|
r"""__init__(file_open_status self, IfcParse::file_open_status::file_open_enum error=UNKNOWN) -> file_open_status"""
|
|
_ifcopenshell_wrapper.file_open_status_swiginit(self, _ifcopenshell_wrapper.new_file_open_status(*args))
|
|
|
|
def value(self):
|
|
r"""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
|
|
|
|
# Register file_open_status in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.file_open_status_swigregister(file_open_status)
|
|
class entity_instance(object):
|
|
r"""Proxy of C++ IfcUtil::IfcBaseClass class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
id_ = property(_ifcopenshell_wrapper.entity_instance_id__get, _ifcopenshell_wrapper.entity_instance_id__set, doc=r"""id_ : uint32_t""")
|
|
file_ = property(_ifcopenshell_wrapper.entity_instance_file__get, _ifcopenshell_wrapper.entity_instance_file__set, doc=r"""file_ : p.IfcParse::IfcFile""")
|
|
|
|
def data(self, *args):
|
|
r"""
|
|
data(entity_instance self) -> IfcEntityInstanceData
|
|
data(entity_instance self) -> IfcEntityInstanceData
|
|
"""
|
|
return _ifcopenshell_wrapper.entity_instance_data(self, *args)
|
|
|
|
def declaration(self):
|
|
r"""declaration(entity_instance self) -> declaration"""
|
|
return _ifcopenshell_wrapper.entity_instance_declaration(self)
|
|
|
|
def set_attribute_value(self, *args):
|
|
r"""
|
|
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):
|
|
r"""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):
|
|
r"""get_attribute_value(entity_instance self, size_t index) -> AttributeValue"""
|
|
return _ifcopenshell_wrapper.entity_instance_get_attribute_value(self, index)
|
|
|
|
def identity(self):
|
|
r"""identity(entity_instance self) -> uint32_t"""
|
|
return _ifcopenshell_wrapper.entity_instance_identity(self)
|
|
|
|
def toString(self, arg2, upper=False):
|
|
r"""toString(entity_instance self, std::ostream & arg2, bool upper=False)"""
|
|
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):
|
|
r"""get_attribute_category(entity_instance self, std::string const & name) -> int"""
|
|
return _ifcopenshell_wrapper.entity_instance_get_attribute_category(self, name)
|
|
|
|
def id(self):
|
|
r"""id(entity_instance self) -> int"""
|
|
return _ifcopenshell_wrapper.entity_instance_id(self)
|
|
|
|
def __len__(self):
|
|
r"""__len__(entity_instance self) -> int"""
|
|
return _ifcopenshell_wrapper.entity_instance___len__(self)
|
|
|
|
def get_attribute_names(self):
|
|
r"""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):
|
|
r"""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):
|
|
r"""
|
|
is_a(entity_instance self, std::string const & s) -> bool
|
|
is_a(entity_instance self, bool with_schema=False) -> std::string
|
|
"""
|
|
return _ifcopenshell_wrapper.entity_instance_is_a(self, *args)
|
|
|
|
def get_argument(self, *args):
|
|
r"""
|
|
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):
|
|
r"""__eq__(entity_instance self, entity_instance other) -> bool"""
|
|
return _ifcopenshell_wrapper.entity_instance___eq__(self, other)
|
|
|
|
def __repr__(self):
|
|
r"""__repr__(entity_instance self) -> std::string"""
|
|
return _ifcopenshell_wrapper.entity_instance___repr__(self)
|
|
|
|
def to_string(self, valid_spf=True):
|
|
r"""to_string(entity_instance self, bool valid_spf=True) -> std::string"""
|
|
return _ifcopenshell_wrapper.entity_instance_to_string(self, valid_spf)
|
|
|
|
def file_pointer(self):
|
|
r"""file_pointer(entity_instance self) -> size_t"""
|
|
return _ifcopenshell_wrapper.entity_instance_file_pointer(self)
|
|
|
|
def get_argument_index(self, a):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""setArgumentAsNull(entity_instance self, unsigned int i)"""
|
|
return _ifcopenshell_wrapper.entity_instance_setArgumentAsNull(self, i)
|
|
|
|
def setArgumentAsInt(self, i, v):
|
|
r"""setArgumentAsInt(entity_instance self, unsigned int i, int v)"""
|
|
return _ifcopenshell_wrapper.entity_instance_setArgumentAsInt(self, i, v)
|
|
|
|
def setArgumentAsBool(self, i, v):
|
|
r"""setArgumentAsBool(entity_instance self, unsigned int i, bool v)"""
|
|
return _ifcopenshell_wrapper.entity_instance_setArgumentAsBool(self, i, v)
|
|
|
|
def setArgumentAsLogical(self, i, v):
|
|
r"""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):
|
|
r"""setArgumentAsDouble(entity_instance self, unsigned int i, double v)"""
|
|
return _ifcopenshell_wrapper.entity_instance_setArgumentAsDouble(self, i, v)
|
|
|
|
def setArgumentAsString(self, i, a):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""setArgumentAsEntityInstance(entity_instance self, unsigned int i, entity_instance v)"""
|
|
return _ifcopenshell_wrapper.entity_instance_setArgumentAsEntityInstance(self, i, v)
|
|
|
|
def setArgumentAsAggregateOfEntityInstance(self, i, v):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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
|
|
|
|
# Register entity_instance in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.entity_instance_swigregister(entity_instance)
|
|
class IfcBaseEntity(entity_instance):
|
|
r"""Proxy of C++ IfcUtil::IfcBaseEntity class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def declaration(self):
|
|
r"""declaration(IfcBaseEntity self) -> declaration"""
|
|
return _ifcopenshell_wrapper.IfcBaseEntity_declaration(self)
|
|
|
|
def get(self, name):
|
|
r"""get(IfcBaseEntity self, std::string const & name) -> AttributeValue"""
|
|
return _ifcopenshell_wrapper.IfcBaseEntity_get(self, name)
|
|
|
|
def get_inverse(self, name):
|
|
r"""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):
|
|
r"""set_id(IfcBaseEntity self, boost::optional< unsigned int > const & i) -> unsigned int"""
|
|
return _ifcopenshell_wrapper.IfcBaseEntity_set_id(self, i)
|
|
|
|
def populate_derived(self):
|
|
r"""populate_derived(IfcBaseEntity self)"""
|
|
return _ifcopenshell_wrapper.IfcBaseEntity_populate_derived(self)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_IfcBaseEntity
|
|
|
|
# Register IfcBaseEntity in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.IfcBaseEntity_swigregister(IfcBaseEntity)
|
|
class IfcLateBoundEntity(IfcBaseEntity):
|
|
r"""Proxy of C++ IfcUtil::IfcLateBoundEntity class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, decl, data):
|
|
r"""__init__(IfcLateBoundEntity self, declaration decl, IfcEntityInstanceData data) -> IfcLateBoundEntity"""
|
|
_ifcopenshell_wrapper.IfcLateBoundEntity_swiginit(self, _ifcopenshell_wrapper.new_IfcLateBoundEntity(decl, data))
|
|
|
|
def declaration(self):
|
|
r"""declaration(IfcLateBoundEntity self) -> declaration"""
|
|
return _ifcopenshell_wrapper.IfcLateBoundEntity_declaration(self)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_IfcLateBoundEntity
|
|
|
|
# Register IfcLateBoundEntity in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.IfcLateBoundEntity_swigregister(IfcLateBoundEntity)
|
|
class IfcBaseType(entity_instance):
|
|
r"""Proxy of C++ IfcUtil::IfcBaseType class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
raise AttributeError("No constructor defined - class is abstract")
|
|
__repr__ = _swig_repr
|
|
|
|
def declaration(self):
|
|
r"""declaration(IfcBaseType self) -> declaration"""
|
|
return _ifcopenshell_wrapper.IfcBaseType_declaration(self)
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_IfcBaseType
|
|
|
|
# Register IfcBaseType in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.IfcBaseType_swigregister(IfcBaseType)
|
|
class parameter_type(object):
|
|
r"""Proxy of C++ IfcParse::parameter_type class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_parameter_type
|
|
|
|
def as_named_type(self):
|
|
r"""as_named_type(parameter_type self) -> named_type"""
|
|
return _ifcopenshell_wrapper.parameter_type_as_named_type(self)
|
|
|
|
def as_simple_type(self):
|
|
r"""as_simple_type(parameter_type self) -> simple_type"""
|
|
return _ifcopenshell_wrapper.parameter_type_as_simple_type(self)
|
|
|
|
def as_aggregation_type(self):
|
|
r"""as_aggregation_type(parameter_type self) -> aggregation_type"""
|
|
return _ifcopenshell_wrapper.parameter_type_as_aggregation_type(self)
|
|
|
|
def _is(self, *args):
|
|
r"""
|
|
_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):
|
|
r"""__init__(parameter_type self) -> parameter_type"""
|
|
_ifcopenshell_wrapper.parameter_type_swiginit(self, _ifcopenshell_wrapper.new_parameter_type())
|
|
|
|
# Register parameter_type in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.parameter_type_swigregister(parameter_type)
|
|
class named_type(parameter_type):
|
|
r"""Proxy of C++ IfcParse::named_type class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, declared_type):
|
|
r"""__init__(named_type self, declaration declared_type) -> named_type"""
|
|
_ifcopenshell_wrapper.named_type_swiginit(self, _ifcopenshell_wrapper.new_named_type(declared_type))
|
|
|
|
def declared_type(self):
|
|
r"""declared_type(named_type self) -> declaration"""
|
|
return _ifcopenshell_wrapper.named_type_declared_type(self)
|
|
|
|
def as_named_type(self):
|
|
r"""as_named_type(named_type self) -> named_type"""
|
|
return _ifcopenshell_wrapper.named_type_as_named_type(self)
|
|
|
|
def _is(self, *args):
|
|
r"""
|
|
_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
|
|
|
|
# Register named_type in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.named_type_swigregister(named_type)
|
|
class simple_type(parameter_type):
|
|
r"""Proxy of C++ IfcParse::simple_type class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__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):
|
|
r"""__init__(simple_type self, IfcParse::simple_type::data_type declared_type) -> simple_type"""
|
|
_ifcopenshell_wrapper.simple_type_swiginit(self, _ifcopenshell_wrapper.new_simple_type(declared_type))
|
|
|
|
def declared_type(self):
|
|
r"""declared_type(simple_type self) -> IfcParse::simple_type::data_type"""
|
|
return _ifcopenshell_wrapper.simple_type_declared_type(self)
|
|
|
|
def as_simple_type(self):
|
|
r"""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
|
|
|
|
# Register simple_type in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.simple_type_swigregister(simple_type)
|
|
class aggregation_type(parameter_type):
|
|
r"""Proxy of C++ IfcParse::aggregation_type class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__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):
|
|
r"""__init__(aggregation_type self, IfcParse::aggregation_type::aggregate_type type_of_aggregation, int bound1, int bound2, parameter_type type_of_element) -> aggregation_type"""
|
|
_ifcopenshell_wrapper.aggregation_type_swiginit(self, _ifcopenshell_wrapper.new_aggregation_type(type_of_aggregation, bound1, bound2, type_of_element))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_aggregation_type
|
|
|
|
def type_of_aggregation(self):
|
|
r"""type_of_aggregation(aggregation_type self) -> IfcParse::aggregation_type::aggregate_type"""
|
|
return _ifcopenshell_wrapper.aggregation_type_type_of_aggregation(self)
|
|
|
|
def bound1(self):
|
|
r"""bound1(aggregation_type self) -> int"""
|
|
return _ifcopenshell_wrapper.aggregation_type_bound1(self)
|
|
|
|
def bound2(self):
|
|
r"""bound2(aggregation_type self) -> int"""
|
|
return _ifcopenshell_wrapper.aggregation_type_bound2(self)
|
|
|
|
def type_of_element(self):
|
|
r"""type_of_element(aggregation_type self) -> parameter_type"""
|
|
return _ifcopenshell_wrapper.aggregation_type_type_of_element(self)
|
|
|
|
def as_aggregation_type(self):
|
|
r"""as_aggregation_type(aggregation_type self) -> aggregation_type"""
|
|
return _ifcopenshell_wrapper.aggregation_type_as_aggregation_type(self)
|
|
|
|
def type_of_aggregation_string(self):
|
|
r"""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()
|
|
)
|
|
|
|
|
|
# Register aggregation_type in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.aggregation_type_swigregister(aggregation_type)
|
|
class declaration(object):
|
|
r"""Proxy of C++ IfcParse::declaration class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, name, index_in_schema):
|
|
r"""__init__(declaration self, std::string const & name, int index_in_schema) -> declaration"""
|
|
_ifcopenshell_wrapper.declaration_swiginit(self, _ifcopenshell_wrapper.new_declaration(name, index_in_schema))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_declaration
|
|
|
|
def name(self):
|
|
r"""name(declaration self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.declaration_name(self)
|
|
|
|
def name_uc(self):
|
|
r"""name_uc(declaration self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.declaration_name_uc(self)
|
|
|
|
def as_type_declaration(self):
|
|
r"""as_type_declaration(declaration self) -> type_declaration"""
|
|
return _ifcopenshell_wrapper.declaration_as_type_declaration(self)
|
|
|
|
def as_select_type(self):
|
|
r"""as_select_type(declaration self) -> select_type"""
|
|
return _ifcopenshell_wrapper.declaration_as_select_type(self)
|
|
|
|
def as_enumeration_type(self):
|
|
r"""as_enumeration_type(declaration self) -> enumeration_type"""
|
|
return _ifcopenshell_wrapper.declaration_as_enumeration_type(self)
|
|
|
|
def as_entity(self):
|
|
r"""as_entity(declaration self) -> entity"""
|
|
return _ifcopenshell_wrapper.declaration_as_entity(self)
|
|
|
|
def _is(self, *args):
|
|
r"""
|
|
_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):
|
|
r"""index_in_schema(declaration self) -> int"""
|
|
return _ifcopenshell_wrapper.declaration_index_in_schema(self)
|
|
|
|
def type(self):
|
|
r"""type(declaration self) -> int"""
|
|
return _ifcopenshell_wrapper.declaration_type(self)
|
|
|
|
def schema(self):
|
|
r"""schema(declaration self) -> schema_definition"""
|
|
return _ifcopenshell_wrapper.declaration_schema(self)
|
|
|
|
# Register declaration in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.declaration_swigregister(declaration)
|
|
class type_declaration(declaration):
|
|
r"""Proxy of C++ IfcParse::type_declaration class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, name, index_in_schema, declared_type):
|
|
r"""__init__(type_declaration self, std::string const & name, int index_in_schema, parameter_type declared_type) -> type_declaration"""
|
|
_ifcopenshell_wrapper.type_declaration_swiginit(self, _ifcopenshell_wrapper.new_type_declaration(name, index_in_schema, declared_type))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_type_declaration
|
|
|
|
def declared_type(self):
|
|
r"""declared_type(type_declaration self) -> parameter_type"""
|
|
return _ifcopenshell_wrapper.type_declaration_declared_type(self)
|
|
|
|
def as_type_declaration(self):
|
|
r"""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):
|
|
r"""argument_types(type_declaration self) -> std::vector< std::string,std::allocator< std::string > >"""
|
|
return _ifcopenshell_wrapper.type_declaration_argument_types(self)
|
|
|
|
# Register type_declaration in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.type_declaration_swigregister(type_declaration)
|
|
class select_type(declaration):
|
|
r"""Proxy of C++ IfcParse::select_type class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, name, index_in_schema, select_list):
|
|
r"""__init__(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"""
|
|
_ifcopenshell_wrapper.select_type_swiginit(self, _ifcopenshell_wrapper.new_select_type(name, index_in_schema, select_list))
|
|
|
|
def select_list(self):
|
|
r"""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):
|
|
r"""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
|
|
|
|
# Register select_type in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.select_type_swigregister(select_type)
|
|
class enumeration_type(declaration):
|
|
r"""Proxy of C++ IfcParse::enumeration_type class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, name, index_in_schema, enumeration_items):
|
|
r"""__init__(enumeration_type self, std::string const & name, int index_in_schema, std::vector< std::string,std::allocator< std::string > > const & enumeration_items) -> enumeration_type"""
|
|
_ifcopenshell_wrapper.enumeration_type_swiginit(self, _ifcopenshell_wrapper.new_enumeration_type(name, index_in_schema, enumeration_items))
|
|
|
|
def enumeration_items(self):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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
|
|
|
|
# Register enumeration_type in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.enumeration_type_swigregister(enumeration_type)
|
|
class attribute(object):
|
|
r"""Proxy of C++ IfcParse::attribute class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, name, type_of_attribute, optional):
|
|
r"""__init__(attribute self, std::string const & name, parameter_type type_of_attribute, bool optional) -> attribute"""
|
|
_ifcopenshell_wrapper.attribute_swiginit(self, _ifcopenshell_wrapper.new_attribute(name, type_of_attribute, optional))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_attribute
|
|
|
|
def name(self):
|
|
r"""name(attribute self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.attribute_name(self)
|
|
|
|
def type_of_attribute(self):
|
|
r"""type_of_attribute(attribute self) -> parameter_type"""
|
|
return _ifcopenshell_wrapper.attribute_type_of_attribute(self)
|
|
|
|
def optional(self):
|
|
r"""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())
|
|
|
|
|
|
# Register attribute in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.attribute_swigregister(attribute)
|
|
class inverse_attribute(object):
|
|
r"""Proxy of C++ IfcParse::inverse_attribute class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__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):
|
|
r"""__init__(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"""
|
|
_ifcopenshell_wrapper.inverse_attribute_swiginit(self, _ifcopenshell_wrapper.new_inverse_attribute(name, type_of_aggregation, bound1, bound2, entity_reference, attribute_reference))
|
|
|
|
def name(self):
|
|
r"""name(inverse_attribute self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.inverse_attribute_name(self)
|
|
|
|
def type_of_aggregation(self):
|
|
r"""type_of_aggregation(inverse_attribute self) -> IfcParse::inverse_attribute::aggregate_type"""
|
|
return _ifcopenshell_wrapper.inverse_attribute_type_of_aggregation(self)
|
|
|
|
def bound1(self):
|
|
r"""bound1(inverse_attribute self) -> int"""
|
|
return _ifcopenshell_wrapper.inverse_attribute_bound1(self)
|
|
|
|
def bound2(self):
|
|
r"""bound2(inverse_attribute self) -> int"""
|
|
return _ifcopenshell_wrapper.inverse_attribute_bound2(self)
|
|
|
|
def entity_reference(self):
|
|
r"""entity_reference(inverse_attribute self) -> entity"""
|
|
return _ifcopenshell_wrapper.inverse_attribute_entity_reference(self)
|
|
|
|
def attribute_reference(self):
|
|
r"""attribute_reference(inverse_attribute self) -> attribute"""
|
|
return _ifcopenshell_wrapper.inverse_attribute_attribute_reference(self)
|
|
|
|
def type_of_aggregation_string(self):
|
|
r"""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
|
|
|
|
# Register inverse_attribute in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.inverse_attribute_swigregister(inverse_attribute)
|
|
class entity(declaration):
|
|
r"""Proxy of C++ IfcParse::entity class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, name, is_abstract, index_in_schema, supertype):
|
|
r"""__init__(entity self, std::string const & name, bool is_abstract, int index_in_schema, entity supertype) -> entity"""
|
|
_ifcopenshell_wrapper.entity_swiginit(self, _ifcopenshell_wrapper.new_entity(name, is_abstract, index_in_schema, supertype))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_entity
|
|
|
|
def is_abstract(self):
|
|
r"""is_abstract(entity self) -> bool"""
|
|
return _ifcopenshell_wrapper.entity_is_abstract(self)
|
|
|
|
def set_subtypes(self, subtypes):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""subtypes(entity self) -> std::vector< IfcParse::entity const *,std::allocator< IfcParse::entity const * > > const &"""
|
|
return _ifcopenshell_wrapper.entity_subtypes(self)
|
|
|
|
def attributes(self):
|
|
r"""attributes(entity self) -> std::vector< IfcParse::attribute const *,std::allocator< IfcParse::attribute const * > > const &"""
|
|
return _ifcopenshell_wrapper.entity_attributes(self)
|
|
|
|
def derived(self):
|
|
r"""derived(entity self) -> std::vector< bool,std::allocator< bool > > const &"""
|
|
return _ifcopenshell_wrapper.entity_derived(self)
|
|
|
|
def all_attributes(self):
|
|
r"""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):
|
|
r"""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):
|
|
r"""attribute_by_index(entity self, size_t index) -> attribute"""
|
|
return _ifcopenshell_wrapper.entity_attribute_by_index(self, index)
|
|
|
|
def attribute_count(self):
|
|
r"""attribute_count(entity self) -> size_t"""
|
|
return _ifcopenshell_wrapper.entity_attribute_count(self)
|
|
|
|
def attribute_index(self, *args):
|
|
r"""
|
|
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):
|
|
r"""supertype(entity self) -> entity"""
|
|
return _ifcopenshell_wrapper.entity_supertype(self)
|
|
|
|
def as_entity(self):
|
|
r"""as_entity(entity self) -> entity"""
|
|
return _ifcopenshell_wrapper.entity_as_entity(self)
|
|
|
|
def __repr__(self):
|
|
return "<entity %s>" % (self.name())
|
|
|
|
|
|
def argument_types(self):
|
|
r"""argument_types(entity self) -> std::vector< std::string,std::allocator< std::string > >"""
|
|
return _ifcopenshell_wrapper.entity_argument_types(self)
|
|
|
|
# Register entity in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.entity_swigregister(entity)
|
|
class schema_definition(object):
|
|
r"""Proxy of C++ IfcParse::schema_definition class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, name, declarations, factory):
|
|
r"""__init__(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"""
|
|
_ifcopenshell_wrapper.schema_definition_swiginit(self, _ifcopenshell_wrapper.new_schema_definition(name, declarations, factory))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_schema_definition
|
|
|
|
def declaration_by_name(self, *args):
|
|
r"""
|
|
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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""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):
|
|
r"""name(schema_definition self) -> std::string const &"""
|
|
return _ifcopenshell_wrapper.schema_definition_name(self)
|
|
|
|
def instantiate(self, decl, data):
|
|
r"""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())
|
|
|
|
|
|
# Register schema_definition in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.schema_definition_swigregister(schema_definition)
|
|
|
|
def schema_by_name(arg1):
|
|
r"""schema_by_name(std::string const & arg1) -> schema_definition"""
|
|
return _ifcopenshell_wrapper.schema_by_name(arg1)
|
|
|
|
def schema_names():
|
|
r"""schema_names() -> std::vector< std::string,std::allocator< std::string > >"""
|
|
return _ifcopenshell_wrapper.schema_names()
|
|
|
|
def register_schema(arg1):
|
|
r"""register_schema(schema_definition arg1)"""
|
|
return _ifcopenshell_wrapper.register_schema(arg1)
|
|
|
|
def clear_schemas():
|
|
r"""clear_schemas()"""
|
|
return _ifcopenshell_wrapper.clear_schemas()
|
|
class RocksDbSerializer(object):
|
|
r"""Proxy of C++ RocksDbSerializer class."""
|
|
|
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
|
__repr__ = _swig_repr
|
|
|
|
def __init__(self, *args):
|
|
r"""
|
|
__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
|
|
"""
|
|
_ifcopenshell_wrapper.RocksDbSerializer_swiginit(self, _ifcopenshell_wrapper.new_RocksDbSerializer(*args))
|
|
__swig_destroy__ = _ifcopenshell_wrapper.delete_RocksDbSerializer
|
|
|
|
def ready(self):
|
|
r"""ready(RocksDbSerializer self) -> bool"""
|
|
return _ifcopenshell_wrapper.RocksDbSerializer_ready(self)
|
|
|
|
def writeHeader(self):
|
|
r"""writeHeader(RocksDbSerializer self)"""
|
|
return _ifcopenshell_wrapper.RocksDbSerializer_writeHeader(self)
|
|
|
|
def finalize(self):
|
|
r"""finalize(RocksDbSerializer self)"""
|
|
return _ifcopenshell_wrapper.RocksDbSerializer_finalize(self)
|
|
|
|
def setFile(self, arg2):
|
|
r"""setFile(RocksDbSerializer self, file arg2)"""
|
|
return _ifcopenshell_wrapper.RocksDbSerializer_setFile(self, arg2)
|
|
|
|
# Register RocksDbSerializer in _ifcopenshell_wrapper:
|
|
_ifcopenshell_wrapper.RocksDbSerializer_swigregister(RocksDbSerializer)
|
|
|
|
def open(fn, readonly=False):
|
|
r"""open(std::string const & fn, bool readonly=False) -> file"""
|
|
return _ifcopenshell_wrapper.open(fn, readonly)
|
|
|
|
def read(data):
|
|
r"""read(std::string const & data) -> file"""
|
|
return _ifcopenshell_wrapper.read(data)
|
|
|
|
def stream_from_string(data):
|
|
r"""stream_from_string(std::string const & data) -> InstanceStreamer"""
|
|
return _ifcopenshell_wrapper.stream_from_string(data)
|
|
|
|
def version():
|
|
r"""version() -> char const *"""
|
|
return _ifcopenshell_wrapper.version()
|
|
|
|
def new_IfcBaseClass(schema_identifier, name):
|
|
r"""new_IfcBaseClass(std::string const & schema_identifier, std::string const & name) -> entity_instance"""
|
|
return _ifcopenshell_wrapper.new_IfcBaseClass(schema_identifier, name)
|
|
|
|
def get_log():
|
|
r"""get_log() -> std::string"""
|
|
return _ifcopenshell_wrapper.get_log()
|
|
|
|
def turn_on_detailed_logging():
|
|
r"""turn_on_detailed_logging()"""
|
|
return _ifcopenshell_wrapper.turn_on_detailed_logging()
|
|
|
|
def turn_off_detailed_logging():
|
|
r"""turn_off_detailed_logging()"""
|
|
return _ifcopenshell_wrapper.turn_off_detailed_logging()
|
|
|
|
def set_log_format_json():
|
|
r"""set_log_format_json()"""
|
|
return _ifcopenshell_wrapper.set_log_format_json()
|
|
|
|
def set_log_format_text():
|
|
r"""set_log_format_text()"""
|
|
return _ifcopenshell_wrapper.set_log_format_text()
|
|
|
|
def get_info_cpp(v, include_identifier=True):
|
|
r"""get_info_cpp(entity_instance v, bool include_identifier=True) -> PyObject"""
|
|
return _ifcopenshell_wrapper.get_info_cpp(v, include_identifier)
|
|
|