Removing tolerance between elements - stretching any surface through API

[roehligas]

Hi,

one of my coworkers came yesterday with an interesting request.

We have a script that is adding tolerance between CLT elements, see below. It is not checking the actual tolerance yet, but this could be implemented.

Sadly it only works one way, we didn't figure out a way to stretch the surfaces outwards, in other words increase the width/height/length of elements with continuous laps, drillings etc.

Will this be solved by the implementation of the function that returns the operation geometries more detailed?
Will those geometries exceed the elements original boundbox or would they also need to be stretched? If they need to be stretched, we'll kind of run into the same problem for this case.

# import modules
import  cadwork   
import  element_controller      as ec
import  attribute_controller    as ac
import geometry_controller      as gc
import utility_controller       as uc
import visualization_controller as vc
import file_controller          as fc
import time
import os
import math

# Get active elements
active_elements = ec.get_active_identifiable_element_ids()

print(active_elements)

# Get user input for sideways shrinking
shrinking_value = uc.get_user_double('How much shall elements be shrinked in total?')

# Ask user if elements should also shrink in length
shrink_in_length = uc.get_user_bool('Do you want to shrink in length direction?', False)

# Loop over all active elements
for elem in active_elements:
    
    # Create a temporary beam with the exact same rough dimensions as the current element
    bb_copy = ec.create_rectangular_beam_points(gc.get_width(elem),gc.get_height(elem),gc.get_p1(elem),gc.get_p2(elem),gc.get_p3(elem))
    
    # Subtract current element from temporary beam to receive all operations on the beam as geometry
    difference_objects = ec.subtract_elements([elem],[bb_copy])
    difference_objects.append(bb_copy)
    
    # Reduce width of the current element, this will also delete all operations
    gc.set_width_real([elem],gc.get_width(elem)-shrinking_value)
       
    # Reduce length if requested
    if shrink_in_length:
        gc.set_length_real([elem],gc.get_length(elem)-shrinking_value)
    
    
    #print(difference_objects)

    # Subtract all operations from the shrinked element
    elem_out = ec.subtract_elements(difference_objects,[elem])
    
    # Delete operations geometry
    ec.delete_elements(difference_objects)

    #print(gc.get_minimum_distance_between_elements(active_elements[0],active_elements[1]))

[roehligas]

I made a quick example to visualize, i guess it'll be hard to understand otherwise.

Run the script above and type in negative tolerance. If there are operations on the edge of the element, they'll be faulty.
If we'd stretch the surfaces out the software would understand correctly in most cases i think.

[NOPKGer]

I think you can do it with this function "ec.stretch_start_facet()", but you may need to temporarily realign the axes so that the area where p1 is located is stretched with this function.
The function then works in both directions.
Here is an example with user input to rotate the axes, but this can also be automated:

import element_controller as ec
import cadwork
import geometry_controller as gc
import utility_controller as uc

element_ids = ec.get_active_identifiable_element_ids()
distance = 75.

for element_id in element_ids:
    #save old directon
    diretcion = (gc.get_p1(element_id),gc.get_p2(element_id))
    #get new directon from 2 points with user input
    new_direction = uc.get_user_points_with_count(2)
    # Rotating the length axis
    gc.rotate_length_axis_2_points([element_id],new_direction[0],new_direction[1])
    #set stretch vector
    xl = gc.get_xl(element_id) * distance
    #stretch start facet (p1)
    ec.stretch_start_facet([element_id], xl)
    # Rotating the length axis back
    gc.rotate_length_axis_2_points([element_id],diretcion[0],diretcion[1])

[roehligas]

I like the idea, but it's not working with drillings close to the border, see image below.

[NOPKGer]

As it looks, only the surface in which the points of the axis rotation are located is stretched.
In this case, you would have to repeat this for each surface. Automating this is more complex but not impossible.
But maybe there is an easier way that I don't even see

[roehligas]

@Brunner246 this one popped into my head again, now that the API is updated and introduced objects such as vertice_list, is it now possible to stretch specific surfaces through the python API? I have several use cases for this where it would come in handy... :)

[roehligas]

Just to clarify, I'm talking about surfaces of a beam for example, such as using Key combination 7+A.

To stretch a normal surface object shouldn't be a necessary function based on your suggestion as one could create a polygon beam.(?)

Sorry for not being specific enough in the question.

[Brunner246]

My idea was meant like this. "Similar" behaviour to Key comb. 7 + A

import cadwork 
import element_controller as ec
import geometry_controller as gc
import attribute_controller as ac
import logging

logging.basicConfig(level=logging.DEBUG)

def main():
    active_beam_ids = get_active_beam_ids()
    logging.info(f"Active beam ids: {active_beam_ids}")
    for element_id in active_beam_ids:
        logging.info(f"Processing element {element_id}")
        extruded_faces_ids = process_element_facets(element_id)
        ec.solder_elements([element_id] + extruded_faces_ids)

def get_active_beam_ids():
    active_element_ids = ec.get_active_identifiable_element_ids()
    return filter(lambda element: ac.get_element_type(element).is_rectangular_beam(), active_element_ids)

