Empart: Interactive Convex Decomposition

• Empart is an interactive mesh-processing tool for convex decomposition that allows users to assign region-specific error tolerances to preserve critical detail while simplifying less important areas.
• It achieves a balance between geometric fidelity and computational efficiency by decomposing selected mesh regions in parallel, reducing convex parts significantly compared to global methods like V-HACD.
• Interactive visual feedback on both approximation error and simulation performance enables precise tuning for robotics applications such as collision checking, grasping, and motion planning.

Searching arXiv for the specified paper and any directly related context papers. arxiv_search(query="(Vu et al., 26 Sep 2025) Empart Interactive Convex Decomposition for Converting Meshes to Parts", max_results=5, sort_by="relevance") Searching by title keywords as a fallback. arxiv_search(query="Empart Interactive Convex Decomposition for Converting Meshes to Parts", max_results=10, sort_by="relevance") Empart is an interactive mesh-processing tool for convex decomposition, defined as converting a detailed triangle mesh into a set of simpler convex parts for use in robotics, physics simulation, collision checking, and motion planning. Its central purpose is to let users preserve high geometric detail only where it matters, such as contact regions in grasping or insertion tasks, while simplifying the rest more aggressively. The method is introduced in "Empart: Interactive Convex Decomposition for Converting Meshes to Parts" (Vu et al., 26 Sep 2025), which argues that task-aware, region-specific simplification can avoid the limitations of uniform-tolerance approximate convex decomposition in robotics.

1. Problem setting and motivation

Standard mesh simplification for simulation often uses a single global tolerance for the entire object. Empart is motivated by the claim that this is a poor fit for robotics because different regions of the same object have different importance: contact surfaces need high fidelity; non-contact regions can be simplified more; over-simplification can break grasping or insertion; and under-simplification creates too many convex parts and slows simulation (Vu et al., 26 Sep 2025).

This framing places Empart within a long-standing trade-off between geometric fidelity and computational efficiency. Convex decomposition is widely used because convex pieces are much cheaper to simulate than arbitrary meshes. Empart matters because it lets designers produce collision geometry that is task-aware, region-specific, interactive, and often much faster to simulate. A plausible implication is that the method is especially relevant when downstream performance depends on preserving only a small subset of geometric features, rather than approximating the entire object uniformly.

The paper situates standard approximate convex decomposition methods, including V-HACD, as suboptimal for robotics when application-specific knowledge can guide where detail should be preserved. V-HACD voxelizes the mesh, greedily chooses cutting planes, and stops when a global part-count or error threshold is reached. In that formulation, one uniform error tolerance is applied to the entire mesh, so different tolerances in different regions cannot be directly enforced.

2. Interactive convex decomposition paradigm

Empart extends standard approximate convex decomposition by allowing the user to draw spatial regions on the mesh using bounding boxes, assign each region its own simplification tolerance, decompose each region independently, preserve detail in user-selected areas, and visualize both approximation error and simulation performance (Vu et al., 26 Sep 2025). The conceptual shift is from decomposing the whole mesh under one tolerance to identifying which regions matter and how much error each can tolerate.

Users select one or more regions by drawing 3D axis-aligned bounding boxes around parts of the mesh. For each box, they assign an error tolerance $\varepsilon_i$. There is also a remainder tolerance $\varepsilon_{\mathrm{rem}}$ for the rest of the mesh. If a selected region has tolerance zero, Empart skips convex decomposition and returns the partitioned mesh directly. The paper also states that selected regions can be preserved exactly when tolerance is zero.

Relative to standard ACD methods such as V-HACD, Empart differs in several explicit ways. It supports region-specific tolerances, can preserve selected regions exactly when tolerance is zero, uses a parallelized decomposition pipeline over selected boxes and the remainder, can internally leverage existing ACD routines as subroutines, explicitly removes convex pieces that intrude into protected regions, and provides interactive visualization of both error and simulation performance. The paper further notes that although V-HACD can reach low error, it may require far more parts than Empart at the same error threshold. This suggests that Empart is not merely an interface layer over an existing decomposition backend, but a constraint-management and workflow system for integrating user intent into decomposition.

3. Formalization as a constrained multi-objective optimization

The paper formulates interactive convex decomposition as a constrained multi-objective optimization problem on a watertight triangle mesh $M=(V,F)$ and selected face regions $U=\{U_1,\dots,U_R\}$ (Vu et al., 26 Sep 2025). The goal is to find a partition $\mathbb{P}=\{P_1,\dots,P_K\}$ that trades off approximation quality and simulation performance, using non-negative weights $(\lambda_{\mathrm{err}}, \lambda_{\mathrm{sim}})$ to shape the trade-off between a concavity error term $\xi(\mathbb P)$ and a simulation term $\tau(\mathbb P)$.

The partition constraints are stated as

$$P_i \cap P_j = \emptyset \quad (i \neq j), \qquad \bigcup_{k=1}^{K} P_k = F.$$

The region-exclusion constraint is

$$\forall\,k,r:\quad P_k \subset U_r \;\lor\; P_k \cap U_r = \emptyset.$$

The concavity error term is given as

$\varepsilon_{\mathrm{rem}}$0

where $\varepsilon_{\mathrm{rem}}$1 is the part concavity and $\varepsilon_{\mathrm{rem}}$2 is the user-specified target concavity. The simulation term $\varepsilon_{\mathrm{rem}}$3 estimates simulation performance.

This formalization is notable because it makes region exclusion explicit: a part must either lie within a selected region or avoid intersecting it. In effect, the decomposition is constrained not only by approximation quality but also by the spatial semantics induced by user-selected boxes. A plausible implication is that Empart operationalizes user knowledge as hard geometric constraints plus per-region error targets, rather than as a post hoc evaluation criterion.

