Skin weight data efficient compression and rapid read-write method based on sparsity theory for animation production

Abstract

The invention provides a skin weight data efficient compression and rapid read-write method based on a sparsity theory for animation production. The method comprises the following steps: (1) circularly traversing each vertex by using a cmds.skinPerent command, and obtaining a skin weight value; (2) carrying out compression processing on the skin weight data, and only reserving a non-zero weight value and a joint index corresponding to the non-zero weight value; (3) storing the compressed data in a disk in a binary format; (4) reading the storage data in the binary format from a disk and decompressing the storage data; and (5) applying the decompressed skin weight data to a target model. The problems of large file size, low read-write efficiency, poor flexibility and the like in the prior art can be solved.

Description

Technical Field

[0001] This invention relates to the field of 3D animation image data processing, and more specifically to a method for efficient compression and fast reading / writing of skinned weight data based on sparsity theory for animation production. Background Technology

[0002] In 3D animation production, skinning weights are used to define the influence relationship between model vertices and skeletal joints, and are one of the core data sets for character animation. Traditional methods and their drawbacks mainly include:

[0003] 1. UV mapping method: Encodes weight information into an image, resulting in large file size, low precision, and no support for topological changes.

[0004] 2. JSON text method: Human-readable but highly redundant, large file size, and low read / write efficiency.

[0005] 3. C++ plugin method: High performance but complex development, poor flexibility and difficult maintenance.

[0006] Maya traditionally uses UV mapping to store and transfer skin weights. However, this method has a key limitation: it only works for models with identical topologies. For example, a basic sphere and a complex model obtained by "extruded" its surfaces have different 3D shapes and vertex counts. Even if their UV layouts look similar, the UV weight map based on the original sphere cannot be correctly applied to the new model because the underlying vertex relationships have changed, leading to incorrect weight allocation. For instance, in game development scenarios, hundreds of soldiers with "variable appearances but universal skeletal animations" (such as soldiers with different equipment and skin colors) need to be bound to a unified skeleton (such as 15-20 joints for a humanoid character) to support shared animations like running, jumping, and attacking. The biggest pain point here is that manually modeling each variant (hair, equipment fine-tuning), binding them one by one, and manually applying weights would take months and easily result in "weight deviations causing clipping in animations." This would significantly slow down the animation production workflow.

[0007] With the increasing precision of models and the number of joints, traditional methods are no longer sufficient to meet the dual demands of efficiency and accuracy in modern animation production. Therefore, there is an urgent need for an efficient, lossless, and easy-to-use 3D animation data management solution. Summary of the Invention

[0008] The purpose of this invention is to address the shortcomings of existing technologies by providing an efficient compression and fast read / write method for skinning weight data based on sparsity theory for animation production, thereby solving problems such as large file size, low read / write efficiency, and poor flexibility in existing technologies. This objective can be achieved through the following technical measures:

[0009] A method for efficient compression and fast read / write of skinning weight data based on sparsity theory for animation production includes the following steps:

[0010] (1) Use the cmds.skinPercent command to iterate through each vertex of the 3D model and obtain the skin weight data of the joints affected by each vertex;

[0011] (2) The skin weight data is compressed, and only non-zero weight values ​​and joint indices corresponding to non-zero weight values ​​are retained;

[0012] (3) Store the compressed data to the disk in binary format;

[0013] (4) Read the stored data in binary format from the disk and decompress it;

[0014] (5) Apply the decompressed skin weight data to the target model.

[0015] Furthermore, the compression process in step (2) above is as follows:

[0016] (2.1) Preparation for weight data extraction and compression: Store the skinning weight data of all vertices in order into a one-dimensional weight array "weights_Array";

[0017] (2.2) Non-zero weight filtering: Iterate through each skin weight data in "weights_Array", store the non-zero weight values ​​in "weightsNonZero_Array", and record the joint index corresponding to the non-zero weight value;

[0018] (2.3) Vertex boundary marker: During the traversal, the SkinPercent command in the maya.cmds module is called to record the position of the current non-zero weight value in "weightsNonZero_Array" and store it as the vertex boundary marker in the vertex split array "vertSplit_Array";

[0019] Furthermore, the process of storing the vertex splitting array vertSplit_Array in step (2.3) above is as follows:

[0020] Vertex boundary segmentation:

[0021] Define the vertex splitting function S(i):

