---
title: Concept Overview of Approximate Convex Decomposition (ACD)
url: https://www.emergentmind.com/topics/approximate-convex-decomposition-acd
type: topic
---

# Concept Overview of Approximate Convex Decomposition (ACD)

Approximate Convex Decomposition (ACD) is the approximation of a geometric, functional, or data object by a collection of convex components, generally trading exactness for fewer components, lower computational cost, or improved numerical tractability. In geometric computing, ACD commonly represents a nonconvex polygon, polyhedron, mesh, or scene as a union of approximately convex parts whose convex hulls serve as proxies for collision detection, physics simulation, shape representation, or interaction. The term is also used more broadly for sparse convex combinations, convex–concave function representations, and convex decompositions of structured mathematical objects. Consequently, ACD does not denote a single optimization problem: its meaning depends on the object being decomposed, the definition of convexity or approximation error, the permitted component representation, and the objective used to control complexity.

## 1. Definitions, scope, and objectives

In the geometric setting, an ACD of a solid shape $\mathcal{S}$ is a collection of components $\{\mathcal{S}_i\}$ whose union approximates the input. Each component may remain mildly concave, while its convex hull $\operatorname{CH}(\mathcal{S}_i)$ is used as an approximation or collision proxy. A typical objective is to minimize the number of components subject to a concavity constraint,

$$
\min |\{\mathcal{S}_i\}|
$$

subject to

$$
\operatorname{Concavity}(\mathcal{S}_i)\leq \epsilon
$$

for every component. A smaller $\epsilon$ generally preserves finer geometric detail while producing more components; a larger $\epsilon$ produces fewer, coarser components.

ACD differs from exact convex decomposition in both feasibility and objective. Exact decomposition requires every output component to be convex, whereas ACD permits bounded deviation from convexity. Exact convex decomposition can require many pieces and is NP-hard in relevant geometric formulations. ACD instead seeks an acceptable balance among geometric fidelity, component count, collision behavior, runtime, and memory use [2205.02961].

The term is also applied outside mesh geometry. For example, a point in a convex polytope can be approximated by a sparse convex combination of vertices, with error bounded in an $\ell_p$ norm [1512.08602]. In mechanism design, a fractional allocation is decomposed into a convex combination of integer allocations [1408.2690]. In turbulent-flow modeling, quadratic spectral quantities are approximated using positive-semidefinite modal weight matrices in a semidefinite relaxation [1401.6417]. In quantum information, a dimension-altering quantum channel is approximated by a convex sum of generalized extreme channels [1510.01040]. These uses share the principle of replacing a complex object by a controlled combination of simpler structured elements, but they do not share a common geometric error measure.

### Geometric ACD terminology

Several distinctions are essential:

- **Exact convexity versus approximate convexity**: an exact decomposition contains only convex pieces; an ACD may use components whose convex hulls introduce bounded geometric error.
- **Partition versus cover**: some methods partition the input into interior-disjoint components, while others return overlapping convexes whose union approximates the object.
- **Objective approximation versus geometric approximation**: a method may return exactly convex pieces while approximating only the minimum number of pieces, as in a quasi-polynomial-time approximation scheme for diagonal-based decomposition [1404.3776].
- **Implicit versus explicit representation**: learned methods may optimize differentiable occupancy fields or half-space parameters and later extract polygonal or polyhedral meshes [1909.05736].
- **Global versus regional tolerance**: conventional ACD often uses one tolerance over the entire object, whereas interactive methods can assign different tolerances to selected regions [2509.22847].

## 2. Exact planar decompositions and combinatorial bounds

A foundational planar point-set formulation starts with a set $P$ of points in general position and decomposes $\operatorname{CH}(P)$ into closed convex polygons. The polygons must have vertices in $P$, pairwise disjoint interiors, exact coverage of the convex hull, and no point of $P$ in the interior of a component. This formulation treats the number of polygons as the quantity to minimize, but it is not the usual tolerance-based mesh ACD problem.

For a point set $P$ with interior-point set $I(P)$ and hull-vertex set $B(P)$, a convex decomposition satisfies

$$
u(P)\leq \frac{4}{3}|I(P)|+\frac{1}{3}|B(P)|+1
\leq \frac{4}{3}|P|-2.
$$

