Voxelization-Based Variable Neighborhood Tabu Search Strategy for Three-Dimensional Irregular Strip Packing

Abstract

This paper proposes an efficient algorithm that integrates a variable neighborhood search (VNS) framework with an adaptive voxel discretization for the three-dimensional irregular packing problem. The problem arises in additive manufacturing, logistics loading, and other fields, especially in strip packing scenarios where the filling length in a virtual container with a fixed cross-section and infinite length is to be minimized. The algorithm first discretizes continuous three-dimensional geometric models into Boolean voxel matrices, thereby transforming complex geometric interference detection into efficient logical operations. An initial solution is generated using a greedy “largest-volume-first” strategy. An innovative adaptive voxel precision adjustment mechanism is introduced to dynamically modify the discretization granularity according to the current filling rate, realizing a hierarchical solution strategy of “coarse-grained fast search + fine-grained precise optimization”. On this basis, a variable-neighborhood iterative framework based on tabu search (TS-VNS) is constructed. Three complementary neighborhood operators are designed: single-item reinsertion, block exchange, and rotation perturbation, together with an adaptive operator selection mechanism driven by historical contributions. Experiments on multiple standard instances of varying scales and complexities (e.g., miniature chess pieces and engine components) show that the proposed algorithm outperforms comparative methods in both packing height and average height, achieving a favorable balance between solution efficiency and stability. Thus, it provides a reliable and efficient approach for the practical engineering application of three-dimensional irregular packing.

1. Introduction

The three-dimensional irregular packing problem is a core optimization challenge in fields such as intelligent manufacturing, modern logistics, aerospace, and additive manufacturing (3D printing). The problem consists of rationally placing a set of three-dimensional objects with complex shapes and varying sizes into one or more fixed-volume containers. Under physical and process constraints—including collision-free placement and stability—it aims to optimize space utilization, the number of containers used, or the occupancy along a specific dimension (e.g., height). The difficulty of the problem stems from the deep coupling of geometric complexity, combinatorial explosion, and engineering constraints: (1) objects have arbitrary shapes (convex or concave, with holes), leading to high computational costs for geometric representation and precise collision detection [1]; (2) the placement sequence, spatial position, and rotation orientation of objects form an exponentially sized search space; (3) practical applications must consider complex constraints such as gravitational stability, support area, and loading sequence. Researchers and industries worldwide have accordingly explored various nesting strategies and optimization approaches.

Despite extensive research, the three-dimensional irregular packing problem still faces a core challenge: it is difficult to simultaneously achieve computational efficiency, solution quality, and engineering applicability because of its extremely high geometric and combinatorial complexity. Especially for practical industrial scenarios involving large-scale instances and strong physical constraints (such as stability and strip packing), developing intelligent nesting systems with high space utilization, high solution efficiency, and strong engineering adaptability remains an important and urgent research direction.

In light of these challenges, this paper proposes an adaptive voxel-based packing algorithm integrated with a hybrid tabu search—variable neighborhood search (TS-VNS) framework. The algorithm iteratively improves greedy construction results through a high-level metaheuristic, balances efficiency and accuracy via an adaptive voxel precision mechanism, and enhances search diversity by means of multi-neighborhood perturbation operators.

To enhance the applicability of the proposed algorithm to real industrial scenarios, we adopt the following key modeling assumptions: (1) Part geometry. All parts are modeled as rigid, non-deformable bodies. Their input 3D mesh models are assumed to be closed, watertight manifolds (i.e., free of holes and self-intersections). Geometric defects are corrected via mesh-repair preprocessing prior to voxelization so that salient features (e.g., curved surfaces and sharp edges) are properly represented. The part size spans from a few millimeters to several hundred millimeters, covering typical industrial components such as thin-walled parts, slender rods, and freeform shapes with complex curvature. (2) Problem setting. We focus on the three-dimensional (strip packing) setting, where the container footprint is fixed and the height is unbounded. Parts are allowed to rotate about the vertical (z) axis by integer multiples of 90°. Only geometric interference (non-overlap) constraints are considered; assembly precedence, interlocking effects, and fasteners/connectors are not modeled. (3) Surface properties. Part surfaces are assumed to be ideal, frictionless, and non-adhesive; only volumetric occupancy is considered. Physical effects such as surface roughness and elastic deformation are neglected. Minimum clearance requirements are enforced uniformly via voxel-space dilation, without distinguishing contact behavior across different materials.

The main contributions are summarized as follows:

(1)

A coarse-to-fine hierarchical solution paradigm enabled by voxel discretization and dynamic resolution control. Unlike existing voxel-based methods that rely on a fixed resolution, our framework adaptively switches voxel resolution according to part geometric complexity and the current placed-volume progress. This enables rapid convergence to high-quality regions at coarse resolutions and refined local adjustments at finer resolutions, substantially reducing computational cost without sacrificing final layout quality.

(2)

A 3D packing optimization engine that synergistically combines variable neighborhood search and tabu search. We introduce three heterogeneous neighborhood moves—single-part reinsertion, block swap, and rotation perturbation—and integrate a performance-driven roulette-wheel mechanism for adaptive operator selection, which dynamically biases the search toward more productive operators. By combining tabu-based cycle avoidance with a simulated-annealing-style probabilistic acceptance criterion, the framework alleviates the tendency of conventional metaheuristics to stagnate in poor local optima.

2. Literature Review

Research on three-dimensional irregular packing can be traced back to the classical Three-Dimensional Bin Packing Problem (3D-BPP). George and Robinson [1] first introduced the notions of “wall–corner” and “layer,” which established a foundational heuristic framework for packing rectilinear objects. To represent irregular geometries, Stoyan and co-workers [2,3] proposed ϕ-objects—a parametric, function-based description that transforms geometric constraints into analytical expressions. To mitigate the complexity of ϕ-objects, Romanova et al. [4] developed quasi-ϕ functions, enabling many packing problems to be formulated as nonlinear programs and allowing accurate modeling under continuous rotations. Egeblad et al. [5] subsequently investigated a range of heuristic strategies (e.g., local search and guided local search) for three-dimensional packing, substantially improving computational efficiency. Focusing on the three-dimensional strip packing setting, Allen et al. [6] designed a hybrid placement strategy that combines a “lowest-position” principle with a “best-fit” criterion. Liu et al. [7] further proposed the constructive algorithm HAPE3D, which incorporates rotations guided by a minimum potential-energy configuration and avoids the computational burden associated with no-fit polyhedron calculations.

With respect to voxel-based approximations, Hur et al. [8] were among the first to employ voxel representations within a bottom-left placement framework for cylindrical containers, coupled with a genetic algorithm to optimize the packing sequence. Jia et al. [9] proposed a particle-simulation-based packing approach in which particles are allowed to move and rotate stochastically, provided that overlap does not occur. In the context of sphere packing, de Korte et al. [10] utilized voxelization to accelerate collision detection. More recently, Lamas-Fernandez et al. [11] introduced a voxel-discretized mixed-integer programming framework, providing a milestone exact-optimization approach that balances solution quality with computational tractability and was published in Operations Research.