def process_element_facets(element_id):
    element_facets = gc.get_element_facets(element_id)

    extruded_faces_ids = []

    for index in range(element_facets.count()):
        external_polygon = element_facets.get_external_polygon(index)
        face_normal = element_facets.get_normal_vector(index)
        surface_elment_id = ec.create_surface([vertice for vertice in external_polygon])
        logging.info("Create surface for face polygon with index {index}")
        EXTRUDE_DISTANCE = 300  # just some random extrusion distance
        extruded_geometry = extrude_along_vector(surface_elment_id, face_normal, EXTRUDE_DISTANCE)
        extruded_faces_ids.append(extruded_geometry)

        log_geometry_info(external_polygon, face_normal, extruded_geometry)
    
    return extruded_faces_ids

def extrude_along_vector(surface_id, vector, distance):
    vector_distance = vector * distance
    return ec.extrude_surface_to_beam_vector(surface_id, vector_distance)

def log_geometry_info(external_polygon, face_normal, extruded_geometry):
    logging.info(f"External polygon: {external_polygon}")
    logging.info(f"Face normal: {face_normal}")
    logging.info(f"Extruded geometry: {extruded_geometry}")

if __name__ == '__main__':
    main()

[roehligas]

This approach goes a long way when it comes to volume estimation, but it is geometrically wrong in most cases.

It would be awesome to have a function allows stretching with a specific offset (7+A) and/or to a target plane (7+A+F) that interacts with the original volume in the way those manual functions do.

Is it hard to bridge from the manual functions to the API?

[Brunner246]

@roehligas

We can create a function for that use case. But how do you know which facet you want to stretch?

just an example of a "simple beam"

[roehligas]

My main purpose with this is to automize the tedious manual job of fixing geometries after IFC import.

Field of usage

We usually get very highly detailed/finished models as IFC files, so all that's left for us to do is fix geometry after import and adjust tolerances to our needs, do some fiddling around to simplify for the machines...
We always cut out all openings/drillings from the geometry because we send the modell as IFC for approval with final geometry, and calculating the cutouts during export takes a lot of time for each export in very big constructions, and there is a high chance that it goes several rounds...

Increasing tolerances for example around dowel connections with steel plate is simple, create a dummy-beam and substract it.

Decreasing manually is rather simple by meassuring first and then using 7+A. Sometimes the angle is wrong, then it's a bit more work to use 7+A+A against a aligned surface. But decreasing tolerances automatically seems impossible with the currently given tools. Soldering together with a beam covers drillings and affects other operations such as angled cuts,...

Backstory:

I had a discussion with Jan R. from Cadwork when he visited us earlier this year that ideally you should give the API access to the geometries that are calculated when using Ctrl+D. Access to classify and manipulate those geometries would allow a highly automated workflow when it comes to detecting systematic errors, apply / edit tolerances, find almost-90-degree operations, check processes and correct before calculating machine data, auto-rotate beams according to their operations for machining,...

Other programs out there have extensive functionality to auto-detect / auto-correct / auto-modify geometry before / during export and i wished this was also possible in Cadwork. One downside that I name openly is that it would be possible to sort of write your own machine export... But by commercializing access to the functionality you could protect/keep track of it after all...

I understood from Jan that it is not planned to implement this sort of functionality, which is why I'm trying to work my way around by stretching surfaces (amongst other quick-fixes).

Starting in 2020 I have written plenty of python-scripts that do extensive modifications on the exported BVN-files and BTL-files, simply because the machine export / geometries that define the machinings are sort of a blackbox for us end users.
Exporting as BTL, modifying it with scripts and importing it again saved me weeks of work on several projects so far. The loss of precision from BTL-import was the only real downside on that approach. This is honestly how I worked before Jan told me that the Python API exists... I created new operations and/or modified operations in BTL to get to the desired geometries. To this day we use some standard scripts on every single project to do some tweaking on BTL- and BVN operations before we send them to the machine, both to adjust tolerances, modify attributes and to reduce runtime.

The approach for the original request:

My plan to detect which one to stretch is by calculating the alignment, for example angle and distance from the elements centerline (p2-p1) or reference sides, distance from connectors,... Basically looping over the facets list and apply criteria matching to find systematic problems and store the surface reference. After would calculate the ideal position of the surfaces and stretch them to that position. But it is really more of a workaround than a proudly solution. The fact that you changed the library just redirected my attention to this approach once again...

[Brunner246]

Hi,

Why do you cut the geometries (drillings, openings)?
If you export this from cadwork, there are settings so that the geometries like drillings are exported cut in.

If you import IFC files, there are options for creating bolts from drillings, for example.

def replace_physical_drillings_with_drilling_axes(aElementIDList: list[int], aMininumDiameter: float, aMaximumDiameter: float) -> list[int]

or for undoing physical "cuttings"

def delete_processes_keep_cutting_bodies(elements: list[int], keep_cutting_elements_only: bool) -> list[int]

i have added the api function for stretching certain facets to our backlog.