Modeling an object made from a bent plate that wasn't rectangular before bending.

[filip-zyzniewski]

Hello,

I am a cadquery beginner and I am trying to model a quite complex object made of metal sheets, cut and bent.
This is a fragment of this object:

I have marked challenging edges with blue and red lines.

Do you have any advice on modeling this?

I have prepared a synthetic example and implemented a naive approach:

"""Builds a bent plate made from a semi-triangular material"""

import itertools
import math
from typing import Iterable

import OCP.BRepAdaptor
import cadquery as cq

HEIGHT = 10
THICKNESS = 0.2
BEND_RADIUS = 0.2
CUT_ANGLE = 15


def circle_edge_angle(edge: cq.Edge) -> float:
    curve = OCP.BRepAdaptor.BRepAdaptor_Curve(edge.wrapped)
    return math.degrees(curve.FirstParameter() - curve.LastParameter())


def enlarge(edge: cq.Edge) -> cq.Edge:
    """Make an edge a bit longer to accommodate for (I assume) rounding errors when cutting."""
    assert edge.geomType() == "LINE"
    start, end = edge.startPoint(), edge.endPoint()
    v = (end - start) * 0.01
    return cq.Edge.makeLine(
        start - v,
        end + v,
    )


def tilt(face: cq.Face) -> cq.Workplane:
    """Tilt the cut face so that it extrudes deeper into the plate as cutting progresses."""
    return (
        cq.Workplane()
        .add(face)
        .workplane()
        .transformed(rotate=(CUT_ANGLE, 0, 0))
        .add(face)
    )


def make_plate() -> cq.Workplane:
    """Build the plate that we will be cutting."""
    sweep_path = (
        cq.Workplane("XY")
        .line(10, 0)
        .line(0, 10)
        .line(-5, 0)
        .line(0, BEND_RADIUS * 2)
        .line(10, 0)
        .wire()
        .val()
    )

    sweep_path = sweep_path.fillet2D(
        BEND_RADIUS,
        sweep_path.Vertices()[1:-1],
    )

    return cq.Workplane("YZ").rect(THICKNESS, HEIGHT).sweep(sweep_path, isFrenet=True)


plate = make_plate()

# The face that will be removed when cutting
top_face = plate.faces(">Z")
# The edge to start cutting at
first_edge = top_face.edges("<X").val()
# The edge to stop cutting at
last_edge = top_face.edges(">X").val()

# Iterable with edges between first_edge and last_edge
cut_path = itertools.islice(
    itertools.takewhile(
        last_edge.__ne__,
        itertools.dropwhile(first_edge.__ne__, itertools.cycle(top_face.edges())),
    ),
    1,
    None,
)

cut_face_edge = enlarge(first_edge)


cut_face = tilt(
    # How to make sure that the normal of this face is in the direction of cutting,
    # not the opposite direction?
    cq.Face.makeRuledSurface(
        cut_face_edge.translate(top_face.val().normalAt().normalized() * HEIGHT),
        cut_face_edge,
    )
)


def make_cutouts(path: Iterable[cq.Edge], cut_face: cq.Workplane) -> cq.Workplane():
    """Builds an object that should be subtracted from the plate to achieve a desired cut."""

    cutouts = cq.Workplane()

    for edge in path:
        match edge.geomType():
            case "LINE":
                distance = edge.Length() / math.cos(math.radians(CUT_ANGLE))
                cutout = cut_face.extrude(distance)
                cut_face = cutout.faces(cq.DirectionMinMaxSelector(cutout.plane.zDir))
            case "CIRCLE":
                depth = edge.Length() * math.tan(math.radians(CUT_ANGLE))
                cutout = (
                    cq.Workplane(
                        cq.Plane(
                            origin=edge.arcCenter(),
                            normal=edge.normal(),
                        )
                    )
                    .add(cut_face)
                    .twistExtrude(
                        -depth,
                        circle_edge_angle(edge),
                        combine=False,
                    )
                )
                cut_face = tilt(cutout.faces("%PLANE")[-1])
            case _:
                raise ValueError("unknown edge type", edge.geomType())
        cutouts += cutout
    return cutouts


cutouts = make_cutouts(cut_path, cut_face)

plate = plate - cutouts

if "show_object" in globals():
    # show_object(cutouts)
    show_object(plate)

I have also uploaded this script here as a pull request to facilitate commenting on particular line ranges.

Resulting object looks like this:

I find this approach very verbose, naive and brittle.
Do you have any recommendations about improving it?
I was thinking about building the cutouts by sweeping the cut_face in one go along another path built from sweep_path, but I have no idea how to build that another path (especially the edges where the material bends).

[lorenzncode]

Here is another version. This used loft instead of sweep.

from math import sqrt, tan, radians
from cadquery.func import *