In recent years, deep reinforcement learning (DRL) has also been applied to three-dimensional packing. Zhu et al. [12] proposed AC-HAPE3D, which models HAPE3D within a Markov decision process, adopts an Actor–Critic scheme to learn placement policies, and uses voxel grids to encode the state space. Hu et al. [13] developed TAP-Net, combining graph neural networks and reinforcement learning for joint transport-and-pack optimization. Cui et al. [14] proposed a voxel-based spectral packing method leveraging fast Fourier transforms, enabling dense, interlocking-free arrangements of thousands of 3D objects. Chehrazad et al. [15] presented a semi-discrete deepest-left-bottom-fill algorithm that balances efficiency and accuracy through adaptive voxel refinement. Araújo et al. [16] introduced machine learning for algorithm selection, dynamically switching among heuristics to significantly improve average space utilization.

Meanwhile, research addressing engineering constraints has continued to deepen. Bortfeldt and Wäscher [17] provided a comprehensive review of constraints in container loading (e.g., stability, load bearing, and loading sequence). Romanova et al. [4] investigated continuous-rotation packing of concave polyhedra via nonlinear optimization. Tollenaere et al. [18] developed an exact MILP model tailored to strip packing of convex objects. Collectively, these studies indicate a clear trend toward higher fidelity, higher efficiency, and stronger constraint integration. Nevertheless, key challenges remain, including how to dynamically balance accuracy and runtime within voxel-based frameworks, how to effectively hybridize multiple metaheuristics, and how to handle strongly heterogeneous part sets (see

Table 1. Summarizes representative advances from recent years.

Reference	Method	Complexity	Objective	Constraints
Zhu et al. (2022) [12]	AC-HAPE3D	O(n × V)	Max utilization	Non-overlap, stability
Lamas-Fernandez (2023) [11]	Voxel MIP	Exponential	Min strip length	Non-overlap, convexity
Cui et al. (2023) [14]	Spectral + FFT	O($N_{voxel}\log N_{voxel}$)	Max density	Non-overlap, interlocking-free
Tollenaere et al. (2026) [18]	MILP	Exponential	Min strip length	Non-overlap, convexity
de Araújo et al. (2025) [16]	ML selection	O($n^2$)	Max utilization	Non-overlap

).

3. Problem Description

For the three-dimensional packing problem of irregular items, the core objective is to arrange a group of such 3D irregular items within a container, minimizing the waste of internal space under given constraints—in other words, maximizing the spatial utilization rate of the container as much as possible. In this paper, given n items $I=\left\{I_{1,}{I}_{2,\dots .,}{I}_n\right\}$ and a 3D rectangular container $C$($L\times W\times H_{max}$)), our goal is to find a set of placement positions $L=\left\{l_{1,}{l}_{2,\dots .,}{l}_n\right\}$ such that all items can be fully placed inside the container without overlapping, while minimizing the height of the container.

In the research presented in this paper, the items to be packed vary in dimensions, and the containers used for different groups of items also differ in size. Therefore, a discrete voxelization method is adopted to represent the geometric characteristics of the items. During the actual packing process, the following constraints must be satisfied: boundary constraints, non-overlapping constraints between items, and height minimization constraint.

3.1. Voxel Representation

To characterize the geometric features of irregular objects, this paper employs a voxelization approach for analysis. The three-dimensional irregular objects and their bounding boxes within the container are divided into uniform tiny cubic units, referred to as voxels. A 3D Boolean matrix (with values of 0 or 1) is constructed for the objects or layout space according to the voxel resolution, so as to represent the shape of objects and the space occupancy state of the container. For object representation, voxels assigned a value of 1 in the matrix correspond to the space occupied by the object, while 0 denotes vacant space. For the container space, a value of 1 indicates that the voxel position is occupied by a placed object, and 0 indicates an unoccupied position. Each object takes its bottom-left voxel (with priority to the left) as the reference voxel; thus, the position of an object can be determined solely by defining the coordinates of this reference voxel. Figure 1 gives an example of an irregular item (with the reference voxel marked in black) and its reference voxel definition. In this paper, the bottom-left corner of the container is set as the coordinate origin, so that all coordinates of points inside the container are positive.

Voxel resolution constitutes a core parameter that determines the equilibrium between geometric fidelity and computational efficiency in voxelized representations. Its selection is not arbitrary but grounded in a systematic trade-off framework, adhering primarily to the following two criteria: first, the geometric fidelity criterion, which requires the voxel grid to sufficiently resolve critical geometric features of objects (e.g., thin walls, slender structures) and avoid the loss of geometric accuracy during discretization, and generally stipulates that the voxel size should be less than half of the minimum feature dimension; second, the computational feasibility criterion, which requires that the overall scale of the generated voxel matrix must be controllable within the limits of available memory and acceptable computational time.

3.2. Irregular 3D Open-Dimensional Packing Problem

According to the classification proposed by Wäscher G et al. [13], this problem belongs to the Irregular 3D Open-Dimensional Packing Problem (I3DODP), also known as the strip packing problem. The core objective of the strip packing problem is to sequentially place the i-th item from a given set of 3D irregular items $I=\left\{I_{1,}{I}_{2,\dots .,}{I}_n\right\}$ into a container with a fixed base area of $L\times W$ according to different packing sequences until all n items are placed, with the ultimate goal of minimizing the required packing height H of the container.

The strip packing problem is subject to the following two basic geometric constraints:

• Boundary constraint: Items shall not exceed the boundaries of the container.
• Non-overlapping constraint: No overlap exists between any two items.

Since the container has a rectangular base and unlimited height, the boundary constraint is straightforward. For ease of processing, this paper sets a maximum height Hmax for the container to ensure accommodation of all items. Let the voxel resolution be v (unit: mm); then, the container C is discretized into a three-dimensional Boolean grid as follows:

$$L_m=⌈{\displaystyle \frac{L}{v}}⌉,W_m=⌈{\displaystyle \frac{W}{v}}⌉,H_m=⌈{\displaystyle \frac{H_{max}}{v}}⌉$$

(1)

The container state is represented by a three-dimensional Boolean matrix $B\in {\{0,1\}}^{L_m\times W_m\times H_m}$, where $B(x,y,z)$ = 1 indicates that the voxel is occupied and 0 indicates it is vacant. Let the placement coordinate of the reference voxel of item i be $({\mathit{x}}_i,{\mathit{y}}_i,{\mathit{z}}_i)$, and its bounding size after rotation ${\mathit{r}}_i$ be ${\mathit{l}}_i\left({\mathit{r}}_i\right)\times {\mathit{w}}_i\left({\mathit{r}}_i\right) \times {\mathit{h}}_i\left({\mathit{r}}_i\right)$. The boundary constraint is then formulated as follows:

$$0\le {\mathit{x}}_i\le L_m-{\mathit{w}}_i\left({\mathit{r}}_i\right)$$

(2)

$$0\le {\mathit{y}}_i\le W_m-{\mathit{d}}_i\left({\mathit{r}}_i\right)$$

(3)

where the rotation attitude ${\mathit{r}}_i$ is selected from the discrete set R = {0°, 90°, 180°, 270°} (around the z-axis).

