Efficient 3D Model Simplification Algorithms Based on OpenMP

Abstract

Efficient simplification of 3D models is essential for mobile and other resource-constrained application scenarios. Industrial 3D assemblies, typically composed of numerous components and dense triangular meshes, often pose significant challenges in rendering and transmission due to their large scale and high complexity. The Quadric Error Metrics (QEM) algorithm offers a practical balance between simplification accuracy and computational efficiency. However, its application to large-scale industrial models remain limited by performance bottlenecks, especially when combined with curvature-based optimization techniques that improve fidelity at the cost of increased computation. Therefore, this paper presents a parallel implementation of the QEM algorithm and its curvature-optimized variant using the OpenMP framework. By identifying key bottlenecks in the serial workflow, this research parallelizes critical processes such as curvature estimation, error metric computation, and data structure manipulation. Experiments on large industrial assembly models at a simplification ratio of 0.3, 0.5, and 0.7 demonstrate that the proposed parallel algorithms achieve significant speedups, with a maximum observed speedup of 5.5×, while maintaining geometric quality and topological consistency. The proposed approach significantly improves model processing efficiency, particularly for medium- to large-scale industrial models, and provides a scalable and practical solution for real-time loading and interaction in engineering applications.

1. Introduction

Mesh simplification is a critical technique in 3D computer graphics and modeling, designed to reduce the computational overhead and storage demands of complex models while preserving geometric fidelity [1]. As the complexity of 3D meshes continues to grow, particularly in industrial applications, the challenge of simplifying large-scale meshes without compromising essential geometric details have become increasingly prominent. This need is further amplified in domains such as virtual reality, industrial design, and medical imaging, where the need for efficient mesh simplification algorithms has escalated, especially under constrains of limited computational resources and bandwidth [2]. In particular, industrial 3D assemblies, which often involve intricate geometric details and are subject to real-time rendering or mobile platform constraints, pose unique challenges [3,4]. These models require simplification techniques that can reduce size and complexity while maintaining critical attributes such as sharp edges, textures, and overall structural integrity [5].

The research builds on decades of progress in 3D mesh simplification algorithms, particularly focusing on the Quadric Error Metrics (QEM) approach. QEM is recognized for its efficiency in simplifying meshes by minimizing geometric distortion through an error minimization framework. While highly effective, QEM faces challenges when applied to highly detailed models, as it may struggle to preserve local geometric details under significant compression ratios [6]. To address these limitations, this study incorporates OpenMP-based parallel computing to accelerate the simplification process while maintaining geometric fidelity. For industrial-scale 3D assemblies, characterized by their large size and structural complexity, multi-core processing is indispensable to meet the associated computational requirements [7]. Additionally, prior research has explored various optimizations of QEM, including curvature-based refinements and saliency detection methods, which have enhanced the quality of simplification for various mesh types. Nevertheless, substantial challenges remain in efficiently handling large-scale industrial models and the ability to optimize for real-time performance in dynamic applications [7,8].

Over the years, researchers have made considerable progress in the development of 3D mesh simplification algorithms [8]. Foundational works focused on improving the balance between compression ratios and geometric accuracy in mesh simplification [9]. More recent studies have further refined these methods by incorporating geometric detail preservation and saliency-driven mechanisms [10]. The QEM approach remains central to these developments due to its versatility and efficiency [11]. Despite the advancements, several limitations persist. Most existing algorithms are not optimized for large-scale models, particularly those used in industrial-scale 3D assemblies. They often fail to account for the dynamic nature of real-time rendering or the computational constraints of mobile platforms. Moreover, non-uniform simplification remains a challenge, particularly when preserving boundaries and planar surfaces [12,13,14]. These issues highlight the need for a more efficient and scalable simplification algorithm, one that integrates parallel computing strategies to manage the complexity of industrial-scale models effectively.

While many related studies have focused on simplification algorithms for static models, real-time performance and the scalability of these algorithms for industrial applications remain largely unexplored. Existing research has primarily addressed smaller-scale models or focused on preserving broad features, but fine-grained geometric detail preservation under high compression ratios, particularly for complex industrial-scale 3D assemblies, remains a insufficiently addressed [15,16]. Moreover, although parallel computing approaches have been applied to mesh simplification, these methods often lack optimization for large datasets or fail to integrate real-time constraints inherent in mobile and web-based applications. This paper addresses these gaps by applying OpenMP-based parallel computing to the QEM algorithm, which enables real-time simplification of large-scale industrial models. This approach ensures that key geometric details are maintained even under high compression ratios, providing a scalable solution to the challenges of simplifying complex industrial-scale 3D assemblies. The experimental results confirm that the proposed method is not only efficient but also scalable, making it suitable for real-world industrial applications.

