3.1. Structured processing of 3d animation data based on eK-means algorithm

The core component of 3D animation data is the set of vertices in consecutive frames. However, the vertices in 3D animation are arranged randomly within frames, the number of vertices in each frame may change dynamically, and the coordinate data is floating-point. This disorder and irregularity makes it difficult to adapt to compression algorithms [14,15]. When processing such data, the traditional K-means algorithm is difficult to effectively organize vertex data due to the non-fixed cluster size, resulting in insufficient structuring and inability to fully adapt to the subsequent compression process [16]. To this end, the eK-means algorithm was proposed to realize the structuring of 3D animation data. This algorithm ensures that the number of vertices in each cluster does not exceed a specific value by setting equal cluster size, forming a stable equal-sized cluster structure, thus solving the problem of disorder and irregularity of vertex sets. The 3D animation data structuring process based on the eK-means algorithm is shown in Fig 1.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 1. Flowchart of 3D animation data structuring based on eK-means algorithm.

https://doi.org/10.1371/journal.pone.0357382.g001

In Fig 1, the process begins with inputting the original vertex set. First, the vertex data from the initial frame is selected as cluster samples, with cluster number computation and centroid initialization performed. Vertices are then assigned to nearest cluster centers using Euclidean distance calculations, forming temporary clusters while strictly controlling cluster size. The clustering process iteratively updates centroids until convergence criteria are met, yielding stable clusters of uniform size. Finally, a vertex index sequence is generated, followed by vertex reordering and coordinate component extraction from the original set to obtain a canonical matrix, completing the structural processing. Concretely, the eK-means algorithm assumes that the vertex set of the 3D animation is , where is the number of animation frames, is the number of vertices per frame, and the third dimension corresponds to the coordinate . To meet the real-time compression requirements, the vertex data of the first frame is selected as the clustering sample. The calculation of the number of clusters is given by equation (1).

(1)

In equation (1), represents rounding up to ensure that the number of vertices in each cluster does not exceed 64 (i.e., the number of elements in an 8 × 8 sub-block), ultimately forming an equal-sized cluster structure. vertices are randomly selected from as the initial cluster centers. The Euclidean distance between each vertex and each cluster center in is calculated, as shown in equation (2).

(2)

Each vertex is assigned to the region corresponding to its nearest cluster center, thus forming temporary clusters. The number of vertices in each temporary cluster is strictly controlled to ensure that it does not exceed 64. Then, for each temporary cluster, the mean of all vertices in it is calculated, and this mean is determined as the new cluster center, as shown in equation (3).

(3)

In equation (3), represents the th cluster, and represents the number of vertices within the cluster. The cluster assignment and center update steps are repeated until the convergence condition is met: the maximum distance between the cluster centers in two consecutive iterations is less than a preset threshold, or the number of iterations reaches its maximum value. After convergence, stable clusters are obtained, each cluster corresponding to a set of spatially adjacent vertices. A vertex index sequence is generated based on the clustering results: the vertices within each cluster are sorted in ascending order of cluster center distance, and then the vertex indices of all clusters are concatenated sequentially according to the cluster number. By reordering the vertex dimensions of the original vertex set via , a structured vertex set is obtained. Finally, the three coordinate components of are extracted into normalized matrices , , and , respectively, completing the data structuring process.

3.2 Design of a 3D animation compression algorithm based on adaptive spatiotemporal segmentation

After structuring, the 3D animation data has been transformed into a regular coordinate matrix, but there is still significant temporal redundancy between consecutive frames, and the differences in motion characteristics of different regions within a single frame result in insufficient exploitation of spatial redundancy [17,18]. To improve compression efficiency, a 3DACTAS algorithm was designed, and the flowchart of the 3DACTAS algorithm is shown in Fig 2.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 2. Flowchart of the 3DACTAS algorithm.

https://doi.org/10.1371/journal.pone.0357382.g002

Fig 2, the DCATAS algorithm does not require a fixed order of temporal and spatial segmentation. It dynamically determines the segmentation strategy based on data characteristics, decomposing the complete animation sequence into four spatiotemporal segmentation blocks with inherent consistency, thus achieving precise compression. This algorithm retains the regularity advantage of structured data and adapts the spatiotemporal dynamic characteristics of animation data through adaptive segmentation [19,20]. Specifically, based on the structured vertex set , the 3D mesh animation to be compressed is defined as shown in equation (4).

(4)

In equation (4), indicates the th frame’s structured vertex coordinate matrix, represents the vertex connection relationship. Next, the adaptive spatiotemporal segmentation stage begins [21,22]. The specific segmentation steps of adaptive spatiotemporal segmentation are shown in Fig 3.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 3. Schematic diagram of adaptive spatiotemporal segmentation steps.

https://doi.org/10.1371/journal.pone.0357382.g003

