create Rectangular MEP on a plane

[usai-sylvain]

Hi There,

I am trying to create a MEP Rectangle around an existing rectangular beam. My problem is that create_rectangular_mep is using the points to define a polyline axis, not to define a coordinate system like create_rectangular_panel_points. So if my beam is not aligned to with world Z, the beam and MEP are misaligned.

260209_MEP-rect_around_beam.zip

Attached code and test file.

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

# MEP cross-section (adjust to your needs)
MEP_WIDTH = 500.0   # width of the rectangular duct
MEP_DEPTH = 300.0    # depth of the rectangular duct


def create_rectangular_mep_from_beam(beam_id: int, mep_width: float, mep_depth: float) -> int | None:
    """
    Create a rectangular MEP along the beam's coordinate system.

    Parameters:
        beam_id: Element ID of the rectangular beam.
        mep_width: Width of the rectangular MEP cross-section.
        mep_depth: Depth of the rectangular MEP cross-section.

    Returns:
        Element ID of the created MEP, or None if the element is not a rectangular beam.
    """
    element_type = ac.get_element_type(beam_id)
    if not element_type.is_rectangular_beam():
        return None

    p1 = gc.get_p1(beam_id)
    p2 = gc.get_p2(beam_id)
    p3 = gc.get_p3(beam_id)
    axis_points = [p1, p2]

    # with `axis_points = [p1, p2, p3]`, the third point is used to create a polyline axis

    return ec.create_rectangular_mep(mep_width, mep_depth, axis_points)
    #return ec.create_rectangular_panel_points(mep_width, mep_depth, p1, p2, p3)


def main() -> None:
    element_ids = ec.get_active_identifiable_element_ids()
    if not element_ids:
        print("No elements selected. Select one or more rectangular beams.")
        return

    for element_id in element_ids:
        mep_id = create_rectangular_mep_from_beam(element_id, MEP_WIDTH, MEP_DEPTH)




if __name__ == "__main__":
    main()

Any workaround ? Thanks !

[Brunner246]

@usai-sylvain

import math
from dataclasses import dataclass
from enum import Enum
from typing import List

import cadwork
import element_controller as ec
import geometry_controller as gc
import visualization_controller as vc


@dataclass(frozen=True, slots=True)
class CoordinateSystem:
    origin: cadwork.point_3d
    local_x_dir: cadwork.point_3d
    local_y_dir: cadwork.point_3d
    local_z_dir: cadwork.point_3d

    def __repr__(self) -> str:
        return (f"CoordinateSystem(origin={self.origin}, "
                f"local_x_dir={self.local_x_dir}, "
                f"local_y_dir={self.local_y_dir}, "
                f"local_z_dir={self.local_z_dir})")


class LocalRotationAxis(Enum):
    X = 1
    Y = 2
    Z = 3


def create_mep_rect(width: float, depth: float, vertices: List[cadwork.point_3d]) -> int:
    return ec.create_rectangular_mep(width, depth, vertices)


def create_beam_rect(width: float, height: float, length: float, cs: CoordinateSystem) -> int:
    return ec.create_rectangular_beam_vectors(width,
                                              height,
                                              length,
                                              cs.origin,
                                              cs.local_x_dir,
                                              cs.local_z_dir)


def get_coordinate_system(element_id: int) -> CoordinateSystem:
    return CoordinateSystem(
        origin=gc.get_p1(element_id),
        local_x_dir=(gc.get_xl(element_id)),
        local_y_dir=(gc.get_yl(element_id)),
        local_z_dir=(gc.get_zl(element_id))
    )


def rotate_element(element_id: int, angle_degrees: float, cs: CoordinateSystem, rotation_axis: LocalRotationAxis):
    match rotation_axis:
        case LocalRotationAxis.X:
            local_rotation_axis = cs.local_x_dir
        case LocalRotationAxis.Y:
            local_rotation_axis = cs.local_y_dir
        case LocalRotationAxis.Z:
            local_rotation_axis = cs.local_z_dir

    ec.rotate_elements([element_id], cs.origin, local_rotation_axis, angle_degrees)


if __name__ == "__main__":
    [element_id] = ec.get_active_identifiable_element_ids()
    cs = get_coordinate_system(element_id)
    print(f"Original Coordinate System: {cs}")

    mep_1 = create_mep_rect(width=100, depth=50, vertices=[gc.get_p1(element_id), gc.get_p2(element_id)])
    beam_1 = create_beam_rect(width=200, height=100, length=1500, cs=cs)

    mep_2 = create_mep_rect(width=100, depth=50, vertices=[gc.get_p1(element_id), gc.get_p2(element_id)])
    beam_2 = create_beam_rect(width=200, height=100, length=1500, cs=cs)

    vc.set_color([beam_2, mep_2], 5)

    rotation_angle_degrees = 90.0
    rotation_angle_radians = math.radians(rotation_angle_degrees)

    rotate_element(mep_2, rotation_angle_radians, cs, LocalRotationAxis.X)
    rotate_element(beam_2, rotation_angle_radians, cs, LocalRotationAxis.X)