The result is an absolute linear upper bound rather than a constant-factor approximation ratio relative to the unknown optimum. Its inductive construction removes selected hull or interior points, recursively decomposes the remaining set, and reinserts the removed points using empty triangles, quadrilaterals, and guaranteed convex merges [1909.06105].

An earlier construction orders points around an extreme point, labels points positive or negative according to local radial geometry, and groups consecutive labels into blocks. If $k$ denotes the number of positive blocks and $c$ the number of convex-hull vertices, the construction produces

$$
|\Gamma|=n+k-c.
$$

A specialized seven-point gadget handles alternating positive/negative configurations. Combining the block construction, alternating-pattern lemma, point-set reduction, and insertion argument yields a minimal convex decomposition with at most

$$
\frac{10n}{7}-c
$$

elements [1207.3468]. Here, “minimal” means locally irreducible under merging: adjacent pieces cannot be replaced by a convex union. It does not mean globally minimum cardinality, and the bound is not an approximation ratio of the form $|\Gamma|/\operatorname{OPT}$.

For planar polygons with holes, the diagonal-based convex decomposition problem asks for the minimum number $K(P)$ of exactly convex subpolygons formed by noncrossing diagonals. Simple polygons admit exact dynamic programming, while the problem with holes is NP-hard. A separator-based quasi-polynomial-time approximation scheme returns at most $(1+\varepsilon)K(P)$ pieces in time

$$
n^{O((\log n/\varepsilon)^4)}.
$$

This is an approximation to the objective value—the number of exact convex pieces—not an approximation to convexity or geometric coverage [1404.3776]. The method uses balanced geometric separators, converts separator curves into conforming polygon diagonals, recursively decomposes the resulting subpolygons, and solves small-optimum instances by exhaustive enumeration.

## 3. Mesh-based ACD for collision and simulation

Modern 3D ACD generally begins with a triangle mesh and produces convex polyhedra or other convex collision primitives. The purpose is to replace expensive collision queries on a detailed nonconvex mesh by queries on a smaller collection of convex objects. Convex algorithms such as GJK, V-Clip, and related distance and intersection methods are particularly relevant.

A typical mesh ACD pipeline recursively cuts a nonconvex component, evaluates the concavity of the resulting pieces, and terminates when every component satisfies a threshold. The approximation error may be measured using surface distance, volume difference, Hausdorff distance, or collision-specific criteria. The selection of a metric is consequential: filling a narrow hole or hollow handle may have little volume effect but can radically change collision behavior.

CoACD defines collision-aware concavity using both boundary and interior distances. For a solid $\mathcal{S}$,

$$
\operatorname{Concavity}(\mathcal{S})
=
\max\left(\operatorname{H_b}(\mathcal{S}),\operatorname{H_i}(\mathcal{S})\right),
$$

where $\operatorname{H_b}$ compares sampled boundary surfaces and $\operatorname{H_i}$ compares sampled interiors. A fast surrogate replaces the interior term by a volume-derived radius,

$$
\widetilde{\operatorname{Concavity}(\mathcal{S})}
=
\max\left(\operatorname{H_b}(\mathcal{S}),k\operatorname{R_v}(\mathcal{S})\right),
$$

with default $k=0.3$. The method directly cuts manifold triangle meshes with 3D planes and uses Monte Carlo tree search rather than only one-step greedy cutting. On the reported V-HACD and PartNet-Mobility comparisons, it produced fewer components or lower concavity than several baselines and improved drawer-opening success in a physics simulation from $49\%$ for V-HACD to $80\%$ [2205.02961].

VisACD uses visibility edges: pairs of mesh vertices whose connecting segment lies outside the mesh while entering a near-surface cage. Its internal visibility-based quantity is

$$
C^*(M)=\sum_i\|e_i\|_2.
$$

A candidate cutting plane is scored by the total length of visibility edges it cuts,

$$
Q_p(M,E)=\sum_i I_p(e_i)\|e_i\|_2.
$$

The method derives candidate planes from visibility edges and large flat surfaces, evaluates many candidates using GPU ray–mesh queries, and recursively cuts the part with the highest concavity. It is designed to reduce orientation sensitivity through geometry-derived plane directions and to avoid post-hoc merging [2604.04244].