In Fig 3, the first step of adaptive spatiotemporal segmentation is initial temporal segmentation. For the structured animation data, potential segmentation frames are detected first within the range of frames , with the aim of quickly separating frame sequences with large temporal differences. If no effective segmentation frame is detected (i.e., there is still no significant difference at ), a spatiotemporal block is directly generated at , without the need for subsequent spatial segmentation. If is detected (abrupt change in inter-frame difference), spatial segmentation is performed on the data of frame length first, and then the second step, continuity detection, is performed. The second step is temporal segmentation that continues the spatial segmentation. Within the maximum allowed segmentation frame length , the potential segmentation frames are moved frame by frame. If the number of principal components changes, the segmentation is performed at the current ; if the principal components remain unchanged until , the segmentation is performed at the maximum frame length. The third step is temporal segmentation that does not continue the spatial segmentation. For the segmentation blocks generated in the second step, if there are no significant dynamic changes in subsequent data, the existing spatial segmentation results can be reused for direct temporal segmentation, avoiding repeated spatial clustering and reducing computational complexity.

Specifically, for the initial temporal segmentation, the study introduces the kernel embedding distribution and maximum mean difference theory to transform the segmentation problem into a problem of minimizing the correlation between two subsequences [23]. For a potential segmented frame within frame , the correlation between subsequence and needs to be minimized. The objective function is given in equation (5).

(5)

In equation (5), represents the correlation between the two subsequences. The similarity of vertex trajectories is measured by the Gaussian kernel function. The correlation calculation and kernel function definition are shown in equation (6).

(6)

In equation (6), and are the vertex trajectory sets of the two subsequences, respectively, and represents the vertex trajectory segment near the th frame with a window size of . represents the kernel function bandwidth parameter. Solving for the minimum correlation degree corresponds to , which is the initial segmented frame .

The temporal segmentation, which continues the spatial segmentation, is based on the frame blocks generated by the initial temporal segmentation. It divides the region based on the difference in the rigidity of vertex motion. The maximum change in the side length of adjacent vertices within the frame block is calculated. The side length change value is fitted by an exponential distribution. The edge with the smallest change is selected as a rigid edge, and the vertices connected to it are rigid vertices. The rest are non-rigid vertices. Then, a region growing algorithm is used to cluster the rigid vertices to obtain an initial rigid cluster. Finally, the rigid clusters are combined by minimizing the reconstruction error to ensure the intrinsic correlation of the segmented regions. The reconstruction error is shown in equation (7).

(7)

In equation (7), represents the trajectory vector of the th vertex, represents the cluster center vector, and represents the trajectory reconstruction vector. Finally, the spatial domain is divided into regions, completing the spatiotemporal collaborative segmentation.

For the temporal segmentation of the non-continuous spatial segmentation in the third step, in order to quantitatively judge the degree of dynamic change of the subsequent frame sequence, the inter-frame vertex trajectory similarity threshold is introduced to calculate the vertex trajectory similarity between the current frame and the last frame of the previous segmentation block, as shown in equation (8).

(8)

In equation (8), represents the trajectory vector of the th vertex in the current frame, represents the trajectory vector of the th vertex in the last frame of the previous segmentation block, and represents the number of vertices. When ≥, it is determined that the dynamic changes of the subsequent frame sequence are not significant, and the spatial domain segmentation result is reused for temporal domain extension; when <, the current extension is terminated, and the initial temporal domain segmentation process is re-executed to ensure that the segmentation block always has good internal feature consistency.

After completing the adaptive spatiotemporal segmentation and generating spatiotemporal blocks, the compression stage begins. In this stage, the study further adopts a combined strategy of “Principal Component Analysis (PCA) dimensionality reduction + lossless compression.” Specifically, the principal components of the spatiotemporal block are first extracted by PCA decomposition, and the first principal components with a cumulative contribution rate of not less than are retained to achieve data dimensionality reduction. PCA decomposition and reconstruction are shown in equation (8).

(9)

In equation (9), represents the data projection matrix, is the principal component matrix, and is the mean vector. The original data is approximated by the first principal components. Then, the dimension-reduced , , and are converted into binary data using the Zlib lossless compression algorithm. The final compression result is shown in equation (10).

(10)

In equation (10), represents the lossless compression result of the th spatiotemporal block, and the compressed data of the complete animation is obtained by accumulation. This adaptive spatiotemporal segmentation algorithm adapts to the motion characteristics of different animation data through a dynamic decision-making mechanism, which not only avoids the insufficient adaptation of fixed segmentation strategies to heterogeneous data, but also maximizes the removal of redundancy through spatiotemporal collaborative segmentation.

3.3. Optimization of 3D animation compression algorithm based on BE and MR

3DACTAS algorithm achieves accurate segmentation and preliminary compression of structured data in 3D animation, there are still two areas for optimization: First, when adjacent spatiotemporal segments are independently subjected to PCA dimensionality reduction, the difference in principal component selection can easily lead to inconsistent data reconstruction at block boundaries, destroying the global correlation of structured data; second, the matrix obtained by PCA decomposition is directly converted into a one-dimensional vector for lossless compression, failing to fully explore the intrinsic correlation between the same type of decomposition matrices in different segments, resulting in incomplete redundancy removal [24,25]. To address this issue, this study proposes a joint optimization strategy that integrates BE and MR to optimize and improve the 3DACTAS algorithm (hereinafter referred to as the I 3DACTAS algorithm).

