Arcs/Circles are segmented when converting to BSplineCurve

Hi Mikhail,

Thank you for your response!

Here is a minimum working example for this case as well as the output in .brep and .stp format. In the screenshot, I am using Rhino to look at the resultant STEP file that comes from OCC - so it is just to view the results.

The problem seems to be either in converting the 2d circle into a Geom2d_TrimmedCurve or in using BRepBuilderAPI_MakeEdge with the surface... Any help is much appreciated :) Maybe it is very simple and obvious where I am doing something wrong!

def point2d(spoint: Point):
    return gp_Pnt2d(spoint.x, spoint.y)    

def direction2d(svector: Vector):
    return gp_Dir2d(svector.x, svector.y)

def plane2d(splane: Plane):
    return gp_Ax22d(point2d(splane.origin), 
        direction2d(splane.xdir))

def circle2d(scircle: Circle):
    return GCE2d_MakeCircle(plane2d(scircle.plane), scircle.radius).Value()

def brep(sbrep):
    vertices = [BRepBuilderAPI_MakeVertex(gp_Pnt(p.x, p.y, p.z)).Vertex() for p in sbrep.Vertices]

    curve3d = [curve(crv) for crv in sbrep.Curve3D]
    curve2d = [curve2d(crv) for crv in sbrep.Curve2D]

    # sbrep.Curve2D contains only one Circle object, with a origin and radius
    # curve() and curve2d() are methods that look at the specific type of curve being
    # converted, and calls the appropriate specific method. In this instance, there
    # is only the one Circle object, which 
    # Using the above circle2d() method, it is converted to a Geom2d_BSplineCurve

    surfaces = [surface(srf) for srf in sbrep.Surfaces]

    # sbrep.Surfaces contains only one BSpline surface, which converts fine

    trims = []
    for t in sbrep.Trims:
        face = sbrep.Faces[t.FaceIndex]
        tcurve = curve2d[t.CurveIndex]

        if isinstance(tcurve, Geom2d_Curve):
            # If the edges are built from 2d data, use the BRepBuilderAPI_MakeEdge method
            # which also takes the relevant surface into account
            edge2d = BRepBuilderAPI_MakeEdge(tcurve, surfaces[face.SurfaceIndex])
        else:
            edge2d = BRepBuilderAPI_MakeEdge(tcurve)

        if edge2d.IsDone():
            trims.append(edge2d.Edge())
        else:
            trims.append(None)
        pass

    wires = []
    for loop in sbrep.Loops:
        wire = BRepBuilderAPI_MakeWire()
        for ti in loop.TrimIndices:
            wire.Add(trims[ti])

        if not wire.IsDone():
            wires.append(None)
        else:
            wires.append(wire.Wire())

    faces = []
    for sface in sbrep.Faces:

        if wires[sface.OuterLoopIndex] is None:
            continue

        face = BRepBuilderAPI_MakeFace(surfaces[sface.SurfaceIndex], wires[sface.OuterLoopIndex], False)

        for hole in sface.LoopIndices:
            if hole != sface.OuterLoopIndex:
                face.Add(wires[hole])

        if not face.IsDone():
            continue

        faces.append(face.Face())

    builder = BRep_Builder()
    bprim = BRepPrim_Builder(builder)
    shell = TopoDS_Shell()

    bprim.MakeShell(shell)

    for face in faces:
        bprim.AddShellFace(shell, face)
        pass

    return shell

Some added context... here is the code I am using to write the STEP file:

def write_step(path, shapes):
    schema = 'AP214IS'
    assembly_mode = 2

    writer = STEPControl_Writer()
    fp = writer.WS().TransferWriter().FinderProcess()
    OCC.Core.Interface.Interface_Static.SetCVal('write.step.schema', schema)
    OCC.Core.Interface.Interface_Static.SetCVal('write.step.unit', 'MM')
    OCC.Core.Interface.Interface_Static.SetCVal('write.step.assembly', str(assembly_mode))
    OCC.Core.Interface.Interface_Static.SetCVal('write.step.product.name', 'EMA Blank')

    for shape in shapes:
        status = writer.Transfer(shape, STEPControl_AsIs)
        if status != 1:
            continue

    status = writer.Write(path)

Hi Mikhail,

Thanks again for looking into this. What is contradictory? Maybe I didn't explain it well enough :)

When I use 2d circles or arcs to construct edges for wires, the result is a face boundary with degree 1 (polygonized) when exported as STEP, not degree 2 as expected.

When I load the .brep file in Gmsh to look at it, it also appears polygonized (degree 1) so I don't think it is a problem with the STEP output.

Did you notice anything odd about the .brep file I provided? Does the code above look like the correct way to create Breps using 2d parameter space curves?