DEEP PARAMETERIZATION FOR 3D SHAPE OPTIMIZATION

CROSS-REFERENCE TO RELATED APPLICATIONS

This application claims priority under 35 U.S.C. § 119 or 365 to European Application No. 21305729.2, filed Jun. 1, 2021. The entire contents of the above application(s) are incorporated herein by reference.

TECHNICAL FIELD

The disclosure relates to the field of computer programs and systems, and more specifically to methods, a system and a program for differentiable simulation-based shape optimization.

BACKGROUND

A number of systems and programs are offered on the market for the design, the engineering and the manufacturing of objects. CAD is an acronym for Computer-Aided Design, e.g., it relates to software solutions for designing an object. CAE is an acronym for Computer-Aided Engineering, e.g., it relates to software solutions for simulating the physical behavior of a future product. CAM is an acronym for Computer-Aided Manufacturing, e.g., it relates to software solutions for defining manufacturing processes and operations. In such computer-aided design systems, the graphical user interface plays an important role as regards the efficiency of the technique. These techniques may be embedded within Product Lifecycle Management (PLM) systems. PLM refers to a business strategy that helps companies to share product data, apply common processes, and leverage corporate knowledge for the development of products from conception to the end of their life, across the concept of extended enterprise. The PLM solutions provided by Dassault Systérnes (under the trademarks CATIA, ENOVIA and DELMIA) provide an Engineering Hub, which organizes product engineering knowledge, a Manufacturing Hub, which manages manufacturing engineering knowledge, and an Enterprise Hub which enables enterprise integrations and connections into both the Engineering and Manufacturing Hubs. All together the system delivers an open object model linking products, processes, resources to enable dynamic, knowledge-based product creation and decision support that drives optimized product definition, manufacturing preparation, production and service.

Within this context and other contexts, shape optimization is gaining wide importance.

Shape optimization improves existing designs for more reliable and durable components. Example optimizations tasks aim to optimize stress, strain, and durability by automatic simulation-driven modification of the shape geometry. This field has a rich history motivated by applications ranging from structural mechanics to electromagnetism. Real-world shape optimization problems may easily comprise thousands of vertices. Search efficiency and scalability remain a challenge is this field.

Existing methods are so computationally demanding that typical engineering practices are to either simply try a limited number of hand-designed shapes or restrict oneself to shapes that can be parameterized using only few degrees of freedom. Typically, existing optimization strategies may involve simplifying the shape's degrees of freedom by reducing the search space size, i.e., limiting the number of candidate shapes.

Within this context, there is a need for an improved solution for shape optimization.

SUMMARY

It is therefore provided a computer-implemented method of machine-learning. The method comprises providing a dataset of 3D modeled objects each representing a mechanical part. Each 3D modeled object comprises a specification of a geometry of the mechanical part. The method further comprises learning a set of parameterization vectors each respective to a respective 3D modeled object of the dataset and a neural network. The neural network is configured to take as input a parameterization vector and to output a representation of a 3D modeled object usable in a differentiable simulation-based shape optimization. The learning comprises minimizing a loss. The loss penalizes, for each 3D modeled object of the dataset, a disparity between the output of the neural network for an input parameterization vector respective to the 3D modeled object and a representation of the 3D modeled object. The representation of the 3D modeled object is usable in a differentiable simulation-based shape optimization.

The method may comprise one or more of the following:

- the representation is an implicit representation;
- the implicit representation is a signed distance field representation;
- the set of parameterization vectors is a set of latent vectors; and/or
- each 3D modeled object of the provided dataset further comprises a specification of one or more physical attributes of the mechanical part, and the representation is a representation of the geometry and of the one or more physical attributes.

It is further provided a neural network learnable (e.g., having been learnt) according to the method. The neural network is a computer-implemented data structure having weights (also referred to as “parameters”) settable (e.g., having been set) by the learning according to the method. The neural network is:

- a decoding neural network, configured to take as input a parameterization vector of a 3D modeled object and to output a representation of the 3D modeled object usable in a differentiable simulation-based shape optimization; or
- an autoencoder, comprising an encoder configured to take as input a 3D modeled object and to output a parameterization of the 3D modeled object, and a decoder configured to take as input a parameterization vector of a 3D modeled object and to output a representation of the 3D modeled object usable in a differentiable simulation-based shape optimization.

It is further provided a method of use of the neural network for differentiable simulation-based shape optimization. The method of use comprises providing a 3D modeled object representing a mechanical part, one or more physical constraints on the 3D modeled object, and a differentiable simulator. The differentiable simulator takes as input a representation of a 3D modeled object and outputs a value. The value represents an extent to which the 3D modeled object respects the one or more physical constraints. The method of use further comprises performing a simulation-based shape optimization of the 3D modeled object by minimizing a loss. The loss penalizes a disparity between the value outputted by the simulator for the output of the neural network for a candidate parameterization vector and an optimal output of the simulator with respect to the one or more physical constraints.

The method of use may comprise:

- the output of the neural network is an explicit representation of the 3D modeled object parameterized by the candidate parameterization vector and the simulator takes as input an explicit representation of a 3D modeled object, or the output of the neural network is an implicit representation of the 3D modeled object parameterized by the candidate parameterization vector and the simulator takes as input an explicit representation of a 3D modeled object, the performing of the simulation-based shape optimization comprising transforming the implicit representation of the 3D modeled object into an explicit representation;
- the loss further penalizes a disparity between a 3D modeled object parameterized by the candidate parameterization vector and the provided 3D modeled object;
- the disparity between the 3D modeled object parameterized by the candidate parameterization vector and the 3D modeled object comprises:
  - a disparity between the candidate parameterization vector and a parameterization vector of the provided 3D modeled object, the parameterization vector being obtained from the provided 3D modeled object; and/or
  - a disparity between the output of the neural network for the candidate parameterization vector and a representation of the provided 3D modeled object;
- the loss if of the type:

custom-character (Ψ_OΦ(ν′_R),ƒ_opt)+α_D(ν,ν′)+βd_s(Φ(ν′_R),O),

where Φ(ν′, custom-character _R) is the output of the neural network Φ for the candidate parameterization vector ν′, Ψ is the simulator, ƒ_optis the optimal output of the simulation with respect to the one or more physical constraints, ν is the parameterization vector of the provided 3D modeled object, O=Φ(ν, custom-character _R) is the representation of the provided 3D modeled object, d_sare distances, and α and β are coefficients of the loss; and/or

- the output of the neural network for an input candidate parameterization vector is an implicit representation of the 3D modeled object parametrized the input parameterization vector, the implicit representation being a signed distance field, the simulator takes as input an explicit representation of a 3D modeled object, and the distance d_sis of the type:

d
_s(Φ(ν₁, custom-character _R),Φ(ν₂,_R))=BCE(B^σ(ν₂),(ν₁))

where for i=1, 2, ν_iis a parameterization vector, Φ(ν_i, custom-character _R) is the output of the neural network for the parameterization vector being the neural network, where

custom-character (ν)={_Φ(ν,x)<0;x∈_R},

B
^σ(ν)={σ(ηΦ(ν,x));x∈ custom-character _R},

η being a negative real number, custom-character and σ being respectively the indicator and the sigmoid functions, _Rbeing a grid of regularly spaced coordinates, and where BCE is a binary cross entropy distance between two sets X and with size n such as ∀ x ∈ x ∪ , x ∈ [0,1] and is given by the formula

$BCE (𝒳, 𝒴) = \frac{1}{n} \sum_{i = 1}^{n} y_{i} \log (x_{i}) + (1 - y_{i}) \log (1 - x_{i}),$

- where the x_iare the points of X and where the y_iare the points of .

It is further provided a computer program comprising instructions for performing the method and/or the method of use.

It is further provided a device comprising a computer-readable data storage medium having recorded thereon the computer program and/or the neural network.

The device may form or serve as a non-transitory computer-readable medium, for example on a SaaS (Software as a service) or other server, or a cloud based platform, or the like. The device may alternatively comprise a processor coupled to the data storage medium. The device may thus form a computer system in whole or in part (e.g., the device is a subsystem of the overall system). The system may further comprise a graphical user interface coupled to the processor.

BRIEF DESCRIPTION OF THE DRAWINGS

Non-limiting examples will now be described in reference to the accompanying drawings, where:

FIGS. 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, and 17 illustrate the methods; and

FIG. 18 shows an example of the system.

DETAILED DESCRIPTION

Discussed is a computer-implemented method of machine-learning. The method comprises providing a dataset of 3D modeled objects each representing a mechanical part. Each 3D modeled object comprises a specification of a geometry of the mechanical part. The method further comprises learning a set of parameterization vectors each respective to a respective 3D modeled object of the dataset and a neural network. The neural network is configured to take as input a parameterization vector and to output a representation of a 3D modeled object usable in a differentiable simulation-based shape optimization. The learning comprises minimizing a loss. The loss penalizes, for each 3D modeled object of the dataset, a disparity between the output of the neural network for an input parameterization vector respective to the 3D modeled object and a representation of the 3D modeled object. The representation of the 3D modeled object is usable in a differentiable simulation-based shape optimization. The method may be referred to as “the learning method”.

