Question about using api.geometry.add_window_represetation.usecase.create_ifc_window_frame_simple

[fdh-fdh]

Hi there,
i am currently working on a project aiming to updating IFC using LIDAR-generated Point cloud data.
Updating a void, for instance, into an existing IfcWall
the problem i get is having the issue of using this class method to create a windows void:
here is my code:

import numpy as np
import ifcopenshell
from ifcopenshell.api import run, geometry
from ifcopenshell.api.geometry.add_window_representation import  Usecase
from ifcopenshell.geom import settings
from ifcopenshell.util import shape_builder
import uuid
from mathutils import Vector

class VoidingFromPointCloud:
    def __init__(self, x_min, y_min, z_min, x_length, y_length, z_length):
    #xz is the windows size and y is the depth
    #the original intention is to take over the voids data using this pre-defined class calculated from Pointcloud data.
    #as an examople : size = (voiding.x_length[0],voiding.y_length[0],voiding.z_length[0])
    #x,y,z min give the position of the void.

        self.x_min = x_min,
        self.y_min = y_min,
        self.z_min = z_min,
        self.x_length = x_length,
        self.y_length = y_length,
        self.z_length = z_length,
        self.midPoint = [x_min+x_length/2, y_min+y_length/2, z_min+z_length/2]

def Opening_Update(ifc_file_path,voiding:VoidingFromPointCloud):
    ifc = ifcopenshell.open(ifc_file_path)
    owner_history = ifc.by_type("IfcOwnerHistory")[0]
    project = ifc.by_type("IfcProject")[0]
    #context = ifc.by_type("IfcGeometricRepresentationContext")[0]

    # initialising the unique id generator
    create_guid = lambda: ifcopenshell.guid.compress(uuid.uuid1().hex)


    #for convience i defined it here with constant value
    window_size = (3.08,3.2,0.2)
    window_thickness = 0.2
    # should here be a relative coordinates due to the wall or globle coordinates
    window_position = (27.775,-0.0999,1.779)
    settings = ifcopenshell.geom.settings()
    usecase = Usecase(ifc,settings).execute()
  
    usecase.create_ifc_window_frame_simple(size=Vector(window_size), thickness=window_thickness, position=Vector(window_position))
    ifc.write("output.ifc")

if __name__=="__main__":
    divisor = 1000
    Voiding_1_in_milimeter = np.asarray([165852.0, 81966.0, 10360.0, 3080.0, 200.0, 3200.0])
    Voiding_1_in_meter = np.divide(Voiding_1_in_milimeter, 1000)
    Voiding1 = VoidingFromPointCloud(*(Voiding_1_in_meter.tolist()))  # in mm and float data type

    Opening_Update(
        '/git_repo/Update-model-fron-Point-Cloud-to-IFC/input/input_V2.ifc',
        Voiding1)

I am not really sure how to use this method.
There's not really a lot to find in the doc
is the returned segment a representation of the void?
Do I need to bring it into the IFCproject ?
The setting is also an input argument of the method, but each time it says there's too much argument i gave in, and they don't recognize it.

Also, I got this error if I did not pass by settings during calling the execution function.

if self.settings["context"].TargetView == "ELEVATION_VIEW":
AttributeError: 'NoneType' object has no attribute 'TargetView'

Do you have maybe other method to use, if it does not make sense at all, aiming for this purpose?
Here is a segment of the model which for testing to create a void, along with some existing ones.
https://www.dropbox.com/scl/fi/vornb1u1ol1f6mrqkwbs8/input_V2.ifc?rlkey=mthfb3df641w3gcyj6w0oo4w3&dl=0
thanks so much for the help!

[Moult]

I highly recommend you read through https://blenderbim.org/docs-python/ifcopenshell-python/geometry_creation.html which will give you a comprehensive understanding of the fundamentals of how geometry works in IFC. It also contains code examples which you can adapt and will help you understand how to supply a context.

[fdh-fdh]

Thank you for answering !
I have tried using this doc to create geometry, however, the wall I created in new file I could see it. But the opening which i use
ifcopenshell.api.run(“void.add_opening”, model, opening=opening, element=wall)
to create the in dependencies to the wall, it could not be shown in the Revit, and is not in the hierarchy.

Have you got a suggestion where the problem could be ?

Thanks so much !