The formulation of the non-overlapping constraint presents the core research challenge, owing to the sophisticated and irregular geometries of the target items. To overcome this difficulty, this study employs a voxel-based discretization scheme to transform the continuous geometric packing problem into a discrete spatial layout optimization problem. Specifically, item i is discretized into a 3D Boolean (0/1) matrix $M_i={\{0,1\}}^{{\mathit{l}}_i\times {\mathit{w}}_i{\times \mathit{h}}_i}$, and the transformed matrix corresponding to rotation attitude ${\mathit{r}}_i$ is denoted as $M_i^{r_i}$. For each candidate placement of item i, the conflict-free compatibility between its rotated voxel matrix $M_i^{r_i}$ and the container occupancy matrix B is examined as follows:

$$M_i^{r_i}\odot B[x_i:x_i+l_i,x_i:y_i+w_i,z_i:z_i+h_i]=0$$

(4)

where $\odot$ denotes the logical ‘AND’ operation

Let $S=\left\{\left(p_i,r_i,x_i,y_i,z_i\right)\right|i=1,\dots ,n\}$ represent a feasible packing solution, where $p_i$ denotes the item identifier. The corresponding packing height is then expressed as:

$$f\left(S\right)=\mathrm{m}\mathrm{a}\mathrm{x}(z_i+h_i(r_i\left)\right)$$

(5)

$h_i\left(r_i\right)$ denotes the voxel height of item i under orientation $r_i$. The optimization objective is given by:

$$min f\left(S\right)$$

(6)

4. Algorithm Framework

To address the complex solution space characteristics of the irregular 3D open-dimensional packing problem, this paper proposes an Adaptive Voxel-based Variable Neighborhood Tabu Search (AV-VNTS) algorithm. The overall framework of the algorithm is illustrated in Figure 2, which mainly consists of four core modules: an initial solution generation module, an adaptive voxel resolution adjustment module, a TS-VNS local search module, and an acceptance criterion and tabu list management module.

4.1. Initial Solution Generation Strategy

• Initial Placement Sequence Generation

The quality of the initial solution directly affects the convergence speed of subsequent optimization and the quality of the final solution. In this paper, a greedy construction algorithm based on the ‘largest-volume-first’ rule is adopted. Items are packed in descending order of their discrete volume, and each item is placed successively according to the ‘lowest-point principle’.

Definition 1.

(Discrete Volume). The discrete volume $V_i$ of an item is defined as the number of entries with value 1 in its voxel matrix  $M_i$:

$$V_i={\sum }_{x=1}^{l_i}{\sum }_{y=1}^{w_i}{\sum }_{z=1}^{h_i}{M}_i(x,y,z)$$

(7)

The algorithm sorts all item instances in descending order according to their volume $V_i$ to generate the initial placement sequence $X=(i_1,i_2,\dots ,i_n)$.

2.

Lowest-Point First Placement Principle

For each item in the sequence, its specific placement position needs to be determined. This paper adopts the Lowest-Z-First (LZF) principle for spatial search, which aims to prioritize positions with lower heights in the container so as to reduce the overall packing height.

The search traverses all candidate positions in the priority order of z → x → y, and a dynamic upper bound for the search height is set, whose calculation formula is given by:

$$z\_limit=min(z\_max+h\_k+1.H\_m-h\_k)$$

(8)

$z_{max}=\mathrm{m}\mathrm{a}\mathrm{x}\left\{z\right|B\left(x,y,z\right)=1\}$ denotes the highest voxel height of already placed items in the current container, $H_m$ is the predefined maximum height of the container, and $h_k$ is the height of the item to be placed. This rule is designed to reduce invalid search operations.

3.

Collision Detection and Placement

The item matrix and the occupied space matrix are traversed. If the same position is occupied in both the item matrix and the occupied space, an overlap is determined, the detection is terminated immediately, and the overlap result is returned. If the traversal reaches $B(L,W,z_{max})$ without termination, it indicates no overlap, and the subsequent item placement can be performed.

After overlap detection, the algorithm selects several feasible positions for the current item $i_k$. Among all feasible positions, the one with the minimum height coordinate z after placement is chosen.

4.2. Adaptive Voxel Resolution Adjustment Mechanism

Voxel resolution is a core parameter that determines the balance between geometric fidelity in discretized representation and computational efficiency. Traditional fixed-resolution strategies struggle to adapt to the complex nature of the 3D irregular packing problem: on the one hand, items with different geometric features exhibit significant differences in their sensitivity to resolution; on the other hand, the size of the remaining space in the container directly affects the necessity of high-resolution search. To this end, this paper proposes an adaptive voxel resolution adjustment mechanism that comprehensively considers the geometric characteristics of items and the progress of the placed volume.

4.2.1. Analysis of the Dual Effects of Voxel Resolution

Items with different geometric characteristics show significant differences in their sensitivity to voxel resolution. Thin-walled parts, complex curved surfaces, and other finely structured items suffer severe geometric distortion at low resolution, leading to failure in collision detection or missing optimal placement positions. In contrast, simple block-shaped items are relatively insensitive to resolution. To quantify this difference, this paper defines a geometric complexity index $k_i$ to comprehensively reflect the fineness of an item’s shape.

$$k_i=\alpha \ast {\displaystyle \frac{S_i}{V_i^{\frac{2}{3}}}}+\beta \ast {\displaystyle \frac{A_{curved surface}}{A_{total}}}+\gamma \ast {\displaystyle \frac{N_{\mathit{F}\mathit{e}\mathit{a}\mathit{t}\mathit{u}\mathit{r}\mathit{e}}}{N_{avg}}}$$

(9)

$S_i$ is the surface area of the item and $V_i$ is its volume; ${\displaystyle \frac{S_i}{V_i^{\frac{2}{3}}}}$ denotes the specific surface area (indicating slenderness or flatness); ${\displaystyle \frac{A_{curved surface}}{A_{total}}}$ is the ratio of curved surface area, reflecting curvature complexity; $N_{\mathit{F}\mathit{e}\mathit{a}\mathit{t}\mathit{u}\mathit{r}\mathit{e}}$ is the number of distinct geometric features in the item, and $N_{avg}$ is the average number of distinct geometric features in the dataset; $\alpha ,\beta ,\gamma$ are weighting coefficients set to 0.4, 0.4, and 0.2, respectively. The weighting coefficients $\alpha ,\beta ,\gamma$ in the geometric complexity index were determined through a preliminary experiment using the grid search method. The specific steps are as follows: select a set of representative test parts (covering different shape complexities), set $\alpha ,\beta ,\gamma$ within the range [0,1] with a step size of 0.1 for combinations, and calculate the correlation between the complexity index and the actual nesting difficulty (using filling height and calculation time as comprehensive indicators) for each combination. The experimental results show that when $\alpha$ = 0.4, $\beta$ = 0.4, and $\gamma$ = 0.2, the complexity index has the highest Pearson correlation coefficient with nesting difficulty (filling height) (r = 0.87) and provides the best distinction among various parts. Therefore, this set of weights is adopted in this study. Additionally, this weight allocation reflects the dominant role of ‘surface area proportion’ and ‘curvature complexity’ in the demand for geometric accuracy, with the number of features as an auxiliary factor. Items are classified into three levels (low, medium, high) according to $k_i$.

4.2.2. Volume Progress-Driven Adjustment Timing

