A Method for Constructing a Clothing Simulation Dataset Based on Marvelous Designer and Blender

Abstract

The application provides a garment simulation dataset construction method based on Marvelous Designer and Blender, and relates to the cross technical field of computer vision and natural language processing. The action sequence is preprocessed, a standard posture and action are spliced by using a Blender script to provide a suitable action for Marvelous Designer simulation; then two automatic parallel pipelines are divided: one imports the preprocessed action and corresponding clothes into Marvelous Designer, performs object calculation, and exports a sequence file of clothes vertex data with consistent topology according to frames; the other imports the action into Blender, extracts and exports corresponding human body skeleton matrix data of each frame; the skeleton matrix and the clothes vertex information are aligned according to frames, and are summarized and packed into a JSON serialized dataset.

Description

Technical Field

[0001] This invention relates to the interdisciplinary field of computer vision and natural language processing, and in particular to a method for constructing a clothing simulation dataset based on Marvelous Designer and Blender. Background Technology

[0002] In applications such as 3D digital humans, virtual try-on, and metaverse, the realism of clothing dynamic simulation is crucial. While traditional physics-based simulation methods can generate realistic wrinkles, their computational costs are extremely high, making them unsuitable for real-time interaction. Therefore, "neural fabric animation" technology, which uses deep neural networks to predict fabric deformation, has become a cutting-edge research area.

[0003] However, the performance of deep learning models is highly dependent on large-scale, high-quality training datasets. Currently, automating the construction of such datasets faces several technical obstacles: First, initial pose conflicts can easily cause physics engine crashes. Clothing models are typically designed in static poses, while the first frame of the acquired action sequences has varying poses; forcibly loading these can cause severe mesh interleaving and "mesh explosion." Second, the mesh topology is unstable. To improve simulation details, physics engines often dynamically add or remove mesh vertices, resulting in inconsistent data dimensions for each frame, making it unsuitable for direct neural network training. Third, feature extraction and alignment are difficult. How to automatically extract compact human motion features and accurately align them with clothing deformation data is a key missing link in the automation pipeline. Fourth, large-scale production capabilities are lacking. Traditional manual operation methods are extremely inefficient and cannot meet the needs of generating massive amounts of samples. Summary of the Invention

[0004] To completely fill the current technological gap in the field of automated construction of 3D clothing dynamic datasets and break the long-standing absolute reliance on manual heuristic operations, this invention proposes a method for constructing clothing simulation datasets based on Marvelous Designer and Blender. This method completely breaks through the bottleneck of large-scale mass production of 3D clothing datasets through an innovative nonlinear animation fusion buffer mechanism, strict underlying topology parameter locking technology, and a fully automated script-driven engine, achieving high-quality, high-efficiency, and highly consistent automated data production.

[0005] The technical solution of the present invention is as follows:

[0006] A method for constructing a clothing simulation dataset based on Marvelous Designer and Blender includes the following steps:

[0007] Step 1: Obtain basic data and construct a buffered set of action sequences;

[0008] First, collect and organize a set of the first number of character action sequences and a set of the second number of 3D clothing models;

[0009] The character motion sequence set includes walking, running, and jumping motion files from a publicly available motion capture database; the 3D clothing model set contains clothing model files of different styles; the 3D clothing model is in the A-Pose standard initial pose by default.

[0010] Step 1.1: Construct the intelligent motion reconstruction logic in the 3D software Blender environment;

[0011] Specifically, before processing any new action sequence, a deep cleanup mechanism is initiated: delve into the underlying data structure, recursively traverse and forcibly clear all remaining object sets, grid caches, skeleton data and critical action data blocks in memory;

[0012] Step 1.2: Introduce non-linear animation technology (NLA) for intelligent pose grafting;