Although QEM-based simplification algorithms have been widely studied and applied across different fields, significant research gaps remain in the simplification of industrial-scale models with real-time rendering and mobile compatibility [17,18]. The primary gap in the existing body of research lies in the efficient parallel computing of simplification tasks for large and dynamic 3D assemblies, which often contain intricate geometric details requiring precise preservation. Furthermore, the real-time processing demands of modern applications such as mobile platforms and web-based systems have not been fully addressed by previous research [19]. In recent years, several GPU-accelerated simplification approaches have been proposed to address these performance bottlenecks. Recent studies have proposed various GPU-accelerated approaches to address performance bottlenecks in mesh simplification. For instance, one CUDA-based method employed lock-free priority queues and independent mesh partitioning to enable high-speed edge collapse operations [20]. Similarly, a fully GPU-parallel polygonal mesh generator leveraging half-edge data structures achieved up to 700× speedups in specific scenarios [21]. End-to-end remeshing frameworks using curvature-driven tessellation and Voronoi clustering have also demonstrated notable improvements in both runtime efficiency and output fidelity [22]. However, despite these advances, most GPU solutions remain tailored to static models or narrowly defined remeshing tasks, and they are not readily applicable to large-scale, dynamic assemblies with hierarchical constraints [23]. This limitation underscores the continued need for parallel simplification techniques that are not only computationally efficient but also generalizable and suitable for real-time, interactive environments [24].

While these GPU-accelerated approaches mark notable progress in performance optimization, they often target static models or require highly specialized hardware and data structures, limiting their adaptability in diverse application scenarios [25,26]. In contrast, this study focuses on enhancing real-time performance and scalability by leveraging OpenMP-based parallel computing within the QEM framework. By focusing on real-time performance and scalability through the OpenMP-based parallel computing of QEM, this study introduces a novel contribution to the field. The integration of multi-core processing and curvature-based refinements makes it possible to handle complex meshes efficiently without compromising their visual quality. This study represents a critical step forward in bridging the gap between traditional mesh simplification algorithms and the dynamic, performance-constrained applications of modern industrial-scale 3D assemblies.

Research Work

Aiming at the problems of large-scale 3D mesh data and complex structure in industrial-scale assemblies, this study accelerates and optimizes the key computational modules of the traditional QEM algorithm and its approximate curvature-based refinement strategy through OpenMP-based parallel computing.

Specifically, the QEM algorithm and its key processes are first examined, and the reasons for its tendency to lose local details under high simplification ratios are analyzed. Next, an improved method based on approximate curvature is examined for the additional computational overhead required when it improves geometric fidelity, and the characteristics of the multi-core environment are combined to parallelize the core steps such as multi-part assembly calculation, error calculation, and curvature estimation. Finally, experiments are conducted on assembly model datasets of different scales to compare the similarities and differences between serial and parallel algorithms in terms of running speed, simplification quality, and scalability. The experimental results demonstrate that the proposed parallel computing strategy significantly reduces runtime while preserving the key geometric details of the model, thereby providing critical technical support for industrial-scale 3D assemblies in application scenarios such as real-time rendering and mobile deployment.

2. Construction of Quadric Error Metrics Algorithm and Approximate Curvature Algorithm (ACA)

2.1. Construction of Quadric Error Metrics Algorithm

The QEM algorithm introduces a novel framework for estimating edge collapse costs based on simplified linear computations. This approach not only enhances computational efficiency but also improves the geometric fidelity of simplified meshes, laying a solid foundation for many subsequent mesh simplification algorithms.

During the simplification process of the triangular mesh model, the edge collapse operation usually merges a pair of vertices into a new vertex and reconnects the relevant triangular faces. This process removes two to three triangles and alters the geometry of several adjacent triangular faces, as shown in Figure 1. To retain the details of the original mesh as much as possible, the simplification algorithm needs to determine which edge collapse operations cause the least error and prioritize collapsing these edges. In other words, the key issues lie in two aspects: (1) how to measure the error, that is, how to define the optimal pair of collapse vertices; and (2) how to determine the position of the new vertex after collapse in order to minimize the error.

