How to transform global axis into local using python in cadwork?

[lucas-ita]

Hi,
Could someone please share a code snippet utilizing the apply_transformation_coordinate(elements, old_point, old_xl, old_yl, new_point, new_xl, new_yl) method? To aid our understanding, let's consider a practical example involving an inclined beam in Cadwork. Let's envision placing the beam in a scene and, subsequently, using the mentioned method to transform the global axis into local coordinates. The expected outcome is that the beam no longer remains inclined.

[Brunner246]

you could do something like this

from typing import List

import cadwork
import element_controller as ec
import geometry_controller as gc


def get_element_orientation_and_position(element_id: int):
    point1 = gc.get_p1(element_id)
    x_direction = gc.get_xl(element_id)
    y_direction = gc.get_yl(element_id)
    return point1, x_direction, y_direction


def transform_element(element_id: int, point1_new: cadwork.point_3d, x_direction_new: cadwork.point_3d,
                      y_direction_new: cadwork.point_3d):
    point1_old, x_direction_old, y_direction_old = get_element_orientation_and_position(element_id)
    ec.apply_transformation_coordinate([element_id],
                                       point1_old,
                                       x_direction_old,
                                       y_direction_old,
                                       point1_new,
                                       x_direction_new,
                                       y_direction_new)


if __name__ == '__main__':
    element_ids: List[int] = ec.get_user_element_ids()

    x_direction_new = cadwork.point_3d(1., 0., 0.)
    y_direction_new = cadwork.point_3d(0., 1., 0.)

    for element_id in element_ids:
        point1_new = gc.get_p1(element_id) # or set your preferred position
        transform_element(element_id, point1_new, x_direction_new, y_direction_new)

[Brunner246]

I havent tested it so far, but maybe that could be something for you https://github.com/sympy/sympy

[roehligas]

I honestly haven't tried sympy within cadwork yet, I assumed it would be rather slow. I use it a lot outside of cadwork though. I'll look into this!

But I still think that the above mentioned functionality should be a part of the cadwork standard library, it would make the code so much cleaner for me personally... :)

[Brunner246]

we want to keept the cwapi3d consistent with just cadwork functions. But we can start with a vector class in cwmath.

[Brunner246]

Unfortunately, the cwmath library has not undergone much further development. I have now added a few initial examples. We will merge this soon. As I said, the goal is for this to be developed further with the community ;)

https://github.com/cwapi3d/cwmath/tree/feature/vector-plane-class/src/cwmath

[roehligas]

That's the spirit!

[lucas-ita]

I have a question. Let's imagine the following scenario: we have a dictionary called element_collision_and_contact, where each key represents a timber element in Cadwork (timber_element), and the values are the elements that collide or contact with this timber element (conFilter). I already understand how to transform timber_element from global to local coordinates, but I'm having difficulty maintaining the relative position of connFilter with respect to this element. How can I perform this transformation properly?
For the sake of having an accompanying intuition: `element_collision_and_contact[timber_element] = connFilter.

[lucas-ita]

Figuring out a way to do this in an efficient way would be enough for me

[roehligas]

The script below is a script we used for some truck stacking a year ago, rather simple but it should do the job if i understand correctly.

Make sure the elements that belong together share the same subgroup for testing. Then mark those elements and run the script.
It will align those elements in XY-plane by the coordinates of the biggest element.

"""
Script for Creating Export Solid based on Subgroup values

Written by RR 24.02.2023

Changelog:
23-02-24:       - Grouping functionality, sorting elements to determine main object by biggest volume.
23-03-03:       - Added functionality:
                    => Copies name and all other attributes from the main object
23-03-07:       - Added functionality:
                    => Distinguishes between columns and beams
"""



# import modules
import  cadwork                 as cw
import  element_controller      as ec
import  attribute_controller    as ac
import geometry_controller      as gc
import menu_controller          as mec 
import utility_controller       as uc
import visualization_controller as vc
import math

splitted_glulam_endings = ['_A','_B','_C','_D','_E','_F']

MAX_NUM_USER_ATTRIBUTES = 30

EXPORT_SOLID_STANDARD_NAME_COLUMN = 'Export Glulam_Column'
EXPORT_SOLID_STANDARD_NAME_BEAM = 'Export Glulam_Beam'

def group_elements_by_function(elements_in,function_in):
    elements_dict = {}

    for curr_id in elements_in:
        curr_attribute = function_in(curr_id)
        
        if curr_attribute not in elements_dict:
            elements_dict[curr_attribute] = []
        
        elements_dict[curr_attribute].append(curr_id)

    return elements_dict


def sort_elements_by_function(elements_in, function_in):
    sorted_elements =  elements_in
    
    sorted_elements.sort(key=function_in)
    
    return sorted_elements





def angle_between_vectors(v1:cw.point_3d, v2:cw.point_3d) -> float:
    return math.acos(v1.dot(v2) / (v1.magnitude() * v2.magnitude()))


def alignElementInZeroPoint(elements_in,ref_element):
    
        
    xg = cw.point_3d(1,0,0)
    yg = cw.point_3d(0,1,0)
    zg = cw.point_3d(0,0,1)
    zero_point = cw.point_3d(0,0,0)
    
    
    p1 = gc.get_p1(ref_element)
    ec.move_element(elements_in, -p1)
    
    # Get the X-vector of the reference element    
    xl = gc.get_xl(ref_element)

    # Rotate elements ato align the global X-axis
    ec.rotate_elements(elements_in, zero_point, xl.cross(xg), angle_between_vectors(xl, xg))
            
    # Rotate elements ato align the global Z-axis
    zl = gc.get_zl(ref_element)
    ec.rotate_elements(elements_in, zero_point, zl.cross(zg), angle_between_vectors(zl, zg))

    # Move the reference object above 0 in Y and Z direction
    ec.move_element(elements_in, xg * -gc.get_length(ref_element)/2)
    #ec.move_element([element_in], zg * gc.get_height(element_in)/2)






# get active element_ids
element_ids = ec.get_active_identifiable_element_ids()


# EDIT HERE BY WHAT FUNCTION YOU WANT TO GROUP
grouped_elements = group_elements_by_function(element_ids,ac.get_subgroup)


dir_Y = cw.point_3d(0,1,0)
dir_Z = cw.point_3d(0,0,1)

last_pos = cw.point_3d(0,0,0)

for key in grouped_elements.keys():
    print(key)
    grouped_elements[key] = sort_elements_by_function(grouped_elements[key],gc.get_volume)

    elements_in_drawing = grouped_elements[key]

    ref_element = elements_in_drawing[-1]
    
    alignElementInZeroPoint(elements_in_drawing,ref_element)

    ec.move_element(elements_in_drawing,dir_Z*gc.get_height(ref_element)/2 + last_pos)

    last_pos += dir_Y* 1000

    if len(elements_in_drawing) >1:
        ec.join_elements(elements_in_drawing)

[roehligas]

In your case i guess you can use your own dictionary that you already have... :)

[lucas-ita]

That was helpful. It's not quite what I need yet, but it's a good start. Thank you very much!

[Brunner246]

I guess the easiest thing to do is a copy / move and rotate as suggested by @roehligas

Alternatively, you can cache the translation vectors of e.g. point 1 to the point 1 of the reference element and the axis orientation based on the reference element and then transform the component using these values.