[0013] Specifically, the process is as follows: First, a skeleton with a standardized static pose is imported as a reference and used as the underlying base track in the non-linear animation system. Then, the original dynamic target motion sequence is loaded and used as an independent segment on the target track above. A pre-set duration of blank offset is introduced at the beginning of the target track segment, and the smooth blending property is activated. Using the interpolation algorithm at the bottom layer of the 3D software Blender, the intermediate transition state of the human skeleton from a static safe pose to the first frame of the original motion is automatically calculated within a pre-set buffer time period. Specifically, the local rotation quaternions and local translation vectors of each node in the human skeleton are extracted at the start and end frames. For translation, linear interpolation is used; for rotation, spherical linear interpolation is used to ensure smooth and uniform rotation and avoid gimbal lock. Finally, the calculated intermediate frame animation is merged with the original motion sequence to export a motion sequence file containing a complete smooth buffer period.

[0014] Step 2: Construct a physics simulation pipeline with forced topology locking; after generating an action sequence file containing a complete smooth buffer period, the physics simulation pipeline automatically drives Marvelous Designer's physics simulation mode to perform the solution task and generate clothing deformation data;

[0015] Specifically, during the initialization phase, the design automatically takes over the cloth mesh generation logic, forcibly sets and locks the global particle spacing parameter to a uniform constant, and globally disables any form of adaptive mesh subdivision, dynamic retopology, and cloth physical tearing functionality throughout the entire physical simulation lifecycle. Furthermore, when exporting simulation results frame by frame, the coordinate system orientation and vertex stitching rules are uniformly defined in Marvelous Designer to ensure that each frame's exported 3D mesh file presents a perfect isotopic state in the data index structure. In Marvelous Designer, the physical simulation is performed by matching the motion sequence file from step 1 with the 3D clothing model set, ultimately obtaining the clothing deformation data from the physical simulation solution.

[0016] Step 3: Construct an automated parsing engine for the skeleton space transformation matrix;

[0017] After calculating the clothing deformation data, human motion input features are simultaneously extracted in the 3D scene using Blender. This is achieved through its provided Python programming interface, which performs the following operations in parallel: Loading the same complete motion sequence file generated in step 1; constructing a timeline iterator and stepping frame by frame; recursively traversing the skeleton tree structure of the human model in each frame to obtain the transformation matrix of each key bone node; and extracting the skeleton space transformation matrix according to the configuration. Specifically, the skeleton space transformation matrix is ​​either a global transformation matrix relative to the world origin or a local transformation matrix relative to the parent bone. The skeleton space transformation matrix encapsulates the rotation, translation, and scaling information of the bones.

[0018] Step 4: Perform large-scale cross-combination and serialized data encapsulation;

[0019] Collect the output results of steps 2 and 3; identify the buffer period inserted in step 1 and remove the invalid data corresponding to the buffer period from the beginning of the sequence. Then, map the clothing vertex data sequence within the remaining valid time period (i.e., the clothing deformation data generated in step 2) and the human pose matrix data sequence (i.e., the skeleton space transformation matrix generated in step 3) one-to-one based on the same timestamp or frame index; for each frame, label the human pose feature vector of that frame as the "input feature" and the clothing vertex coordinate vector of that frame as the "target ground truth." Simultaneously, collect the metadata information of the current combination. Finally, package all the data under a complete "action-clothing" combination and output it as a structured data file containing:

[0020] Metadata block: Describes the attribute information of the dataset samples.

[0021] Action feature block: An array arranged by time frame, where each element is a set of skeleton space transformation matrices for the current frame.

[0022] Clothing Deformation Block: An array arranged by time frames, where each element is a sequence of isotopic clothing vertex data for the current frame.

[0023] Multiple data files together constitute a 3D clothing simulation dataset.

[0024] Secondly, this application proposes a computer-readable storage medium storing executable instructions that, when executed, cause a processor to perform the clothing simulation dataset construction method.

[0025] Thirdly, this application proposes a computer program product, including a computer program or instructions that, when executed by a processor, implement the aforementioned method for constructing a clothing simulation dataset.

[0026] The beneficial effects of adopting the above technical solution are as follows:

[0027] This invention provides a method for constructing a clothing simulation dataset based on Marvelous Designer and Blender. Compared with the previous industry's heuristic workshop process that could only rely on experience, this invention, as the first truly fully automated cross-software collaborative dataset construction solution, demonstrates disruptive technological advantages.

[0028] First, this invention achieves an order-of-magnitude leap in the global convergence stability of differential equation solvers. Based on automated nonlinear preheating using a mechanical buffer domain, the residual convergence curve of the Newton-Raphson iteration stage is significantly smoothed, enabling the system to robustly handle extreme nonlinear boundary conditions with extremely high acceleration and large displacements without human intervention. Extreme actions that previously resulted in near-100% failure under manual operation are successfully transformed into usable data, greatly expanding the state space coverage of the synthetic data.

[0029] Secondly, the pipeline-generated dataset exhibits out-of-the-box high-dimensional tensor perfect alignment. Thanks to the invention's pioneering strict topological isomorphism locking technique, the model-generated 3D tensors possess zero structural noise purity, allowing researchers to directly input them into graph convolutional networks or attention-based 3D architectures for end-to-end backpropagation training. This completely eliminates the overhead of resampling algorithms, which are indispensable and extremely expensive in traditional data preprocessing and prone to geometric distortion.

[0030] Finally, this pipeline achieves high-throughput industrial scaling of generative physics simulation for the first time in the industry. The decentralized, automated parallel scheduling kernel completely eliminates all human interaction latency in the graphical interface, making it possible to explore massive parameter spaces across shapes, materials, and kinematic modes. Dataset production efficiency has been dramatically reduced from the traditional manual monthly level to the fully automated, unattended machine hour level, filling the absolute gap in the field of neural cloth animation lacking large-scale industrial data generation tools and providing massive prior data support for generative AI models driving the next generation of physical perception. Attached Figure Description

[0031] Figure 1 This invention provides an overall main flowchart of a method for constructing a clothing simulation dataset based on Marvelous Designer and Blender, as shown in the embodiments of the present invention.

[0032] Figure 2 This is a sub-flowchart of the non-linear animation preprocessing stage for the target character's movements in an embodiment of the present invention;

[0033] Figure 3 This is a flowchart of the parallel collaborative operation of two automated pipelines in an embodiment of the present invention;

[0034] Figure 4 This is a display of the serialized dataset results and hierarchical organizational structure diagram of the final output of this embodiment of the invention;

[0035] (a) is a schematic diagram of the global hierarchical structure of the dataset JSON file, and (b) is a schematic diagram of the internal data structure of a single sequence sample's JSON file. Detailed Implementation

[0036] The specific implementation methods of this application will be further described in detail below with reference to the accompanying drawings and embodiments.

[0037] Example 1:

[0038] A method for constructing a clothing simulation dataset based on Marvelous Designer and Blender, such as Figure 1 As shown, it includes the following steps:

[0039] Step 1: Obtain basic data and construct a buffered set of action sequences;

[0040] First, collect and organize a set of the first number of character action sequences and a set of the second number of 3D clothing models;

[0041] The character motion sequence set includes walking, running, and jumping motion files from a publicly available motion capture database; the 3D clothing model set includes clothing model files of different styles such as dresses, shirts, and pants; the 3D clothing model is in the A-Pose standard initial pose by default.

[0042] Step 1.1: In order to completely solve the physical explosion problem caused by initial posture conflict, this invention constructs intelligent motion reconstruction logic in the 3D software Blender environment;

[0043] Specifically, before processing any new action sequence, an extremely rigorous deep cleanup mechanism is initiated: delving into the underlying data structure, recursively traversing and forcibly clearing all remaining object sets, grid caches, skeleton data, and crucial action data blocks in memory. This initialization strategy fundamentally eliminates task interruptions caused by data block naming conflicts during continuous batch processing.

[0044] Step 1.2: Introduce non-linear animation technology (NLA) for intelligent pose grafting;