To address the boundary inconsistency problem, this study utilizes the uniformly sized regular vertex clusters generated by the eK-means algorithm and designs a BE method based on structured cluster features. This method first expands the boundary of each structured cluster block by 2-neighborhood. Then, combining the structured vertex index sequence from the 3DACTAS algorithm, it locates the overlapping cluster regions of adjacent segmentation blocks and extracts the mean vertex coordinates as boundary reference features. During decompression and reconstruction, the boundary reference features of the current block and adjacent blocks are weighted and fused to correct the PCA dimensionality reduction error, ensuring a smooth transition of boundary vertex coordinates and avoiding abrupt changes.

To address the issue of untapped potential correlations in the decomposition matrix, this study proposes an MR optimization method based on spectral clustering, the overall process of which is shown in Fig 4.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 4. MR optimization flowchart.

https://doi.org/10.1371/journal.pone.0357382.g004

In Fig 4, MR optimization improves the redundancy removal efficiency of subsequent lossless compression through three core steps: feature extraction, adaptive clustering, and structured recombination. The premise of MR is to accurately measure the similarity of different decomposition matrices. Continuing the PCA decomposition results of the 3DACTAS algorithm, the projection matrix, principal component matrix, and mean vector of all spatiotemporal segments are denoted as a set . Since the decomposition matrix sizes of different segments differ, directly calculating the Euclidean distance has limitations [26,27]. Therefore, this study uses histograms to characterize the distribution characteristics of matrix data and measures the distribution similarity through Earth Mover’s Distance (EMD), as shown in equation (11).

(11)

In equation (11), represents the histogram feature of the decomposition matrix , and represents the similarity measure of the two matrices. The smaller the value, the closer the distributions are. The essence of EMD distance is to solve for the minimum transportation cost between the two distributions, as shown in equation (12).

(12)

In equation (12), represents the element migration between distributions, and represents the Euclidean distance between elements. After similarity measurement, spectral clustering algorithm is used to classify the decomposed matrix, and the process is shown in Fig 5.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 5. Flowchart of spectral clustering.

https://doi.org/10.1371/journal.pone.0357382.g005

In Fig 5, spectral clustering, through four steps—constructing a similarity graph, calculating the Laplacian matrix, eigenvalue decomposition, and clustering—can effectively handle the clustering problem of non-convex data and adapt to the complex distribution characteristics of the decomposition matrix. The number of clusters is determined using an adaptive calculation method, combined with the number of segmentation blocks, as shown in formula (13).

(13)

In equation (13), represents the rounding up operation, represents the number of clusters. After clustering, the decomposition matrices within the same category are restructured. To maximize the “contact area” of similar data and improve the efficiency of lossless compression, three restructuring methods are designed, as shown in Fig 6.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 6. Schematic diagram of MR reconstruction method.

https://doi.org/10.1371/journal.pone.0357382.g006

In Fig 6, the row-first filling method starts from the top left corner and fills rows sequentially, continuing after reaching the specified number of columns. The arched filling meth od fills rows to the end of the column and then fills the next row in the opposite direction, forming an alternating arrangement. The spiral filling method starts from the top left corner and fills clockwise in a spiral pattern until a regular square matrix is formed. During the recombination process, gaps caused by differences in matrix sizes are filled with 0. This method, while ensuring the regularity of the recombination, significantly reduces computational complexity and does not affect the compression effect compared to mean filling, maximum filling, and other methods. The recombination dimension is determined by the total number of elements in the same category of matrices, as shown in equation (14).

(14)

In equation (14), represents the target clustering category, represents the number of elements in the th decomposition matrix within the category, and represents the dimension of the recombined matrix.

4.1. Dataset selection

To verify the effectiveness of the proposed 3DACTAS and I3DACTAS algorithms, the study selected four 3D animation datasets—“Cloth,” “Chicken,” “Horse,” and “Michael”—for performance testing. The four datasets are all sourced from the public 3D animation dataset repository. To meet the experimental requirements of the study, targeted construction and preprocessing were performed on the public datasets: ① Cloth dataset: The original data consists of cloth fluttering animations, with a total of 200 frames and 10,240 vertices per frame. During construction, 120 frames with stable motion states and distinct deformation features were selected, and the number of vertices per frame was downsampled to 8,192, retaining the core features of random fluttering of flexible bodies; ② Chicken dataset: The original data consists of chickens pecking animations, with a total of 200 frames and 5,120 vertices per frame. During construction, 150 effective action frames were selected, and the number of vertices per frame was downsampled to 4,096, retaining the coupled features of local deformation at joints and overall rigid motion; ③ Horse dataset: The original data consists of horses running animations, with a total of 250 frames and 8,192 vertices per frame. During construction, 200 consecutive action frames were selected, and the number of vertices per frame was downsampled to 6,144, emphasizing the features of severe joint deformation; ④ Michael dataset: The original data consists of human walking and waving animations, with a total of 250 frames and 6,144 vertices per frame. During construction, 180 consecutive action frames were selected, and the number of vertices per frame was downsampled to 5,120, retaining the features of regular human motion and multi-part collaborative deformation. After preprocessing, the four datasets underwent normalization, mapping the vertex coordinates to the [0,1] interval to eliminate the impact of coordinate scale differences on experimental results. Finally, the experimental datasets required for the study were constructed, covering typical 3D animation types such as flexible, rigid-flexible hybrid, and human motion, with reasonable vertex scale and frame length distributions, enabling comprehensive testing of the algorithm’s generality and robustness. The experimental environment and algorithm parameter settings are shown in Table 1.

