BenDFM: Taxonomy & Synthetic CAD Dataset

• BenDFM is a taxonomy and synthetic CAD dataset for learning-based Design for Manufacturing in sheet metal bending, distinguishing geometric and configuration-dependent manufacturability metrics.
• It provides 20,000 process-aware simulated parts with detailed labels on collision, unfolding overlap, and complexity, generated via a PythonOCC-based bending simulator.
• Benchmark results reveal that graph-based B-Rep representations outperform point cloud methods in predicting both binary feasibility and continuous complexity measures.

Searching arXiv for the BenDFM paper and the benchmarked model papers to ground the article in current arXiv records. BenDFM is a taxonomy and synthetic CAD dataset for learning-based Design for Manufacturing (DFM) in sheet metal bending. It addresses two coupled problems in intra-process manufacturability assessment (IPMA): ambiguity in what “manufacturability” denotes as a learning target, and the absence of realistic labeled data for bending-specific prediction tasks. In the formulation introduced by the paper, BenDFM is both a conceptual framework for distinguishing classes of manufacturability metrics and a concrete dataset of 20,000 process-aware simulated sheet metal parts, including both manufacturable and unmanufacturable cases, with folded and unfolded geometries and labels spanning feasibility and complexity objectives (Ballegeer et al., 13 Mar 2026).

1. Position within DFM and IPMA

The paper situates BenDFM within the classical division of DFM into process selection and intra-process manufacturability assessment. Process selection asks which manufacturing process is appropriate, whereas IPMA asks whether a design is manufacturable within an already chosen process and how difficult it will be to produce. BenDFM targets IPMA for sheet metal bending, a formative process in which flat sheets are bent along lines using a press brake composed of punch and die (Ballegeer et al., 13 Mar 2026).

For bending, manufacturability depends on both geometric and setup-specific constraints. The paper lists bend radii, flange lengths, reliefs, and overlap-free unfolding as geometric constraints, and tool reach, collisions, bending sequence, and part reorientation as configuration-specific constraints. These constraints are described as subtle and highly coupled. A central motivation for BenDFM is that designers often lack detailed process knowledge, while industrial tooling and simulation systems are frequently accessible only to production engineers.

The work identifies two blockers for learning-based IPMA. First, prior literature uses inconsistent definitions of manufacturability: binary feasibility, continuous complexity, and cost or time proxies are often mixed without clearly specifying whether labels are intrinsic to geometry or contingent on a machine, toolset, or CAM configuration. Second, suitable data are scarce. Industrial corpora exhibit survivorship bias because they predominantly contain successful and optimized parts, while synthetic DFM datasets have mostly focused on subtractive processes and simple primitive geometries rather than global, sequential constraints of bending. BenDFM is presented as a response to both issues.

2. Taxonomy of manufacturability metrics

The taxonomy introduced in BenDFM organizes manufacturability metrics along two axes: configuration dependence and measurement type (Ballegeer et al., 13 Mar 2026). Configuration-independent metrics are determined by geometry and basic physical laws within a process; configuration-dependent metrics depend on specific machine capabilities, tooling, CAM settings, or bend sequences. Measurement type is divided into feasibility, which asks whether a part can be made, and complexity or effort, which asks how difficult it is to make.

This yields four quadrants.

Quadrant	Definition	BenDFM example
Geometric feasibility	Configuration-independent feasibility	Flat pattern self-intersection
Configurational feasibility	Configuration-dependent feasibility	Punch–part and die–part collisions
Geometric complexity	Configuration-independent continuous effort	Unfolded rectangular bounding area
Configurational complexity	Configuration-dependent continuous effort	Reorientation distance and number of flips

The paper uses flat pattern self-overlap as the canonical geometric-feasibility label. If the unfolded sheet self-intersects, the part cannot be cut from a single sheet. By contrast, tooling collisions are configurational-feasibility labels because they are evaluated relative to a specific punch and die geometry and placement policy.