[0045] Specifically, the process involves: first, importing a skeleton with a standardized static pose as a reference, and then using it as the underlying base track in the non-linear animation system; next, loading the original dynamic target motion sequence and pushing it as an independent segment into the target track above; the innovation of this invention lies in introducing a pre-set duration of blank offset at the beginning of the target track segment and activating the smooth blending attribute (Blend In); using the interpolation algorithm at the bottom layer of the 3D software Blender within a pre-set buffer time period, automatically calculating the intermediate transition state of the human skeleton from a static safe pose to the first frame of the original motion in a natural and smooth manner; specifically, extracting the local rotation quaternions and local translation vectors of each node in the human skeleton at the start and end frames. For translation attributes, linear interpolation is used; for rotation attributes, spherical linear interpolation is used to ensure the smoothness and uniformity of the rotation process and avoid gimbal lock; finally, merging the calculated intermediate frame animation with the original motion sequence to export an motion sequence file containing a complete smooth buffer period;

[0046] Step 2: Construct a physics simulation pipeline with forced topology locking; After generating an action sequence file containing a complete smooth buffer period, the physics simulation pipeline automatically drives Marvelous Designer's physics simulation mode to perform high-intensity solution tasks and generate clothing deformation data;

[0047] To meet the stringent requirements of deep learning for fixed tensor dimensions, this invention implements an extremely strict "forced topology locking" mechanism on the underlying runtime environment of the physics simulation pipeline through external commands. Specifically, during the initialization phase, the logic for automatically taking over the generation of the cloth mesh is designed, forcibly setting and locking the global particle spacing parameter to a uniform constant, and globally disabling any form of adaptive mesh subdivision, dynamic retopology, and cloth physical tearing functions throughout the entire lifecycle of the physics simulation. Furthermore, when exporting simulation results frame by frame, the coordinate system orientation and vertex stitching rules are uniformly defined in Marvelous Designer to ensure that the 3D mesh file exported in each frame presents a perfect isotopic state in the data index structure. In Marvelous Designer, the physical simulation is performed by matching the action sequence file from step 1 with the 3D clothing model set, ultimately obtaining the clothing deformation data from the physical simulation solution.

[0048] Step 3: Construct an automated parsing engine for the skeleton space transformation matrix;

[0049] After calculating the clothing deformation data, the human motion input features for training the deep learning model simulating clothing fabric are simultaneously extracted in the 3D scene Blender. Using its provided Python programming interface, the following operations are performed in parallel: The same complete motion sequence file generated in step 1 is loaded; a timeline iterator is constructed and iterates frame by frame. In each frame, the skeleton tree structure of the human model is recursively traversed to obtain the transformation matrix of each key bone node (such as the pelvis, spine, and limb joints). Based on the configuration, the skeleton space transformation matrix is ​​extracted; specifically, the skeleton space transformation matrix is ​​a global transformation matrix relative to the world origin, or a local transformation matrix relative to the parent bone. The 4x4 skeleton space transformation matrix highly concisely encapsulates the rotation, translation, and scaling information of the bones, perfectly avoiding the gimbal lock problem that may be caused by traditional Euler angles. Through this structured feature extraction, human motion is accurately encoded into a series of high-density mathematical feature vectors.

[0050] Step 4: Perform large-scale cross-combination and serialized data encapsulation;

[0051] The final step of this invention is to achieve truly unmanned mass production. The main control program collects the output results of steps 2 and 3; identifies the buffer period inserted in step 1, and removes the invalid data corresponding to the buffer period from the beginning of the sequence. Then, the clothing vertex data sequence within the remaining valid time period, i.e., the clothing deformation data generated in step 2, and the human posture matrix data sequence, i.e., the skeleton space transformation matrix generated in step 3, are mapped one-to-one based on the same timestamp or frame index. For each frame, the human posture feature vector of that frame is marked as the "input feature," and the clothing vertex coordinate vector of that frame is marked as the "target ground truth." Simultaneously, metadata information for the current combination is collected, such as the person's gender, clothing style, and fabric physical parameters. Finally, all data under a complete "action-clothing" combination is packaged and output as a structured data file, such as a JSON file. This JSON file contains:

[0052] Metadata block: Describes the attribute information of the dataset samples.

[0053] Action feature block: An array arranged by time frame, where each element is a set of skeleton space transformation matrices for the current frame.

[0054] Clothing Deformation Block: An array arranged by time frames, where each element is a sequence of isotopic clothing vertex data for the current frame.

[0055] Multiple data files together form a large-scale 3D clothing simulation dataset that can be directly used to train neural networks.

[0056] Example 2:

[0057] The inventiveness of this invention is primarily anchored in the industry's first implementation of the following programmatic innovation in underlying architecture.

[0058] First, it fills a gap in the industry with an automated mechanism for nonlinear kinematic buffering based on spherical linear interpolation. This invention completely abandons the traditional empirical paradigm that heavily relies on manual posterior alignment. It pioneeringly uses the quaternion interpolation mathematical logic at the bottom layer of 3D software to automatically construct a transition integration domain that conforms to the physical dynamics relaxation conditions between the initial boundary and the highly dynamic nonlinear manifold. This buffer domain acts as a numerical pressure relief valve, fundamentally solving the implicit integrator divergence and system collapse caused by extreme local spatial compression during the initialization phase of multi-rigid-body collisions through pure algorithmic logic.

[0059] Secondly, it pioneers a graph isomorphism locking paradigm under strong constraints. This invention, for the first time, forcibly intervenes in and takes over the mesh generation operator at the underlying level of the physics engine through bypass injection, maintaining absolute consistency of the mesh graph during drastic hyperelastic deformation simulations. This topology freezing technique overturns the inefficient traditional "solve first, register later" process, completely circumventing the most challenging problem in 3D geometry processing—non-rigid cross-domain mesh registration—and directly achieving zero-loss isomorphic tensor output at the source.

[0060] Furthermore, this invention employs a fully automated, compact dimensionality reduction feature parsing method based on spatial transformation group representation. Breaking away from the traditional point-by-point coordinate regression manual acquisition strategy, this invention rigorously formalizes action conditions into hierarchical homogeneous spatial transformation matrices, achieving a highly abstract representation of high-dimensional action manifolds with minimal information entropy cost, and providing an absolutely standard tensor interface for subsequent neural network reading.

[0061] I. Overall System Architecture and Main Process (see...) Figure 1 ):

[0062] like Figure 1 As shown, the automated dataset construction system provided by this invention is mainly divided into four highly coupled core modules: an action library cleaning and preprocessing module, a physics engine strong constraint module, a pose feature tensor parsing module, and a endpoint data alignment and packaging module. The system's main control script is responsible for scheduling the external Blender software environment and Marvelous Designer engine environment. When a cross-combined mass production task instruction is received, the main control script automatically sends the specified action file into the preprocessing environment, and then distributes it to the physics pipeline and parsing pipeline for dual-thread asynchronous or synchronous processing. Finally, the tensor assembly is completed at the data aggregation end.

[0063] II. Hybrid Workflow of Intelligent Deep Cleaning and Non-linear Animation (see...) Figure 2 ):

[0064] In automated pipelines that continuously process massive amounts of files, even the smallest amount of memory-resident data can cause the task to crash. For example... Figure 2 The preprocessing flow shown in the script first performs extreme environmental purification before each preprocessing task is started.

[0065] Specifically, the script forces entry into object mode, clearing all visible objects in the current viewport. More importantly, the script calls the underlying data collection interface of the 3D software to perform a deep cleanup loop. The program iterates through and forcibly removes all remaining collection categories, residual mesh data blocks, and isolated skeleton entity data. Especially for animation processing, the script specifically iterates through and physically deletes all action data blocks. This thorough cleanup ensures that subsequently imported models and animation tracks receive the purest initialization environment, avoiding track reference errors caused by naming conflicts.