The QEM algorithm uses “the sum of the squared distances from the new vertex to the planes of its first-order neighboring triangles” as the measurement standard for collapse cost. Specifically, the error metric is defined as the sum of the squared distances between the collapsed point and the local surface of the original mesh.

For Figure 1, two points are contracted into one point. Then it can be defined in the form of (1).

$$V_0=\mathit{arg}\underset{v}{min}{\sum }_{P\in plane\left(V_1\right)\cup plane\left(V_2\right)}d{\left(v,P\right)}^2$$

(1)

In the formula, $plane\left(V_i\right)$—the first-order neighborhood triangular face of point $V_i$; and $d{\left(V,p\right)}^2$—the square of the distance from point V to plane P.

In three-dimensional geometric space, a plane can be expressed as $Ax+By+Cz+D=0$, where $A^2+B^2+C^2=1$. Also, $p=(a,b,c)$ can represent the unit normal vector of the plane P. Then, this plane can be written as $p^{T}V=0$ in terms of the unit normal vector and a point $V=(x,y,z)$ on the plane. The sum of squared distances from any point $V=(l,m,n)$ in three-dimensional space to this plane can be expressed as (2)

$$\begin{gathered} d{\left(v,p\right)}^2={\displaystyle \frac{{\left(Al+Bm+Cn+D\right)}^2}{{\left(A^2+B^2+C^2\right)}^2}} \\ ={\left(Al+Bm+Cn+D\right)}^2 \\ ={\left(p^{T}v\right)}^2={\left(v^{T}p\right)}^2 \\ =\left(v^{T}p\right)\left(p^{T}v\right) \\ ={ v}^T\left(p{p}^T\right)v \\ =v^T{K}_{p}v \end{gathered}$$

(2)

The definition of $K_p$ is given in (3).

$$K_p={pp}^T=\left[\begin{array}{cccc}{a}^2& ab& ac& ad\\ ab& b^2& bc& bd\\ ac& bc& c^2& cd\\ ad& bd& cd& d^2\end{array}\right]$$

(3)

Then $V_0$ in (2) can be represented by (4).

$$V_0=\mathit{arg}\underset{v}{mi}{v}^T\left(\sum _{P\in plane\left(V_1\right)\cup plane\left(V_2\right)}{K}_p\right)v$$

(4)

The quadratic error matrix $Q_v$ can be defined by Equation (5). Both $K_p$ and $Q_v$ are symmetric matrices, and only 10 elements need to be stored to represent them.

$$Q_v=\sum _{P\in plane\left(v\right)}{K}_p$$

(5)

Approximately, it is considered that the sum $\sum _{P\in plane\left(V_1\right)\cup plane\left(V_2\right)}{K}_p$ can be expressed as (6)

$$\begin{gathered} {\sum }_{P\in plane\left(V_1\right)\cup plane\left(V_2\right)}{K}_p= \\ \sum _{P\in plane\left(V_1\right)}{K}_p+\sum _{P\in plane\left(V_2\right)}{K}_p \end{gathered}$$

(6)

Then (4) can be expressed as (7)

$$\begin{array}{c}{V}_0=\mathit{arg}\underset{v}{min}{v}^T\\ \hspace{1em}\hspace{1em}\hspace{1em} \left({\displaystyle \sum _{P\in plane\left(V_1\right)}}{K}_p+{\displaystyle \sum _{P\in plane\left(V_2\right)}}{K}_p\right)v\\ =\mathit{arg}\underset{v}{min}{v}^T(Q_1+Q_2)v\end{array}$$

(7)

The quadratic error matrix $Q_{V_0}$ of the new vertex $V_0$ can be expressed as (8)

$$Q_{V_0}=Q_{V_1}+Q_{V_2}$$

(8)

The quadratic error of the new vertex $V_0$ after folding can be expressed as (9)