Determining the adjustment timing is crucial to the adaptive mechanism. Since volume is the essential indicator for measuring space occupancy, this paper uses the ratio of the total volume of placed items to the total volume of all items as the basis for adjustment progress, rather than the number of items. The volume progress is defined as:

$$p_v={\displaystyle \frac{{\sum }_{iϵI_{placed}}{V}_i}{{\sum }_{iϵI_{total}}{V}_i}}$$

(10)

where $I_{placed}$ is the set of successfully placed items and $I_{total}$ is the set of all items. The volume progress $p_v$ ranges in [0,1].

Based on two critical values of $p_v$, namely 0.3 and 0.7, the packing process is divided into three stages: initial stage ($p_v$ < 0.3), middle stage (0.3 < $p_v$ < 0.7) and final stage ($p_v$ > 0.7), with corresponding voxel resolution adjustments performed in each stage. The selection of volume progress thresholds 0.3 and 0.7 is based on statistical analysis of multiple test cases. We observed the distribution patterns of remaining void sizes under different fill rates: when $p_v$ < 0.3, the remaining space in the container is relatively large (average void diameter > 10 v), and using coarse resolution (2 v) is sufficient to accurately detect collisions; when 0.3 ≤ $p_v$ ≤ 0.7, the void sizes gradually decrease to between 2 v and 10 v, requiring standard resolution v; when p_v > 0.7, the remaining space mostly consists of small gaps (average diameter < 2 v), and fine resolution (0.5 v) must be used to avoid missed detections. We further verified the robustness of these thresholds through sensitivity analysis: adjusting the thresholds by ±0.1 within the ranges 0.2~0.4 and 0.6~0.8 resulted in a final fill height change of no more than 1.5% and a computation time change of less than 8%. Therefore, 0.3 and 0.7 are selected as stable and generalizable thresholds.

4.2.3. Dual-Driven Accuracy Requirement Modeling

Based on the above analysis, this paper establishes accuracy requirement models from two dimensions: item characteristics and space state. The item-level accuracy requirement is defined based on the geometric complexity index.

$$v_i^{ideal}=v_{min}+\left(v_{max}-v_{min}\right)\ast e^{-\theta \ast k_i}$$

(11)

$v_{min}$ and $v_{max}$ represent the highest and lowest precisions corresponding to the minimum and maximum voxel sizes, respectively, and $\theta$ is the attenuation coefficient ranging from 0.5 to 2, serving as a key factor in balancing the aggregate features and precision decisions. This function determines whether high-precision voxels are required for the voxelization of an item.

For the current set of unplaced items $I_{remain}$, its aggregated precision requirement is calculated as the volume-weighted average.

$$v_{item}={\displaystyle \frac{{\sum }_{i\in I_{remain}}{V}_i\ast v_i^{ideal}}{{\sum }_{i\in I_{remain}}{V}_i}}$$

(12)

Among the remaining items, there exist some critical items that are highly sensitive to precision and have large volumes, whose successful placement directly affects the overall layout. A critical item identification index ${\phi }_i=k_i\ast {\displaystyle \frac{V_i}{V_{avg}}}$ is defined; when ${\phi }_i$ > 1 additional weight is assigned to such items.

The space state-driven accuracy requirement comprehensively considers the global space tightness and local gap characteristics.

$$v_{space}=v_{max}-\left(v_{max}-v_{min}\right)\ast \tau \ast ({1+{\displaystyle \frac{{\lambda }_{min}}{{\lambda }_{ref}}})}^{-1}$$

(13)

$\tau$ is the ratio of occupied space to the total container volume, ${\lambda }_{min}$ is the minimum local gap size, and ${\lambda }_{ref}$ is the gap size threshold, which takes the value of the voxel size corresponding to the lowest precision.

4.2.4. Hybrid Adjustment Rules and Precision Update

The item feature-driven accuracy requirement $v_{item}$ and the space state-driven accuracy requirement $v_{space}$ are weighted and fused to obtain the comprehensive accuracy.

$$v_{target}=w_{item}\ast v_{item}+w_{spave}\ast v_{space}$$

(14)

Among them, the weights are dynamically adjusted according to the volume progress.

$$w_{item}=w_{min}+\left(w_{max}-w_{min}\right)\ast p_v,w_{space}=1-w_{item}$$

(15)

This weight design conforms to the strategy of rapid placement in the early stage when space is sufficient, while high precision is required in the later stage to search for gaps and handle remaining items.

4.2.5. Spatial Matrix Mapping and Conflict Repair After Precision Variation

When the precision changes, the container grid size is altered, resulting in inconsistent spatial matrix dimensions. Let the new grid size be:

$$L_m^{new}=⌈{\displaystyle \frac{L}{v_{new}}}⌉,{ W}_m^{new}=⌈{\displaystyle \frac{W}{v_{new}}}⌉,{ H}_m^{new}=⌈{\displaystyle \frac{H_{max}}{v_{new}}}⌉$$

(16)

The coordinates of placed items are mapped proportionally to the new grid:

$$x_i^{new}=⌈{\displaystyle \frac{x_i^{old}\ast v_{old}}{v_{new}}}⌉, { y}_i^{new}=⌈{\displaystyle \frac{y_i^{old}\ast v_{old}}{v_{new}}}⌉, { z}_m^{new}=⌈{\displaystyle \frac{z_i^{old}\ast v_{old}}{v_{new}}}⌉$$

(17)

Mapping may introduce overlaps between items or interference with the container boundaries, so conflict resolution must be performed. During repair, items are processed in descending order of geometric complexity, with high-complexity items adjusted first. For low-complexity items, local fine-tuning is performed near their original positions (e.g., searching for feasible positions within a 3 × 3 × 3 neighborhood); for high-complexity items, full reinsertion is carried out if necessary, with relocation based on the lowest-point principle. If conflicts persist after repair, a global rescheduling is triggered: the container is cleared, and all items are re-placed at the current precision to ensure the feasibility of the solution.

4.3. Tabu-Based Variable Neighborhood Search

Among the many metaheuristics available, we selected Variable Neighborhood Search (VNS) and Tabu Search (TS) for the following reasons. VNS systematically switches among multiple neighborhood structures (single-item reinsertion, block swap, rotation perturbation), which allows the search to escape local optima by exploring different regions of the solution space—a critical property for the highly non-convex packing problem. TS complements VNS with a memory mechanism (tabu list) that prevents the search from revisiting recently explored configurations, thereby accelerating convergence and avoiding cycles. In preliminary experiments, we compared VNS-TS against Iterated Local Search (ILS) and Simulated Annealing (SA) as standalone local-search engines. VNS-TS consistently achieved lower packing heights and better convergence rates on the test instances. Notably, SA is not discarded; we incorporate it as the acceptance criterion within the TS-VNS framework (see Section 4.4) to further enhance global exploration. Thus, the combination of VNS and TS offers a balanced trade-off between exploration and exploitation, making it well suited for the irregular strip packing problem.

4.3.1. Neighborhood Structure Definition

This paper designs three neighborhood operators with complementary properties to perturb the current solution from different dimensions.

Definition 2.

(Single-item Reinsertion Neighborhood N1). The set of solutions obtained by removing any item i from the current solution S and reinserting it under all feasible rotation orientations and placement positions.