For configurational complexity, BenDFM defines handling and reorientation metrics between consecutive bends. If $\mathbf{m}_{i-1}$ and $\mathbf{m}_i$ denote bend midpoint positions, the reorientation distance is

$d_{i,i-1} = \|\mathbf{m}_i - \mathbf{m}_{i-1}\|.$

If $\mathbf{n}_{i-1}^{\theta}$ is the punch normal at the final angle of bend $i-1$ and $\mathbf{n}_i^0$ is the punch normal at the start of bend $i$, the reorientation angle is

$$\Delta \theta_{i,i-1} = \arccos \bigl( \mathbf{n}_{i-1}^{\theta} \cdot \mathbf{n}_i^0 \bigr).$$

A part flip is recorded when $\Delta\theta_{i,i-1} > 90^\circ$, and the total number of flips is

$$N_{\text{flip}} = \sum_i \mathbf{1}\{\Delta\theta_{i,i-1} > 90^\circ\}.$$

For geometric complexity, the principal example is the unfolded rectangular bounding area $\mathbf{m}_i$0, defined as the area of the minimal axis-aligned rectangle enclosing the flat pattern, including bend allowances. The taxonomy is meant to clarify which learning targets are expected to generalize across plants or tool configurations and which are not. A plausible implication is that it functions not only as a dataset annotation scheme but also as a scoping device for claims of model generalizability.

3. Dataset construction and process-aware simulation

BenDFM contains 20,000 sheet metal bending parts. For each part, the dataset stores folded 3D geometry as STEP/B-Rep, unfolded flat pattern geometry as STEP, bend sequence metadata, and manufacturability labels spanning all four taxonomy quadrants (Ballegeer et al., 13 Mar 2026). The parts are procedurally generated with a process-aware bending simulator implemented using PythonOCC.

The generation pipeline begins from an initial rectangular sheet. The base sheet may lie in the XY, YZ, or XZ plane. Length and width are uniformly sampled from 150–300 mm, and thickness $\mathbf{m}_i$1 from 2.0–6.0 mm. Candidate bend edges are maintained in a pool of eligible edges, and sampling is weighted toward edges closer to the base and toward longer edges. Bend parameters are then sampled: bend angle $\mathbf{m}_i$2 with a bias toward $\mathbf{m}_i$3; bend radius $\mathbf{m}_i$4; random up/down orientation; and flange height between 75 mm and the maximum base-sheet dimension. With 20% probability, a partial-width bend covering 50–75% of the edge length is used, which triggers bend reliefs.

The simulator constructs the 2D bend face, extrudes the bend volume along the edge direction, extrudes the post-bend flange region, and updates candidate edges. It supports rectangular, slanted, and rounded flanges, with rounded flanges marked as terminal because they do not generate new bendable edges. A symmetry bias is also introduced: after a bend is created, the system searches for a symmetric edge counterpart on the same face and may replicate the bend parameters there, allowing variation in flange height. The process continues until a target bend count is reached, producing parts with 2–10 bends.

To model configuration-dependent effects, BenDFM explicitly constructs tooling geometry for each bend. The punch is modeled as an isosceles triangular tip with rectangular body, with a 90° tip angle, tip thickness $\mathbf{m}_i$5 mm, and length 300 mm. The die is modeled as an isosceles triangular channel with base blocks and opening width $\mathbf{m}_i$6 mm. For each bend, punch and die are placed around the bend centerline and aligned with the bending direction.

Because final geometry is created by extrusion rather than by physical simulation, the dataset emulates dynamic bending through intermediate states. Bend allowance is computed as

$\mathbf{m}_i$7

where $\mathbf{m}_i$8 is a K-factor in the range 0.3–0.5 depending on material. Intermediate geometries are reconstructed at angles such as $\mathbf{m}_i$9, allowing tooling to be positioned and collision-checked throughout the bend trajectory. Full unfolding is obtained by replaying the bend sequence with all bend angles set to $d_{i,i-1} = \|\mathbf{m}_i - \mathbf{m}_{i-1}\|.$0 and assigning the calculated bend allowances as flat sections.