The learning method constitutes an improved solution for differentiable simulation-based shape optimization.

Notably, the learning method provides a solution to perform a resource-saving yet accurate and high-quality differentiable simulation-based shape optimization. Indeed, the learning method learns a set of parameterization vectors, each respective to a 3D modeled object of the provided dataset (i.e., the training dataset), i.e., each vector parameterizes (e.g., encodes) a respective 3D modeled object. In other words, each parameterization vector is a vector representation of the corresponding respective 3D modeled object, capturing its geometry and optionally physical attributes thereof, since the 3D modeled object is provided with a specification of a geometry of the mechanical part it represents and optionally with a specification of the physical attributes of the part. Yet the parameterization vector, which for example may be a latent vector, has a dimension lower than that of the 3D modeled object. This implies the following: the parameterization vector costs less in terms of storage requirements than the corresponding 3D modeled object, and when used in a differentiable simulation-based optimization, the parameterization vector reduces the memory (i.e., random access memory, also referred to as “RAM”) footprint and the burden on the CPU (central processing unit).

Each learnt parameterization vector is indeed usable in a differentiable simulation-based shape optimization, because the learning method learns, in addition of the set of parameterization vectors, a neural network configured to take such a vector as input and to output a representation of the corresponding respective 3D modeled object, the representation being usable in a differentiable simulation-based shape optimization. Thus the neural network forms a mapping between the learnt space of parameterization vectors and a representation space compatible with a differentiable simulation-based shape optimization. Moreover, it is to be noted that the learnt set of parameterization vectors does not limit the shape optimization to the 3D modeled objects of the provided dataset. Indeed, the learnt set of parameterization vectors form a low-dimensional space of parameterization vectors based on which the optimization may then be made, i.e., the space of the parameterization vectors is a search space of the optimization. 3D modeled objects other that the ones in the provided dataset may be optimized by the optimization using the space of parameterization vectors, as a parameterization vector of a 3D modeled object not belonging to the set may still be obtained based on the learnt neural network, for example by performing a minimization (e.g., a Maximum a Posterior estimation) based on the learnt neural network to obtain this vector, or for example by encoding the 3D modeled object if the neural network is an autoencoder.

Thus, while a differentiable simulation-based shape optimization is normally computationally-demanding as previously discussed, the learning method circumvent these difficulties by finding a parameterization space (e.g., a latent space) for the free variables of the optimization with the consideration that vectors of this space, due to their reduced dimension, may efficiently be used in the optimization, i.e., with a reduced footprint on the RAM and a reduced burden on the CPU, while keeping a high quality result of the simulation, since the vectors still capture the geometry, and optionally the physical attributes, of the underlying mechanical parts to optimize. In yet other words, the learning method provides a data structure compatible with a differentiable simulation-based simulation, i.e., usable in such a simulation, and allowing an efficient, in terms of memory footprint and CPU usage, implementation of the optimization on a computer system with yet high quality results. For example, the learning method allows not to restrict the candidates of the optimization (i.e., the space or variety of possible solutions) due to computational limitations imposed by the underlying computer system.

The optimization method is method of differentiable simulation-based shape optimization, for optimizing the shape of the mechanical part represented by the provided 3D modeled object with respect to the one or more physical constraints (for example, optimizing the mechanical part with respect to stiffness constraints) and based on a differential simulator that measures an extent of respect of the constraints. The loss involved in the minimization involves candidate parameterization vector, i.e., the free variable of the minimization is a parameterization vector and the space of the free-variables, in which the minimization explores candidate optimums, is the parameterization vector space. Thereby, the optimization works in a low-dimensional space (e.g., a latent space) learnable according to the learning method, thus having as previously explained a dimension lower than that of a 3D modeled object space, so that, as previously explained, the memory footprint and the burden on the CPU are reduced during the optimization without the need of restricting or simplifying the space of potential solutions. In other words, the optimization provides a quality result while working on a space learnt to allows the optimization to be resource-saving and efficiently implemented on a computer, from the viewpoint of the memory footprint and CPU burden as previously explained.

The optimization method may be part of a manufacturing CAD (also referred to as “solid modeling”) process, to design a mechanical part to be manufactured downstream of the manufacturing CAD process based on a 3D volume model (i.e., solid model) of the mechanical part. The optimization method may be a step of such a process, to optimize the shape of the mechanical part with respect to one or more physical constraints, which may include manufacturing constraints of the mechanical part and/or constraints on the physical performances of the mechanical part once manufactured. The optimization method outputs an optimized version of the 3D solid representing the mechanical part with respect to the constraint, which may be then further modified by further downstream CAD design steps and/or then serve as a basis for manufacturing the mechanical part. The optimization method contributes to a more efficient, resource-saving and time-saving design process as the optimization is automatically performed, in a one-shot efficient computation. In other words, the shape optimization step of the design process is automated by a resource-saving optimization method, which saves time and computer-resources, as well as improving ergonomics and design assistance for the designer.

The learning method and the optimization method may be performed independently. Alternatively, they may be integrated into a same computer implemented process, which may be, or may be integrated to, the previously discussed manufacturing CAD process. The process integrating the learning method and the optimization method comprises an offline stage, consisting of the learning method, and an online stage, consisting of the optimization method. FIG. 1 shows a flowchart of an example of such a process.

The learning method is now further discussed. The learning method is a machine-learning method, i.e., a method of machine-learning.

As known per se from the field of machine-learning, the processing of an input by a neural network includes applying operations to the input, the operations being defined by data including weight values. Learning a neural network thus includes determining values of the weights based on a dataset configured for such learning, such a dataset being possibly referred to as a learning dataset or a training dataset. For that, the dataset includes data pieces each forming a respective training sample. The training samples represent the diversity of the situations where the neural network is to be used after being learnt. Any training dataset herein may comprise a number of training samples higher than 1000, 10000, 100000, or 1000000. In the context of the present disclosure, by “learning a neural network based on a dataset”, it is meant that the dataset is a learning/training dataset of the neural network, based on which the values of the weights (also referred to as “parameters”) are set.

In the context of the learning method, the training dataset is thus the provided dataset of 3D modeled objects each representing a mechanical part. Each training sample includes a 3D modeled object, which comprises a specification of the geometry of the mechanical part, i.e., data capturing the geometry of the mechanical part. Each 3D modeled object may further comprise a specification of one or more physical attributes of the mechanical part. The one or more physical attributes may comprise one or more of a segmentation of the corresponding mechanical part, a volumetric mass density, a thermal conductivity, a specific heat, a thermal expansion, a stiffness, an electrical resistivity, a conductivity and/or a motion attribute. The 3D modeled objects of the training dataset may represent mechanical parts of a same class (e.g., chairs, planes or cars), in which case any 3D modeled object undergoing the optimization in the optimization method represents a mechanical part of the same class.

The learning method thus manipulates 3D modeled objects The optimization method as well. A 3D modeled object is any object defined by data stored e.g., in the database. By extension, the expression “modeled object” designates the data itself. According to the type of the system, the modeled objects may be defined by different kinds of data. The system may indeed be any combination of a CAD system, a CAE system, a CAM system, a PDM system and/or a PLM system. In those different systems, modeled objects are defined by corresponding data. One may accordingly speak of CAD object, PLM object, PDM object, CAE object, CAM object, CAD data, PLM data, PDM data, CAM data, CAE data. However, these systems are not exclusive one of the other, as a modeled object may be defined by data corresponding to any combination of these systems. A system may thus well be both a CAD and PLM system, as will be apparent from the definitions of such systems provided below.

Any 3D modeled object herein represents a mechanical part, to be manufactured in a real world, e.g., downstream to a manufacturing CAD process such as the one previously discussed. By “3D modeled object”, it is meant any object which is modeled by data allowing its 3D representation. A 3D representation allows the viewing of the part from all viewpoints (e.g., from various angles and/or distances). For example, a 3D modeled object, when 3D represented, may be handled and turned around any of its axes, or around any axis in the screen on which the representation is displayed. This notably excludes 2D icons, which are not 3D modeled. The 3D modeled object represents the geometry of a product to be manufactured in the real world subsequent to the completion of its virtual design with for instance a CAD software solution or CAD system, such as a (e.g., mechanical) part or assembly of parts (or equivalently an assembly of parts, as the assembly of parts may be seen as a part itself from the point of view of the methods), or more generally any rigid body assembly (e.g., a mobile mechanism). A CAD software solution allows the design of products in various and unlimited industrial fields, including: aerospace, architecture, construction, consumer goods, high-tech devices, industrial equipment, transportation, marine, and/or offshore oil/gas production or transportation. The 3D modeled object may thus represent an industrial product which may be any mechanical part, such as a part of a terrestrial vehicle (including e.g., car and light truck equipment, racing cars, motorcycles, truck and motor equipment, trucks and buses, trains), a part of an aerial vehicle (including e.g., airframe equipment, aerospace equipment, propulsion equipment, defense products, airline equipment, space equipment), a part of a naval vehicle (including e.g., navy equipment, commercial ships, offshore equipment, yachts and workboats, marine equipment), a general mechanical part (including e.g., industrial manufacturing machinery, heavy mobile machinery or equipment, installed equipment, industrial equipment product, fabricated metal product, tire manufacturing product), an electro-mechanical or electronic part (including e.g., consumer electronics, security and/or control and/or instrumentation products, computing and communication equipment, semiconductors, medical devices and equipment), a consumer good (including e.g., furniture, home and garden products, leisure goods, fashion products, hard goods retailers' products, soft goods retailers' products), a packaging (including e.g., food and beverage and tobacco, beauty and personal care, household product packaging).