CuACD extends the search-based approach into a fully GPU-resident pipeline. It uses warp-centric computational geometry, device-side dynamic allocation, GPU mesh clipping, connected-component processing, convex-hull construction, Hausdorff evaluation, and look-ahead search. With default threshold $\tau=0.05$, $W_{\mathrm{top}}=30$, $N_{\mathrm{ce}}=16$, and depth $D=2$, it reports mean runtimes of $0.23$ seconds on the V-HACD benchmark, $0.16$ seconds on PartNet-Mobility, and $0.25$ seconds on an Objaverse subset, with mean concavities of $0.0488$, $0.0458$, and $0.0496$, respectively [2609.28731].

### Primitive-based alternatives

Hull-based ACD provides flexible convex components but can be expensive in collision detection because hull complexity varies with vertex and face count. A bottom-up alternative fits parameterized primitives to face groups and greedily merges adjacent groups. Supported primitives include oriented bounding boxes, spheres, capped cylinders, capsules, frustums, and isosceles trapezoidal prisms. Each primitive encloses the vertices of all faces assigned to its region. Merge priority is based on excess volume,

$$
C(p_0,p_1)=V(p^*)-\left(V(p_0)+V(p_1)\right),
$$

optionally weighted according to downstream collision cost. This approach reports lower one-way Hausdorff and Chamfer distances, smaller serialized collider size, and faster rigid-body simulation than V-HACD and CoACD on the tested models [2602.07369].

## 4. Learned and differentiable convex representations

Learned ACD methods replace explicit recursive cutting with differentiable representations whose components remain convex by construction or whose parameters are optimized through occupancy reconstruction.

CvxNet represents a 3D object as the union of a fixed number $K$ of learned convex polytopes. Each convex is an intersection of $H$ half-spaces,

$$
H_h(x)=\mathbf{n}_h^{\mathsf T}x+d_h,
$$

and is represented differentiably using a smooth maximum of plane functions followed by a sigmoid:

$$
\Phi(x)=\frac{1}{\alpha}\log\left(\sum_{h=1}^{H}\exp(\alpha H_h(x))\right),
$$

$$
C(x)=\operatorname{Sigmoid}(-\beta\Phi(x)).
$$

The union is

$$
\hat O(x)=\max_{k=1,\ldots,K}C_k(x).
$$

Training combines occupancy reconstruction with overlap, unique-parameterization, guidance, and localization losses. The standard depth-to-3D configuration uses $K=50$ convexes with $H=50$ hyperplanes per convex. The learned half-spaces can be converted into explicit polygonal meshes using duality and convex-hull computations, avoiding Marching Cubes. On the reported ShapeNet depth-to-3D benchmark, CvxNet achieved mean IoU $0.731$, Chamfer-$L_1$ $0.080$, and F-score $73.49$ [1909.05736].

A related DNSM method initializes many overlapping deformable convex polytopes, fits them to a binary shape, ranks them using a local significance measure, removes redundant components, and refits the survivors with an overlap penalty. Each polytope is an intersection of half-spaces,

$$
\mathcal{P}_i=\bigcap_{j=1}^{M}H_{ij}.
$$

The initial energy rewards overlap to expose redundancy; the final energy penalizes overlap after low-significance components are removed. The local measure depends on the unique region contributed by a polytope and its size relative to the largest polytope. The method was evaluated on 2D binary shape images, including MPEG-7 shapes and walking-person silhouettes, and is intended for part-based representation, shape matching, recognition, and collision detection [1606.07509].

For indoor scenes, a learned regression network predicts a fixed set of 24 parallelepiped-like convexes from RGB-D input. Each primitive is represented by six half-spaces, and refinement optimizes the predicted convex parameters against depth and semantic samples. Greedy pruning reduces the average final count to approximately 14 convexes. On NYUv2, the refined and pruned configuration reported AbsRel $0.144$, RMSE $0.603$, mean normal error $38.235^\circ$, and segmentation accuracy $0.615$ [2307.04246]. This is a view-conditioned scene abstraction rather than a guaranteed watertight decomposition of a complete hidden scene.

Feature-field learning formulates ACD as self-supervised geometric representation learning. A continuous field $f:\mathcal{M}\rightarrow\mathbb{R}^{k}$ is trained so that points forming convex pairs have similar features, while points whose connecting segment exits the solid have dissimilar features. Clustering the field partitions the surface; the convex hull of each cluster becomes an output component. The method uses inward-ray positive sampling, nearby hard negatives, a contrastive loss, a PVCNN encoder, triplane features, and recursive concavity-controlled clustering. Trained on approximately 340,000 Objaverse shapes with 448-dimensional features, it reports lower concavity and reconstruction error than V-HACD, CoACD, Cvx-Net, and BSP-Net at comparable component counts on several datasets [2603.09285].