[Moult]

Potentially your opening has incorrect coordinates? Have you tried loading the IFC with the BlenderBIM Add-on to check whether the problem is specific to Revit or your file is incorrect?

[fdh-fdh]

Yes, Blender could open the file without problems, but Revit does.

[fdh-fdh]

for instance, this code: which mostly copied from the doc.
should created a file with a wall and a void on it.
but there is only a wall, without a void both in blender and in OpenIfcviewer is there to open.
maybe could you know why ?

def Opening_Update():

    model = ifcopenshell.file()

    # All projects must have one IFC Project element
    project = run("root.create_entity", model, ifc_class="IfcProject", name="My Project")

    # Geometry is optional in IFC, but because we want to use geometry in this example, let's define units
    # Assigning without arguments defaults to metric units
    run("unit.assign_unit", model)

    # Let's create a modeling geometry context, so we can store 3D geometry (note: IFC supports 2D too!)
    context = run("context.add_context", model, context_type="Model")

    # In particular, in this example we want to store the 3D "body" geometry of objects, i.e. the body shape
    body = run("context.add_context", model, context_type="Model",
               context_identifier="Body", target_view="MODEL_VIEW", parent=context)

    # Create a site, building, and storey. Many hierarchies are possible.
    site = run("root.create_entity", model, ifc_class="IfcSite", name="My Site")
    building = run("root.create_entity", model, ifc_class="IfcBuilding", name="Building A")
    storey = run("root.create_entity", model, ifc_class="IfcBuildingStorey", name="Ground Floor")

    # Since the site is our top level location, assign it to the project
    # Then place our building on the site, and our storey in the building
    run("aggregate.assign_object", model, relating_object=project, product=site)
    run("aggregate.assign_object", model, relating_object=site, product=building)
    run("aggregate.assign_object", model, relating_object=building, product=storey)

    # Let's create a new wall
    wall = run("root.create_entity", model, ifc_class="IfcWall")

    # Give our wall a local origin at (2, 3, 5)
    matrix = np.eye(4)
    matrix[:, 3][0:3] = (2, 3, 5)
    run("geometry.edit_object_placement", model, product=wall,matrix=matrix)

    # Add a new wall-like body geometry, 5 meters long, 3 meters high, and 200mm thick
    representation = run("geometry.add_wall_representation", model, context=body, length=5, height=3, thickness=0.2)
    # Assign our new body geometry back to our wall
    run("geometry.assign_representation", model, product=wall, representation=representation)

    # Place our wall in the ground floor
    run("spatial.assign_container", model, relating_structure=storey, product=wall)

    opening = ifcopenshell.api.run("root.create_entity", model, ifc_class="IfcOpeningElement")

    # Let's create an opening representation of a 950mm x 1100mm door.
    # Notice how the thickness is greater than the wall thickness, this
    # helps resolve floating point resolution errors in 3D.
    representation = ifcopenshell.api.run("geometry.add_wall_representation", model,
                                          context=body, length=.95, height=1.1, thickness=0.2)
    ifcopenshell.api.run("geometry.assign_representation", model,
                         product=opening, representation=representation)

    # Let's shift our door 1 meter along the wall and 100mm along the
    # wall, to create a nice overlap for the opening boolean.
    matrix = np.identity(4)
    matrix[:, 3] = [1, -.1, 0, 0]
    ifcopenshell.api.run("geometry.edit_object_placement", model, product=opening, matrix=matrix)

    # The opening will now void the wall.
    ifcopenshell.api.run("void.add_opening", model, opening=opening, element=wall)

    # Write out to a file
    model.write("model_test.ifc")
if __name__=="__main__":
    Opening_Update()

but in the ifc file: the opening element is created as here you see

[Moult]

Your opening coordinates are incorrect. You have placed your opening at 1,-.1,0 whereas your wall is at 2,3,5.

[fdh-fdh]

thank you for answer the questions. i have found the issue, and it works now!

[fdh-fdh]

Hi there,
there is another question coming up.
logically each time if i wanna to create a void which go through the wall i need to use a bigger thickness than the wall.
but it seems that the maximal of the opening which ever could be created, is the half thickness of the wall. more bigger could not be shown in the ifc and stay always with half thick as the wall.
that made me have to put two openings at the same pos, with positive and negative thickniss, than could ever create a opening that go through the wall.