Any 3D modeled object herein may form a discrete geometrical representation of a 3D real-world object which is a mechanical part. The discrete geometrical representation is herein a data structure which comprises a discrete set of pieces of data. Each piece of data represents a respective geometrical entity positioned in a 3D space. Each geometrical entity represents a respective location of the 3D object (in other words, a respective portion of material constitutive of a solid represented by the 3D object). The aggregation (i.e., union or juxtaposition) of the geometrical entities represents altogether the 3D object. Any discrete geometrical representation herein may in examples comprise a number of such pieces of data higher than 100, 1000, or 10000.

Any discrete geometrical representation herein may for example be a 3D point cloud, each geometrical entity being a point. Any discrete geometrical representation herein may alternatively be a 3D mesh, each geometrical entity being a mesh tile or face. Any 3D mesh herein may be regular or irregular (i.e., consisting or not of faces of a same type). Any 3D mesh herein may be a polygonal mesh, for example a triangular mesh. Any 3D mesh herein may alternatively be a B-Rep. Any 3D mesh herein may be obtained from a 3D point cloud, for example by triangulating the 3D point cloud (e.g., with a Delaunay triangulation). Any 3D point cloud herein may be determined from physical measurements on a real object, for example within a 3D reconstruction process. The 3D reconstruction process may comprise providing the real object, providing one or more physical sensors each configured for acquiring a respective physical signal, and acquiring one or more respective physical signals by operating the one or more physical sensors on the real object (i.e., scanning the real object with each sensor). The 3D reconstruction may then automatically determine a 3D point cloud and/or a 3D mesh based on the measurements, according to any known technique. The one or more sensors may comprise a plurality of (e.g., RGB, and/or image or video) cameras and the determination may comprise a structure-from-motion analysis. The one or more sensors may alternatively or additionally comprise one or more depth sensors (e.g., on an RGB-depth camera) and the determination may comprise a 3D reconstruction from depth data. The one or more depth sensors may for example comprise a laser (e.g., a lidar) or an ultrasound emitter-receiver. Any discrete geometrical representation herein may alternatively be any type of CAD model.

Any 3D point cloud or 3D mesh herein may alternatively be obtained from a 3D modeled object representing a skin (i.e., outer surface) of a solid (e.g., corresponding to B-Rep model, which represents a skin, i.e., an exact surface), for example by ray-casting on the 3D modeled object or tessellating the 3D modeled object. The tessellating may be performed according to any 3D modeled object rendering process. Such a rendering process may be coded on any CAD system in order to display a graphical representation of the 3D modeled object. The 3D modeled object may be designed or have been designed by a user with a CAD system.

Any discrete geometrical representation herein may alternatively be a voxel representation. Voxel is a natural extension of pixels for 2D representations. Voxel is an image of a three-dimensional space region limited by given sizes, which has its own nodal point coordinates in an accepted coordinate system, its own form, its own state parameter that indicates its belonging to some modeled object, and has properties of modeled region.

Any 3D modeled object herein may alternatively be represented by an implicit representation, i.e., a representation by an implicit function, for example the signed distance function. An implicit function is a function defined over the 3D space where the 3D modeled object surface corresponds the isosurface of this function. That isosurface is a surface that represents points of a constant value (e.g., distance to the shape surface) within a volume of space. In other words, it is a level set of a function whose domain is a 3D-space.

The learning method then learns, based on the provided dataset of 3D modeled objects, a set of parameterization vectors and a neural network. The learning is now discussed.

The neural network is configured to take as input a parameterization vector and to output a representation of a 3D modeled object usable in a differentiable simulation-based shape optimization.

The neural network may be a decoding neural network (e.g., a decoder), configured to take as input the parameterization vector and to output the representation of the 3D modeled object. In such a case, the neural network provides a mapping between an input representation vector and a representation of a 3D modeled object usable in a differentiable simulation-based optimization (i.e., a representation that is usable in such an optimization). The decoding neural network is however not in this case configured to encode a 3D modeled object into a parameterization vector, but the neural network may be used to obtain the parameterization vector of the 3D modeled object, for example using an optimization based on the learnt neural network (e.g., by computing a Maximum A Posterior Estimation, as discussed hereinafter).

Alternatively, the neural network may be an autoencoder. The autoencoder comprises an encoder, configured to take as input a 3D modeled object and to output a parameterization vector of the 3D modeled object, i.e., to encode the 3D modeled object into a parameterization vector. The autoencoder further comprises a decoder, configured to take as input a parameterization vector and to output the 3D modeled object encoded by the parameterization vector, i.e., to decode the parameterization vector into the 3D modeled object. Thus, in this case, the neural network is both configured to take as input a 3D modeled object and to output a parameterization vector of the 3D modeled object, because it comprises the encoder, and configured to take as input a parameterization vector and to output a representation of a 3D modeled object the 3D modeled object usable in a differentiable simulation-based shape optimization, because it comprises the decoder. Furthermore, in this case, the set (resp. space) of parameterization vectors is implicitly learnt, through the learning of the encoder: the set (resp. the space) of parameterization vectors is the set (resp. the space) of vectors that the encoder is able to output after its learning. In this case, the neural network is the only output of the learning.

In any case, the neural network may be a deep neural network. The concept of Deep Neural Network is discussed in reference D. E. Rumelhart, G. E. Hinton, R. J. Williams, “Learning internal representations by error propagation”, Parallel distributed processing: explorations in the microstructure of cognition, vol. 1: foundations, MIT Press, Cambridge, Mass., 1986, which is incorporated herein by reference. Deep Neural Networks (DNNs) are a powerful set of techniques for learning in Neural Networks which is a biologically-inspired programming paradigm enabling a computer to learn from observational data. In object recognition, the success of DNNs is attributed to their ability to learn rich midlevel media representations as opposed to hand-designed low-level features (such as Zernike moments, HOG, Bag-of-Words, SIFT) used in other methods (such as min-cut, SVM, Boosting, Random Forest). More specifically, DNNs are focused on end-to-end learning based on raw data. In other words, they move away from feature engineering to a maximal extent possible, by accomplishing an end-to-end optimization starting with raw features and ending in labels.

The learning method learns a set of parameterization vectors each respective to a 3D modeled object of the training dataset. In other words, for each object of the training dataset, there is a parameterization vector. However, parameterization vectors of 3D modeled objects not belonging to the training dataset may still be obtained based on the learnt neural network at a later stage, for example during the optimization method. For example, for a 3D modeled object not belonging to the training dataset, a parameterization vector of the 3D modeled object may be obtained by a minimization (e.g., a Maximum A Posterior estimation) based on the learnt neural network, or, if the learnt neural network is an autoencoder, by applying the encoder to the 3D modeled object.

Each parameterization vector is a vector that encodes the geometry of the mechanical part represented by the corresponding respective 3D modeled object. The parameterization vector may for example encode the mechanical part's degrees of freedom that may be used to modify the shape of the mechanical part and/or any other geometrical and/or topological specification of the shape of the mechanical part. The parameterization vector may encode any number of degrees of freedom and may in particular encode a number allowing full control of the shape or, alternatively, a reduced number, for example to make shape modification more tractable or to enforce some structural constraints. The parameterization vector may be a latent vector, as known per se from the field of machine-learning. In any case, the space of the parameterization vectors has a dimension smaller than that of the space of the 3D modeled objects.

The learning further learns the neural network, which is, as previously explained, learnt to map the latent space to a space of representations of the 3D modeled object. A 3D modeled object may thus be modified by modifying its corresponding parameterization vector, which may then be mapped onto the space of the representations. For a given parameterization vector, respective to a 3D modeled object, the representation of the 3D modeled object, that the neural network is trained to output, is usable in a differentiable simulation-based shape optimization. The representation of the 3D modeled object may be any representation usable in the optimization, for example an explicit representation such as a discrete geometrical representation, or an implicit representation.

The differentiable simulation-based shape optimization is now further discussed. The following discussion on the shape optimization, the simulation and the simulator notably apply to the shape optimization, the simulation and the simulator involved in the optimization method, further discussed hereinafter.

The shape optimization, also referred to as “3D shape optimization” or simply “optimization”, designates the problem of finding the shape of a 3D modeled object representing a mechanical part which is an optimal shape in that the shape minimizes a certain cost function, which is a mapping from a vector space into a scalar set or space, while satisfying one or more physical constraints. The one or more constraints forms a condition of the optimization problem, that the solution must satisfy. The one or more constraints may comprise one or more of primarily equality constraints, inequality constraints, and/or integer constraints. Shape optimization methods and algorithms may be used to analyze and improve the designs of numerous successive configurations without any help from the engineer or designer.