4. Dataset scope, subsets, and label structure

The dataset is partitioned into two balanced subsets tailored to feasibility tasks (Ballegeer et al., 13 Mar 2026). The BenDFM subset contains 14,000 parts with 2–8 bends, balanced 50/50 between parts with and without tooling collisions and stratified by bend count. All parts in this subset are guaranteed to be free of unfolding overlaps so that the sole feasibility issue is tooling collision. The BenDFM-U subset contains 6,000 parts with 7–10 bends, again balanced 50/50 between parts with and without flat-pattern overlap and stratified by bend count.

An important design choice is that 40% of bends are forced to be collision-free during generation by resampling parameters until no collisions occur. This avoids trivial datasets dominated by obvious failures and is intended to produce a more nuanced decision boundary.

Configurational-feasibility labels are generated by post hoc evaluation after the full part is built, so future flanges can interfere with earlier bends. For each bend, at every intermediate angle in 5° increments, punch and die are instantiated at three lateral positions along the bend line—left, center, and right—and intersection volumes between tooling and part are computed. A bend is collision-free if at least one punch position yields no intersection at any intermediate angle. At the part level, a binary collision label is assigned if any bend collides. Per-bend collision flags and counts are also recorded.

Geometric-feasibility labels are produced by boolean operations on the unfolded flat pattern to detect self-intersections. If the flat pattern self-overlaps, the part is labeled infeasible.

Complexity labels include handling and geometry statistics. In addition to reorientation distances, angles, and flip counts, the dataset records number of bends, sheet thickness, 3D bounding box volume, solid part volume, part mass, unfolded rectangular bounding area, number of distinct bend angles and radii, extrema of flange height, bend angle, and radius, number of bends with reliefs, and number of rounded flanges. Part mass is computed as

$d_{i,i-1} = \|\mathbf{m}_i - \mathbf{m}_{i-1}\|.$1

5. Learning representations, benchmark tasks, and training protocol

BenDFM is native in STEP/B-Rep format, but the benchmark derives two learning representations (Ballegeer et al., 13 Mar 2026). For PointNext, each part is represented as a point cloud obtained by sampling 1024 surface points, with per-point features given by spatial coordinates and surface normal vector. For UV-Net, the representation is an attributed adjacency graph (AAG) built from the B-Rep: nodes correspond to faces, edges to face adjacencies, and node and edge attributes are learned embeddings. UV-Net samples a $d_{i,i-1} = \|\mathbf{m}_i - \mathbf{m}_{i-1}\|.$2 parametric UV grid on each face and 10 points along each edge curve, processes face samples with 2D CNNs and edge samples with 1D CNNs, and then applies a Graph Convolutional Network over the AAG before global pooling.

The benchmark defines four representative tasks, one for each taxonomy quadrant. The two feasibility tasks are binary classification: configurational feasibility as prediction of whether a part exhibits any punch or die collision on the BenDFM subset, and geometric feasibility as prediction of whether the flat pattern self-intersects on BenDFM-U. The two complexity tasks are regression: configurational complexity as prediction of number of part flips, and geometric complexity as prediction of unfolded bounding area. Classification uses binary cross-entropy loss and reports AUC, accuracy, and F1; regression uses mean squared error and reports MAE, RMSE, and MAPE.

The training protocol is fixed across models: an 80/10/10 train/validation/test split, Adam optimizer with learning rate $d_{i,i-1} = \|\mathbf{m}_i - \mathbf{m}_{i-1}\|.$3, batch size 32, early stopping with patience of 20 epochs, and five repetitions with fixed seeds.

6. Benchmark results, interpretation, and broader significance