Download:

• PNG
  larger image
• TIFF
  original image

Table 1. Experimental environment and algorithm parameter settings.

https://doi.org/10.1371/journal.pone.0357382.t001

First, for the three core parameters of the eK-means algorithm, the compression ratio and peak signal-to-noise ratio (PSNR) were used as evaluation indicators to conduct a sensitivity analysis. The experimental results are shown in Fig 7.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 7. Sensitivity analysis of eK-means algorithm parameters (Evaluation metrics: Compression ratio and PSNR (dB); Experimental hardware: Intel i7-12700H + RTX3060).

https://doi.org/10.1371/journal.pone.0357382.g007

As shown in Fig 7(a), the maximum cluster size had a significant impact on the indicators. Within the range of 32–64, both the compression ratio and PSNR increased with increasing cluster size, reaching their optimal values at 64 (compression ratio 5.32, PSNR 41.38 dB). Beyond 64, both indicators declined due to decreased vertex correlation within the cluster. Fig 7 (b) shows that the convergence threshold’s influence was concentrated on PSNR. Within the range of 1e^-5 to 1e^-4, PSNR fluctuations were less than 0.6 dB. Beyond the threshold of 5e^-4, PSNR decreased rapidly, while the compression ratio remained relatively stable (fluctuations ≤ 0.05). Fig 7 (c) shows that the maximum number of iterations significantly improved PSNR within the range of 20–100, but converged after 100 iterations. Further increasing the number of iterations had minimal improvement on either indicator, indicating that 100 iterations were sufficient to meet the clustering stability requirements. In summary, the optimal parameter combination for eK-means was a maximum cluster size of 64, a convergence threshold of 1e⁻⁴, and a maximum number of iterations of 100. For the four core parameters of the 3DACTAS algorithm, the compression ratio and PSNR were used as evaluation indicators. Sensitivity analysis was carried out based on the structured dataset, and the experimental results are shown in Fig 8.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 8. Sensitivity analysis of 3DACTAS algorithm parameters.

https://doi.org/10.1371/journal.pone.0357382.g008

As shown in Fig 8, the cumulative contribution rate of PCA was negatively correlated with the compression ratio and positively correlated with PSNR. A balance between compression efficiency and reconstruction quality could be achieved at 95%. The compression ratio was optimal when the maximum segmentation frame length was 30. Too short a frame length led to too many segmentation blocks, increasing redundancy, while too long a frame length disrupted inter-frame correlation, causing a decrease in PSNR. The Gaussian kernel bandwidth parameter was optimal for both metrics when it was 0.1. Deviating from this value would reduce the accuracy of inter-frame difference detection and affect the segmentation effect. The rigid edge determination threshold was optimal when it is 0.02. Too small a threshold resulted in overly fine division of rigid regions, while too large a threshold would miss flexible deformation regions, both of which would reduce compression and reconstruction performance. In summary, the optimal parameter combination for 3DACTAS was a cumulative PCA contribution rate of 95%, a maximum segmentation frame length of 30, a Gaussian kernel bandwidth of 0.1, and a rigid edge determination threshold of 0.02.

To evaluate the parameter sensitivity of the I3DACTAS algorithm on unseen datasets, we selected the “Humanoid” dataset (human dance animation, 180 frames, 5120 vertices per frame) from a public dataset repository that was not used for training or optimization. The experiment tested the impact of core hyperparameters on SSIM and validated parameter generalization. Experimental results are presented in Table 2.

Download:

• PNG
  larger image
• TIFF
  original image

Table 2. Results of parameter generality validation.

https://doi.org/10.1371/journal.pone.0357382.t002

As shown in Table 2, when core hyperparameters fluctuate within ±12.5% of their optimal values, the SSIM change rate remains below 2%, indicating low sensitivity. Applying the optimal parameter set to unseen datasets achieves an SSIM score of 0.932 without additional tuning, demonstrating the parameters’ universality.

The study has identified a universal optimal parameter combination: maximum clustering size of 64, convergence threshold of 1e-4, maximum iteration count of 100, and cumulative PCA contribution rate of 95%. validated across datasets shows that SSIM fluctuations remain below 2% even with minor parameter variations, eliminating the need for separate optimization for different datasets. This parameter set demonstrates flexibility in adapting to various 3D animations—including rigid-rigid coupling and human motion—and exhibits both universality and robustness.

4.2. Performance test of 3D animation compression algorithm

First, to verify the performance of the eK-means algorithm in the structured processing of vertex data from 3D animations, this study compared four clustering algorithms—traditional K-means, K-means++, DBSCAN, and spectral clustering—in four 3D animation datasets: “Cloth,” “Chicken,” “Horse,” and “Michael.” The experiments were conducted using clustering contour coefficient, vertex regularity index (VRI), and clustering time as evaluation metrics. The results are shown in Table 3.