The shape optimization is a simulation-based optimization, i.e., the optimization uses a simulation to verify whether a candidate optimum respects the constraints. In other words, respect or non-respect of the one or more constraints is assessed by the simulation. The simulation is a physical simulation, also referred to as “physics simulation”, which designates the simulation real-world physical behavior of the mechanical part based on a mathematical model of this behavior, the model modeling the state of the system at a given time. The physics simulation includes a set of one or more equations that describe how the behavior of the mechanical part evolves over time in a specific physical context, and a numerical method discretizing the set of one or more equations. Physics simulation is an engineering tool usually used in industrial design, to test manufacturing products before their actual manufacturing. For example, a simulation may be the simulation of a crash as an early step in crash testing. The physical simulation may belong to any field of physics. For example, the simulation may be one or more of a mechanical simulation, an optical simulation, and/or a thermal-dynamic simulation.

A mechanical simulation designates a simulation that simulates bodies (rigid or flexible) behavior and dynamics caused by different load conditions. Mechanical simulation is usually used to allow engineers to test, validate, and modify designs before they become a physical prototype. For instance, mechanical simulation may be used for analyzing vehicle performance in complex simulated driving environments (such as crash test or driver controls).

Optical simulation enables building optical systems by creating and placing various optical components in a physical space and simulates light propagation through the system. Example optical simulations range from optical part design such as lamps, mirrors and dashboard in the automotive industry, indoor/outdoor lighting, or cockpit analysis in the aircraft industry.

Thermodynamic simulation designates the calculation of the temporal evolution of the thermal state of a system (e.g., a mechanical part) using a numerical model of the system, which may include the temperature at a certain number of points of the elements composing the system, which evolve according to the different laws governing heat exchanges. A typical example is simulating an automotive air conditioning system by calculating the thermodynamic behavior of the whole process including the refrigeration system and passenger compartment.

The simulation uses a simulator, which is a function performing the simulation. The simulator includes the numerical method(s) and algorithm(s) that constitute the simulation. The simulator thus outputs result of the simulation. The simulation is differentiable, which means that the simulation is a differentiable function. This allows to use gradient-based numerical methods in the optimization, i.e., the optimization may implement any suitable gradient-based optimization method, such as a gradient descent algorithm. The use of a differentiable simulator notably allows backpropagation of the simulation gradient in the candidate parameterization vector during the optimization. Differentiable simulations are discussed in Yuanming Hu et al. “DiffTaichi: Differentiable Programming for Physical Simulation”, in ICLR (2020), which is incorporated herein by reference.

The representation of a 3D modeled object that the neural network is trained to output is usable in the optimization, i.e., the representation is usable by the simulator. This does however not exclude the optimization to include a step of changing the representation into another type of representation for the purpose of the simulation. In other words, the representation may be directly usable in the simulator, or a pre-processing of the representation may be required.

The representation may be an implicit representation. The implicit representation is, as previously said, a representation of the corresponding 3D modeled object by an implicit function, defined over the 3D space where the 3D modeled object surface corresponds the isosurface of this function. That isosurface is a surface that represents points of a constant value (e.g., distance to the shape surface) within a volume of space. In other words, it is a level set of a function whose domain is a 3D-space. The implicit representation may be a signed distance field representation, i.e., the implicit function being in this case a continuous function that attributes to each point of the 3D space a signed distance to the boundary of the 3D modeled object, the signed distance being positive when the point is outside the object and negative when the point is inside. The signed distance field representation is known per se. The implicit representation allows an improved adaptability to the 3D resolution of the corresponding modeled object: the 3D resolution of the 3D modeled object represented by an input parameterization vector then decoded into the implicit representation of the 3D modeled object will be, or at least tend to be, preserved during the optimization without any further burden on the computer. The implicit representation is thus a representation that allows the optimization to manipulate 3D modeled objects with any kind of resolution. The signed distance field representation allows particularly high 3D resolutions, as the 3D modeled objects can be sampled at any resolution with this representation, using for example the 0-isosurface extraction algorithm discloses in William E. Lorensen and Harvey E. Cline, “Marching Cubes: A High Resolution 3D Surface Construction Algorithm”, in Proceedings of the 14th Annual Conference on Computer Graphics and Interactive Techniques. SIGGRAPH ′87, New York, N.Y., USA, which is incorporated herein by reference. Furthermore, the signed distance field representation allows to compute the normal to the surface, which may be used during the optimization for gradient computation. The representation may alternatively be an explicit representation, such as a discrete geometrical representation.

The representation is a representation of the geometry of the 3D modeled object. For example, the signed distance field representation captures the geometry of the 3D modeled object using a signed distance to its boundary. The representation may further represent the one or more physical attributes of the 3D modeled object, when the 3D modeled object includes these one or more attributes.

The learning comprises minimizing a loss. The loss penalizes, for each 3D modeled object of the dataset, a disparity between the output of the neural network for an input parameterization vector respective to the 3D modeled object and a representation of the 3D modeled object usable in a differentiable simulation-based shape optimization. The loss may be loss suitable for this training. The loss penalizes a disparity between the output of the neural network for an input candidate parameterization vector (i.e., a candidate of the optimization, a free-variable of the optimization), this output forming a candidate representation of the 3D modeled object represented by the candidate parameterization vector, and the true representation of the 3D modeled object usable in a differentiable simulation-based shape optimization (e.g., its signed distance field). In other words, the candidate parameterization vector and the weights of the neural network are the free-variables of the minimization, which modifies them as long as the value of the loss is too high, e.g., with respect to a convergence criterion. A high value of the loss means that there is a too high disparity between the candidate representation, which is the candidate output of the neural network and thus represents a candidate set of weights, and the exact representation. For example, the loss may be an increasing function of a distance between the candidate output and the exact representation. For example, the loss may be a reconstruction loss, the concept of reconstruction loss being known per se from the field of machine-learning. The loss may be referred to as “the learning loss”.

As previously explained, when the neural network is an autoencoder, the candidate parameterization vector is an output of the encoder, so that in this case, the candidate parameterization vector corresponds to a candidates set of weights of the encoder. In this case the weights of the encoder and the weights of the decoder are modified during the minimization, the modification of the encoder weights indirectly modifying the candidate parameterization vector. In the case where the neural network is a decoding neural network, the candidate parameterization vector is directly a variable of the minimization and is directly modified during the minimization.

An implementation of the learning method is now discussed. This implementation may form the offline stage of the process of which flowchart is shown on FIG. 1.

Given the provided set of 3D modeled object, noted custom-character , this implementation automatically finds a low dimensional space that allows the parametrization of this set. Specifically, this implementation sets a number of shape's degrees of freedom D and learns the neural network, which is a DNN decoder Φ, to find the optimal D-dimensional parametrization space and the optimal Φ weights such that each 3D modeled object from custom-character can be obtained by decoding its associated learned parametrization vector using Φ.

The output of the decoder in this implementation is the Signed Distance Field representation, which uses a Signed Distance Function (SDF) belonging to the field of implicit representations of 3D shapes. The SDF function is a function ƒ_SDF:p=(x,y,z) ∈ custom-character ³→s ∈ that attributes to each point (x,y,z) its signed distance s to the boundary of the 3D modeled object. The signed distance is positive outside of the object and negative inside by convention. Thus, the SDF is zero on the object's boundary. The main upside of this representation is that the object can be sampled at any resolution if the SDF is represented by a continuous function by extracting the 0-isosruface using algorithms such as the one discussed in previously-cited reference William E. Lorensen and Harvey E. Cline, “Marching Cubes: A High Resolution 3D Surface Construction Algorithm”, in Proceedings of the 14th Annual Conference on Computer Graphics and Interactive Techniques. SIGGRAPH ‘87, New York, N.Y., USA. Therefore, in the implementation example, 3D objects are characterized with a geometric representation.

As the provided set of 3D SDF shapes custom-character , this implementation uses a set of 4000 3 D CAD objects, each representing a mechanical part, from which this implementation generated their SDF values formulated for each shape O ∈ as a set of 3D points p_ialong with their signed distance to the shape surface s_i:

O={(p_i,s_i);p_i∈G_O}