## 5. Region-aware, interactive, and task-specific ACD

Uniform global tolerances are often inappropriate when only selected regions affect a downstream task. Empart addresses this problem by allowing users to assign different tolerances to selected mesh regions and to the remainder. The workflow consists of uploading a watertight triangle mesh, selecting axis-aligned bounding boxes, assigning regional tolerances, running decomposition, inspecting error and simulation metrics, and iteratively adjusting the regions.

Selected regions are intersected with the mesh and processed independently. A zero tolerance preserves the partitioned original mesh rather than decomposing it. The remainder is decomposed separately and clipped against the selected regions so that independently generated convex pieces do not cross regional boundaries. The resulting output can contain convex pieces, exact or near-exact mesh partitions, clipped convexes, and optionally merged neighboring components [2509.22847].

Empart’s formulation treats decomposition as a constrained multi-objective problem involving regional approximation error and simulation performance. It requires each generated part either to lie entirely inside a selected region or entirely outside it. The implementation does not globally solve the nonlinear optimization; it combines Boolean partitioning, calls to existing ACD methods, convex clipping, parallel processing, and post-processing merges.

On a motor mesh with selected shafts, mounting holes, and lifting eyes, Empart required approximately 100 parts to achieve an average selected-region Hausdorff error of approximately $13$ mm, whereas V-HACD required approximately 10,000 parts. At that error level, Empart’s simulation performance was approximately 20 times better. In a robotic pick-and-place experiment using Gazebo and Bullet, Empart produced an overall real-time factor of $0.78$ and a total simulation time of $106$ seconds, compared with $0.22$ and $377$ seconds for V-HACD, a reduction of $69\%$ [2509.22847].

A related scene-decomposition approach predicts convex primitives from RGB-D input and then performs scene-specific optimization and pruning. Its results indicate that a learned initialization can be essential because direct optimization from random convexes produces unusable configurations. This illustrates a recurring distinction in learned ACD: the neural model may provide an initialization or prior, while geometric optimization enforces scene-specific fidelity.

## 6. Broader convex-decomposition formulations

ACD concepts extend beyond geometric part decomposition.

### Sparse convex combinations

Approximate Carathéodory methods seek a sparse convex combination of vertices approximating a point $u$ in a polytope. If $P$ lies in an $\ell_p$ ball of radius $D$ with $p\geq 2$, a deterministic construction produces

$$
u'=\sum_{j=1}^{k}\alpha_jv_j
$$

with

$$
k=O\left(\frac{D^2p}{\epsilon^2}\right),
\qquad
\|u-u'\|_p\leq\epsilon.
$$

The method uses Mirror Descent on a dual convex function and selects one vertex per iteration using a linear optimization oracle. The dependence on $D^2p/\epsilon^2$ is tight up to constants in the stated setting [1512.08602].

### Mechanism design

For a packing polytope $X\subseteq[0,1]^n$, a fractional optimum $x^*$ can be scaled by an integrality-gap factor and decomposed into a distribution over integer outcomes. A faster iterative procedure approximates the target, corrects coordinate errors using standard basis vectors, and exactifies the expectation using the packing property. The resulting mechanism achieves an $\alpha(1+\epsilon)$ approximation and requires

$$
O\left(\frac{n^2}{\epsilon^2}\right)
$$

integrality-gap-verifier calls. The exact convex combination defines a distributional range supporting a maximal-in-distributional-range mechanism with VCG-style payments [1408.2690].

### Turbulent-flow spectra

Resolvent analysis expresses channel-flow velocity fluctuations as weighted sums of response modes. Because spectra are quadratic in modal coefficients, the method introduces a positive-semidefinite modal weight matrix

$$
X_{ij}=\chi_i^*\chi_j,
\qquad X\succeq 0.
$$

The spectral quantities become affine in $X$, producing a semidefinite relaxation after dropping the rank-one constraint. Rank reduction then recovers rank-one matrices with the same spectra and objective value. At $Re_\tau=2003$, using 12 modes per wall-parallel wavenumber pair and 100 phase-speed samples produced close agreement with DNS spectra while reducing wall-normal and temporal resolution by approximately three orders of magnitude [1401.6417]. This is an approximate convex decomposition of statistical observables, not an exact decomposition of instantaneous velocity fields.