4. Decomposition pipeline and parallelized execution

Empart enforces region-specific constraints through a decomposition pipeline consisting of Boolean difference, independent region processing, separate decomposition of the remainder, removal of overlapping remainder pieces, and a final neighbor-merging stage (Vu et al., 26 Sep 2025). The input mesh is first split into selected box regions and the remaining unselected region.

For each selected box $\varepsilon_{\mathrm{rem}}$4, the algorithm computes $\varepsilon_{\mathrm{rem}}$5. If $\varepsilon_{\mathrm{rem}}$6, it calls ConvexDecompose(M_b, \varepsilon); otherwise it returns the mesh region itself. The remainder is processed separately with its own tolerance through ConvexDecompose(M_{\mathrm{rem}}, \varepsilon_{\mathrm{rem}}), after which overlapping portions are removed using BoolDifferenceConvex.

A final MergeNeighbors pass merges neighboring convex parts within a specified volume error threshold $\varepsilon_{\mathrm{rem}}$7. The paper provides pseudocode for Interactive_Convex_Decomposition, ProcessBox(b, M, ε), DecompRemainder(M_rem, B, ε_rem), and BoolDifferenceConvex(P, box) in the appendix. At a high level, the logic is to split the mesh into regions, decompose selected boxes independently, decompose the remainder, subtract box volumes from remainder parts, and merge neighbors.

A notable implementation detail is that BoolDifferenceConvex works by splitting convex pieces against the planes of the bounding box, removing pieces fully inside the box, and then merging neighbors with $\varepsilon_{\mathrm{rem}}$8. The paper emphasizes that both the boolean differencing and the convex decomposition of each region are parallelized, giving sub-linear scaling with respect to the number of selected regions. This suggests that the method is designed not only for region specificity but also for interactive latency in multi-region workflows.

5. Interactive feedback: approximation error and simulation performance

Empart includes visual feedback for approximation error by uniformly sampling points on the original mesh, computing the shortest distance from each sample to the approximated surface, also computing the reverse direction, normalizing distances to $\varepsilon_{\mathrm{rem}}$9, and visualizing them with a color map (Vu et al., 26 Sep 2025). The appendix algorithm Error_Samples uses BooleanUnion of the approximating parts, SampleSurface, BuildKDTree, NearestDistance, NormalizeClamp, and optional region filtering.

The paper describes a dense error overlay in which red indicates high error and white indicates low error. It also notes that users can hide individual convex hulls to inspect nested regions and adjust tolerances interactively. In this design, error visualization is not merely diagnostic; it functions as part of an iterative decomposition workflow in which region selection and tolerance assignment are refined in response to visual evidence.

Empart also includes a task-agnostic simulation metric built in MuJoCo. The evaluation procedure instantiates 25 objects in a grid inside a closed box, applies randomized forces for 0.1 seconds, represents each object using the convex parts from decomposition, and logs simulation time divided by wall-clock time. The resulting ratio is used as a consistent proxy for performance across decompositions. The paper describes this as a way to compare decompositions without requiring knowledge of the downstream task. A plausible implication is that Empart treats simulation throughput as a first-class optimization signal alongside geometric error, rather than as an external benchmark applied only after decomposition.

6. Empirical results, robotics application, and limitations

The paper evaluates Empart on a motor mesh with seven selected regions: a shaft, four mounting holes, and two lifting eyes (Vu et al., 26 Sep 2025). The reported comparison plots number of parts versus error and simulation real-time factor versus error. To reach an average Hausdorff distance of 13 mm, V-HACD required 10000 parts, whereas Empart achieved the same error with about 100 parts. At that threshold, simulation performance was 20x better for Empart than for V-HACD.

The same section records an important nuance about performance interpretation. V-HACD with 100 parts had real-time factor 0.093, while Empart with 129 parts had real-time factor 0.115. The paper uses this result to show that part count alone does not determine simulation speed; how hulls interact in collision checking also matters. This directly addresses a common simplification of convex decomposition evaluation in which lower part count is treated as a sufficient proxy for runtime.

A robotic pick-and-place experiment is conducted in Gazebo with the Bullet physics engine using a Fanuc R-2000iC/210L robot. The task is to pick up motors and place them onto a mounting plate, with the motor’s mounting holes needing to align with studs. Empart is used to preserve the hole regions with 5 mm Hausdorff error tolerance. The baseline is V-HACD with max hull count 10000, voxel resolution $M=(V,F)$0, and max volume error $M=(V,F)$1. The reported results are: Empart simulation time 106 s, V-HACD simulation time 377 s; overall slowdown 0.78x real-time for Empart and 0.22x real-time for V-HACD; minimum current RTF 0.34 for Empart and 0.07 for V-HACD. The paper concludes that Empart reduced total simulation time by 69% for this task and was faster at every measured time-point; at time-point T10, described as a particularly collision-heavy point, Empart was 4.9x faster.

The practical implications identified in the paper include robotics collision geometry generation, physics simulation, motion planning, grasping and insertion, interactive CAD-to-simulation workflows, and mesh processing for application-specific performance tuning. Its main practical advantage is that it gives users a way to preserve fidelity only where it matters, which can dramatically reduce the number of convex parts and improve simulation throughput.

The paper also identifies several limitations and future directions. The current prototype focuses on convex decomposition; future work may support analytic shape primitives. Region selection is manual, and semantic segmentation could improve usability. The current performance metric is simulation-based, but the same approach could be extended to motion-planning collision checking. Finally, the relationship between part count and simulation performance is described as nonlinear due to simulator optimizations like broad-phase collision checking and island deactivation. This positions Empart not as a universal replacement for existing decomposition pipelines, but as a task-aware framework whose effectiveness depends on meaningful region selection and the structure of the downstream simulator.