Download:

• PNG
  larger image
• TIFF
  original image

Table 3. Performance verification of eK-means algorithm.

https://doi.org/10.1371/journal.pone.0357382.t003

As shown in Table 3, the eK-means algorithm significantly outperformed the comparative algorithms in both silhouette coefficient and VRI on the four datasets. The average silhouette coefficient reached 0.755, representing improvements of 16.7%, 11.8%, 24.2%, and 6.9% compared to traditional K-means, K-means++, DBSCAN, and spectral clustering, respectively. The average VRI was 0.825, representing improvements of 15.9%, 10.2%, 22.3%, and 5.1%, respectively. This demonstrated its ability to generate structured vertex clusters with stronger spatial correlation and more uniform size. Furthermore, eK-means simplified the iterative logic through equal-cluster constraints, achieving an average clustering time of only 9.84 seconds, a reduction of 23.6%–53.2% compared to the comparative algorithms. This significantly reduced computational overhead while maintaining structured quality. To compare the performance of the 3DACTAS algorithm and the I3DACTAS algorithm, the study selected the 3D animation reconstruction error (KGError) as the evaluation index. The test results under different bits per vertex per frame (BPVF) are shown in Fig 9.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 9. Comparison results of 3DACTAS and I3DACTAS algorithms on different datasets.

https://doi.org/10.1371/journal.pone.0357382.g009

As shown in Fig 9(a), due to the strong randomness of motion in the Cloth flexible body dataset, the KGError of both algorithms was higher than that of other datasets. However, I3DACTAS showed significant optimization, reducing the error by 23.7% to 34.4% at various BPVFs compared to 3DACTAS. Fig 9(b) and (c) show that for the Chicken and Horse rigid-flexible hybrid datasets, due to the joint deformation coupling characteristics, I3DACTAS had a more prominent advantage at low BPVFs, reducing the error by 22.9% to 28.1%, and tended to stabilize at high BPVFs. Fig 9(d) shows that the Michael human motion dataset had regular trajectories and the lowest overall error. I3DACTAS reduced the average error by 24.5%, and the errors of both algorithms decreased with increasing BPVF. The error reduction slowed down when BPVF ≥ 8, indicating that this range could balance compression efficiency and reconstruction quality.

Next, the Adaptive Geometric Feature-based 3D Animation Compression Algorithm (AG-3DAC) and the Transformer-based 3D Animation Compression Algorithm (T-3DAC) were selected as comparison methods for the I3DACTAS algorithm. The results of the Spatiotemporal Edge Difference Error (STED) of the three algorithms under different BPVFs in four 3D animation datasets are shown in Fig 10.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 10. Comparison of STED results for different algorithms.

https://doi.org/10.1371/journal.pone.0357382.g010

As shown in Fig 10(a), due to the strong randomness of motion in the Cloth flexible body dataset, all three algorithms had the highest STED values. However, I3DACTAS had a significant advantage, reducing the STED by 34.6% ~ 38.1% compared to AG-3DAC and 24.7% ~ 31.2% compared to T-3DAC at various BPVFs. As shown in Fig 10(b) and (c), due to the coupling effect of joint deformation in the Chicken and Horse rigid-flexible hybrid datasets, the differences between the algorithms were more obvious at low BPVFs (2, 4). When BPVF = 2, I3DACTAS reduced the STED by 36.3% ~ 39.5% and 28.2% ~ 32.4% compared to the two comparison algorithms, respectively. The difference gradually narrowed at high BPVFs. As shown in Fig 10(d), the Michael human motion dataset had regular trajectories and the lowest overall STED value. I3DACTAS maintained the best performance under all BPVF conditions, with an average reduction of 32.1% and 23.5% compared to AG-3DAC and T-3DAC, respectively. Moreover, the STED of the three algorithms decreased with increasing BPVF, and the rate of decrease slowed down when BPVF≥8. The above results indicate that I3DACTAS exhibits the lowest error in all tests, validating its superior edge-preserving ability. In the (a) Cloth dataset, due to the strong randomness and flexibility characteristics of fabric motion, vertex trajectories undergo drastic and irregular changes, resulting in high STED values for all algorithms. However, I3DACTAS effectively smoothes the block boundaries through the BE strategy, significantly alleviating the tearing sensation of flexible bodies after compression. In the (b) Chicken and (c) Horse datasets, which are rigid-flexible coupled, the performance differences between algorithms are particularly evident at low bit rates. This is because traditional algorithms struggle to simultaneously account for local nonlinear deformation at joints and rigid body motion of the torso. In contrast, I3DACTAS’s adaptive segmentation can dynamically match motion characteristics and, combined with MR, exploits the inherent correlation in the data, thereby significantly reducing reconstruction errors. In contrast, the (d) Michael dataset, with its highly periodic and regular human walking motion, has the lowest overall STED value. I3DACTAS further optimizes boundary transitions on this basis, eliminating block artifacts and ensuring temporal continuity of the action.