$$\begin{array}{c}\Delta \left(V_0\right)=V_0^T{Q}_{V_0}{V}_0\\ \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}=q_{11}{x}_t^2+2q_{12}{x}_t{y}_t+2q_{13}{x}_t{z}_t\\ \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}+{{2q}_{14}{x}_t+q}_{22}{y}_t^2+2q_{23}{y}_t{z}_t+\\ \hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}\hspace{1em}2q_{24}{y}_t+q_{33}{z}_t^2+2q_{34}{z}_t+q_{44}\end{array}$$

(9)

The error introduced by edge collapse is mainly determined by the position of the new vertex after collapse and the sum of the quadratic error matrices formed by the first-order neighborhood triangular face corresponding to the vertices at both ends of the original edge. In the triangular mesh model, the information of the edge and its associated vertices is known before simplification. Therefore, only by determining the optimal position of the new vertex can the collapse cost of this edge be accurately calculated.

The coordinates of the new point need to minimize the quadratic error of this edge as much as possible. Take the partial derivative of the quadratic error of the new vertex $V_0$ to obtain the value of the new vertex, as shown in (10).

$${\displaystyle \frac{\mathsf{\partial }{\Delta }^{\prime }\left(V_0\right)}{\mathsf{\partial }x}}={\displaystyle \frac{\mathsf{\partial }{\Delta }^{\prime }\left(V_0\right)}{\mathsf{\partial }y}}={\displaystyle \frac{\mathsf{\partial }{\Delta }^{\prime }\left(V_0\right)}{\mathsf{\partial }z}}=0$$

(10)

From (10), we can obtain (11).

$$\left[\begin{array}{cccc}{q}_{11}& q_{12}& q_{13}& q_{14}\\ q_{12}& q_{22}& q_{23}& q_{24}\\ q_{13}& q_{23}& q_{33}& q_{34}\\ 0& 0& 0& 1\end{array}\right]V_0=\left[\begin{array}{c}0\\ 0\\ 0\\ 1\end{array}\right]$$

(11)

Therefore, the coordinates of $V_0$ can be directly obtained, and the calculation method is shown in (12):

$$V_0={\left[\begin{array}{cccc}{q}_{11}& q_{12}& q_{13}& q_{14}\\ q_{12}& q_{22}& q_{23}& q_{24}\\ q_{13}& q_{23}& q_{33}& q_{34}\\ 0& 0& 0& 1\end{array}\right]}^{-1}\left[\begin{array}{c}0\\ 0\\ 0\\ 1\end{array}\right]$$

(12)

When the matrix is not invertible, directly select the vertex with the smaller quadratic error among the edges to be folded as the position of the new vertex. If the quadratic errors of the two vertices are the same, select the midpoint of the two points as the position of the new vertex. The specific calculation method is shown in (13).