do you know why that happening
i calculate the relative pos of the opening base on the pos coordinates of the wall which contains the opening.

here is my code.

import numpy as np
import ifcopenshell
from ifcopenshell.api import run, geometry
from ifcopenshell.util import shape_builder, placement
from Geometry3D import Point
import Toolbox

class VoidingFromPointCloud:
    def __init__(self, x_min, y_min, z_min, x_length, y_length, z_length):
        self.x_min = x_min,
        self.y_min = y_min,
        self.z_min = z_min,
        self.x_length = x_length,
        self.y_length = y_length,
        self.z_length = z_length,
        self.midPoint = [x_min+x_length/2, y_min+y_length/2, z_min+z_length/2]

def Opening_Update(ifc,voiding):
    containingwall = Toolbox.find_containing_wall(ifcopenshell.open(ifc),voiding)
    model = ifcopenshell.open(ifc)
    body = model.by_type("IfcGeometricRepresentationSubContext")[1]
    print(body)

    #reading contatining wall coordintate.
    containingwall_position = ifcopenshell.util.placement.get_local_placement(containingwall.ObjectPlacement)
    voiding_placement_point = Point(voiding.x_min[0], voiding.y_min[0], voiding.z_min[0])

    relative_Pos = np.eye(4)

    # relative_Pos[:,3]= [31.975000000000321,1.7799999999999137,0.099999999999994593,0]
    #relative_Pos[:,3]= [voiding.x_min[0],voiding.z_min[0],voiding.y_min[0],0]


    # relative_Pos[0,3]= voiding_placement_point.x-containingwall_position[0,3]
    # relative_Pos[1,3]= voiding_placement_point.y-containingwall_position[1,3]
    # relative_Pos[2,3]= voiding_placement_point.z-containingwall_position[2,3]
    # relative_Pos[3,3]= 0
    relative_Pos[0,3]= containingwall_position[0,3]+1
    relative_Pos[1,3]= containingwall_position[1,3]
    relative_Pos[2,3]= containingwall_position[2,3]+0.2
    relative_Pos[3,3]= 0
    print(relative_Pos)



    opening = ifcopenshell.api.run("root.create_entity", model, ifc_class="IfcOpeningElement")


    representation = ifcopenshell.api.run("geometry.add_wall_representation", model,
                                          context=body, length=voiding.x_length[0], height=voiding.z_length[0], thickness=voiding.y_length[0])
    ifcopenshell.api.run("geometry.assign_representation", model,
                         product=opening, representation=representation)
    ifcopenshell.api.run("geometry.edit_object_placement", model, product=opening, matrix= relative_Pos)

    ifcopenshell.api.run("void.add_opening", model, opening=opening, element=containingwall)

    #it shall have to create openings from both sides, which is wired but it works.
    opening = ifcopenshell.api.run("root.create_entity", model, ifc_class="IfcOpeningElement")
    representation = ifcopenshell.api.run("geometry.add_wall_representation", model,
                                          context=body, length=voiding.x_length[0], height=voiding.z_length[0], thickness=-1*voiding.y_length[0])
    ifcopenshell.api.run("geometry.assign_representation", model,
                         product=opening, representation=representation)
    ifcopenshell.api.run("geometry.edit_object_placement", model, product=opening, matrix= relative_Pos)

    ifcopenshell.api.run("void.add_opening", model, opening=opening, element=containingwall)





    model.write("model_test_result_pos_100_test.ifc")
if __name__=="__main__":

    ifc_path = "/Users/ffffdh/Desktop/BIM_Update_Py/git_repo/Update-model-fron-Point-Cloud-to-IFC/input/input_V2.ifc"
    model = ifcopenshell.open(ifc_path)
    divisor = 1000
    Voiding_1_in_milimeter = np.asarray([165852.0, 81966.0, 10360.0, 3080.0, 200.0, 3200.0])
    Voiding_1_in_meter = np.divide(Voiding_1_in_milimeter, 1000)
    voiding1 = VoidingFromPointCloud(*(Voiding_1_in_meter.tolist()))  # in mm and float data type
    #con_Wall= Toolbox.find_containing_wall(model,voiding1)
    Opening_Update(ifc_path,voiding1)

thanks so much !!!!!