from_extrusion in OCCBrep does not support COMPAS core curves

[yiqiaowang-arch]

Feature Request

As a developer using COMPAS core geometry workflows, I want OCCBrep.from_extrusion to accept COMPAS core curves (e.g., Polyline, Line, or Curve) so that I can integrate OCC BREP modeling into existing COMPAS-based geometry pipelines without manually converting curves into OCC-specific types.

Details

Is your feature request related to a problem? Please describe.

Yes. The OCCBrep.from_extrusion function currently requires an OCCBrepEdge as input, which in turn expects a curve in the OCC-specific format (e.g., from OCCCurve). However, OCCCurve does not directly accept core COMPAS curves like Polyline, and passing a list of COMPAS Point objects results in an argument mismatch in the BRepBuilderAPI_MakeEdge constructor.

example:

from compas.geometry import Vector
from compas_occ.brep import OCCBrep, OCCBrepEdge
from compas_occ.geometry import OCCCurve

curve = OCCCurve(floor_edge.points)  # floor_edge.points is a list of compas.geometry.Point
brep_edge = OCCBrepEdge.from_curve(curve)  # ❌ This fails with argument type error
brep_extrusion = OCCBrep.from_extrusion(brep_edge, Vector(0, 0, floor_to_floor_height))

Error:

Traceback (most recent call last):
  File "<string>", line 1, in <module>
  File "c:\Users\wangy\.local\share\mamba\envs\cea_compas\lib\site-packages\compas_occ\brep\brepedge.py", line 548, in from_curve
    builder = BRepBuilderAPI.BRepBuilderAPI_MakeEdge(curve.occ_curve)
  File "c:\Users\wangy\.local\share\mamba\envs\cea_compas\lib\site-packages\OCC\Core\BRepBuilderAPI.py", line 2094, in __init__
    _BRepBuilderAPI.BRepBuilderAPI_MakeEdge_swiginit(self, _BRepBuilderAPI.new_BRepBuilderAPI_MakeEdge(*args))
TypeError: Wrong number or type of arguments for overloaded function 'new_BRepBuilderAPI_MakeEdge'.

Describe the solution you'd like

Allow OCCBrep.from_extrusion to accept COMPAS core curves (e.g., Polyline, Line, Curve, etc.) directly and internally handle their conversion to valid OCC curves for BREP construction.

Alternatively, provide a convenience function or automatic casting within OCCBrepEdge.from_curve or OCCCurve to handle COMPAS core geometries robustly.

Describe alternatives you've considered

• Manually converting COMPAS core geometry into OCC-compatible geometry (e.g., writing custom functions to create OCCCurve manually) is cumbersome and error-prone.
• Wrapping extrusion logic with intermediate OCC objects, but this breaks abstraction and compatibility between core COMPAS and compas_occ.

[yiqiaowang-arch]

I did not notice that compas_occ is now in 1.3.0, but my environment is stuck at python 3.8 so I cannot update it. I will try manually installing it via pip.

[yiqiaowang-arch]

a version higher than 1.0.2 does not work for me. I can successfully create OCCCurve from compas.geometry.Curve, but cannot create OCCBrepEdge from it. Do I need a higher version to realize it?

[yiqiaowang-arch]

I have compas_occ now in 1.3.0, but from_extrusion still requires OCCBrepEdge to function.

[tomvanmele]

a few things

OCCCurve is a base class for parametric curves. It provides a basic API for curve objects, but it can only be created by providing an existing instance of an OCC curve. The set of points you provide is not a valid input parameter.

The expected type for constructing an OCCEdge.from_curve is indeed OCCCurve. This means that it accepts any curve that is based on OCCCurve and therefore implements this API. In most cases the input will be an OCCNurbsCurve but this is not strictly always the case.

The correct version of the snippet you wrote would therefore be

from compas_viewer.viewer import Viewer

from compas.geometry import Circle
from compas.geometry import Vector
from compas_occ.brep import OCCBrep
from compas_occ.brep import OCCBrepEdge
from compas_occ.geometry import OCCNurbsCurve

circle = Circle(radius=0.3)
curve = OCCNurbsCurve.from_circle(circle)
edge = OCCBrepEdge.from_curve(curve)