$$V_0=\left\{\begin{array}{c}{V}_1,{ Q}_{V_1}<Q_{V_2}\\ V_2,{ Q}_{V_1}>Q_{V_2}\\ \left(V_1+V_2\right)∕2,Q_{V_1}=Q_{V_2}\end{array}\right.$$

(13)

In the formula, $V_0$—position of the new point after collapse; $V_1,V_2$—positions of points before collapse; and $Q_{V_1},Q_{V_2}$—$V_1,V_2$ respective quadratic error matrices.

Figure 2 illustrates the overall workflow of the QEM simplification algorithm. The process begins with setting simplification parameters such as the target ratio, followed by loading the 3D model in mesh format. Based on the parameters, the target number of faces is computed, and a threshold is established for edge collapse operations. Each edge is then assigned a collapse cost, and those with costs below the threshold are iteratively removed through edge collapse operations. After each collapse, the vertex, edge, and face information of the mesh is updated to ensure geometric consistency. The algorithm continues until the simplification target is reached, after which the final simplified model is output. This flow chart provides a clear procedural overview that complements the mathematical formulations introduced earlier, highlighting the iterative nature of QEM-based mesh simplification. The basic calculation flow chart of the QEM algorithm is as follows:

2.2. Construction of Approximate Curvature Algorithm

Curvature is used to characterize the degree of bending of a curve. A larger numerical value indicates a more significant bend. Since the surface of the triangular mesh is composed of a series of continuous planes and lacks the smoothness of a real curved surface, approximate curvature is usually used to measure its local geometric variation. Regions with smaller curvature are generally flatter, whereas regions with larger curvature contain more geometric details, reflecting higher geometric complexity. The approximate curvature of the triangular mesh surface can be expressed by Equation (14).

$$Cur\left(Edge\left(V_1,V_2\right)\right)={\displaystyle \frac{angle\left(N\left(V_1\right),N\left(V_2\right)\right)}{‖V_1-V_2‖}}$$

(14)

In the formula, $Edge\left(V_1,V_2\right)$—the edge determined by vertices $V_1,V_2; Cur\left(Edge\left(V_1,V_2\right)\right)$—the approximate curvature of the edge $\left(V_1,V_2\right); N\left(V_1\right),N\left(V_2\right)$—the vertex normal vector of vertices $V_1,V_2; angle\left(N\left(V_1\right),N\left(V_2\right)\right)$—the included angle between the normal vector of the two vertices $V_1,V_2; \mathrm{and} ‖V_1-V_2‖$—the length of the edge determined by $V_1,V_2$.

As shown in Equation (14), the calculation of vertex normal vectors directly affects the estimation result of approximate edge curvature. In this process, the algorithm comprehensively considers the area and interior angle information of the first-order neighborhood triangles. That is, triangle-area weighting is applied to reflect the relative influence of different faces on the vertex normal vector, while interior-angle weighting is introduced to correct the deviations caused by differences in triangle shapes. Specifically, triangles with larger areas are assigned higher weights in the normal vector calculation, thus exerting greater influence on the vertex direction estimation. When multiple triangles have similar areas but significantly different shapes, weighting by vertex interior angles more accurately reflects the contributions of different shapes to geometric features, thereby effectively reducing the errors caused by shape differences and improving the accuracy of curvature approximation.

Therefore, the normal vector of vertex $V_i$ is given by Equation (15)

$$\mathrm{N}\left(V_i\right)={\displaystyle \frac{\sum _{fϵfaces\left(V_i\right)}{\gamma }_f{A}_f{n}_f}{‖\sum _{fϵfaces\left(V_i\right)}{\gamma }_f{A}_f{n}_f‖}}$$

(15)

In the equation, $N\left(V_i\right)$—the vertex normal vector of vertex $V_i; {\gamma }_f$—the interior angle size of a first-order neighborhood triangle corresponding to vertex $V_i;A_f$—the area of this triangle; and $n_f$—the initial normal vector of this triangle.

A foldable approximate edge curvature can be calculated from (14) and (15).

3. Parallel Processing Algorithm Construction and Experiment

3.1. Overview of Parallel Optimization Strategy

Analysis of the Fast QEM mesh structure reveals a distinct tree-like dependency between triangle-face data and the vertex data. The initialization of base vertices and the computation of the normal vector form the basis for all subsequent edge collapse evaluation and geometric updates. Moreover, the collapse operations on different edges at the same hierarchy level are data-independent, thus demonstrating inherent parallelism. Based on this characteristic, this study proposes a parallel strategy combining multi-level task restructuring with decoupling, which reorganizes the core process of the original serial QEM algorithm in a modular manner and enables thread-based processing, thereby providing structural support for efficient parallelization.

3.1.1. Data Structure Layering Strategy

The mesh-processing workflow of the Fast QEM algorithm can be divided into five stages with clearly defined dependency order: vertex information initialization (designated as the base layer), quadric matrix initialization, triangle referencing and edge error calculation, edge collapse evaluation, and vertex update, as well as topological compression and mesh reconstruction. This hierarchical structure clarifies the computational dependency boundaries, enabling thread-level parallel processing at each stage while fully ensuring data consistency. With this structured parallel design, the proposed method effectively eliminates dependency conflicts among tasks within each stage, significantly improving computational resource utilization.

3.1.2. Concrete Algorithm Implementation

• Step 1. Loading and Preprocessing Stage: All OBJ files of the 3D part models in assembly are loaded simultaneously to construct the 3D mesh data list.
• Step 2. Thread Pool Initialization: A thread pool for parallel simplification is established, followed by the creation of OpenMP parallel tasks to manage simplification states within each thread-private cache.
• Step 3. Parallel Initialization: Triangle references and edge quadric error metrics are initialized in parallel, while new triangle data are constructed concurrently.
• Step 4. Iteration Termination Check: If the number of triangles has not yet reached the target threshold, parallel collapse operations continue.
• Step 5. Compression and Output: Perform the final mesh compression and output the simplified OBJ file.

3.2. Parallel Algorithm Experiment

To evaluate the actual performance of the proposed parallel 3D mesh simplification algorithm (including the traditional QEM algorithm and the ACA) in processing large-scale 3D meshes, three representative industrial models with varying scales and complexities, “Transport Vehicle,” “Robotic Arm,” and “Pipeline”, were selected for experimentation, as illustrated in Figure 3, Figure 4 and Figure 5. The face counts of these models are 7,892,504, 296,462, and 4,194,970, respectively, with file sizes ranging from 89.9 MB to 2.58 GB, which ensures good representativeness. They collectively comprise 350 individual components, and basic information is summarized in

Table 1. Basic information on the 3D model used in parallel computing experiments.

3D Model Name	Transport Vehicle	Manipulator Arm	Pipeline
Model Size	2.58 GB	89.9 MB	1.36 GB
Number of Part Models	217	28	105
Number of Faces	7,892,504	296,462	4,194,970
Simplification Rate	0.5	0.5	0.5

. All parallel computing experiments were conducted on a high-performance mobile workstation equipped with an Intel i7 hexa-core processor and 64 GB of memory. The operating system was Microsoft Windows 10. All C++ programs were developed and tested using Microsoft Visual Studio 2022 (compiler: MSVC v14.3) and OpenMP 2.0 standard.

3.3. Analysis of Experimental Results

To verify the effectiveness of the proposed parallel optimization strategy, a comparison was conducted between the traditional QEM algorithm and the approximate curvature-based refinement. Figure 6, Figure 7 and Figure 8 illustrate the computation time of the ACA and QEM-based simplification algorithms under different simplification ratios (30%, 50%, and 70%) with varying numbers of threads. A consistent trend is observed across all cases: parallelization significantly reduces computation time compared with the serial baseline, and the benefit becomes more evident as the model size increases. For ACA, which is computationally more intensive, the parallel efficiency improvement is particularly pronounced. At higher simplification ratios (50% and 70%), ACA achieves a substantial reduction in execution time, especially for large-scale meshes (e.g., 500 k–2 M faces), indicating that larger workloads provide more opportunities for parallel exploitation. In contrast, QEM exhibits lower computational demand, resulting in relatively limited speedup; in small-scale meshes (0–10 k faces), the overhead of thread scheduling even dominates, leading to minimal efficiency gain.

To exploit the benefits of multi-thread parallelization, two levels of parallelism were implemented in the simplification framework. First, for large assemblies consisting of multiple parts, simplification was performed independently on each part. Since there is no computational dependency among different parts, the process can be executed concurrently without requiring synchronization. Second, within each part, the calculation of QEM or approximate curvature values for all vertices was parallelized, as the error metric of each vertex is independent of others.

The parallel implementation was realized using OpenMP directives. For vertex-based operations, a static scheduling strategy was adopted to evenly distribute the workload across threads while minimizing scheduling overhead. Shared mesh data, such as vertex and face information, were carefully handled to avoid conflicts: thread-private variables were used for local computations, and updates were aggregated after each parallel section. This design ensures that the majority of computations—particularly part-level simplification and vertex-level error metric evaluation—are executed in a highly parallel manner, while synchronization costs are kept minimal. As a result, the proposed implementation achieves both computational efficiency and reproducibility.

Moreover, the comparison between different simplification ratios highlights that higher ratios enhance the effectiveness of parallelization. At 30% simplification, the total runtime remains relatively short, and the gain from parallel computing is moderate (

Table 2. Multi-threaded parallelization calculation of 3D model simplification for computation Time (simplification ratio: 30%).

Algorithm	Model Name	Simplification Time (s)
		No Parallel	2 Threads	3 Threads	4 Threads	5 Threads	6 Threads	7 Threads	8 Threads
QEM	Transport Vehicle	169.128	134.229	124.359	97.762	71.062	56.598	52.476	44.981
	Mechanical Arm	5.999	5.535	4.896	3.643	2.862	2.167	1.986	1.666
	Pipeline	88.397	79.343	64.085	51.380	43.587	32.501	27.484	23.894
ACA	Transport Vehicle	1068.636	1187.381	627.344	517.712	537.303	405.468	381.656	344.721
	Mechanical Arm	36.005	45.576	20.397	19.391	14.521	13.067	13.848	11.922
	Pipeline	609.405	620.067	503.883	476.148	289.121	279.101	199.755	183.058

). At 50% simplification, the runtime shows a noticeable increase compared with 30%, and parallel computing provides a clear efficiency advantage (

Table 3. Multi-threaded parallelization calculation of 3D model simplification for computation time (simplification ratio: 50%).

Algorithm	Model Name	Simplification Time (s)
		No Parallel	2 Threads	3 Threads	4 Threads	5 Threads	6 Threads	7 Threads	8 Threads
QEM	Transport Vehicle	361.543	191.652	152.632	121.365	96.187	76.739	72.447	71.383
	Mechanical Arm	12.813	6.813	5.576	4.243	3.234	3.086	2.728	2.330
	Pipeline	186.216	99.985	78.266	59.894	49.042	41.713	34.630	34.793
ACA	Transport Vehicle	2310.260	1574.612	1550.400	1019.628	917.744	848.163	671.954	699.878
	Mechanical Arm	78.451	53.040	48.626	37.737	30.710	28.049	24.414	24.183
	Pipeline	1101.373	896.796	752.663	581.087	459.756	357.839	363.389	301.920

). However, at 70% simplification, the runtime increases significantly in the serial case, and parallel execution yields a much sharper reduction in computation time (

Table 4. Multi-threaded parallelization calculation of 3D model simplification for computation time (simplification ratio: 70%).

Algorithm	Model Name	Simplification Time (s)
		No Parallel	2 Threads	3 Threads	4 Threads	5 Threads	6 Threads	7 Threads	8 Threads
QEM	Transport Vehicle	567.586	361.740	259.788	196.654	160.365	144.794	127.750	119.970
	Mechanical Arm	20.069	13.698	10.286	7.266	5.726	4.623	4.106	3.798
	Pipeline	295.522	205.164	154.230	103.922	88.546	69.524	59.770	58.957
ACA	Transport Vehicle	3690.765	3513.644	2484.314	1925.705	1607.630	1389.438	1304.468	1149.177
	Mechanical Arm	123.160	101.244	83.557	62.134	52.418	45.492	41.433	37.575
	Pipeline	1746.319	1434.758	1165.924	1079.959	773.248	601.095	527.391	487.983

). This finding demonstrates that computational intensity and problem scale are key factors in determining the efficiency of multi-threaded acceleration. Overall, the results confirm that ACA is better suited for parallelization, and higher simplification ratios coupled with large and complex models maximize the benefits of multi-thread computation. Overall, the improved QEM algorithm and approximate curvature-based refinement efficiently utilize multi-core resources, demonstrating strong parallel scalability and stability in simplification tasks for medium-to-large-scale models.

To substantiate these findings, we conducted experiments comparing the two algorithms on representative industrial meshes under multi-threaded environments. The results show that the ACA achieves a speedup ratio comparable to that of the QEM algorithm across all thread configurations, with performance gains reaching up to 5.5× for large-scale models, thereby confirming the favorable scalability of the proposed approach.

However, the extent of acceleration also varies with the complexity of the models. From the perspective of mesh complexity, experimental results on the three types of models suggest that the speedup ratio increases significantly with the number of triangles. The “Transporter” model, which originally contains more than 7.8 million triangles, can effectively fill the thread task queue, thereby exhibiting superior acceleration potential under multi-threaded computation. In contrast, the “Robotic Arm” model, with fewer triangles, faces limitations in thread scheduling and task partitioning, resulting in relatively lower acceleration performance. Meanwhile, the figure also exhibits the typical characteristic of diminishing marginal acceleration. In general, the acceleration efficiency decreases as the number of threads increases. This phenomenon can be attributed to several factors. First, additional parallel overhead, including thread creation, task scheduling, and synchronization, becomes increasingly significant when more threads are employed, thereby offsetting the benefits of parallelization. Second, according to Amdahl’s law, the inherently sequential portion of the algorithm imposes an upper bound on the achievable speedup, resulting in diminishing returns with larger thread counts. Furthermore, intensive memory access during mesh simplification introduces cache contention and memory bandwidth limitations, which restrict further improvements in execution time. Consequently, while the parallelization strategy effectively reduces the simplification time for large-scale meshes, the efficiency gain tends to saturate as the number of threads increases.

The results presented in Figure 9, Figure 10 and Figure 11 reveal the impact of multi-thread parallelization on the computational efficiency of both QEM- and ACA-based simplification algorithms under different simplification ratios. Overall, the speedup achieved by parallel computing exhibits a consistent increasing trend with higher thread counts, although the magnitude of improvement strongly depends on the algorithm type, simplification ratio, and model category. Specifically, ACA shows more substantial parallel acceleration than QEM across all tested scenarios, which can be attributed to its higher computational complexity and larger per-thread workload, making it more suitable for parallel exploitation. In contrast, QEM demonstrates only modest speedup gains, especially under lower simplification ratios, where the computational burden is relatively small and parallel overhead offsets much of the benefit (Table 2, Table 3 and Table 4).

Furthermore, increasing the simplification ratio enhances the effectiveness of parallel computing. At 30% simplification, the maximum speedup remains below 4.0 in most cases, whereas at 70% simplification, ACA achieves speedup values exceeding 5.0 for large models such as the transport vehicle. This indicates that larger simplification workloads provide greater parallelism potential, as the overhead of thread management becomes less significant relative to the overall computation. In addition, the performance across different models (pipeline, mechanical arm, and transport vehicle) suggests that geometric complexity and face count distribution also play an important role: more complex models consistently yield higher acceleration efficiency under the same simplification ratio.

In summary, the results highlight that (1) ACA benefits more significantly from multi-thread parallelization than QEM, (2) higher simplification ratios enhance parallel efficiency due to increased computational intensity, and (3) complex models with larger mesh sizes show greater scalability. These findings demonstrate the necessity of tailoring the choice of simplification algorithm and thread configuration to the model size and target simplification ratio in order to achieve optimal computational efficiency.

A comprehensive analysis reveals that the ACA is better suited for executing the mesh simplification task in the multi-threaded parallel environment. The core calculation process of this algorithm features a high degree of task independence and excellent load balancing capability, allowing it to demonstrate greater parallel scalability and execution efficiency on multi-core platforms. In contrast, while the parallel acceleration of the traditional QEM algorithm is less pronounced compared to the ACA, its relatively straightforward overall calculation process and high serial execution efficiency provide it with some parallel potential and practical value in the overall computational environment. For small-scale models or a low thread count, the ACA can more effectively handle the simplification tasks of medium and large 3D meshes while maintaining simplification accuracy and topological consistency. It also boasts stronger engineering adaptability and promising application prospects.

4. Conclusions

To address the increasing demand for efficient and accurate processing of large-scale industrial 3D mesh, this study investigates the parallel optimization of classic simplification algorithms. The QEM algorithm, known for its balanced performance in geometric fidelity and computational efficiency, has laid a solid foundation for 3D mesh simplification in industrial contexts. However, with the growing scale and complexity of industrial assemblies, traditional serial algorithms fall short in meeting real-time and high-throughput requirements.

This research focuses on the parallelization and performance optimization of the QEM algorithm and its enhanced variant based on approximate curvature estimation. To overcome the bottlenecks posed by large and complex assemblies, which introduce an OpenMP-based parallel framework that leverages data hierarchization and task decoupling, key steps—such as multi-component simplification, error metric calculation, and curvature estimation—are optimized through thread-level parallel acceleration. A hierarchical structure is designed to ensure data consistency and task independence during parallel execution, enabling efficient and scalable processing.

The major outcomes of this study are as follows:

• Efficient Parallel Strategy: A hierarchical, decoupled parallel simplification framework was developed, demonstrating reliable performance across diverse industrial-scale models.
• Significant Acceleration: Experimental results on three representative industrial models reveal a maximum speedup of 5.5× over traditional serial approaches, with the improvement being most pronounced for large-scale triangular mesh models.
• Algorithm-Specific Insights: The QEM algorithm shows potential for lightweight optimization due to its low computational density, while the approximate curvature variant benefits more from parallelism under high thread-count environments due to its heavier computation load.

Despite these promising results, some limitations remain. First, the current parallel strategy is primarily CPU-based, which may restrict scalability for ultra-large models. Second, load balancing among threads still poses challenges when processing highly heterogeneous structures. Future work will explore hybrid parallelization schemes, such as GPU acceleration and region-based task scheduling, to further enhance real-time performance and adaptability to larger and more complex assemblies.