 Original Article
 Open Access
 Published:
Collisionaware interactive simulation using graph neural networks
Visual Computing for Industry, Biomedicine, and Art volume 5, Article number: 15 (2022)
Abstract
Deep simulations have gained widespread attention owing to their excellent acceleration performances. However, these methods cannot provide effective collision detection and response strategies. We propose a deep interactive physical simulation framework that can effectively address toolobject collisions. The framework can predict the dynamic information by considering the collision state. In particular, the graph neural network is chosen as the base model, and a collisionaware recursive regression module is introduced to update the network parameters recursively using interpenetration distances calculated from the vertexface and edgeedge tests. Additionally, a novel selfsupervised collision term is introduced to provide a more compact collision response. This study extensively evaluates the proposed method and shows that it effectively reduces interpenetration artifacts while ensuring high simulation efficiency.
Introduction
Many computer graphics applications, such as computer games, movie production, and fashion design, require physical simulation. Traditional numerical calculation methods produce physically accurate and visually excellent results. However, these methods are time consuming. Consequently, they cannot satisfy the performance requirements for interactive applications.
Deep simulation methods have emerged as popular alternatives to traditional numerical calculation methods owing to the rapid development of deep learning techniques. These methods [1,2,3,4] use the ability of neural networks to learn nonlinear functions to propose differentiable models that output deformable objects as functions of the target shape, pose, motion, and other design parameters. However, these methods perform poorly in collision detection and response (CDR), which has a significant impact on visual realism and simulation accuracy. To avoid interpenetration, these methods manually set a relatively large collision threshold in the training data generation process [1]. However, a manually set threshold cannot meet the requirements for an accurate CDR.
This study proposes a framework for collisionaware interactive physical simulation using a graph neural network (GNN), which can achieve a CDR function similar to continuous collision detection (CCD), which is the most effective method for solving the CDR problem in traditional physical simulation. The GNN was used as the base model because it can provide complete vertexedgeface information, which can be used intuitively in basic geometric primitive collision tests. Additionally, a novel collisionaware recursive regression module is introduced to update the network parameters recursively using the interpenetration distances calculated from the vertexface and edgeedge tests.
Using a regression module, our model detects collisions. Finally, to provide a compact collision response, a novel selfsupervised term is introduced. In summary, our main contributions are as follows: (1) propose a GNN with a collisionaware recursive regression module to effectively sense and respond to toolobject collisions; (2) a novel selfsupervised collision term is introduced to reduce the interpenetration errors in unseen (that is, test) sequences and provide a more compact collision response; and (3) the proposed method was extensively evaluated in several common interactive simulation scenes with vertexface, edgeface, and faceface collisions.
Related works
This section reviews three main areas: deep simulation, CCD, and GNNs.
Deep simulation
Neural networks can be used as effective function approximators in physical systems. For linear elastic deformation, Luo et al. [3] proposed a highly reusable and efficient neural networkbased nonlinear deformable simulation framework, which partially restores the forcedisplacement relationship by warping the simulated nodal displacement, and used a simplistic constitutive model to infer the linear elasticity. For nonlinear elastic deformation, Holden et al. [1] combined subspace simulation techniques with machine learning to support interactions with external objects. Romero et al. [4] used a model formula with nonlinear corrections applied to the local undeformable setting and decoupled internal and external contactdriven corrections.
The collision process is one of the physical simulation difficulties associated with deep learning techniques. The most basic method is to learn the implicit collision relations between collision objects. Teng et al. [5] managed selfcollisions by applying forces on a sparse set of deprojected simulation points. They supported external collisions by allowing partial, albeit costly, fullspace simulations in collisionprone mesh areas. Additionally, Tan et al. [6] presented a learningbased method that synthesizes collisionfree 3D human poses. They decomposed wholebody collisions into groups of collisions between localized body parts using a bilevel autoencoder. Pfaff et al. [7] took advantage of the excellent explanatory capability of GNNs for graph datasets (meshbased datasets), and their model can learn the dynamics of a wide range of physical systems, from cloth simulation over structural mechanics to fluid dynamics directly. In this study, a GNN is used as a base model because it can learn complete vertexedgeface information.
CCD
CCD is widely applied in many areas, including physicalbased simulation, computeraided design/computeraided manufacturings, and robot motion planning. Its main purpose is to use some form of the interpolating trajectory to check for collisions between two discrete positions of objects or primitives. A common method of CCD is to simply enclose the bounding volumes (BVs) at the beginning and end of a motion step using a swept volume. Axisaligned bounding boxes are usually chosen for this method. Coming and Staadt [8] proposed a velocityaligned discrete oriented polytopes as a type of swept volume for underlying spheres as BVs. Additionally, Redon et al. [9] proposed an oriented bounding boxes algorithm. Penetration depthbased detection is another method of CCD. The minimum distance is not a good measure for defining repelling forces, and computing the exact impact time using CCD is too timeconsuming for realtime applications. Redon and Lin [10] estimated the local penetration depth on the graphics processing unit using the local penetration direction computed for these regions. Tang et al. [11] traced the contact features along their deforming trajectories and accumulated penalty forces along the penetration time intervals between overlapping feature pairs.
Choi et al. [12] presented a framework for the CCD of composite quadric models with piecewise linear or quadric surface patches as boundary surfaces and conic curves or line segments as boundary curves. Although these methods can effectively provide CDR in traditional physical simulations, deep simulations remain an open problem.
GNNs
GNNs have been shown to be effective representations for learning largescale tasks [13]. A GNN can effectively learn knowledge representation [14], message passing [15], and encode longrange dependencies (video processing). GNNs also perform well in dynamic physical systems, such as for climate prediction [16], with an emphasis on individual objects [17] and their relations [18], partially observable systems [19], prevalent interactions within physical systems [14], hierarchically organized particle systems [20], or more generally physical simulation [7, 21, 22].
Methods
The objective of the study is to design a deep interactive physical simulation framework that can effectively address toolobject collisions. A GNNbased encoderprocessordecoder architecture was chosen as the baseline, which can provide complete vertexedgeface information. To detect toolobject collisions, a collisionaware recursive regression module that uses interpenetration distances calculated from vertexface and edgeedge tests to recursively update network parameters is introduced. Furthermore, a novel selfsupervised collision term to provide a more compact collision response is introduced to reduce the interpenetration errors in unseen (that is, test) sequences. Figure 1 shows an overview of the proposed method.
GNNbased architecture
A GNNbased encoderprocessdecoder architecture is used to learn the dynamic information. GNNs, compared with other networks, can provide complete vertexedgeface information. In particular, the dynamic information is encoded to a mesh graph, passed the messages on the mesh graph, and adapted the mesh discretization during the forward simulation. The mesh discretization information of the latent space contains the dynamic information of the system, and the mesh discretization information can be decoded to learn the dynamic information of the system. Figure 2 shows the networkspecific configuration.
A combined mesh \(M=\left({M}_X^t,{M}_Y^{t+1}\right)\) is the model input, where \({M}_X^t=\left({V}_X,{E}_X\right)\)is the simulation mesh of the deformable object at time t, nodes V_{X} connected by mesh edges E_{X} an \({M}_Y^{t+1}\left({M}_Y^{t^{\prime }},{P}_{t+1}\right)=\left({V}_Y,{E}_Y\right)\) is the simulation mesh of tool at time t + 1, nodes V_{Y} connected by mesh edges E_{Y} . Additionally, P_{t + 1}(p_{t + 1}, o_{t + 1}) is the pose of the tool (position p_{t + 1} and orientation o_{t + 1}) at time t + 1 and \({M}_Y^{t^{\prime }}\) is the base tool mesh at time t^{′}. We used P_{t + 1} and \({M}_Y^{t^{\prime }}\) to calculate the tool mesh \({M}_Y^{t+1}\) at time t + 1. Each node i ∈ M is associated with coordinates u_{i}, additional dynamic information q_{i}.
Encoder: The combined mesh is encoded into a multigraph G = (V, E). The nodes in the mesh correspond to the nodes in the graph, and the edges in the mesh correspond to the E in the graph. They are used to calculate the dynamic information inside the system. E handles dynamic information external to the system, such as collisions and contacts, which are the overall information of the system. An edge feature is defined as follows: \({e}_{ij}\left({e}_{ij}^W,{e}_{ij}^M\right)\), where \({e}_{ij}^M\in E\) and \({e}_{ij}^W={u}_i{u}_j\), if u_{i} − u_{j} < r_{W}, r_{W} is the collision radius. If the world distance between two nodes is less than r_{W}, the two nodes may collide. The node feature v_{i} is represented as a dynamic feature a_{i} and a onehot vector of node types. Finally, the node and edge features are encoded by two latent layers multilayer perceptrons (MLPs) ϵ^{E}, ϵ^{V} into a 128 dimensional hidden vector.
Processor: Messagepassing blocks were used to pass messages on the mesh graph and adapt the mesh discretization during forward simulation. The processor consists of L identical message passing blocks, which generalizes GraphNet blocks to multiple edge sets, and L = 2 by default. Each block contains a separate set of network parameters and is sequentially applied to the output of the previous block, updating the edge e_{ij}, and node v_{i} embeddings to \({e}_{ij}^{\prime }\) and \({v}_i^{\prime }\), respectively, by the following:
where f ^{E} and f ^{V} are implemented using two latentlayer MLPs with residual connections. Then, the proposed model learns the dynamic information latent space at time t + 1, the key to which is to decode the latent dynamic information to the real physical space.
Decoder: To transform the latent dynamic information space into real physical dynamic information, a two latentlayer MLP, δ^{V}, was used as a decoder to update the dynamic information of the nodes in the mesh by converting the latent node feature v^{i} at time t to the dynamic feature a^{i} of a deformable object at time t. The dynamic feature a^{i} is the derivative of the dynamic information q^{i} at time t. The forward Euler integration can be used to calculate the dynamic information \({q}_{t+1}^i\) at time t + 1. For firstorder systems, \({q}_{t+1}^i={a}^i+{q}_t^i\), whereas for secondorder systems, \({q}_{t+1}^i={a}_i+2{q}_t^i{q}_{t1}^i\).
Furthermore, to train a collisionaware model that learns dynamic information and toolobject collisions, the proposed GNNbased model loss is defined as follows:
where L_{q} is the dynamic information loss defined as follows:
L_{ccd} is the collisionaware recursive regression module’s continuous collisiondetection loss, which is explained in detail in collisionaware recursive regression module section. L_{compact} is the selfsupervised term loss that provides a compact collision response, which is explained in detail in selfsupervised term section.
Collisionaware recursive regression module
The messagepassing architecture learns dynamic information. However, it is difficult to detect the collision information in the system. To address this problem, the architecture outputs are used as the inputs to the collisionaware recursive regression module to calculate the interpenetration distance and update the network parameters recursively. Additionally, a novel selfsupervised collision term is introduced to provide a more compact collision response.
To calculate the interpenetration distance, a nonpenetration continuous collisiondetection filter that filters vertexface collision and edgeedge collision pairs is used. The interpenetration distance is defined as the continuous collisiondetection loss of the module as follows:
where ξ_{VF} and ξ_{EE} are the distances between vertexface and edgeedge collision pairs, respectively.
Traditional iterative continuous collisiondetection algorithms are difficult to integrate into networks; therefore, a fast nonpenetration continuous collisiondetection filter [23] is chosen as the collisionaware recursive regression module to calculate the interpenetration distance. Furthermore, because of the high computational cost, a culling strategy based on the signed distance field (SDF) values is provided. The collisiondetection module contains two terms: the vertexface and edgeedge tests. Figures 3(a) and 4(a) show the vertexface and edgeedge tests, respectively.
Vertexface test: For a triangle T_{t} and a vertex P_{t} defined by the start and end positions during the interval [0, 1], these positions are linearly interpolated in the interval with respect to the time variable t. If the following four scalar values, A, B, \(\frac{2\ast C+F}{3}\), and \(\frac{2\ast D+E}{3}\) have the same sign, T_{t} and P_{t} will not be coplanar during the interval:
where n_{0} is the normal of △a_{0}b_{0}c_{0}, n_{1} is the normal of △a_{1}b_{1}c_{1}, and \(\overline{n}=\frac{n_0+{n}_1\left(\overrightarrow{v_b}\overrightarrow{v_a}\right)\times \left(\overrightarrow{v_c}\overrightarrow{v_a}\right)}{2},\overrightarrow{v_a}\) is the vector of a_{0}a_{1}, \(\overrightarrow{v_b}\) is the vector of b_{0}b_{1}, \(\overrightarrow{v_c}\) is the vector of c_{0}c_{1}.
Edgeedge test: For two edges E^{1} and E^{2} defined by the start and positions during the interval [0, 1], these positions are linearly interpolated in the interval with respect to the time variable t. If the following four scalar values: A^{′}, B^{′}, \(\frac{2\ast {C}^{\prime }+{F}^{\prime }}{3}\), and \(\frac{2\ast {D}^{\prime }+{E}^{\prime }}{3}\) have the same sign, E^{1} and E^{2} will not be coplanar during the interval.
where \({n}_0^{\prime }\) is the normal of △u_{0}k_{0}v_{0}, \({n}_1^{\prime }\) is the normal of △u_{1}k_{1}v_{1}, and \({\overline{n}}^{\prime }=\frac{n_0^{\prime }+{n}_1^{\prime }\left(\overrightarrow{v_u}\overrightarrow{v_k}\right)\times \left(\overrightarrow{v_v}\overrightarrow{v_k}\right)}{2}\), \(\overrightarrow{v_k}\) is the vector of k_{0}k_{1}, \(\overrightarrow{v_u}\) is the vector of u_{0}u_{1}, \(\overrightarrow{v_v}\) is the vector of v_{0}v_{1}.
The computation cost of every vertexface and edgeedge pair is very large; therefore, the vertexes which SDF values that are smaller than a certain value before filtering are culled. The filtered vertexface and edgeedge pairs that did not collide and the rest were defined as the collision pairs.
For vertexface collision pairs, \({\upgamma}^{t_0,{t}_0+1}\) are vertexface pairs during the interval frame [t_{0}, t_{0} + 1], and the vertexface pairs collide at time t_{0} + 1. Figure 3(b) shows the vertexface distance at time interval [0, 1]. To reduce the number of vertexface collision pairs, the distance between vertexface pairs is reduced. \({D}_{vf}^{t_0,{t}_0+1}\) is defined as the distance between vertexface pairs during the interval frame interval [t_{0}, t_{0} + 1]. Therefore, the vertexface loss is defined as follows:
where
For edgeedge collision pairs, \({\upeta}^{t_0,{t}_0+1}\) are edgeedge pairs during the interval frame [t_{0}, t_{0} + 1], and the edgeedge pairs collide at time t_{0} + 1. Figure 4(b) shows the edge distance at time interval [0, 1]. To reduce the number of edgeedge collision pairs, the distance between edgeedge pairs is reduced. \({D}_{ee}^{t_0,{t}_0+1}\) is defined as the distance between edgeedge pairs during the interval frame interval [t_{0}, t_{0} + 1]. Therefore, the edgeedge loss is defined as follows:
where
Selfsupervised term
Using the learned dynamic information defined in GNNbased architecture section and the toolobject collision detection module in collisionaware recursive regression module section, a collisionaware model to learn the dynamic information and toolobject collision can be trained. However, there were interpenetration errors in the unseen (that is, test) sequence. This challenge is addressed by learning a compact collision response that reliably solves toolobject interpretations. To provide a compact collision response, the following selfsupervised collision term is proposed:
and
where \({\overline{z}}_{rand}\sim N\left(0,1\right)\), Δ is the collisionfree constraint threshold, SDF() is the signed distance field of the tool, D() is the decoder of our model, and P_{t + 1} is the pose of the tool at time t + 1. The selfsupervised term samples the latent space and checks collisions against a constraint tool mesh using a selfsupervised strategy (that is, ground truth positions are not needed for this term). This key ingredient allows for thorough sampling of the latent space and the learning of a compact collision response that reliably solves the toolobject interpenetration problem.
The selfsupervised loss is derived from ref. [24], which requires a consistent distribution of the sampled latent space and training data. To enforce a normal distribution in the latent space, an additional term L_{KL} is included.
Datasets
Generally, most meshbased simulation methods are suitable for acquiring data for the proposed method. The inputs to the training procedure were a raw time series of framebyframe vertex positions and face indices. More details about the exact data acquisition process used in our results are provided.
All simulations were performed using the incremental potential contact (IPC) simulation library [25] and captured data at 25 fps. The datasets used are shown in Fig. 5. The IPC library can provide accurate CDR simulation results. The datasets used in this study involve vertexface collisions (conebunny), edgeface collisions (knifetorus), and faceface collisions (spheremat and cylinderbanana). All datasets contain dynamic information (velocity), SDF values of the tools, vertex positions, and face information. The vertexface collision datasets used in this study are conebunnies, which simulate a cone stabbing a bunny. The edgeface collision datasets used in this study are knifetorus, which simulate a knife cutting a rubber torus. The faceface collision datasets used in this study were a spheremat and cylinderbanana. The spheremat datasets simulated a rigid sphere falling onto a rubber mat, whereas the cylinderbanana datasets simulated a rigid cylinder pressing a banana. Table 1 shows the model complexity of the datasets.
Training
This section introduces the training software environment, normalization strategies, training noise, and optimization procedures used in this study.
Software: All models were implemented using TensorFlow1, Sonnet1, and the “Graph Nets” library.
Normalization: All input and target vectors elementwise were normalized to zero mean and unit variance, using statistics computed online during training. Normalization can lead to faster training and better performance. Preliminary experiments showed that normalization led to faster training, although the converged performance did not improve significantly.
Training noise: Modeling a complex and chaotic simulation system requires a model to mitigate error accumulation over long rollouts. Because the models in this study were trained on groundtruth onestep data, they were never presented with input data corrupted by this type of accumulated noise. This means that when a rollout is generated by feeding the model with its own noisy, previous predictions as input, the fact that its inputs are outside the training distribution may lead to more substantial errors and thus rapidly accumulate further error. A simple approach to make the model more robust to noisy inputs by corrupting the input positions of the model with Gaussian noise is used; thus, the training distribution is closer to the distribution generated during rollouts.
Optimization procedures: The model parameters were optimized over this loss with the Adam optimizer [26], using a nominal minibatch size of one. A maximum of 1 × 10^{5} gradient update steps was performed with an exponential learning rate decay from 10^{4} to 10^{6}. While models can be trained in fewer steps, this study avoided using aggressive learning rates to reduce variance across datasets and make comparisons across settings fairer.
Results
This section demonstrates that our model can reliably process collisions in the physical system and conduct several experiments comparing the baseline, quantitative evaluation, and qualitative evaluation in different simulation scenes: faceface collisions, edgeface collisions, vertexface collisions, and ablation studies. The reader is referred to the supplemental video for the corresponding animations. The proposed model runs on a PC with a central processing unit Intel E5–2637, 128 GB RAM, and a GTX 1080 Ti graphics card.
Comparison
A spheremat scene is chosen to demonstrate the advantage of the proposed method in processing collisions compared with the baseline. The proposed method is compared with subphysics [1] and a baseline. The baseline comes from meshgraphnets [7] without remeshing because remeshing changes the topology of the data, which is not conducive to evaluating collisions. Figure 6 shows a comparison between the proposed method and the baseline. The top row is the ground truth, the second row is the subphysics simulation result, the third row is the baseline simulation result, and the bottom row is the proposed method simulation result. The results show that their method has a large interpenetration area, whereas the proposed method has none. Clearly, the proposed method detects collisions in the physical system.
Qualitative evaluation
To demonstrate the effectiveness of the proposed method in terms of quality, three different collision scenarios were defined: vertexface collision, edgeface collision, and faceface collision. Figure 7(a) shows the vertexface collision, Fig. 7(b) shows the edgeface collision, and Fig. 7(c) shows the faceface collision. In all three figures, the first row shows the simulation result of the proposed method, and the second row shows the ground truth. None of the three scenes had any interpenetration of the proposed method. Table 2 shows the quantitative evaluation of the collision elimination. The table shows that the proposed method can effectively eliminate collision errors. According to the results in the figures and table, the proposed method can process vertexface, edgeface, and faceface collisions.
Quantitative evaluation
To demonstrate the effectiveness of the proposed method, three different scenes of collisions were defined: vertexface, edgeface, and faceface collisions. Four collision quantitative evaluations were used: vertexface collision numbers, vertexface collision interpenetration distance, edgeedge collision numbers, and edgeedge collision interpenetration distance to judge the effectiveness of the proposed method’s processing collision. Figure 8 shows four collision quantitative evaluation results for three collision scenes.
Because ref. [1] lacks a CCD module, it is excluded from the comparison. Clearly, for the four collision quantitative evaluations, the proposed method is fairly less accurate than the baseline [7] and is close to the ground truth. The results demonstrate that the proposed method can effectively reduce collision errors in physical systems.
Ablation study
The selfsupervised term was removed from the proposed method to demonstrate the effectiveness of the random latent space in completing CDR. Figure 9 shows the comparison results. The first row shows the proposed method’s simulation results, while the second row shows the ablation simulation results. The figure shows that there are interpenetrations if the selfsupervised term is removed. The results show that using the selfsupervised term to complete the collision response is crucial for the proposed method.
Performance
The proposed method is compared with the ground truth physical simulator IPC to evaluate its performance. Table 1 presents the results of this comparison. As the table shows, the proposed method leverages IPC by at least one order of magnitude.
Discussion
In this section, the advantages and challenges of the proposed method are discussed. The proposed method is compared with other stateoftheart methods. Although the simulation results of the other methods have interpenetrations, the proposed method has none. Clearly, the proposed method detects collisions in the physical system better than the other methods. The proposed method was qualitatively and quantitatively evaluated in three collision scenarios: vertexface, edgeface, and faceface collisions. The proposed method can visually produce no interpenetration results and effectively reduce the number of vertexface collision and edgeedge collisions, resulting in visually excellent and physically accurate results. An ablation study was conducted to demonstrate the effectiveness of the random latent space for complete CDR. Some interpenetrations occur without a random latent space, demonstrating that our selfsupervised term effectively reduces interpenetrations. Furthermore, compared to traditional CCD methods (IPC), the proposed method leverages at least one order of magnitude. In conclusion, to the best of our knowledge, the proposed deep learningbased framework can effectively address toolobject collisions and is a stateoftheart method.
However, this study only focused on the interaction between a rigid tool and soft body. The penetration number of the vertex face and edge increases sharply as the model’s complexity increases. The existing framework does not support largescale interactive simulation computations owing to the limitations of the existing storage and computational power of the workstation. Future studies should introduce multiscale representations to achieve largescale interactive simulations.
Conclusions
In this study, a deep interactive physical simulation framework that can effectively address toolobject collisions is presented. This was achieved using a GNNbased architecture and collisionaware recursive regression module to detect collisions. Additionally, a novel selfsupervised collision term is introduced to provide a more compact collision response. The proposed method was extensively evaluated and the results demonstrated that it can effectively reduce interpenetration artifacts while ensuring high simulation efficiency. However, the trained model could only be applied to simulations using the same tool object. Further research must be conducted to enhance the generalizability of this study’s results. The existing framework does not support largescale interactive simulation computations owing to the limitations of the existing storage and computational power of the workstation. Furthermore, future work must introduce multiscale representations to achieve largescale interactive simulations.
Availability of data and materials
The IPC library, available at https://github.com/ipcsim/IPC, was used to generate simulation datasets.
Abbreviations
 GNN:

Graph neural network
 CDR:

Collision detection and response
 CCD:

Continuous collision detection
 BV:

Bounding volume
 MLP:

Multilayer perceptron
 SDF:

Signed distance field
 IPC:

Incremental potential contact
References
Holden D, Duong BC, Datta S, Nowrouzezahrai D (2019) Subspace neural physics: Fast datadriven interactive simulation. Paper presented at the 18th annual ACM SIGGRAPH/Eurographics symposium on computer animation, ACM, Los Angeles, 2628 July 2019. https://doi.org/10.1145/3309486.3340245
Santesteban I, Thuerey N, Otaduy MA, Casas D (2021) Selfsupervised collision handling via generative 3D garment models for virtual tryon. Paper presented at the 2021 IEEE/CVF conference on computer vision and pattern recognition, IEEE, Nashville, 2025 June 2021. https://doi.org/10.1109/CVPR46437.2021.01159
Luo R, Shao TJ, Wang HM, Xu WW, Chen X, Zhou K et al (2020) NNWarp: Neural networkbased nonlinear deformation. IEEE Trans Vis Comput Graph 26(4):17451759.
Romero C, Casas D, Pérez J, Otaduy M (2021) Learning contact corrections for handlebased subspace dynamics. ACM Trans Graph 40(4): 131. https://doi.org/10.1145/3476576.3476703
Teng Y, Meyer M, DeRose T, Kim T (2015) Subspace condensation: Full space adaptivity for subspace deformations. ACM Trans Graph 34(4): 76. https://doi.org/10.1145/2766904
Tan QY, Pan ZR, Manocha D (2021) L Collision: Fast generation of collisionfree human poses using learned nonpenetration constraints. arXiv preprint arXiv:2011.03632.
Pfaff T, Fortunato M, SanchezGonzalez A, Battaglia PW (2021) Learning meshbased simulation with graph networks. arXiv preprint arXiv:2010.03409.
Coming DS, Staadt OG (2008) Velocityaligned discrete oriented polytopes for dynamic collision detection. IEEE Trans Vis Comput Graph 14(1):112. https://doi.org/10.1109/TVCG.2007.70405
Redon S, Kheddar A, Coquillart S (2002) Fast continuous collision detection between rigid bodies. Comput Graph Forum 21(3):279287. https://doi.org/10.1111/14678659.t01100587
Redon S, Lin MC (2006) A fast method for local penetration depth computation. J Graph Tools 11(2):3750. https://doi.org/10.1080/2151237X.2006.10129216
Tang M, Manocha D, Otaduy MA, Tong RF (2012) Continuous penalty forces. ACM Trans Graph 31(4): 107. https://doi.org/10.1145/2185520.2185603
Choi YK, Wang WP, Mourrain B, Tu CH, Jia XH, Sun F (2014) Continuous collision detection for composite quadric models. Graph Models 76(5):566579. https://doi.org/10.1016/j.gmod.2014.03.005
Battaglia PW, Hamrick JB, Bapst V, SanchezGonzalez A, Zambaldi V, Malinowski M et al (2018) Relational inductive biases, deep learning, and graph networks. arXiv preprint arXiv:1806.01261.
Kipf T, Fetaya E, Wang KC, Welling M, Zemel R (2018) Neural relational inference for interacting systems. Paper presented at the 35th international conference on machine learning, JMLR.org. Stockholm; 2018.
Gilmer J, Schoenholz SS, Riley PF, Vinyals O, Dahl GE (2017) Neural message passing for quantum chemistry. Paper presented at the 34th international conference on machine learning, JMLR.org. Sydney; 2017.
Seo S, Liu Y (2019) Differentiable physicsinformed graph networks. arXiv preprint arXiv:1902.02950.
Chang MB, Ullman T, Torralba A, Tenenbaum JB (2017) A compositional objectbased approach to learning physical dynamics. arXiv preprint arXiv:1612.00341.
SanchezGonzalez A, Heess N, Springenberg JT, Merel J, Riedmiller M, Hadsell R. et al (2018) Graph networks as learnable physics engines for inference and control. Paper presented at the 35th international conference on machine learning, JMLR.org. Stockholm; 2018.
Li YZ, Wu JJ, Zhu JY, Tenenbaum JB, Torralba A, Tedrake R (2019) Propagation networks for modelbased control under partial observation. Paper presented at the 2019 international conference on robotics and automation, IEEE, Montrl, 2024 May 2019. https://doi.org/10.1109/ICRA.2019.8793509
Mrowca D, Zhuang CX, Wang E, Haber N, FeiFei L, Tenenbaum JB et al (2018) Flexible neural representation for physics prediction. arXiv preprint arXiv:1806.08047.
SanchezGonzalez A, Bapst V, Cranmer K, Battaglia P (2019) Hamiltonian graph networks with ODE integrators. arXiv preprint arXiv:1909.12790.
SanchezGonzalez A, Godwin J, Pfaff T, Ying R, Leskovec J, Battaglia P (2020) Learning to simulate complex physics with graph networks. Paper presented at the 37th international conference on machine learning, PMLR, Vienna.
Tang M, Manocha D, Tong RF (2010) Fast continuous collision detection using deforming nonpenetration filters. Paper presented at the 2010 ACM SIGGRAPH symposium on interactive 3D graphics and games, ACM, Washington. https://doi.org/10.1145/1730804.1730806
Kingma DP, Welling M (2014) Autoencoding variational bayes. arXiv preprint arXiv:1312.6114.
Li MC, Ferguson Z, Schneider T, Langlois T, Zorin D, Panozzo D et al (2020) Incremental potential contact: Intersectionand inversionfree, largedeformation dynamics. ACM Trans Graph 39(4): 49. https://doi.org/10.1145/3386569.3392425
Kingma DB, Ba J (2017) Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980.
Acknowledgements
The authors are grateful to the College of Computer Science, Sichuan University, and the Shenzhen Institute of Advanced Technology, Chinese Academy of Sciences.
Funding
This project was funded by Natural Science Foundation of Guangdong Province, No. 2020B010165004.
Author information
Authors and Affiliations
Contributions
XZ and YQ conceptualized the study; XZ implemented the machine learning model, conducted all the experiments, and produced the paper; YQ and PAH revised the manuscript; ZF and QW supplied significant information regarding the current research to the introduction and conclusion; The final manuscript has been read and approved by all authors; XZ and YQ contributed equally to this work.
Corresponding author
Ethics declarations
Competing interests
The authors declare that they have no known competing financial interests or personal relationships that could have influenced the work reported in this study.
Additional information
Publisher’s Note
Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Supplementary Information
Additional file 1.
Rights and permissions
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons licence, and indicate if changes were made. The images or other third party material in this article are included in the article's Creative Commons licence, unless indicated otherwise in a credit line to the material. If material is not included in the article's Creative Commons licence and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this licence, visit http://creativecommons.org/licenses/by/4.0/.
About this article
Cite this article
Zhu, X., Qian, Y., Wang, Q. et al. Collisionaware interactive simulation using graph neural networks. Vis. Comput. Ind. Biomed. Art 5, 15 (2022). https://doi.org/10.1186/s42492022001134
Received:
Accepted:
Published:
DOI: https://doi.org/10.1186/s42492022001134
Keywords
 Deep physical simulation
 Collisionaware
 Continuous collision detection
 Graph neural network