[0066] After cleanup, the system introduces non-linear animation (NLA) technology. The script loads a reference file with standardized static poses, pushes the initial state of its core skeleton object into the underlying non-linear animation track as a reference base layer. Next, it loads the target motion file containing complex motion trajectories, converts it into animation clips, and places them in a newly created target animation track.

[0067] To allow the physics engine time to react, the script forcibly shifts the starting keyframes of the motion in the upper target track backward by a preset buffer duration and activates the blend-in parameter for that segment. Driven by internal mathematical interpolation, the software automatically calculates the static pose of the lower base track and the starting pose of the upper target track frame by frame, generating smooth and natural intermediate transition states.

[0068] Finally, when calling the FBX export interface, the script sets specific baking parameters. The script is precisely configured to bake the effects of all non-linear animation tracks with NLA Strips, while filtering out the leaf bones that are used for auxiliary display, in order to export a perfect new motion sequence that includes buffer transitions.

[0069] III. Topology-locked simulation and parallel feature analysis process (see...) Figure 3 ):

[0070] like Figure 3 As shown, after preprocessing, the files are simultaneously fed into two parallel automated pipelines.

[0071] In the physics simulation pipeline, to ensure that the exported 3D model file can be mapped to a high-dimensional tensor of fixed size, the script completely takes over the engine's default behavior logic. After loading the pre-stitched garment project, the script examines all plate properties, locks the particle spacing parameter controlling mesh density to a fixed threshold, and sends explicit instructions to the physics engine to globally disable adaptive mesh subdivision and dynamic retopology algorithms. Simultaneously, it disables the physical tearing property of the fabric material. Under these strong constraints, the garment's 3D mesh structure is completely "frozen," achieving perpetual topological consistency over time. To balance visual quality and anti-mold-breaking mechanisms, the script automatically adjusts the solution accuracy, multiplying the number of collision detection substeps, providing a physical guarantee for subsequently producing high-purity deformation ground truth values.

[0072] In the parallel feature parsing pipeline, the system no longer focuses on the cluttered vertices of the human body surface, but instead constructs a dedicated traversal iterator for the skeletal system. At a specific frame, the iterator delves into the skeletal level, sequentially extracting the spatial transformation matrix of each key skeletal node involved in driving human deformation. This multidimensional feature matrix contains rich information about the rotational orientation, spatial scaling ratio, and relative displacement of that part. Because it uses matrices as the carrier, it naturally possesses the convenience of cross-coordinate system transformation, making it an excellent way to encode actions into high-density feature vectors.

[0073] IV. Large-scale production scheduling and dataset result encapsulation (see...) Figure 4 ):

[0074] To achieve industrial-grade mass production, the main control program takes over all processes and uses cross-traversal logic to enable different actions to be automatically matched and combined with different garments, executing all the preprocessing, calculation and feature extraction processes mentioned above.

[0075] like Figure 4 The diagram illustrates the final data results and organization logic generated by this invention. (a) shows the global hierarchical structure of the dataset JSON file, including a basic information layer (metadata, physical material parameters, global mesh topology), an output target layer (deformation ground truth time series array), and an input feature layer (action time series feature array). (b) is an example of the internal data structure of a single sequence sample's JSON file, demonstrating the storage methods for sequence identifiers, metadata, mesh topology (triangle face vertex indices), and mesh vertex coordinates and bone poses in multi-frame data. After feature extraction, the system must remove the redundant transition buffer data that we artificially added in the first stage for physical stability. The script maintains a timestamp offset marker to precisely locate the critical frame where the buffer period ends and the original action officially begins. From this critical frame, the system maps and pairs the extracted effective spatial transformation matrix sequence with the previously exported isotopological clothing vertex coordinate sequence from the physics engine on the time axis.

[0076] The final encapsulated serialized file (such as JSON format) exhibits a highly standardized hierarchical structure:

[0077] The top-level basic information layer (Metadata Block) retains the global universal identifier of the sample, and contains a dictionary of physical material parameters that guide the deformation law of the fabric and a global mesh topology connection index tree of the clothing.

[0078] The downward-facing input feature block stores an array of all skeletal spatial transformation matrices that serve as conditional inputs to the network, frame by frame.

[0079] The corresponding output target layer (Ground Truth Block) stores the three-dimensional vertex coordinate tensor arrays that serve as the network's fitting target frame by frame.

[0080] This integrated and structured final result encapsulation specification allows researchers to directly initiate the end-to-end model training process using extremely concise data loader code, regardless of the deep learning training framework used in the backend. This marks the entry of 3D clothing animation dataset construction technology into a fully mature industrial era.

[0081] Example 3:

[0082] This embodiment proposes a computer-readable storage medium that stores executable instructions. When these instructions are executed, if they are implemented as software functional units and sold or used as independent products, they can be stored in a computer-readable storage medium.

[0083] The computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the clothing simulation dataset construction method described in the various embodiments of this application.

[0084] The aforementioned storage media include: flash memory, hard disk, multimedia card, card-type memory (e.g., SD (Secure Digital Memory Card) or DX (Memory Data Register, MDR) memory, random access memory (RAM), static random access memory (SRAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), programmable read-only memory (PROM), magnetic storage, disk, optical disk, server, APP (Application) application store, and other media capable of storing program verification codes, on which computer programs are stored. When the computer programs are executed by a processor, they can implement the various steps of the clothing simulation dataset construction method described above.

[0085] Example 4:

[0086] This embodiment proposes a computer program product, including a computer program or instructions, which, when executed by a processor, implements the aforementioned method for constructing a clothing simulation dataset.

[0087] Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or part of the technical solution, can be embodied in the form of a computer program product.

[0088] The various embodiments in this application are described in a progressive manner. The same or similar parts between the various embodiments can be referred to each other. Each embodiment focuses on describing the differences from other embodiments.

[0089] The scope of protection of this application is not limited to the embodiments described above. Obviously, those skilled in the art can make various modifications and variations to this disclosure without departing from the scope and spirit of this disclosure. If such modifications and variations fall within the scope of the methods disclosed herein and their equivalents, then the intent of this disclosure also includes such modifications and variations.

Claims

1. A method for constructing a clothing simulation dataset based on Marvelous Designer and Blender, characterized in that, Includes the following steps: Step 1: Obtain basic data and construct a buffered set of action sequences; Collect and organize the first set of character action sequences and the second set of 3D clothing models; The character motion sequence set includes walking, running, and jumping motion files from a publicly available motion capture database; the 3D clothing model set contains clothing model files of different styles; the 3D clothing model is in the A-Pose standard initial pose by default. Step 2: Construct a physics simulation pipeline with forced topology locking; after generating an action sequence file containing a complete smooth buffer period, the physics simulation pipeline automatically drives Marvelous Designer's physics simulation mode to perform the solution task and generate clothing deformation data; Step 3: Construct an automated parsing engine for the skeleton space transformation matrix; Step 4: Perform large-scale cross-combination and serialized data encapsulation.

2. The method for constructing a clothing simulation dataset based on Marvelous Designer and Blender according to claim 1, characterized in that, Step 1 includes the following steps: Step 1.1: Construct the intelligent motion reconstruction logic in the 3D software Blender environment; Specifically, before processing any new action sequence, a deep cleanup mechanism is initiated: delve into the underlying data structure, recursively traverse and forcibly clear all remaining object sets, grid caches, skeleton data and critical action data blocks in memory; Step 1.2: Introduce non-linear animation technology (NLA) for intelligent pose grafting; Specifically, the process is as follows: First, a skeleton with a standardized static pose is imported as a reference and used as the underlying base track in the non-linear animation system. Then, the original dynamic target motion sequence is loaded and used as an independent segment in the target track above. A pre-set duration of blank offset is introduced at the beginning of the target track segment, and the smooth blending property is activated. Using the interpolation algorithm at the bottom layer of the 3D software Blender, the intermediate transition state of the human skeleton from a static safe pose to the first frame of the original motion is automatically calculated within a pre-set buffer time period. Specifically, the local rotation quaternions and local translation vectors of each node in the human skeleton are extracted in the start and end frames. For translation attributes, linear interpolation is used; for rotation attributes, spherical linear interpolation is used to ensure smooth and uniform rotation and avoid gimbal lock. Finally, the calculated intermediate frame animation is merged with the original motion sequence to export a motion sequence file containing a complete smooth buffer period.

3. The method for constructing a clothing simulation dataset based on Marvelous Designer and Blender according to claim 2, characterized in that, Step 2 specifically involves: during the initialization phase of the calculation, designing an automatic takeover logic for generating the cloth mesh, forcibly setting and locking the global particle spacing parameter to a uniform constant, and globally disabling any form of adaptive mesh subdivision, dynamic retopology, and cloth physical tearing function throughout the entire lifecycle of the physical simulation; in addition, when exporting simulation results frame by frame, uniformly defining coordinate system orientation and vertex stitching rules in Marvelous Designer to ensure that the 3D mesh file exported in each frame presents a perfect isotopic state in the data index structure; In MarvelousDesigner, physical simulation is performed by matching the motion sequence file from step 1 with the 3D clothing model set, ultimately yielding the clothing deformation data obtained from the physical simulation.

4. The method for constructing a clothing simulation dataset based on Marvelous Designer and Blender according to claim 3, characterized in that, Step 3 specifically involves: after calculating the clothing deformation data, simultaneously extracting human motion input features in the 3D scene Blender; using its provided Python programming interface, performing the following operations in parallel: loading the same complete motion sequence file generated in step 1; constructing a timeline iterator and stepping frame by frame; in each frame, recursively traversing the skeleton tree structure of the human model to obtain the transformation matrix of each key bone node; extracting the skeleton space transformation matrix according to the configuration; the skeleton space transformation matrix is ​​specifically a global transformation matrix relative to the world origin, or a local transformation matrix relative to the parent bone; the skeleton space transformation matrix encapsulates the rotation, translation, and scaling information of the bones.

5. The method for constructing a clothing simulation dataset based on Marvelous Designer and Blender according to claim 4, characterized in that, Step 4 specifically involves: collecting the output results of steps 2 and 3; identifying the buffer period inserted in step 1 and removing the invalid data corresponding to the buffer period from the beginning of the sequence; then, mapping the clothing vertex data sequence within the remaining valid time period, i.e., the clothing deformation data generated in step 2, and the human posture matrix data sequence, i.e., the skeleton space transformation matrix generated in step 3, to the same timestamp or frame index; for each frame, marking the human posture feature vector of that frame as "input feature" and the clothing vertex coordinate vector of that frame as "target ground truth"; simultaneously, collecting the metadata information of the current combination; and finally, packaging all the data under a complete "action-clothing" combination and outputting it as a structured data file.

6. The method for constructing a clothing simulation dataset based on Marvelous Designer and Blender according to claim 5, characterized in that, The structured data file contains: Metadata block: Describes the attribute information of the dataset samples; Action feature block: an array arranged by time frame, where each element is a set of skeleton space transformation matrices for the current frame; Clothing deformation block: an array arranged by time frames, where each element is a sequence of isotopic clothing vertex data for the current frame; Multiple data files together constitute a 3D clothing simulation dataset.

7. A computer-readable storage medium storing executable instructions, characterized in that, When the instruction is executed, it causes the processor to perform the clothing simulation dataset construction method according to any one of claims 1-6.

8. A computer program product, comprising a computer program or instructions, characterized in that, When the computer program or instructions are executed by a processor, they implement the clothing simulation dataset construction method as described in any one of claims 1-6.

Images