where G_Ois a set of regularly distributed coordinates in [—1; 1] (this is true because it is considered that shapes' geometries are centered and normalized within [−1,1]^∧3. Also, G_Omay be the same or different for the different O shapes and has a size that depends on the desired accuracy). Let G_Rbe the grid of regularly spaced coordinates in [—1; 1] of resolution R. O is referred to as a SDF shape. This representation may be obtained using libraries such as mesh-to-sdf (https://pypi.org/project/mesh-to-sdf/) from other geometries such as meshes, or voxels.

In this implementation, the neural network is DNN decoder Φ: this implementation uses an auto-decoder architecture similar to the architecture described in Jeong Joon Park et al., “DeepSDF: Learning Continuous Signed Distance Functions for Shape Representation”, in The IEEE Conference on Computer Vision and Pattern Recognition (CVPR), June 2019, which is incorporated herein by reference. Φ learns a continuous SDF representation of a class of shapes. Specifically, Φ learns to map a D-dimensional space ν={ν_i}_i⊂ custom-character ^Dto shapes in ={O_i}_i. As such, for each O={(p_i,s_i);p_i∈ G_O} ∈ , this implementation learns Φ and ν_i∈ ^Dsuch that

Φ(ν_i,p_j)=s_j;∀p_j∈G_O

The training loss in this implementation may be of the type:

$Φ, {v_{i}}_{i} = \underset{\tilde{Φ}, {v_{i}^{'}}_{i}}{\arg \min} \sum_{O_{i} \in ℳ} (\sum_{p_{j} \in G_{o}} { \tilde{Φ} (v_{i}^{'}, p_{j}) - s_{j} }_{2}^{2} + \frac{1}{σ^{2}} { v_{i}^{'} }_{2}^{2})$

where D=256 and σ=0.01 in the implementation.

After the training phase, the outcome is a trained decoder Φ and deep parametrization space custom-character such that for a given shape O represented by its SDF values (that do not necessarily belong to ), there exists a D-dimensional vector ν ∈ such that Φ(v,G_R)=O.

The optimization method is now further discussed.

The optimization method performs the differentiable simulation-based shape optimization. The optimization method comprises providing: a 3D modeled object representing a mechanical part, one or more physical constraints on the 3D modeled object, and a differentiable simulator. The differentiable simulator is the simulator performing the simulation on which the optimization is based, taking as input a representation of a 3D modeled object and outputting a value representing an extent to which the 3D modeled object respects the one or more physical constraints. The provided 3D modeled object is the input of the optimization, which is to optimize the shape of the 3D modeled object, representing the shape of the mechanical part, with respect to the one or more physical constraints. The one or more physical constraints form constraints of the optimization. The simulator is based on the geometry of its input 3D modeled object. It may also be based on a specification of one or more physical attributes of the input 3D modeled object. The input 3D modeled object, notably if it is a representation outputted by the neural network and if the objects of the training set of the neural network includes such a specification, may include the specification. If not, the simulator may compute the one or more physical attributes based on the geometry of the input.

The optimization method then comprises performing the shape optimization of the mechanical part, the shape optimization being simulation-based, i.e., being based on the provided differentiable simulator. The simulator is used by the optimization to quantify respect or non-respect of the constraints, i.e., during the optimization, respect or non-respect of the one or more physical constraints for a candidate parameterization vector is assessed using the simulator. The value outputted by the simulator evaluates the respect or non-respect of the constraints by its input.

The optimization minimizes a loss which penalizes a disparity between the value outputted by the simulator for the representation outputted by the neural network for a candidate parameterization vector (i.e., a candidate of the optimization, the parameterization vector being the free-variable of the optimization) and the optimal output of the simulator. In other words, the loss quantifies a disparity between the value representing an optimal extent to which the one or more constraints are respected (i.e., the optimal output of the simulator), and a value that represents an extent to which a candidate parameterization vector respects the constraints (i.e., the value outputted by the simulator for the output of the neural network for the candidate parameterization vector). A high value of the loss thereby means that the disparity is too high, so that the candidate parameterization vector, which represents the shape of the mechanical part to be optimized, is not optimal yet with respect to the constraints, so that another candidate vector is to be found. The minimization of the loss thereby ensures that the optimal parameterization vector (i.e., the output/result of the optimization) tends to respect the one or more physical constraints. The loss may be referred to as “the optimization loss”.

The optimization thus comprises simulation steps, where for candidate parameterization vectors, the simulator is applied to the representation outputted by the neural network for these parameterization vectors. The representation may be implicit or explicit, and the simulator may take as input explicit representations.

Specifically:

- the output of the neural network may be an explicit representation of the 3D modeled object parameterized by the candidate parameterization vector and the simulator may take as input an explicit representation of a 3D modeled object; or
- the output of the neural network may be an implicit representation of the 3D modeled object parameterized by the candidate parameterization vector and the simulator may take as input an explicit representation of a 3D modeled object. In this case, the performing of the simulation-based shape optimization comprising transforming (i.e., for each candidate representation vector fed as input to the loss) the implicit representation of the 3D modeled object (i.e., parameterized by the parameterization vector fed as input to the neural network) into an explicit representation.

The transforming may consist in any method for transforming an implicit representation into an explicit representation. The transforming may notably comprise extracting surface points of the 3D modeled object based on its implicit representation, for example by evaluating the implicit function on a grid of regularly spaced coordinate, sampling the points closest to the surface, and projecting them onto, thereby yielding a surface point cloud which is the explicit representation.

The loss may further penalize a disparity between a 3D modeled object parameterized by the candidate parameterization vector and the provided 3D modeled object. This allows to constraint the being-optimized parameterization vector to remain as close as possible to the input 3D modeled object while respecting the one or more physical constraints. In other words, the optimization tends to optimize the shape of the mechanical part with respects to the one or more constraints but without modifying, as far as possible, the initial shape of the mechanical part to a large extent.

The disparity between the 3D modeled object parameterized by the candidate parameterization vector and the 3D modeled object may comprise a disparity between the candidate parameterization vector and a parameterization vector of the provided 3D modeled object. The parameterization vector of the provided 3D model object is obtained from the 3D modeled object. The optimization method may thus comprise a step of obtaining this parameterization vector. This step may comprise applying an encoder of the neural network to the 3D modeled object, when the neural network is an autoencoder. Alternatively, when the neural network is a decoding neural network as previously discussed, this step may comprise extracting the parameterization vector by an optimization performed on the learnt neural network, e.g., by computing a Maximum-a-Posterior (MAP) estimation as follows:

$v = \arg \min_{ν^{'}} \sum_{(p_{j}, s_{j}) \in O} { Φ (v^{'}, p_{j}) - s_{j} }_{2}^{2} + \frac{1}{σ^{2}} { v^{'} }_{2}^{2},$

where ν is the parameterization vector, where Φ(ν′,p_j) is the output of the neural network for a candidate vector ν′ of the optimization, where O is the provided 3D modeled object, where (p₁,s₁) ∈ O represents samples of the representation of O. The term

$\frac{1}{σ^{2}} { v^{'} }_{2}^{2}$

is optional and may be absent from the formula.

This disparity allows to prevent, as far as possible, the optimized mechanical part to have a shape departing from its initial shape in a too large extend, by controlling the shape modification using the parameterization vector. Additionally or alternatively, the disparity between the 3D modeled object parameterized by the candidate parameterization vector and the 3D modeled object may comprise a disparity between the output of the neural network for the candidate parameterization vector and a representation of the provided 3D modeled object. This allows to prevent, as far as possible, the optimized mechanical part to have a shape departing from its initial shape in a too large extend, by controlling the shape modification using the representation of the 3D modeled object representing the mechanical part. The optimization method may thus contemplate two different disparities for avoiding, as far as possible, shape modification in a too large extent. Using both disparities improves robustness.

The loss may be of the type:

custom-character (ΨOΦ(ν′_R),ƒ_opt)+α(ν,ν′)+βd_s(Φ(ν′,_R),O),

where Φ(ν′, custom-character _R) is the output of the neural network 4) for the candidate parameterization vector ν′, Ψ is the simulator, ƒ_optis the optimal output of the simulation with respect to the one or more physical constraints, ν is the parameterization vector of the provided 3D modeled object, O=Φ(ν, custom-character _R) is the representation of the provided 3D modeled object, d_sare distances, and a and β are coefficients of the loss.

The optimization method may comprise, prior to the minimization of the loss, a step of extracting a parameterization vector of the provided 3D modeled object. The extraction may comprise a selection of the parameterization vector based on the learnt neural network. For example, if the learnt neural network is an autoencoder, the extracting may comprise applying the encoder to the provided 3D modeled object to obtain its parameterization vector. If the learnt neural network is a decoding neural network, the extracting may comprise finding the parameterization vector with an optimization based on the learnt decoding neural network, the optimization including for example computing a Maximum-A-Posterior (MAP) estimation.

When the output of the neural network for an input candidate parameterization vector is an implicit representation of the 3D modeled object parametrized the input parameterization vector, the implicit representation being a signed distance field, and the simulator takes as input an explicit representation of a 3D modeled object, the distance d_smay be of the type:

d
_sΦ(ν₁, custom-character _R),Φ(ν₂,_R))=BCE(B^σ(ν₂),(ν₁)),

where for i=1, 2, ν_iis a parameterization vector, Φ(ν_i, custom-character _R) is the output of the neural network for the parameterization vector ν_i, Φ being the neural network, where

custom-character (ν)={_Φ(ν,x)<0;x∈_R},

B
^σ(ν)={σ(ηΦ(ν,x));x∈ custom-character _R},

η being a negative real number, custom-character and σ being respectively the indicator and the sigmoid functions, _Rbeing a grid of regularly spaced coordinates, and where BCE is a binary cross entropy distance between two sets X and with size n such as ∀x ∈ X ∪ , x ∈ [0, 1] and is given by the formula

$BCE (𝒳, 𝒴) = \frac{1}{n} \sum_{i = 1}^{n} y_{i} \log (x_{i}) + (1 - y_{i}) \log (1 - x_{i}),$

where the x_iare the points of X and where the y_iare the points of custom-character .

An implementation of the optimization method is now discussed. This implementation may form the online stage of the process of which flowchart is shown on FIG. 1. This implementation contemplates a dropping simulation and an optimization of the physical stability of a mechanical part. It is to be understood that this particular simulation and this particular optimization only form an example which illustrates the implementation. Other examples of simulations and optimization problems may be contemplated by the optimization.

Industrial 3D shapes are often expected to satisfy a particular behavior in the physical world as rotational dynamics, fluid dynamics or resistance to external force load to name few. This behavior may be quantified using physical simulation tools that evaluates within a relevant context to which extent the simulated 3D shape meets the expected physical behavior. This evaluation relies on comparing the physical simulation output formulated for instance as a 3D trajectory, volume deformation, or heat distribution, to an optimal physical simulation output usually fixed by Terms of Service for industrial shapes.

This implementation belongs within this context. Given a 3D modeled object O that represents a mechanical part that violates a pre-defined physical behavior, this implementation carries out an optimization schema that outputs another 3D modeled object O_optverifying the said physical behavior while remaining similar to the original modeled object O.

This implementation shifts this simulation-based physical optimization problem from the space of 3D modeled object into a lower dimensional space automatically learned. Therefore, the former formulation may be equivalently written by replacing O by ν such that Φ(ν,G_R)=O. Besides making the problem more computationally tractable since this implementation simplifies the search space while obeying exact simulation constraint, it also yields advantages related to preserving shape structure, as further explained hereinafter.

This implementation adopts the modeling that the physical behavior of object O is quantified by a value ƒ ∈ custom-character . ƒ may be multi-dimensional, and in such cases, it suffices to apply an aggregation formula to ƒ such as Euclidean norm to obtain a scalar). Let ƒ_opt∈ be the target (optimal) physical behavior value that O is to achieve, and let Ψ be the physical simulator, so Ψ(O)=ƒ. Consequently, the optimization problem may be expressed as finding ν_optsuch that:

ν_opt=argmin_ν, custom-character (Ψ_OΦ(ν′)ƒ_opt)+α(ν,ν′)+βd_s(O,Φ(ν′))

where custom-character and are distance functions in and ^Drespectively (Euclidean distance for instance) and d_sis a distance function in the spatial space that measures the similarity between the spatial layout of two 3D modeled objects. d_sdepends on the 3D shape representation. α and β are two weighting positive scalar coefficient, that are for example determined by the user. While the last two terms of the objective function promote the similarity to the input modeled object O, the first one encourages shape variations that enforce the respect of the target physical behavior quantified by ƒ_opt.

The implementation extracts a parametrization vector ν for the provided 3D modeled object O by computing a Maximum-a-Posterior (MAP) estimation as follows:

$v = \arg \min_{v^{'}} \sum_{(p_{j}, s_{j}) \in O} { Φ (v^{'}, p_{j}) - s_{j} }_{2}^{2} + \frac{1}{σ^{2}} { v^{'} }_{2}^{2} .$

This formulation is valid for SDF shapes O of arbitrary size and distribution because the gradient of the loss with respect to ν may be computed separately for each SDF sample (p_j,s_j). This implies that Φ may handle any form or sampling of SDF values. Note that SDF shapes may be obtained from any representation such as mesh, voxel.

This makes the implementation generalizable to any input representation.

This implementation uses a simulator, also referred to as “physical simulation module”, Ψ that takes as input an SDF representation of a 3D modeled object O and produces its physical behavior value ƒ: Ψ(O)=ƒ. As illustrated on FIG. 2, showing a schematic representation of the simulator, Ψ consists of two steps (1) Extract surface points: the implementation identifies the shape surface of O to enable physical assessment of O and (2) Dropping simulation simulates the physical behavior of O represented by its surface points and returns the loss function value is to be minimized (the difference between ƒ and ƒ_opt).

The Extract surface point step proceeds as follows. As stated earlier, Ψ produces shapes represented as signed distance field SDF formulated by a function that attributes to each three dimensional point its signed distance to the surface, where this distance is positive if the point is outside the shape surface and negative otherwise. Φ is a differentiable function of the type:

Φ:(ν;x)∈ custom-character ^D×³s∈

with ν the parametrization vector, x the point coordinates and s the signed distance to the surface of the object. Let ∇Φ_ν:^D*→^Dand ∇Φ_x:³→³be its gradients with respect to the parametrization vector ν and the point coordinates x.

The extracting according to this implementation obtains a point cloud of the surface of the object, by evaluating Φ on the grid of regularly spaced coordinates G_Rof size R. The resulting set of grid coordinates is noted:

G
_R
={x
₁
; . . . ;x
_R
₃}.

To obtain the point cloud of the surface, this implementation evaluates the signed distance of all points in G_R. Let:

S(ν)={s₁; . . . ;s_R₃}={Φ(ν;x₁); . . . ;Φ(ν,x_R₃)},

be the resulting signed distances. Using the grid of signed distances, this implementation samples the points closest to the surface in order to obtain the surface point cloud.

In this approach, the gradient ∇Φ_xis leveraged to project the points near the surface onto it. The sampled point cloud may be written as:

$C (v) = {x - Φ (v, x) \frac{\nabla Φ_{x} (v, x)}{ \nabla Φ_{x} (v, x) }; ❘ Φ (v, x) ❘ < s_{\max}, x \in G_{R}} with s_{\max} = \frac{\sqrt{3}}{2 R} .$

The idea here is quite simple: since the distance and the direction to the surface from any point in space are known thanks to Φ being differentiable with respect to x, this implementation has everything needed to adjust the point coordinates towards the object's surface.

The dropping simulation proceeds as follows. It implements a physical simulation process, based on: a description of shapes and their variations (e.g., as sets of parameters or density functions), a physical simulation algorithm, for instance based on PDE (e.g., the linear elasticity equations or Stokes system), for describing the mechanical behavior of mechanical parts, and a numerical description of physical behavior (e.g., the part volume or position).

3D modeled objects, that represent mechanical parts, are described by their surface points extracted as previously explained. 100 points are sampled for the simulation using farthest point sampling. They may vary in the 3D space.

The physical simulation model is designed to quantify the physical stability of the 3D shape. Note that physical stability depends on the geometric representation learned by the deep decoder D. To this end, this implementation implements a rigid body dynamics model that simulates the dropping of the 3D shape when subjected to gravity and to trivial perturbation forces. The model may be implemented using the framework of previously-cited reference Yuanming Hu et al, “DiffTaichi: Differentiable Programming for Physical Simulation”, in ICLR (2020).

According to Euler's First Law, the sum of the external forces F on a system of particles (or rigid body) equals the sum of mass and acceleration of all its particles. As such, if x is the center of mass of the system, and m its total mass, then:

$F = m \frac{d^{2} x}{{dt}^{2}} .$

In addition, Euler's Second Law specifies the rotational dynamics of a rigid body. With L the angular momentum and τ the torques applied to the object, then:

$τ = \frac{dL (t)}{dt}$

such that L=I(t)ω(t) with I(t) the inertia matrix and ω(t) the angular velocity at time t.

In order to simulate the linear and rotation dynamics of a rigid object, this implementation the numerical integration approach described in references David Baraff, “An Introduction to Physically Based Modeling (I)”, en, in SIGGRAPH, (1997), p. 32, and David Baraff, “An Introduction to Physically Based Modeling (II)”, en, in SIGGRAPH (1997), p. 38, which are both incorporated herein by reference, this approach being based on the first order Euler algorithm discussed in Kendall E Atkinson, “An Introduction to Numerical Analysis”, John Wiley & sons, 2008, which is incorporated herein by reference.

For any simulation time step t ∈ {0, 1, . . . T}, the system of mass m is described by the following variables:
x_t∈ ³: position of the center of mass
ν_t∈ ³: velocity of the center of mass
R_t∈ ^3×3: rotation matrix
I_t∈ ^3×3: inertia matrix
L_t∈ ³: angular momentum
ω_t∈ ³: rotational velocity
q_t∈ ⁴: quaternion representing the object's orientation more efficiently.

Indeed, since the quaternion is on the unit sphere, it can be normalized throughout the simulation, which prevent numerical drift as discussed in previously-cited references David Baraff, “An Introduction to Physically Based Modeling (I)”, en, in SIGGRAPH, (1997), p. 32, and David Baraff, “An Introduction to Physically Based Modeling (II)”, en, in SIGGRAPH (1997), p. 38.

Furthermore, the resultants of all forces and torques applied to the system are respectively noted F_tand τ_tfor each simulation time step t.

This implementation also computes three physical properties of the object that will allow to simulate its dynamics: mass, center of mass and matrix of inertia; Ψ(ν)=(m, G, I₀. All three items are computed from a point cloud sampled inside the object, noted:

_inside(Z)={x∈G_R;Φ(ν,x)<0}

Let n_inbe the size of _inside(z) and m_pthe mass of a single point of the grid G_R. According to previously-cited references David Baraff, “An Introduction to Physically Based Modeling (I)”, en, in SIGGRAPH, (1997), p. 32, and David Baraff, “An Introduction to Physically Based Modeling (II)”, en, in SIGGRAPH (1997), p. 38,

$m = n_{in} m_{p} G = \frac{1}{n_{in}} \sum_{x \in 𝒞_{inside} (z)} x I_{0} = m_{p} [r (x) {r (x)}^{T} 3 \times 3 - {r (x)}^{T} r (x)]$

with r (x)=x−G ∈ ^1×3and _3×3the identity matrix.

Supposing the initial state of all variables known, the numerical integration of Euler's laws yields the algorithm described in previously-cited reference “An Introduction to Numerical Analysis”, John Wiley & sons, 2008.

To account for contacts between the object and its environment or other objects, a contact model is used. Contact models may be divided into two families: colliding contact and resting contact. Colliding contact occurs when two bodies are in contact at some point p and with a non-zero relative velocity towards each other. Resting contact is the opposite: the two bodies are in contact but without velocity.

The impulse-based approach described in previously-cited references David Baraff, “An Introduction to Physically Based Modeling (I)”, en, in SIGGRAPH, (1997), p. 32, and David Baraff, “An Introduction to Physically Based Modeling (II)”, en, in SIGGRAPH (1997), p. 38, is used as contact model. This implementation focuses on contacts between a rigid body and a plane (floor for example), but could be extended to contacts with other rigid bodies with a simple geometry. To model resting contact, this implementation proceeds with computing the resulting impulse at each contact point. To this end, information about all the other contact points in order to balance the object is used. As such, all impulses have to be determined at the same time. Consequently, this type of contact cannot leverage parallel computations. For this reason, this implementation approximates it as in the examples provided in the Taichi repository (to be found on https://github.com/yuanming-hu/difftaichi) by assuming a colliding contact at each contact point and computing the resulting impulse as the average of all impulses.

The first step is to detect when a collision occurs between the floor and the object. A contact point at time t is noted _t⊂ of size . The floor is a plane described by its normal {circumflex over (n)} (oriented upwards by convention) and an offset c.

For any point p ∈ _tits signed distance to the plane may be computed as:

(p)={circumflex over (n)}·p−c

A collision occurs with at point p of the object whenever <0. Let _tbe the set of contact points at time t.

In practice, collisions are detected with an approximation of the point coordinates at time t+1, noted

={p∈_t(p+νpΔt)<0}

with ν_pthe velocity of point p at time t.

When a collision is detected, an instantaneous change in velocity is required. To do so, a new quantity J called an impulse is used. Applying an impulse to an object produces an instantaneous change in the velocity of the body. In the end, the contact point p ∈ induces an impulse J_p, defined as:

J
_p
=i
_normal
{circumflex over (n)}+j
_tangent
{circumflex over (t)}

computed as described in previously-cited references David Baraff, “An Introduction to Physically Based Modeling (I)”, en, in SIGGRAPH, (1997), p. 32, and David Baraff, “An Introduction to Physically Based Modeling (II)”, en, in SIGGRAPH (1997), p. 38. Consequently, the object is subject to a global impulse J_tand torque τ_t^jat time t such that:

$J_{t} = \frac{J_{p}}{\max (1, #)} τ_{t}^{J} = \frac{(p - x_{M}) \times J_{p}}{\max (1, #)}$

The simulation algorithm is described by Algorithm 1 below:

Algorithm 1 First order numerical integration of Euler’s laws

with constraints

Require: x₀, n₀, L₀, I₀, ω₀, q₀, R₀

for t ← 1 to T do

procedure COLLISION HANDLING

for p ∈₊₁do

J_p← j_normal(p) n + {dot over (j)}_tangent(p) {circumflex over (t)}

end for

$\begin{matrix} J_{t} \leftarrow \frac{\sum_{p \in, {\overset{⌣}{A}}_{j + i}} J_{p}}{\max (1, # \overset{⌣}{A} ?)} \\ 𝒯_{i}^{j} \leftarrow \frac{\sum_{p \in, {\overset{⌣}{A}}_{j + i}} (p - x_{M}) \times J_{p}}{\max (1, # \overset{⌣}{A} ?)} \end{matrix} $

end procedure

procedure LINEAR DYNAMICS

$n_{i} \leftarrow n_{i - 1} + \frac{1}{m} (Δ t F_{i} + J_{t})$

x_t← x_t−1+ Δt v_t

end procedure

procedure ROTATIONAL DYNAMICS

L_i← L_i−1+ Δt (n + r_i^t)

l_t⁻¹← R_i−1I₀⁻¹R_t−1

ω_t← I_i⁻¹L_t

$q ? \leftarrow q_{t - 1} + \frac{Δ t}{2} < q_{i - 1}, [0, ω_{t}] >_{quat}$

$q_{t} \leftarrow \frac{q ?}{ q ? }$

R_i← quat2rot(q_i)

end procedure

end for

indicates data missing or illegible when filed

The symbol . . . _quatdenotes the quaternion multiplication. A quaternion q=s+ν_xi+ν_yj+ν_zk can be noted as the pair [s, ν], with s ∈ and ν ∈ ³.

The quaternion multiplication is defined as:

[s₁,ν₁],[s₂,ν₂]_quat=[s₁s₂−ν₁·ν₂,s₁ν₂+ν₁×ν₂]

with x denoting the cross product between two 3D vectors. The routine quat2rot transforms the quaternion representation to a rotation matrix.

FIG. 3 shows an illustration of two dropping simulation: unstable shape (top and bottom rows) and stable shape (middle row).

The rotation matrix is used to determine how upright the object is at the end of the dropping simulation. For all t ∈ {0, . . . , T}, the rotation matrix is noted:

$R_{t} = [\begin{matrix} r_{0, 0}^{t} & r_{0, 1}^{t} & r_{0, 2}^{t} \\ r_{1, 0}^{t} & r_{1, 1}^{t} & r_{1, 2}^{t} \\ r_{2, 0}^{t} & r_{2, 1}^{t} & r_{2, 2}^{t} \end{matrix}]$

with r_ij^t∈ [−1, 1], ∀(i, j) ∈ {0, 1, 2}².

At the initial state (without initial orientation),

$R_{0} = [\begin{matrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 0 & 1 \end{matrix}]$

Since the object is to be in an upright position at the end of the simulation, the physical behavior quantity ƒ for stability assessment is:

ƒ_stability(Ψ)=1−r_2,2^T

with the initial surface point cloud and ψ=(m, G, I_O) the object properties (mass, center of mass, inertia matrix).

The optimization problem is, as previously discussed,

ν_opt=argmin_ν,(Ψ_OΦ(ν′,_R),ƒ_opt)+α(ν,ν′)+βd_s(Φ(ν′,_R),O)

d_sis the distance between Φ(ν,_R) and Φ(ν′,_R) is defined as follows:

d
_s(Φ(ν,_R)Φ(ν′,_R))=BCE(B^σ(ν₂),(ν₁))

with (ν) and B^σ (ν) are function defined as the following:

(ν)={_Φ(ν,x)<0;x∈_R}

B
^σ(ν)={σ(ηΦ(ν,x));x∈_R},η=−1000

where and σ are respectively the indicator and the sigmoid functions.

The binary cross-entropy BCE between two sets X and with size n such as ∀ x ∈ X ∪ , x ∈ [0, 1] is defined as:

$BCE (𝒳, 𝒴) = \frac{1}{n} \sum_{i = 1}^{n} y_{i} \log (x_{i}) + (1 - y_{i}) \log (1 - x_{i}) .$

This distance is commonly used to train deep learning models and is differentiable. The value of η is chosen manually to offer the desired result.

ΨOΦ is also differentiable with respect to ν since both functions Ψ and Φ are differentiable. Now it remains to compute ∇_νΨ_OΦ so that ν_optcan be obtained using classical gradient-based optimization approaches.

Since the simulation model is differentiable, ƒ_stabilityis well defined. ∇_νƒ_stabilityis defined as follows:

$\nabla_{v} f_{stability} = \frac{\partial f_{stability}}{\partial v} = \frac{\partial f_{stability}}{\partial SDF} \frac{\partial SDF}{\partial v} = \frac{\partial f_{stability}}{\partial SDF} \nabla_{v} Φ$

∇_νΦ is well defined since Φ is a DNN. Only

$\frac{\partial f_{stability}}{\partial SDF}$

is to be computed.

Computing

$\frac{\partial f_{stability}}{\partial SDF}$

boils down to estimating now SDF should be modified to shift the ƒ_stabilityvalue in the optimal direction (minimize ƒ_stabilityin the present case since the shape is to be stabilized). Thereby, from now on this quantity is written

δSDF.

The set of surface points may be written as:

={p₁, . . . ,p_n_c},p_i∈³

with the size of the surface point cloud . The corresponding functional gradient may also be written as:

ƒ_stability(,ψ)={g₁. . . }p_i∈³.

The functional gradient yields information about how the coordinates of each point of the surface should change so as to increase or decrease the functional score.

To know how the SDF values of the surface points should change accordingly, i.e., to know δSDF, the gradients ∇ϕ(z, x) are used:

(z)={∇ϕ(z,x)=[∇_zϕ(z,x),∇_xϕ(z,x)];x∈_R}.

The change of SDF values at any point of the grid x ∈ _Ris:

δ_SDF(x)=−∇_xϕ(ν,x),g(x)∈.

FIG. 4 illustrates the concepts of surface point cloud C_regular(z) (illustrated by crosses, for example cross 400), SDF gradients ∇_xϕ (illustrated by arrows 40, 42 and 44), functional gradients ƒ_stability. (illustrated by arrows 46, 48 and 50). FIG. 4 illustrates the SDF and simulation gradients that are used to compute the previously-discussed change of SDF values at any point. For the sake of understandability, the illustration of FIG. 4 features a surface point cloud obtained with regular sampling. However, the same expression applies for projected sampling (projecting point near the surface onto the surface as previously discussed). For the surface to move in the direction indicated by the functional gradients (green), the SDF values of active points should change according to the equation describingδ_SDF(the SDF values of all active points should decrease).

Finally, ν_optmay be estimated by solving the optimization problem (i.e., minimizing the optimization loss) using a gradient-based approach, for example the gradient descent algorithm.

As previously explained, the process of which flowchart is shown on FIG. 1 may comprise, as the offline stage, the previously-discussed implementation of the learning method, and as the online stage, the previously-discussed implementation of the optimization method.

The offline stage aims at training a deep decoder using a set of 3D objects. It consists of a DNN-based model. 3D objects are characterized with one or more geometry representations and/or attributes. The deep decoder learns a parametrization (latent) vectors and a mapping function that maps the parametrization vectors to the 3D object characterization space.

The online stage, given a 3D shape to optimize with respect to a physical simulation constraint, proceeds with the following steps:

1) Identify the input parametrization vector that produces the input shape when decoded using the deep decoder.

2) Implement the physical simulation constraint. The physical simulation constraint depends on the 3D objects characterization geometry representations and/or attributes given to learn the deep decoder at the offline stage. In other words, to meet the physical simulation constraint, it is sufficient to modify the provided characterization geometry representations and/or attributes.

3) Optimize the input parametrization vector into an output parametrization one that produces a corrected version.

The process illustrated by FIG. 1 thus proposes a learning-based parametrization of a class of complex 3D shapes for the task of 3D shape optimization through physical simulation. This process offers the following:
simulation-based 3D shape optimization using an automatically learned parametrization from a set of 3D objects is performed;
allowing an automatic (learned) low dimensional parametrization of complex shapes;
guaranteeing relevant object variations with respect to real world objects to meet the simulation-based constraint. This is due to the fact that the search space is shifted to the learned parametrization space that embeds knowledge about the object category;
allowing the handling of complex optimization tasks (complex shapes and complex shape variations) compared to existing methods;
efficient method to back-propagate the simulation gradient to the parametrization vector is proposed, allowing the use of fast gradient-based methods to optimize the input object.

FIG. 5 illustrates several shape optimizations of chairs to improve their stability obtained with the process of which flowchart is shown on FIG. 1.

As previously said, this implementation may perform other types of optimization. For example, this implementation may perform a drag minimization for cars objects, as discussed for example in reference E. Remelli et. al., “MeshSDF: Differentiable Iso-Surface Extraction”, in Advances in Neural Information Processing Systems, 2020, which is incorporated herein by reference. This implementation may for that use the same settings as previously discussed while replacing the physical simulation module shown in FIG. 2 by that shown in FIG. 6, where:
Extract surface: employs Marching Cubes algorithm that outputs a mesh S from Φ(ν′,G_R); and
Computational Fluid Dynamics simulator that takes as input S and computes the pressure field.

The physical behavior quantity ƒ_aerodynamicfor aerodynamic assessment is similar to the one in previously-cited reference E. Remelli et. al., “MeshSDF: Differentiable Iso-Surface Extraction”, in Advances in Neural Information Processing Systems, 2020:

$Ψ_{O} Φ (v^{'}, G_{R}) = f_{aerodynamic} = \int_{S} \int pndS$

where the integral term approximates drag given the predicted pressure field p and n denotes the projection of surface normals along airflow direction. Here ƒ_opt=0.

The implementation may contemplate other optimization examples, such as the optimization problems illustrated by FIG. 5 in previously-cited reference E. Remelli et. al., “MeshSDF: Differentiable Iso-Surface Extraction”, in Advances in Neural Information Processing Systems, 2020. However, the optimization method does not use a learned surrogate model to imitate the simulation, but rather directly integrates the simulation process. The simulation provided by the optimization method is hence more accurate and does not depend on the learning data (i.e., is generalizable).

Figures illustrating the previously-discussed implementations are now presented.

FIG. 7 illustrates the neural network, where the neural network is a decoding neural network. FIG. 8 illustrates the neural network, where the neural network is an autoencoder.

FIG. 9 illustrates the pipeline of the implementation. FIGS. 10-12 illustrate the simulation layer. FIG. 13 illustrates the sampling layer. FIG. 14 illustrate the forward pass of the sampling layer and FIG. 15 illustrates the backward pass of the sampling layer. FIG. 16 illustrates the latent optimization.

FIG. 17 illustrates various shape optimizations performed with the implementation.

The methods are computer-implemented. This means that steps (or substantially all the steps) of the methods are executed by at least one computer, or any system alike. Thus, steps of the methods are performed by the computer, possibly fully automatically, or, semi-automatically. In examples, the triggering of at least some of the steps of the methods may be performed through user-computer interaction. The level of user-computer interaction required may depend on the level of automatism foreseen and put in balance with the need to implement user's wishes. In examples, this level may be user-defined and/or pre-defined.

A typical example of computer-implementation of a method is to perform the method with a system adapted for this purpose. The system may comprise a processor coupled to a memory and a graphical user interface (GUI), the memory having recorded thereon a computer program comprising instructions for performing the method. The memory may also store a database. The memory is any hardware adapted for such storage, possibly comprising several physical distinct parts (e.g., one for the program, and possibly one for the database).

FIG. 18 shows an example of the system, wherein the system is a client computer system, e.g., a workstation of a user.

The client computer of the example comprises a central processing unit (CPU) 1010 connected to an internal communication BUS 1000, a random access memory (RAM) 1070 also connected to the BUS. The client computer is further provided with a graphical processing unit (GPU) 1110 which is associated with a video random access memory 1100 connected to the BUS. Video RAM 1100 is also known in the art as frame buffer. A mass storage device controller 1020 manages accesses to a mass memory device, such as hard drive 1030. Mass memory devices suitable for tangibly embodying computer program instructions and data include all forms of nonvolatile memory, including by way of example semiconductor memory devices, such as EPROM, EEPROM, and flash memory devices; magnetic disks such as internal hard disks and removable disks; magneto-optical disks; and CD-ROM disks 1040. Any of the foregoing may be supplemented by, or incorporated in, specially designed ASICs (application-specific integrated circuits). A network adapter 1050 manages accesses to a network 1060. The client computer may also include a haptic device 1090 such as cursor control device, a keyboard or the like. A cursor control device is used in the client computer to permit the user to selectively position a cursor at any desired location on display 1080. In addition, the cursor control device allows the user to select various commands, and input control signals. The cursor control device includes a number of signal generation devices for input control signals to system. Typically, a cursor control device may be a mouse, the button of the mouse being used to generate the signals. Alternatively or additionally, the client computer system may comprise a sensitive pad, and/or a sensitive screen.

The computer program may comprise instructions executable by a computer, the instructions comprising means for causing the above system to perform the learning method and/or the optimization method. The program may be recordable on any data storage medium, including the memory of the system. The program may for example be implemented in digital electronic circuitry, or in computer hardware, firmware, software, or in combinations of them. The program may be implemented as an apparatus, for example a product tangibly embodied in a machine-readable storage device for execution by a programmable processor. Method steps may be performed by a programmable processor executing a program of instructions to perform functions of the method by operating on input data and generating output. The processor may thus be programmable and coupled to receive data and instructions from, and to transmit data and instructions to, a data storage system, at least one input device, and at least one output device. The application program may be implemented in a high-level procedural or object-oriented programming language, or in assembly or machine language if desired. In any case, the language may be a compiled or interpreted language. The program may be a full installation program or an update program. Application of the program on the system results in any case in instructions for performing the learning method and/or the optimization method.

DEEP PARAMETERIZATION FOR 3D SHAPE OPTIMIZATION

Information

Publication Number

Date Filed

Date Published

Inventors

Original Assignees

CPC

International Classifications

Abstract

Description

Claims

Priority Claims (1)