[0022] S(i) = |{ (i',j) ∈ N | i' ≤ i}|

[0023] Where N represents the set of vertex pairs with non-zero weights, and i represents the index of the current vertex;

[0024] Each element is a tuple (i′, j), where i′ is the “row / vertex index” and j is the “column / adjacent vertex index”.

[0025] The result of S(i) is stored in a vertex splitting array vertSplit_Array:

[0026] vertSplit_Array = [S(0), S(1), ..., S(V - 1), S(V)]

[0027] Where V represents the total number of vertices, which is the maximum value of row / vertex index + 1;

[0028] (2.4) Joint index mapping: Store the joint indices corresponding to all non-zero weight values ​​in the joint index array "infMap_Array" in order to form a mapping relationship between non-zero weight values ​​and joint indices;

[0029] The three arrays mentioned above fully represent the core information of the skinning weight data from the numerical dimension (weightsNonZero_Array), the structural dimension (vertSplit_Array), and the correlation dimension (infMap_Array), respectively, forming an organically complementary synergistic mechanism; among them, the vertex segmentation array vertSplit_Array, which is based on the vertex boundary segmentation algorithm, occupies a core innovative position.

[0030] Thus, compared with existing compression algorithms that use a single array or standard sparse matrix format, the triple array collaborative mechanism proposed in this invention can fully utilize the natural sparsity, joint-weight correlation, and structured distribution of the skin weight data to achieve higher compression efficiency and more efficient data access performance.

[0031] (2.5) Conversion to multidimensional numerical NumPy arrays: Using the np.array() function of the NumPy library, the three key arrays generated in the previous step are converted from Python list format to NumPy multidimensional array ndarray format. This conversion utilizes NumPy's contiguous memory layout and vectorized computation characteristics to achieve data type unification and efficient numerical operations, laying the foundation for subsequent binary storage.

[0032] (2.6) Data storage optimization: Use the savez function of NumPy library to compress and store the batch-generated skin weight data in npz format.

[0033] The data storage in step (3) uses the savez function of the NumPy library to save the converted NumPy array as a compressed .npz format file. The built-in compression mechanism of this format is used to further improve the efficiency of data storage and reading performance.

[0034] Furthermore, the skin weight data from step (5) above is applied to the target model processing steps as follows:

[0035] Existing restoration algorithms require traversing the entire compressed array or performing complex index calculations, which results in high time complexity and cannot meet the requirements of real-time rendering. The vertSplit_Array array generated by the vertex boundary segmentation algorithm can directly locate vertex boundaries (represented in Python code as vertSplit_Array.append(infMap_ChunkCount)), without the need for additional index mapping calculations. The overall restoration time complexity is O(|N|), which is close to the theoretical optimal value.

[0036] The implementation process of the compression algorithm in the NumPy library in Maya 2026 is as follows:

[0037] The steps for acquiring and setting weight data are implemented using Maya's command module: First, the basic attribute parameters of the skinning cluster are set, including envelope values ​​and skinning methods. Then, the weight data range for each vertex is determined by traversing the vertex splitting map array `vertSplit_Array`. For each vertex, the complete weight-joint relationship of the vertex is reconstructed using the non-zero weight value array `weightsNonZero_Array` and the joint index mapping array `infMap_Array`, where the joint index points to a specific position in the joint list. Finally, the `skinPercent` command interface of Maya software is called to apply the reconstructed weight data to the corresponding geometric vertex, achieving accurate restoration of the skinning cluster binding. This setting process fully utilizes the efficient access characteristics of NumPy arrays, ensuring that the weight data of large-scale 3D models can be reconstructed and applied quickly and accurately.

[0038] The beneficial effects of this invention are:

[0039] 1. Significantly improves storage efficiency: Through compression algorithms, only non-zero weight values ​​and corresponding joint indexes are retained, achieving a compression rate of up to 98% and reducing file size by approximately 40 times (e.g., from 119 MB JSON format to 2.7 MB .npz format). This solves the problem of wasted storage space in traditional methods and is especially suitable for large 3D models and high joint count scenarios, significantly reducing disk usage and transmission costs.

[0040] 2. Significantly improved read and write speeds: Write speed is increased by approximately 5 times (from 18.38 seconds to 3.03 seconds), and read speed is increased by approximately 1700 times (from 492 seconds to 0.28 seconds). This overcomes the inefficiency of JSON text storage and the complexity of C++ processing, enabling fast data processing, which is particularly suitable for animation production and real-time rendering needs, thus improving work efficiency.

[0041] 3. Supports high-precision and high-complexity models: It is compatible with high-precision models and high-joint-count scenes (e.g., models with 100 joints and 20k vertices), and supports model animation and skeletal transformations, ensuring accurate weight data restoration. This overcomes the limitations of traditional UV graph storage on complex models and avoids weight mapping errors.

[0042] 4. Enhanced compatibility and platform adaptability: Based on the Maya platform, it uses commands such as cmds.skinPercent and the NumPy library, is compatible with Python scripts and the OpenMaya API, and requires no external dependencies; it is suitable for 3D animation, game development and other fields, provides dual optimization (storage and speed), and is compatible with versions such as Maya 2026.

[0043] 5. Overall performance optimization: By storing data in binary format (.npz), efficient compression and decompression are achieved, ensuring data integrity and restoration while reducing CPU resource consumption. This provides an efficient and reliable solution for 3D content creation, driving technological progress in the industry.

[0044] This invention utilizes a compression method based on three key arrays to fully leverage the sparsity of 3D model skinning weight data, achieving a compression rate of up to 98% and a several-fold increase in data processing speed while maintaining data integrity. The method employs the NumPy library for binary compression (.npz format), storing only non-zero weight values ​​and their corresponding joint indices, significantly reducing file size and improving read / write speed. Simultaneously, it directly accesses Maya's underlying data via the OpenMaya API, avoiding the performance bottlenecks of traditional Maya commands. It also supports direct execution of Python scripts without compilation, exhibiting excellent scalability and cross-platform compatibility.

[0045] Its beneficial effects include:

[0046] - File size reduced by approximately 40 times;

[0047] - Save speed is increased by approximately 5 times;

[0048] - Loading speed increased by more than 1700 times;

[0049] - Supports models with high vertex and joint counts;

[0050] - Supports modular design and team collaboration;

[0051] - No compilation required, easy to deploy and maintain. Attached Figure Description

[0052] Figure 1 This is a flowchart of the method steps of the present invention;

[0053] Figure 2 This is a flowchart of the compression process in a specific implementation method;

[0054] Figure 3 This is a flowchart of the vertex boundary segmentation process based on the basic sparsity theory in a specific implementation;

[0055] Figure 4 This is a flowchart of the data storage stage in a specific implementation method;

[0056] Figure 5 This is a flowchart of the data loading and restoration phase in a specific implementation method. Detailed Implementation

[0057] Unless otherwise specified, the software and platforms used in the following embodiments are all conventional software and platforms.

[0058] Example 1

[0059] In view of the current state of the technology, this invention provides a method for efficient compression and fast reading / writing of skinning weight data based on sparsity theory for animation production, applicable to the Autodesk Maya platform, such as... Figure 1 As shown, the specific steps include the following:

[0060] (1) Use the cmds.skinPercent command to iterate through each vertex of the 3D model and obtain the skin weight data of the joints affected by each vertex;

[0061] (2) Based on the sparsity theory, the skin weight data is compressed, and only non-zero weight values ​​and joint indices corresponding to non-zero weight values ​​are retained;

[0062] (3) Store the compressed data to the disk in binary format;

[0063] (4) Read the stored data in binary format from the disk and decompress it;

[0064] (5) Apply the decompressed skin weight data to the target model.

[0065] Furthermore, the compression process in step (2) above is as follows: Figure 2 As shown:

[0066] (2.1) Preparation for weight data extraction and compression: Store the skinning weight data of all vertices in order into a one-dimensional weight array "weights_Array";

[0067] (2.2) Non-zero weight filtering: Iterate through each skin weight data in "weights_Array", store the non-zero weight values ​​in "weightsNonZero_Array", and record the joint index corresponding to the non-zero weight value;

[0068] To address the sparsity of 3D model skinning weight data, the `compress_weightData` method is called to compress the non-zero weight values ​​in the Python list, generating three key arrays: a non-zero weight value array `weightsNonZero_Array`, a joint index array `infMap_Array`, and a vertex splitting map array `vertSplit_Array()`. The complementary storage of these three arrays achieves efficient compression and complete reconstruction of the original weight data.

[0069] (2.3) Vertex boundary marker: During the traversal, the SkinPercent command in the maya.cmds module is called to record the position of the current non-zero weight value in "weightsNonZero_Array" and store it as the vertex boundary marker in the vertex split array "vertSplit_Array";

[0070] Furthermore, the processing method for storing the vertex splitting array vertSplit_Array in step (2.3) above is as follows: Figure 3 As shown:

[0071] Vertex boundary segmentation:

[0072] Define the vertex splitting function S(i):

[0073] S(i) = |{ (i',j) ∈ N | i' ≤ i}|

[0074] Where N represents the set of vertex pairs with non-zero weights, and i represents the index of the current vertex;

[0075] Each element is a tuple (i′, j), where i′ is the “row / vertex index” and j is the “column / adjacent vertex index”.

[0076] The result of S(i) is stored in a vertex splitting array vertSplit_Array:

[0077] vertSplit_Array = [S(0), S(1), ..., S(V - 1), S(V)]

[0078] Where V represents the total number of vertices, which is the maximum value of row / vertex index + 1;

[0079] Existing compression algorithms typically use a single array or standard sparse matrix format, which cannot fully utilize the special structural characteristics of skinned weight data. This invention uses three arrays to store information of different dimensions, forming a complementary relationship, and achieves lossless data restoration.

[0080] (2.4) Joint index mapping: Store the joint indices corresponding to all non-zero weight values ​​in the joint index array "infMap_Array" in order to form a mapping relationship between non-zero weight values ​​and joint indices;

[0081] The three arrays mentioned above fully represent the core information of the skinning weight data from the numerical dimension (weightsNonZero_Array), the structural dimension (vertSplit_Array), and the correlation dimension (infMap_Array), respectively, forming an organically complementary synergistic mechanism; among them, the vertex segmentation array vertSplit_Array, which is based on the vertex boundary segmentation algorithm, occupies a core innovative position.

[0082] Thus, compared with existing compression algorithms that use a single array or standard sparse matrix format, the triple array collaborative mechanism proposed in this invention can fully utilize the natural sparsity, joint-weight correlation, and structured distribution of the skin weight data to achieve higher compression efficiency and more efficient data access performance.

[0083] (2.5) Convert to multidimensional numerical NumPy array: Using the np.array() function of the NumPy library, the three key arrays generated in the previous step are converted from Python list format to NumPy multidimensional array ndarray format; this conversion utilizes NumPy's contiguous memory layout and vectorized computation characteristics to achieve data type unification and efficient numerical operations, laying the foundation for subsequent binary storage.

[0084] The compression process described above involves traversing the original weight data one by one, saving only non-zero weight values ​​and their corresponding joint indices; after processing all joints of a vertex, the vertex boundary marker is updated, which not only significantly reduces storage space (compression ratio up to 98%), but also preserves complete weight information through index mapping, achieving efficient storage and loading.

[0085] Step (3) uses the `savez` function from the NumPy library to save the converted NumPy array as a compressed `.npz` file. This format's built-in compression mechanism further improves data storage and retrieval performance. Figure 4 As shown.

[0086] In summary, the skinned weighted data compression algorithm formula system based on sparsity theory in this invention includes a sparse weight matrix mathematical model, a non-zero weight selection algorithm, a joint index mapping algorithm, a vertex boundary segmentation algorithm, a compression ratio calculation formula, a data restoration algorithm, an algorithm complexity analysis, a sparsity optimization formula, an adaptive threshold optimization algorithm, and a weight normalization preservation algorithm. The flowchart illustrating the collaboration between these 10 algorithms is shown below. Figure 3 As shown, compared to existing sparse matrix compression formats (COO, CSR, CSC), which cannot efficiently process skinning weight data, the CSR format requires storing an array of row pointers, making it difficult to quickly locate vertex boundaries; the COO format requires sorting and deduplication, resulting in low processing efficiency. The corresponding array used in this invention, vertSplit_Array (vertex splitting map array), is represented in the code as vertSplit_Array = [0, 3, 7, 10,...], directly indicating the starting position of the weight data of the i-th vertex in the compressed array. This way, accessing the weight data of any vertex requires only one array access. Compared to the CSR format, it saves storage space for the column index array.

[0087] The skin weighted data compression algorithm formula system based on sparsity theory in this invention has the following advantages: Mathematical modeling innovation: The skin weight data was abstracted into a sparse matrix, and a complete mathematical model was established; Algorithm theory innovation: A compression algorithm based on sparsity theory is proposed, which has a clear mathematical definition; Innovative performance analysis: Provides complete complexity analysis and compression ratio calculation formulas; Adaptive optimization: A dynamic threshold optimization algorithm is introduced to improve compression efficiency.

[0088] The implementation process of the compression method based on three key arrays in Maya 2026 is as follows:

[0089] The steps for acquiring and setting weight data are implemented through Maya's command module: First, the basic attribute parameters of the skinning cluster (including envelope values, skinning methods, etc.) are set. Then, the vertex splitting map array `vertSplit_Array` is traversed to determine the weight data range for each vertex. For each vertex, the complete weight-joint relationship is reconstructed using the non-zero weight value array `weightsNonZero_Array` and the joint index map array `infMap_Array` (the joint index points to the specific position in the joint list). Finally, Maya's `skinPercent` command interface is called to apply the reconstructed weight data to the corresponding geometric vertices in batches, achieving accurate restoration of skinning cluster binding. This process fully utilizes the efficient access characteristics of NumPy arrays to ensure the rapid and accurate reconstruction and application of weight data for large-scale 3D models. Figure 5 The data loading and restoration phases are as follows: First, the system loads a compressed data package containing three core arrays using the np.load function of the NumPy library, and obtains metadata such as the affected joint array (inf_Array), geometry information, number of vertices, and skin cluster attribute parameters. Then, it iterates through the joint names in inf_Array, checks whether all affected joints exist in the current Maya scene, and automatically creates missing joints. Finally, the reconstructed weight data is applied to the model vertices using the cmds.skinPercent command, while ensuring that the weight data is normalized (summed to 1), and the skin cluster attributes (including envelope value, skinning method, component usage flag, weight normalization, and normal deformation options) are updated in real time.

[0090] The entire restoration process is performed in batches, with progress information output every 1000 vertices processed to ensure processing efficiency and user experience on large-scale models. Once the weight data of all vertices has been successfully applied, the skinning weight data will be fully restored, and the model's deformation behavior will be consistent with the original state.

[0091] The following is a practical example applying the method of this invention: Assume that Maya has 3 joints (A, B, C) and 3 vertices (these 3 vertices actually form a triangular face in space) as shown in Table 1. Vertex 1 only affects joint B, with a weight of 1 (weight range is 0~1); Vertex 2 has the same effect on joints A and B, with a weight of 0.5 for each; Vertex 3 only affects joint C, with a weight of 1.

[0092] Table 1. Comparison of storage principles and byte lengths of the three key arrays.

[0093]

[0094] Table 1 illustrates the storage principles and byte length comparison of the three key arrays. Byte length directly affects the size of the weighted data file: the longer the byte length, the larger the file size and the higher the computational overhead.

[0095] As can be seen from Table 1, in a small-scale scenario with 3 vertices and 3 joints, the total byte length after compression (11) is slightly larger than the native storage (9); however, this phenomenon only exists in extremely small scenarios. When the number of joints increases significantly, the sparsity of the skinning weight data will be fully utilized, and the compression advantage will be amplified dramatically. For example, if a triangle with 3 vertices is bound to 100 joints (as in the Elsa skirt and ribbon animation in Frozen, where the triangle serves as the key control point for the fabric, and 100 joints form a virtual skeletal mesh, achieving natural wrinkles and stretching through IK constraints and weight-driven methods to avoid clipping issues), then:

[0096] The native Maya storage weight value = 100 (number of joints) * 3 (number of vertices) = 300 bytes.

[0097] The compression algorithm of this invention uses three arrays for collaborative storage, with a total number of bytes of only about 3-5 (because the default maximum number of influences of Maya skin cluster nodes is 5, that is, each vertex is affected by a maximum of 5 joints, and the amount of non-zero weight data is extremely small).

[0098] At this point, the more vertices (and the more detailed) the polyhedron, and the more joints it has, the more pronounced the difference will be. Suppose an object has 200,000 vertices and 100 joints (like the Na'vi in ​​the Avatar series; the 200,000 vertices correspond to the character's high-precision skin / muscle model (including details like pores and wrinkles), and the 100 joints form a standard human skeleton (15 for the spine, 40 for the limbs, 10 for the thoracic / pelvic bones, 15 for the neck / head, and 20 for the fingers). Through smooth skinning and weight gradient allocation, it achieves muscle stretching when running, joint compression when punching, or skin collapse and deformation when injured, balancing detail and animation efficiency). Then:

[0099] Native Maya storage weight value = 100 (number of joints) * 200,000 (number of vertices) = 20 million bytes

[0100] The compression algorithm of this invention uses three arrays for storage, with a total number of bytes of only about 200,000 to 1 million (depending on the number of joints affected by the vertex, since it is impossible for a vertex to be affected by all joints, there are a large number of zero values), and the compression rate is 1% to 5% of the original JSON file.

[0101] This invention achieves efficient compression through the collaborative work of three key arrays: `weightsNonZero_Array` stores only non-zero weight values, directly eliminating a large amount of zero-value data; `infMap_Array` records the joint index corresponding to each non-zero weight, ensuring the correct mapping between weights and influencers; and `vertSplit_Array` serves as the vertex splitting array, marking the starting position of each vertex in `infMap_Array`, achieving precise location of vertex boundaries. The algorithm employs a block processing strategy, immediately merging data and resetting the counter after traversing all the influence joints of a vertex, saving memory while ensuring data integrity. Through this mechanism, the original 119MB of JSON-formatted weight data is compressed to only 2.7MB, achieving a compression ratio of approximately 44:1. Simultaneously, the read / write speed is improved from 18.38 + 492 seconds to 3.03 + 0.28 seconds, achieving dual optimization of storage space and processing efficiency. This is the core technological breakthrough of this invention compared to traditional methods.

[0102] In practical applications, using the method of this invention to process a skin cluster with 50 joints: the total time from data acquisition to saving to disk is approximately 3 seconds, and the total time from reading the .npz file to setting the weight data is approximately 0.28 seconds (specific values ​​vary depending on computer configuration). Compared with the traditional data processing process of native Maya paths, the results are shown in Table 2:

[0103] Table 2 Performance Test Comparison

[0104]

[0105] The embodiments of the present invention are not limited to the examples described above. Under the premise of the basic technical concept of the present invention, those skilled in the art can make various modifications, substitutions or changes to the content of the present invention through ordinary technical knowledge and conventional means, and all of these fall within the scope of protection of the present invention.

Claims

1. A method for efficient compression and fast read / write of skinning weight data based on sparsity theory for animation production, characterized in that... Includes the following steps: (1) Use the cmds.skinPercent command to iterate through each vertex of the 3D model and obtain the skin weight data of the joints affected by each vertex; (2) The skin weight data is compressed, and only non-zero weight values ​​and joint indices corresponding to non-zero weight values ​​are retained; (3) Store the compressed data to the disk in binary format; (4) Read the stored data in binary format from the disk and decompress it; (5) Apply the decompressed skin weight data to the target model.

2. The method for efficient compression and fast reading / writing of skinning weight data based on sparsity theory for animation production as described in claim 1, characterized in that: The compression process in step (2) is as follows: (2.1) Preparation for weight data extraction and compression: Store the skinning weight data of all vertices in order into a one-dimensional weight array "weights_Array"; (2.2) Non-zero weight filtering: Iterate through each skin weight data in "weights_Array", store the non-zero weight values ​​in "weightsNonZero_Array", and record the joint index corresponding to the non-zero weight value; (2.3) Vertex boundary marker: During the traversal, the SkinPercent command in the maya.cmds module is called to complete the weight processing of all joints of each vertex, record the position of the current non-zero weight value in "weightsNonZero_Array", and store it as the vertex boundary marker in the vertex split array "vertSplit_Array"; (2.4) Joint index mapping: Store the joint indices corresponding to all non-zero weight values ​​in the joint index array "infMap_Array" in order to form a mapping relationship between non-zero weight values ​​and joint indices; (2.5) Convert to multidimensional numerical NumPy array: Use the np.array() function of the NumPy library to convert the three key arrays generated in the previous step from Python list format to NumPy multidimensional array ndarray format.

3. The method for efficient compression and fast reading / writing of skinning weight data based on sparsity theory for animation production as described in claim 2, characterized in that: The process of storing the vertex splitting array vertSplit_Array in step (2.3) is as follows: Vertex boundary segmentation: Define the vertex splitting function S(i): S(i) = |{ (i',j) ∈ N | i' ≤ i}| Where N represents the set of vertex pairs with non-zero weights, and i represents the index of the current vertex; Each element is a tuple (i′, j), where i′ is the "row / vertex index" and j is the "column / adjacent vertex index"; The result of S(i) is stored in a vertex splitting array vertSplit_Array: vertSplit_Array = [S(0), S(1), ..., S(V - 1), S(V)] Where V represents the total number of vertices, which is the maximum value of row / vertex index + 1.

4. The efficient compression and fast read / write method for skinning weight data based on sparsity theory for animation production according to any one of claims 1-3, characterized in that: The data storage in step (3) uses the savez function of the NumPy library to save the converted NumPy array as a compressed .npz format file.

Images