$$N_1\left(S\right)=\bigcup _{i=1}^n\bigcup _{r\in R(x,y,z)}\bigcup _{r\in P_{i,r}(S\backslash \{i\left\}\right)}\left\{\left(S\backslash \{i\right\}\right)\cup \left\{\right(i,r,x,y,z\left)\right\}\}$$

(18)

$P_{i,r}(S\backslash \{i\left\}\right)$ denotes the set of all feasible placement positions for item i in orientation $r$ under the container occupancy state corresponding to the partial solution. This operator is used for fine-tuning placed items in the later stage of the search.

Definition 3.

(Block Swap Neighborhood N2). The set of solutions obtained by randomly selecting two distinct items i and j and exchanging their placement information. Two swap modes are considered.

• Full Swap: Exchange both orientation and coordinates simultaneously;
• Partial Swap: Exchange only coordinates while keeping their respective orientations unchanged;

$$N_2\left(S\right)=\bigcup _{i\ne j}\bigcup _{model\in \{full,partial\}}\left\{Swap\right(S,i,j,model\left)\right|Feasibility\}$$

(19)

By exploring the synergistic relationships among items, this operator helps break local structures and is suitable for balancing exploration and exploitation in the middle stage of the search.

Definition 4.

(Rotation Perturbation Neighborhood N3). Randomly select k items, forcibly change their rotation orientations, and relocate them to the lowest feasible positions under the new orientations.

$$N_3\left(S\right)=\bigcup _{T\complement I,\left|T\right|=k}\bigcup _{\forall i\in T,r_i^{\prime }\in r_i}\left\{Reinsert\right(S,T,\left\{r_i^{\prime }\right\}\left)\right\}$$

(20)

This operator achieves a large-scale structural reorganization through batch rotation, providing global perturbation capability, and is suitable for jumping out of local optima in the early stage of the search.

4.3.2. Adaptive Operator Selection Mechanism

To dynamically adapt to the optimal operator combination at different search stages, this paper establishes an adaptive selection mechanism based on historical contribution. The core idea of this mechanism is to dynamically adjust the selection probability of each operator according to its performance in historical iterations, so that computing resources are biased towards operators with greater contributions.

Definition 5.

(Operator Contribution). The contribution of operator k in its t-th application is defined as:

$${∆}_k^{\left(t\right)}={\displaystyle \frac{f\left(S_{before}\right)-f\left(S_{after}\right)}{t_k}}$$

(21)

$f\left(S_{before}\right)$ and $f\left(S_{after}\right)$  are the objective function values before and after applying the operator, respectively, and  $t_k$  is the time cost of the operation. This definition integrates both the objective improvement and computational efficiency. A positive contribution indicates that the operator has improved the solution, while a negative value means degraded solution quality.

Weight Update Rule: Each operator k maintains a weight  $w_k$, with an initial weight set to  ${\displaystyle \frac{1}{3}}$. After each iteration, the weights are updated based on historical contributions:

$$w_k^{(t+1)}=\lambda \ast w_k^{\left(t\right)}+(1-\lambda ){\displaystyle \frac{{\sum }_{\tau =1}^t{∆}_k^{\tau }}{{\sum }_{\tau =1}^t{\vartheta }_k^{\tau }}}$$

(22)

In this weight calculation,  $\lambda \in [0.8,0.95]$  is the forgetting factor that controls the decay rate of historical information;  ${\vartheta }_k^{\tau }$  is an indicator function of whether operator  k  is used at the  $\tau$-th iteration. This update rule assigns higher weights to operators with better recent performance while retaining certain historical information to maintain stability.

Selection Probability: At the beginning of each iteration, the operator is selected using the roulette wheel method based on current weights. This adaptive mechanism enables the algorithm to dynamically adjust the operator combination according to the search process, avoiding low search efficiency caused by fixed operator strategies.

4.3.3. Tabu List Design

To avoid search cycles, this paper establishes an independent tabu list for each operator, which records the characteristics of recently explored solutions and prohibits repeated visits within the tabu tenure.

Definition of Tabu Characteristics: Differentiated tabu characteristics are designed for different operators.

• For the single-item reinsertion operator N1, the tabu characteristic is defined as the item-position pair $(i,x_i,y_i,z_i)$, which prohibits reinserting item i back to its original position;
• For the block swap operator N2, the tabu characteristic is defined as the item pair $(i,j)$, which prohibits repeated swapping of the same pair of items;
• For the rotation perturbation operator N3, the tabu characteristic is defined as the item-rotation pair $(i,r_{old}\to r_{new})$, which prohibits applying the same rotation change to the same item.

Tabu Tenure: The tabu tenure $T_{tabu}$ is dynamically adjusted and related to the problem scale:

$$T\_tabu=\lceil \surd n\rceil +rand(0,5)$$

(23)

Tabu List Management: Each time a new solution is accepted, its tabu characteristic is added to the tabu list of the corresponding operator with an expiration time set. At the beginning of each iteration, tabu records that have exceeded their expiration time are removed.

4.3.4. Computational Cost of Neighborhood Operators and Overall Efficiency

This section analyzes the computational complexity of the three neighborhood operators—single-part reinsertion (N1), block swap (N2), and rotation perturbation (N3)—and quantifies their impact on overall algorithmic efficiency.

(1)

Single-Part Reinsertion (N1)

N1 first removes one part from the current solution at random, then evaluates all admissible orientations of that part (four rotations) and invokes the lowest-z-first (LZF) search to identify a feasible placement. LZF scans part of the container voxel space, yielding a nominal time complexity of $O(L_m\ast W_m\ast z_{limit})$, where $L_m\ast W_m$ denote the voxelized container footprint dimensions, and $z_{limit}$ depends on the current packing height. In implementation, the dynamic search cap $z_{limit}=\mathrm{m}\mathrm{i}\mathrm{n}(z_{max}+h+1,H_m-h)$ reduces the effective complexity to $O(L_m\ast W_m\ast c),$ where c is a small constant. On a representative instance (ENGINE2, voxel grid 150 × 150 × variable height), one N1 move takes approximately 0.8 ms on average. N1 serves as a medium-cost operator for fine-grained local refinement and is effective at improving local layouts.

(2)

Block Swap (N2)

N2 randomly selects two parts and swaps their positions and orientations. After swapping, only local overlap checks are required in the affected regions (via the collision-detection routine), without any global placement search. Consequently, N2 is substantially cheaper than N1, with an average runtime of about 0.1 ms per move. Its low computational burden makes it well suited for frequent use in the mid-search phase to explore spatial synergies among parts.

(3)

Rotation Perturbation (N3)

N3 randomly selects k = $⌈0.15\ast n⌉$ parts (n: total number of parts), forcibly changes their orientations, and reinserts them. Since each reinsertion is equivalent to N1, the cost of N3 is approximately k times that of N1. For ENGINE2 (n = 97), k ≈ 15, and one N3 move takes around 12 ms on average, making it the most expensive operator. Despite its high cost, its strong perturbation capability is critical for escaping local minima, particularly in early search stages.