brep = OCCBrep.from_extrusion(edge, Vector(0, 0, 10))

viewer = Viewer()
viewer.scene.add(brep)
viewer.show()

The code is a bit verbose and could be simplified, but it should work as expected.
Give it a try and let me know if it solves your problem...

[chenkasirer]

@tomvanmele was gonna open an issue for something related so just piggybacking this one.
Shouldn't OCCBrep.from_* all take compas.geometry types rather than specific OCC stuff? otherwise, this breaks the whole CAD-agnostic code idea, specifically of the Brep interface.

Like in this scenario I'd expect from_extrusion to take a compas.geometry.Curve or NurbsCurve (wrapping an OCC curve, sure) then internally creating an Edge from it if necessary. This is how it works in Rhino.

What are your thoughts about that?

[yiqiaowang-arch]

Hi @tomvanmele, thanks for the reply! I tried your method by first initializing an OCCNurbsCurve. But the "curve" that is being generated from OCCNurbsCurve seems have to be NOT a polyline... Normally a building would have a polyline as its footprint instead of a smooth curve. Is there any way to turn a polyline into the base of extrusion?

[yiqiaowang-arch]

I tried another method to create the building Brep with not smooth curve but polyline. Basically I need to extrude a surface from each line of the polyline, and assemble the whole Brep by myself. But my method is really unintuitive, and from_extrusion (if allowing a polyline) would simplify this greatly...

Below is the code snippet. There are three steps for the construction of a building:

1. identify the elevation of the building
2. move the footprint to each floor for its base
3. build a brep for this floor using floor+walls+ceiling
4. (merge the Brep into one?)

from compas.geometry import Point, Line, Vector, Polygon
from compas.datastructures import Mesh
from compas_libigl.intersections import intersection_ray_mesh
from compas_occ.brep import OCCBrep
from compas_viewer import Viewer

UP = Vector(0, 0, 1)

def extrude_line_to_polygon(line: Line, height: float, direction: Vector = UP) -> Polygon:
    """Make a rectangular wall polygon by extruding a line along a direction."""
    v = direction.unitized().scaled(height)
    return Polygon([line.start, line.end, line.end.translated(v), line.start.translated(v)])

def ground_z_under(mesh: Mesh, origin_point, direction: Vector = UP) -> float:
    """Cast a ray and return the Z at the first hit via barycentric interpolation."""
    hit = intersection_ray_mesh((origin_point, direction), mesh.to_vertices_and_faces())
    if not hit:
        raise ValueError("No ground hit under the footprint.")
    fkey, u, v, _ = hit[0]
    a, b, c = mesh.face_points(fkey)  # triangle
    w = 1 - u - v
    return w * a.z + u * b.z + v * c.z

def make_floor_brep(footprint_at_z: Polygon, floor_height: float) -> OCCBrep:
    """Build one floor solid from: slab + walls + ceiling."""
    slab = footprint_at_z
    walls = [extrude_line_to_polygon(edge, floor_height, UP) for edge in slab.lines]
    ceiling = slab.translated(Vector(0, 0, floor_height))
    return OCCBrep.from_polygons([slab, *walls, ceiling])

# --- scene setup --------------------------------------------------------------
viewer = Viewer()

# square footprint and a simple 'ground' mesh at z=10
footprint = Polygon([Point(0, 0, 0), Point(1, 0, 0), Point(1, 1, 0), Point(0, 1, 0)])
ground = Mesh.from_points([Point(0, 0, 10), Point(2, 0, 10), Point(2, 2, 10), Point(0, 2, 10)])

viewer.scene.add(footprint)
viewer.scene.add(ground)

# --- find elevation and place floors -----------------------------------------
elevation = ground_z_under(ground, footprint.centroid)
base_footprint = footprint.translated(Vector(0, 0, elevation))

floor_height = 3.0
for floor in range(2, 5):  # floors 2, 3, 4 (building floats)
    z = floor * floor_height
    brep = make_floor_brep(base_footprint.translated(Vector(0, 0, z)), floor_height)
    viewer.scene.add(brep)

viewer.show()

My forum post (https://forum.compas-framework.org/t/pluginnotinstallederror-using-compas-with-plugins-compas-libigl-compas-occ/1052/11) is also connected to this approach. I will link this reply there as well.