HEIGHT = 10
THICKNESS = 0.2
BEND_RADIUS = 0.2
CUT_ANGLE = 15

# 2D wire
pts1 = [
    (0, 0),
    (10, 0),
    (10, 10),
    (5, 10),
    (5, 10 + BEND_RADIUS * 2),
    (15, 10 + BEND_RADIUS * 2),
]
path1 = polyline(*pts1)
path1.move(z=-5)

# 3D path z decreases by CUT_ANGLE along path
distances = [0.0]
for i in range(1, len(pts1)):
    dx = pts1[i][0] - pts1[i - 1][0]
    dy = pts1[i][1] - pts1[i - 1][1]
    distances.append(distances[-1] + sqrt(dx * dx + dy * dy))

pts2 = [
    (x, y, HEIGHT / 2 - d * tan(radians(CUT_ANGLE)))
    for (x, y), d in zip(pts1, distances)
]
path2 = polyline(*pts2)

# wire fillet
path1b = path1.fillet2D(BEND_RADIUS, path1.Vertices()[1:-1])
path2b = path2.fillet(BEND_RADIUS, path2.Vertices()[1:-1])

# create shell
res_loft = loft(path1b, path2b)

# thicken faces
res = compound(
    [f.thicken(-THICKNESS / 2.0) + f.thicken(THICKNESS / 2.0) for f in res_loft]
)
res = clean(res)

[adam-urbanczyk]

Your paths need to have the same number of edges for this approach to work reliably. AFAICT it is not the case right now.

In [180]: len(list(front_path))
Out[180]: 9

In [181]: len(list(back_path))
Out[181]: 8

[adam-urbanczyk]

I think this is the simplest solution. The only tricky part is the selector - loft does not formally produce edges with LINE geometry so I had to use tmp.edges('not %LINE') instead of tmp.edges('|Y')

import itertools
from math import radians, sin

import cadquery as cq
from cadquery.func import *

BEND_RADIUS = 2
CUT_ANGLE = radians(30)

bend_points = [
    cq.Vector(0, 0, 0), # removing this fixes the loft
    cq.Vector(20, 0, 0),
    cq.Vector(20, 0, 200),
    cq.Vector(20, 0, 300),
    cq.Vector(60, 0, 300),
    cq.Vector(60, 0, 250),
]
back_path = polyline(*bend_points)
back_path.move(y=-400)

for previous, point in itertools.pairwise(bend_points[2:]):
    distance = (point - previous).Length
    depth = previous.y - sin(CUT_ANGLE) * distance
    point.y += depth

front_path = polyline(*bend_points)

tmp = loft(front_path, back_path)
res = fillet(tmp, tmp.edges('not %LINE'), BEND_RADIUS)

[adam-urbanczyk]

Due to the intricacies of loft, I think in the end I'd recommend this, so you can use have no surprises with the geometry.

import itertools
from math import radians, sin

import cadquery as cq
from cadquery.func import *

BEND_RADIUS = 5
CUT_ANGLE = radians(30)

bend_points = [
    cq.Vector(0, 0, 0),
    cq.Vector(20, 0, 0),
    cq.Vector(20, 0, 200),
    cq.Vector(20, 0, 300),
    cq.Vector(60, 0, 300),
    cq.Vector(60, 0, 250),
]

back_path = polyline(*bend_points)
back_path.move(y=-400)

for previous, point in itertools.pairwise(bend_points[2:]):
    distance = (point - previous).Length
    depth = previous.y - sin(CUT_ANGLE) * distance
    point.y += depth

front_path = polyline(*bend_points)

faces = []
for e1, e2 in zip(back_path, front_path):
    faces.append(face(polygon(e1.startPoint(), e1.endPoint(), e2.endPoint(), e2.startPoint())))

sh = shell(faces)
res = fillet(sh, sh.edges('|Y'), BEND_RADIUS)

[lorenzncode]

This looks good. I think I'll open a separate discussion regarding bends where the original face contains features such as hole/slot which may require a different approach.

[filip-zyzniewski]

Hello,
This discussion has encouraged me to use lofting for more of the details of the object, leading me to this:

import itertools
from math import radians, sin

import cadquery as cq
from cadquery.func import *

BEND_RADIUS = 5
CUT_ANGLE = radians(30)
THICKNESS = 1
CHEAT = 0.01

# Setting to True causes:
#  Traceback (most recent call last):
#    File "/home/filip/git/github.com/filip-zyzniewski/city-el/mechanics/battery-box/model/test.py", line 71, in <module>
#      sh = fillet(sh, fillet_edges, BEND_RADIUS)
#    File "/home/filip/git/github.com/filip-zyzniewski/city-el/mechanics/battery-box/model/.venv/lib/python3.13/site-packages/cadquery/occ_impl/shapes.py", line 6156, in fillet
#      return _compound_or_shape(builder.Shape())
#                                ~~~~~~~~~~~~~^^
#  OCP.OCP.StdFail.StdFail_NotDone: BRep_API: command not done
FILLET_SHELL = False