In a typical AV-VNTS run (ENGINE2, 500 iterations), the call-frequency ratio of the three operators is approximately N1:N2:N3 = 45%:30%:25%. In terms of total runtime contribution, N1 accounts for ~60%, N3 for ~30%, and N2 for only ~10%. The adaptive operator-selection mechanism adjusts these frequencies online according to historical contribution: N3 is invoked more often in early search (~40%) to promote global exploration, whereas N1 dominates in late search (~58%) for local intensification. Compared with a fixed-ratio policy (e.g., one-third each), the adaptive strategy reduces total computation time by roughly 25%, while maintaining statistically comparable solution quality (packing height). Therefore, by allocating operator usage dynamically, the algorithm achieves an effective exploration–exploitation trade-off and sustains strong overall efficiency.

4.4. Acceptance Criterion

The acceptance criterion determines how the algorithm selects new solutions during the iteration process and is a key mechanism for balancing exploration and exploitation. In this paper, an acceptance criterion is designed based on the idea of simulated annealing. The acceptance probability of inferior solutions is controlled by a temperature parameter, realizing the dynamic transition between extensive exploration in the early stage and intensive exploitation in the later stage of the algorithm.

Definition 6.

(Acceptance Probability). Given the current solution S, candidate solution $S^{\prime }$ and current temperature  $T$, the probability of accepting  $S^{\prime }$  as the new current solution is