Table 4 presents performance evaluation results of various algorithms under weak lighting and extreme disparity conditions. For weak lighting scenarios, ambient illumination intensity ranges from 5 to 30 lux with Gaussian illumination noise added during mesh vertex sampling; for extreme disparity scenarios, binocular data capture of 3D animation models exhibits a foreground-to-background disparity difference ≥50 pixels along with significant edge disparity jumps. Complex constraint test samples were generated using the Chicken and Michael datasets.

Download:

• PNG
  larger image
• TIFF
  original image

Table 4. Performance test results of different algorithms under weak lighting and extreme disparity conditions.

https://doi.org/10.1371/journal.pone.0357382.t004

As shown in Table 4, the I3DACTAS algorithm demonstrates significantly superior performance compared to competing algorithms under complex constraint conditions. In low-light environments where illumination noise can interfere with vertex coordinate acquisition, I3DACTAS employs eK-means structured clustering to filter noise disturbances, achieving an average reduction of 42.6% in KGError compared to other methods. Under extreme disparity scenarios, its boundary editing module effectively corrects block boundary distortions caused by sudden disparity changes, maintaining a high SSIM value of 0.867. In both challenging conditions, the algorithm’s rendering frame rate remains consistently above 50 FPS; contrastively, competing algorithms exhibit severe performance degradation due to their inability to suppress visual noise and boundary distortion. These results confirm that I3DACTAS exhibits stronger resistance to visual environmental disturbances.

Table 5 shows the test results of each algorithm in terms of KGError, Structural Similarity Index Measure (SSIM), compression ratio, and compression time on four 3D animation datasets.

Download:

• PNG
  larger image
• TIFF
  original image

Table 5. Test results of different algorithms on different datasets for various metrics.

https://doi.org/10.1371/journal.pone.0357382.t005

As shown in Table 5, the I3DACTAS algorithm performed best across all metrics. In terms of reconstruction quality, its KGError was reduced by an average of 38.7% and 31.5% compared to AG-3DAC and T-3DAC, respectively, while its SSIM was improved by an average of 8.9% and 5.6%. Particularly noteworthy was its excellent structure preservation capability, with a KGError as low as 0.037 and an SSIM of 0.945 on the Michael dataset. Regarding compression efficiency, I3DACTAS achieved an average compression ratio of 6.97, representing improvements of 28.3% and 22.1% compared to the other two algorithms. Furthermore, its compression time was reasonably controlled; although slightly longer than AG-3DAC, it was 18.6%–24.5% shorter than T-3DAC, avoiding time redundancy in complex models. KGError measures the deviation between reconstructed animations and original animations. Lower values indicate better reconstruction quality and reduced distortion. The I3DACTAS algorithm achieves 38.7% and 31.5% lower KGError averages compared to benchmark algorithms, demonstrating significant improvement in reconstruction quality and substantial distortion reduction. SSIM evaluates structural similarity between reconstructed and original animations within the [0,1] range, where higher values indicate better structural preservation. With an average SSIM of 0.934, I3DACTAS outperforms benchmark algorithms by effectively retaining original animation features and achieving visual fidelity closer to the source material. Compression ratio reflects data compression efficiency. Higher values signify greater compression effectiveness and more thorough removal of data redundancy. I3DACTAS achieves average compression ratios of 6.97, representing 28.3% and 22.1% improvements over benchmark algorithms, indicating superior compression efficiency. Shorter compression time reflects enhanced real-time performance. Although I3DACTAS requires slightly longer compression duration than AG-3DAC, its processing time is significantly reduced compared to T-3DAC, demonstrating successful balance between compression performance and real-time requirements.

The comparison results between the I3DACTAS algorithm and the most recent state-of-the-art algorithms (DyMeshVAE [28], NeCGS [29]) are shown in Table 6.

Download:

• PNG
  larger image
• TIFF
  original image

Table 6. Comparison between the I3DACTAS algorithm and the most recent state-of-the-art algorithms.

https://doi.org/10.1371/journal.pone.0357382.t006

As shown in Table 6, compared to the two recent SOTA algorithms, I3DACTAS demonstrates the best overall performance. Compared to DyMeshVAE, it reduces the average KGError by 15.2%, improves SSIM by 2.1%, enhances the compression ratio by 8.3%, and shortens the computational time by 9.5%. In contrast to NeCGS, it lowers the average reconstruction error by 9.8% and increases structural similarity by 1.4%. The two SOTA deep learning algorithms rely on graph networks and neural encoding, resulting in higher inference time. The 3DACTAS algorithm, on the other hand, leverages structured processing and adaptive segmentation, balancing compression accuracy, efficiency, and inference speed, while exhibiting superior generalization in flexible and human motion animation scenarios.

To verify the effectiveness of the core optimization modules of the BE and MR methods in the I3DACTAS algorithm, the Cloth flexible body dataset, which exhibited strong motion randomness, was selected, and ablation experiments were conducted under the condition of BPVF = 8. Four algorithm versions were designed for comparison: Version 1 was the complete I3DACTAS version (BE + MR), Version 2 was the version with BE removed and only MR retained, Version 3 was the version with MR removed and only BE retained, and Version 4 was the baseline 3DACTAS version without any optimizations. The ablation experiment results are shown in Fig 11.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 11. Ablation experiment results of the I3DACTAS algorithm.