The benchmark shows that both models outperform random or naive baselines on all tasks, and that UV-Net consistently surpasses PointNext (Ballegeer et al., 13 Mar 2026). On tooling-collision prediction in the BenDFM subset, UV-Net attains AUC $d_{i,i-1} = \|\mathbf{m}_i - \mathbf{m}_{i-1}\|.$4, accuracy $d_{i,i-1} = \|\mathbf{m}_i - \mathbf{m}_{i-1}\|.$5, and F1 $d_{i,i-1} = \|\mathbf{m}_i - \mathbf{m}_{i-1}\|.$6, while PointNext attains AUC $d_{i,i-1} = \|\mathbf{m}_i - \mathbf{m}_{i-1}\|.$7, accuracy $d_{i,i-1} = \|\mathbf{m}_i - \mathbf{m}_{i-1}\|.$8, and F1 $d_{i,i-1} = \|\mathbf{m}_i - \mathbf{m}_{i-1}\|.$9. On unfolding-overlap prediction in BenDFM-U, UV-Net reaches AUC $\mathbf{n}_{i-1}^{\theta}$0, accuracy $\mathbf{n}_{i-1}^{\theta}$1, and F1 $\mathbf{n}_{i-1}^{\theta}$2, while PointNext reaches AUC $\mathbf{n}_{i-1}^{\theta}$3, accuracy $\mathbf{n}_{i-1}^{\theta}$4, and F1 $\mathbf{n}_{i-1}^{\theta}$5.

The regression results show the same ordering. For number of part flips, the baseline that predicts the training mean of 1.37 yields MAE $\mathbf{n}_{i-1}^{\theta}$6, RMSE $\mathbf{n}_{i-1}^{\theta}$7, and MAPE $\mathbf{n}_{i-1}^{\theta}$8. UV-Net improves this to MAE $\mathbf{n}_{i-1}^{\theta}$9, RMSE $i-1$0, and MAPE $i-1$1, while PointNext yields MAE $i-1$2, RMSE $i-1$3, and MAPE $i-1$4. For unfolded bounding area, the baseline that predicts the training mean of 254.59 cm² yields MAE $i-1$5, RMSE $i-1$6, and MAPE $i-1$7. UV-Net obtains MAE $i-1$8, RMSE $i-1$9, and MAPE $\mathbf{n}_i^0$0; PointNext obtains MAE $\mathbf{n}_i^0$1, RMSE $\mathbf{n}_i^0$2, and MAPE $\mathbf{n}_i^0$3.

Two conclusions are emphasized. First, graph/B-Rep-based representations that preserve topology and face adjacency are better suited to IPMA in bending than point-based representations, consistent with the fact that many bending constraints are global and structural rather than purely local. Second, geometric metrics are easier to predict than configuration-dependent metrics: both models perform better on unfolding overlap than on tooling collisions, and much better on unfolded area than on flip count. This empirically supports the taxonomy’s distinction between geometry-intrinsic and setup-contingent targets.

In relation to prior work, the paper states that most synthetic DFM datasets address subtractive processes with primitive solids and local feature constraints, and that there was no public dataset for sheet metal bending IPMA. BenDFM is therefore positioned as the first synthetic dataset dedicated to sheet metal bending, with richer geometry, multiple manufacturability labels, and explicit inclusion of infeasible cases. At the same time, the work notes that the dataset is synthetic and that validation on real industrial parts and bending operations remains an important next step.

The dataset is intended for benchmarking 3D geometric learning architectures, multi-task learning across manufacturability quadrants, and unsupervised or self-supervised B-Rep encoders. The paper also points to engineering uses such as early manufacturability feedback in CAD, warnings about potential unfolding overlap, approximate prediction of sheet area or number of flips, and probabilistic estimates of collision risk under a standard toolset. Suggested future directions include cross-configuration generalization, explicit conditioning on machine and tool descriptors, sequence-aware models, finer-grained collision labels, hybrid models that combine industrial time or cost data with BenDFM-like geometry, and extension of the same taxonomy to other formative or multi-process settings. The authors state that the dataset and code will be made publicly available at https://github.com/UGent-CVAMO/bendfm.