# Setting to False causes a crazy shape
THICKEN = True

pois = [
    cq.Vector(0, 0, 0),
    cq.Vector(20, 0, 0),
    cq.Vector(20, 0, BEND_RADIUS),
    # without CHEAT, we get:
    # Traceback (most recent call last):
    #   File "/home/filip/git/github.com/filip-zyzniewski/city-el/mechanics/battery-box/model/test.py", line 64, in <module>
    #     p.fillet(
    #     ~~~~~~~~^
    #         BEND_RADIUS,
    #         ^^^^^^^^^^^^
    #     ...<4 lines>...
    #         ],
    #         ^^
    #     )
    #     ^
    #   File "/home/filip/git/github.com/filip-zyzniewski/city-el/mechanics/battery-box/model/.venv/lib/python3.13/site-packages/cadquery/occ_impl/shapes.py", line 3004, in fillet
    #     raise ValueError(f"Failed fillet at vertex {i+1}!")
    # ValueError: Failed fillet at vertex 6!
    cq.Vector(20, 0, BEND_RADIUS+CHEAT),
    cq.Vector(20, 0, 200),
    cq.Vector(20, 0, 300),
    cq.Vector(60, 0, 300),
    cq.Vector(60, 0, 290),
    cq.Vector(60+CHEAT, 0, 290),
    cq.Vector(60, 0, 250),
]

back_points = [
    p + cq.Vector(0, p.z*0.15-400, 0)
    for p in pois
]

back_path = polyline(*back_points)

pois[0] += cq.Vector(0, -20, 0)
pois[1] += cq.Vector(0, -20, 0)
pois[2] += cq.Vector(0, -20, 0)
pois[-2] += cq.Vector(0, -250, 0)
pois[-1] = back_points[-1]
for previous, point in itertools.pairwise(pois[4:8]):
    distance = (point - previous).Length
    depth = previous.y - sin(CUT_ANGLE) * distance
    point.y += depth

front_path = polyline(*pois)

if FILLET_SHELL:
    faces = []
    for e1, e2 in zip(back_path, front_path):
        faces.append(face(polygon(e1.startPoint(), e1.endPoint(), e2.endPoint(), e2.startPoint())))
    sh = shell(faces)
else:
    paths = [
        p.fillet(
            BEND_RADIUS,
            [
                p.Vertices()[1],
                p.Vertices()[5],
                p.Vertices()[6],
            ],
        )
        for p in [front_path, back_path]
    ]
    sh = loft(paths)



if FILLET_SHELL:
    fillet_edges = sh.edges("|Y")
    sh = fillet(sh, fillet_edges, BEND_RADIUS)

if THICKEN:
    obj = compound(
        [f.thicken(-THICKNESS / 2.0) + f.thicken(THICKNESS / 2.0) for f in sh]
    )
    obj = clean(obj)
else:
    obj = offset(sh, THICKNESS/2, both=True, cap=True, tol=1e-3)
    # Uncommenting the line below causes:
    #   Traceback (most recent call last):
    #     File "/home/filip/git/github.com/filip-zyzniewski/city-el/mechanics/battery-box/model/test.py", line 104, in <module>
    #       obj = clean(obj)
    #     File "/home/filip/git/github.com/filip-zyzniewski/city-el/mechanics/battery-box/model/.venv/lib/python3.13/site-packages/cadquery/occ_impl/shapes.py", line 6091, in clean
    #       builder.Build()
    #       ~~~~~~~~~~~~~^^
    #   OCP.OCP.Standard.Standard_ConstructionError: gp_Dir() - input vector has zero norm
    #
    # obj = clean(obj)

show_object(obj)

The result looks mostly OK, except small details:

• the top bends are not uniform, they get narrower towards the front:
  
  

• the edge under that bend has a weird protrusion extending downwards from it:
  

Setting THICKEN = False leads to such an object:

[lorenzncode]

Regarding the fillet, there are two problems:

1. This edge will fail to fillet:

   do_not_fillet_this_edge = sh.edges("|Y").edges(">>Z[-2]")

   The solution is to exclude this edge from the fillet. Since the shape is more
   complicated now you need to be more selective on the edges to apply the
   fillet.

2. This edge will fail to fillet with BEND_RADIUS == 5:

   edge2 = sh.edges("|Y").edges("<<Z").edges(">>X")

   The solution is to reduce the radius.

Try this with FILLET_SHELL = True:

fillet_edges = sh.edges("|Y").edges(">Z")
fillet_edges = compound(fillet_edges + sh.edges("|Y").edges("<Z").edges(">X"))
sh = fillet(sh, fillet_edges, BEND_RADIUS - 1e-3)