https://doi.org/10.1371/journal.pone.0357382.g011

As shown in Fig 11(a) and (b), at the KGError and SSIM levels, removing the BE method increased the error to 0.071 and decreased the structural similarity to 0.886, representing a deterioration of 33.9% and a decrease of 4.1% respectively compared to the complete algorithm. This indicated that BE could effectively correct the block boundary inconsistency problem under the dynamic deformation of flexible bodies. As shown in Figure 11(c), at the compression ratio level, removing the MR optimization method reduced the compression ratio from 6.78 to 5.54, a decrease of 18.3%, highlighting MR’s ability to mine the correlation of the decomposition matrix. As shown in Figure 11(d), although the compression time was shortened by an average of 10.1% after removing a single module, the complete algorithm achieved the optimal balance between reconstruction quality and compression efficiency by synergistically combining BE and MR, sacrificing a small amount of time. The reduction in KGError demonstrates that the BE and MR modules effectively enhance reconstruction quality. The SSIM improvement indicates enhanced structural preservation capability, while the increased compression ratio reflects the MR module’s ability to effectively extract matrix correlations and eliminate redundancy. The slight increase in compression time demonstrates the reasonable trade-off in performance optimization achieved by the modules.

To address the high computational complexity and prolonged compression time of the I3DACTAS algorithm, two optimization strategies are proposed: ① Optimizing the spectral clustering algorithm by replacing spectral clustering with K-means clustering for decomposed matrix classification in the MR module, thereby reducing clustering computational overhead; ② Optimizing the decision logic of adaptive spatiotemporal segmentation to simplify inter-frame difference detection computation and decrease iteration cycles. The effectiveness of these optimizations is validated through performance comparisons before and after optimization. Experiments were conducted using the Cloth and Michael datasets as test objects, with compression time, compression ratio, KGError, and SSIM as evaluation metrics. Experimental results are presented in Table 7.

Download:

• PNG
  larger image
• TIFF
  original image

Table 7. Optimization results of computational complexity for the I3DACTAS algorithm.

https://doi.org/10.1371/journal.pone.0357382.t007

As shown in Table 7, the optimized I3DACTAS algorithm demonstrates significant compression time reductions. The Cloth dataset compression time decreased from 14.23 seconds to 7.86 seconds (44.8% reduction), while the Michael dataset compression time dropped from 11.98 seconds to 6.52 seconds (45.6% reduction), effectively minimizing computational overhead. Performance metrics exhibited only minor fluctuations: compression ratio showed slight decreases (0.16–0.18), KGError marginally increased (0.003–0.004), and SSIM slightly declined (0.006–0.007), all remaining within acceptable ranges. The algorithm’s positioning is clarified: For cross-platform real-time interaction scenarios, the compression process can adopt an offline preprocessing mode to pre-compress animation data, allowing direct access to compressed data during loading without real-time compression. For real-time compression requirements (e.g., live streaming scenarios), the proposed optimization strategies combined with GPU acceleration technology can further reduce compression time to under 5 seconds per sequence, meeting real-time performance requirements (frames <100ms) and resolving compression time bottlenecks.

Table 8 presents comparative experiments with the Universal Grid Compression Standard (MPEG-4 Part 16 Animation Framework Extension, AFX) and classical video compression technologies (MPEG PCC).

Download:

• PNG
  larger image
• TIFF
  original image

Table 8. Comparison results with general compression standards and classical techniques.

https://doi.org/10.1371/journal.pone.0357382.t008

As shown in Table 8, the I3DACTAS algorithm demonstrates significant superiority over both MPEG-4 AFX universal grid compression standards and MPEG PCC classic video compression technologies in three core metrics: compression ratio, KGError, and SSIM. In terms of compression ratio, I3DACTAS achieves 51.8%−54.6% improvement over MPEG-4 AFX and 44.5%−47.4% improvement over MPEG PCC, indicating enhanced redundancy removal capability. Regarding reconstruction quality, I3DACTAS reduces KGError by 28.1%−35.8% compared to benchmark standards while improving SSIM by 8.6%−11.0%, demonstrating superior reconstruction performance. Regarding compression time, optimized I3DACTAS reduces processing duration to 6.52–7.86 seconds, surpassing MPEG PCC and approaching MPEG-4 AFX levels. This breakthrough resolves the limitation of narrow comparison scope, proving that I3DACTAS not only outperforms specialized compression algorithms but also excels over universal standards and classical video compression techniques, showcasing remarkable performance advantages.

Finally, to validate the scalability of the I3DACTAS algorithm, we constructed ultra-high-resolution meshes and ultra-long sequence datasets. The algorithm’s performance was evaluated across different vertex scales (1 million, 5 million, 10 million vertices) and frame lengths (500 frames, 1000 frames, 2000 frames). Using the optimized I3DACTAS algorithm, assessment metrics included compression ratio, KGError, SSIM, and compression time. Experimental results are presented in Table 9.

Download:

• PNG
  larger image
• TIFF
  original image