### Quantum channels

The set of completely positive trace-preserving maps from an $n$-dimensional input to an $m$-dimensional output is convex. A channel can be represented by its Choi state, and generalized extreme channels have Kraus rank at most $n$. A numerical method approximates a channel as a convex combination of $m$ generalized extreme channels,

$$
\widetilde{\mathcal{E}}
=
\sum_{i=1}^{m}p_i\mathcal{E}_i^{\mathrm g},
$$

using circuit parameterizations based on cosine-sine decompositions and lower-cost ansätze. The optimization minimizes Choi-state trace distance, which bounds the diamond distance by

$$
\|\mathcal{E}-\widetilde{\mathcal{E}}\|_\diamond
\leq
2nD_t(\mathcal{C},\widetilde{\mathcal{C}}).
$$

The reported experiments cover low-dimensional dimension-preserving and dimension-altering channels; the generalized Ruskai conjecture motivating the component count is not established analytically for all dimensions [1510.01040].

### Difference-of-convex function approximation

A twice-differentiable function on a bounded domain can be written as a difference of two convex functions by adding a sufficiently large quadratic term to both the function and a reference term. Residual networks with nonnegative internal weights, nonnegative feature transforms, ReLU activations, and positive output coefficients enforce convexity of each subnetwork. Two such subnetworks produce a difference-of-convex approximation.

The architecture is structurally convex under its sign constraints, but the finite neural networks provide approximations rather than a quantitative universal approximation theorem with explicit width, depth, and error rates. Its optimization and generalization claims are conditional or empirical; an MNIST experiment reported training accuracy $97.91\%$ and test accuracy $97.58\%$ [1803.08203].

## 7. Methods, limitations, and open directions

ACD methods differ substantially in their guarantees and failure modes. Geometric mesh algorithms may provide explicit concavity thresholds but depend on mesh quality, sampling, watertightness, and search heuristics. Learned methods can amortize inference across datasets and support differentiable optimization, but they require training distributions and may generalize poorly to incomplete, noisy, thin, or out-of-distribution geometry. Primitive-based methods provide predictable collision complexity and editability, but their restricted shape families may require many components for organic or high-frequency geometry.

Several limitations recur across ACD formulations:

- **No universal objective**: component count, Hausdorff error, volume error, collision preservation, simulation time, and semantic consistency may conflict.
- **No general optimality guarantee**: greedy cutting, tree search, feature clustering, and bottom-up merging are generally heuristic.
- **Tolerance sensitivity**: decreasing a concavity threshold usually increases component count and computational cost.
- **Representation dependence**: voxelization, mesh topology, sampling density, primitive families, and feature dimensionality can affect results.
- **Overlap and watertightness**: convexifying disjoint surface clusters can create overlapping hulls; learned unions may overlap by design; surface coverage does not necessarily imply volumetric correctness.
- **Task dependence**: a decomposition optimized for collision detection may not be optimal for navigation, rendering, semantic segmentation, or articulated manipulation.
- **Interactive specification**: regional methods can allocate detail efficiently but may require manual selection of important regions.
- **Hardware dependence**: GPU-resident methods achieve substantial acceleration but require device memory, parallel geometric kernels, and robust handling of variable-sized intermediate data.
- **Generalization**: feed-forward models trained on object collections may not reliably represent scenes, incomplete scans, or unusual topology without additional preprocessing or adaptation.

Recent work emphasizes three directions. First, geometric metrics are becoming more task-aware, incorporating interior free space, visibility, and collision conditions rather than relying only on surface or volume error. Second, learned feature fields and differentiable convex representations seek to replace expensive search with amortized prediction while retaining geometric self-supervision. Third, GPU-resident systems target the computational bottlenecks of mesh cutting, convex-hull construction, dynamic allocation, and concavity evaluation.

The resulting research landscape treats ACD not as one algorithm but as a family of approximation paradigms. Exact planar decomposition, collision-aware mesh decomposition, differentiable unions of convex polytopes, sparse convex combinations, semidefinite modal representations, channel decompositions, and difference-of-convex function approximation all instantiate the same broad idea: represent a complex object using a controlled combination of simpler convex structures, while making the approximation error, component complexity, and downstream utility explicit.

Source: https://www.emergentmind.com/topics/approximate-convex-decomposition-acd