Modify gitignore

src/ifcsverchok/Makefile

@@ -0,0 +1,15 @@
+VERSION:=`date '+%y%m%d'`
+
+.PHONY: dist
+dist:
+	rm -rf dist
+	mkdir -p dist/ifcsverchok
+	cp -r ./*.py dist/ifcsverchok/
+	cp -r ./nodes dist/ifcsverchok/
+	cd dist/ifcsverchok && sed -i "s/999999/$(VERSION)/" __init__.py
+	cd dist && zip -r ifcsverchok-$(VERSION).zip ./*
+	rm -rf dist/ifcsverchok
+
+.PHONY: clean
+clean:
+	rm -rf dist

src/ifcsverchok/__init__.py

@@ -0,0 +1,129 @@
+bl_info = {
+    "name": "IFC for Sverchok",
+    "author": "Dion Moult",
+    "version": (0, 0, 999999),
+    "blender": (2, 90, 0),
+    "location": "Node Editor",
+    "category": "Node",
+    "description": "An extension to Sverchok to work with IFC data",
+    "tracker_url": "https://github.com/IfcOpenShell/IfcOpenShell/issues",
+    "warning": "",
+}
+
+import sys
+import importlib
+import nodeitems_utils
+import sverchok
+from sverchok.core import sv_registration_utils, make_node_list
+from sverchok.utils import auto_gather_node_classes, get_node_class_reference
+from sverchok.menu import SverchNodeItem, SverchNodeCategory, register_node_panels
+from sverchok.utils.extra_categories import register_extra_category_provider, unregister_extra_category_provider
+from sverchok.ui.nodeview_space_menu import make_extra_category_menus
+from sverchok.utils.logging import info, debug
+
+def nodes_index():
+    return [("IFC", [
+        ("ifc.create_file", "SvIfcCreateFile"),
+        ("ifc.read_file", "SvIfcReadFile"),
+        ("ifc.write_file", "SvIfcWriteFile"),
+        ("ifc.create_entity", "SvIfcCreateEntity"),
+        ("ifc.create_shape", "SvIfcCreateShape"),
+        ("ifc.read_entity", "SvIfcReadEntity"),
+        ("ifc.by_id", "SvIfcById"),
+        ("ifc.by_guid", "SvIfcByGuid"),
+        ("ifc.by_type", "SvIfcByType"),
+        ("ifc.by_query", "SvIfcByQuery"),
+        ("ifc.add", "SvIfcAdd"),
+        ("ifc.remove", "SvIfcRemove"),
+        ("ifc.generate_guid", "SvIfcGenerateGuid"),
+        ("ifc.get_property", "SvIfcGetProperty"),
+        ("ifc.get_attribute", "SvIfcGetAttribute"),
+        ("ifc.select_blender_objects", "SvIfcSelectBlenderObjects"),
+    ])]
+
+def make_node_list():
+    modules = []
+    base_name = "ifcsverchok.nodes"
+    index = nodes_index()
+    for category, items in index:
+        for module_name, node_name in items:
+            module = importlib.import_module(f".{module_name}", base_name)
+            modules.append(module)
+    return modules
+
+imported_modules = make_node_list()
+
+reload_event = False
+
+import bpy
+
+def register_nodes():
+    node_modules = make_node_list()
+    for module in node_modules:
+        module.register()
+    info("Registered %s nodes", len(node_modules))
+
+def unregister_nodes():
+    global imported_modules
+    for module in reversed(imported_modules):
+        module.unregister()
+
+def make_menu():
+    menu = []
+    index = nodes_index()
+    for category, items in index:
+        identifier = "IFCSVERCHOK_" + category.replace(' ', '_')
+        node_items = []
+        for item in items:
+            nodetype = item[1]
+            rna = get_node_class_reference(nodetype)
+            if not rna:
+                info("Node `%s' is not available (probably due to missing dependencies).", nodetype)
+            else:
+                node_item = SverchNodeItem.new(nodetype)
+                node_items.append(node_item)
+        if node_items:
+            cat = SverchNodeCategory(
+                        identifier,
+                        category,
+                        items=node_items
+                    )
+            menu.append(cat)
+    return menu
+
+class SvExCategoryProvider(object):
+    def __init__(self, identifier, menu):
+        self.identifier = identifier
+        self.menu = menu
+
+    def get_categories(self):
+        return self.menu
+
+our_menu_classes = []
+
+def register():
+    global our_menu_classes
+
+    debug("Registering ifcsverchok")
+
+    register_nodes()
+    extra_nodes = importlib.import_module(".nodes", "ifcsverchok")
+    auto_gather_node_classes(extra_nodes)
+    menu = make_menu()
+    menu_category_provider = SvExCategoryProvider("IFCSVERCHOK", menu)
+    register_extra_category_provider(menu_category_provider) #if 'IFCSVERCHOK' in nodeitems_utils._node_categories:
+    nodeitems_utils.register_node_categories("IFCSVERCHOK", menu)
+    our_menu_classes = make_extra_category_menus()
+
+def unregister():
+    global our_menu_classes
+    if 'IFCSVERCHOK' in nodeitems_utils._node_categories:
+        nodeitems_utils.unregister_node_categories("IFCSVERCHOK")
+    for clazz in our_menu_classes:
+        try:
+            bpy.utils.unregister_class(clazz)
+        except Exception as e:
+            print("Can't unregister menu class %s" % clazz)
+            print(e)
+    unregister_extra_category_provider("IFCSVERCHOK")
+    unregister_nodes()

src/ifcsverchok/helper.py

@@ -0,0 +1,14 @@
+import bpy
+from sverchok.data_structure import zip_long_repeat
+
+ifc_files = {}
+
+class SvIfcCore():
+    def process(self):
+        sv_inputs_nested = []
+        for name in self.sv_input_names:
+            sv_inputs_nested.append(self.inputs[name].sv_get())
+        for sv_input_nested in zip_long_repeat(*sv_inputs_nested):
+            for sv_input in zip_long_repeat(*sv_input_nested):
+                sv_input = list(sv_input)
+                self.process_ifc(*sv_input)

src/ifcsverchok/nodes/ifc/add.py

@@ -0,0 +1,37 @@
+import bpy
+import ifcopenshell
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcAdd(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcAdd'
+    bl_label = 'IFC Add'
+    file: StringProperty(name='file', update=updateNode)
+    entity: StringProperty(name='entity', update=updateNode)
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'file').prop_name = 'file'
+        self.inputs.new('SvStringsSocket', 'entity').prop_name = 'entity'
+        self.outputs.new('SvStringsSocket', 'file')
+        self.outputs.new('SvStringsSocket', 'entity')
+
+    def process(self):
+        self.sv_input_names = ['file', 'entity']
+        self.file_out = []
+        self.entity_out = []
+        super().process()
+        self.outputs['file'].sv_set([self.file_out])
+        self.outputs['entity'].sv_set([self.entity_out])
+
+    def process_ifc(self, file, entity):
+        self.entity_out.append(file.add(entity))
+        self.file_out.append(file)
+
+def register():
+    bpy.utils.register_class(SvIfcAdd)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcAdd)

src/ifcsverchok/nodes/ifc/by_guid.py

@@ -0,0 +1,31 @@
+import bpy
+import ifcopenshell
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcByGuid(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcByGuid'
+    bl_label = 'IFC By Guid'
+    file: StringProperty(name='file', update=updateNode)
+    guid: StringProperty(name='guid', update=updateNode)
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'file').prop_name = 'file'
+        self.inputs.new('SvStringsSocket', 'guid').prop_name = 'guid'
+        self.outputs.new('SvStringsSocket', 'entity')
+
+    def process(self):
+        self.sv_input_names = ['file', 'guid']
+        super().process()
+
+    def process_ifc(self, file, guid):
+        self.outputs['entity'].sv_set([[file.by_guid(guid)]])
+
+def register():
+    bpy.utils.register_class(SvIfcByGuid)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcByGuid)

src/ifcsverchok/nodes/ifc/by_id.py

@@ -0,0 +1,31 @@
+import bpy
+import ifcopenshell
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcById(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcById'
+    bl_label = 'IFC By Id'
+    file: StringProperty(name='file', update=updateNode)
+    id: StringProperty(name='id', update=updateNode)
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'file').prop_name = 'file'
+        self.inputs.new('SvStringsSocket', 'id').prop_name = 'id'
+        self.outputs.new('SvStringsSocket', 'entity')
+
+    def process(self):
+        self.sv_input_names = ['file', 'id']
+        super().process()
+
+    def process_ifc(self, file, id):
+        self.outputs['entity'].sv_set([[file.by_id(int(id))]])
+
+def register():
+    bpy.utils.register_class(SvIfcById)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcById)

src/ifcsverchok/nodes/ifc/by_query.py

@@ -0,0 +1,33 @@
+import bpy
+import ifcopenshell
+import ifcopenshell.util.selector
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcByQuery(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcByQuery'
+    bl_label = 'IFC By Query'
+    file: StringProperty(name='file', update=updateNode)
+    query: StringProperty(name='query', update=updateNode)
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'file').prop_name = 'file'
+        self.inputs.new('SvStringsSocket', 'query').prop_name = 'query'
+        self.outputs.new('SvStringsSocket', 'entity')
+
+    def process(self):
+        self.sv_input_names = ['file', 'query']
+        super().process()
+
+    def process_ifc(self, file, query):
+        selector = ifcopenshell.util.selector.Selector()
+        self.outputs['entity'].sv_set([selector.parse(file, query)])
+
+def register():
+    bpy.utils.register_class(SvIfcByQuery)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcByQuery)

src/ifcsverchok/nodes/ifc/by_type.py

@@ -0,0 +1,31 @@
+import bpy
+import ifcopenshell
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcByType(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcByType'
+    bl_label = 'IFC By Type'
+    file: StringProperty(name='file', update=updateNode)
+    type: StringProperty(name='type', update=updateNode)
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'file').prop_name = 'file'
+        self.inputs.new('SvStringsSocket', 'type').prop_name = 'type'
+        self.outputs.new('SvStringsSocket', 'entity')
+
+    def process(self):
+        self.sv_input_names = ['file', 'type']
+        super().process()
+
+    def process_ifc(self, file, type):
+        self.outputs['entity'].sv_set([file.by_type(type)])
+
+def register():
+    bpy.utils.register_class(SvIfcByType)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcByType)

src/ifcsverchok/nodes/ifc/create_entity.py

@@ -0,0 +1,92 @@
+import bpy
+import ifcopenshell
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcCreateEntity(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcCreateEntity'
+    bl_label = 'IFC Create Entity'
+    file: StringProperty(name='file', update=updateNode)
+    ifc_class: StringProperty(name='ifc_class', update=updateNode)
+    current_ifc_class: StringProperty(name='current_ifc_class')
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'file').prop_name = 'file'
+        self.inputs.new('SvStringsSocket', 'ifc_class').prop_name = 'ifc_class'
+        self.outputs.new('SvStringsSocket', 'file')
+        self.outputs.new('SvStringsSocket', 'entity')
+
+    def process(self):
+        self.sv_input_names = ['file', 'ifc_class']
+        ifc_class = self.inputs['ifc_class'].sv_get()[0][0]
+        if ifc_class:
+            file = self.inputs['file'].sv_get()[0][0]
+            if file:
+                schema_name = file.wrapped_data.schema
+            else:
+                schema_name = 'IFC4'
+            self.schema = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name)
+            self.entity_schema = self.schema.declaration_by_name(ifc_class)
+
+            if ifc_class != self.current_ifc_class:
+                self.generate_inputs(ifc_class)
+            try:
+                for i in range(0, len(self.inputs)):
+                    self.inputs[i].sv_get()
+            except:
+                # This occurs when a blender save file is reloaded
+                self.generate_inputs(ifc_class)
+
+            for i in range(0, self.entity_schema.attribute_count()):
+                self.sv_input_names.append(self.entity_schema.attribute_by_index(i).name())
+        super().process()
+
+    def generate_inputs(self, ifc_class):
+        while len(self.inputs) > 2:
+            self.inputs.remove(self.inputs[-1])
+        for i in range(0, self.entity_schema.attribute_count()):
+            name = self.entity_schema.attribute_by_index(i).name()
+            setattr(SvIfcCreateEntity, name, StringProperty(name=name))
+            self.inputs.new('SvStringsSocket', name).prop_name = name
+        self.current_ifc_class = ifc_class
+
+    def process_ifc(self, file, ifc_class, *attributes):
+        entity = file.create_entity(ifc_class)
+        for i in range(0, len(entity)):
+            try:
+                value = attributes[i]
+                if isinstance(value, str) and value == '':
+                    value = None
+            except:
+                value = None
+            if value is None and entity.is_a('IfcRoot') and i==0:
+                value = ifcopenshell.guid.new()
+            if value is not None:
+                value = self.cast_value(self.entity_schema.attribute_by_index(i), value)
+            try:
+                entity[i] = value
+            except:
+                raise Exception('The IFC class {} requires a valid value for {} - you provided {}'.format(
+                    ifc_class, entity.attribute_name(i), value))
+        self.outputs['file'].sv_set([[file]])
+        self.outputs['entity'].sv_set([[entity]])
+
+    def cast_value(self, attribute, value):
+        data_type = self.get_attribute_data_type(attribute.type_of_attribute())
+        if data_type == 'integer':
+            value = int(value)
+        return value
+
+    def get_attribute_data_type(self, data_type):
+        if hasattr(data_type, 'declared_type'):
+            return self.get_attribute_data_type(data_type.declared_type())
+        return data_type
+
+def register():
+    bpy.utils.register_class(SvIfcCreateEntity)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcCreateEntity)

src/ifcsverchok/nodes/ifc/create_file.py

@@ -0,0 +1,50 @@
+import bpy
+import ifcopenshell
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcCreateFileRefresh(bpy.types.Operator):
+    bl_idname = "node.sv_ifc_create_file_refresh"
+    bl_label = "LB Out"
+
+    idtree: StringProperty(default='')
+    idname: StringProperty(default='')
+    has_baked: bpy.props.BoolProperty(name='Has Baked', default=False)
+
+    def execute(self, context):
+        node = bpy.data.node_groups[self.idtree].nodes[self.idname]
+        node.process()
+        return {'FINISHED'}
+
+
+class SvIfcCreateFile(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcCreateFile'
+    bl_label = 'IFC Create File'
+    schema: StringProperty(name='schema', update=updateNode, default='IFC4')
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'schema').prop_name = 'schema'
+        self.outputs.new('SvVerticesSocket', 'file')
+
+    def draw_buttons(self, context, layout):
+        self.wrapper_tracked_ui_draw_op(layout, 'node.sv_ifc_create_file_refresh', icon='FILE_REFRESH', text='Refresh')
+
+    def process(self):
+        self.sv_input_names = ['schema']
+        super().process()
+
+    def process_ifc(self, schema):
+        guid = ifcopenshell.guid.new()
+        ifcsverchok.helper.ifc_files[guid] = ifcopenshell.file(schema=schema)
+        self.outputs['file'].sv_set([[ifcsverchok.helper.ifc_files[guid]]])
+
+def register():
+    bpy.utils.register_class(SvIfcCreateFile)
+    bpy.utils.register_class(SvIfcCreateFileRefresh)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcCreateFile)
+    bpy.utils.unregister_class(SvIfcCreateFileRefresh)

src/ifcsverchok/nodes/ifc/create_shape.py

@@ -0,0 +1,65 @@
+import bpy
+import logging
+import ifcopenshell
+import ifcsverchok.helper
+import blenderbim.bim.import_ifc
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcCreateShapeRefresh(bpy.types.Operator):
+    bl_idname = "node.sv_ifc_create_shape_refresh"
+    bl_label = "IFC Create Shape Refresh"
+    bl_options = {'UNDO'}
+
+    idtree: StringProperty(default='')
+    idname: StringProperty(default='')
+
+    def execute(self, context):
+        node = bpy.data.node_groups[self.idtree].nodes[self.idname]
+        node.process()
+        return {'FINISHED'}
+
+
+class SvIfcCreateShape(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcCreateShape'
+    bl_label = 'IFC Create Shape'
+    file: StringProperty(name='file', update=updateNode)
+    entity: StringProperty(name='entity', update=updateNode)
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'file').prop_name = 'file'
+        self.inputs.new('SvStringsSocket', 'entity').prop_name = 'entity'
+
+    def draw_buttons(self, context, layout):
+        self.wrapper_tracked_ui_draw_op(layout, 'node.sv_ifc_create_shape_refresh', icon='FILE_REFRESH', text='Refresh')
+
+    def process(self):
+        self.sv_input_names = ['file', 'entity']
+        super().process()
+
+    def process_ifc(self, file, entity):
+        try:
+            if not entity.is_a('IfcProduct'):
+                return
+            logger = logging.getLogger('ImportIFC')
+            self.ifc_import_settings = blenderbim.bim.import_ifc.IfcImportSettings.factory(bpy.context, '', logger)
+            settings = ifcopenshell.geom.settings()
+            shape = ifcopenshell.geom.create_shape(settings, entity)
+            ifc_importer = blenderbim.bim.import_ifc.IfcImporter(self.ifc_import_settings)
+            ifc_importer.file = file
+            mesh = ifc_importer.create_mesh(entity, shape)
+            obj = bpy.data.objects.new('IFC Element', mesh)
+            bpy.context.scene.collection.objects.link(obj)
+        except:
+            print('Entity could not be converted into a shape', entity)
+
+
+def register():
+    bpy.utils.register_class(SvIfcCreateShapeRefresh)
+    bpy.utils.register_class(SvIfcCreateShape)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcCreateShape)
+    bpy.utils.unregister_class(SvIfcCreateShapeRefresh)

src/ifcsverchok/nodes/ifc/generate_guid.py

@@ -0,0 +1,24 @@
+import bpy
+import ifcopenshell
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcGenerateGuid(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcGenerateGuid'
+    bl_label = 'IFC Generate Guid'
+
+    def sv_init(self, context):
+        self.outputs.new('SvStringsSocket', 'guid')
+
+    def process(self):
+        self.outputs['guid'].sv_set([[ifcopenshell.guid.new()]])
+
+
+def register():
+    bpy.utils.register_class(SvIfcGenerateGuid)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcGenerateGuid)

src/ifcsverchok/nodes/ifc/get_attribute.py

@@ -0,0 +1,41 @@
+import bpy
+import ifcopenshell
+import ifcopenshell.util.element
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcGetAttribute(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcGetAttribute'
+    bl_label = 'IFC Get Attribute'
+    entity: StringProperty(name='entity', update=updateNode)
+    attribute_name: StringProperty(name='attribute_name', update=updateNode)
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'entity').prop_name = 'entity'
+        self.inputs.new('SvStringsSocket', 'attribute_name').prop_name = 'attribute_name'
+        self.outputs.new('SvStringsSocket', 'value')
+
+    def process(self):
+        self.sv_input_names = ['entity', 'attribute_name']
+        self.value_out = []
+        super().process()
+        self.outputs['value'].sv_set(self.value_out)
+
+    def process_ifc(self, entity, attribute_name):
+        try:
+            if attribute_name.isnumeric():
+                self.value_out.append(entity[int(attribute_name)])
+            else:
+                self.value_out.append(entity.get_info()[attribute_name])
+        except:
+            pass
+
+
+def register():
+    bpy.utils.register_class(SvIfcGetAttribute)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcGetAttribute)

src/ifcsverchok/nodes/ifc/get_property.py

@@ -0,0 +1,40 @@
+import bpy
+import ifcopenshell
+import ifcopenshell.util.element
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcGetProperty(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcGetProperty'
+    bl_label = 'IFC Get Property'
+    entity: StringProperty(name='entity', update=updateNode)
+    pset_name: StringProperty(name='pset_name', update=updateNode)
+    prop_name: StringProperty(name='prop_name', update=updateNode)
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'entity').prop_name = 'entity'
+        self.inputs.new('SvStringsSocket', 'pset_name').prop_name = 'pset_name'
+        self.inputs.new('SvStringsSocket', 'prop_name').prop_name = 'prop_name'
+        self.outputs.new('SvStringsSocket', 'value')
+
+    def process(self):
+        self.sv_input_names = ['entity', 'pset_name', 'prop_name']
+        self.value_out = []
+        super().process()
+        self.outputs['value'].sv_set(self.value_out)
+
+    def process_ifc(self, entity, pset_name, prop_name):
+        try:
+            self.value_out.append(ifcopenshell.util.element.get_psets(entity)[pset_name][prop_name])
+        except:
+            pass
+
+
+def register():
+    bpy.utils.register_class(SvIfcGetProperty)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcGetProperty)

src/ifcsverchok/nodes/ifc/read_entity.py

@@ -0,0 +1,59 @@
+import bpy
+import ifcopenshell
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcReadEntity(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcReadEntity'
+    bl_label = 'IFC Read Entity'
+    file: StringProperty(name='file', update=updateNode)
+    entity: StringProperty(name='entity', update=updateNode)
+    current_ifc_class: StringProperty(name='current_ifc_class')
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'file').prop_name = 'file'
+        self.inputs.new('SvStringsSocket', 'entity').prop_name = 'entity'
+        self.outputs.new('SvStringsSocket', 'id')
+        self.outputs.new('SvStringsSocket', 'is_a')
+
+    def process(self):
+        self.sv_input_names = ['file', 'entity']
+        ifc_class = self.inputs['entity'].sv_get()[0][0]
+        if ifc_class:
+            ifc_class = ifc_class.is_a()
+            file = self.inputs['file'].sv_get()[0][0]
+            if file:
+                schema_name = file.wrapped_data.schema
+            else:
+                schema_name = 'IFC4'
+            self.schema = ifcopenshell.ifcopenshell_wrapper.schema_by_name(schema_name)
+            self.entity_schema = self.schema.declaration_by_name(ifc_class)
+
+            if ifc_class != self.current_ifc_class:
+                self.generate_outputs(ifc_class)
+        super().process()
+
+    def generate_outputs(self, ifc_class):
+        while len(self.outputs) > 2:
+            self.outputs.remove(self.outputs[-1])
+        for i in range(0, self.entity_schema.attribute_count()):
+            name = self.entity_schema.attribute_by_index(i).name()
+            self.outputs.new('SvStringsSocket', name).prop_name = name
+        self.current_ifc_class = ifc_class
+
+    def process_ifc(self, file, entity):
+        self.outputs['id'].sv_set([[entity.id()]])
+        self.outputs['is_a'].sv_set([[entity.is_a()]])
+        for i in range(0, self.entity_schema.attribute_count()):
+            name = self.entity_schema.attribute_by_index(i).name()
+            self.outputs[name].sv_set([[entity[i]]])
+
+
+def register():
+    bpy.utils.register_class(SvIfcReadEntity)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcReadEntity)

src/ifcsverchok/nodes/ifc/read_file.py

@@ -0,0 +1,31 @@
+import bpy
+import ifcopenshell
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcReadFile(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcReadFile'
+    bl_label = 'IFC Read File'
+    path: StringProperty(name='path', update=updateNode)
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'path').prop_name = 'path'
+        self.outputs.new('SvVerticesSocket', 'file')
+
+    def process(self):
+        self.sv_input_names = ['path']
+        super().process()
+
+    def process_ifc(self, path):
+        guid = ifcopenshell.guid.new()
+        ifcsverchok.helper.ifc_files[guid] = ifcopenshell.open(path)
+        self.outputs['file'].sv_set([[ifcsverchok.helper.ifc_files[guid]]])
+
+def register():
+    bpy.utils.register_class(SvIfcReadFile)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcReadFile)

src/ifcsverchok/nodes/ifc/remove.py

@@ -0,0 +1,37 @@
+import bpy
+import ifcopenshell
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcRemove(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcRemove'
+    bl_label = 'IFC Remove'
+    file: StringProperty(name='file', update=updateNode)
+    entity: StringProperty(name='entity', update=updateNode)
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'file').prop_name = 'file'
+        self.inputs.new('SvStringsSocket', 'entity').prop_name = 'entity'
+        self.outputs.new('SvStringsSocket', 'file')
+
+    def process(self):
+        file = self.inputs['file'].sv_get()[0][0]
+        self.new_file = ifcopenshell.file.from_string(file.wrapped_data.to_string())
+        self.remove_entity(self.inputs['entity'].sv_get())
+        self.outputs['file'].sv_set([[self.new_file]])
+
+    def remove_entity(self, entity):
+        if isinstance(entity, (tuple, list)):
+            for e in entity:
+                self.remove_entity(e)
+        else:
+            self.new_file.remove(self.new_file.by_id(entity.id()))
+
+def register():
+    bpy.utils.register_class(SvIfcRemove)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcRemove)

src/ifcsverchok/nodes/ifc/select_blender_objects.py

@@ -0,0 +1,56 @@
+import bpy
+import ifcopenshell
+import ifcopenshell.util.selector
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcSelectBlenderObjectsRefresh(bpy.types.Operator):
+    bl_idname = "node.sv_ifc_select_blender_objects_refresh"
+    bl_label = "IFC Select Blender Objects Refresh"
+    bl_options = {'UNDO'}
+
+    idtree: StringProperty(default='')
+    idname: StringProperty(default='')
+
+    def execute(self, context):
+        node = bpy.data.node_groups[self.idtree].nodes[self.idname]
+        node.process()
+        return {'FINISHED'}
+
+
+class SvIfcSelectBlenderObjects(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcSelectBlenderObjects'
+    bl_label = 'IFC Select Blender Objects'
+    file: StringProperty(name='file', update=updateNode)
+    query: StringProperty(name='query', update=updateNode)
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'entities').prop_name = 'entities'
+
+    def draw_buttons(self, context, layout):
+        self.wrapper_tracked_ui_draw_op(layout, 'node.sv_ifc_select_blender_objects_refresh', icon='FILE_REFRESH', text='Refresh')
+
+    def process(self):
+        self.sv_input_names = ['entities']
+        self.guids = []
+        super().process()
+        for obj in bpy.context.visible_objects:
+            index = obj.BIMObjectProperties.attributes.find('GlobalId')
+            if index != -1 \
+                    and obj.BIMObjectProperties.attributes[index].string_value in self.guids:
+                obj.select_set(True)
+
+    def process_ifc(self, entities):
+        self.guids.append(entities.GlobalId)
+
+
+def register():
+    bpy.utils.register_class(SvIfcSelectBlenderObjectsRefresh)
+    bpy.utils.register_class(SvIfcSelectBlenderObjects)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcSelectBlenderObjects)
+    bpy.utils.unregister_class(SvIfcSelectBlenderObjectsRefresh)

src/ifcsverchok/nodes/ifc/write_file.py

@@ -0,0 +1,30 @@
+import bpy
+import ifcopenshell
+import ifcsverchok.helper
+from bpy.props import StringProperty
+from sverchok.node_tree import SverchCustomTreeNode
+from sverchok.data_structure import updateNode
+
+
+class SvIfcWriteFile(bpy.types.Node, SverchCustomTreeNode, ifcsverchok.helper.SvIfcCore):
+    bl_idname = 'SvIfcWriteFile'
+    bl_label = 'IFC Write File'
+    file: StringProperty(name='file', update=updateNode)
+    path: StringProperty(name='path', update=updateNode)
+
+    def sv_init(self, context):
+        self.inputs.new('SvStringsSocket', 'file').prop_name = 'file'
+        self.inputs.new('SvStringsSocket', 'path').prop_name = 'path'
+
+    def process(self):
+        self.sv_input_names = ['file', 'path']
+        super().process()
+
+    def process_ifc(self, file, path):
+        file.write(path)
+
+def register():
+    bpy.utils.register_class(SvIfcWriteFile)
+
+def unregister():
+    bpy.utils.unregister_class(SvIfcWriteFile)