Table 9. Scalability Verification Results of I3DACTAS Algorithm.

https://doi.org/10.1371/journal.pone.0357382.t009

As shown in Table 9, the I3DACTAS algorithm maintains robust performance stability across ultra-high-resolution grids (1 million to 10 million vertices) and ultra-long sequences (500–2000 frames). When vertex scale increases from 1 million to 10 million, the compression ratio only decreases from 6.58 to 6.35, while KGError rises from 0.058 to 0.064 and SSIM drops from 0.915 to 0.902. These gradual performance changes demonstrate the algorithm’s excellent adaptability to high-resolution grids. With frame length expanding from 500 to 2000 frames, the compression ratio shows slight improvement (6.58 to 6.71), KGError decreases marginally (0.058 to 0.055), and SSIM improves slightly (0.915 to 0.920), accompanied by linear growth in compression time—consistent with expected patterns. Theoretically, the eK-means algorithm employs cluster equality constraints to reduce computational load through parallel clustering for large vertex scales. Adaptive spatiotemporal segmentation dynamically adjusts partitioning strategies based on frame length to minimize computational redundancy in ultra-long sequences. MR optimization utilizes structured recombination to meet processing demands for large-scale decomposition matrices, ensuring strong scalability that effectively addresses compression requirements for both ultra-high-resolution grids and extended sequences.

The original I3DACTAS algorithm in the study requires 11–14 seconds for compression, making it well-suited for offline preprocessing of animation resources. Real-time interactive scenarios, however, do not require real-time compression; they only need to load preprocessed compressed data, thereby avoiding time-consuming processes. Additionally, the lightweight optimization proposed in the study reduces compression time to 5–8 seconds, and with GPU acceleration, it can be further compressed within 5 seconds—satisfying low-latency real-time compression demands such as live streaming and enabling seamless integration with various real-time interactive applications.

4.3. Analysis of practical application effects

To verify the engineering practical value of the I3DACTAS algorithm, the mainstream game development engine Unity 2022.3.8f1 was selected as the deployment platform to build a virtual character interaction system for practical application testing. This system was designed for cross-platform 3D character animation interaction scenarios on mobile and PC, requiring the loading of a large number of skeleton-driven character actions (such as running and attacking) and scene flexible body animations (such as flag waving and clothing swaying). Traditional compression algorithms suffer from problems such as excessive resource consumption leading to lag on mobile devices and unstable real-time rendering frame rates. This deployment integrates the I3DACTAS algorithm into the system’s animation resource preprocessing module, replacing the original default compression scheme. The tested animation types cover three typical animation resources of the system’s core applications: human character attack actions, flag waving animations, and human walking actions. The practical effect of the algorithm was verified through testing key system performance indicators. First, LoadRunner was used for performance testing. Fig 12 shows the platform’s minimum response time, maximum response time, CPU and memory usage under different concurrent user counts.

Download:

• PNG
  larger image
• TIFF
  original image

Fig 12. Performance test results of the virtual character interaction system.

https://doi.org/10.1371/journal.pone.0357382.g012

As shown in Fig 12, overall, with the increase in user concurrency, the platform’s minimum response time, maximum response time, CPU usage, and memory utilization all continuously increased. Specifically, at 500 concurrent users, the platform’s minimum response time was 0.903s, within 1 second; the maximum response time was 1.54s, within 2 seconds; and both CPU and memory utilization remained below 50%. These results demonstrated that the virtual character interaction system incorporating the I3DACTAS algorithm could provide users with stable and reliable services.

In practical application testing, four core practical indicators were selected: resource consumption after compression, animation loading time, average rendering frame rate, and user interaction latency. These were compared with the system's original default Zlib compression algorithm. The measured results are shown in Table 10.

Download:

• PNG
  larger image
• TIFF
  original image

Table 10. Practical application results.

https://doi.org/10.1371/journal.pone.0357382.t010

As shown in Table 10, the I3DACTAS algorithm significantly improved the system's practical performance after deployment. In terms of resource consumption, the compression of the two core animation resources on mobile devices reduced their usage by 85.7%–85.9% compared to the original algorithm, while the resource consumption for human walking animations on PCs decreased by 86.1%, greatly alleviating the problem of limited storage resources on mobile devices. Regarding loading performance, animation loading time was reduced by 72.2%–75.0% on mobile devices and by 84.6% on PCs, completely resolving the animation loading stuttering issue in cross-platform scenarios. In terms of real-time interaction, the average rendering frame rate on mobile devices increased by 44.7%–47.4%, maintaining a stable above 55 FPS, while the PC rate increased by 41.5%, reaching 92 FPS. Simultaneously, user interaction latency decreased by 46.1%–52.6%, with mobile latency controlled below 45ms and PC latency as low as 18ms, ensuring a smooth user experience. Even in scenarios with highly randomized flag-waving animations, I3DACTAS maintained excellent performance, verifying the algorithm's robustness in real-world engineering scenarios. This demonstrated that the algorithm could effectively adapt to the practical needs of cross-platform 3D animation interactive systems. Through resource compression and loading, and rendering performance optimization, it provided reliable technical support for practical applications and has significant practical value.