$$P_{accept}\left(S,S^{\prime }\right)=\left\{\begin{array}{c} 1 if f\left(S^{\prime }\right)<f\left(S\right)\\ \exp \left(-{\displaystyle \frac{f\left(S^{\prime }\right)-f\left(S\right)}{T}}\right),if f\left(S^{\prime }\right)\ge f\left(S\right)\end{array}\right.$$

(24)

The temperature T gradually decreases with the iteration process, controlling the probability of accepting inferior solutions. An exponential cooling schedule is adopted in this paper:

$$T_{t+1}=\alpha \ast T_t,\alpha \in [0.95,0.99]$$

In this paper, the initial temperature  $T_0$  is determined using a method based on the initial acceptance probability:  N neighborhood solutions are randomly generated, and the average deterioration degree  $\overline{∆f^{+}}$  (arithmetic mean of positive differences) is calculated.

Setting the initial acceptance probability  $P_0=0.85$, we have:

$$T_0=-{\displaystyle \frac{\overline{∆f^{+}}}{\ln P_0}}$$

(25)

When the temperature drops below 0.01, the algorithm terminates the iteration. In addition to the temperature threshold, the algorithm also sets a maximum number of iterations of 10,000 and a termination condition of no improvement for 50 consecutive generations. The algorithm terminates and outputs the current optimal solution when any of the conditions is satisfied.

5. Results

The instances used in this study are derived from the cutting and packing problem dataset for academic research in the ESICUP community, with a total of three instances, denoted as CHESS, MERGED [14] and ENGINE. These three instances correspond to three different scenario types of items. By varying the quantity of different types of items within the same instance, three groups of corresponding data are generated for each instance. In this section, these instances will be used to evaluate the performance of the proposed voxelization-based packing algorithm.

5.1. Test Instances

The instances us The key differences among the nine groups of instance data adopted in this algorithm are presented in

Table 2. Case introduction.

Instances	Case	Geometric Characteristics of Parts	Quantity (Type)
MERGED	MERGED1	Small and precise parts	45 (15)
	MERGED2		75 (15)
	MERGED3		120 (15)
CHESS	CHESS1	Medium-sized parts with complex curved surfaces	32 (6)
	CHESS2		60 (6)
	CHESS3		90 (6)
ENGINE	ENGINE1	Large and bulky parts with a wide variety of types	56 (56)
	ENGINE2		97 (56)
	ENGINE3		142 (56)

.

Among the data types of these three groups of instances, each group has distinct geometric characteristics, representing different practical scenarios in real applications. MERGED represents an extreme scenario with extremely small sizes, high precision requirements, and a large variety of parts. CHESS represents a scenario of small-sized precision parts with complex curved surfaces and medium to low quantities. ENGINE represents an industrial heavy-duty scenario with large sizes, sturdy structures, and a high number of parts. These three datasets enable a comprehensive test of the algorithm from three dimensions: extreme precision, geometric complexity, and efficiency & scale. They facilitate an in-depth investigation into the algorithm’s adaptability to different scenarios, leading to more comprehensive conclusions.

5.2. Impact of Different Voxel Resolutions

Voxel resolution is a core parameter of the proposed algorithm. It directly determines the fidelity of mapping continuous geometry into a discrete voxel space and therefore governs the fundamental trade-off between geometric accuracy and computational efficiency. To systematically quantify its impact, we conduct a controlled experiment in which the initial solution is generated using the same procedure as in the main algorithm. For three representative datasets, we evaluate a set of discrete voxel resolutions and analyze how the packing height H and the computational time T vary with resolution.

The effects of voxel resolution on packing performance across the datasets are summarized in Figure 3, Figure 4 and Figure 5. Specifically, we test resolutions from 0.2 to 1.0 for MERGED1, from 0.5 to 1.5 for CHESS1, and from 1.5 to 3.0 for ENGINE1. These ranges are chosen to reflect the different geometric scales and runtime requirements of each scenario. By jointly considering the sensitivity of [o bj ec tO bj ec t] H and [o bj ec tO bj ec t] T to resolution, we determine an appropriate baseline voxel resolution for each dataset.

5.3. Sensitivity Analysis of Volume Progress Thresholds

In Section 4.2.2, we set the volume-progress threshold $p_v$ to 0.3 and 0.7 to partition the adaptive voxel resolution into three stages (coarse, standard, and fine). To examine the robustness of these two thresholds, we conducted a sensitivity analysis in this section. Three representative instances (Chess1, Engine2, and Merged3) were selected, and the thresholds were adjusted to ($p_v$ = 0.2/0.6) and ($p_v$ = 0.4/0.8), respectively. All other parameters were kept unchanged. For each configuration, we recorded the final packing height and the computational time. The results are reported in

Table 3. Results of the sensitivity analysis for volume progress thresholds.

Case	Threshold (Low/High)	${\mathit{H}}_{\mathit{a}\mathit{v}\mathit{g}}$ (mm)	t (s)
Chess1	0.2/0.6	124.1	7.1
	0.3/0.7 (Primitive)	123.4	6.2
	0.4/0.8	124.3	6.0
Engine2	0.2/0.6	224.5	29.2
	0.3/0.7 (Primitive)	223.4	28.1
	0.4/0.8	224.0	27.5
Merged3	0.2/0.6	66.3	22.3
	0.3/0.7 (Primitive)	65.6	21.4
	0.4/0.8	66.0	20.8

.

From Table 3, it can be seen that when the threshold fluctuates within the range of 0.2~0.4 and 0.6~0.8, the change in filling height does not exceed 1.5%, and the change in computation time does not exceed 8%. This indicates that the selected pv = 0.3 and pv = 0.7 in this study have good robustness and have little impact on the algorithm’s performance.

5.4. Experimental Setup

5.4.1. Comparison Algorithms

To verify the performance of the AV-VNTS algorithm, the original greedy algorithm (Base-Greedy) is selected as the benchmark for comparison. To ensure a fair comparison, all algorithms adopt the same voxelization representation and collision detection logic. Each algorithm runs independently 10 times, and the statistical results are taken for analysis.

5.4.2. Parameter Settings

The core parameters of the AV-VNTS algorithm are listed in

Table 4. Core parameters of the Algorithm.

Parameter Type	Parameter Name	Symbol	Value
Voxel Resolution	Initial Resolution	$v_0$	0.3–2.0 mm
	Minimum Resolution	$v_{min}$	0.2 mm
	Maximum Resolution	$v_{max}$	3.0 mm
	Resolution Adjustment Step	$\beta$	0.2
	Attenuation Coefficient	$\theta$	1.0
	Geometry Correction Coefficient	$\gamma$	0.2
TS-VNS	Operator Selection Forgetting Factor	$\lambda$	0.9
	Disturbance Ratio	$\alpha$	0.15
	Tabu Length Base	$T_{tabu}$	$⌈\sqrt{n}⌉$
	Maximum LNS Iterations	LNS_Max	30
Acceptance Criterion	Initial Temperature	$T_0$	Derived from initial acceptance probability
	Cooling Coefficient	${\alpha }_T$	0.98
	Minimum Temperature	$T_{min}$	0.01
	Stagnation Threshold	$L_{stall}$	50

. The upper and lower bounds of voxel resolution are dynamically determined according to instance characteristics, while the other parameters adopt experimentally calibrated values.

5.5. Small Example Precise Solution and Comparison

To assess the exact solvability of the proposed constrained minimization model and to quantify the performance gap of AV-VNTS on a small-scale instance with a known optimum, we consider a benchmark instance comprising seven irregular parts from four distinct categories (denoted as ILP). The container footprint is fixed at 20 × 20 voxels (i.e., $L_m\times W_m=20\times 20,$ with an open height dimension), and the maximum height is capped at 50 voxels.

Following the problem definition in Section 2, the three-dimensional irregular strip packing problem is formulated as an integer linear programming (ILP) model. We solve this ILP using a commercial solver (IBM ILOG CPLEX 12.10) with default settings, a single thread, and a time limit of 3600 s. The solver is invoked via the Python API (cplex package, version 12.10.0.0), and the global optimum is searched using a branch-and-bound procedure.

The results are shown in Figure 6. The left panel corresponds to the solution obtained by AV-VNTS, which reaches a maximum voxel height of 16 with a runtime of 3.4 s. The right panel reports the optimal solution returned by CPLEX, achieving a maximum voxel height of 12 with a runtime of 128.4 s.

This performance discrepancy can be primarily attributed to the following factors: (1) AV-VNTS, being a heuristic algorithm, does not guarantee global optimality, yet it is capable of producing feasible solutions rapidly; (2) the exact solver performs a global search via branch-and-bound, which in the worst case incurs exponential-time computational complexity; and (3) in this small-scale instance, the parts exhibit strong geometric complementarity and allow multiple alternative nesting configurations, rendering greedy initialization and local search more susceptible to becoming trapped in locally optimal layouts.

In summary, the small-instance study validates the correctness of the proposed ILP formulation, and the optimal solution provides a reliable benchmark for assessing the performance of heuristic approaches. Under engineering-acceptable computational times, AV-VNTS is able to obtain high-quality feasible solutions that are close to the optimum, thereby confirming its practical value for large-scale real-world problems.

5.6. Comparison of Packing Results

5.6.1. Comparison with Greedy Algorithm

The experimental results (

Table 5. Comparison of results.

	AV-VNTS			Base-Greedy
Case	${\mathit{H}}_{\mathit{m}\mathit{i}\mathit{n}}$ (mm)	${\mathit{H}}_{\mathit{a}\mathit{v}\mathit{g}}$ (mm)	Standard Deviation	${\mathit{H}}_{\mathit{m}\mathit{i}\mathit{n}}$ (mm)	${\mathit{H}}_{\mathit{a}\mathit{v}\mathit{g}}$ (mm)	Standard Deviation
CHESS1	121.8	123.4	2.2	126.6	136.5	7.4
CHESS2	253.2	255.8	0.3	256.2	275.3	9.9
CHESS3	439.8	445.7	3.6	448.2	468.1	11.8
MERGED1	24.0	25.4	0.8	29.4	35.3	5.3
MERGED2	39.3	41.1	1.4	41.4	46.3	6.5
MERGED3	60.6	65.6	2.6	66.9	75.3	10.3
ENGINE1	192	212.5	10.6	196	242.3	22.5
ENGINE2	196	223.4	12.8	200	239.1	21.1
ENGINE3	308	336.5	15.7	376	425.1	29.8

) show that the proposed algorithm in this study is significantly superior to the comparison algorithm in packing height, with varying degrees of improvement across different cases. The packing height is reduced by 14.4% on average per case, especially by 21.6% on the ENGINE dataset. The minimum, mean and variance of the height are all smaller than those of the comparison algorithm, indicating that the AV-VNTS algorithm outperforms the comparison algorithm in result stability. Figure 7, Figure 8, Figure 9 and Figure 10 show the comparison packing diagrams of partial data (AV-VNTS represents the result of the proposed algorithm, and Base-Greedy represents the result of the comparison algorithm).

To assess whether the improvement of AV-VNTS over the Base-Greedy baseline is statistically significant, we conducted an independent two-sample t-test (or Welch’s t-test when the equal-variance assumption is not tenable) for each instance, using results from 30 independent runs. We employed a one-sided two-sample test with the null hypothesis that the mean packing height produced by AV-VNTS is not smaller than that of Base-Greedy. The significance level was set to α = 0.05.

Table 6. Results of the statistical significance tests.

Case	AV-VNTS (SD)	Base-Greedy (SD)	t	p	Significance
CHESS1	123.4 $\pm$ 2.2	135.5 $\pm$ 7.4	−5.61	<0.001	Yes
CHESS2	255.8 $\pm$ 0.3	275.3 $\pm$ 9.9	−6.20	<0.001	Yes
CHESS3	445.7 $\pm$ 3.6	468.1 $\pm$ 11.8	−5.99	<0.001	Yes
MERGED1	25.4 $\pm$ 0.8	35.3 $\pm$ 5.3	−5.95	<0.001	Yes
MERGED2	$41.1 \pm$ 1.4	46.3 $\pm$ 6.5	−2.55	0.011	Yes
MERGED3	65.6 $\pm$ 2.6	75.3 $\pm$ 10.3	−2.96	0.005	Yes
ENGINE1	$212.5 \pm$ 10.6	242.3 $\pm$ 22.5	−3.90	<0.001	Yes
ENGINE2	223.4 $\pm$ 12.8	239.1 $\pm$ 21.1	−2.07	0.027	Yes
ENGINE3	$336.5 \pm 15.7$	425.1 $\pm$ 29.8	−8.57	<0.001	Yes

summarizes the test outcomes; in all cases the p-values are far below 0.05, indicating that the performance gains of AV-VNTS are statistically significant across all test instances.

5.6.2. Comparison with Advanced Algorithms

To further verify the effectiveness of AV-VNTS, we compared it with two representative advanced algorithms: HAPE3D (a classical constructive algorithm) and AC-HAPE3D (a method based on reinforcement learning and voxels). Since the original codes of these algorithms were not publicly available, we reproduced them according to the descriptions in their respective papers and ran them on the same test instances (CHESS1, ENGINE2, MERGED3). All experiments were conducted on the same hardware environment, with each algorithm run independently 30 times, recording the average packing height, average computation time, and standard deviation. The comparison results are shown in

Table 7. Performance comparison between AV-VNTS and advanced algorithms.

Case	Algorithm	H_avg (mm)	t (s)	t (vs. AV-VNTS)	p (Unilateral)
Chess1	HAPE3D	128.5	15.3	5.62	<0.001
	AC-HAPE3D	125.2	22.8	4.18	<0.001
	AV-VNTS	123.4	6.2	-	-
Engine2	HAPE3D	246.5	35.2	7.45	<0.001
	AC-HAPE3D	234.2	45.8	5.89	<0.001
	AV-VNTS	223.4	28.1	-	-
Merged3	HAPE3D	71.2	18.5	6.23	<0.001
	AC-HAPE3D	68.5	26.3	4.95	<0.001
	AV-VNTS	65.6	21.4	-	-

.

An independent samples t-test (with Welch correction if variances are unequal) was used to compare the mean filling heights of AV-VNTS with HAPE3D, and AV-VNTS with AC-HAPE3D. The null hypothesis was that the mean of AV-VNTS is not lower than that of the comparison algorithms, and the alternative hypothesis was that the mean of AV-VNTS is lower (one-sided test). The significance level was set at α = 0.05. As seen in Table 5, all p-values are less than 0.001, far below 0.05, indicating that the filling height of AV-VNTS is significantly lower than that of HAPE3D and AC-HAPE3D.

As can be seen from Table 7, AV-VNTS achieved the lowest packing height across all test cases, while the computation time was also significantly better than that of AC-HAPE3D. Compared with HAPE3D, AV-VNTS reduced the packing height by about 2–5%, and the computation time was approximately 40–80% of that of HAPE3D (significantly faster on CHESS1 and slightly faster on ENGINE2). This demonstrates the comprehensive advantages of the proposed algorithm in terms of both solution quality and efficiency.

5.7. Ablation Experiment

To quantify the individual contributions of the three key modules—adaptive resolution control, tabu search, and simulated annealing (SA) acceptance—we conducted an ablation study. Variant A disables adaptive resolution and uses a fixed baseline resolution throughout. Variant B removes tabu search (i.e., VNS only with greedy acceptance). Variant C disables the SA acceptance mechanism and adopts greedy acceptance. Variant D corresponds to the Base-Greedy algorithm. We consider three medium-sized instances (Chess_3, Engine_2, and Merged_3). Each variant is executed 10 times, and we report the average packing height and average runtime. The results are summarized in

Table 8. Results of the ablation experiment.

Variant	Chess_3		Engine_2		Merged_3
	${\mathit{H}}_{\mathit{a}\mathit{v}\mathit{g}}$	t	${\mathit{H}}_{\mathit{a}\mathit{v}\mathit{g}}$	t	${\mathit{H}}_{\mathit{a}\mathit{v}\mathit{g}}$	t
Base-greedy	468.1	52.4	239.1	17.3	75.3	14.6
Fixed precision	453.2	83.7	230.5	45.2	69.8	32.5
No taboo search	458.5	68.3	232.3	24.6	71.2	10.8
No simulated annealing	450.8	70.2	227.1	26.5	68,5	20.1
AV-VNTS	445.7	73.8	223.4	28.1	65.6	21.4

.

As shown in the table, using a fixed resolution (i.e., without adaptivity) leads to a substantial increase in runtime across all instances, while yielding packing heights comparable to the full model. This indicates that adaptive resolution control can markedly reduce computational time without compromising solution quality, with particularly pronounced benefits in scenarios involving complex geometries (Chess) or stringent accuracy requirements (Merged). When tabu search is removed, the resulting packing heights are noticeably higher than those of the full algorithm, suggesting that the tabu-memory mechanism effectively prevents revisiting previously explored layouts and thereby improves solution quality. Disabling simulated annealing results in a slightly higher packing height than the full method. In practice, simulated annealing contributes an additional 1–2% improvement with only a marginal runtime overhead, demonstrating a favorable cost–benefit trade-off.

Overall, the complete AV-VNTS consistently attains the lowest packing height among all variants while maintaining a moderate runtime, confirming the effectiveness of the synergy among the proposed modules. The ablation study further shows that adaptive resolution, tabu search, and simulated annealing each provide non-substitutable contributions and collectively underpin the performance gains of the proposed algorithm.

6. Discussion

This paper addresses the long-standing engineering challenge of packing large-scale sets of three-dimensional irregular parts and proposes a hybrid heuristic framework built upon a voxelized representation. The central idea is to voxelize both the continuous 3D workspace and the complex part geometries, thereby transforming inherently difficult continuous-space interference checks into efficient Boolean operations on a discrete 3D grid. This reformulation substantially reduces the computational burden of collision detection. On the algorithmic side, we develop an adaptive voxel-resolution control mechanism that is simultaneously **packing-progress driven** and **geometry-aware**. Specifically, the switching schedule is triggered by the *placed-volume progress*, which constitutes an intrinsic measure of space consumption: placing a large part naturally induces timely resolution updates, while the cumulative effect of many small parts is captured in a principled manner.

On the search side, we design a tabu-enhanced variable neighborhood search engine (TS-VNS) with three complementary operators: single-part reinsertion, block swap, and rotation perturbation. An adaptive operator-selection mechanism updates operator weights based on historical contributions, allocating computational effort preferentially to more effective operators. Together with the memory component of the tabu list, this design mitigates cycling and improves search robustness.

For empirical validation, we consider three representative benchmark families (chess pieces, engine components, and mixed-shape datasets). The results demonstrate that, relative to the baseline strategy, the proposed method achieves a marked reduction in final packing height, i.e., a substantial improvement in space utilization. The advantage is particularly pronounced in instances featuring heterogeneous part types with large variations in size and geometry, which corroborates the efficiency and robustness of the proposed approach for industrially relevant heterogeneous part sets.

Despite its strong performance in static settings, the proposed approach has several limitations. First, voxelization itself can remain computationally expensive for extremely complex geometries, potentially leading to non-negligible preprocessing overhead. Second, as the core search strategy is heuristic in nature, global optimality is not guaranteed. Third, we currently restrict rotations to four discrete orientations about the z-axis. Allowing full 3D rotations (arbitrary rotations about the x-, y-, and z-axes) would: (i) cause a combinatorial explosion in the search space, increasing the number of candidate orientations from 4 to 64+; (ii) substantially increase computational cost, as it becomes impractical to precompute voxel templates for all orientations and instead requires on-the-fly rotation and resampling, multiplying collision-check time by an order of magnitude; and (iii) offer limited marginal gains in practice—our preliminary experiments indicate that introducing additional x-axis rotations reduces the packing height by only ~3–5% while increasing runtime by 40–60%.

Future work may further improve practical applicability along several directions. First, more powerful metaheuristics could be incorporated to replace or augment the current search engine, improving solution quality and generalization across different instance characteristics. Second, more efficient spatial indexing and state-management data structures could be developed to accelerate collision detection and free-space queries while reducing memory footprint, thereby enabling substantially larger problem scales. Third, richer rotation models could be explored; beyond rotations about the vertical axis, limited-angle tilting about horizontal axes may further improve utilization and enhance the practicality of the resulting layouts.